wake-up-neo.net

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

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

Ist es außerdem 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?

178
Bob

Cast von String mit float():

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

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

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
72
Olivier Verdier

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

Ja, in der Tat gibt es mehrere Möglichkeiten. Einige funktionieren ohne Import, andere erfordern import. Für diese Antwort beschränke ich die Bibliotheken in der Übersicht jedoch auf Standardbibliothek und NumPy (die keine Standardbibliothek, sondern eine sehr verbreitete Drittbibliothek ist). Partybibliothek).

In der folgenden Tabelle sind die Möglichkeiten zusammengefasst, wie eine Not-a-Number oder eine positive oder negative Unendlichkeit erstellt werden 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:

  • Der Konstruktor float unterscheidet nicht zwischen Groß- und Kleinschreibung, daher können Sie auch float("NaN") oder float("InFiNiTy") verwenden.
  • Die Konstanten cmath und numpy geben plain Python float - Objekte zurück.
  • Der numpy.NINF Ist die einzige mir bekannte Konstante, für die der - Nicht erforderlich ist.
  • Es ist möglich, komplexe NaN und Infinity mit complex und cmath zu erstellen:

    ╒══════════╤════════════════╤═════════════════╤═════════════════════╤══════════════════════╕
    │   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 einfache float und keine complex zurück.

gibt es eine Funktion, mit der überprüft werden kann, ob eine Zahl unendlich ist oder nicht?

Ja, es gibt tatsächlich mehrere Funktionen für NaN, Infinity und weder Nan noch Inf. Diese vordefinierten Funktionen sind jedoch nicht integriert. Sie erfordern immer ein 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 cmath und numpy funktionieren auch für komplexe Objekte. Sie prüfen, ob der Real- oder Imaginärteil NaN oder Infinity ist.
  • Die numpy - Funktionen funktionieren auch für numpy - Arrays und für alles, was in eines 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, um nach NaN zu suchen: pandas.isna und pandas.isnull (aber nicht nur NaN, es stimmt überein auch None und NaT)
  • Obwohl es keine eingebauten Funktionen gibt, wäre es einfach, sie selbst zu erstellen (ich habe die Typprüfung und Dokumentation hier 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 eine array einfügen möchten (zum Beispiel array.array Oder numpy.array), Ist der Typ des Arrays mussfloat oder complex, da sonst versucht wird, es auf den Typ des Arrays 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
29
MSeifert

Versuchen Sie es mit Python 2.4

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, float("9e999") ausgeführt wird. Verwenden Sie nicht inf = 9e999 , Sie müssen es aus einem String konvertieren. -inf gibt den -Infinity.

2
user6458202