Trong Python, chúng ta có thể triển khai ma trận dưới dạng danh sách lồng nhau [danh sách bên trong danh sách]. Ta có thể coi mỗi phần tử là một hàng của ma trận
Ví dụ:
In [8]: data
Out[8]:
array[[[ 0.9526, -0.246 , -0.8856],
[ 0.5639, 0.2379, 0.9104]]]
In [9]: data * 10 In [10]: data + data
Out[9]: Out[10]:
array[[[ 9.5256, -2.4601, -8.8565], array[[[ 1.9051, -0.492 , -1.7713],
[ 5.6385, 2.3794, 9.104 ]]] [ 1.1277, 0.4759, 1.8208]]]69 sẽ đại diện cho ma trận 3x2. Hàng đầu tiên có thể được chọn là In [8]: data
Out[8]:
array[[[ 0.9526, -0.246 , -0.8856],
[ 0.5639, 0.2379, 0.9104]]]
In [9]: data * 10 In [10]: data + data
Out[9]: Out[10]:
array[[[ 9.5256, -2.4601, -8.8565], array[[[ 1.9051, -0.492 , -1.7713],
[ 5.6385, 2.3794, 9.104 ]]] [ 1.1277, 0.4759, 1.8208]]]70. Và, phần tử trong cột đầu tiên của hàng đầu tiên có thể được chọn là In [8]: data
Out[8]:
array[[[ 0.9526, -0.246 , -0.8856],
[ 0.5639, 0.2379, 0.9104]]]
In [9]: data * 10 In [10]: data + data
Out[9]: Out[10]:
array[[[ 9.5256, -2.4601, -8.8565], array[[[ 1.9051, -0.492 , -1.7713],
[ 5.6385, 2.3794, 9.104 ]]] [ 1.1277, 0.4759, 1.8208]]]71Chuyển vị của ma trận là phép đổi chỗ hàng và cột. Kí hiệu là X'. Phần tử ở hàng thứ i và cột thứ j trong X sẽ được đặt ở hàng thứ j và cột thứ i trong X'. Vậy nếu X là ma trận 3x2 thì X' sẽ là ma trận 2x3
Dưới đây là một số cách để thực hiện điều này trong Python
Chuyển đổi ma trận bằng vòng lặp lồng nhau
# Program to transpose a matrix using a nested loop
X = [[12,7],
[4 ,5],
[3 ,8]]
result = [[0,0,0],
[0,0,0]]
# iterate through rows
for i in range[len[X]]:
# iterate through columns
for j in range[len[X[0]]]:
result[j][i] = X[i][j]
for r in result:
print[r]
đầu ra
[12, 4, 3] [7, 5, 8]
Trong chương trình này, chúng tôi đã sử dụng các vòng lặp
In [8]: data
Out[8]:
array[[[ 0.9526, -0.246 , -0.8856],
[ 0.5639, 0.2379, 0.9104]]]
In [9]: data * 10 In [10]: data + data
Out[9]: Out[10]:
array[[[ 9.5256, -2.4601, -8.8565], array[[[ 1.9051, -0.492 , -1.7713],
[ 5.6385, 2.3794, 9.104 ]]] [ 1.1277, 0.4759, 1.8208]]]72 lồng nhau để lặp qua từng hàng và từng cột. Tại mỗi điểm chúng ta đặt phần tử X[i][j] vào result[j][i]Chuyển đổi ma trận bằng cách sử dụng tính năng hiểu danh sách lồng nhau
''' Program to transpose a matrix using list comprehension'''
X = [[12,7],
[4 ,5],
[3 ,8]]
result = [[X[j][i] for j in range[len[X]]] for i in range[len[X[0]]]]
for r in result:
print[r]Đầu ra của chương trình này giống như trên. Chúng tôi đã sử dụng khả năng hiểu danh sách lồng nhau để lặp qua từng phần tử trong ma trận
Thật dễ dàng để nhân một ma trận với một đại lượng vô hướng. Chỉ cần nhân mỗi số trong ma trận với vô hướng
Thí dụ
const mA = toán học. ma trận[[[1, 2], [3, 4], [5, 6]]];
// Phép nhân ma trận
const matrixMult = math. nhân[2, mA];
// Kết quả [ [2, 4], [6, 8], [10, 12] ]
Tự mình thử »
Thí dụ
const mA = toán học. ma trận[[[0, 2], [4, 6], [8, 10]]];
// Phép chia ma trận
const matrixDiv = math. chia[mA, 2];
// Kết quả [ [0, 1], [2, 3], [4, 5] ]
Tự mình thử »
Hoán vị một ma trận
Để chuyển đổi ma trận, có nghĩa là thay thế các hàng bằng các cột
Khi bạn hoán đổi hàng và cột, bạn xoay ma trận xung quanh đường chéo của nó
nhân ma trận
Nhân ma trận khó hơn
Ta chỉ có thể nhân hai ma trận nếu số hàng của ma trận A bằng số cột của ma trận B
Sau đó, chúng ta cần biên dịch một "sản phẩm chấm"
Ta cần nhân các số ở mỗi hàng của A với các số ở mỗi cột của B, rồi cộng các tích
NumPy, viết tắt của Numerical Python, là gói cơ bản cần thiết cho tính toán khoa học và phân tích dữ liệu hiệu suất cao. Nó là nền tảng mà gần như tất cả các công cụ cấp cao hơn trong cuốn sách này được xây dựng trên đó. Đây là một số trong những điều nó cung cấp
Điểm cuối cùng cũng là một trong những điểm quan trọng nhất từ quan điểm hệ sinh thái. Vì NumPy cung cấp API C dễ sử dụng nên rất dễ dàng chuyển dữ liệu sang các thư viện bên ngoài được viết bằng ngôn ngữ cấp thấp và cũng để các thư viện bên ngoài trả lại dữ liệu cho Python dưới dạng mảng NumPy. Tính năng này đã làm cho Python trở thành ngôn ngữ được lựa chọn để gói các cơ sở mã C/C++/Fortran kế thừa và mang lại cho chúng một giao diện năng động và dễ sử dụng
Mặc dù bản thân NumPy không cung cấp nhiều chức năng phân tích dữ liệu cấp cao, nhưng hiểu biết về mảng NumPy và tính toán hướng mảng sẽ giúp bạn sử dụng các công cụ như gấu trúc hiệu quả hơn nhiều. Nếu bạn chưa quen với Python và chỉ muốn bắt tay vào làm việc với dữ liệu bằng gấu trúc, vui lòng đọc lướt qua chương này. Để biết thêm về các tính năng nâng cao của NumPy như phát sóng, hãy xem Chương 12
Đối với hầu hết các ứng dụng phân tích dữ liệu, các lĩnh vực chức năng chính mà tôi sẽ tập trung vào là
Mặc dù NumPy cung cấp nền tảng tính toán cho các hoạt động này, nhưng bạn có thể sẽ muốn sử dụng gấu trúc làm cơ sở cho hầu hết các loại phân tích dữ liệu [đặc biệt là dữ liệu có cấu trúc hoặc dữ liệu dạng bảng] vì nó cung cấp giao diện cấp cao, phong phú giúp hầu hết các tác vụ dữ liệu phổ biến trở nên rất hiệu quả. . gấu trúc cũng cung cấp một số chức năng cụ thể hơn cho miền như thao tác chuỗi thời gian, không có trong NumPy
Một trong những tính năng chính của NumPy là đối tượng mảng N chiều của nó, hay ndarray, là một bộ chứa nhanh, linh hoạt cho các tập dữ liệu lớn trong Python. Mảng cho phép bạn thực hiện các phép toán trên toàn bộ khối dữ liệu bằng cách sử dụng cú pháp tương tự như các phép toán tương đương giữa các phần tử vô hướng
In [8]: data
Out[8]:
array[[[ 0.9526, -0.246 , -0.8856],
[ 0.5639, 0.2379, 0.9104]]]
In [9]: data * 10 In [10]: data + data
Out[9]: Out[10]:
array[[[ 9.5256, -2.4601, -8.8565], array[[[ 1.9051, -0.492 , -1.7713],
[ 5.6385, 2.3794, 9.104 ]]] [ 1.1277, 0.4759, 1.8208]]]Một ndarray là một thùng chứa đa chiều chung cho dữ liệu đồng nhất; . Mỗi mảng có một
In [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]0, một bộ cho biết kích thước của mỗi chiều và một
In [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]1, một đối tượng mô tả kiểu dữ liệu của mảng
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']
Chương này sẽ giới thiệu cho bạn những kiến thức cơ bản về cách sử dụng mảng NumPy và sẽ đủ để bạn theo dõi phần còn lại của cuốn sách. Mặc dù không cần phải hiểu sâu về NumPy đối với nhiều ứng dụng phân tích dữ liệu, nhưng việc thành thạo tư duy và lập trình hướng mảng là một bước quan trọng trên con đường trở thành một chuyên gia khoa học về Python
Ghi chú
Bất cứ khi nào bạn nhìn thấy “mảng”, “mảng NumPy” hoặc “ndarray” trong văn bản, với một vài ngoại lệ, tất cả chúng đều đề cập đến cùng một thứ. đối tượng ndarray
Cách dễ nhất để tạo một mảng là sử dụng hàm
In [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]2. Điều này chấp nhận bất kỳ đối tượng giống như chuỗi nào [bao gồm cả các mảng khác] và tạo ra một mảng NumPy mới chứa dữ liệu đã truyền. Ví dụ: một danh sách là một ứng cử viên tốt để chuyển đổi________số 8
Các chuỗi lồng nhau, giống như một danh sách các danh sách có độ dài bằng nhau, sẽ được chuyển đổi thành một mảng nhiều chiều
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]Trừ khi được chỉ định rõ ràng [sẽ nói thêm về điều này sau],
In [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]3 cố gắng suy ra một kiểu dữ liệu tốt cho mảng mà nó tạo ra. Kiểu dữ liệu được lưu trữ trong một đối tượng
In [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]1 đặc biệt;
[12, 4, 3] [7, 5, 8]2
Ngoài
In [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]3, còn có một số hàm khác để tạo mảng mới. Như ví dụ,
In [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]6 và
In [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]7 lần lượt tạo các mảng 0 hoặc 1 với độ dài hoặc hình dạng nhất định.
In [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]8 tạo một mảng mà không khởi tạo các giá trị của nó thành bất kỳ giá trị cụ thể nào. Để tạo một mảng chiều cao hơn với các phương thức này, hãy truyền một bộ cho hình dạng
[12, 4, 3] [7, 5, 8]7
thận trọng
Sẽ không an toàn khi cho rằng
In [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]9 sẽ trả về một mảng toàn các số không. Trong nhiều trường hợp, như đã trình bày trước đây, nó sẽ trả về các giá trị rác chưa được khởi tạo
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']00 là phiên bản có giá trị mảng của hàm
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']01 Python tích hợp
''' Program to transpose a matrix using list comprehension'''
X = [[12,7],
[4 ,5],
[3 ,8]]
result = [[X[j][i] for j in range[len[X]]] for i in range[len[X[0]]]]
for r in result:
print[r]Xem Bảng 4-1 để biết danh sách ngắn các hàm tạo mảng tiêu chuẩn. Vì NumPy tập trung vào tính toán số, nên loại dữ liệu, nếu không được chỉ định, trong nhiều trường hợp sẽ là
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']02 [dấu phẩy động]
Bảng 4-1. Hàm tạo mảng
FunctionDescription
In [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]2Chuyển đổi dữ liệu đầu vào [danh sách, bộ dữ liệu, mảng hoặc loại trình tự khác] thành một ndarray bằng cách suy ra một loại hoặc chỉ định rõ ràng một loại. Sao chép dữ liệu đầu vào theo mặc định.
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']04Chuyển đổi đầu vào thành ndarray, nhưng không sao chép nếu đầu vào đã là ndarray
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']00Giống như
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']01 tích hợp sẵn nhưng trả về ndarray thay vì danh sách.
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']07Tạo một mảng gồm tất cả các số 1 với hình dạng và kiểu chữ đã cho.
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']08 lấy một mảng khác và tạo ra một mảng có cùng hình dạng và kiểu chữ.
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']09Giống như
In [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]7 và
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']08 nhưng thay vào đó tạo ra các mảng 0
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']12Tạo mảng mới bằng cách cấp phát bộ nhớ mới, nhưng không điền bất kỳ giá trị nào như
In [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]7 và
In [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]6
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']15Tạo ma trận đơn vị hình vuông N x N [1 trên đường chéo và 0 ở những nơi khác]
Kiểu dữ liệu hoặc
In [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]1 là một đối tượng đặc biệt chứa thông tin mà ndarray cần để giải thích một đoạn bộ nhớ dưới dạng một loại dữ liệu cụ thể
In [8]: data
Out[8]:
array[[[ 0.9526, -0.246 , -0.8856],
[ 0.5639, 0.2379, 0.9104]]]
In [9]: data * 10 In [10]: data + data
Out[9]: Out[10]:
array[[[ 9.5256, -2.4601, -8.8565], array[[[ 1.9051, -0.492 , -1.7713],
[ 5.6385, 2.3794, 9.104 ]]] [ 1.1277, 0.4759, 1.8208]]]7Dtypes là một phần khiến NumPy trở nên mạnh mẽ và linh hoạt. Trong hầu hết các trường hợp, chúng ánh xạ trực tiếp lên biểu diễn máy bên dưới, giúp dễ dàng đọc và ghi các luồng dữ liệu nhị phân vào đĩa và cũng để kết nối với mã được viết bằng ngôn ngữ cấp thấp như C hoặc Fortran. Các dtypes số được đặt tên theo cùng một cách. một tên loại, chẳng hạn như
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']17 hoặc
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']18, theo sau là một số cho biết số lượng bit trên mỗi phần tử. Một giá trị dấu phẩy động có độ chính xác kép tiêu chuẩn [được sử dụng dưới mui xe trong đối tượng
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']17 của Python] chiếm 8 byte hoặc 64 bit. Do đó, loại này được biết đến trong NumPy là
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']02. Xem Bảng 4-2 để biết danh sách đầy đủ các loại dữ liệu được hỗ trợ của NumPy
Ghi chú
Đừng lo lắng về việc ghi nhớ các kiểu dữ liệu NumPy, đặc biệt nếu bạn là người dùng mới. Thông thường, bạn chỉ cần quan tâm đến loại dữ liệu chung mà bạn đang xử lý, cho dù là dấu chấm động, phức, số nguyên, boolean, chuỗi hay đối tượng Python chung. Khi bạn cần kiểm soát nhiều hơn cách dữ liệu được lưu trữ trong bộ nhớ và trên đĩa, đặc biệt là các tập dữ liệu lớn, bạn nên biết rằng mình có quyền kiểm soát đối với loại lưu trữ
Bảng 4-2. kiểu dữ liệu NumPy
LoạiMã loạiMô tả
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']21
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']22Kiểu số nguyên 8 bit [1 byte] có dấu và không dấu
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']23
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']24Kiểu số nguyên 16 bit có dấu và không dấu
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']25
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']26Kiểu số nguyên 32 bit có dấu và không dấu
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']27
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']28Kiểu số nguyên 32 bit có dấu và không dấu
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']29
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']30_____Dấu phẩy động chính xác một nửa_____63___31 và dấu phẩy động chuẩn chính xác _____63___31. Tương thích với C float_______602_______634Dấu chấm động có độ chính xác kép tiêu chuẩn. Tương thích với đối tượng C double và Python
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']17_______636
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']37Extended-precision floating point
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']38
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']39Các số phức được biểu thị bằng hai số float 32, 64 hoặc 128 tương ứng
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']40?Kiểu Boolean lưu trữ các giá trị
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']41 và
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']42
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']43OPython loại đối tượng
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']44SLoại chuỗi có độ dài cố định [1 byte cho mỗi ký tự]. Ví dụ: để tạo chuỗi dtype có độ dài 10, hãy sử dụng
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']45.
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']46ULoại unicode có độ dài cố định [số byte dành riêng cho nền tảng]. Ngữ nghĩa đặc điểm kỹ thuật tương tự như
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']44 [e. g.
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']48]
Bạn có thể chuyển đổi hoặc ép kiểu một cách rõ ràng một mảng từ dtype này sang dtype khác bằng cách sử dụng phương thức
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']49 của ndarray
In [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]1
Trong ví dụ này, các số nguyên được chuyển thành dấu phẩy động. Nếu tôi chuyển một số số dấu phẩy động thành kiểu số nguyên, phần thập phân sẽ bị cắt bớt
In [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]
Nếu bạn có một mảng các chuỗi đại diện cho các số, bạn có thể sử dụng
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']49 để chuyển chúng sang dạng số
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']0
Nếu quá trình truyền không thành công vì một số lý do [chẳng hạn như một chuỗi không thể chuyển đổi thành
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']02], thì
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']52 sẽ được nâng lên. Thấy rằng tôi đã hơi lười biếng và đã viết
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']17 thay vì
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']54;
Bạn cũng có thể sử dụng thuộc tính dtype của mảng khác
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']1
Có các chuỗi mã loại tốc ký mà bạn cũng có thể sử dụng để chỉ một dtype
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']2
Ghi chú
Gọi
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']49 luôn tạo một mảng mới [bản sao của dữ liệu], ngay cả khi dtype mới giống với dtype cũ
thận trọng
Cần lưu ý rằng các số dấu phẩy động, chẳng hạn như các số trong mảng
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']02 và
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']31, chỉ có khả năng tính gần đúng các đại lượng phân số. Trong các phép tính phức tạp, bạn có thể tích lũy một số lỗi dấu phẩy động, khiến phép so sánh chỉ có giá trị đến một số vị trí thập phân nhất định
Các hoạt động giữa mảng và vô hướng
Mảng rất quan trọng vì chúng cho phép bạn thể hiện các thao tác hàng loạt trên dữ liệu mà không cần viết bất kỳ vòng lặp
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']58 nào. Điều này thường được gọi là vector hóa. Bất kỳ phép toán số học nào giữa các mảng có kích thước bằng nhau đều áp dụng phép toán theo từng phần tử
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']3
Các phép toán số học với đại lượng vô hướng như bạn mong đợi, truyền giá trị cho từng phần tử
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']4
Hoạt động giữa các mảng có kích thước khác nhau được gọi là phát sóng và sẽ được thảo luận chi tiết hơn trong Chương 12. Hiểu sâu về phát sóng là không cần thiết đối với hầu hết cuốn sách này
Lập chỉ mục cơ bản và cắt lát
Lập chỉ mục mảng NumPy là một chủ đề phong phú, vì có nhiều cách bạn có thể muốn chọn một tập hợp con dữ liệu hoặc các phần tử riêng lẻ của mình. Mảng một chiều rất đơn giản;
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']5
Như bạn có thể thấy, nếu bạn gán một giá trị vô hướng cho một lát cắt, như trong
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']59, thì giá trị đó sẽ được lan truyền [hoặc được quảng bá từ đó trở đi] cho toàn bộ lựa chọn. Một điểm khác biệt quan trọng đầu tiên với danh sách là các lát mảng là các khung nhìn trên mảng ban đầu. Điều này có nghĩa là dữ liệu không được sao chép và mọi sửa đổi đối với chế độ xem sẽ được phản ánh trong mảng nguồn
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']6
Nếu bạn chưa quen với NumPy, bạn có thể ngạc nhiên về điều này, đặc biệt nếu bạn đã sử dụng các ngôn ngữ lập trình mảng khác sao chép dữ liệu nhiều hơn. Vì NumPy đã được thiết kế dành cho các trường hợp sử dụng dữ liệu lớn, bạn có thể tưởng tượng các vấn đề về hiệu suất và bộ nhớ nếu NumPy khăng khăng sao chép dữ liệu sang trái và phải
thận trọng
Nếu bạn muốn có một bản sao của một lát ndarray thay vì một dạng xem, bạn sẽ cần sao chép mảng đó một cách rõ ràng;
Với mảng chiều cao hơn, bạn có nhiều lựa chọn hơn. Trong mảng hai chiều, các phần tử ở mỗi chỉ mục không còn là vô hướng mà là mảng một chiều
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']7
Do đó, các phần tử riêng lẻ có thể được truy cập đệ quy. Nhưng đó là một chút quá nhiều công việc, vì vậy bạn có thể chuyển một danh sách các chỉ mục được phân tách bằng dấu phẩy để chọn các phần tử riêng lẻ. Vì vậy, đây là tương đương
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']8
Xem Hình 4-1 để biết minh họa về lập chỉ mục trên mảng 2D
Hình 4-1. Lập chỉ mục các phần tử trong một mảng NumPy
Trong các mảng nhiều chiều, nếu bạn bỏ qua các chỉ số sau này, đối tượng được trả về sẽ là một mảng có chiều thấp hơn bao gồm tất cả dữ liệu dọc theo các chiều cao hơn. Vì vậy, trong mảng 2 × 2 × 3
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']61
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']9
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']62 là một mảng 2 × 3
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]0
Cả giá trị vô hướng và mảng đều có thể được gán cho
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']62
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]1
Tương tự,
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']64 cung cấp cho bạn tất cả các giá trị có chỉ số bắt đầu bằng
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']65, tạo thành một mảng 1 chiều
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]2
Lưu ý rằng trong tất cả các trường hợp khi các phần con của mảng đã được chọn, các mảng được trả về là dạng xem
Giống như các đối tượng một chiều như danh sách Python, ndarrays có thể được cắt bằng cú pháp quen thuộc
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]3
Các đối tượng có chiều cao hơn cung cấp cho bạn nhiều tùy chọn hơn vì bạn có thể cắt một hoặc nhiều trục và cũng có thể trộn các số nguyên. Xem xét mảng 2D ở trên,
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']66. Cắt mảng này hơi khác một chút
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]4
Như bạn có thể thấy, nó đã cắt dọc theo trục 0, trục đầu tiên. Do đó, một lát cắt chọn một loạt các phần tử dọc theo một trục. Bạn có thể chuyển nhiều lát giống như bạn có thể chuyển nhiều chỉ mục
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]5
Khi cắt như thế này, bạn luôn thu được các dạng xem mảng có cùng số lượng kích thước. Bằng cách trộn các chỉ mục số nguyên và các lát cắt, bạn sẽ có được các lát cắt có chiều thấp hơn
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]6
Xem Hình 4-2 để minh họa. Lưu ý rằng bản thân dấu hai chấm có nghĩa là lấy toàn bộ trục, vì vậy bạn chỉ có thể cắt các trục có chiều cao hơn bằng cách thực hiện
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]7
Tất nhiên, gán cho một biểu thức lát cắt sẽ gán cho toàn bộ vùng chọn
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]8
Hãy xem xét một ví dụ trong đó chúng ta có một số dữ liệu trong một mảng và một mảng tên trùng lặp. Ở đây tôi sẽ sử dụng hàm
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']67 trong
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']68 để tạo một số dữ liệu phân phối chuẩn ngẫu nhiên
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]9
Hình 4-2. cắt mảng hai chiều
Giả sử mỗi tên tương ứng với một hàng trong mảng
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']69 và chúng tôi muốn chọn tất cả các hàng có tên tương ứng
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']70. Giống như các phép tính số học, phép so sánh [chẳng hạn như
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']71] với mảng cũng được vector hóa. Do đó, so sánh
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']72 với chuỗi
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']70 mang lại một mảng boolean
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]0Mảng boolean này có thể được chuyển khi lập chỉ mục mảng
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]1Mảng boolean phải có cùng độ dài với trục mà nó lập chỉ mục. Bạn thậm chí có thể trộn và khớp các mảng boolean với các lát cắt hoặc số nguyên [hoặc chuỗi các số nguyên, sẽ nói thêm về điều này sau]
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]2Để chọn mọi thứ trừ
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']70, bạn có thể sử dụng
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']75 hoặc phủ định điều kiện bằng cách sử dụng
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']76
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]3Chọn hai trong số ba tên để kết hợp nhiều điều kiện boolean, sử dụng các toán tử số học boolean như
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']77 [và] và
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']78 [hoặc]
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]4Chọn dữ liệu từ một mảng bằng cách lập chỉ mục boolean luôn tạo một bản sao của dữ liệu, ngay cả khi mảng được trả về không thay đổi
thận trọng
Từ khóa Python
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']79 và
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']80 không hoạt động với mảng boolean
Đặt giá trị với mảng boolean hoạt động theo cách thông thường. Để đặt tất cả các giá trị âm trong
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']69 thành 0, chúng ta chỉ cần thực hiện
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]5Đặt toàn bộ hàng hoặc cột bằng mảng boolean 1D cũng dễ dàng
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]6Lập chỉ mục ưa thích là một thuật ngữ được NumPy sử dụng để mô tả việc lập chỉ mục bằng cách sử dụng các mảng số nguyên. Giả sử chúng ta có một mảng 8 × 4
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]7Để chọn ra một tập hợp con của các hàng theo một thứ tự cụ thể, bạn chỉ cần chuyển một danh sách hoặc ndarray các số nguyên chỉ định thứ tự mong muốn
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]8Hy vọng mã này đã làm những gì bạn mong đợi. Sử dụng chỉ số âm chọn hàng từ cuối
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]9Truyền nhiều mảng chỉ mục sẽ làm điều gì đó hơi khác một chút;
[12, 4, 3] [7, 5, 8]20
Hãy dành một chút thời gian để hiểu những gì vừa xảy ra. các phần tử
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']82 và
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']83 đã được chọn. Hành vi lập chỉ mục ưa thích trong trường hợp này hơi khác so với những gì một số người dùng có thể đã mong đợi [bao gồm cả bản thân tôi], đó là vùng hình chữ nhật được hình thành bằng cách chọn một tập hợp con các hàng và cột của ma trận. Đây là một cách để có được điều đó
[12, 4, 3] [7, 5, 8]21
Một cách khác là sử dụng hàm
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']84, hàm này chuyển đổi hai mảng số nguyên 1D thành bộ chỉ mục chọn vùng hình vuông
[12, 4, 3] [7, 5, 8]22
Hãy nhớ rằng lập chỉ mục ưa thích, không giống như cắt, luôn sao chép dữ liệu vào một mảng mới
Chuyển mảng và hoán đổi trục
Chuyển đổi là một hình thức định hình lại đặc biệt, tương tự trả về chế độ xem trên dữ liệu cơ bản mà không cần sao chép bất kỳ thứ gì. Mảng có phương thức
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']85 và thuộc tính đặc biệt
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']86
[12, 4, 3] [7, 5, 8]23
Khi thực hiện tính toán ma trận, bạn sẽ thực hiện việc này rất thường xuyên, chẳng hạn như tính toán tích ma trận bên trong XTX bằng cách sử dụng
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']87
[12, 4, 3] [7, 5, 8]24
Đối với các mảng chiều cao hơn,
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']85 sẽ chấp nhận một bộ số trục để hoán vị các trục [để uốn cong tâm thêm]
[12, 4, 3] [7, 5, 8]25
Chuyển đổi đơn giản với
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']89 chỉ là trường hợp đặc biệt của hoán đổi trục. ndarray có phương thức
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']90 lấy một cặp số trục
[12, 4, 3] [7, 5, 8]26
Tương tự,
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']90 trả về chế độ xem trên dữ liệu mà không tạo bản sao
Một hàm phổ quát, hay ufunc, là một hàm thực hiện các phép toán theo phần tử trên dữ liệu trong ndarrays. Bạn có thể coi chúng như các trình bao bọc được vector hóa nhanh cho các hàm đơn giản nhận một hoặc nhiều giá trị vô hướng và tạo ra một hoặc nhiều kết quả vô hướng
Nhiều ufunc là các phép biến đổi theo nguyên tố đơn giản, như
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']92 hoặc
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']93
[12, 4, 3] [7, 5, 8]27
Chúng được gọi là ufunc đơn nguyên. Những người khác, chẳng hạn như
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']94 hoặc
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']95, lấy 2 mảng [do đó, ufunc nhị phân] và trả về một mảng duy nhất làm kết quả
[12, 4, 3] [7, 5, 8]28
Mặc dù không phổ biến nhưng một ufunc có thể trả về nhiều mảng.
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']96 là một ví dụ, một phiên bản vector hóa của Python tích hợp sẵn
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']97. nó trả về các phần phân số và tích phân của một mảng dấu phẩy động
[12, 4, 3] [7, 5, 8]29
Xem Bảng 4-3 và Bảng 4-4 để biết danh sách các ufunc có sẵn
Bảng 4-3. ufunc đơn nguyên
HàmMô tả
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']98Tính toán giá trị tuyệt đối theo từng phần tử cho các giá trị số nguyên, dấu phẩy động hoặc phức. Sử dụng
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']99 như một giải pháp thay thế nhanh hơn cho dữ liệu có giá trị không phức tạp
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']92Tính căn bậc hai của mỗi phần tử. Tương đương với
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]01
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]02Tính bình phương mỗi phần tử. Tương đương với
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]03
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']93Tính toán số mũ ex của từng phần tử
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]05Logarit tự nhiên [cơ số e], log cơ số 10, log cơ số 2 và log[1 + x], tương ứng
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]06Tính toán dấu của từng phần tử. 1 [dương], 0 [không] hoặc -1 [âm]
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]07Tính toán mức trần của từng phần tử, i. e. số nguyên nhỏ nhất lớn hơn hoặc bằng mỗi phần tử____808Tính sàn của mỗi phần tử, i. e. số nguyên lớn nhất nhỏ hơn hoặc bằng mỗi phần tử
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]09Làm tròn các phần tử thành số nguyên gần nhất, giữ nguyên giá trị
In [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]1
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']96Trả về các phần phân số và tích phân của mảng dưới dạng mảng riêng biệt
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]12Trả về mảng boolean cho biết mỗi giá trị có phải là
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]13 [Không phải là số]
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]14Trả về mảng boolean cho biết mỗi phần tử có hữu hạn hay không . Tương đương với
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]21
Bảng 4-4. Hàm vạn năng nhị phân
HàmMô tả
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']94Thêm các phần tử tương ứng trong mảng
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]23Trừ các phần tử trong mảng thứ hai từ mảng thứ nhất
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]24Nhân các phần tử mảng
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]25Chia hoặc chia sàn [cắt bớt phần còn lại]
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]26Nâng các phần tử trong mảng thứ nhất lên lũy thừa được chỉ định trong mảng thứ hai
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]27Tối đa phần tử.
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]28 bỏ qua
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]13
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]30Tối thiểu theo yếu tố.
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]31 bỏ qua
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]13
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]33Mô đun theo phần tử [phần dư của phép chia]
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]34Sao chép dấu của các giá trị trong đối số thứ hai sang các giá trị trong đối số thứ nhất
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]35Thực hiện so sánh theo phần tử, tạo ra mảng boolean. Tương đương với các toán tử trung tố
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]36
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]37Tính toán giá trị thực theo từng phần tử của phép toán logic. Tương đương với toán tử infix
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]38
Sử dụng mảng NumPy cho phép bạn thể hiện nhiều loại tác vụ xử lý dữ liệu dưới dạng biểu thức mảng ngắn gọn mà có thể yêu cầu viết vòng lặp. Phương pháp thay thế các vòng lặp rõ ràng này bằng các biểu thức mảng thường được gọi là vector hóa. Nói chung, các phép toán mảng được vector hóa thường sẽ nhanh hơn một hoặc hai [hoặc nhiều] bậc độ lớn so với các phép toán Python thuần túy tương đương của chúng, với tác động lớn nhất trong bất kỳ loại tính toán số nào. Sau đó, trong Chương 12, tôi sẽ giải thích về phát sóng, một phương pháp hiệu quả để vector hóa tính toán
Ví dụ đơn giản, giả sử chúng ta muốn đánh giá hàm
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]39 trên một lưới giá trị thông thường. Hàm
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]40 nhận hai mảng 1D và tạo ra hai ma trận 2D tương ứng với tất cả các cặp
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]41 trong hai mảng
[12, 4, 3] [7, 5, 8]70
Bây giờ, đánh giá hàm là một vấn đề đơn giản bằng cách viết cùng một biểu thức mà bạn sẽ viết với hai điểm
[12, 4, 3] [7, 5, 8]71
Xem Hình 4-3. Ở đây tôi đã sử dụng hàm matplotlib
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]42 để tạo một biểu đồ hình ảnh từ một mảng 2D của các giá trị hàm
Hình 4-3. Biểu đồ hàm được đánh giá trên lưới
Thể hiện logic có điều kiện dưới dạng hoạt động mảng
Hàm
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]43 là phiên bản vector hóa của biểu thức ternary
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]44. Giả sử chúng ta có một mảng boolean và hai mảng giá trị
[12, 4, 3] [7, 5, 8]72
Giả sử chúng tôi muốn lấy một giá trị từ
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]45 bất cứ khi nào giá trị tương ứng trong
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]46 là
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']41 nếu không thì lấy giá trị từ
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]48. Việc hiểu danh sách làm điều này có thể trông giống như
[12, 4, 3] [7, 5, 8]73
Điều này có nhiều vấn đề. Đầu tiên, nó sẽ không nhanh lắm đối với các mảng lớn [vì tất cả công việc đang được thực hiện bằng Python thuần túy]. Thứ hai, nó sẽ không hoạt động với mảng nhiều chiều. Với
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]49, bạn có thể viết điều này rất ngắn gọn
[12, 4, 3] [7, 5, 8]74
Đối số thứ hai và thứ ba của
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]49 không cần phải là mảng; . Một cách sử dụng điển hình của
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]51 trong phân tích dữ liệu là tạo ra một mảng giá trị mới dựa trên một mảng khác. Giả sử bạn có một ma trận dữ liệu được tạo ngẫu nhiên và bạn muốn thay thế tất cả các giá trị dương bằng 2 và tất cả các giá trị âm bằng -2. Điều này rất dễ thực hiện với
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]49
[12, 4, 3] [7, 5, 8]75
Các mảng được chuyển đến
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]51 có thể không chỉ là mảng có kích thước bằng nhau hoặc vô hướng
Với một chút thông minh, bạn có thể sử dụng
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]51 để diễn đạt logic phức tạp hơn;
[12, 4, 3] [7, 5, 8]76
Mặc dù có thể không rõ ràng ngay lập tức, nhưng vòng lặp
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']58 này có thể được chuyển đổi thành một biểu thức
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]51 lồng nhau
[12, 4, 3] [7, 5, 8]77
Trong ví dụ cụ thể này, chúng ta cũng có thể tận dụng lợi thế của thực tế là các giá trị boolean được coi là 0 hoặc 1 trong các phép tính, do đó, điều này có thể được biểu thị [mặc dù khó hiểu hơn một chút] dưới dạng phép toán số học
[12, 4, 3] [7, 5, 8]78
Phương pháp toán học và thống kê
Một tập hợp các hàm toán học tính toán số liệu thống kê về toàn bộ mảng hoặc về dữ liệu dọc theo một trục có thể truy cập dưới dạng phương thức mảng. Tập hợp [thường được gọi là rút gọn] như
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]59,
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]60 và độ lệch chuẩn
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]61 có thể được sử dụng bằng cách gọi phương thức cá thể mảng hoặc sử dụng hàm NumPy cấp cao nhất
[12, 4, 3] [7, 5, 8]79
Các hàm như
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]60 và
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]59 lấy một đối số tùy chọn
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]64 để tính toán thống kê trên trục đã cho, dẫn đến một mảng có ít thứ nguyên hơn
''' Program to transpose a matrix using list comprehension'''
X = [[12,7],
[4 ,5],
[3 ,8]]
result = [[X[j][i] for j in range[len[X]]] for i in range[len[X[0]]]]
for r in result:
print[r]Các phương pháp khác như
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]65 và
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]66 không tổng hợp, thay vào đó tạo ra một mảng các kết quả trung gian
''' Program to transpose a matrix using list comprehension'''
X = [[12,7],
[4 ,5],
[3 ,8]]
result = [[X[j][i] for j in range[len[X]]] for i in range[len[X[0]]]]
for r in result:
print[r]Xem Bảng 4-5 để biết danh sách đầy đủ. Chúng ta sẽ thấy nhiều ví dụ về các phương pháp này đang hoạt động trong các chương sau
Bảng 4-5. Phương pháp thống kê mảng cơ bản
Phương thứcMô tả
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]59Tổng của tất cả các phần tử trong mảng hoặc dọc theo một trục. Mảng có độ dài bằng 0 có tổng bằng 0.
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]60Trung bình số học. Các mảng có độ dài bằng 0 có nghĩa là
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]13.
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]70Độ lệch chuẩn và phương sai tương ứng với bậc tự do tùy chọn điều chỉnh [mẫu số mặc định
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]71]. ________ 872 Tối thiểu và tối đa.
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]73Chỉ số của các phần tử tối thiểu và tối đa, tương ứng.
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]65Tích lũy của các phần tử bắt đầu từ 0
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]66Tích lũy của các phần tử bắt đầu từ 1
Các phương thức cho mảng Boolean
Các giá trị Boolean được ép buộc thành 1 [
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']41] và 0 [
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']42] trong các phương pháp trên. Do đó,
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]59 thường được sử dụng như một phương tiện để đếm các giá trị
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']41 trong một mảng boolean
''' Program to transpose a matrix using list comprehension'''
X = [[12,7],
[4 ,5],
[3 ,8]]
result = [[X[j][i] for j in range[len[X]]] for i in range[len[X[0]]]]
for r in result:
print[r]Có hai phương thức bổ sung,
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]80 và
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]81, đặc biệt hữu ích cho các mảng boolean.
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]80 kiểm tra xem một hoặc nhiều giá trị trong một mảng có phải là
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']41 hay không, trong khi
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]81 kiểm tra xem mọi giá trị có phải là
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']41 hay không
''' Program to transpose a matrix using list comprehension'''
X = [[12,7],
[4 ,5],
[3 ,8]]
result = [[X[j][i] for j in range[len[X]]] for i in range[len[X[0]]]]
for r in result:
print[r]Các phương thức này cũng hoạt động với các mảng không phải boolean, trong đó các phần tử khác 0 đánh giá là
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']41
Giống như kiểu danh sách có sẵn của Python, các mảng NumPy có thể được sắp xếp tại chỗ bằng phương thức
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]87
''' Program to transpose a matrix using list comprehension'''
X = [[12,7],
[4 ,5],
[3 ,8]]
result = [[X[j][i] for j in range[len[X]]] for i in range[len[X[0]]]]
for r in result:
print[r]Các mảng nhiều chiều có thể có từng phần giá trị 1D được sắp xếp tại chỗ dọc theo một trục bằng cách chuyển số trục cho
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]87
''' Program to transpose a matrix using list comprehension'''
X = [[12,7],
[4 ,5],
[3 ,8]]
result = [[X[j][i] for j in range[len[X]]] for i in range[len[X[0]]]]
for r in result:
print[r]Phương thức cấp cao nhất
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]89 trả về một bản sao được sắp xếp của một mảng thay vì sửa đổi mảng tại chỗ. Một cách nhanh chóng để tính lượng tử của một mảng là sắp xếp nó và chọn giá trị ở một thứ hạng cụ thể
''' Program to transpose a matrix using list comprehension'''
X = [[12,7],
[4 ,5],
[3 ,8]]
result = [[X[j][i] for j in range[len[X]]] for i in range[len[X[0]]]]
for r in result:
print[r]Để biết thêm chi tiết về cách sử dụng các phương pháp sắp xếp của NumPy và các kỹ thuật nâng cao hơn như sắp xếp gián tiếp, hãy xem Chương 12. Một số loại thao tác dữ liệu khác liên quan đến sắp xếp [ví dụ: sắp xếp bảng dữ liệu theo một hoặc nhiều cột] cũng được tìm thấy trong gấu trúc
Logic thiết lập duy nhất và khác
NumPy có một số thao tác thiết lập cơ bản cho ndarrays một chiều. Có lẽ cái được sử dụng phổ biến nhất là
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]90, trả về các giá trị duy nhất được sắp xếp trong một mảng
''' Program to transpose a matrix using list comprehension'''
X = [[12,7],
[4 ,5],
[3 ,8]]
result = [[X[j][i] for j in range[len[X]]] for i in range[len[X[0]]]]
for r in result:
print[r]Tương phản
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]90 với giải pháp thay thế Python thuần túy
''' Program to transpose a matrix using list comprehension'''
X = [[12,7],
[4 ,5],
[3 ,8]]
result = [[X[j][i] for j in range[len[X]]] for i in range[len[X[0]]]]
for r in result:
print[r]Một hàm khác,
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]92, kiểm tra tư cách thành viên của các giá trị trong một mảng trong một mảng khác, trả về một mảng boolean
''' Program to transpose a matrix using list comprehension'''
X = [[12,7],
[4 ,5],
[3 ,8]]
result = [[X[j][i] for j in range[len[X]]] for i in range[len[X[0]]]]
for r in result:
print[r]Xem Bảng 4-6 để biết danh sách các hàm đã đặt trong NumPy
Bảng 4-6. Hoạt động tập hợp mảng
Phương thứcMô tả
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]93Tính toán các phần tử duy nhất, đã sắp xếp trong
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]94
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]95Tính toán các phần tử phổ biến, đã sắp xếp trong
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]94 và
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]97
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]98Tính toán tổ hợp đã sắp xếp của các phần tử
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]99Tính toán một mảng boolean cho biết liệu mỗi phần tử của
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]94 có được chứa trong
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]97
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]02Đặt sự khác biệt, các phần tử trong In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]94 không có trong
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]97
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]05Đặt sự khác biệt đối xứng; NumPy có thể lưu và tải dữ liệu vào và từ đĩa ở định dạng văn bản hoặc nhị phân. Trong các chương sau, bạn sẽ tìm hiểu về các công cụ trong gấu trúc để đọc dữ liệu dạng bảng vào bộ nhớ
Lưu trữ mảng trên đĩa ở định dạng nhị phân
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]06 và In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]07 là hai hàm đặc biệt để lưu và tải dữ liệu mảng trên đĩa một cách hiệu quả. Mảng được lưu theo mặc định ở định dạng nhị phân thô không nén với phần mở rộng tệp In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]08In [8]: data
Out[8]:
array[[[ 0.9526, -0.246 , -0.8856],
[ 0.5639, 0.2379, 0.9104]]]
In [9]: data * 10 In [10]: data + data
Out[9]: Out[10]:
array[[[ 9.5256, -2.4601, -8.8565], array[[[ 1.9051, -0.492 , -1.7713],
[ 5.6385, 2.3794, 9.104 ]]] [ 1.1277, 0.4759, 1.8208]]]70Nếu đường dẫn tệp chưa kết thúc bằng
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]08, phần mở rộng sẽ được thêm vào. Mảng trên đĩa sau đó có thể được tải bằng cách sử dụng In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]07In [8]: data
Out[8]:
array[[[ 0.9526, -0.246 , -0.8856],
[ 0.5639, 0.2379, 0.9104]]]
In [9]: data * 10 In [10]: data + data
Out[9]: Out[10]:
array[[[ 9.5256, -2.4601, -8.8565], array[[[ 1.9051, -0.492 , -1.7713],
[ 5.6385, 2.3794, 9.104 ]]] [ 1.1277, 0.4759, 1.8208]]]71Bạn lưu nhiều mảng trong kho lưu trữ zip bằng cách sử dụng
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]11 và chuyển các mảng dưới dạng đối số từ khóaIn [8]: data
Out[8]:
array[[[ 0.9526, -0.246 , -0.8856],
[ 0.5639, 0.2379, 0.9104]]]
In [9]: data * 10 In [10]: data + data
Out[9]: Out[10]:
array[[[ 9.5256, -2.4601, -8.8565], array[[[ 1.9051, -0.492 , -1.7713],
[ 5.6385, 2.3794, 9.104 ]]] [ 1.1277, 0.4759, 1.8208]]]72Khi tải tệp
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]12, bạn nhận được một đối tượng giống như dict tải các mảng riêng lẻ một cách lười biếngIn [8]: data
Out[8]:
array[[[ 0.9526, -0.246 , -0.8856],
[ 0.5639, 0.2379, 0.9104]]]
In [9]: data * 10 In [10]: data + data
Out[9]: Out[10]:
array[[[ 9.5256, -2.4601, -8.8565], array[[[ 1.9051, -0.492 , -1.7713],
[ 5.6385, 2.3794, 9.104 ]]] [ 1.1277, 0.4759, 1.8208]]]73Lưu và tải tệp văn bản
Tải văn bản từ tệp là một tác vụ khá chuẩn. Bối cảnh của các hàm đọc và ghi tệp trong Python có thể hơi khó hiểu đối với người mới, vì vậy tôi sẽ tập trung chủ yếu vào các hàm
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]13 và In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]14 trong gấu trúc. Đôi khi, sẽ hữu ích khi tải dữ liệu vào các mảng NumPy vanilla bằng cách sử dụng In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]15 hoặc In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]16 chuyên dụng hơnCác chức năng này có nhiều tùy chọn cho phép bạn chỉ định các dấu phân cách khác nhau, chức năng chuyển đổi cho các cột nhất định, bỏ qua các hàng và những thứ khác. Lấy một trường hợp đơn giản của tệp được phân tách bằng dấu phẩy [CSV] như thế này
In [8]: data
Out[8]:
array[[[ 0.9526, -0.246 , -0.8856],
[ 0.5639, 0.2379, 0.9104]]]
In [9]: data * 10 In [10]: data + data
Out[9]: Out[10]:
array[[[ 9.5256, -2.4601, -8.8565], array[[[ 1.9051, -0.492 , -1.7713],
[ 5.6385, 2.3794, 9.104 ]]] [ 1.1277, 0.4759, 1.8208]]]74Điều này có thể được tải vào một mảng 2D như vậy
In [8]: data
Out[8]:
array[[[ 0.9526, -0.246 , -0.8856],
[ 0.5639, 0.2379, 0.9104]]]
In [9]: data * 10 In [10]: data + data
Out[9]: Out[10]:
array[[[ 9.5256, -2.4601, -8.8565], array[[[ 1.9051, -0.492 , -1.7713],
[ 5.6385, 2.3794, 9.104 ]]] [ 1.1277, 0.4759, 1.8208]]]75In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]17 thực hiện thao tác nghịch đảo. viết một mảng vào một tệp văn bản được phân tách. In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]18 tương tự như In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]19 nhưng được thiết kế cho các mảng có cấu trúc và xử lý dữ liệu bị thiếu; Mẹo
Để biết thêm về cách đọc và ghi tệp, đặc biệt là dữ liệu dạng bảng hoặc bảng tính, hãy xem các chương sau liên quan đến gấu trúc và các đối tượng DataFrame
Đại số tuyến tính, như phép nhân ma trận, phân tách, định thức và phép toán ma trận vuông khác, là một phần quan trọng của bất kỳ thư viện mảng nào. Không giống như một số ngôn ngữ như MATLAB, phép nhân hai mảng hai chiều với
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]20 là một tích phần tử thay vì tích ma trận dấu chấm. Như vậy, có một hàm In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]21, vừa là một phương thức mảng, vừa là một hàm trong không gian tên In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]22, để nhân ma trậnIn [8]: data
Out[8]:
array[[[ 0.9526, -0.246 , -0.8856],
[ 0.5639, 0.2379, 0.9104]]]
In [9]: data * 10 In [10]: data + data
Out[9]: Out[10]:
array[[[ 9.5256, -2.4601, -8.8565], array[[[ 1.9051, -0.492 , -1.7713],
[ 5.6385, 2.3794, 9.104 ]]] [ 1.1277, 0.4759, 1.8208]]]76Tích ma trận giữa mảng 2D và mảng 1D có kích thước phù hợp dẫn đến mảng 1D
In [8]: data
Out[8]:
array[[[ 0.9526, -0.246 , -0.8856],
[ 0.5639, 0.2379, 0.9104]]]
In [9]: data * 10 In [10]: data + data
Out[9]: Out[10]:
array[[[ 9.5256, -2.4601, -8.8565], array[[[ 1.9051, -0.492 , -1.7713],
[ 5.6385, 2.3794, 9.104 ]]] [ 1.1277, 0.4759, 1.8208]]]77In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]23 có một bộ phân tách ma trận tiêu chuẩn và những thứ như nghịch đảo và định thức. Chúng được triển khai hoàn toàn bằng cách sử dụng cùng các thư viện Fortran tiêu chuẩn ngành được sử dụng trong các ngôn ngữ khác như MATLAB và R, chẳng hạn như BLAS, LAPACK hoặc có thể [tùy thuộc vào bản dựng NumPy của bạn] Intel MKLIn [8]: data
Out[8]:
array[[[ 0.9526, -0.246 , -0.8856],
[ 0.5639, 0.2379, 0.9104]]]
In [9]: data * 10 In [10]: data + data
Out[9]: Out[10]:
array[[[ 9.5256, -2.4601, -8.8565], array[[[ 1.9051, -0.492 , -1.7713],
[ 5.6385, 2.3794, 9.104 ]]] [ 1.1277, 0.4759, 1.8208]]]78Xem Bảng 4-7 để biết danh sách một số hàm đại số tuyến tính được sử dụng phổ biến nhất
Ghi chú
Cộng đồng khoa học Python hy vọng rằng một ngày nào đó có thể có một toán tử trung tố nhân ma trận được triển khai, cung cấp giải pháp thay thế đẹp hơn về mặt cú pháp cho việc sử dụng
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']87. Nhưng bây giờ đây là cách
Bảng 4-7. NumPy thường được sử dụng. hàm linalg
Chức năngMô tả
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]25Trả về các phần tử đường chéo [hoặc ngoài đường chéo] của ma trận vuông dưới dạng mảng 1D hoặc chuyển đổi mảng 1D thành ma trận vuông có các số 0 trên đường chéoIn [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]21Phép nhân ma trậnIn [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]27Tính tổng các phần tử đường chéoIn [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]28Tính toán định thức ma trậnIn [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]29Tính toán các giá trị riêng và vectơ riêng của Mô-đun
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']68 bổ sung cho Python
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]37 tích hợp sẵn các hàm để tạo hiệu quả toàn bộ mảng giá trị mẫu từ nhiều loại phân phối xác suất. Ví dụ: bạn có thể lấy một mảng mẫu 4 nhân 4 từ phân phối chuẩn chuẩn bằng cách sử dụng In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]38In [8]: data
Out[8]:
array[[[ 0.9526, -0.246 , -0.8856],
[ 0.5639, 0.2379, 0.9104]]]
In [9]: data * 10 In [10]: data + data
Out[9]: Out[10]:
array[[[ 9.5256, -2.4601, -8.8565], array[[[ 1.9051, -0.492 , -1.7713],
[ 5.6385, 2.3794, 9.104 ]]] [ 1.1277, 0.4759, 1.8208]]]79Ngược lại, mô-đun
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]37 tích hợp sẵn của Python chỉ lấy mẫu một giá trị tại một thời điểm. Như bạn có thể thấy từ tiêu chuẩn này, In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']68 nhanh hơn rất nhiều so với thứ tự cường độ để tạo các mẫu rất lớn
In [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]10
Xem Bảng 4-8 để biết một phần danh sách các chức năng có sẵn trong
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']68. Tôi sẽ đưa ra một số ví dụ về việc tận dụng khả năng của các chức năng này để tạo ra các mảng mẫu lớn cùng một lúc trong phần tiếp theo
Bảng 4-8. Danh sách một phần của numpy. chức năng ngẫu nhiên
Chức năng Mô tả
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]42Gieo trình tạo số ngẫu nhiênIn [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]43Trả về một hoán vị ngẫu nhiên của một chuỗi hoặc trả về một phạm vi được hoán vịIn [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]44Hoán vị ngẫu nhiên một chuỗi tại vị tríIn [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]45Lấy mẫu từ một phân phối đồng nhấtIn [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]46Rút các số nguyên ngẫu nhiên từ một phạm vi thấp đến cao nhất địnhIn [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']67Lấy các mẫu từ một phân phối bình thường với giá trị trung bình 0 và độ lệch chuẩn 1
Một ứng dụng minh họa của việc sử dụng các phép toán mảng là mô phỏng các bước đi ngẫu nhiên. Trước tiên, hãy xem xét bước đi ngẫu nhiên đơn giản bắt đầu từ 0 với các bước 1 và -1 xảy ra với xác suất bằng nhau. Một cách Python thuần túy để thực hiện một bước đi ngẫu nhiên duy nhất với 1.000 bước bằng cách sử dụng mô-đun
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]37 tích hợpIn [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]11
Xem Hình 4-4 để biết biểu đồ ví dụ về 100 giá trị đầu tiên trên một trong các bước đi ngẫu nhiên này
Hình 4-4. Đi bộ ngẫu nhiên đơn giản
Bạn có thể nhận xét rằng
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]55 chỉ đơn giản là tổng tích lũy của các bước ngẫu nhiên và có thể được đánh giá dưới dạng biểu thức mảng. Vì vậy, tôi sử dụng mô-đun In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]56 để rút 1.000 lần tung đồng xu cùng một lúc, đặt các giá trị này thành 1 và -1 và tính tổng tích lũyIn [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]12
Từ đó, chúng tôi có thể bắt đầu trích xuất các số liệu thống kê như giá trị tối thiểu và tối đa dọc theo quỹ đạo của bước đi
In [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]13
Một thống kê phức tạp hơn là thời gian băng qua đường đầu tiên, bước mà tại đó bước đi ngẫu nhiên đạt đến một giá trị cụ thể. Ở đây, chúng ta có thể muốn biết mất bao lâu để bước đi ngẫu nhiên cách gốc tọa độ 0 ít nhất 10 bước theo cả hai hướng.
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]57 cung cấp cho chúng tôi một mảng boolean cho biết nơi đi bộ đã đạt hoặc vượt quá 10, nhưng chúng tôi muốn chỉ mục của 10 hoặc -10 đầu tiên. Hóa ra điều này có thể được tính toán bằng cách sử dụng In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]58, trả về chỉ số đầu tiên của giá trị lớn nhất trong mảng boolean [In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']41 là giá trị lớn nhất]
In [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]14
Lưu ý rằng việc sử dụng
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]58 ở đây không phải lúc nào cũng hiệu quả vì nó luôn quét toàn bộ mảng. Trong trường hợp đặc biệt này, khi quan sát thấy một In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']41, chúng tôi biết đó là giá trị lớn nhất
Mô phỏng nhiều bước đi ngẫu nhiên cùng một lúc
Nếu mục tiêu của bạn là mô phỏng nhiều bước đi ngẫu nhiên, chẳng hạn như 5.000 bước đi trong số đó, bạn có thể tạo tất cả các bước đi ngẫu nhiên bằng các sửa đổi nhỏ đối với đoạn mã trên. Các hàm
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']68 nếu được truyền 2-tuple sẽ tạo ra một mảng 2D gồm các lượt rút thăm và chúng ta có thể tính tổng tích lũy trên các hàng để tính toán tất cả 5.000 bước đi ngẫu nhiên trong một lần chụp
In [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]15
Bây giờ, chúng ta có thể tính các giá trị lớn nhất và nhỏ nhất thu được trên tất cả các bước đi
In [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]16
Trong số những lần đi bộ này, hãy tính thời gian băng qua đường tối thiểu là 30 hoặc -30. Điều này hơi khó vì không phải tất cả 5.000 trong số họ đều đạt 30. Chúng ta có thể kiểm tra điều này bằng phương pháp
In [13]: data1 = [6, 7.5, 8, 0, 1] In [14]: arr1 = np.array[data1] In [15]: arr1 Out[15]: array[[ 6. , 7.5, 8. , 0. , 1. ]]80
In [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]17
Chúng ta có thể sử dụng mảng boolean này để chọn ra các hàng của
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]64 thực sự vượt qua mức 30 tuyệt đối và gọi In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]58 trên trục 1 để lấy thời gian vượt quaIn [35]: arr = np.array[[3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [36]: arr Out[36]: array[[ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1]] In [37]: arr.astype[np.int32] Out[37]: array[[ 3, -1, -2, 0, 12, 10], dtype=int32]18
Vui lòng thử nghiệm với các bản phân phối khác cho các bước khác với việc tung đồng xu có kích thước bằng nhau. Bạn chỉ cần sử dụng một hàm tạo số ngẫu nhiên khác, chẳng hạn như
In [16]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [17]: arr2 = np.array[data2]
In [18]: arr2
Out[18]:
array[[[1, 2, 3, 4],
[5, 6, 7, 8]]]
In [19]: arr2.ndim
Out[19]: 2
In [20]: arr2.shape
Out[20]: [2, 4]38 để tạo các bước phân phối chuẩn với một số độ lệch chuẩn và trung bình