Можно ли установить число в NaN или бесконечность?

Можно ли установить элемент массива в NaN в Python?

Кроме того, можно ли установить переменную в +/- бесконечность? Если да, существует ли какая-либо функция для проверки того, является ли число бесконечным или нет?

Ответ 1

Листинг из строки с помощью float():

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

Ответ 2

Да, вы можете использовать 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

Ответ 3

Можно ли установить число в NaN или бесконечность?

Да, на самом деле есть несколько способов. Некоторые из них работают без какого-либо импорта, в то время как другие требуют import, однако для этого ответа я ограничу библиотеки в обзоре стандартной библиотекой и NumPy (который не является стандартной библиотекой, а очень распространенной сторонней библиотекой).

В следующей таблице приведены способы, как можно создать не-а-номер или положительный или отрицательный пейзажный float:

╒══════════╤══════════════╤════════════════════╤════════════════════╕
│ module   │ NaN          │ Infinity           │ -Infinity          │
╞══════════╪══════════════╪════════════════════╪════════════════════╡
│ 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    │
╘══════════╧══════════════╧════════════════════╧════════════════════╛

Пара замечаний к столу:

Конструктор float фактически нечувствителен к регистру, поэтому вы также можете использовать float("NaN") или float("InFiNiTy").
Константы cmath и numpy возвращают простые объекты с float Python.
numpy.NINF - фактически единственная известная мне константа, для которой не требуется -.

Можно создать комплекс NaN и Infinity с complex и cmath:

╒══════════╤════════════════╤═════════════════╤═════════════════════╤══════════════════════╕
│ module   │ NaN+0j         │ 0+NaNj          │ Inf+0j              │ 0+Infj               │
╞══════════╪════════════════╪═════════════════╪═════════════════════╪══════════════════════╡
│ built-in │ complex("nan") │ complex("nanj") │ complex("inf")      │ complex("infj")      │
│          │                │                 │ complex("infinity") │ complex("infinityj") │
├──────────┼────────────────┼─────────────────┼─────────────────────┼──────────────────────┤
│ cmath    │ cmath.nan      │ cmath.nanj      │ cmath.inf           │ cmath.infj           │
╘══════════╧════════════════╧═════════════════╧═════════════════════╧══════════════════════╛

Есть ли функция, чтобы проверить, является ли число бесконечностью или нет?

Да, есть - на самом деле есть несколько функций для NaN, Infinity и ни Nan, ни Inf. Однако эти предопределенные функции не являются встроенными, они всегда требуют import:

╒══════════╤═════════════╤════════════════╤════════════════════╕
│ module   │ NaN         │ Infinity or    │ not NaN and        │
│          │             │ -Infinity      │ not Infinity and   │
│          │             │                │ not -Infinity      │
╞══════════╪═════════════╪════════════════╪════════════════════╡
│ math     │ math.isnan  │ math.isinf     │ math.isfinite      │
├──────────┼─────────────┼────────────────┼────────────────────┤
│ cmath    │ cmath.isnan │ cmath.isinf    │ cmath.isfinite     │
├──────────┼─────────────┼────────────────┼────────────────────┤
│ numpy    │ numpy.isnan │ numpy.isinf    │ numpy.isfinite     │
╘══════════╧═════════════╧════════════════╧════════════════════╛

Опять пара замечаний:

Функции cmath и numpy также работают для сложных объектов, они проверят, является ли действительная или мнимая часть NaN или Infinity.
numpy функции также работают для numpy массивов и всего, что может быть преобразовано в один (например, списки, кортежи и т.д.)
Есть также функции, которые явно проверяют положительную и отрицательную бесконечность в NumPy: numpy.isposinf и numpy.isneginf.
Pandas предлагает две дополнительные функции для проверки на NaN (но не только NaN, он также соответствует None и NaT)
Несмотря на то, что нет встроенных функций, было бы легко создать их самостоятельно (здесь я пренебрег проверкой типов и документацией):
```
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))
```

Подводя итоги ожидаемых результатов для этих функций (при условии, что ввод является плавающим):

╒════════════════╤═══════╤════════════╤═════════════╤══════════════════╕
│          input │ NaN   │ Infinity   │ -Infinity   │ something else   │
│ function       │       │            │             │                  │
╞════════════════╪═══════╪════════════╪═════════════╪══════════════════╡
│ isnan          │ True  │ False      │ False       │ False            │
├────────────────┼───────┼────────────┼─────────────┼──────────────────┤
│ isinf          │ False │ True       │ True        │ False            │
├────────────────┼───────┼────────────┼─────────────┼──────────────────┤
│ isfinite       │ False │ False      │ False       │ True             │
╘════════════════╧═══════╧════════════╧═════════════╧══════════════════╛

Можно ли установить элемент массива в NaN в Python?

В списке это не проблема, вы всегда можете включить туда NaN (или Infinity):

>>> [math.nan, math.inf, -math.inf, 1]  # python list
[nan, inf, -inf, 1]

Однако, если вы хотите включить его в array (например, array.array или numpy.array), тогда тип массива должен быть float или complex потому что в противном случае он попытается уменьшить его до типа массива!

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

Ответ 4

При использовании Python 2.4 попробуйте

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

Я столкнулся с проблемой, когда я портировал simplejson на встроенное устройство, которое запускало Python 2.4, float("9e999") исправил его. Не используйте inf = 9e999, вам нужно преобразовать его из строки. -inf дает -Infinity.