Hướng dẫn what is scalar array in python? - mảng vô hướng trong python là gì?

Python chỉ xác định một loại của một lớp dữ liệu cụ thể (chỉ có một loại số nguyên, một loại dấu phẩy động, v.v.). Điều này có thể thuận tiện trong các ứng dụng không cần phải quan tâm đến tất cả các cách dữ liệu có thể được biểu diễn trong máy tính. Đối với điện toán khoa học, tuy nhiên, thường cần kiểm soát nhiều hơn.

Nội dung chính Show

Các loại vô hướng tích hợp#
Các loại số nguyên#
Loại số nguyên không dấu, tương thích với C isinstance(val, np.generic)6.
Loại số nguyên không dấu, tương thích với C True1.
Dữ liệu thực sự được lưu trữ trong các mảng đối tượng (nghĩa là, các mảng có DTYPE >>> f16 = np.float16("0.1") >>> f32 = np.float32("0.1") >>> f64 = np.float64("0.1") >>> f16 == f32 == f64 False >>> f16, f32, f64 (0.1, 0.1, 0.1) 32) là các tham chiếu đến các đối tượng Python, không phải chính các đối tượng. Do đó, các mảng đối tượng hoạt động giống như Python >>> f16 = np.float16("0.1") >>> f32 = np.float32("0.1") >>> f64 = np.float64("0.1") >>> f16 == f32 == f64 False >>> f16, f32, f64 (0.1, 0.1, 0.1) 33 thông thường, theo nghĩa là nội dung của chúng không cần phải thuộc cùng loại Python.
Tương thích với C99 >>> f16 = np.float16("0.1") >>> f32 = np.float32("0.1") >>> f64 = np.float64("0.1") >>> f16 == f32 == f64 False >>> f16, f32, f64 (0.1, 0.1, 0.1) 68, >>> f16 = np.float16("0.1") >>> f32 = np.float32("0.1") >>> f64 = np.float64("0.1") >>> f16 == f32 == f64 False >>> f16, f32, f64 (0.1, 0.1, 0.1) 69, >>> f16 = np.float16("0.1") >>> f32 = np.float32("0.1") >>> f64 = np.float64("0.1") >>> f16 == f32 == f64 False >>> f16, f32, f64 (0.1, 0.1, 0.1) 70 và >>> f16 = np.float16("0.1") >>> f32 = np.float32("0.1") >>> f64 = np.float64("0.1") >>> f16 == f32 == f64 False >>> f16, f32, f64 (0.1, 0.1, 0.1) 71, tương ứng.
Attributes#
Giao thức Array: Phía Python
Mảng vô hướng là gì?
Mảng vô hướng numpy là gì?
Scalar và vector trong Python là gì?
Sự khác biệt giữa vô hướng và một mảng là gì?

Trong Numpy, có 24 loại Python cơ bản mới để mô tả các loại vô hướng khác nhau. Các mô tả loại này chủ yếu dựa trên các loại có sẵn trong ngôn ngữ C mà Cpython được viết, với một số loại bổ sung tương thích với các loại Python.

Scalar Array có các thuộc tính và phương thức tương tự như ndarrays. 1 Điều này cho phép người ta xử lý các vật phẩm của một mảng một phần trên cùng một chân với các mảng, làm mịn các cạnh thô kết quả khi trộn các hoạt động vô hướng và mảng.

Các Scalar Array sống trong một hệ thống phân cấp (xem hình bên dưới) của các loại dữ liệu. Chúng có thể được phát hiện bằng cách sử dụng hệ thống phân cấp: ví dụ, isinstance(val, np.generic) sẽ trả về True nếu Val là đối tượng vô hướng mảng. Ngoài ra, loại vô hướng mảng nào có thể được xác định bằng cách sử dụng các thành viên khác của hệ thống phân cấp kiểu dữ liệu. Do đó, ví dụ isinstance(val, np.complexfloating) sẽ trả về True nếu Val là loại có giá trị phức tạp, trong khi

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

1 sẽ trả về đúng nếu Val là một trong những loại mảng linh hoạt (

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

4).

Hình: Phân cấp của các đối tượng loại đại diện cho các loại dữ liệu mảng. Không được hiển thị là hai loại số nguyên

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

5 và
>>> f16 = np.float16("0.1") >>> f32 = np.float32("0.1") >>> f64 = np.float64("0.1") >>> f16 == f32 == f64 False >>> f16, f32, f64 (0.1, 0.1, 0.1)
6 chỉ chỉ vào loại số nguyên chứa một con trỏ cho nền tảng. Tất cả các loại số cũng có thể được lấy bằng tên chiều rộng bit.## Hierarchy of type objects representing the array data types. Not shown are the two integer types

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

