NumPy hỗ trợ nhiều loại số hơn nhiều so với Python. Phần này hiển thị những cái có sẵn và cách sửa đổi kiểu dữ liệu của một mảng
Các kiểu nguyên thủy được hỗ trợ được gắn chặt với các kiểu trong C
loại gọn gàng
loại C
Sự miêu tả
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]3
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]4
Boolean [Đúng hoặc Sai] được lưu dưới dạng byte
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]0
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]1
nền tảng được xác định
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]2
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]3
nền tảng được xác định
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]4
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]5
nền tảng được xác định
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]6
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]7
nền tảng được xác định
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]8
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]9
nền tảng được xác định
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]00
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]01
nền tảng được xác định
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]02
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]03
nền tảng được xác định
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]04
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]05
nền tảng được xác định
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]06
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]07
nền tảng được xác định
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]08
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]09
nền tảng được xác định
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]00 /
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]01
Phao nửa chính xác. bit dấu, 5 bit số mũ, 10 bit định trị
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]02
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]03
Phao chính xác đơn do nền tảng xác định. bit dấu thông thường, số mũ 8 bit, phần định trị 23 bit
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]04
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]05
Phao chính xác kép do nền tảng xác định. bit dấu thông thường, số mũ 11 bit, phần định trị 52 bit
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]06
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]07
Phao có độ chính xác mở rộng do nền tảng xác định
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]08
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]09
Số phức, được biểu thị bằng hai số float có độ chính xác đơn [các thành phần thực và ảo]
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]00
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]01
Số phức, được biểu thị bằng hai số float có độ chính xác kép [thành phần thực và ảo]
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]02
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]03
Số phức, được biểu thị bằng hai số float có độ chính xác mở rộng [các thành phần thực và ảo]
Vì nhiều trong số này có định nghĩa phụ thuộc vào nền tảng nên một bộ bí danh có kích thước cố định được cung cấp [Xem Bí danh có kích thước ].
Các kiểu số NumPy là các thể hiện của các đối tượng
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]04 [kiểu dữ liệu], mỗi đối tượng có các đặc điểm riêng. Khi bạn đã nhập NumPy bằng cách sử dụng
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]05, các loại dtype có sẵn dưới dạng
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]06,
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]07, v.v.
Các loại nâng cao, không được liệt kê ở trên, được khám phá trong phần Mảng có cấu trúc .
Có 5 kiểu số cơ bản biểu diễn boolean [bool], số nguyên [int], số nguyên không dấu [uint] dấu phẩy động [float] và số phức. Những người có số trong tên của họ cho biết kích thước bit của loại [i. e. cần bao nhiêu bit để biểu diễn một giá trị trong bộ nhớ]. Một số loại, chẳng hạn như
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]9 và
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]09, có kích thước bit khác nhau, tùy thuộc vào nền tảng [e. g. 32-bit so với. máy 64-bit]. Điều này nên được tính đến khi giao tiếp với mã cấp thấp [chẳng hạn như C hoặc Fortran] nơi xử lý bộ nhớ thô
Kiểu dữ liệu có thể được sử dụng làm hàm để chuyển đổi số python thành vô hướng mảng [xem phần vô hướng mảng để được giải thích], chuỗi số python thành mảng thuộc loại đó hoặc làm đối số cho từ khóa dtype mà nhiều hàm hoặc phương thức numpy chấp nhận. Vài ví dụ
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]0
Các loại mảng cũng có thể được gọi bằng mã ký tự, chủ yếu để duy trì khả năng tương thích ngược với các gói cũ hơn như Numeric. Một số tài liệu vẫn có thể đề cập đến những điều này, ví dụ
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]
Chúng tôi khuyên bạn nên sử dụng các đối tượng dtype để thay thế
Để chuyển đổi kiểu của một mảng, hãy sử dụng. astype[] [được ưu tiên] hoặc chính loại đó là một hàm. Ví dụ
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]0
Lưu ý rằng, ở trên, chúng tôi sử dụng đối tượng float Python làm dtype. NumPy biết rằng
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]9 đề cập đến
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]41,
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]4 có nghĩa là
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]06, rằng
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]03 là
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]45 và
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]46 là
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]47. Các kiểu dữ liệu khác không có Python tương đương
Để xác định loại mảng, hãy xem thuộc tính dtype
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]0
các đối tượng dtype cũng chứa thông tin về loại, chẳng hạn như độ rộng bit và thứ tự byte của nó. Kiểu dữ liệu cũng có thể được sử dụng gián tiếp để truy vấn các thuộc tính của kiểu, chẳng hạn như đó có phải là số nguyên hay không
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]0
Mảng vô hướng #
NumPy thường trả về các phần tử của mảng dưới dạng vô hướng mảng [một vô hướng với một dtype được liên kết]. Hàm vô hướng mảng khác với hàm vô hướng Python, nhưng phần lớn chúng có thể được sử dụng thay thế cho nhau [ngoại lệ chính là dành cho các phiên bản Python cũ hơn v2. x, trong đó các đại lượng mảng số nguyên không thể đóng vai trò là chỉ số cho danh sách và bộ dữ liệu]. Có một số trường hợp ngoại lệ, chẳng hạn như khi mã yêu cầu các thuộc tính rất cụ thể của một đại lượng vô hướng hoặc khi nó kiểm tra cụ thể xem một giá trị có phải là đại lượng vô hướng trong Python hay không. Nói chung, các sự cố có thể dễ dàng khắc phục bằng cách chuyển đổi rõ ràng các hàm vô hướng mảng thành hàm vô hướng Python, sử dụng hàm loại Python tương ứng [e. g. ,
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]9,
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]03,
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]46,
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]51,
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]52]
Ưu điểm chính của việc sử dụng mảng vô hướng là chúng bảo toàn kiểu mảng [Python có thể không có sẵn kiểu vô hướng phù hợp, e. g.
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]53]. Do đó, việc sử dụng mảng vô hướng đảm bảo hành vi giống hệt nhau giữa mảng và vô hướng, bất kể giá trị có nằm trong mảng hay không. Vô hướng NumPy cũng có nhiều phương thức giống như mảng
Lỗi tràn #
Kích thước cố định của các loại số NumPy có thể gây ra lỗi tràn khi một giá trị yêu cầu nhiều bộ nhớ hơn khả dụng trong loại dữ liệu. Ví dụ:
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]54 đánh giá đúng
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]55 đối với số nguyên 64 bit, nhưng đưa ra 1874919424 [không chính xác] đối với số nguyên 32 bit
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]4
Hành vi của các loại số nguyên NumPy và Python khác nhau đáng kể khi tràn số nguyên và có thể gây nhầm lẫn cho người dùng khi mong đợi các số nguyên NumPy hoạt động tương tự như
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]9 của Python. Không giống như NumPy, kích thước của
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]9 của Python rất linh hoạt. Điều này có nghĩa là số nguyên Python có thể mở rộng để chứa bất kỳ số nguyên nào và sẽ không bị tràn
NumPy cung cấp
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]58 và
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]59 để xác minh giá trị tối thiểu hoặc tối đa của giá trị số nguyên NumPy và giá trị dấu phẩy động tương ứng
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]5
Nếu số nguyên 64 bit vẫn còn quá nhỏ, kết quả có thể được chuyển thành số dấu phẩy động. Các số dấu phẩy động cung cấp phạm vi giá trị có thể lớn hơn nhưng không chính xác
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]6
Độ chính xác mở rộng #
Số dấu phẩy động của Python thường là số dấu phẩy động 64 bit, gần tương đương với
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]60. Trong một số tình huống bất thường, có thể hữu ích khi sử dụng các số dấu phẩy động với độ chính xác cao hơn. Điều này có khả thi trong numpy hay không tùy thuộc vào phần cứng và môi trường phát triển. cụ thể, các máy x86 cung cấp dấu phẩy động phần cứng với độ chính xác 80 bit và trong khi hầu hết các trình biên dịch C cung cấp điều này dưới dạng loại
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]07 của chúng, MSVC [tiêu chuẩn cho các bản dựng Windows] làm cho
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]07 giống với
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]05 [64 bit]. NumPy làm cho
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]07 của trình biên dịch có sẵn dưới dạng
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]65 [và
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]66 cho các số phức]. Bạn có thể tìm hiểu những gì numpy của bạn cung cấp với
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]67
NumPy không cung cấp một dtype với độ chính xác cao hơn
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]07 của C;
Để căn chỉnh bộ nhớ hiệu quả,
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]65 thường được lưu trữ đệm bằng 0 bit, hoặc là 96 hoặc 128 bit. Cái nào hiệu quả hơn phụ thuộc vào phần cứng và môi trường phát triển; .
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]65 được thêm vào mặc định của hệ thống; . Bất chấp tên gọi,
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]32 và
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]33 chỉ cung cấp độ chính xác tương đương với
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]65, tức là 80 bit trên hầu hết các máy x86 và 64 bit trong các bản dựng Windows tiêu chuẩn
Được cảnh báo rằng ngay cả khi
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]65 cung cấp độ chính xác cao hơn python
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]03, thì rất dễ bị mất độ chính xác đó, vì python thường buộc các giá trị phải chuyển qua
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]03. Ví dụ: toán tử định dạng
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]40 yêu cầu các đối số của nó phải được chuyển đổi thành các loại python tiêu chuẩn và do đó không thể duy trì độ chính xác mở rộng ngay cả khi nhiều vị trí thập phân được yêu cầu. Có thể hữu ích khi kiểm tra mã của bạn với giá trị
>>> np.array[[1, 2, 3], dtype='f'] array[[1., 2., 3.], dtype=float32]41