web-dev-qa-db-fra.com

Est-il possible de définir un nombre sur NaN ou l'infini?

Est-il possible de définir un élément d'un tableau sur NaN en Python?

De plus, est-il possible de définir une variable sur +/- infini? Si tel est le cas, existe-t-il une fonction permettant de vérifier si un nombre est infini ou non?

pythonnumericnaninfinite
178
Bob

Cast de la chaîne en utilisant float():

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

Oui, vous pouvez utiliser numpy pour cela.

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
72
Olivier Verdier

Est-il possible de définir un nombre sur NaN ou l'infini?

Oui, en fait, il y a plusieurs façons. Quelques-uns travaillent sans aucune importation, tandis que d'autres nécessitent import, cependant, pour cette réponse, je limiterai les bibliothèques de la vue d'ensemble à standard-library et NumPy (qui n'est pas une bibliothèque standard, mais un tiers très courant. bibliothèque).

Le tableau suivant résume les différentes manières de créer un non-nombre ou un infini positif ou négatif 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    │
╘══════════╧══════════════╧════════════════════╧════════════════════╛
_

Quelques remarques à la table:

  • Le constructeur float ne tient pas compte de la casse, vous pouvez donc également utiliser float("NaN") ou float("InFiNiTy").
  • Les constantes cmath et numpy renvoient des objets simples Python float.
  • Le _numpy.NINF_ est en fait la seule constante que je connaisse qui ne nécessite pas le _-_.

  • Il est possible de créer des complexes NaN et Infinity avec complex et 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           │
╘══════════╧════════════════╧═════════════════╧═════════════════════╧══════════════════════╛
_

    Les options avec ¹ renvoient un float, et non un complex.

existe-t-il une fonction permettant de vérifier si un nombre est infini ou non?

Oui, en fait, il existe plusieurs fonctions pour NaN, Infinity et ni Nan ni Inf. Cependant, ces fonctions prédéfinies ne sont pas intégrées, elles nécessitent toujours 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     │
╘══════════╧═════════════╧════════════════╧════════════════════╛
_

Encore une ou deux remarques:

  • Les fonctions cmath et numpy fonctionnent également pour des objets complexes. Elles vérifient si la partie réelle ou imaginaire est NaN ou Infinity.
  • Les fonctions numpy fonctionnent également pour les tableaux numpy et tout ce qui peut être converti en un seul (comme les listes, les tuples, etc.)
  • Il existe également des fonctions qui vérifient explicitement l'infini positif et négatif dans NumPy: _numpy.isposinf_ et _numpy.isneginf_.
  • Pandas offre deux fonctions supplémentaires pour vérifier NaN: pandas.isna et pandas.isnull (mais pas seulement NaN, cela correspond aussi à None et NaT)

  • Même s'il n'y a pas de fonctions intégrées, il serait facile de les créer vous-même (j'ai négligé la vérification de type et la documentation ici):

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

Pour résumer les résultats attendus pour ces fonctions (en supposant que l'entrée est un float):

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

Est-il possible de définir un élément d'un tableau sur NaN en Python?

Dans une liste ce n'est pas un problème, vous pouvez toujours y inclure NaN (ou Infinity):

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

Toutefois, si vous souhaitez l'inclure dans un array (par exemple _array.array_ ou _numpy.array_), le type du tableau doit être soit float ou complex car sinon, il essaiera de le réduire au type de tableau!

_>>> 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
_
29
MSeifert

Lorsque vous utilisez Python 2.4, essayez

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

Je suis confronté au problème lorsque je portais le simplejson sur un périphérique intégré qui fonctionnait sous Python 2.4, float("9e999"). N'utilisez pas inf = 9e999, vous devez le convertir à partir de chaîne. -inf donne le -Infinity.

2
user6458202