5 and

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

6 which just point to the integer type that holds a pointer for the platform. All the number types can be obtained using bit-width names as well.#

Tuy nhiên, vô hướng mảng là bất biến, vì vậy không có thuộc tính vô hướng nào được giải quyết.

Các loại vô hướng tích hợp#

Các loại vô hướng tích hợp được hiển thị dưới đây. Các tên giống C được liên kết với mã ký tự, được hiển thị trong các mô tả của chúng. Sử dụng các mã ký tự, tuy nhiên, không được khuyến khích.

Một số loại vô hướng về cơ bản tương đương với các loại Python cơ bản và do đó kế thừa từ chúng cũng như từ loại vô hướng mảng chung:

Loại vô hướng mảng

Loại Python liên quan

Inherits?

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

Python 2 chỉ

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

Vâng

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

Vâng

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

Vâng

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

Vâng

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

không

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

>>> m = memoryview(np.str_("abc"))
>>> m.format
'3w'
>>> m.tobytes()
b'a\x00\x00\x00b\x00\x00\x00c\x00\x00\x00'

không

>>> m = memoryview(np.str_("abc"))
>>> m.format
'3w'
>>> m.tobytes()
b'a\x00\x00\x00b\x00\x00\x00c\x00\x00\x00'

>>> m = memoryview(np.str_("abc"))
>>> m.format
'3w'
>>> m.tobytes()
b'a\x00\x00\x00b\x00\x00\x00c\x00\x00\x00'

không

Kiểu dữ liệu

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

7 rất giống với Python

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

8 nhưng không được kế thừa từ nó vì

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

8 của Python không cho phép bản thân được kế thừa và trên cấp độ C, kích thước của dữ liệu bool thực tế không giống như Python Boolean vô hướng.

Cảnh báo

Loại

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

7 không kế thừa từ

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

8 tích hợp theo Python 3, vì loại

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

8 không còn là loại số nguyên có chiều rộng cố định.not inherit from the

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

8 built-in under Python 3, because type

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

8 is no longer a fixed-width integer type.

Mẹo

Kiểu dữ liệu mặc định trong Numpy là

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

classnumpy.generic[source]# numpy.generic[source]#

Lớp cơ sở cho các loại vô hướng numpy.

Lớp từ đó hầu hết (tất cả?) Các loại vô hướng Numpy có nguồn gốc. Đối với tính nhất quán, phơi bày cùng một API với

>>> np.void(b'abcd')
void(b'\x61\x62\x63\x64')

0, mặc dù có nhiều thuộc tính do đó là chỉ có, chỉ có, hay hoàn toàn không liên quan. Đây là lớp mà người dùng được đề xuất mạnh mẽ nên lấy các loại vô hướng tùy chỉnh.

classnumpy.number[source]# numpy.number[source]#

Tóm tắt lớp cơ sở của tất cả các loại vô hướng số.

Các loại số nguyên#

classnumpy.integer[source]# numpy.integer[source]#

Tóm tắt lớp cơ sở của tất cả các loại vô hướng số nguyên.

Ghi chú

Các loại số nguyên numpy phản ánh hành vi của các số nguyên C, và do đó có thể bị lỗi tràn.Overflow Errors.

Các loại số nguyên đã ký#

classnumpy.signedinteger[source]# numpy.signedinteger[source]#

Tóm tắt lớp cơ sở của tất cả các loại vô hướng số nguyên đã ký.

classnumpy.byte[source]#numpy.byte[source]#

Loại số nguyên đã ký, tương thích với C

>>> np.void(b'abcd')
void(b'\x61\x62\x63\x64')

Mã ký tự

>>> np.void(b'abcd')
void(b'\x61\x62\x63\x64')

Bí danh trên nền tảng này (Linux x86_64)

>>> np.void(b'abcd')
void(b'\x61\x62\x63\x64')

3: Số nguyên có chữ ký 8 bit (

>>> np.void(b'abcd')
void(b'\x61\x62\x63\x64')

4 đến

>>> np.void(b'abcd')
void(b'\x61\x62\x63\x64')

5).

classnumpy.short[source]# numpy.short[source]#

Loại số nguyên đã ký, tương thích với C

>>> np.void(b'abcd')
void(b'\x61\x62\x63\x64')

Mã ký tự

>>> np.void(b'abcd')
void(b'\x61\x62\x63\x64')

Bí danh trên nền tảng này (Linux x86_64)

>>> np.void(b'abcd')
void(b'\x61\x62\x63\x64')

