Est-il possible de définir un nombre à NaN ou à l'infini?
Oui, en fait, il existe plusieurs façons. Quelques-uns fonctionnent sans aucune importation, tandis que d'autres nécessitent import
, mais pour cette réponse, je limiterai les bibliothèques de l'aperçu à la bibliothèque standard et à NumPy (qui n'est pas une bibliothèque standard mais une bibliothèque tierce très courante).
Le tableau suivant résume les façons dont on peut créer un infini pas un 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 sur la table:
- Le
float
constructeur est en fait insensible à la casse, vous pouvez donc également utiliser float("NaN")
ou float("InFiNiTy")
.
- Les constantes
cmath
et numpy
renvoient des float
objets Python simples .
- 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 NaN et Infinity complexes 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 une plaine float
, pas un complex
.
existe-t-il une fonction pour vérifier si un nombre est infini ou non?
Oui, il existe - 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 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 quelques remarques:
- Les fonctions
cmath
et numpy
fonctionnent également pour les objets complexes, elles vérifieront si la partie réelle ou imaginaire est NaN ou Infinity.
- Les
numpy
fonctions fonctionnent également pour les numpy
tableaux et tout ce qui peut être converti en un (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 propose deux fonctions supplémentaires à vérifier
NaN
: pandas.isna
et pandas.isnull
(mais pas seulement NaN, il correspond également à 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 flottant):
╒════════════════╤═══════╤════════════╤═════════════╤══════════════════╕
│ 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]
Cependant, si vous souhaitez l'inclure dans un array
(par exemple array.array
ou numpy.array
), le type du tableau doit être float
ou complex
parce que sinon, il essaiera de le convertir en type de tableaux!
>>> 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