How Does Python 3's `range()` Object Achieve Fast Containment Checks?

Fast Containment Checks in Python 3 range() Object

The range() function in Python 3 may seem computationally intensive, as it appears to check for membership in a vast range. However, it operates in an optimized manner that belies this expectation.

Under the hood, range() employs a smart sequence object that avoids precomputing its entire contents. Instead, it stores the start, stop, and step values and calculates numbers on demand during iteration.

Crucially, the range() object implements the contains hook to calculate membership efficiently without scanning its potential values. This near-constant time operation avoids the need to iterate through every integer in the range.

To illustrate, consider a custom range implementation:

class my_range:
    # Constructor with start, stop, and step values
    def __init__(self, start, stop, step):
        self.start = start
        self.stop = stop
        self.step = step

    # Generator for iterating through the range
    def __iter__(self):
        current = self.start
        if self.step  self.stop:
                yield current
                current += self.step
        else:
            while current <p>This custom implementation lacks several features of the Python range() object, demonstrating the optimized nature of the latter. The range() object efficiently manages memory and performs containment checks without substantial computational overhead, making it a robust and fast tool for working with ranges.</p>

The above is the detailed content of How Does Python 3's `range()` Object Achieve Fast Containment Checks?. For more information, please follow other related articles on the PHP Chinese website!