3: Số nguyên có chữ ký 8 bit (

>>> np.void(b'abcd')
void(b'\x61\x62\x63\x64')

4 đến

>>> np.void(b'abcd')
void(b'\x61\x62\x63\x64')

5).

classnumpy.intc[source]# numpy.intc[source]#

Loại số nguyên đã ký, tương thích với C

>>> np.void(b'abcd')
void(b'\x61\x62\x63\x64')

Mã ký tự

>>> arr = np.array((1, 2), dtype=[('x', np.int8), ('y', np.int8)])
>>> arr[()]
(1, 2)  # looks like a tuple, but is `np.void`

Bí danh trên nền tảng này (Linux x86_64)

>>> np.void(b'abcd')
void(b'\x61\x62\x63\x64')

3: Số nguyên có chữ ký 8 bit (

>>> np.void(b'abcd')
void(b'\x61\x62\x63\x64')

4 đến

>>> np.void(b'abcd')
void(b'\x61\x62\x63\x64')

5).

classnumpy.int_[source]# numpy.int_[source]#

Loại số nguyên đã ký, tương thích với C

>>> np.void(b'abcd')
void(b'\x61\x62\x63\x64')

Mã ký tự

>>> arr = np.array((1, 2), dtype=[('x', np.int8), ('y', np.int8)])
>>> arr[()]
(1, 2)  # looks like a tuple, but is `np.void`

Bí danh trên nền tảng này (Linux x86_64)

>>> np.void(b'abcd')
void(b'\x61\x62\x63\x64')

3: Số nguyên có chữ ký 8 bit (

>>> np.void(b'abcd')
void(b'\x61\x62\x63\x64')

4 đến

>>> np.void(b'abcd')
void(b'\x61\x62\x63\x64')

5).

Bí danh trên nền tảng này (Linux x86_64)

>>> np.void(b'abcd')
void(b'\x61\x62\x63\x64')

3: Số nguyên có chữ ký 8 bit (

>>> np.void(b'abcd')
void(b'\x61\x62\x63\x64')

4 đến

>>> np.void(b'abcd')
void(b'\x61\x62\x63\x64')

5).

classnumpy.longlong[source]# numpy.longlong[source]#

Loại số nguyên đã ký, tương thích với C

>>> np.void(b'abcd')
void(b'\x61\x62\x63\x64')

Mã ký tự

ndarrays5

Các loại số nguyên không dấu#

classnumpy.unsignedinteger[source]# numpy.unsignedinteger[source]#

Tóm tắt lớp cơ sở của tất cả các loại vô hướng số nguyên không dấu.

classnumpy.ubyte[source]#numpy.ubyte[source]#

Loại số nguyên không dấu, tương thích với C ndarrays6.

Mã ký tự

ndarrays7

Bí danh trên nền tảng này (Linux x86_64)

ndarrays8: Số nguyên không dấu 8 bit (ndarrays9 đến isinstance(val, np.generic)0).

classnumpy.ushort[source]# numpy.ushort[source]#

Loại số nguyên không dấu, tương thích với C isinstance(val, np.generic)1.

Mã ký tự

isinstance(val, np.generic)2

Bí danh trên nền tảng này (Linux x86_64)

ndarrays8: Số nguyên không dấu 8 bit (ndarrays9 đến isinstance(val, np.generic)0).

classnumpy.uintc[source]# numpy.uintc[source]#

Loại số nguyên không dấu, tương thích với C isinstance(val, np.generic)1.

Mã ký tự

isinstance(val, np.generic)7

Bí danh trên nền tảng này (Linux x86_64)

ndarrays8: Số nguyên không dấu 8 bit (ndarrays9 đến isinstance(val, np.generic)0).

classnumpy.uint[source]# numpy.uint[source]#

Loại số nguyên không dấu, tương thích với C isinstance(val, np.generic)1.

Mã ký tự

True2

Bí danh trên nền tảng này (Linux x86_64)

ndarrays8: Số nguyên không dấu 8 bit (ndarrays9 đến isinstance(val, np.generic)0).

Bí danh trên nền tảng này (Linux x86_64)

ndarrays8: Số nguyên không dấu 8 bit (ndarrays9 đến isinstance(val, np.generic)0).

classnumpy.ulonglong[source]#numpy.ulonglong[source]#

Loại số nguyên không dấu, tương thích với C isinstance(val, np.generic)1.

isinstance(val, np.generic)3: Số nguyên không dấu 16 bit (ndarrays9 đến isinstance(val, np.generic)5).

True9

Loại số nguyên không dấu, tương thích với C isinstance(val, np.generic)6.

