py4u blog

Python - Element Index in Range Tuples

In Python, working with tuples that represent ranges (e.g., (start, end) tuples) and finding the index of an element within those ranges is a common task. This blog post will explore different techniques and best practices for achieving this.

2026-07

Table of Contents#

  1. Understanding Range Tuples
  2. Simple Linear Search Approach
  3. Using Binary Search for Sorted Ranges
  4. Best Practices
  5. Example Usage
  6. References

1. Understanding Range Tuples#

A range tuple is typically a tuple of two elements, say (a, b), where a is the start of the range and b is the end (assuming a <= b). For example, (10, 20) represents all the numbers from 10 (inclusive) to 20 (inclusive).

2. Simple Linear Search Approach#

Common Practice#

If you have a list of range tuples and you want to find which range contains a particular element, you can loop through each tuple in the list and check if the element lies within the range.

Code Example#

def find_index_linear(element, range_tuples):
    for index, (start, end) in enumerate(range_tuples):
        if start <= element <= end:
            return index
    return -1  # Element not found in any range
 
range_list = [(1, 5), (6, 10), (11, 15)]
element = 8
print(find_index_linear(element, range_list))

Explanation#

In the find_index_linear function, we use a for loop to iterate over each tuple in range_tuples. For each tuple, we check if the element is within the start and end bounds. If it is, we return the current index. If the loop finishes without finding a match, we return -1 to indicate the element is not in any of the ranges.

3. Using Binary Search for Sorted Ranges#

Common Practice#

If the range tuples are sorted (based on their start values), we can use binary search to improve the efficiency of finding the index. This is useful when dealing with a large number of range tuples.

Code Example#

import bisect
 
def find_index_binary(element, range_tuples):
    starts = [start for start, end in range_tuples]
    index = bisect.bisect_left(starts, element)
    if index < len(range_tuples):
        start, end = range_tuples[index]
        if start <= element <= end:
            return index
    if index > 0:
        start, end = range_tuples[index - 1]
        if start <= element <= end:
            return index - 1
    return -1
 
range_list_sorted = [(1, 5), (6, 10), (11, 15)]
element = 8
print(find_index_binary(element, range_list_sorted))

Explanation#

First, we extract the start values from each range tuple into a separate list starts. Then we use bisect.bisect_left to find the insertion point of the element in the starts list. We then check the tuple at that index (and the previous index if applicable) to see if the element lies within the range.

4. Best Practices#

  • Sorting: If possible, keep your range tuples sorted. This allows you to use more efficient search algorithms like binary search.
  • Error Handling: Always handle the case where the element is not found in any range (returning an appropriate indicator like -1).
  • Documentation: Clearly document the format of the range tuples (e.g., whether they are inclusive or exclusive at the bounds) in your code comments.

5. Example Usage#

Suppose you are building a program to categorize scores. You have ranges like (0, 59) for "F", (60, 69) for "D", (70, 79) for "C", etc. You can use the above functions to quickly find which category (index in the range tuple list) a particular score belongs to.

score_ranges = [(0, 59), (60, 69), (70, 79), (80, 89), (90, 100)]
score = 85
index = find_index_linear(score, score_ranges)
if index!= -1:
    grade = ["F", "D", "C", "B", "A"][index]
    print(f"Score {score} is in grade {grade}")
else:
    print("Invalid score")

6. References#