Apakah mungkin untuk menetapkan angka ke NaN atau infinity?

Apakah mungkin untuk mengatur elemen array ke NaNdalam Python?

Selain itu, apakah mungkin untuk menetapkan variabel ke +/- tanpa batas? Jika demikian, apakah ada fungsi untuk memeriksa apakah suatu angka tidak terbatas atau tidak?

Keluarkan dari string menggunakan float():

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

Ya, Anda bisa menggunakannya numpyuntuk itu.

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

Apakah mungkin untuk menetapkan angka ke NaN atau infinity?

Ya, sebenarnya ada beberapa cara. Beberapa pekerjaan tanpa impor, sementara yang lain memerlukan import, namun untuk jawaban ini saya akan membatasi perpustakaan dalam ikhtisar untuk perpustakaan standar dan NumPy (yang bukan perpustakaan standar tetapi perpustakaan pihak ketiga yang sangat umum).

Tabel berikut merangkum cara-cara bagaimana seseorang dapat membuat angka tidak terbatas atau positif atau negatif 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    │
╘══════════╧══════════════╧════════════════════╧════════════════════╛

Pasangan berkomentar di atas meja:

• The floatkonstruktor sebenarnya case-sensitive, sehingga Anda juga dapat menggunakan float("NaN")atau float("InFiNiTy").
• The cmathdan numpykonstanta kembali Python polos floatbenda.
• Ini numpy.NINFadalah satu-satunya konstanta yang saya tahu yang tidak memerlukan -.

• Dimungkinkan untuk membuat NaN dan Infinity yang kompleks dengan complexdan 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           │
  ╘══════════╧════════════════╧═════════════════╧═════════════════════╧══════════════════════╛

  Opsi dengan ¹ mengembalikan dataran float, bukan a complex.

apakah ada fungsi untuk memeriksa apakah suatu angka tidak terbatas atau tidak?

Ya ada - sebenarnya ada beberapa fungsi untuk NaN, Infinity, dan Nan maupun Inf. Namun fungsi-fungsi yang telah ditentukan ini tidak built-in, mereka selalu memerlukan 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     │
╘══════════╧═════════════╧════════════════╧════════════════════╛

Sekali lagi beberapa komentar:

• Fungsi cmathdan numpyjuga berfungsi untuk objek yang kompleks, mereka akan memeriksa apakah bagian nyata atau imajiner adalah NaN atau Infinity.
• numpyFungsi - fungsi ini juga berfungsi untuk numpyarray dan semua yang dapat dikonversi menjadi satu (seperti daftar, tuple, dll.)
• Ada juga fungsi yang secara eksplisit memeriksa infinity positif dan negatif di NumPy: numpy.isposinfdan numpy.isneginf.
• Pandas menawarkan dua fungsi tambahan untuk memeriksa NaN: pandas.isnadan pandas.isnull(tetapi tidak hanya NaN, itu juga cocok dengan Nonedan NaT)

• Meskipun tidak ada fungsi bawaan, akan mudah untuk membuatnya sendiri (saya mengabaikan pemeriksaan tipe dan dokumentasi di sini):

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

Untuk merangkum hasil yang diharapkan untuk fungsi-fungsi ini (dengan asumsi input adalah float):

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

Apakah mungkin untuk mengatur elemen array ke NaN dengan Python?

Dalam daftar itu tidak masalah, Anda selalu dapat menyertakan NaN (atau Infinity) di sana:

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

Namun jika Anda ingin memasukkannya dalam array(misalnya array.arrayatau numpy.array) maka jenis array harus menjadi floatatau complexkarena kalau tidak akan mencoba untuk tertunduk ke jenis array!

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

Saat menggunakan Python 2.4, coba

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

Saya menghadapi masalah ketika saya port javascript sederhana ke perangkat tertanam yang menjalankan Python 2.4, float("9e999")memperbaikinya. Jangan gunakan inf = 9e999, Anda perlu mengubahnya dari string. -infmemberikan -Infinity.