classnumpy.inexact[source]# numpy.inexact[source]#

isinstance(val, np.generic)8: Số nguyên không dấu 32 bit (ndarrays9 đến True0).

Loại số nguyên không dấu, tương thích với C True1.

True3: Số nguyên không dấu 64-bit (ndarrays9 đến True5).

True6: Số nguyên không dấu đủ lớn để phù hợp với con trỏ, tương thích với C True7.

>>> f16 = np.float16("0.1")
>>> f32 = np.float32(f16)
>>> f64 = np.float64(f32)
>>> f16 == f32 == f64
True
>>> f16, f32, f64
(0.1, 0.099975586, 0.0999755859375)

Loại số nguyên đã ký, tương thích với C True8.\(\frac{1}{10}\); isinstance(val, np.complexfloating)3 prints as isinstance(val, np.complexfloating)4 because it is as close to that value as possible, whereas the other types do not as they have more precision and therefore have closer values.

Mã ký tự

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

Các loại không chính xác#

classnumpy.floating[source]#numpy.floating[source]#

Lớp cơ sở trừu tượng của tất cả các loại vô hướng số với biểu diễn không chính xác (có khả năng) không chính xác của các giá trị trong phạm vi của nó, chẳng hạn như số điểm nổi.

classnumpy.half[source]#numpy.half[source]#

Ghi chú

Mã ký tự

isinstance(val, np.complexfloating)5

Bí danh trên nền tảng này (Linux x86_64)

ndarrays8: Số nguyên không dấu 8 bit (ndarrays9 đến isinstance(val, np.generic)0).

classnumpy.single[source]# numpy.single[source]#

Loại số nguyên không dấu, tương thích với C isinstance(val, np.generic)1.

Mã ký tự

isinstance(val, np.generic)3: Số nguyên không dấu 16 bit (ndarrays9 đến isinstance(val, np.generic)5).

Bí danh trên nền tảng này (Linux x86_64)

ndarrays8: Số nguyên không dấu 8 bit (ndarrays9 đến isinstance(val, np.generic)0).

Loại số nguyên không dấu, tương thích với C isinstance(val, np.generic)1. numpy.double(x=0, /)[source]#

isinstance(val, np.generic)3: Số nguyên không dấu 16 bit (ndarrays9 đến isinstance(val, np.generic)5).

Mã ký tự

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

Loại số nguyên không dấu, tương thích với C isinstance(val, np.generic)6.

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

isinstance(val, np.generic)8: Số nguyên không dấu 32 bit (ndarrays9 đến True0).

Loại số nguyên không dấu, tương thích với C True1.

classnumpy.longdouble[source]# numpy.longdouble[source]#

True3: Số nguyên không dấu 64-bit (ndarrays9 đến True5).

Mã ký tự

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

Loại số nguyên không dấu, tương thích với C isinstance(val, np.generic)6.

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

Bí danh trên nền tảng này (Linux x86_64)

ndarrays8: Số nguyên không dấu 8 bit (ndarrays9 đến isinstance(val, np.generic)0).

Loại số nguyên không dấu, tương thích với C `isinstance(val, np.generic)`1.

classnumpy.complexfloating[source]# numpy.complexfloating[source]#

isinstance(val, np.generic)3: Số nguyên không dấu 16 bit (ndarrays9 đến isinstance(val, np.generic)5).

classnumpy.csingle[source]#numpy.csingle[source]#

Loại số nguyên không dấu, tương thích với C isinstance(val, np.generic)6.

Mã ký tự

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

Loại số nguyên không dấu, tương thích với C isinstance(val, np.generic)6.

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

Bí danh trên nền tảng này (Linux x86_64)

isinstance(val, np.generic)8: Số nguyên không dấu 32 bit (ndarrays9 đến True0).

Loại số nguyên không dấu, tương thích với C True1.numpy.cdouble(real=0, imag=0)[source]#

True3: Số nguyên không dấu 64-bit (ndarrays9 đến True5).

Mã ký tự

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

Loại số nguyên không dấu, tương thích với C isinstance(val, np.generic)6.

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

Loại số nguyên không dấu, tương thích với C isinstance(val, np.generic)6.

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

Bí danh trên nền tảng này (Linux x86_64)

isinstance(val, np.generic)8: Số nguyên không dấu 32 bit (ndarrays9 đến True0).

classnumpy.clongdouble[source]#numpy.clongdouble[source]#

Loại số nguyên không dấu, tương thích với C True1.

isinstance(val, np.generic)3: Số nguyên không dấu 16 bit (ndarrays9 đến isinstance(val, np.generic)5).

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

