numeros - minimo valor en una lista python

Python: valores máximos y mínimos utilizables

Question

Python 2.x permite comparar tipos heterogéneos.

Un atajo útil (en Python 2.7 aquí) es que None compara más pequeño que cualquier valor entero o flotante:

>>> None < float(''-inf'') < -sys.maxint * 2l < -sys.maxint
True

Y en Python 2.7 una tupla vacía () es un valor infinito:

>>> () > float(''inf'') > sys.maxint
True

Este método abreviado es útil cuando uno puede ordenar una lista mixta de entradas y flotillas y desea tener un mínimo absoluto y un máximo para hacer referencia.

Sin embargo, este acceso directo se ha eliminado en Python 3000 (esto es Python 3.2):

>>> None < 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: NoneType() < int()

Además, Python3000 ha eliminado sys.maxint en la teoría de que todos los ints promueven los largos y el límite ya no se aplica.

PEP 326 , un caso para los valores superior e inferior, avanzó una referencia min y max en Python. El nuevo comportamiento de pedido documented .

Desde que se rechazó PEP 326, ¿cuáles son las definiciones útiles y utilizables para un valor mínimo y máximo que funcionan con enteros y flotantes y largos en Python 2X y Python 3000?

Editar

Varias respuestas están en la línea de "solo use maxv = float (''inf'')" ... La razón por la que estoy pensando, por remota que sea la posibilidad, es la siguiente:

>>> float(2**5000)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
OverflowError: long int too large to convert to float 

Y:

>>> cmp(1.0**4999,10.0**5000)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
OverflowError: (34, ''Result too large'')

Todavía:

>>> () > 2**5000
True

Para que cmp alcance un valor flotante, float(''inf'') , el valor largo tendría que convertirse en un valor flotante y la conversión causaría un OverflowError ...

Conclusión

Gracias a todos por sus respuestas y comentarios. Escogí la answer de TryPyPy porque parecía más en línea con lo que estaba preguntando: un valor absoluto más grande y más absoluto como se describe en la entrada de Wikipedia en el infinito.

Con esta pregunta, aprendí que un valor largo o int no se convierte a un valor flotante para completar la comparación de float(''inf'') > 2**5000 . No sabía eso.

Answer 1

En cPython, el cmp no realiza una conversión a flotar implícitamente. Es decir, esto funciona:

>>> float(''inf'') > 2**5000
True

Mientras esto realiza explícitamente la conversión dread:

>>> float(''inf'') > float(2**5000)
Overflow...

La respuesta correcta , IMHO, no es un valor per se por un cambio en la lógica:

def func_with_min():
   minval=None
   for loop in list_with_mins:
      if minval is None or minval<minseen:
          # do that min thing you wanna do...

Si quieres tener un valor , float(''-inf'') para min y float(''inf'') es bastante seguro. Asegúrese de guardar en caché que fuera de un bucle sin embargo:

def func():
   minval=float(''-inf'')
   for loop in now_you_can_loop:
       # otherwise float(''-inf'') is kinda slow

Answer 2

Para comparaciones numéricas, +- float("inf") debería funcionar.

EDIT: No siempre funciona (pero cubre los casos realistas):

print(list(sorted([float("nan"), float("inf"), float("-inf"), float("nan"), float("nan")])))
# NaNs sort above and below +-Inf
# However, sorting a container with NaNs makes little sense, so not a real issue.

Para tener objetos que se comparan como superiores o inferiores a cualquier otro objeto arbitrario (incluida inf , pero excluyendo a otros tramposos como los que aparecen a continuación), puede crear clases que establezcan su máximo / mínimo en sus métodos especiales para comparaciones:

class _max:
    def __lt__(self, other): return False
    def __gt__(self, other): return True

class _min:
    def __lt__(self, other): return True
    def __gt__(self, other): return False

MAX, MIN = _max(), _min()

print(list(sorted([float("nan"), MAX, float(''inf''), MIN, float(''-inf''), 0,float("nan")])))
# [<__main__._min object at 0xb756298c>, nan, -inf, 0, inf, nan, <__main__._max object at 0xb756296c>]

Por supuesto, se necesita más esfuerzo para cubrir las variantes ''o iguales''. Y no solucionará el problema general de no poder ordenar una lista que contenga None e int , pero eso también debería ser posible con un poco de envoltura y / o decorar-ordenar-ordenar-decorar-decapar (por ejemplo, clasificar una lista de tuplas de (typename, value) ).

Answer 3

Ya tienes las opciones más obvias en tu pregunta: float(''-inf'') y float(''inf'') .

Además, tenga en cuenta que None es menos que todo y que la tupla vacía es más alta que todo en Py2, y, por ejemplo, Jython y PyPy tienen todo el derecho de usar un orden diferente si así lo desean. Todo lo que se garantiza es la coherencia dentro de una copia en ejecución del intérprete; el orden real es arbitrario.