¿Cómo sujetar un número entero a algún rango?

Tengo el siguiente código:

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]

Básicamente, calculo un nuevo índice y lo uso para encontrar algún elemento de una lista. Para asegurarme de que el índice esté dentro de los límites de la lista, necesitaba escribir esas 2 ifdeclaraciones distribuidas en 4 líneas. Eso es bastante detallado, un poco feo ... Me atrevo a decir que es bastante poco pitónico .

¿Existe alguna otra solución más sencilla y compacta? (y más pitónico )

Sí, sé que puedo usar if elseen una línea, pero no se puede leer:

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

También sé que puedo encadenar max()y min()juntar. Es más compacto, pero siento que es un poco oscuro, más difícil de encontrar errores si lo escribo mal. En otras palabras, no lo encuentro muy sencillo.

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

En realidad, esto es bastante claro. Mucha gente lo aprende rápidamente. Puede utilizar un comentario para ayudarlos.

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

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

por ejemplo:

>>> 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

muchas respuestas interesantes aquí, todas casi iguales, excepto ... ¿cuál es más rápida?

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 lo tiene !, usa python simple. La versión numpy es, quizás no sorprendentemente, la más lenta de todas. Probablemente porque está buscando matrices, donde las otras versiones simplemente ordenan sus argumentos.

Ver numpy.clip :

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

Encadenar max()y min()juntar es el idioma normal que he visto. Si le resulta difícil de leer, escriba una función auxiliar para encapsular la operación:

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

¿Qué pasó con mi amado lenguaje Python legible? :-)

En serio, solo hazlo una función:

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

luego simplemente llámalo con algo como:

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

O una solución más simple y flexible en la que usted mismo hace el cálculo:

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

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

Si quisiera, incluso podría hacer que el mínimo / máximo sea una lista para que se vea más "matemáticamente puro":

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

Este me parece más pitónico:

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

Algunas pruebas:

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

Si su código parece demasiado difícil de manejar, una función podría ayudar:

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

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

Evite escribir funciones para tareas tan pequeñas, a menos que las aplique con frecuencia, ya que saturará su código.

para valores individuales:

min(clamp_max, max(clamp_min, value))

para listas de valores:

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