Loại số nguyên không dấu, tương thích với C isinstance(val, np.generic)6.

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

Loại số nguyên không dấu, tương thích với C isinstance(val, np.generic)6.

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

Bí danh trên nền tảng này (Linux x86_64)

isinstance(val, np.generic)8: Số nguyên không dấu 32 bit (ndarrays9 đến True0).

Loại số nguyên không dấu, tương thích với C True1.

classnumpy.bool_[source]#numpy.bool_[source]#

True3: Số nguyên không dấu 64-bit (ndarrays9 đến True5).

True6: Số nguyên không dấu đủ lớn để phù hợp với con trỏ, tương thích với C True7.

Loại số nguyên đã ký, tương thích với C True8.

Mã ký tự

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

Bí danh

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

classnumpy.datetime64[source]#numpy.datetime64[source]#

Nếu được tạo từ một số nguyên 64 bit, nó thể hiện mức bù từ

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

28. Nếu được tạo từ chuỗi, chuỗi có thể ở định dạng ngày ISO 8601 hoặc DateTime.

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

Xem Datetimes và Timedeltas để biết thêm thông tin.Datetimes and Timedeltas for more information.

Mã ký tự

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

classnumpy.timedelta64[source]# numpy.timedelta64[source]#

Một thời gian được lưu trữ dưới dạng số nguyên 64 bit.

Xem Datetimes và Timedeltas để biết thêm thông tin.Datetimes and Timedeltas for more information.

Mã ký tự

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

classnumpy.object_[source]# numpy.object_[source]#

Một thời gian được lưu trữ dưới dạng số nguyên 64 bit.

Mã ký tự

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

Bất kỳ đối tượng Python.

Ghi chú

Dữ liệu thực sự được lưu trữ trong các mảng đối tượng (nghĩa là, các mảng có DTYPE

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

32) là các tham chiếu đến các đối tượng Python, không phải chính các đối tượng. Do đó, các mảng đối tượng hoạt động giống như Python

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

33 thông thường, theo nghĩa là nội dung của chúng không cần phải thuộc cùng loại Python.

Loại đối tượng cũng đặc biệt vì một mảng chứa

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

32 Các mục không trả về đối tượng

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

32 trên truy cập mục, mà thay vào đó trả về đối tượng thực tế mà mục mảng đề cập đến.flexible: they have no predefined size and the data they describe can be of different length in different arrays. (In the character codes

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

36 is an integer denoting how many elements the data type consists of.)

classnumpy.flexible[source]# numpy.flexible[source]#

Các loại dữ liệu sau đây là linh hoạt: chúng không có kích thước được xác định trước và dữ liệu chúng mô tả có thể có độ dài khác nhau trong các mảng khác nhau. (Trong mã ký tự

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

36 là một số nguyên biểu thị có bao nhiêu yếu tố mà loại dữ liệu bao gồm.)

classnumpy.bytes_[source]#numpy.bytes_[source]#

Tóm tắt lớp cơ sở của tất cả các loại vô hướng không có độ dài được xác định trước. Kích thước thực tế của các loại này phụ thuộc vào việc khởi tạo NP.DTYPE cụ thể.

Một chuỗi byte.

Mã ký tự

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

Bí danh

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

classnumpy.str_[source]# numpy.str_[source]#

Nếu được tạo từ một số nguyên 64 bit, nó thể hiện mức bù từ

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

28. Nếu được tạo từ chuỗi, chuỗi có thể ở định dạng ngày ISO 8601 hoặc DateTime.

Xem Datetimes và Timedeltas để biết thêm thông tin.

Một thời gian được lưu trữ dưới dạng số nguyên 64 bit.Buffer Protocol, exposing its contents as UCS4:

>>> m = memoryview(np.str_("abc"))
>>> m.format
'3w'
>>> m.tobytes()
b'a\x00\x00\x00b\x00\x00\x00c\x00\x00\x00'

Mã ký tự

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

Bí danh

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

classnumpy.void[source]# numpy.void[source]#

Nếu được tạo từ một số nguyên 64 bit, nó thể hiện mức bù từ

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

28. Nếu được tạo từ chuỗi, chuỗi có thể ở định dạng ngày ISO 8601 hoặc DateTime.

>>> np.void(b'abcd')
void(b'\x61\x62\x63\x64')

Xem Datetimes và Timedeltas để biết thêm thông tin.Structured arrays:

>>> arr = np.array((1, 2), dtype=[('x', np.int8), ('y', np.int8)])
>>> arr[()]
(1, 2)  # looks like a tuple, but is `np.void`

Mã ký tự

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

Một thời gian được lưu trữ dưới dạng số nguyên 64 bit.

