เป็นไปได้ไหมที่จะตั้งค่าตัวเลขเป็น NaN หรือไม่สิ้นสุด

เป็นไปได้ไหมที่จะกำหนดองค์ประกอบของอาร์เรย์เป็นNaNPython?

นอกจากนี้เป็นไปได้ไหมที่จะตั้งค่าตัวแปรเป็น +/- อินฟินิตี้ ถ้าเป็นเช่นนั้นมีฟังก์ชั่นใด ๆ ที่จะตรวจสอบว่าตัวเลขนั้นไม่มีที่สิ้นสุดหรือไม่?

ส่งจากสตริงโดยใช้float():

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

ใช่คุณสามารถใช้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

เป็นไปได้ไหมที่จะตั้งค่าตัวเลขเป็น NaN หรือไม่สิ้นสุด

ใช่อันที่จริงมีหลายวิธี งานบางอย่างที่ไม่มีการนำเข้าใด ๆ ในขณะที่คนอื่นต้องการimportแต่สำหรับคำตอบนี้ฉันจะ จำกัด ห้องสมุดในภาพรวมให้กับไลบรารีมาตรฐานและ NumPy (ซึ่งไม่ใช่ห้องสมุดมาตรฐาน แต่เป็นห้องสมุดบุคคลที่สามทั่วไป)

ตารางต่อไปนี้สรุปวิธีการที่วิธีการหนึ่งที่สามารถสร้างไม่-a-จำนวนหรืออินฟินิตี้บวกหรือลบ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    │
╘══════════╧══════════════╧════════════════════╧════════════════════╛

หมายเหตุคู่กับตาราง:

• floatคอนสตรัคเป็นจริงกรณีตายเพื่อให้คุณยังสามารถใช้หรือfloat("NaN")float("InFiNiTy")
• กระบวนการcmathและnumpyค่าคงที่ส่งคืนfloatวัตถุPython ธรรมดา
• เป็นจริงคงที่เดียวที่ฉันรู้ว่าไม่จำเป็นต้องใช้numpy.NINF-

• เป็นไปได้ที่จะสร้าง NaN และ Infinity ที่ซับซ้อนด้วยcomplexและ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           │
  ╘══════════╧════════════════╧═════════════════╧═════════════════════╧══════════════════════╛
  

  ตัวเลือกที่มี¹กลับธรรมดาไม่ได้floatcomplex

มีฟังก์ชั่นใด ๆ เพื่อตรวจสอบว่าหมายเลขนั้นไม่มีที่สิ้นสุดหรือไม่?

ใช่มี - อันที่จริงมีฟังก์ชั่นหลายอย่างสำหรับ NaN, Infinity และไม่ใช่ Nan หรือ Inf อย่างไรก็ตามฟังก์ชั่นที่กำหนดไว้ล่วงหน้าเหล่านี้ไม่ได้มีมาให้ในตัว แต่จำเป็นต้องมี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     │
╘══════════╧═════════════╧════════════════╧════════════════════╛

ข้อสังเกตอีกสองสามข้อ:

• cmathและnumpyฟังก์ชั่นยังทำงานสำหรับวัตถุที่ซับซ้อนพวกเขาจะตรวจสอบว่าส่วนหนึ่งจริงหรือจินตนาการที่จังหวัดน่านหรืออินฟินิตี้
• numpyฟังก์ชั่นยังทำงานให้กับnumpyอาร์เรย์และทุกอย่างที่สามารถแปลงเป็นหนึ่ง (เช่นรายการ tuple ฯลฯ )
• นอกจากนี้ยังมีฟังก์ชั่นอย่างชัดเจนว่าการตรวจสอบในเชิงบวกและเชิงลบในอินฟินิตี้ NumPy: และnumpy.isposinfnumpy.isneginf
• Pandas เสนอฟังก์ชั่นเพิ่มเติมอีกสองฟังก์ชั่นเพื่อตรวจสอบNaN: pandas.isnaและpandas.isnull(แต่ไม่เฉพาะ 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

เมื่อใช้ Python 2.4 ให้ลอง

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

ฉันกำลังเผชิญกับปัญหาเมื่อฉันย้ายพอร์ต simplejson ไปยังอุปกรณ์ฝังตัวซึ่งใช้งาน Python 2.4 ได้float("9e999")รับการแก้ไข อย่าใช้inf = 9e999คุณต้องแปลงมันเป็นสตริง จะช่วยให้-inf-Infinity