Python: Mapowanie z przedziałów na wartości

Question

Reorganizuję funkcję, która, biorąc pod uwagę serię punktów końcowych, które domyślnie definiują interwały, sprawdza, czy liczba jest zawarta w przedziale, a następnie zwraca odpowiednią (niezwiązaną w żaden obliczalny sposób). Kod, który jest teraz obsługę prac jest:

if p <= 100: 
    return 0 
elif p > 100 and p <= 300: 
    return 1 
elif p > 300 and p <= 500: 
    return 2 
elif p > 500 and p <= 800: 
    return 3 
elif p > 800 and p <= 1000: 
    return 4 
elif p > 1000: 
    return 5 

Który jest IMO dość straszne, i nie ma tym, że zarówno odstępach i zwracane wartości są ustalony. Jakiekolwiek wykorzystanie dowolnej struktury danych jest oczywiście możliwe.

Answer 1

import bisect 
bisect.bisect_left([100,300,500,800,1000], p) 

Answer 2

spróbować czegoś wzdłuż linii:

d = {(None,100): 0, 
    (100,200): 1, 
    ... 
    (1000, None): 5} 
value = 300 # example value 
for k,v in d.items(): 
    if (k[0] is None or value > k[0]) and (k[1] is None or value <= k[1]): 
     return v 

Answer 3

Można spróbować podjąć to:

def check_mapping(p): 
    mapping = [(100, 0), (300, 1), (500, 2)] # Add all your values and returns here 

    for check, value in mapping: 
     if p <= check: 
      return value 

print check_mapping(12) 
print check_mapping(101) 
print check_mapping(303) 

produkuje:

0 
1 
2 

Jak zawsze w Pythonie, nie będzie lepsze sposoby na zrobienie tego.

Answer 4

def which_interval(endpoints, number): 
    for n, endpoint in enumerate(endpoints): 
     if number <= endpoint: 
      return n 
     previous = endpoint 
    return n + 1 

Przekaż swoje punkty końcowe w postaci listy w endpoints, tak:

which_interval([100, 300, 500, 800, 1000], 5) 

Edit:

Powyższe jest przeszukiwanie liniowe. Odpowiedź Glenna Maynarda będzie lepsza, ponieważ wykorzystuje algorytm bisekcji.

Answer 5

Innym sposobem ...

def which(lst, p): 
    return len([1 for el in lst if p > el]) 

lst = [100, 300, 500, 800, 1000] 
which(lst, 2) 
which(lst, 101) 
which(lst, 1001) 

Answer 6

To jest rzeczywiście dość straszne. Bez wymóg nie mają sztywno, to powinno być napisane tak:

if p <= 100: 
    return 0 
elif p <= 300: 
    return 1 
elif p <= 500: 
    return 2 
elif p <= 800: 
    return 3 
elif p <= 1000: 
    return 4 
else: 
    return 5 

Oto przykłady tworzenia funkcji wyszukiwania, zarówno liniowych i stosując wyszukiwanie binarne, z wymogiem no-hardcodings spełnione, a kilka kontroli poprawności na dwóch stołach:

def make_linear_lookup(keys, values): 
    assert sorted(keys) == keys 
    assert len(values) == len(keys) + 1 
    def f(query): 
     return values[sum(1 for key in keys if query > key)] 
    return f 

import bisect 
def make_bisect_lookup(keys, values): 
    assert sorted(keys) == keys 
    assert len(values) == len(keys) + 1 
    def f(query): 
     return values[bisect.bisect_left(keys, query)] 
    return f