Come bloccare un intero su un certo intervallo?

Ho il codice seguente:

new_index = index + offset
if new_index < 0:
    new_index = 0
if new_index >= len(mylist):
    new_index = len(mylist) - 1
return mylist[new_index]

Fondamentalmente, calcolo un nuovo indice e lo uso per trovare qualche elemento da un elenco. Per assicurarmi che l'indice fosse all'interno dei limiti dell'elenco, avevo bisogno di scrivere quelle 2 ifistruzioni distribuite su 4 righe. È piuttosto prolisso, un po 'brutto ... Oserei dire, è abbastanza non pitonico .

C'è qualche altra soluzione più semplice e compatta? (e più pitonico )

Sì, lo so che posso usare if elsein una riga, ma non è leggibile:

new_index = 0 if new_index < 0 else len(mylist) - 1 if new_index >= len(mylist) else new_index

So anche che posso incatenare max()e min()insieme. È più compatto, ma sento che è un po 'oscuro, più difficile da trovare bug se lo digito male. In altre parole, non lo trovo molto semplice.

new_index = max(0, min(new_index, len(mylist)-1))

Questo è abbastanza chiaro, in realtà. Molte persone lo imparano velocemente. Puoi usare un commento per aiutarli.

new_index = max(0, min(new_index, len(mylist)-1))

sorted((minval, value, maxval))[1]

per esempio:

>>> minval=3
>>> maxval=7
>>> for value in range(10):
...   print sorted((minval, value, maxval))[1]
... 
3
3
3
3
4
5
6
7
7
7

molte risposte interessanti qui, tutte quasi uguali, tranne ... quale è più veloce?

import numpy
np_clip = numpy.clip
mm_clip = lambda x, l, u: max(l, min(u, x))
s_clip = lambda x, l, u: sorted((x, l, u))[1]
py_clip = lambda x, l, u: l if x < l else u if x > u else x

>>> import random
>>> rrange = random.randrange
>>> %timeit mm_clip(rrange(100), 10, 90)
1000000 loops, best of 3: 1.02 µs per loop

>>> %timeit s_clip(rrange(100), 10, 90)
1000000 loops, best of 3: 1.21 µs per loop

>>> %timeit np_clip(rrange(100), 10, 90)
100000 loops, best of 3: 6.12 µs per loop

>>> %timeit py_clip(rrange(100), 10, 90)
1000000 loops, best of 3: 783 ns per loop

paxdiablo ce l' ha !, usa il semplice pitone. La versione numpy è, forse non sorprendentemente, la più lenta di tutte. Probabilmente perché sta cercando array, dove le altre versioni ordinano semplicemente i loro argomenti.

Vedi numpy.clip :

index = numpy.clip(index, 0, len(my_list) - 1)

Incatenare max()e min()insieme è l'idioma normale che ho visto. Se trovi difficile leggere, scrivi una funzione di supporto per incapsulare l'operazione:

def clamp(minimum, x, maximum):
    return max(minimum, min(x, maximum))

Che fine ha fatto il mio amato linguaggio leggibile Python? :-)

Seriamente, rendilo una funzione:

def addInRange(val, add, minval, maxval):
    newval = val + add
    if newval < minval: return minval
    if newval > maxval: return maxval
    return newval

quindi chiamalo con qualcosa come:

val = addInRange(val, 7, 0, 42)

O una soluzione più semplice e flessibile in cui esegui il calcolo da solo:

def restrict(val, minval, maxval):
    if val < minval: return minval
    if val > maxval: return maxval
    return val

x = restrict(x+10, 0, 42)

Se lo desideri, potresti persino creare un elenco di min / max in modo che appaia più "matematicamente puro":

x = restrict(val+7, [0, 42])

Questo mi sembra più pitonico:

>>> def clip(val, min_, max_):
...     return min_ if val < min_ else max_ if val > max_ else val

Alcuni test:

>>> clip(5, 2, 7)
5
>>> clip(1, 2, 7)
2
>>> clip(8, 2, 7)
7

Se il tuo codice sembra troppo ingombrante, una funzione potrebbe aiutare:

def clamp(minvalue, value, maxvalue):
    return max(minvalue, min(value, maxvalue))

new_index = clamp(0, new_index, len(mylist)-1)

Evita di scrivere funzioni per attività così piccole, a meno che non le applichi spesso, poiché ingombrerà il tuo codice.

per valori individuali:

min(clamp_max, max(clamp_min, value))

per elenchi di valori:

map(lambda x: min(clamp_max, max(clamp_min, x)), values)