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?
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
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
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:
float
ne tient pas compte de la casse, vous pouvez donc également utiliser float("NaN")
ou float("InFiNiTy")
.cmath
et numpy
renvoient des objets simples Python float
.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:
cmath
et numpy
fonctionnent également pour des objets complexes. Elles vérifient si la partie réelle ou imaginaire est NaN ou Infinity.numpy
fonctionnent également pour les tableaux numpy
et tout ce qui peut être converti en un seul (comme les listes, les tuples, etc.)numpy.isposinf
_ et _numpy.isneginf
_.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
_
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
.