Python – Check Element for Range Occurrences

In Python, checking if an element exists within a specific range of values is a common programming task. This can be accomplished using various approaches, from simple iteration to more advanced search algorithms.

What is Range Occurrence Checking?

Range occurrence checking involves determining whether a specific element exists within a collection of values (like a dictionary, list, or range). The "range" here refers to a bounded set of elements with defined start and end points.

Method 1: Using Flag-Based Iteration

This approach uses a boolean flag to track whether the target element is found during iteration ?

# Dictionary with item names and quantities
inventory = {'pencil': 10, 'pen': 20, 'book': 30}

# Element to search for
target_quantity = 20
found = False

# Iterate through dictionary values
for item_name, quantity in inventory.items():
    if quantity == target_quantity:
        found = True
        print(f"Found {item_name} with quantity {quantity}")
        break

if not found:
    print("Element not found in the range")

Found pen with quantity 20

Method 2: Using enumerate() Method

The enumerate() function provides both index and value during iteration, useful for tracking position ?

# Dictionary with items and their values
inventory = {'pencil': 10, 'pen': 20, 'book': 30}
target_value = 30

# Use enumerate to get index and value
for index, value in enumerate(inventory.values()):
    if value == target_value:
        print(f"Element found at position {index} with value {value}")
        break
else:
    print("Element not found in the range")

Element found at position 2 with value 30

Method 3: Using Binary Search

Binary search is efficient for sorted data, with O(log n) time complexity ?

# Dictionary with sorted values
inventory = {'pencil': 10, 'pen': 20, 'book': 30}
target = 20

def binary_search(arr, left, right, target):
    if right >= left:
        mid = (left + right) // 2
        
        if arr[mid] == target:
            return mid
        elif arr[mid] > target:
            return binary_search(arr, left, mid - 1, target)
        else:
            return binary_search(arr, mid + 1, right, target)
    return -1

# Convert dictionary values to sorted list
values = sorted(inventory.values())
result = binary_search(values, 0, len(values) - 1, target)

if result != -1:
    print(f"Element {target} found at index {result}")
else:
    print("Element not found")

Element 20 found at index 1

Method 4: Using Python's 'in' Operator

The simplest approach using Python's built-in membership testing ?

# Dictionary with items
inventory = {'pencil': 10, 'pen': 20, 'book': 30}
target = 25

# Check if target exists in values
if target in inventory.values():
    print(f"Value {target} exists in inventory")
else:
    print(f"Value {target} not found in inventory")

# Check within a specific range
price_range = range(15, 35)
matching_items = [item for item, price in inventory.items() if price in price_range]
print(f"Items in price range 15-35: {matching_items}")

Value 25 not found in inventory
Items in price range 15-35: ['pen', 'book']

Comparison of Methods

Conclusion

Use the in operator for simple existence checks, binary search for sorted large datasets, and iteration methods when you need additional processing during the search. Choose the method based on your data structure and performance requirements.