NaN veya sonsuz olarak bir sayı ayarlamak mümkün mü?

Bir dizinin elemanını NaNPython'da ayarlamak mümkün müdür ?

Ayrıca, bir değişkeni +/- sonsuza ayarlamak mümkün müdür? Öyleyse, bir sayının sonsuz olup olmadığını kontrol etmek için herhangi bir işlev var mı?

Aşağıdakileri kullanarak dizeden yayınlayın float():

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

Evet, numpybunun için kullanabilirsiniz .

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

NaN veya sonsuz olarak bir sayı ayarlamak mümkün mü?

Evet, aslında birkaç yol var. Bazıları herhangi bir ithalat olmadan çalışır import, ancak diğerleri gerektirir , ancak bu cevap için genel bakıştaki kütüphaneleri standart kütüphane ve NumPy ile sınırlayacağım (standart kütüphane değil, çok yaygın bir üçüncü taraf kütüphanesi).

Aşağıdaki tablo, bir sayı olmayan veya pozitif veya negatif sonsuzluğu nasıl oluşturabileceğinizi özetler 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    │
╘══════════╧══════════════╧════════════════════╧════════════════════╛

Bir çift tabloya dikkat çekiyor:

• floatAyrıca kullanabilmesi yapıcı, aslında küçük harfe duyarlı değildir float("NaN")ya float("InFiNiTy").
• cmathVe numpysabitler düz Python dönmek floatnesneleri.
• numpy.NINFAslında gerektirmez benim bildiğim tek sabittir -.

• Karmaşık NaN ve Infinity oluşturmak mümkündür complexve 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           │
  ╘══════════╧════════════════╧═════════════════╧═════════════════════╧══════════════════════╛

  With ile seçenekler düz floatdeğil, düz döndürür complex.

sayının sonsuz olup olmadığını kontrol etmek için herhangi bir işlev var mı?

Evet var - aslında NaN, Infinity ve ne Nan ne de Inf için birkaç fonksiyon var. Ancak bu önceden tanımlanmış işlevler yerleşik değildir, her zaman aşağıdakileri gerektirir 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     │
╘══════════╧═════════════╧════════════════╧════════════════════╛

Yine birkaç açıklama:

• cmathVe numpyişlevleri de ya gerçek veya sanal kısmı NaN veya Infinity ise onlar kontrol edecek, karmaşık nesneler için çalışıyoruz.
• numpyAyrıca fonksiyonlar işin numpy(vb listeleri, başlığın gibi) birine dönüştürülebilir diziler ve her şeyi
• NumPy'de pozitif ve negatif sonsuzluğu açıkça kontrol eden fonksiyonlar da vardır: numpy.isposinfve numpy.isneginf.
• Pandalar teklifler iki ek denetlemek için fonksiyonlar NaN: pandas.isnave pandas.isnull(ama sadece NaN, aynı zamanda maçları Noneve NaT)

• Yerleşik işlevler olmasa da, bunları kendiniz oluşturmak kolay olurdu (burada tür denetimi ve dokümantasyonunu ihmal ettim):

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

Bu işlevler için beklenen sonuçları özetlemek için (girdinin şamandıralı olduğu varsayılarak):

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

Bir dizinin elemanını Python'da NaN olarak ayarlamak mümkün müdür?

Listede sorun değil, her zaman NaN (veya Infinity) ekleyebilirsiniz:

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

İster şirket dahil etmek istiyorsanız Ancak eğer array(örneğin array.arrayveya numpy.array) daha sonra dizinin tipi zorundadır olmak floatya complexaksi çünkü diziler türüne bunu downcast çalışacağız!

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

Python 2.4 kullanırken,

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

Simplejson'u Python 2.4'ü çalıştıran gömülü bir cihaza sabitlerken sorunla karşı karşıya kaldım float("9e999"). Kullanmayın inf = 9e999, dizeden dönüştürmeniz gerekir. -infverir -Infinity.