¿Es posible establecer un número en NaN o infinito?

5 minutos de lectura

avatar de usuario
Beto

¿Es posible establecer un elemento de una matriz para NaN en Python?

Además, ¿es posible establecer una variable en +/- infinito? Si es así, ¿hay alguna función para verificar si un número es infinito o no?

  • stackoverflow.com/questions/944700 le indica cómo verificar NaN. Para Inf y -Inf puede probar con == pero eso no funciona para NaN debido a las reglas IEEE754 para NaN.

    –David Heffernan

    25 de marzo de 2011 a las 22:27


Emitir desde una cadena usando float():

>>> float('NaN')
nan
>>> float('Inf')
inf
>>> -float('Inf')
-inf
>>> float('Inf') == float('Inf')
True
>>> float('Inf') == 1
False

  • ¡Eso me enseñará a no saltar con una broma antes de leer la pregunta por segunda vez! ¡Lo siento! Dicho esto, no estaría de más decirlo de todos modos porque es una trampa en la que es fácil caer, NaN != NaN

    –David Heffernan

    25 de marzo de 2011 a las 22:30


  • también nota: >>> float(‘Inf’)-float(‘Inf’) ===> nan

    – NTG

    02/09/2014 a las 16:04


  • Nota:float('Inf')*0 y float('Inf')/float('Inf') ==> nan. y también float('Inf')*-1 ==> -inf

    – matan h

    10 de diciembre de 2020 a las 13:44


Sí, puedes usar numpy para eso.

import numpy as np
a = arange(3,dtype=float)

a[0] = np.nan
a[1] = np.inf
a[2] = -np.inf

a # is now [nan,inf,-inf]

np.isnan(a[0]) # True
np.isinf(a[1]) # True
np.isinf(a[2]) # True

  • En python> = 2.6, solo puede usar math.isnan() y math.isinf()

    – Hace

    9 de mayo de 2011 a las 10:21

  • numpy es una importación bastante pesada si todo lo que quieres es NaN o inf

    – cz

    3 abr 2018 a las 16:10

  • Si todo lo que necesitas es NaN o Infuno podria from numpy import nan, inf que ha existido desde que se planteó esta cuestión.

    – andrewgu

    27 de febrero de 2019 a las 0:01

avatar de usuario
MSeifert

¿Es posible establecer un número en NaN o infinito?

Sí, de hecho hay varias formas. Algunos funcionan sin importaciones, mientras que otros requieren importsin embargo, para esta respuesta limitaré las bibliotecas en la descripción general a la biblioteca estándar y NumPy (que no es una biblioteca estándar sino una biblioteca de terceros muy común).

La siguiente tabla resume las formas en que se puede crear un no-número o un infinito positivo o negativo float:

╒══════════╤══════════════╤════════════════════╤════════════════════╕
│   result │ NaN          │ Infinity           │ -Infinity          │
│ module   │              │                    │                    │
╞══════════╪══════════════╪════════════════════╪════════════════════╡
│ built-in │ float("nan") │ float("inf")       │ -float("inf")      │
│          │              │ float("infinity")  │ -float("infinity") │
│          │              │ float("+inf")      │ float("-inf")      │
│          │              │ float("+infinity") │ float("-infinity") │
├──────────┼──────────────┼────────────────────┼────────────────────┤
│ math     │ math.nan     │ math.inf           │ -math.inf          │
├──────────┼──────────────┼────────────────────┼────────────────────┤
│ cmath    │ cmath.nan    │ cmath.inf          │ -cmath.inf         │
├──────────┼──────────────┼────────────────────┼────────────────────┤
│ numpy    │ numpy.nan    │ numpy.PINF         │ numpy.NINF         │
│          │ numpy.NaN    │ numpy.inf          │ -numpy.inf         │
│          │ numpy.NAN    │ numpy.infty        │ -numpy.infty       │
│          │              │ numpy.Inf          │ -numpy.Inf         │
│          │              │ numpy.Infinity     │ -numpy.Infinity    │
╘══════════╧══════════════╧════════════════════╧════════════════════╛

Un par de comentarios a la mesa:

  • los float constructor no distingue entre mayúsculas y minúsculas, por lo que también puede usar float("NaN") o float("InFiNiTy").
  • los cmath y numpy las constantes devuelven Python simple float objetos.
  • los numpy.NINF es en realidad la única constante que conozco que no requiere el -.
  • Es posible crear complejos NaN e Infinity con complex y cmath:

    ╒══════════╤════════════════╤═════════════════╤═════════════════════╤══════════════════════╕
    │   result │ NaN+0j         │ 0+NaNj          │ Inf+0j              │ 0+Infj               │
    │ module   │                │                 │                     │                      │
    ╞══════════╪════════════════╪═════════════════╪═════════════════════╪══════════════════════╡
    │ built-in │ complex("nan") │ complex("nanj") │ complex("inf")      │ complex("infj")      │
    │          │                │                 │ complex("infinity") │ complex("infinityj") │
    ├──────────┼────────────────┼─────────────────┼─────────────────────┼──────────────────────┤
    │ cmath    │ cmath.nan ¹    │ cmath.nanj      │ cmath.inf ¹         │ cmath.infj           │
    ╘══════════╧════════════════╧═════════════════╧═════════════════════╧══════════════════════╛
    

    Las opciones con ¹ devuelven un plano floatNo un complex.

