Có thể đặt một số thành NaN hoặc vô cùng?
Vâng, trên thực tế có một số cách. Một số công việc không có bất kỳ nhập khẩu nào, trong khi những người khác yêu cầu import, tuy nhiên đối với câu trả lời này, tôi sẽ giới hạn các thư viện trong tổng quan về thư viện tiêu chuẩn và NumPy (không phải là thư viện tiêu chuẩn mà là thư viện của bên thứ ba rất phổ biến).
Bảng sau đây tóm tắt các cách người ta có thể tạo một số không hoặc một số vô cực dương hoặc âm 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 │
╘══════════╧══════════════╧════════════════════╧════════════════════╛
Một vài nhận xét cho bàn:
- Hàm
floattạo thực sự không phân biệt chữ hoa chữ thường, vì vậy bạn cũng có thể sử dụng float("NaN")hoặc float("InFiNiTy").
- Các hằng số
cmathvà numpytrả về floatcác đối tượng Python đơn giản .
- Đây
numpy.NINFthực sự là hằng số duy nhất tôi biết không yêu cầu -.
Có thể tạo NaN và Infinity phức tạp với complexvà 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 │
╘══════════╧════════════════╧═════════════════╧═════════════════════╧══════════════════════╛
Các tùy chọn với ¹ trả về một đơn vị float, không phải là a complex.
Có chức năng nào để kiểm tra xem một số có vô cùng hay không?
Đúng là có - trên thực tế có một số chức năng cho NaN, Infinity và cả Nan và Inf. Tuy nhiên, các hàm được xác định trước này không được tích hợp sẵn, chúng luôn yêu cầu 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 │
╘══════════╧═════════════╧════════════════╧════════════════════╛
Lại một vài nhận xét:
- Các hàm
cmathvà numpyhàm cũng hoạt động đối với các đối tượng phức tạp, chúng sẽ kiểm tra xem phần thực hay phần ảo là NaN hay Infinity.
- Các
numpyhàm cũng hoạt động cho numpycác mảng và mọi thứ có thể được chuyển đổi thành một (như danh sách, bộ dữ liệu, v.v.)
- Ngoài ra còn có các hàm kiểm tra rõ ràng về vô cực dương và âm trong NumPy:
numpy.isposinfvà numpy.isneginf.
- Pandas cung cấp hai chức năng bổ sung để kiểm tra
NaN: pandas.isnavà pandas.isnull(nhưng không chỉ NaN, nó cũng phù hợp Nonevà NaT)
Mặc dù không có các hàm dựng sẵn, nhưng sẽ dễ dàng tự tạo chúng (tôi bỏ qua việc kiểm tra và tài liệu loại ở đây):
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))
Để tóm tắt các kết quả dự kiến cho các chức năng này (giả sử đầu vào là dấu phẩy):
╒════════════════╤═══════╤════════════╤═════════════╤══════════════════╕
│ input │ NaN │ Infinity │ -Infinity │ something else │
│ function │ │ │ │ │
╞════════════════╪═══════╪════════════╪═════════════╪══════════════════╡
│ isnan │ True │ False │ False │ False │
├────────────────┼───────┼────────────┼─────────────┼──────────────────┤
│ isinf │ False │ True │ True │ False │
├────────────────┼───────┼────────────┼─────────────┼──────────────────┤
│ isfinite │ False │ False │ False │ True │
╘════════════════╧═══════╧════════════╧═════════════╧══════════════════╛
Có thể đặt phần tử của một mảng thành NaN trong Python không?
Trong danh sách không có vấn đề gì, bạn luôn có thể bao gồm NaN (hoặc Infinity) ở đó:
>>> [math.nan, math.inf, -math.inf, 1] # python list
[nan, inf, -inf, 1]
Tuy nhiên, nếu bạn muốn đưa nó vào một array(ví dụ array.arrayhoặc numpy.array) thì kiểu của mảng phải là floathoặc complexbởi vì nếu không nó sẽ cố gắng hạ thấp nó thành kiểu mảng!
>>> 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