Bất kỳ đối tượng Python.Note on string types.

Ghi chú

Dữ liệu thực sự được lưu trữ trong các mảng đối tượng (nghĩa là, các mảng có DTYPE >>> f16 = np.float16("0.1") >>> f32 = np.float32("0.1") >>> f64 = np.float64("0.1") >>> f16 == f32 == f64 False >>> f16, f32, f64 (0.1, 0.1, 0.1) 32) là các tham chiếu đến các đối tượng Python, không phải chính các đối tượng. Do đó, các mảng đối tượng hoạt động giống như Python >>> f16 = np.float16("0.1") >>> f32 = np.float32("0.1") >>> f64 = np.float64("0.1") >>> f16 == f32 == f64 False >>> f16, f32, f64 (0.1, 0.1, 0.1) 33 thông thường, theo nghĩa là nội dung của chúng không cần phải thuộc cùng loại Python.

Loại đối tượng cũng đặc biệt vì một mảng chứa

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

32 Các mục không trả về đối tượng

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

32 trên truy cập mục, mà thay vào đó trả về đối tượng thực tế mà mục mảng đề cập đến.

numpy.bool8[source]#bool8[source]#

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

36 là một số nguyên biểu thị có bao nhiêu yếu tố mà loại dữ liệu bao gồm.)

Tóm tắt lớp cơ sở của tất cả các loại vô hướng không có độ dài được xác định trước. Kích thước thực tế của các loại này phụ thuộc vào việc khởi tạo NP.DTYPE cụ thể.int8[source]# numpy.int16# numpy.int32# numpy.int64#

Một chuỗi byte.

Khi được sử dụng trong các mảng, loại này dải byte null kéo dài.

Một chuỗi unicode.uint8[source]# numpy.uint16# numpy.uint32# numpy.uint64#

Khi được sử dụng trong các mảng, loại này sẽ kéo theo các codepoint null.

Không giống như

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

6 tích hợp, điều này hỗ trợ giao thức bộ đệm, hiển thị nội dung của nó dưới dạng UCS4:

numpy.intp[source]#intp[source]#

Hoặc là một chuỗi mờ đục của byte, hoặc một cấu trúc.

Có thể xây dựng các vô hướng

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

4 chỉ có thể được xây dựng thông qua việc chiết xuất từ các mảng có cấu trúc:

Mã ký tự

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

numpy.uintp[source]#uintp[source]#

Cảnh báo

Xem ghi chú trên các loại chuỗi.

Mã ký tự

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

numpy.float16[source]#float16[source]#

Khả năng tương thích số: Nếu bạn đã sử dụng các ký tự typecode cũ trong mã số của mình (không bao giờ được khuyến nghị), bạn sẽ cần thay đổi một số trong số chúng thành các ký tự mới. Cụ thể, các thay đổi cần thiết là

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

44,

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

45,

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

46,

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

47,

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

48 và

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

49. Những thay đổi này làm cho quy ước ký tự loại phù hợp hơn với các mô -đun Python khác như mô -đun

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

50.

numpy.float32[source]#float32[source]#

Bí danh có kích thước#

numpy.float64[source]#float64[source]#

Cùng với các tên có nguồn gốc C (chủ yếu) của họ, số nguyên, phao và loại dữ liệu phức tạp cũng có sẵn bằng cách sử dụng quy ước có chiều rộng bit để có thể luôn có một mảng có kích thước phù hợp. Hai bí danh (ndarrays2 và True6) chỉ vào loại số nguyên đủ lớn để giữ một con trỏ C cũng được cung cấp.

bí danh của

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

53float96# numpy.float128[source]#

numpy.int8 [nguồn]# numpy.int16# numpy.int32# numpy.int64#

numpy.complex64[source]#complex64[source]#

Bí danh cho các loại số nguyên đã ký (một trong

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

54,

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

55,

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

56,

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

57 và

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

58) với số lượng bit được chỉ định.

numpy.complex128[source]#complex128[source]#

Tương thích với C99

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

59,

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

60,

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

61 và

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

62, tương ứng.

numpy.uint8 [nguồn]# numpy.uint16# numpy.uint32# numpy.uint64#complex192# numpy.complex256[source]#

Bí danh cho các loại số nguyên không dấu (một trong

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

63,

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

64,

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

65,

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

66 và

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

67) với số lượng bit được chỉ định.

