NumPy - Hướng dẫn nhanh
NumPy là một gói Python. Nó là viết tắt của 'Numerical Python'. Nó là một thư viện bao gồm các đối tượng mảng đa chiều và một tập hợp các quy trình xử lý mảng.
Numeric, tổ tiên của NumPy, được phát triển bởi Jim Hugunin. Một gói khác Numarray cũng được phát triển, có một số chức năng bổ sung. Năm 2005, Travis Oliphant đã tạo ra gói NumPy bằng cách kết hợp các tính năng của Numarray vào gói Numeric. Có rất nhiều người đóng góp cho dự án mã nguồn mở này.
Các hoạt động sử dụng NumPy
Sử dụng NumPy, nhà phát triển có thể thực hiện các thao tác sau:
Các phép toán toán học và logic trên mảng.
Các biến đổi Fourier và các quy trình để thao tác hình dạng.
Các phép toán liên quan đến đại số tuyến tính. NumPy có các hàm tích hợp sẵn cho đại số tuyến tính và tạo số ngẫu nhiên.
NumPy - Thay thế cho MatLab
NumPy thường được sử dụng cùng với các gói như SciPy (Python khoa học) và Mat−plotlib(thư viện vẽ đồ thị). Sự kết hợp này được sử dụng rộng rãi để thay thế cho MatLab, một nền tảng phổ biến cho tính toán kỹ thuật. Tuy nhiên, Python thay thế cho MatLab hiện được xem như một ngôn ngữ lập trình hoàn thiện và hiện đại hơn.
Nó là mã nguồn mở, là một lợi thế bổ sung của NumPy.
Bản phân phối Python tiêu chuẩn không đi kèm với mô-đun NumPy. Một giải pháp thay thế nhẹ là cài đặt NumPy bằng trình cài đặt gói Python phổ biến,pip.
pip install numpy
Cách tốt nhất để kích hoạt NumPy là sử dụng gói nhị phân có thể cài đặt cụ thể cho hệ điều hành của bạn. Các tệp nhị phân này chứa đầy đủ ngăn xếp SciPy (bao gồm NumPy, SciPy, matplotlib, IPython, SymPy và các gói mũi cùng với Python lõi).
các cửa sổ
Anaconda (từ https://www.continuum.io) là một bản phân phối Python miễn phí cho ngăn xếp SciPy. Nó cũng có sẵn cho Linux và Mac.
Mái hiên (https://www.enthought.com/products/canopy/) có sẵn miễn phí cũng như phân phối thương mại với ngăn xếp SciPy đầy đủ cho Windows, Linux và Mac.
Python (x, y): Đây là bản phân phối Python miễn phí với ngăn xếp SciPy và Spyder IDE dành cho hệ điều hành Windows. (Có thể tải xuống từhttps://www.python-xy.github.io/)
Linux
Trình quản lý gói của các bản phân phối Linux tương ứng được sử dụng để cài đặt một hoặc nhiều gói trong ngăn xếp SciPy.
Đối với Ubuntu
sudo apt-get install python-numpy
python-scipy python-matplotlibipythonipythonnotebook python-pandas
python-sympy python-nose
Đối với Fedora
sudo yum install numpyscipy python-matplotlibipython
python-pandas sympy python-nose atlas-devel
Xây dựng từ Nguồn
Core Python (2.6.x, 2.7.x và 3.2.x trở đi) phải được cài đặt với distutils và mô-đun zlib phải được bật.
Trình biên dịch C GNU gcc (4.2 trở lên) phải có sẵn.
Để cài đặt NumPy, hãy chạy lệnh sau.
Python setup.py install
Để kiểm tra xem mô-đun NumPy có được cài đặt đúng cách hay không, hãy thử nhập nó từ lời nhắc Python.
import numpy
Nếu nó chưa được cài đặt, thông báo lỗi sau sẽ được hiển thị.
Traceback (most recent call last):
File "<pyshell#0>", line 1, in <module>
import numpy
ImportError: No module named 'numpy'
Ngoài ra, gói NumPy được nhập bằng cú pháp sau:
import numpy as np
Đối tượng quan trọng nhất được định nghĩa trong NumPy là kiểu mảng N-chiều được gọi là ndarray. Nó mô tả bộ sưu tập các mặt hàng cùng loại. Các mục trong bộ sưu tập có thể được truy cập bằng chỉ mục dựa trên số không.
Mọi mục trong một ndarray có cùng kích thước khối trong bộ nhớ. Mỗi phần tử trong ndarray là một đối tượng của đối tượng kiểu dữ liệu (được gọi làdtype).
Bất kỳ mục nào được trích xuất từ đối tượng ndarray (bằng cách cắt) được đại diện bởi một đối tượng Python thuộc một trong các kiểu vô hướng mảng. Sơ đồ sau cho thấy mối quan hệ giữa ndarray, đối tượng kiểu dữ liệu (dtype) và kiểu vô hướng mảng:
Một thể hiện của lớp ndarray có thể được xây dựng bằng các quy trình tạo mảng khác nhau được mô tả ở phần sau của hướng dẫn. Ndarray cơ bản được tạo bằng một hàm mảng trong NumPy như sau:
numpy.array
Nó tạo ra một ndarray từ bất kỳ đối tượng nào để lộ giao diện mảng hoặc từ bất kỳ phương thức nào trả về một mảng.
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
Hàm tạo ở trên nhận các tham số sau:
Sr.No. | Mô tả về Thông Số |
---|---|
1 | object Bất kỳ đối tượng nào hiển thị phương thức giao diện mảng sẽ trả về một mảng hoặc bất kỳ chuỗi (lồng nhau) nào. |
2 | dtype Kiểu dữ liệu mong muốn của mảng, tùy chọn |
3 | copy Không bắt buộc. Theo mặc định (true), đối tượng được sao chép |
4 | order C (hàng chính) hoặc F (cột chính) hoặc A (bất kỳ) (mặc định) |
5 | subok Theo mặc định, mảng trả về buộc phải là mảng lớp cơ sở. Nếu đúng, các lớp con được chuyển qua |
6 | ndmin Chỉ định kích thước tối thiểu của mảng kết quả |
Hãy xem các ví dụ sau để hiểu rõ hơn.
ví dụ 1
import numpy as np
a = np.array([1,2,3])
print a
Kết quả như sau:
[1, 2, 3]
Ví dụ 2
# more than one dimensions
import numpy as np
a = np.array([[1, 2], [3, 4]])
print a
Kết quả như sau:
[[1, 2]
[3, 4]]
Ví dụ 3
# minimum dimensions
import numpy as np
a = np.array([1, 2, 3,4,5], ndmin = 2)
print a
Kết quả như sau:
[[1, 2, 3, 4, 5]]
Ví dụ 4
# dtype parameter
import numpy as np
a = np.array([1, 2, 3], dtype = complex)
print a
Kết quả như sau:
[ 1.+0.j, 2.+0.j, 3.+0.j]
Các ndarrayđối tượng bao gồm phân đoạn một chiều liền kề của bộ nhớ máy tính, kết hợp với lược đồ lập chỉ mục ánh xạ từng mục tới một vị trí trong khối bộ nhớ. Khối bộ nhớ giữ các phần tử theo thứ tự chính hàng (kiểu C) hoặc thứ tự chính cột (kiểu FORTRAN hoặc MatLab).
NumPy hỗ trợ nhiều kiểu số hơn nhiều so với Python. Bảng sau đây cho thấy các kiểu dữ liệu vô hướng khác nhau được xác định trong NumPy.
Sr.No. | Loại dữ liệu & mô tả |
---|---|
1 | bool_ Boolean (Đúng hoặc Sai) được lưu trữ dưới dạng byte |
2 | int_ Kiểu số nguyên mặc định (giống C long; thường là int64 hoặc int32) |
3 | intc Giống hệt với int C (thường là int32 hoặc int64) |
4 | intp Số nguyên được sử dụng để lập chỉ mục (giống như C ssize_t; thông thường là int32 hoặc int64) |
5 | int8 Byte (-128 đến 127) |
6 | int16 Số nguyên (-32768 đến 32767) |
7 | int32 Số nguyên (-2147483648 đến 2147483647) |
số 8 | int64 Số nguyên (-9223372036854775808 đến 9223372036854775807) |
9 | uint8 Số nguyên không dấu (0 đến 255) |
10 | uint16 Số nguyên không dấu (0 đến 65535) |
11 | uint32 Số nguyên không dấu (0 đến 4294967295) |
12 | uint64 Số nguyên không dấu (0 đến 18446744073709551615) |
13 | float_ Viết tắt cho float64 |
14 | float16 Nửa chính xác float: bit dấu, số mũ 5 bit, phần định trị 10 bit |
15 | float32 Phao chính xác đơn: bit dấu, số mũ 8 bit, phần định trị 23 bit |
16 | float64 Phao chính xác kép: bit dấu, số mũ 11 bit, phần định trị 52 bit |
17 | complex_ Viết tắt cho phức tạp128 |
18 | complex64 Số phức, được biểu thị bằng hai số thực 32 bit (thành phần thực và ảo) |
19 | complex128 Số phức, được biểu thị bằng hai số thực 64 bit (thành phần thực và ảo) |
Các kiểu số NumPy là các thể hiện của các đối tượng dtype (kiểu dữ liệu), mỗi đối tượng có các đặc điểm riêng biệt. Các kiểu có sẵn như np.bool_, np.float32, v.v.
Đối tượng kiểu dữ liệu (dtype)
Một đối tượng kiểu dữ liệu mô tả việc diễn giải khối bộ nhớ cố định tương ứng với một mảng, tùy thuộc vào các khía cạnh sau:
Loại dữ liệu (số nguyên, đối tượng float hoặc Python)
Kích thước của dữ liệu
Thứ tự Byte (little-endian hoặc big-endian)
Trong trường hợp kiểu có cấu trúc, tên của các trường, kiểu dữ liệu của từng trường và một phần của khối bộ nhớ được lấy bởi từng trường.
Nếu kiểu dữ liệu là một mảng con, hình dạng và kiểu dữ liệu của nó
Thứ tự byte được quyết định bằng cách thêm tiền tố '<' hoặc '>' vào kiểu dữ liệu. '<' có nghĩa là mã hóa có giá trị nhỏ (ít quan trọng nhất được lưu trữ ở địa chỉ nhỏ nhất). '>' có nghĩa là mã hóa là big-endian (byte quan trọng nhất được lưu trữ ở địa chỉ nhỏ nhất).
Một đối tượng dtype được tạo bằng cú pháp sau:
numpy.dtype(object, align, copy)
Các thông số là -
Object - Được chuyển đổi thành đối tượng kiểu dữ liệu
Align - Nếu đúng, hãy thêm phần đệm vào trường để trường tương tự như C-struct
Copy- Tạo một bản sao mới của đối tượng dtype. Nếu sai, kết quả là tham chiếu đến đối tượng kiểu dữ liệu nội trang
ví dụ 1
# using array-scalar type
import numpy as np
dt = np.dtype(np.int32)
print dt
Kết quả như sau:
int32
Ví dụ 2
#int8, int16, int32, int64 can be replaced by equivalent string 'i1', 'i2','i4', etc.
import numpy as np
dt = np.dtype('i4')
print dt
Kết quả như sau:
int32
Ví dụ 3
# using endian notation
import numpy as np
dt = np.dtype('>i4')
print dt
Kết quả như sau:
>i4
Các ví dụ sau đây cho thấy việc sử dụng kiểu dữ liệu có cấu trúc. Ở đây, tên trường và kiểu dữ liệu vô hướng tương ứng sẽ được khai báo.
Ví dụ 4
# first create structured data type
import numpy as np
dt = np.dtype([('age',np.int8)])
print dt
Kết quả như sau:
[('age', 'i1')]
Ví dụ 5
# now apply it to ndarray object
import numpy as np
dt = np.dtype([('age',np.int8)])
a = np.array([(10,),(20,),(30,)], dtype = dt)
print a
Kết quả như sau:
[(10,) (20,) (30,)]
Ví dụ 6
# file name can be used to access content of age column
import numpy as np
dt = np.dtype([('age',np.int8)])
a = np.array([(10,),(20,),(30,)], dtype = dt)
print a['age']
Kết quả như sau:
[10 20 30]
Ví dụ 7
Các ví dụ sau xác định một kiểu dữ liệu có cấu trúc được gọi là student với một trường chuỗi 'tên', một integer field 'age' và một float field'điểm'. Loại dtype này được áp dụng cho đối tượng ndarray.
import numpy as np
student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')])
print student
Kết quả như sau:
[('name', 'S20'), ('age', 'i1'), ('marks', '<f4')])
Ví dụ 8
import numpy as np
student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')])
a = np.array([('abc', 21, 50),('xyz', 18, 75)], dtype = student)
print a
Kết quả như sau:
[('abc', 21, 50.0), ('xyz', 18, 75.0)]
Mỗi kiểu dữ liệu dựng sẵn có một mã ký tự nhận dạng duy nhất nó.
'b' - boolean
'i' - (có dấu) số nguyên
'u' - số nguyên không dấu
'f' - dấu phẩy động
'c' - dấu phẩy động phức hợp
'm' - hẹn giờ
'M' - ngày giờ
'O' - Đối tượng (Python)
'S', 'a' - (byte-) chuỗi
'U' - Unicode
'V' - dữ liệu thô (vô hiệu)
Trong chương này, chúng ta sẽ thảo luận về các thuộc tính mảng khác nhau của NumPy.
ndarray.shape
Thuộc tính mảng này trả về một bộ giá trị bao gồm các kích thước mảng. Nó cũng có thể được sử dụng để thay đổi kích thước mảng.
ví dụ 1
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print a.shape
Kết quả như sau:
(2, 3)
Ví dụ 2
# this resizes the ndarray
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
a.shape = (3,2)
print a
Kết quả như sau:
[[1, 2]
[3, 4]
[5, 6]]
Ví dụ 3
NumPy cũng cung cấp một chức năng định hình lại để thay đổi kích thước một mảng.
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
b = a.reshape(3,2)
print b
Kết quả như sau:
[[1, 2]
[3, 4]
[5, 6]]
ndarray.ndim
Thuộc tính mảng này trả về số thứ nguyên của mảng.
ví dụ 1
# an array of evenly spaced numbers
import numpy as np
a = np.arange(24)
print a
Kết quả như sau:
[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
Ví dụ 2
# this is one dimensional array
import numpy as np
a = np.arange(24)
a.ndim
# now reshape it
b = a.reshape(2,4,3)
print b
# b is having three dimensions
Kết quả như sau:
[[[ 0, 1, 2]
[ 3, 4, 5]
[ 6, 7, 8]
[ 9, 10, 11]]
[[12, 13, 14]
[15, 16, 17]
[18, 19, 20]
[21, 22, 23]]]
numpy.itemsize
Thuộc tính mảng này trả về độ dài của mỗi phần tử của mảng tính bằng byte.
ví dụ 1
# dtype of array is int8 (1 byte)
import numpy as np
x = np.array([1,2,3,4,5], dtype = np.int8)
print x.itemsize
Kết quả như sau:
1
Ví dụ 2
# dtype of array is now float32 (4 bytes)
import numpy as np
x = np.array([1,2,3,4,5], dtype = np.float32)
print x.itemsize
Kết quả như sau:
4
numpy.flags
Đối tượng ndarray có các thuộc tính sau. Các giá trị hiện tại của nó được trả về bởi hàm này.
Sr.No. | Thuộc tính & Mô tả |
---|---|
1 | C_CONTIGUOUS (C) Dữ liệu nằm trong một phân đoạn liền kề kiểu C duy nhất |
2 | F_CONTIGUOUS (F) Dữ liệu nằm trong một phân đoạn liền kề theo kiểu Fortran |
3 | OWNDATA (O) Mảng sở hữu bộ nhớ mà nó sử dụng hoặc mượn nó từ một đối tượng khác |
4 | WRITEABLE (W) Vùng dữ liệu có thể được ghi vào. Đặt điều này thành False sẽ khóa dữ liệu, khiến dữ liệu ở chế độ chỉ đọc |
5 | ALIGNED (A) Dữ liệu và tất cả các yếu tố được căn chỉnh phù hợp với phần cứng |
6 | UPDATEIFCOPY (U) Mảng này là bản sao của một số mảng khác. Khi mảng này được phân bổ, mảng cơ sở sẽ được cập nhật với nội dung của mảng này |
Thí dụ
Ví dụ sau đây cho thấy các giá trị hiện tại của cờ.
import numpy as np
x = np.array([1,2,3,4,5])
print x.flags
Kết quả như sau:
C_CONTIGUOUS : True
F_CONTIGUOUS : True
OWNDATA : True
WRITEABLE : True
ALIGNED : True
UPDATEIFCOPY : False
Một mới ndarray đối tượng có thể được xây dựng bằng bất kỳ quy trình tạo mảng nào sau đây hoặc sử dụng phương thức khởi tạo ndarray cấp thấp.
numpy.empty
Nó tạo ra một mảng chưa được khởi tạo có hình dạng và kiểu được chỉ định. Nó sử dụng hàm tạo sau:
numpy.empty(shape, dtype = float, order = 'C')
Hàm tạo nhận các tham số sau.
Sr.No. | Mô tả về Thông Số |
---|---|
1 | Shape Hình dạng của một mảng trống trong int hoặc tuple int |
2 | Dtype Kiểu dữ liệu đầu ra mong muốn. Không bắt buộc |
3 | Order 'C' cho mảng chính hàng kiểu C, 'F' cho mảng cột chính kiểu FORTRAN |
Thí dụ
Đoạn mã sau đây cho thấy một ví dụ về một mảng trống.
import numpy as np
x = np.empty([3,2], dtype = int)
print x
Kết quả như sau:
[[22649312 1701344351]
[1818321759 1885959276]
[16779776 156368896]]
Note - Các phần tử trong một mảng hiển thị các giá trị ngẫu nhiên khi chúng không được khởi tạo.
numpy.zeros
Trả về một mảng mới có kích thước được chỉ định, chứa đầy các số không.
numpy.zeros(shape, dtype = float, order = 'C')
Hàm tạo nhận các tham số sau.
Sr.No. | Mô tả về Thông Số |
---|---|
1 | Shape Hình dạng của một mảng trống trong int hoặc chuỗi int |
2 | Dtype Kiểu dữ liệu đầu ra mong muốn. Không bắt buộc |
3 | Order 'C' cho mảng chính hàng kiểu C, 'F' cho mảng cột chính kiểu FORTRAN |
ví dụ 1
# array of five zeros. Default dtype is float
import numpy as np
x = np.zeros(5)
print x
Kết quả như sau:
[ 0. 0. 0. 0. 0.]
Ví dụ 2
import numpy as np
x = np.zeros((5,), dtype = np.int)
print x
Bây giờ, kết quả sẽ như sau:
[0 0 0 0 0]
Ví dụ 3
# custom type
import numpy as np
x = np.zeros((2,2), dtype = [('x', 'i4'), ('y', 'i4')])
print x
Nó sẽ tạo ra kết quả sau:
[[(0,0)(0,0)]
[(0,0)(0,0)]]
numpy.ones
Trả về một mảng mới có kích thước và kiểu được chỉ định, chứa đầy các mảng.
numpy.ones(shape, dtype = None, order = 'C')
Hàm tạo nhận các tham số sau.
Sr.No. | Mô tả về Thông Số |
---|---|
1 | Shape Hình dạng của một mảng trống trong int hoặc tuple int |
2 | Dtype Kiểu dữ liệu đầu ra mong muốn. Không bắt buộc |
3 | Order 'C' cho mảng chính hàng kiểu C, 'F' cho mảng cột chính kiểu FORTRAN |
ví dụ 1
# array of five ones. Default dtype is float
import numpy as np
x = np.ones(5)
print x
Kết quả như sau:
[ 1. 1. 1. 1. 1.]
Ví dụ 2
import numpy as np
x = np.ones([2,2], dtype = int)
print x
Bây giờ, kết quả sẽ như sau:
[[1 1]
[1 1]]
Trong chương này, chúng ta sẽ thảo luận về cách tạo một mảng từ dữ liệu hiện có.
numpy.asarray
Hàm này tương tự như numpy.array ngoại trừ thực tế là nó có ít tham số hơn. Quy trình này rất hữu ích để chuyển đổi chuỗi Python thành ndarray.
numpy.asarray(a, dtype = None, order = None)
Hàm tạo nhận các tham số sau.
Sr.No. | Mô tả về Thông Số |
---|---|
1 | a Nhập dữ liệu ở bất kỳ hình thức nào như danh sách, danh sách các bộ giá trị, bộ giá trị, bộ giá trị hoặc bộ nhiều danh sách |
2 | dtype Theo mặc định, kiểu dữ liệu của dữ liệu đầu vào được áp dụng cho mảng kết quả |
3 | order C (hàng chính) hoặc F (cột chính). C là mặc định |
Các ví dụ sau đây cho thấy cách bạn có thể sử dụng asarray chức năng.
ví dụ 1
# convert list to ndarray
import numpy as np
x = [1,2,3]
a = np.asarray(x)
print a
Đầu ra của nó sẽ như sau:
[1 2 3]
Ví dụ 2
# dtype is set
import numpy as np
x = [1,2,3]
a = np.asarray(x, dtype = float)
print a
Bây giờ, kết quả sẽ như sau:
[ 1. 2. 3.]
Ví dụ 3
# ndarray from tuple
import numpy as np
x = (1,2,3)
a = np.asarray(x)
print a
Đầu ra của nó sẽ là -
[1 2 3]
Ví dụ 4
# ndarray from list of tuples
import numpy as np
x = [(1,2,3),(4,5)]
a = np.asarray(x)
print a
Ở đây, kết quả sẽ như sau:
[(1, 2, 3) (4, 5)]
numpy.frombuffer
Hàm này diễn giải một bộ đệm là một mảng một chiều. Bất kỳ đối tượng nào để lộ giao diện đệm được sử dụng làm tham số để trả vềndarray.
numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
Hàm tạo nhận các tham số sau.
Sr.No. | Mô tả về Thông Số |
---|---|
1 | buffer Bất kỳ đối tượng nào để lộ giao diện bộ đệm |
2 | dtype Kiểu dữ liệu của ndarray trả về. Mặc định là thả nổi |
3 | count Số mục cần đọc, mặc định -1 có nghĩa là tất cả dữ liệu |
4 | offset Vị trí bắt đầu để đọc. Mặc định là 0 |
Thí dụ
Các ví dụ sau đây chứng minh việc sử dụng frombuffer chức năng.
import numpy as np
s = 'Hello World'
a = np.frombuffer(s, dtype = 'S1')
print a
Đây là đầu ra của nó -
['H' 'e' 'l' 'l' 'o' ' ' 'W' 'o' 'r' 'l' 'd']
numpy.fromiter
Chức năng này xây dựng một ndarrayđối tượng từ bất kỳ đối tượng có thể lặp lại nào. Một mảng một chiều mới được trả về bởi hàm này.
numpy.fromiter(iterable, dtype, count = -1)
Ở đây, hàm tạo nhận các tham số sau.
Sr.No. | Mô tả về Thông Số |
---|---|
1 | iterable Mọi đối tượng có thể lặp lại |
2 | dtype Kiểu dữ liệu của mảng kết quả |
3 | count Số lượng các mục được đọc từ trình lặp. Mặc định là -1 có nghĩa là tất cả dữ liệu sẽ được đọc |
Các ví dụ sau đây cho thấy cách sử dụng range()hàm để trả về một đối tượng danh sách. Một trình lặp của danh sách này được sử dụng để tạo thành mộtndarray vật.
ví dụ 1
# create list object using range function
import numpy as np
list = range(5)
print list
Đầu ra của nó như sau:
[0, 1, 2, 3, 4]
Ví dụ 2
# obtain iterator object from list
import numpy as np
list = range(5)
it = iter(list)
# use iterator to create ndarray
x = np.fromiter(it, dtype = float)
print x
Bây giờ, kết quả sẽ như sau:
[0. 1. 2. 3. 4.]
Trong chương này, chúng ta sẽ xem cách tạo một mảng từ các phạm vi số.
numpy.arange
Hàm này trả về một ndarrayđối tượng chứa các giá trị cách đều nhau trong một phạm vi nhất định. Định dạng của hàm như sau:
numpy.arange(start, stop, step, dtype)
Hàm tạo nhận các tham số sau.
Sr.No. | Mô tả về Thông Số |
---|---|
1 | start Bắt đầu của một khoảng thời gian. Nếu bỏ qua, mặc định là 0 |
2 | stop Kết thúc khoảng thời gian (không bao gồm số này) |
3 | step Khoảng cách giữa các giá trị, mặc định là 1 |
4 | dtype Kiểu dữ liệu của ndarray kết quả. Nếu không được cung cấp, kiểu dữ liệu đầu vào sẽ được sử dụng |
Các ví dụ sau đây cho thấy cách bạn có thể sử dụng chức năng này.
ví dụ 1
import numpy as np
x = np.arange(5)
print x
Đầu ra của nó sẽ như sau:
[0 1 2 3 4]
Ví dụ 2
import numpy as np
# dtype set
x = np.arange(5, dtype = float)
print x
Ở đây, đầu ra sẽ là -
[0. 1. 2. 3. 4.]
Ví dụ 3
# start and stop parameters set
import numpy as np
x = np.arange(10,20,2)
print x
Đầu ra của nó như sau:
[10 12 14 16 18]
numpy.linspace
Chức năng này tương tự như arange()chức năng. Trong hàm này, thay vì kích thước bước, số lượng các giá trị cách đều giữa khoảng được chỉ định. Cách sử dụng chức năng này như sau:
numpy.linspace(start, stop, num, endpoint, retstep, dtype)
Hàm tạo nhận các tham số sau.
Sr.No. | Mô tả về Thông Số |
---|---|
1 | start Giá trị bắt đầu của chuỗi |
2 | stop Giá trị cuối của chuỗi, được bao gồm trong chuỗi nếu điểm cuối được đặt thành true |
3 | num Số lượng mẫu cách đều nhau sẽ được tạo ra. Mặc định là 50 |
4 | endpoint Đúng theo mặc định, do đó giá trị dừng được bao gồm trong chuỗi. Nếu sai, nó không được bao gồm |
5 | retstep Nếu đúng, trả về các mẫu và bước giữa các số liên tiếp |
6 | dtype Loại dữ liệu đầu ra ndarray |
Các ví dụ sau đây chứng minh việc sử dụng linspace chức năng.
ví dụ 1
import numpy as np
x = np.linspace(10,20,5)
print x
Đầu ra của nó sẽ là -
[10. 12.5 15. 17.5 20.]
Ví dụ 2
# endpoint set to false
import numpy as np
x = np.linspace(10,20, 5, endpoint = False)
print x
Đầu ra sẽ là -
[10. 12. 14. 16. 18.]
Ví dụ 3
# find retstep value
import numpy as np
x = np.linspace(1,2,5, retstep = True)
print x
# retstep here is 0.25
Bây giờ, đầu ra sẽ là -
(array([ 1. , 1.25, 1.5 , 1.75, 2. ]), 0.25)
numpy.logspace
Hàm này trả về một ndarrayđối tượng chứa các số cách đều nhau trên thang log. Điểm cuối bắt đầu và điểm dừng của thang đo là chỉ số của cơ sở, thường là 10.
numpy.logspace(start, stop, num, endpoint, base, dtype)
Các tham số sau xác định đầu ra của logspace chức năng.
Sr.No. | Mô tả về Thông Số |
---|---|
1 | start Điểm bắt đầu của chuỗi là bắt đầu cơ sở |
2 | stop Giá trị cuối cùng của chuỗi là điểm dừng cơ bản |
3 | num Số lượng giá trị giữa phạm vi. Mặc định là 50 |
4 | endpoint Nếu đúng, dừng là giá trị cuối cùng trong phạm vi |
5 | base Cơ sở của không gian nhật ký, mặc định là 10 |
6 | dtype Kiểu dữ liệu của mảng đầu ra. Nếu không được đưa ra, nó phụ thuộc vào các đối số đầu vào khác |
Các ví dụ sau sẽ giúp bạn hiểu logspace chức năng.
ví dụ 1
import numpy as np
# default base is 10
a = np.logspace(1.0, 2.0, num = 10)
print a
Đầu ra của nó sẽ như sau:
[ 10. 12.91549665 16.68100537 21.5443469 27.82559402
35.93813664 46.41588834 59.94842503 77.42636827 100. ]
Ví dụ 2
# set base of log space to 2
import numpy as np
a = np.logspace(1,10,num = 10, base = 2)
print a
Bây giờ, đầu ra sẽ là -
[ 2. 4. 8. 16. 32. 64. 128. 256. 512. 1024.]
Nội dung của đối tượng ndarray có thể được truy cập và sửa đổi bằng cách lập chỉ mục hoặc cắt, giống như các đối tượng chứa trong Python.
Như đã đề cập trước đó, các mục trong đối tượng ndarray tuân theo chỉ mục dựa trên số không. Có ba loại phương pháp lập chỉ mục:field access, basic slicing và advanced indexing.
Cắt lát cơ bản là một phần mở rộng của khái niệm cơ bản của Python về cắt thành n chiều. Một đối tượng lát trong Python được xây dựng bằng cách chostart, stopvà step tham số tích hợp slicechức năng. Đối tượng lát cắt này được chuyển đến mảng để trích xuất một phần của mảng.
ví dụ 1
import numpy as np
a = np.arange(10)
s = slice(2,7,2)
print a[s]
Đầu ra của nó như sau:
[2 4 6]
Trong ví dụ trên, một ndarray đối tượng được chuẩn bị bởi arange()chức năng. Sau đó, một đối tượng lát cắt được xác định với các giá trị bắt đầu, dừng và bước tương ứng là 2, 7 và 2. Khi đối tượng lát cắt này được chuyển đến ndarray, một phần của nó bắt đầu với chỉ số 2 đến 7 với bước 2 được cắt.
Kết quả tương tự cũng có thể đạt được bằng cách đưa các tham số cắt phân tách bằng dấu hai chấm: (start: stop: step) trực tiếp đến ndarray vật.
Ví dụ 2
import numpy as np
a = np.arange(10)
b = a[2:7:2]
print b
Ở đây, chúng ta sẽ nhận được cùng một đầu ra -
[2 4 6]
Nếu chỉ đặt một tham số, một mục tương ứng với chỉ mục sẽ được trả về. Nếu một: được chèn trước nó, tất cả các mục từ chỉ mục đó trở đi sẽ được trích xuất. Nếu hai tham số (với: giữa chúng) được sử dụng, các mục giữa hai chỉ mục (không bao gồm chỉ mục dừng) với bước một mặc định sẽ được cắt.
Ví dụ 3
# slice single item
import numpy as np
a = np.arange(10)
b = a[5]
print b
Đầu ra của nó như sau:
5
Ví dụ 4
# slice items starting from index
import numpy as np
a = np.arange(10)
print a[2:]
Bây giờ, đầu ra sẽ là -
[2 3 4 5 6 7 8 9]
Ví dụ 5
# slice items between indexes
import numpy as np
a = np.arange(10)
print a[2:5]
Ở đây, đầu ra sẽ là -
[2 3 4]
Mô tả trên áp dụng cho đa chiều ndarray quá.
Ví dụ 6
import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print a
# slice items starting from index
print 'Now we will slice the array from the index a[1:]'
print a[1:]
Kết quả như sau:
[[1 2 3]
[3 4 5]
[4 5 6]]
Now we will slice the array from the index a[1:]
[[3 4 5]
[4 5 6]]
Slicing cũng có thể bao gồm dấu chấm lửng (…) để tạo một bộ lựa chọn có cùng độ dài với kích thước của một mảng. Nếu sử dụng dấu chấm lửng ở vị trí hàng, nó sẽ trả về một mảng ndarray bao gồm các mục trong hàng.
Ví dụ 7
# array to begin with
import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print 'Our array is:'
print a
print '\n'
# this returns array of items in the second column
print 'The items in the second column are:'
print a[...,1]
print '\n'
# Now we will slice all items from the second row
print 'The items in the second row are:'
print a[1,...]
print '\n'
# Now we will slice all items from column 1 onwards
print 'The items column 1 onwards are:'
print a[...,1:]
Kết quả của chương trình này như sau:
Our array is:
[[1 2 3]
[3 4 5]
[4 5 6]]
The items in the second column are:
[2 4 5]
The items in the second row are:
[3 4 5]
The items column 1 onwards are:
[[2 3]
[4 5]
[5 6]]
Có thể thực hiện lựa chọn từ ndarray là một chuỗi không phải tuple, đối tượng ndarray kiểu dữ liệu số nguyên hoặc Boolean, hoặc một bộ dữ liệu có ít nhất một mục là đối tượng chuỗi. Lập chỉ mục nâng cao luôn trả về một bản sao của dữ liệu. Ngược lại, việc cắt chỉ hiển thị một khung nhìn.
Có hai loại lập chỉ mục nâng cao - Integer và Boolean.
Lập chỉ mục số nguyên
Cơ chế này giúp chọn bất kỳ mục tùy ý nào trong một mảng dựa trên chỉ mục N chiều của nó. Mỗi mảng số nguyên đại diện cho số chỉ mục trong thứ nguyên đó. Khi chỉ mục bao gồm nhiều mảng số nguyên như kích thước của mảng đích, nó sẽ trở nên đơn giản.
Trong ví dụ sau, một phần tử của cột được chỉ định từ mỗi hàng của đối tượng ndarray được chọn. Do đó, chỉ mục hàng chứa tất cả các số hàng và chỉ mục cột chỉ định phần tử được chọn.
ví dụ 1
import numpy as np
x = np.array([[1, 2], [3, 4], [5, 6]])
y = x[[0,1,2], [0,1,0]]
print y
Đầu ra của nó sẽ như sau:
[1 4 5]
Vùng chọn bao gồm các phần tử tại (0,0), (1,1) và (2,0) từ mảng đầu tiên.
Trong ví dụ sau, các phần tử đặt ở các góc của mảng 4X3 được chọn. Các chỉ số lựa chọn hàng là [0, 0] và [3,3] trong khi các chỉ số cột là [0,2] và [0,2].
Ví dụ 2
import numpy as np
x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])
print 'Our array is:'
print x
print '\n'
rows = np.array([[0,0],[3,3]])
cols = np.array([[0,2],[0,2]])
y = x[rows,cols]
print 'The corner elements of this array are:'
print y
Kết quả của chương trình này như sau:
Our array is:
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
The corner elements of this array are:
[[ 0 2]
[ 9 11]]
Lựa chọn kết quả là một đối tượng ndarray chứa các phần tử góc.
Lập chỉ mục nâng cao và cơ bản có thể được kết hợp bằng cách sử dụng một lát cắt (:) hoặc dấu chấm lửng (…) với một mảng chỉ mục. Ví dụ sau sử dụng lát cắt cho hàng và chỉ mục nâng cao cho cột. Kết quả là như nhau khi lát cắt được sử dụng cho cả hai. Nhưng chỉ mục nâng cao dẫn đến sao chép và có thể có bố cục bộ nhớ khác nhau.
Ví dụ 3
import numpy as np
x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])
print 'Our array is:'
print x
print '\n'
# slicing
z = x[1:4,1:3]
print 'After slicing, our array becomes:'
print z
print '\n'
# using advanced index for column
y = x[1:4,[1,2]]
print 'Slicing using advanced index for column:'
print y
Kết quả của chương trình này sẽ như sau:
Our array is:
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
After slicing, our array becomes:
[[ 4 5]
[ 7 8]
[10 11]]
Slicing using advanced index for column:
[[ 4 5]
[ 7 8]
[10 11]]
Lập chỉ mục mảng Boolean
Loại lập chỉ mục nâng cao này được sử dụng khi đối tượng kết quả có nghĩa là kết quả của các phép toán Boolean, chẳng hạn như toán tử so sánh.
ví dụ 1
Trong ví dụ này, các mục lớn hơn 5 được trả về do lập chỉ mục Boolean.
import numpy as np
x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])
print 'Our array is:'
print x
print '\n'
# Now we will print the items greater than 5
print 'The items greater than 5 are:'
print x[x > 5]
Đầu ra của chương trình này sẽ là:
Our array is:
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
The items greater than 5 are:
[ 6 7 8 9 10 11]
Ví dụ 2
Trong ví dụ này, các phần tử NaN (Không phải là Số) được bỏ qua bằng cách sử dụng ~ (toán tử bổ sung).
import numpy as np
a = np.array([np.nan, 1,2,np.nan,3,4,5])
print a[~np.isnan(a)]
Đầu ra của nó sẽ là -
[ 1. 2. 3. 4. 5.]
Ví dụ 3
Ví dụ sau đây cho thấy cách lọc ra các phần tử không phức tạp khỏi một mảng.
import numpy as np
a = np.array([1, 2+6j, 5, 3.5+5j])
print a[np.iscomplex(a)]
Ở đây, kết quả như sau:
[2.0+6.j 3.5+5.j]
Thời hạn broadcastingđề cập đến khả năng của NumPy để xử lý các mảng có hình dạng khác nhau trong các phép toán số học. Các phép toán số học trên mảng thường được thực hiện trên các phần tử tương ứng. Nếu hai mảng có hình dạng hoàn toàn giống nhau thì các phép toán này được thực hiện trơn tru.
ví dụ 1
import numpy as np
a = np.array([1,2,3,4])
b = np.array([10,20,30,40])
c = a * b
print c
Đầu ra của nó như sau:
[10 40 90 160]
Nếu kích thước của hai mảng không giống nhau, thì không thể thực hiện được các phép toán giữa phần tử. Tuy nhiên, các thao tác trên các mảng có hình dạng không giống nhau vẫn có thể thực hiện được trong NumPy, vì khả năng phát sóng. Mảng nhỏ hơn làbroadcast với kích thước của mảng lớn hơn để chúng có hình dạng tương thích.
Có thể phát sóng nếu các quy tắc sau được thỏa mãn:
Mảng với nhỏ hơn ndim hơn cái còn lại được thêm chữ '1' trong hình dạng của nó.
Kích thước trong mỗi kích thước của hình dạng đầu ra là tối đa của kích thước đầu vào trong kích thước đó.
Một đầu vào có thể được sử dụng trong tính toán, nếu kích thước của nó trong một thứ nguyên cụ thể khớp với kích thước đầu ra hoặc giá trị của nó chính xác là 1.
Nếu đầu vào có kích thước thứ nguyên là 1, thì mục nhập dữ liệu đầu tiên trong thứ nguyên đó sẽ được sử dụng cho tất cả các phép tính dọc theo thứ nguyên đó.
Một tập hợp các mảng được cho là broadcastable nếu các quy tắc trên tạo ra kết quả hợp lệ và một trong những điều sau là đúng:
Các mảng có hình dạng giống hệt nhau.
Mảng có cùng số thứ nguyên và độ dài của mỗi thứ nguyên là độ dài chung hoặc 1.
Mảng có quá ít kích thước có thể có hình dạng của nó được thêm vào trước với kích thước có độ dài 1, do đó thuộc tính đã nêu ở trên là đúng.
Chương trình sau đây cho thấy một ví dụ về phát sóng.
Ví dụ 2
import numpy as np
a = np.array([[0.0,0.0,0.0],[10.0,10.0,10.0],[20.0,20.0,20.0],[30.0,30.0,30.0]])
b = np.array([1.0,2.0,3.0])
print 'First array:'
print a
print '\n'
print 'Second array:'
print b
print '\n'
print 'First Array + Second Array'
print a + b
Kết quả của chương trình này sẽ như sau:
First array:
[[ 0. 0. 0.]
[ 10. 10. 10.]
[ 20. 20. 20.]
[ 30. 30. 30.]]
Second array:
[ 1. 2. 3.]
First Array + Second Array
[[ 1. 2. 3.]
[ 11. 12. 13.]
[ 21. 22. 23.]
[ 31. 32. 33.]]
Hình sau minh họa cách mảng b được phát sóng để tương thích với a.
Gói NumPy chứa một đối tượng vòng lặp numpy.nditer. Nó là một đối tượng trình vòng lặp đa chiều hiệu quả bằng cách sử dụng nó có thể lặp lại trên một mảng. Mỗi phần tử của một mảng được truy cập bằng giao diện Iterator tiêu chuẩn của Python.
Hãy để chúng tôi tạo một mảng 3X4 bằng cách sử dụng hàm arange () và lặp lại nó bằng cách sử dụng nditer.
ví dụ 1
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print 'Original array is:'
print a
print '\n'
print 'Modified array is:'
for x in np.nditer(a):
print x,
Kết quả của chương trình này như sau:
Original array is:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
Modified array is:
0 5 10 15 20 25 30 35 40 45 50 55
Ví dụ 2
Thứ tự lặp được chọn để phù hợp với bố cục bộ nhớ của một mảng mà không cần xem xét một thứ tự cụ thể. Điều này có thể được nhìn thấy bằng cách lặp lại chuyển vị của mảng trên.
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print 'Original array is:'
print a
print '\n'
print 'Transpose of the original array is:'
b = a.T
print b
print '\n'
print 'Modified array is:'
for x in np.nditer(b):
print x,
Kết quả của chương trình trên như sau:
Original array is:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
Transpose of the original array is:
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
Modified array is:
0 5 10 15 20 25 30 35 40 45 50 55
Thứ tự lặp lại
Nếu các phần tử giống nhau được lưu trữ bằng cách sử dụng thứ tự kiểu F, trình vòng lặp sẽ chọn cách hiệu quả hơn để lặp qua một mảng.
ví dụ 1
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print 'Original array is:'
print a
print '\n'
print 'Transpose of the original array is:'
b = a.T
print b
print '\n'
print 'Sorted in C-style order:'
c = b.copy(order='C')
print c
for x in np.nditer(c):
print x,
print '\n'
print 'Sorted in F-style order:'
c = b.copy(order='F')
print c
for x in np.nditer(c):
print x,
Đầu ra của nó sẽ như sau:
Original array is:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
Transpose of the original array is:
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
Sorted in C-style order:
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
0 20 40 5 25 45 10 30 50 15 35 55
Sorted in F-style order:
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
0 5 10 15 20 25 30 35 40 45 50 55
Ví dụ 2
Có thể buộc nditer đối tượng sử dụng một thứ tự cụ thể bằng cách đề cập rõ ràng đến nó.
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print 'Original array is:'
print a
print '\n'
print 'Sorted in C-style order:'
for x in np.nditer(a, order = 'C'):
print x,
print '\n'
print 'Sorted in F-style order:'
for x in np.nditer(a, order = 'F'):
print x,
Đầu ra của nó sẽ là -
Original array is:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
Sorted in C-style order:
0 5 10 15 20 25 30 35 40 45 50 55
Sorted in F-style order:
0 20 40 5 25 45 10 30 50 15 35 55
Sửa đổi giá trị mảng
Các nditer đối tượng có một tham số tùy chọn khác được gọi là op_flags. Giá trị mặc định của nó là chỉ đọc, nhưng có thể được đặt ở chế độ chỉ đọc-ghi hoặc chỉ ghi. Điều này sẽ cho phép sửa đổi các phần tử mảng bằng cách sử dụng trình lặp này.
Thí dụ
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print 'Original array is:'
print a
print '\n'
for x in np.nditer(a, op_flags = ['readwrite']):
x[...] = 2*x
print 'Modified array is:'
print a
Đầu ra của nó như sau:
Original array is:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
Modified array is:
[[ 0 10 20 30]
[ 40 50 60 70]
[ 80 90 100 110]]
Vòng lặp bên ngoài
Hàm tạo lớp nditer có ‘flags’ , có thể nhận các giá trị sau:
Sr.No. | Mô tả về Thông Số |
---|---|
1 | c_index Chỉ mục C_order có thể được theo dõi |
2 | f_index Chỉ mục Fortran_order được theo dõi |
3 | multi-index Có thể theo dõi loại chỉ mục với một chỉ mục mỗi lần lặp lại |
4 | external_loop Khiến các giá trị được cung cấp là mảng một chiều có nhiều giá trị thay vì mảng không chiều |
Thí dụ
Trong ví dụ sau, mảng một chiều tương ứng với mỗi cột được duyệt qua bởi trình vòng lặp.
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print 'Original array is:'
print a
print '\n'
print 'Modified array is:'
for x in np.nditer(a, flags = ['external_loop'], order = 'F'):
print x,
Kết quả như sau:
Original array is:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
Modified array is:
[ 0 20 40] [ 5 25 45] [10 30 50] [15 35 55]
Lặp lại phát sóng
Nếu hai mảng là broadcastable, một kết hợp nditerđối tượng có thể lặp lại chúng đồng thời. Giả sử rằng một mảnga có thứ nguyên 3X4 và có một mảng khác b của kích thước 1X4, trình lặp kiểu sau được sử dụng (mảng b được phát tới kích thước của a).
Thí dụ
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print 'First array is:'
print a
print '\n'
print 'Second array is:'
b = np.array([1, 2, 3, 4], dtype = int)
print b
print '\n'
print 'Modified array is:'
for x,y in np.nditer([a,b]):
print "%d:%d" % (x,y),
Đầu ra của nó sẽ như sau:
First array is:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
Second array is:
[1 2 3 4]
Modified array is:
0:1 5:2 10:3 15:4 20:1 25:2 30:3 35:4 40:1 45:2 50:3 55:4
Một số quy trình có sẵn trong gói NumPy để thao tác với các phần tử trong đối tượng ndarray. Chúng có thể được phân loại thành các loại sau:
Thay đổi hình dạng
Sr.No. | Hình dạng & Mô tả |
---|---|
1 | định hình lại Cung cấp một hình dạng mới cho một mảng mà không thay đổi dữ liệu của nó |
2 | bằng phẳng Trình lặp 1-D trên mảng |
3 | làm phẳng Trả về bản sao của mảng được thu gọn thành một thứ nguyên |
4 | nói ravel Trả về một mảng phẳng liền kề |
Hoạt động Transpose
Sr.No. | Hoạt động Mô tả |
---|---|
1 | đổi chỗ Hoán vị các kích thước của một mảng |
2 | ndarray.T Giống như self.transpose () |
3 | cuộnaxis Cuộn trục đã chỉ định về phía sau |
4 | hoán đổi Thay đổi hai trục của một mảng |
Thay đổi kích thước
Sr.No. | Kích thước & Mô tả |
---|---|
1 | phát sóng Tạo một đối tượng bắt chước phát sóng |
2 | broadcast_to Truyền một mảng đến một hình dạng mới |
3 | expand_dims Mở rộng hình dạng của một mảng |
4 | vắt kiệt Loại bỏ các mục nhập một chiều khỏi hình dạng của một mảng |
Tham gia Mảng
Sr.No. | Mảng & Mô tả |
---|---|
1 | ghép lại Nối một chuỗi các mảng dọc theo một trục hiện có |
2 | cây rơm Nối một chuỗi các mảng dọc theo một trục mới |
3 | bao Xếp các mảng theo trình tự theo chiều ngang (theo cột khôn ngoan) |
4 | vstack Xếp các mảng theo trình tự theo chiều dọc (theo hàng khôn ngoan) |
Tách mảng
Sr.No. | Mảng & Mô tả |
---|---|
1 | tách ra Tách một mảng thành nhiều mảng con |
2 | hsplit Tách một mảng thành nhiều mảng con theo chiều ngang (theo cột) |
3 | vsplit Tách một mảng thành nhiều mảng con theo chiều dọc (theo hàng) |
Thêm / Xóa các phần tử
Sr.No. | Yếu tố & Mô tả |
---|---|
1 | thay đổi kích thước Trả về một mảng mới với hình dạng được chỉ định |
2 | nối thêm Nối các giá trị vào cuối một mảng |
3 | chèn Chèn các giá trị dọc theo trục đã cho trước các chỉ số đã cho |
4 | xóa bỏ Trả về một mảng mới với các mảng con dọc theo trục đã bị xóa |
5 | độc nhất Tìm các phần tử duy nhất của một mảng |
Sau đây là các chức năng cho các hoạt động bitwise có sẵn trong gói NumPy.
Sr.No. | Hoạt động Mô tả |
---|---|
1 | bitwise_and Tính toán bitwise AND hoạt động của các phần tử mảng |
2 | bitwise_or Tính toán hoạt động theo bitwise OR của các phần tử mảng |
3 | đảo ngược Tính toán theo bitwise KHÔNG |
4 | dịch trái Dịch chuyển các bit của biểu diễn nhị phân sang trái |
5 | right_shift Dịch chuyển các bit của biểu diễn nhị phân sang phải |
Các hàm sau đây được sử dụng để thực hiện các hoạt động chuỗi được vector hóa cho các mảng kiểu dtype numpy.string_ hoặc numpy.unicode_. Chúng dựa trên các hàm chuỗi tiêu chuẩn trong thư viện tích hợp sẵn của Python.
Sr.No. | Mô tả chức năng |
---|---|
1 | thêm vào() Trả về nối chuỗi phần tử khôn ngoan cho hai mảng str hoặc Unicode |
2 | nhân() Trả về chuỗi có nhiều nối, có phần tử khôn ngoan |
3 | trung tâm() Trả về bản sao của chuỗi đã cho với các phần tử được căn giữa trong chuỗi có độ dài được chỉ định |
4 | viết hoa () Trả về bản sao của chuỗi chỉ có ký tự đầu tiên được viết hoa |
5 | tiêu đề() Trả về phiên bản dựa trên tiêu đề thông thường của phần tử của chuỗi hoặc unicode |
6 | thấp hơn() Trả về một mảng có các phần tử được chuyển đổi thành chữ thường |
7 | phía trên() Trả về một mảng có các phần tử được chuyển đổi thành chữ hoa |
số 8 | tách () Trả về danh sách các từ trong chuỗi, sử dụng dấu phân tách |
9 | đường chia () Trả về danh sách các dòng trong phần tử, ngắt ở ranh giới dòng |
10 | dải () Trả lại một bản sao đã xóa các ký tự đầu và cuối |
11 | tham gia() Trả về một chuỗi là sự nối các chuỗi trong chuỗi |
12 | thay thế() Trả về bản sao của chuỗi với tất cả các lần xuất hiện của chuỗi con được thay thế bằng chuỗi mới |
13 | giải mã () Gọi str.decode phần tử khôn ngoan |
14 | mã hóa () Cuộc gọi str.encode phần tử khôn ngoan |
Các hàm này được định nghĩa trong lớp mảng ký tự (numpy.char). Gói Numarray cũ hơn chứa lớp chararray. Các hàm trên trong lớp numpy.char rất hữu ích trong việc thực hiện các hoạt động chuỗi được vector hóa.
Nói một cách dễ hiểu, NumPy chứa một số lượng lớn các phép toán khác nhau. NumPy cung cấp các hàm lượng giác tiêu chuẩn, các hàm cho các phép toán số học, xử lý số phức, v.v.
Hàm lượng giác
NumPy có các hàm lượng giác tiêu chuẩn trả về tỷ số lượng giác cho một góc nhất định tính bằng radian.
Example
import numpy as np
a = np.array([0,30,45,60,90])
print 'Sine of different angles:'
# Convert to radians by multiplying with pi/180
print np.sin(a*np.pi/180)
print '\n'
print 'Cosine values for angles in array:'
print np.cos(a*np.pi/180)
print '\n'
print 'Tangent values for given angles:'
print np.tan(a*np.pi/180)
Đây là đầu ra của nó -
Sine of different angles:
[ 0. 0.5 0.70710678 0.8660254 1. ]
Cosine values for angles in array:
[ 1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01
6.12323400e-17]
Tangent values for given angles:
[ 0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00
1.63312394e+16]
arcsin, arcos, và arctancác hàm trả về nghịch đảo lượng giác của sin, cos và tan của góc đã cho. Kết quả của các chức năng này có thể được xác minh bởinumpy.degrees() function bằng cách chuyển đổi radian sang độ.
Example
import numpy as np
a = np.array([0,30,45,60,90])
print 'Array containing sine values:'
sin = np.sin(a*np.pi/180)
print sin
print '\n'
print 'Compute sine inverse of angles. Returned values are in radians.'
inv = np.arcsin(sin)
print inv
print '\n'
print 'Check result by converting to degrees:'
print np.degrees(inv)
print '\n'
print 'arccos and arctan functions behave similarly:'
cos = np.cos(a*np.pi/180)
print cos
print '\n'
print 'Inverse of cos:'
inv = np.arccos(cos)
print inv
print '\n'
print 'In degrees:'
print np.degrees(inv)
print '\n'
print 'Tan function:'
tan = np.tan(a*np.pi/180)
print tan
print '\n'
print 'Inverse of tan:'
inv = np.arctan(tan)
print inv
print '\n'
print 'In degrees:'
print np.degrees(inv)
Đầu ra của nó như sau:
Array containing sine values:
[ 0. 0.5 0.70710678 0.8660254 1. ]
Compute sine inverse of angles. Returned values are in radians.
[ 0. 0.52359878 0.78539816 1.04719755 1.57079633]
Check result by converting to degrees:
[ 0. 30. 45. 60. 90.]
arccos and arctan functions behave similarly:
[ 1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01
6.12323400e-17]
Inverse of cos:
[ 0. 0.52359878 0.78539816 1.04719755 1.57079633]
In degrees:
[ 0. 30. 45. 60. 90.]
Tan function:
[ 0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00
1.63312394e+16]
Inverse of tan:
[ 0. 0.52359878 0.78539816 1.04719755 1.57079633]
In degrees:
[ 0. 30. 45. 60. 90.]
Các hàm để làm tròn
numpy.around ()
Đây là một hàm trả về giá trị được làm tròn đến độ chính xác mong muốn. Hàm nhận các tham số sau.
numpy.around(a,decimals)
Ở đâu,
Sr.No. | Mô tả về Thông Số |
---|---|
1 | a Dữ liệu đầu vào |
2 | decimals Số số thập phân làm tròn đến. Mặc định là 0. Nếu âm, số nguyên được làm tròn đến vị trí bên trái của dấu thập phân |
Example
import numpy as np
a = np.array([1.0,5.55, 123, 0.567, 25.532])
print 'Original array:'
print a
print '\n'
print 'After rounding:'
print np.around(a)
print np.around(a, decimals = 1)
print np.around(a, decimals = -1)
Nó tạo ra kết quả sau:
Original array:
[ 1. 5.55 123. 0.567 25.532]
After rounding:
[ 1. 6. 123. 1. 26. ]
[ 1. 5.6 123. 0.6 25.5]
[ 0. 10. 120. 0. 30. ]
numpy.floor ()
Hàm này trả về số nguyên lớn nhất không lớn hơn tham số đầu vào. Sàn củascalar x là cái lớn nhất integer i, như vậy mà i <= x. Lưu ý rằng trong Python, ván sàn luôn được làm tròn từ 0.
Example
import numpy as np
a = np.array([-1.7, 1.5, -0.2, 0.6, 10])
print 'The given array:'
print a
print '\n'
print 'The modified array:'
print np.floor(a)
Nó tạo ra kết quả sau:
The given array:
[ -1.7 1.5 -0.2 0.6 10. ]
The modified array:
[ -2. 1. -1. 0. 10.]
numpy.ceil ()
Hàm ceil () trả về giá trị trần của giá trị đầu vào, tức là giá trị scalar x Là nhỏ nhất integer i, như vậy mà i >= x.
Example
import numpy as np
a = np.array([-1.7, 1.5, -0.2, 0.6, 10])
print 'The given array:'
print a
print '\n'
print 'The modified array:'
print np.ceil(a)
Nó sẽ tạo ra kết quả sau:
The given array:
[ -1.7 1.5 -0.2 0.6 10. ]
The modified array:
[ -1. 2. -0. 1. 10.]
Các mảng đầu vào để thực hiện các phép toán số học như cộng (), trừ (), nhân () và chia () phải có cùng hình dạng hoặc phải tuân theo quy tắc phát mảng.
Thí dụ
import numpy as np
a = np.arange(9, dtype = np.float_).reshape(3,3)
print 'First array:'
print a
print '\n'
print 'Second array:'
b = np.array([10,10,10])
print b
print '\n'
print 'Add the two arrays:'
print np.add(a,b)
print '\n'
print 'Subtract the two arrays:'
print np.subtract(a,b)
print '\n'
print 'Multiply the two arrays:'
print np.multiply(a,b)
print '\n'
print 'Divide the two arrays:'
print np.divide(a,b)
Nó sẽ tạo ra kết quả sau:
First array:
[[ 0. 1. 2.]
[ 3. 4. 5.]
[ 6. 7. 8.]]
Second array:
[10 10 10]
Add the two arrays:
[[ 10. 11. 12.]
[ 13. 14. 15.]
[ 16. 17. 18.]]
Subtract the two arrays:
[[-10. -9. -8.]
[ -7. -6. -5.]
[ -4. -3. -2.]]
Multiply the two arrays:
[[ 0. 10. 20.]
[ 30. 40. 50.]
[ 60. 70. 80.]]
Divide the two arrays:
[[ 0. 0.1 0.2]
[ 0.3 0.4 0.5]
[ 0.6 0.7 0.8]]
Bây giờ chúng ta hãy thảo luận về một số hàm số học quan trọng khác có sẵn trong NumPy.
numpy.reciprocal ()
Hàm này trả về nghịch đảo của đối số, theo phần tử. Đối với các phần tử có giá trị tuyệt đối lớn hơn 1, kết quả luôn là 0 do cách Python xử lý phép chia số nguyên. Đối với số nguyên 0, cảnh báo tràn được đưa ra.
Thí dụ
import numpy as np
a = np.array([0.25, 1.33, 1, 0, 100])
print 'Our array is:'
print a
print '\n'
print 'After applying reciprocal function:'
print np.reciprocal(a)
print '\n'
b = np.array([100], dtype = int)
print 'The second array is:'
print b
print '\n'
print 'After applying reciprocal function:'
print np.reciprocal(b)
Nó sẽ tạo ra kết quả sau:
Our array is:
[ 0.25 1.33 1. 0. 100. ]
After applying reciprocal function:
main.py:9: RuntimeWarning: divide by zero encountered in reciprocal
print np.reciprocal(a)
[ 4. 0.7518797 1. inf 0.01 ]
The second array is:
[100]
After applying reciprocal function:
[0]
numpy.power ()
Hàm này coi các phần tử trong mảng đầu vào đầu tiên là cơ sở và trả về giá trị của nó được nâng lên thành lũy thừa của phần tử tương ứng trong mảng đầu vào thứ hai.
import numpy as np
a = np.array([10,100,1000])
print 'Our array is:'
print a
print '\n'
print 'Applying power function:'
print np.power(a,2)
print '\n'
print 'Second array:'
b = np.array([1,2,3])
print b
print '\n'
print 'Applying power function again:'
print np.power(a,b)
Nó sẽ tạo ra kết quả sau:
Our array is:
[ 10 100 1000]
Applying power function:
[ 100 10000 1000000]
Second array:
[1 2 3]
Applying power function again:
[ 10 10000 1000000000]
numpy.mod ()
Hàm này trả về phần còn lại của phép chia của các phần tử tương ứng trong mảng đầu vào. Chức năngnumpy.remainder() cũng tạo ra kết quả tương tự.
import numpy as np
a = np.array([10,20,30])
b = np.array([3,5,7])
print 'First array:'
print a
print '\n'
print 'Second array:'
print b
print '\n'
print 'Applying mod() function:'
print np.mod(a,b)
print '\n'
print 'Applying remainder() function:'
print np.remainder(a,b)
Nó sẽ tạo ra kết quả sau:
First array:
[10 20 30]
Second array:
[3 5 7]
Applying mod() function:
[1 0 2]
Applying remainder() function:
[1 0 2]
Các hàm sau được sử dụng để thực hiện các phép toán trên mảng với số phức.
numpy.real() - trả về phần thực của đối số kiểu dữ liệu phức tạp.
numpy.imag() - trả về phần ảo của đối số kiểu dữ liệu phức tạp.
numpy.conj() - trả về liên hợp phức, có được bằng cách thay đổi dấu của phần ảo.
numpy.angle()- trả về góc của đối số phức tạp. Hàm có tham số độ. Nếu đúng, góc tính bằng độ được trả về, ngược lại góc tính bằng radian.
import numpy as np
a = np.array([-5.6j, 0.2j, 11. , 1+1j])
print 'Our array is:'
print a
print '\n'
print 'Applying real() function:'
print np.real(a)
print '\n'
print 'Applying imag() function:'
print np.imag(a)
print '\n'
print 'Applying conj() function:'
print np.conj(a)
print '\n'
print 'Applying angle() function:'
print np.angle(a)
print '\n'
print 'Applying angle() function again (result in degrees)'
print np.angle(a, deg = True)
Nó sẽ tạo ra kết quả sau:
Our array is:
[ 0.-5.6j 0.+0.2j 11.+0.j 1.+1.j ]
Applying real() function:
[ 0. 0. 11. 1.]
Applying imag() function:
[-5.6 0.2 0. 1. ]
Applying conj() function:
[ 0.+5.6j 0.-0.2j 11.-0.j 1.-1.j ]
Applying angle() function:
[-1.57079633 1.57079633 0. 0.78539816]
Applying angle() function again (result in degrees)
[-90. 90. 0. 45.]
NumPy có một số hàm thống kê hữu ích để tìm độ lệch chuẩn và phương sai tối thiểu, tối đa, phần trăm, v.v. từ các phần tử đã cho trong mảng. Các chức năng được giải thích như sau:
numpy.amin () và numpy.amax ()
Các hàm này trả về giá trị nhỏ nhất và giá trị lớn nhất từ các phần tử trong mảng đã cho dọc theo trục được chỉ định.
Thí dụ
import numpy as np
a = np.array([[3,7,5],[8,4,3],[2,4,9]])
print 'Our array is:'
print a
print '\n'
print 'Applying amin() function:'
print np.amin(a,1)
print '\n'
print 'Applying amin() function again:'
print np.amin(a,0)
print '\n'
print 'Applying amax() function:'
print np.amax(a)
print '\n'
print 'Applying amax() function again:'
print np.amax(a, axis = 0)
Nó sẽ tạo ra kết quả sau:
Our array is:
[[3 7 5]
[8 4 3]
[2 4 9]]
Applying amin() function:
[3 3 2]
Applying amin() function again:
[2 4 3]
Applying amax() function:
9
Applying amax() function again:
[8 7 9]
numpy.ptp ()
Các numpy.ptp() hàm trả về phạm vi (tối đa-tối thiểu) của các giá trị dọc theo trục.
import numpy as np
a = np.array([[3,7,5],[8,4,3],[2,4,9]])
print 'Our array is:'
print a
print '\n'
print 'Applying ptp() function:'
print np.ptp(a)
print '\n'
print 'Applying ptp() function along axis 1:'
print np.ptp(a, axis = 1)
print '\n'
print 'Applying ptp() function along axis 0:'
print np.ptp(a, axis = 0)
Nó sẽ tạo ra kết quả sau:
Our array is:
[[3 7 5]
[8 4 3]
[2 4 9]]
Applying ptp() function:
7
Applying ptp() function along axis 1:
[4 5 7]
Applying ptp() function along axis 0:
[6 3 6]
numpy.percentile ()
Phần trăm (hoặc một phần trăm) là một thước đo được sử dụng trong thống kê cho biết giá trị mà dưới đó một tỷ lệ phần trăm quan sát nhất định trong một nhóm quan sát giảm xuống. Chức năngnumpy.percentile() lấy các đối số sau đây.
numpy.percentile(a, q, axis)
Ở đâu,
Sr.No. | Lập luận & Mô tả |
---|---|
1 | a Mảng đầu vào |
2 | q Phân vị để tính toán phải từ 0-100 |
3 | axis Trục dọc theo phân vị sẽ được tính |
Thí dụ
import numpy as np
a = np.array([[30,40,70],[80,20,10],[50,90,60]])
print 'Our array is:'
print a
print '\n'
print 'Applying percentile() function:'
print np.percentile(a,50)
print '\n'
print 'Applying percentile() function along axis 1:'
print np.percentile(a,50, axis = 1)
print '\n'
print 'Applying percentile() function along axis 0:'
print np.percentile(a,50, axis = 0)
Nó sẽ tạo ra kết quả sau:
Our array is:
[[30 40 70]
[80 20 10]
[50 90 60]]
Applying percentile() function:
50.0
Applying percentile() function along axis 1:
[ 40. 20. 60.]
Applying percentile() function along axis 0:
[ 50. 40. 60.]
numpy.median ()
Medianđược định nghĩa là giá trị phân tách nửa cao hơn của mẫu dữ liệu với nửa dưới. Cácnumpy.median() được sử dụng như trong chương trình sau.
Thí dụ
import numpy as np
a = np.array([[30,65,70],[80,95,10],[50,90,60]])
print 'Our array is:'
print a
print '\n'
print 'Applying median() function:'
print np.median(a)
print '\n'
print 'Applying median() function along axis 0:'
print np.median(a, axis = 0)
print '\n'
print 'Applying median() function along axis 1:'
print np.median(a, axis = 1)
Nó sẽ tạo ra kết quả sau:
Our array is:
[[30 65 70]
[80 95 10]
[50 90 60]]
Applying median() function:
65.0
Applying median() function along axis 0:
[ 50. 90. 60.]
Applying median() function along axis 1:
[ 65. 80. 60.]
numpy.mean ()
Trung bình số học là tổng các phần tử dọc theo một trục chia cho số phần tử. Cácnumpy.mean()hàm trả về giá trị trung bình cộng của các phần tử trong mảng. Nếu trục được đề cập, nó được tính toán dọc theo nó.
Thí dụ
import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print 'Our array is:'
print a
print '\n'
print 'Applying mean() function:'
print np.mean(a)
print '\n'
print 'Applying mean() function along axis 0:'
print np.mean(a, axis = 0)
print '\n'
print 'Applying mean() function along axis 1:'
print np.mean(a, axis = 1)
Nó sẽ tạo ra kết quả sau:
Our array is:
[[1 2 3]
[3 4 5]
[4 5 6]]
Applying mean() function:
3.66666666667
Applying mean() function along axis 0:
[ 2.66666667 3.66666667 4.66666667]
Applying mean() function along axis 1:
[ 2. 4. 5.]
numpy.average ()
Bình quân gia quyền là giá trị trung bình do nhân của mỗi thành phần với một yếu tố phản ánh tầm quan trọng của nó. Cácnumpy.average()hàm tính toán trung bình có trọng số của các phần tử trong một mảng theo trọng số tương ứng của chúng đã cho trong một mảng khác. Hàm có thể có một tham số trục. Nếu trục không được chỉ định, mảng sẽ được làm phẳng.
Xét một mảng [1,2,3,4] và các trọng số tương ứng [4,3,2,1], trung bình có trọng số được tính bằng cách cộng tích của các phần tử tương ứng và chia tổng cho tổng các trọng số.
Trung bình có trọng số = (1 * 4 + 2 * 3 + 3 * 2 + 4 * 1) / (4 + 3 + 2 + 1)
Thí dụ
import numpy as np
a = np.array([1,2,3,4])
print 'Our array is:'
print a
print '\n'
print 'Applying average() function:'
print np.average(a)
print '\n'
# this is same as mean when weight is not specified
wts = np.array([4,3,2,1])
print 'Applying average() function again:'
print np.average(a,weights = wts)
print '\n'
# Returns the sum of weights, if the returned parameter is set to True.
print 'Sum of weights'
print np.average([1,2,3, 4],weights = [4,3,2,1], returned = True)
Nó sẽ tạo ra kết quả sau:
Our array is:
[1 2 3 4]
Applying average() function:
2.5
Applying average() function again:
2.0
Sum of weights
(2.0, 10.0)
Trong một mảng nhiều chiều, trục để tính toán có thể được chỉ định.
Thí dụ
import numpy as np
a = np.arange(6).reshape(3,2)
print 'Our array is:'
print a
print '\n'
print 'Modified array:'
wt = np.array([3,5])
print np.average(a, axis = 1, weights = wt)
print '\n'
print 'Modified array:'
print np.average(a, axis = 1, weights = wt, returned = True)
Nó sẽ tạo ra kết quả sau:
Our array is:
[[0 1]
[2 3]
[4 5]]
Modified array:
[ 0.625 2.625 4.625]
Modified array:
(array([ 0.625, 2.625, 4.625]), array([ 8., 8., 8.]))
Độ lệch chuẩn
Độ lệch chuẩn là căn bậc hai của giá trị trung bình của độ lệch bình phương so với giá trị trung bình. Công thức cho độ lệch chuẩn như sau:
std = sqrt(mean(abs(x - x.mean())**2))
Nếu mảng là [1, 2, 3, 4], thì giá trị trung bình của nó là 2,5. Do đó độ lệch bình phương là [2,25, 0,25, 0,25, 2,25] và căn bậc hai của trung bình của nó chia cho 4, tức là sqrt (5/4) là 1,1180339887498949.
Thí dụ
import numpy as np
print np.std([1,2,3,4])
Nó sẽ tạo ra kết quả sau:
1.1180339887498949
Phương sai
Phương sai là giá trị trung bình của các độ lệch bình phương, tức là mean(abs(x - x.mean())**2). Nói cách khác, độ lệch chuẩn là căn bậc hai của phương sai.
Thí dụ
import numpy as np
print np.var([1,2,3,4])
Nó sẽ tạo ra kết quả sau:
1.25
Nhiều chức năng liên quan đến sắp xếp có sẵn trong NumPy. Các hàm sắp xếp này thực hiện các thuật toán sắp xếp khác nhau, mỗi thuật toán được đặc trưng bởi tốc độ thực thi, hiệu suất trong trường hợp xấu nhất, không gian làm việc cần thiết và tính ổn định của các thuật toán. Bảng sau đây cho thấy sự so sánh của ba thuật toán sắp xếp.
Tốt bụng | tốc độ | trường hợp xấu nhất | không gian làm việc | ổn định |
---|---|---|---|---|
'sắp xếp nhanh chóng' | 1 | O (n ^ 2) | 0 | Không |
'hợp nhất' | 2 | O (n * log (n)) | ~ n / 2 | Đúng |
'heapsort' | 3 | O (n * log (n)) | 0 | Không |
numpy.sort ()
Hàm sort () trả về một bản sao đã được sắp xếp của mảng đầu vào. Nó có các thông số sau:
numpy.sort(a, axis, kind, order)
Ở đâu,
Sr.No. | Mô tả về Thông Số |
---|---|
1 | a Mảng được sắp xếp |
2 | axis Trục dọc theo mảng sẽ được sắp xếp. Nếu không có, mảng sẽ được làm phẳng, sắp xếp trên trục cuối cùng |
3 | kind Mặc định là quicksort |
4 | order Nếu mảng chứa các trường, thứ tự các trường sẽ được sắp xếp |
Thí dụ
import numpy as np
a = np.array([[3,7],[9,1]])
print 'Our array is:'
print a
print '\n'
print 'Applying sort() function:'
print np.sort(a)
print '\n'
print 'Sort along axis 0:'
print np.sort(a, axis = 0)
print '\n'
# Order parameter in sort function
dt = np.dtype([('name', 'S10'),('age', int)])
a = np.array([("raju",21),("anil",25),("ravi", 17), ("amar",27)], dtype = dt)
print 'Our array is:'
print a
print '\n'
print 'Order by name:'
print np.sort(a, order = 'name')
Nó sẽ tạo ra kết quả sau:
Our array is:
[[3 7]
[9 1]]
Applying sort() function:
[[3 7]
[1 9]]
Sort along axis 0:
[[3 1]
[9 7]]
Our array is:
[('raju', 21) ('anil', 25) ('ravi', 17) ('amar', 27)]
Order by name:
[('amar', 27) ('anil', 25) ('raju', 21) ('ravi', 17)]
numpy.argsort ()
Các numpy.argsort()hàm thực hiện sắp xếp gián tiếp trên mảng đầu vào, dọc theo trục đã cho và sử dụng một kiểu sắp xếp cụ thể để trả về mảng chỉ số dữ liệu. Mảng chỉ số này được sử dụng để xây dựng mảng đã sắp xếp.
Thí dụ
import numpy as np
x = np.array([3, 1, 2])
print 'Our array is:'
print x
print '\n'
print 'Applying argsort() to x:'
y = np.argsort(x)
print y
print '\n'
print 'Reconstruct original array in sorted order:'
print x[y]
print '\n'
print 'Reconstruct the original array using loop:'
for i in y:
print x[i],
Nó sẽ tạo ra kết quả sau:
Our array is:
[3 1 2]
Applying argsort() to x:
[1 2 0]
Reconstruct original array in sorted order:
[1 2 3]
Reconstruct the original array using loop:
1 2 3
numpy.lexsort ()
hàm thực hiện sắp xếp gián tiếp bằng cách sử dụng một chuỗi các khóa. Các khóa có thể được xem như một cột trong bảng tính. Hàm trả về một mảng chỉ số, sử dụng dữ liệu đã sắp xếp để lấy dữ liệu. Lưu ý rằng khóa cuối cùng sẽ là khóa chính của loại.
Thí dụ
import numpy as np
nm = ('raju','anil','ravi','amar')
dv = ('f.y.', 's.y.', 's.y.', 'f.y.')
ind = np.lexsort((dv,nm))
print 'Applying lexsort() function:'
print ind
print '\n'
print 'Use this index to get sorted data:'
print [nm[i] + ", " + dv[i] for i in ind]
Nó sẽ tạo ra kết quả sau:
Applying lexsort() function:
[3 1 0 2]
Use this index to get sorted data:
['amar, f.y.', 'anil, s.y.', 'raju, f.y.', 'ravi, s.y.']
Mô-đun NumPy có một số chức năng để tìm kiếm bên trong một mảng. Có sẵn các hàm tìm giá trị lớn nhất, cực tiểu cũng như các phần tử thỏa mãn một điều kiện nhất định.
numpy.argmax () và numpy.argmin ()
Hai hàm này trả về chỉ số của các phần tử cực đại và cực tiểu tương ứng dọc theo trục đã cho.
Thí dụ
import numpy as np
a = np.array([[30,40,70],[80,20,10],[50,90,60]])
print 'Our array is:'
print a
print '\n'
print 'Applying argmax() function:'
print np.argmax(a)
print '\n'
print 'Index of maximum number in flattened array'
print a.flatten()
print '\n'
print 'Array containing indices of maximum along axis 0:'
maxindex = np.argmax(a, axis = 0)
print maxindex
print '\n'
print 'Array containing indices of maximum along axis 1:'
maxindex = np.argmax(a, axis = 1)
print maxindex
print '\n'
print 'Applying argmin() function:'
minindex = np.argmin(a)
print minindex
print '\n'
print 'Flattened array:'
print a.flatten()[minindex]
print '\n'
print 'Flattened array along axis 0:'
minindex = np.argmin(a, axis = 0)
print minindex
print '\n'
print 'Flattened array along axis 1:'
minindex = np.argmin(a, axis = 1)
print minindex
Nó sẽ tạo ra kết quả sau:
Our array is:
[[30 40 70]
[80 20 10]
[50 90 60]]
Applying argmax() function:
7
Index of maximum number in flattened array
[30 40 70 80 20 10 50 90 60]
Array containing indices of maximum along axis 0:
[1 2 0]
Array containing indices of maximum along axis 1:
[2 0 1]
Applying argmin() function:
5
Flattened array:
10
Flattened array along axis 0:
[0 1 1]
Flattened array along axis 1:
[0 2 0]
numpy.nonzero ()
Các numpy.nonzero() hàm trả về chỉ số của các phần tử khác 0 trong mảng đầu vào.
Thí dụ
import numpy as np
a = np.array([[30,40,0],[0,20,10],[50,0,60]])
print 'Our array is:'
print a
print '\n'
print 'Applying nonzero() function:'
print np.nonzero (a)
Nó sẽ tạo ra kết quả sau:
Our array is:
[[30 40 0]
[ 0 20 10]
[50 0 60]]
Applying nonzero() function:
(array([0, 0, 1, 1, 2, 2]), array([0, 1, 1, 2, 0, 2]))
numpy.where ()
Hàm where () trả về chỉ số của các phần tử trong mảng đầu vào thỏa mãn điều kiện đã cho.
Thí dụ
import numpy as np
x = np.arange(9.).reshape(3, 3)
print 'Our array is:'
print x
print 'Indices of elements > 3'
y = np.where(x > 3)
print y
print 'Use these indices to get elements satisfying the condition'
print x[y]
Nó sẽ tạo ra kết quả sau:
Our array is:
[[ 0. 1. 2.]
[ 3. 4. 5.]
[ 6. 7. 8.]]
Indices of elements > 3
(array([1, 1, 2, 2, 2]), array([1, 2, 0, 1, 2]))
Use these indices to get elements satisfying the condition
[ 4. 5. 6. 7. 8.]
numpy.extract ()
Các extract() hàm trả về các phần tử thỏa mãn bất kỳ điều kiện nào.
import numpy as np
x = np.arange(9.).reshape(3, 3)
print 'Our array is:'
print x
# define a condition
condition = np.mod(x,2) == 0
print 'Element-wise value of condition'
print condition
print 'Extract elements using condition'
print np.extract(condition, x)
Nó sẽ tạo ra kết quả sau:
Our array is:
[[ 0. 1. 2.]
[ 3. 4. 5.]
[ 6. 7. 8.]]
Element-wise value of condition
[[ True False True]
[False True False]
[ True False True]]
Extract elements using condition
[ 0. 2. 4. 6. 8.]
Chúng ta đã thấy rằng dữ liệu được lưu trữ trong bộ nhớ của máy tính phụ thuộc vào kiến trúc mà CPU sử dụng. Nó có thể là little-endian (ít quan trọng nhất được lưu trữ trong địa chỉ nhỏ nhất) hoặc big-endian (byte quan trọng nhất trong địa chỉ nhỏ nhất).
numpy.ndarray.byteswap ()
Các numpy.ndarray.byteswap() chức năng chuyển đổi giữa hai đại diện: bigendian và little-endian.
import numpy as np
a = np.array([1, 256, 8755], dtype = np.int16)
print 'Our array is:'
print a
print 'Representation of data in memory in hexadecimal form:'
print map(hex,a)
# byteswap() function swaps in place by passing True parameter
print 'Applying byteswap() function:'
print a.byteswap(True)
print 'In hexadecimal form:'
print map(hex,a)
# We can see the bytes being swapped
Nó sẽ tạo ra kết quả sau:
Our array is:
[1 256 8755]
Representation of data in memory in hexadecimal form:
['0x1', '0x100', '0x2233']
Applying byteswap() function:
[256 1 13090]
In hexadecimal form:
['0x100', '0x1', '0x3322']
Trong khi thực thi các hàm, một số trong số chúng trả về bản sao của mảng đầu vào, trong khi một số trả về dạng xem. Khi nội dung được lưu trữ vật lý ở một vị trí khác, nó được gọi làCopy. Mặt khác, nếu một chế độ xem khác của cùng một nội dung bộ nhớ được cung cấp, chúng tôi gọi nó làView.
Không được sao chép
Các phép gán đơn giản không tạo ra bản sao của đối tượng mảng. Thay vào đó, nó sử dụng cùng một id () của mảng ban đầu để truy cập nó. Cácid() trả về một định danh chung của đối tượng Python, tương tự như con trỏ trong C.
Hơn nữa, bất kỳ thay đổi nào trong một trong hai đều được phản ánh trong cái còn lại. Ví dụ, hình dạng thay đổi của một cái cũng sẽ thay đổi hình dạng của cái kia.
Thí dụ
import numpy as np
a = np.arange(6)
print 'Our array is:'
print a
print 'Applying id() function:'
print id(a)
print 'a is assigned to b:'
b = a
print b
print 'b has same id():'
print id(b)
print 'Change shape of b:'
b.shape = 3,2
print b
print 'Shape of a also gets changed:'
print a
Nó sẽ tạo ra kết quả sau:
Our array is:
[0 1 2 3 4 5]
Applying id() function:
139747815479536
a is assigned to b:
[0 1 2 3 4 5]
b has same id():
139747815479536
Change shape of b:
[[0 1]
[2 3]
[4 5]]
Shape of a also gets changed:
[[0 1]
[2 3]
[4 5]]
Xem hoặc sao chép nông
NumPy có ndarray.view()phương thức là một đối tượng mảng mới xem xét cùng một dữ liệu của mảng ban đầu. Không giống như trường hợp trước, thay đổi kích thước của mảng mới không thay đổi kích thước của mảng ban đầu.
Thí dụ
import numpy as np
# To begin with, a is 3X2 array
a = np.arange(6).reshape(3,2)
print 'Array a:'
print a
print 'Create view of a:'
b = a.view()
print b
print 'id() for both the arrays are different:'
print 'id() of a:'
print id(a)
print 'id() of b:'
print id(b)
# Change the shape of b. It does not change the shape of a
b.shape = 2,3
print 'Shape of b:'
print b
print 'Shape of a:'
print a
Nó sẽ tạo ra kết quả sau:
Array a:
[[0 1]
[2 3]
[4 5]]
Create view of a:
[[0 1]
[2 3]
[4 5]]
id() for both the arrays are different:
id() of a:
140424307227264
id() of b:
140424151696288
Shape of b:
[[0 1 2]
[3 4 5]]
Shape of a:
[[0 1]
[2 3]
[4 5]]
Slice của một mảng tạo ra một khung nhìn.
Thí dụ
import numpy as np
a = np.array([[10,10], [2,3], [4,5]])
print 'Our array is:'
print a
print 'Create a slice:'
s = a[:, :2]
print s
Nó sẽ tạo ra kết quả sau:
Our array is:
[[10 10]
[ 2 3]
[ 4 5]]
Create a slice:
[[10 10]
[ 2 3]
[ 4 5]]
Bản sao sâu
Các ndarray.copy()chức năng tạo một bản sao sâu. Nó là một bản sao hoàn chỉnh của mảng và dữ liệu của nó, và không chia sẻ với mảng ban đầu.
Thí dụ
import numpy as np
a = np.array([[10,10], [2,3], [4,5]])
print 'Array a is:'
print a
print 'Create a deep copy of a:'
b = a.copy()
print 'Array b is:'
print b
#b does not share any memory of a
print 'Can we write b is a'
print b is a
print 'Change the contents of b:'
b[0,0] = 100
print 'Modified array b:'
print b
print 'a remains unchanged:'
print a
Nó sẽ tạo ra kết quả sau:
Array a is:
[[10 10]
[ 2 3]
[ 4 5]]
Create a deep copy of a:
Array b is:
[[10 10]
[ 2 3]
[ 4 5]]
Can we write b is a
False
Change the contents of b:
Modified array b:
[[100 10]
[ 2 3]
[ 4 5]]
a remains unchanged:
[[10 10]
[ 2 3]
[ 4 5]]
Gói NumPy chứa thư viện Ma trận numpy.matlib. Mô-đun này có các hàm trả về ma trận thay vì đối tượng ndarray.
matlib.empty ()
Các matlib.empty()hàm trả về một ma trận mới mà không cần khởi tạo các mục nhập. Hàm nhận các tham số sau.
numpy.matlib.empty(shape, dtype, order)
Ở đâu,
Sr.No. | Mô tả về Thông Số |
---|---|
1 | shape int hoặc nhiều int xác định hình dạng của ma trận mới |
2 | Dtype Không bắt buộc. Kiểu dữ liệu của đầu ra |
3 | order C hoặc F |
Thí dụ
import numpy.matlib
import numpy as np
print np.matlib.empty((2,2))
# filled with random data
Nó sẽ tạo ra kết quả sau:
[[ 2.12199579e-314, 4.24399158e-314]
[ 4.24399158e-314, 2.12199579e-314]]
numpy.matlib.zeros ()
Hàm này trả về ma trận chứa đầy các số không.
import numpy.matlib
import numpy as np
print np.matlib.zeros((2,2))
Nó sẽ tạo ra kết quả sau:
[[ 0. 0.]
[ 0. 0.]]
numpy.matlib.ones ()
Hàm này trả về ma trận được lấp đầy bởi 1s.
import numpy.matlib
import numpy as np
print np.matlib.ones((2,2))
Nó sẽ tạo ra kết quả sau:
[[ 1. 1.]
[ 1. 1.]]
numpy.matlib.eye ()
Hàm này trả về một ma trận với 1 dọc theo các phần tử đường chéo và các số không ở nơi khác. Hàm nhận các tham số sau.
numpy.matlib.eye(n, M,k, dtype)
Ở đâu,
Sr.No. | Mô tả về Thông Số |
---|---|
1 | n Số hàng trong ma trận kết quả |
2 | M Số cột, mặc định là n |
3 | k Chỉ số của đường chéo |
4 | dtype Kiểu dữ liệu của đầu ra |
Thí dụ
import numpy.matlib
import numpy as np
print np.matlib.eye(n = 3, M = 4, k = 0, dtype = float)
Nó sẽ tạo ra kết quả sau:
[[ 1. 0. 0. 0.]
[ 0. 1. 0. 0.]
[ 0. 0. 1. 0.]]
numpy.matlib.identity ()
Các numpy.matlib.identity()hàm trả về ma trận Identity có kích thước đã cho. Ma trận nhận dạng là một ma trận vuông với tất cả các phần tử đường chéo là 1.
import numpy.matlib
import numpy as np
print np.matlib.identity(5, dtype = float)
Nó sẽ tạo ra kết quả sau:
[[ 1. 0. 0. 0. 0.]
[ 0. 1. 0. 0. 0.]
[ 0. 0. 1. 0. 0.]
[ 0. 0. 0. 1. 0.]
[ 0. 0. 0. 0. 1.]]
numpy.matlib.rand ()
Các numpy.matlib.rand() hàm trả về một ma trận có kích thước đã cho chứa đầy các giá trị ngẫu nhiên.
Thí dụ
import numpy.matlib
import numpy as np
print np.matlib.rand(3,3)
Nó sẽ tạo ra kết quả sau:
[[ 0.82674464 0.57206837 0.15497519]
[ 0.33857374 0.35742401 0.90895076]
[ 0.03968467 0.13962089 0.39665201]]
Noterằng ma trận luôn là hai chiều, trong khi ndarray là một mảng n chiều. Cả hai đối tượng đều có thể chuyển đổi được.
Thí dụ
import numpy.matlib
import numpy as np
i = np.matrix('1,2;3,4')
print i
Nó sẽ tạo ra kết quả sau:
[[1 2]
[3 4]]
Thí dụ
import numpy.matlib
import numpy as np
j = np.asarray(i)
print j
Nó sẽ tạo ra kết quả sau:
[[1 2]
[3 4]]
Thí dụ
import numpy.matlib
import numpy as np
k = np.asmatrix (j)
print k
Nó sẽ tạo ra kết quả sau:
[[1 2]
[3 4]]
Gói NumPy chứa numpy.linalgmô-đun cung cấp tất cả các chức năng cần thiết cho đại số tuyến tính. Một số chức năng quan trọng trong mô-đun này được mô tả trong bảng sau.
Sr.No. | Mô tả chức năng |
---|---|
1 | dấu chấm Tích của hai mảng |
2 | vdot Tích của hai vectơ |
3 | bên trong Tích bên trong của hai mảng |
4 | matmul Tích ma trận của hai mảng |
5 | bản ngã Tính toán định thức của mảng |
6 | gỡ rối Giải phương trình ma trận tuyến tính |
7 | inv Tìm nghịch đảo nhân của ma trận |
Matplotlib là một thư viện vẽ đồ thị cho Python. Nó được sử dụng cùng với NumPy để cung cấp một môi trường thay thế nguồn mở hiệu quả cho MatLab. Nó cũng có thể được sử dụng với các bộ công cụ đồ họa như PyQt và wxPython.
Mô-đun Matplotlib lần đầu tiên được viết bởi John D. Hunter. Kể từ năm 2012, Michael Droettboom là nhà phát triển chính. Hiện tại, Matplotlib ver. 1.5.1 là phiên bản ổn định có sẵn. Gói này có sẵn ở dạng phân phối nhị phân cũng như ở dạng mã nguồn trên www.matplotlib.org .
Thông thường, gói được nhập vào tập lệnh Python bằng cách thêm câu lệnh sau:
from matplotlib import pyplot as plt
Đây pyplot()là hàm quan trọng nhất trong thư viện matplotlib, được sử dụng để vẽ dữ liệu 2D. Tập lệnh sau vẽ phương trìnhy = 2x + 5
Thí dụ
import numpy as np
from matplotlib import pyplot as plt
x = np.arange(1,11)
y = 2 * x + 5
plt.title("Matplotlib demo")
plt.xlabel("x axis caption")
plt.ylabel("y axis caption")
plt.plot(x,y)
plt.show()
Một đối tượng ndarray x được tạo từ np.arange() function như các giá trị trên x axis. Các giá trị tương ứng trêny axis được lưu trữ trong một ndarray object y. Các giá trị này được vẽ biểu đồ bằng cách sử dụngplot() chức năng của mô-đun con pyplot của gói matplotlib.
Biểu diễn đồ họa được hiển thị bởi show() chức năng.
Đoạn mã trên sẽ tạo ra kết quả sau:
Thay vì biểu đồ tuyến tính, các giá trị có thể được hiển thị riêng biệt bằng cách thêm chuỗi định dạng vào plot()chức năng. Các ký tự định dạng sau có thể được sử dụng.
Sr.No. | Nhân vật & Mô tả |
---|---|
1 | '-' Kiểu đường liền nét |
2 | '--' Kiểu đường đứt nét |
3 | '-.' Kiểu đường dấu gạch ngang |
4 | ':' Kiểu đường chấm |
5 | '.' Điểm đánh dấu |
6 | ',' Điểm đánh dấu pixel |
7 | 'o' Điểm đánh dấu vòng tròn |
số 8 | 'v' Điểm đánh dấu tam giác_dưới |
9 | '^' Triangle_up marker |
10 | '<' Điểm đánh dấu tam giác_left |
11 | '>' Điểm đánh dấu tam giác_phải |
12 | '1' Tri_down marker |
13 | '2' Tri_up marker |
14 | '3' Điểm đánh dấu Tri_left |
15 | '4' Điểm đánh dấu Tri_right |
16 | 's' Điểm đánh dấu hình vuông |
17 | 'p' Điểm đánh dấu Lầu Năm Góc |
18 | '*' Dấu sao |
19 | 'h' Điểm đánh dấu hình lục giác1 |
20 | 'H' Điểm đánh dấu Hexagon2 |
21 | '+' Điểm đánh dấu cộng |
22 | 'x' Điểm đánh dấu X |
23 | 'D' Điểm đánh dấu kim cương |
24 | 'd' Điểm đánh dấu Thin_diamond |
25 | '|' Điểm đánh dấu Vline |
26 | '_' Điểm đánh dấu dòng |
Các chữ viết tắt màu sau đây cũng được xác định.
Tính cách | Màu sắc |
---|---|
'b' | Màu xanh da trời |
'g' | màu xanh lá |
'r' | Đỏ |
'c' | Lục lam |
'm' | Đỏ tươi |
'y' | Màu vàng |
'k' | Đen |
'w' | trắng |
Để hiển thị các vòng tròn đại diện cho các điểm, thay vì đường trong ví dụ trên, hãy sử dụng “ob” dưới dạng chuỗi định dạng trong hàm plot ().
Thí dụ
import numpy as np
from matplotlib import pyplot as plt
x = np.arange(1,11)
y = 2 * x + 5
plt.title("Matplotlib demo")
plt.xlabel("x axis caption")
plt.ylabel("y axis caption")
plt.plot(x,y,"ob")
plt.show()
Đoạn mã trên sẽ tạo ra kết quả sau:
Lô sóng hình sin
Tập lệnh sau tạo ra sine wave plot sử dụng matplotlib.
Thí dụ
import numpy as np
import matplotlib.pyplot as plt
# Compute the x and y coordinates for points on a sine curve
x = np.arange(0, 3 * np.pi, 0.1)
y = np.sin(x)
plt.title("sine wave form")
# Plot the points using matplotlib
plt.plot(x, y)
plt.show()
subplot ()
Hàm subplot () cho phép bạn vẽ các thứ khác nhau trong cùng một hình. Trong tập lệnh sau,sine và cosine values được âm mưu.
Thí dụ
import numpy as np
import matplotlib.pyplot as plt
# Compute the x and y coordinates for points on sine and cosine curves
x = np.arange(0, 3 * np.pi, 0.1)
y_sin = np.sin(x)
y_cos = np.cos(x)
# Set up a subplot grid that has height 2 and width 1,
# and set the first such subplot as active.
plt.subplot(2, 1, 1)
# Make the first plot
plt.plot(x, y_sin)
plt.title('Sine')
# Set the second subplot as active, and make the second plot.
plt.subplot(2, 1, 2)
plt.plot(x, y_cos)
plt.title('Cosine')
# Show the figure.
plt.show()
Đoạn mã trên sẽ tạo ra kết quả sau:
quán ba()
Các pyplot submodule cung cấp bar()chức năng tạo biểu đồ thanh. Ví dụ sau tạo biểu đồ thanh của hai tập hợpx và y mảng.
Thí dụ
from matplotlib import pyplot as plt
x = [5,8,10]
y = [12,16,6]
x2 = [6,9,11]
y2 = [6,15,7]
plt.bar(x, y, align = 'center')
plt.bar(x2, y2, color = 'g', align = 'center')
plt.title('Bar graph')
plt.ylabel('Y axis')
plt.xlabel('X axis')
plt.show()
Mã này sẽ tạo ra kết quả sau:
NumPy có một numpy.histogram()chức năng là một biểu diễn đồ họa của sự phân bố tần số của dữ liệu. Hình chữ nhật có kích thước ngang bằng nhau tương ứng với khoảng lớp được gọi làbin và variable height tương ứng với tần số.
numpy.histogram ()
Hàm numpy.histogram () nhận mảng đầu vào và thùng làm hai tham số. Các phần tử kế tiếp nhau trong mảng bin đóng vai trò là ranh giới của mỗi bin.
import numpy as np
a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27])
np.histogram(a,bins = [0,20,40,60,80,100])
hist,bins = np.histogram(a,bins = [0,20,40,60,80,100])
print hist
print bins
Nó sẽ tạo ra kết quả sau:
[3 4 5 2 1]
[0 20 40 60 80 100]
plt ()
Matplotlib có thể chuyển đổi biểu diễn dạng số này của biểu đồ thành biểu đồ. Cácplt() function của mô-đun con pyplot lấy mảng chứa dữ liệu và mảng bin làm tham số và chuyển đổi thành biểu đồ.
from matplotlib import pyplot as plt
import numpy as np
a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27])
plt.hist(a, bins = [0,20,40,60,80,100])
plt.title("histogram")
plt.show()
Nó sẽ tạo ra kết quả sau:
Các đối tượng ndarray có thể được lưu vào và tải từ các tệp đĩa. Các chức năng IO có sẵn là -
load() và save() các hàm xử lý / tệp nhị phân numPy (với npy sự mở rộng)
loadtxt() và savetxt() chức năng xử lý các tệp văn bản bình thường
NumPy giới thiệu một định dạng tệp đơn giản cho các đối tượng ndarray. Điều này.npy tệp lưu trữ dữ liệu, hình dạng, loại dtype và các thông tin khác cần thiết để tạo lại ndarray trong tệp đĩa sao cho mảng được truy xuất chính xác ngay cả khi tệp nằm trên một máy khác có kiến trúc khác.
numpy.save ()
Các numpy.save() tệp lưu trữ mảng đầu vào trong tệp đĩa với npy sự mở rộng.
import numpy as np
a = np.array([1,2,3,4,5])
np.save('outfile',a)
Để tạo lại mảng từ outfile.npy, sử dụng load() chức năng.
import numpy as np
b = np.load('outfile.npy')
print b
Nó sẽ tạo ra kết quả sau:
array([1, 2, 3, 4, 5])
Các hàm save () và load () chấp nhận một tham số Boolean bổ sung allow_pickles. Một pickle trong Python được sử dụng để tuần tự hóa và hủy tuần tự hóa các đối tượng trước khi lưu vào hoặc đọc từ tệp đĩa.
savetxt ()
Việc lưu trữ và truy xuất dữ liệu mảng ở định dạng tệp văn bản đơn giản được thực hiện với savetxt() và loadtxt() chức năng.
Thí dụ
import numpy as np
a = np.array([1,2,3,4,5])
np.savetxt('out.txt',a)
b = np.loadtxt('out.txt')
print b
Nó sẽ tạo ra kết quả sau:
[ 1. 2. 3. 4. 5.]
Các hàm savetxt () và loadtxt () chấp nhận các tham số tùy chọn bổ sung như đầu trang, chân trang và dấu phân cách.