¿Hay alguna función para verificar si un número es infinito o no?

Sí, hay, de hecho, hay varias funciones para NaN, Infinity y ni Nan ni Inf. Sin embargo, estas funciones predefinidas no están integradas, siempre requieren un import:

╒══════════╤═════════════╤════════════════╤════════════════════╕
│      for │ NaN         │ Infinity or    │ not NaN and        │
│          │             │ -Infinity      │ not Infinity and   │
│ module   │             │                │ not -Infinity      │
╞══════════╪═════════════╪════════════════╪════════════════════╡
│ math     │ math.isnan  │ math.isinf     │ math.isfinite      │
├──────────┼─────────────┼────────────────┼────────────────────┤
│ cmath    │ cmath.isnan │ cmath.isinf    │ cmath.isfinite     │
├──────────┼─────────────┼────────────────┼────────────────────┤
│ numpy    │ numpy.isnan │ numpy.isinf    │ numpy.isfinite     │
╘══════════╧═════════════╧════════════════╧════════════════════╛

De nuevo un par de observaciones:

  • los cmath y numpy Las funciones también funcionan para objetos complejos, verificarán si la parte real o imaginaria es NaN o Infinity.
  • los numpy Las funciones también funcionan para numpy arreglos y todo lo que se puede convertir en uno (como listas, tuplas, etc.)
  • También hay funciones que verifican explícitamente el infinito positivo y negativo en NumPy: numpy.isposinf y numpy.isneginf.
  • Pandas ofrece dos funciones adicionales para verificar NaN: pandas.isna y pandas.isnull (pero no solo NaN, también coincide None y NaT)
  • Aunque no hay funciones integradas, sería fácil crearlas usted mismo (descuidé la verificación de tipos y la documentación aquí):

    def isnan(value):
        return value != value  # NaN is not equal to anything, not even itself
    
    infinity = float("infinity")
    
    def isinf(value):
        return abs(value) == infinity 
    
    def isfinite(value):
        return not (isnan(value) or isinf(value))
    

Para resumir los resultados esperados para estas funciones (asumiendo que la entrada es un flotante):

╒════════════════╤═══════╤════════════╤═════════════╤══════════════════╕
│          input │ NaN   │ Infinity   │ -Infinity   │ something else   │
│ function       │       │            │             │                  │
╞════════════════╪═══════╪════════════╪═════════════╪══════════════════╡
│ isnan          │ True  │ False      │ False       │ False            │
├────────────────┼───────┼────────────┼─────────────┼──────────────────┤
│ isinf          │ False │ True       │ True        │ False            │
├────────────────┼───────┼────────────┼─────────────┼──────────────────┤
│ isfinite       │ False │ False      │ False       │ True             │
╘════════════════╧═══════╧════════════╧═════════════╧══════════════════╛

¿Es posible establecer un elemento de una matriz en NaN en Python?

En una lista no hay problema, siempre puedes incluir NaN (o Infinity) allí:

>>> [math.nan, math.inf, -math.inf, 1]  # python list
[nan, inf, -inf, 1]

Sin embargo, si desea incluirlo en un array (por ejemplo array.array o numpy.array) entonces el tipo de la matriz deber ser float o complex ¡porque de lo contrario intentará reducirlo al tipo de matrices!

>>> import numpy as np
>>> float_numpy_array = np.array([0., 0., 0.], dtype=float)
>>> float_numpy_array[0] = float("nan")
>>> float_numpy_array
array([nan,  0.,  0.])

>>> import array
>>> float_array = array.array('d', [0, 0, 0])
>>> float_array[0] = float("nan")
>>> float_array
array('d', [nan, 0.0, 0.0])

>>> integer_numpy_array = np.array([0, 0, 0], dtype=int)
>>> integer_numpy_array[0] = float("nan")
ValueError: cannot convert float NaN to integer

  • Nota: math.isnan no funciona con números complejos. Usar math.isnan(x.real) or math.isnan(x.imag) en cambio.

    – Jonathan H.

    5 de abril de 2018 a las 10:57

Cuando use Python 2.4, intente

inf = float("9e999")
nan = inf - inf

Me enfrento al problema cuando estaba transfiriendo el simplejson a un dispositivo integrado que ejecuta Python 2.4, float("9e999") arreglado. no usar inf = 9e999necesitas convertirlo de cadena.
-inf da el -Infinity.

O puedes calcularlos

Python 3.9 on Windows 10
>>> import sys
>>> Inf = sys.float_info.max * 10
>>> Inf
inf
>>> NaN = Inf - Inf
>>> NaN
nan

¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad