如何检查数字是否在一组非连续范围内？

Question

Question may sound complicated, but actually is pretty simple, but i can't find any nice solution in Python.

I have ranges like ("8X5000", "8X5099") . Here X can be any digit, so I want to match numbers that fall into one of the ranges ( 805000..805099 or 815000..815099 or ... 895000..895099 ).

How can I do this?

Answer 1

@TimPietzcker answer is correct and Pythonic, but it raises some performance concerns (arguably making it even more Pythonic). It creates an iterator that is searches for a value. I don't expect Python to be able to optimize the search.

This should perform better:

def IsInRange(n, r=("8X5000", "8X5099")):
    (minr, maxr) = [[int(i) for i in l.split('X')] for l in r]
    p = len(r[0]) - r[0].find('X')

    nl = (n // 10**p, n % 10**(p-1))
    fInRange = all([minr[i] <= nl[i] <= maxr[i] for i in range(2)])
    return fInRange

The second line inside the function is a nested list comprehension so may be a little hard to read but it sets:

minr = [8, 5000]
maxr = [8, 5099]

When n = 595049:

nl = (5, 5049)

The code just splits the ranges into parts (while converting to int), splits the target number into parts, then range checks the parts. It wouldn't be hard to enhance this to handle multiple X's in the range specifiers.

Update

I just tested relative performance using timeit:

def main():
    t1 = timeit.timeit('MultiRange.in_range(985000)', setup='import MultiRange', number=10000)
    t2 = timeit.timeit('MultiRange.IsInRange(985000)', setup='import MultiRange', number=10000)

    print t1, t2
    print float(t2)/float(t1), 1 - float(t2)/float(t1)        

On my 32-bit Win 7 machine running Python 2.7.2 my solution is almost 10 times faster than @TimPietzcker's (to be specific, it runs in 12% of the time). As you increase the size of the range, it only gets worse. When:

ranges=("8X5000", "8X5999")

The performance boost is 50x. Even for the smallest range, my version runs 4 times faster.

With @PaulMcGuire suggested performance patch to in_range , my version runs 3 times faster.

Update 2

Motivated by @PaulMcGuire's comment I went ahead and refactored our functions into classes. Here's mine:

class IsInRange5(object):
    def __init__(self, r=("8X5000", "8X5099")):
        ((self.minr0, self.minr1), (self.maxr0, self.maxr1)) = [[int(i) for i in l.split('X')] for l in r]
        pos = len(r[0]) - r[0].find('X')
        self.basel = 10**(pos-1)
        self.baseh = self.basel*10
        self.ir = range(2)

    def __contains__(self, n):
        return self.minr0 <= n // self.baseh <= self.maxr0 and \
            self.minr1 <= n % self.basel <= self.maxr1

This did close the gap, but even after pre-computing range invariants (for both) @PaulMcGuire's took 50% longer.

Answer 2

range = (80555,80888)

x = 80666

print range[0] < x < range[1]

maybe what your looking for ...

Answer 3

Example for Python 3 (in Python 2, use xrange instead of range ):

def in_range(number, ranges=("8X5000", "8X5099")):
    actual_ranges = ((int(ranges[0].replace("X", digit)),
                     int(ranges[1].replace("X", digit)) + 1)
                     for digit in "0123456789")
    return any(number in range(*interval) for interval in actual_ranges)

Results:

>>> in_range(805001)
True
>>> in_range(895099)
True
>>> in_range(805100)
False

An improvement to this, suggested by Paul McGuire (thanks!):

def in_range(number, ranges=("8X5000", "8X5099")):
    actual_ranges = ((int(ranges[0].replace("X", digit)),
                     int(ranges[1].replace("X", digit)))
                     for digit in "0123456789")
    return any(minval <= number <= maxval for minval, maxval in actual_ranges)