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

Ist es möglich, ein Element eines Arrays NaNin Python festzulegen?

Ist es zusätzlich möglich, eine Variable auf +/- unendlich zu setzen? Wenn ja, gibt es eine Funktion, mit der überprüft werden kann, ob eine Zahl unendlich ist oder nicht?

Cast aus String mit float():

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

Ja, das können Sie verwenden numpy.

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

Versuchen Sie es mit Python 2.4

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

Ich habe das Problem, als ich den simplejson auf ein eingebettetes Gerät portierte, auf dem Python 2.4 ausgeführt wurde, und das Problem float("9e999")behoben wurde. Nicht verwenden inf = 9e999, Sie müssen es aus einem String konvertieren. -infgibt die -Infinity.