Python: mappatura da intervalli a valori

Question

Sto refactoring una funzione che, data una serie di endpoint che definiscono implicitamente gli intervalli, controlla se un numero è incluso nell'intervallo e quindi restituisce un corrispondente (non correlato in alcun modo calcolabile). Il codice che ora gestisce il lavoro è:

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 

Che è IMO abbastanza orribile, e manca in quanto entrambi gli intervalli ed i valori di ritorno sono hardcoded. Qualsiasi utilizzo di qualsiasi struttura dati è ovviamente possibile.

Answer 1

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

Answer 2

provare qualcosa sulla falsariga di:

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

Si potrebbe provare un prendere su questo:

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) 

produce:

0 
1 
2 

Come sempre in Python, non ci sarà qualche modo migliore per farlo.

Answer 4

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

passare il vostro endpoint come un elenco in endpoints, in questo modo:

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

Edit:

Quanto sopra è una ricerca lineare. La risposta di Glenn Maynard avrà prestazioni migliori, poiché utilizza un algoritmo di bisezione.

Answer 5

Un altro modo ...

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

E 'infatti abbastanza orribile. Senza l'obbligo di non hanno hardcoding, essa avrebbe dovuto essere scritta così:

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 

Ecco alcuni esempi di creazione di una funzione di ricerca, sia lineari che usando la ricerca binaria, con l'obbligo di non-hardcodings soddisfatte, e un paio di controlli di sanità sulle due tabelle:

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