Tương thích với C99 >>> f16 = np.float16("0.1") >>> f32 = np.float32("0.1") >>> f64 = np.float64("0.1") >>> f16 == f32 == f64 False >>> f16, f32, f64 (0.1, 0.1, 0.1) 68, >>> f16 = np.float16("0.1") >>> f32 = np.float32("0.1") >>> f64 = np.float64("0.1") >>> f16 == f32 == f64 False >>> f16, f32, f64 (0.1, 0.1, 0.1) 69, >>> f16 = np.float16("0.1") >>> f32 = np.float32("0.1") >>> f64 = np.float64("0.1") >>> f16 == f32 == f64 False >>> f16, f32, f64 (0.1, 0.1, 0.1) 70 và >>> f16 = np.float16("0.1") >>> f32 = np.float32("0.1") >>> f64 = np.float64("0.1") >>> f16 == f32 == f64 False >>> f16, f32, f64 (0.1, 0.1, 0.1) 71, tương ứng.

Bí danh cho loại số nguyên đã ký (một trong

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

54,

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

55,

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

56,

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

57 và np.longlong) có cùng kích thước với con trỏ.

numpy.float_[source]#float_[source]#

bí danh của

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

numpy.complex_[source]#complex_[source]#

bí danh của

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

Một số sử dụng thêm các quy ước đặt tên thay thế cho phao chính xác mở rộng và các số phức tạp:

numpy.longfloat[source]#longfloat[source]#

bí danh của

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

numpy.singlecomplex[source]#singlecomplex[source]#

bí danh của

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

numpy.cfloat[source]#cfloat[source]#

bí danh của

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

numpy.longcomplex[source]#longcomplex[source]#

Một số sử dụng thêm các quy ước đặt tên thay thế cho phao chính xác mở rộng và các số phức tạp:

numpy.clongfloat[source]#clongfloat[source]#

Một số sử dụng thêm các quy ước đặt tên thay thế cho phao chính xác mở rộng và các số phức tạp:

bí danh của

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

numpy.string_[source]#string_[source]#

bí danh của

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

numpy.unicode_[source]#unicode_[source]#

bí danh của

>>> f16 = np.float16("0.1")
>>> f32 = np.float32("0.1")
>>> f64 = np.float64("0.1")
>>> f16 == f32 == f64
False
>>> f16, f32, f64
(0.1, 0.1, 0.1)

Attributes#

Các bí danh sau đây có nguồn gốc từ Python 2 và chúng tôi không nên sử dụng mã mới.

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

bí danh của

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

bí danh của

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

Các đối tượng vô hướng mảng có

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

05 là

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

06 (-1.000.000.0). Họ cũng chưa (chưa) có thuộc tính

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

07. Mặt khác, chúng chia sẻ các thuộc tính giống như các mảng:

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

Giá trị số nguyên của cờ.

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

Tuple của kích thước mảng.

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

Tuple của byte bước trong mỗi chiều.

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

Số lượng kích thước mảng.

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

Con trỏ để bắt đầu dữ liệu.

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

Số lượng các yếu tố trong gentype.

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

Độ dài của một phần tử trong byte.

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

Thuộc tính vô hướng giống hệt với thuộc tính mảng tương ứng.

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

Nhận mảng dữ liệu-Descriptor.

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

Con trỏ để bắt đầu dữ liệu.

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

Số lượng các yếu tố trong gentype.

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

Độ dài của một phần tử trong byte.

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

Thuộc tính vô hướng giống hệt với thuộc tính mảng tương ứng.

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

Nhận mảng dữ liệu-Descriptor.

Indexing#

Phần thực của vô hướng.

Phần tưởng tượng của vô hướng.
Một cái nhìn 1-D của vô hướng.
Giao thức Array: Phía Python

Methods#

Giao thức mảng: structufunc, so that the error state used for ufuncs also carries over to the math on array scalars.

Ưu tiên mảng.

