Ist es möglich, eine Zahl auf NaN oder unendlich zu setzen?
Ja, tatsächlich gibt es mehrere Möglichkeiten. Einige funktionieren ohne Import, während andere dies erfordern import. Für diese Antwort beschränke ich die Bibliotheken in der Übersicht jedoch auf Standardbibliothek und NumPy (keine Standardbibliothek, sondern eine sehr verbreitete Bibliothek von Drittanbietern).
Die folgende Tabelle fasst zusammen, wie man eine Nicht-Zahl oder eine positive oder negative Unendlichkeit erzeugen kann 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 │
╘══════════╧══════════════╧════════════════════╧════════════════════╛
Ein paar Bemerkungen zur Tabelle:
- Der
floatKonstruktor unterscheidet nicht zwischen Groß- und Kleinschreibung, sodass Sie auch float("NaN")oder verwenden können float("InFiNiTy").
- Die Konstanten
cmathund numpygeben einfache Python- floatObjekte zurück.
- Das
numpy.NINFist eigentlich die einzige Konstante, von der ich weiß, dass sie das nicht erfordert -.
Es ist möglich, komplexes NaN und Unendlichkeit mit complexund zu erzeugen 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 │
╘══════════╧════════════════╧═════════════════╧═════════════════════╧══════════════════════╛
Die Optionen mit ¹ geben eine Ebene zurück float, nicht a complex.
Gibt es eine Funktion, um zu überprüfen, ob eine Zahl unendlich ist oder nicht?
Ja, tatsächlich gibt es mehrere Funktionen für NaN, Infinity und weder Nan noch Inf. Diese vordefinierten Funktionen sind jedoch nicht integriert. Sie erfordern immer Folgendes 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 │
╘══════════╧═════════════╧════════════════╧════════════════════╛
Nochmals ein paar Bemerkungen:
- Die Funktionen
cmathund numpyfunktionieren auch für komplexe Objekte. Sie prüfen, ob der Real- oder Imaginärteil NaN oder Infinity ist.
- Die
numpyFunktionen funktionieren auch für numpyArrays und alles, was in eines konvertiert werden kann (wie Listen, Tupel usw.).
- Es gibt auch Funktionen, die in NumPy explizit nach positiver und negativer Unendlichkeit suchen:
numpy.isposinfund numpy.isneginf.
- Pandas bietet zwei zusätzliche Funktionen, nach denen gesucht werden muss
NaN: pandas.isnaund pandas.isnull(aber nicht nur NaN, es stimmt auch mit Noneund NaT)
Obwohl es keine eingebauten Funktionen gibt, wäre es einfach, sie selbst zu erstellen (ich habe hier die Typprüfung und Dokumentation vernachlässigt):
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))
Um die erwarteten Ergebnisse für diese Funktionen zusammenzufassen (vorausgesetzt, die Eingabe ist ein Float):
╒════════════════╤═══════╤════════════╤═════════════╤══════════════════╕
│ input │ NaN │ Infinity │ -Infinity │ something else │
│ function │ │ │ │ │
╞════════════════╪═══════╪════════════╪═════════════╪══════════════════╡
│ isnan │ True │ False │ False │ False │
├────────────────┼───────┼────────────┼─────────────┼──────────────────┤
│ isinf │ False │ True │ True │ False │
├────────────────┼───────┼────────────┼─────────────┼──────────────────┤
│ isfinite │ False │ False │ False │ True │
╘════════════════╧═══════╧════════════╧═════════════╧══════════════════╛
Ist es möglich, ein Element eines Arrays in Python auf NaN zu setzen?
In einer Liste ist es kein Problem, Sie können dort immer NaN (oder Infinity) einfügen:
>>> [math.nan, math.inf, -math.inf, 1] # python list
[nan, inf, -inf, 1]
Wenn Sie es jedoch in ein array(zum Beispiel array.arrayoder numpy.array) aufnehmen möchten, muss der Typ des Arrays sein floatoder complexweil es sonst versucht, es auf den Array-Typ herunterzuspielen!
>>> 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