Python: mappage d'intervalles à des valeurs

Question

Je suis en train de refactoriser une fonction qui, étant donné une série de points de terminaison qui définissent implicitement des intervalles, vérifie si un nombre est inclus dans l'intervalle, puis renvoie un correspondant (non lié de manière calculable). Le code qui gère maintenant le travail est:

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 

Ce qui est tout à fait l'OMI horrible, et manque en ce que les intervalles et les valeurs de retour sont hardcoded. Toute utilisation de toute structure de données est bien sûr possible.

Answer 1

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

Answer 2

Essayez quelque chose le long des lignes de:

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

Vous pouvez essayer une prise à ce sujet:

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) 

produit:

0 
1 
2 

Comme toujours en Python, il y aura de meilleures façons de le faire.

Answer 4

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

passer votre extrémités comme une liste endpoints, comme ceci:

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

Edit:

Ce qui précède est une recherche linéaire. La réponse de Glenn Maynard aura de meilleures performances, car elle utilise un algorithme de bissection.

Answer 5

Une autre façon ...

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

Il est en effet tout à fait horrible. Sans obligation d'avoir pas hardcoding, il aurait dû être écrit comme ceci:

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 

Voici des exemples de création d'une fonction de recherche, à la fois linéaire et en utilisant la recherche binaire, avec l'exigence non-hardcodings remplie, et un couple des contrôles de santé mentale sur les deux tables:

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