>>> np.datetime64(10, 'Y') numpy.datetime64('1980') >>> np.datetime64('1980', 'Y') numpy.datetime64('1980') >>> np.datetime64(10, 'D') numpy.datetime64('1970-01-11') 29	sc .__ mảng_wrap __ (obj) trả về vô hướng từ mảng
>>> np.datetime64(10, 'Y') numpy.datetime64('1980') >>> np.datetime64('1980', 'Y') numpy.datetime64('1980') >>> np.datetime64(10, 'D') numpy.datetime64('1970-01-11') 24	Nhận mảng dữ liệu-Descriptor.
>>> np.datetime64(10, 'Y') numpy.datetime64('1980') >>> np.datetime64('1980', 'Y') numpy.datetime64('1980') >>> np.datetime64(10, 'D') numpy.datetime64('1970-01-11') 31	Phần thực của vô hướng.
>>> np.datetime64(10, 'Y') numpy.datetime64('1980') >>> np.datetime64('1980', 'Y') numpy.datetime64('1980') >>> np.datetime64(10, 'D') numpy.datetime64('1970-01-11') 32	Phần thực của vô hướng.
>>> np.datetime64(10, 'Y') numpy.datetime64('1980') >>> np.datetime64('1980', 'Y') numpy.datetime64('1980') >>> np.datetime64(10, 'D') numpy.datetime64('1970-01-11') 33	Phần tưởng tượng của vô hướng.
>>> np.datetime64(10, 'Y') numpy.datetime64('1980') >>> np.datetime64('1980', 'Y') numpy.datetime64('1980') >>> np.datetime64(10, 'D') numpy.datetime64('1970-01-11') 34
>>> np.datetime64(10, 'Y') numpy.datetime64('1980') >>> np.datetime64('1980', 'Y') numpy.datetime64('1980') >>> np.datetime64(10, 'D') numpy.datetime64('1970-01-11') 35	Phần thực của vô hướng.

Phần tưởng tượng của vô hướng.

>>> np.datetime64(10, 'Y')
numpy.datetime64('1980')
>>> np.datetime64('1980', 'Y')
numpy.datetime64('1980')
>>> np.datetime64(10, 'D')
numpy.datetime64('1970-01-11')

36(item, /)

Một cái nhìn 1-D của vô hướng.

Giao thức Array: Phía Python

Giao thức mảng: structdtypes from the built-in scalar types): One way is to simply subclass the

>>> np.void(b'abcd')
void(b'\x61\x62\x63\x64')

0 and overwrite the methods of interest. This will work to a degree, but internally certain behaviors are fixed by the data type of the array. To fully customize the data type of an array you need to define a new data-type, and register it with NumPy. Such new types can only be defined in C, using the NumPy C-API.

Mảng vô hướng là gì?

Một mảng vô hướng là một nhóm có độ dài cố định của các vị trí bộ nhớ liên tiếp, mỗi lưu trữ một giá trị cùng loại. Bạn truy cập các mảng vô hướng bằng cách tham khảo từng vị trí với số nguyên bắt đầu từ 0. Trong các chương trình D, bạn thường sẽ sử dụng các mảng vô hướng để truy cập dữ liệu mảng trong hệ điều hành.a fixed-length group of consecutive memory locations that each store a value of the same type. You access scalar arrays by referring to each location with an integer starting from zero. In D programs, you would usually use scalar arrays to access array data within the operating system.

Mảng vô hướng numpy là gì?

Trong Numpy, một vô hướng là bất kỳ đối tượng nào bạn đặt trong một mảng.Nó tương tự như khái niệm trong đại số tuyến tính, một yếu tố của một trường được sử dụng để xác định không gian vectơ.Numpy đảm bảo tất cả các vô hướng trong một mảng có giống nhau.Không thể một vô hướng có loại Int32, các vô hướng khác có loại Int64.any object that you put in an array. It's similar to the concept in linear algebra, an element of a field which is used to define a vector space. NumPy ensures all scalars in an array have same types. It's impossible one scalar having type int32, the other scalars having type int64.

Scalar và vector trong Python là gì?

Một vô hướng là một số duy nhất.Một vectơ là một mảng các số.. A vector is an array of numbers.

Sự khác biệt giữa vô hướng và một mảng là gì?

Có một sự khác biệt lớn giữa hai trong số các định dạng chính - bộ xử lý vô hướng và mảng - trong đó hệ thống máy tính xử lý thông tin.Trong khi các bộ xử lý vô hướng hoạt động trên một mục dữ liệu tại một thời điểm, các bộ xử lý mảng có thể giải quyết đồng thời nhiều luồng dữ liệu.scalar processors work on one data item at a time, array processors can tackle multiple data streams simultaneously.

Hướng dẫn what is scalar array in python? - mảng vô hướng trong python là gì?

Các loại vô hướng tích hợp#

Các loại số nguyên#

Các loại số nguyên đã ký#

Các loại số nguyên không dấu#

Loại số nguyên không dấu, tương thích với C isinstance(val, np.generic)6.

Các loại không chính xác#

Loại số nguyên không dấu, tương thích với C isinstance(val, np.generic)1.

Loại số nguyên không dấu, tương thích với C True1.

Attributes#

Indexing#

Methods#

Giao thức Array: Phía Python

Mảng vô hướng là gì?

Mảng vô hướng numpy là gì?

Scalar và vector trong Python là gì?

Sự khác biệt giữa vô hướng và một mảng là gì?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội

Loại số nguyên không dấu, tương thích với C `isinstance(val, np.generic)`1.