Ist es möglich, eine Zahl auf NaN oder unendlich zu setzen?

Ist es möglich, ein Element eines Arrays zu setzen NaN in Python?

Ist es außerdem möglich, eine Variable auf +/- unendlich zu setzen? Wenn ja, gibt es eine Funktion, um zu überprüfen, ob eine Zahl unendlich ist oder nicht?

Cast aus Schnur mit float():

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

Ja, können Sie verwenden numpy dafür.

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

Ist es möglich, eine Zahl auf NaN oder unendlich zu setzen?

Ja, tatsächlich gibt es mehrere Möglichkeiten. Einige funktionieren ohne Importe, während andere dies erfordern importaber für diese Antwort beschränke ich die Bibliotheken in der Übersicht auf Standardbibliothek und NumPy (was keine Standardbibliothek, sondern eine sehr verbreitete Bibliothek von Drittanbietern ist).

Die folgende Tabelle fasst die Möglichkeiten 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 Anmerkungen zur Tabelle:

• Das float Der Konstruktor unterscheidet tatsächlich nicht zwischen Groß- und Kleinschreibung, sodass Sie auch verwenden können float("NaN") oder float("InFiNiTy").
• Das cmath und numpy Konstanten geben einfaches Python zurück float Objekte.
• Das numpy.NINF ist eigentlich die einzige mir bekannte Konstante, die das nicht benötigt -.

• Es ist möglich, komplexe NaN und Infinity mit zu erstellen complex und 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 floatkein complex.

Gibt es eine Funktion, um zu überprüfen, ob eine Zahl unendlich ist oder nicht?

Ja, das gibt es – 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 eine 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     │
╘══════════╧═════════════╧════════════════╧════════════════════╛

Nochmal ein paar Anmerkungen:

• Das cmath und numpy Funktionen funktionieren auch für komplexe Objekte, sie prüfen, ob entweder der Real- oder der Imaginärteil NaN oder Infinity ist.
• Das numpy Funktionen funktionieren auch für numpy Arrays und alles, was in eins konvertiert werden kann (wie Listen, Tupel usw.)
• Es gibt auch Funktionen, die in NumPy explizit auf positive und negative Unendlichkeit prüfen: numpy.isposinf und numpy.isneginf.
• Pandas bietet zwei zusätzliche Funktionen zur Überprüfung an NaN: pandas.isna und pandas.isnull (aber nicht nur NaN, es passt auch None und NaT)

• Auch wenn es keine eingebauten Funktionen gibt, wäre es einfach, sie selbst zu erstellen (ich habe hier 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 (unter der Annahme, dass die Eingabe ein Float ist):

╒════════════════╤═══════╤════════════╤═════════════╤══════════════════╕
│          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 eine aufnehmen möchten array (zum Beispiel array.array oder numpy.array) dann den Typ des Arrays muss sein float oder complex weil es sonst versuchen wird, es auf den Arrays-Typ umzuwandeln!

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

Wenn Sie Python 2.4 verwenden, versuchen Sie es

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

Ich stehe vor dem Problem, als ich den Simplejson auf ein eingebettetes Gerät portierte, auf dem Python 2.4 ausgeführt wird. float("9e999") behoben. Nicht verwenden inf = 9e999müssen Sie es aus einer Zeichenfolge konvertieren.
-inf gibt die -Infinity.

Oder Sie können sie berechnen

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