Trong phần này, chúng ta sẽ tạo một chương trình Java để hiển thị các số lẻ từ 1 đến 100. Để học chương trình số lẻ Java, bạn phải có kiến thức cơ bản về vòng lặp for và câu lệnh if trong Java
Chúng ta có thể sử dụng các vòng lặp Java khác nhau để hiển thị các số lẻ
- Sử dụng Java cho vòng lặp
- Sử dụng Câu lệnh if lồng nhau
- Sử dụng Vòng lặp While
Sử dụng Java cho vòng lặp
Trong ví dụ sau, chúng tôi đã khai báo một biến có tên là số và khởi tạo nó bằng 100 [giới hạn in số lẻ]. Chúng tôi đã sử dụng một vòng lặp for thực hiện tới 100 lần và với mỗi lần lặp của i, câu lệnh if sẽ kiểm tra số đó có phải là số lẻ hay không. Sau khi in ra mỗi số lẻ giá trị i tăng lên 1
Để kiểm tra số đã chia cho 2 nếu nó dư, số đó là số lẻ và câu lệnh print in ra số đó
Hiển thịSố lẻVí dụ1. java
đầu ra
List of odd numbers from 1 to 100: 1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51 53 55 57 59 61 63 65 67 69 71 73 75 77 79 81 83 85 87 89 91 93 95 97 99
Sử dụng Câu lệnh if lồng nhau
Chương trình sau hơi khác so với chương trình trên vì chúng ta đã định nghĩa một phương thức chứa logic để kiểm tra số lẻ. Bên trong phương thức, chúng tôi đã sử dụng câu lệnh if lồng nhau
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
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. ]]
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 [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;
In [21]: arr1.dtype Out[21]: dtype['float64'] In [22]: arr2.dtype Out[22]: dtype['int64']
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
In [23]: np.zeros[10] Out[23]: array[[ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]] In [24]: np.zeros[[3, 6]] Out[24]: array[[[ 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0.]]] In [25]: np.empty[[2, 3, 2]] Out[25]: array[[[[ 4.94065646e-324, 4.94065646e-324], [ 3.87491056e-297, 2.46845796e-130], [ 4.94065646e-324, 4.94065646e-324]], [[ 1.90723115e+083, 5.73293533e-053], [ -2.33568637e+124, -6.70608105e-012], [ 4.42786966e+160, 1.27100354e+025]]]]
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 tích hợp sẵn trong Python
In [26]: np.arange[15] Out[26]: array[[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]]
Xem 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
Mô tả chức nă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]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_______4_______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 [27]: arr1 = np.array[[1, 2, 3], dtype=np.float64] In [28]: arr2 = np.array[[1, 2, 3], dtype=np.int32] In [29]: arr1.dtype In [30]: arr2.dtype Out[29]: dtype['float64'] Out[30]: dtype['int32']
Dtypes 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 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
TypeType CodeDescription
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']22Signed and unsigned 8-bit [1 byte] integer types
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']24Signed and unsigned 16-bit integer types
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']26Signed and unsigned 32-bit integer types
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']28Signed and unsigned 32-bit integer types
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']30Half-precision floating point
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']31
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']32Standard single-precision floating point. Tương thích với C float_______4_______02_______4_______34Dấu chấm động có độ chính xác kép tiêu chuẩn. Tương thích với C double và Python
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']17 object
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']36
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 diễn lần lượt bằng hai số float 32, 64 hoặc 128
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']43Loại đối tượng OPython
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']44S Kiểu chuỗi ký tự có độ dài cố định. 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 truyền 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 [31]: arr = np.array[[1, 2, 3, 4, 5]] In [32]: arr.dtype Out[32]: dtype['int64'] In [33]: float_arr = arr.astype[np.float64] In [34]: float_arr.dtype Out[34]: dtype['float64']
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 chuỗi 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 lý do nào đó [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], một số
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 ra 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 xấp xỉ các đại lượng phân số. Trong các tính toán 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 phép toán 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, 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 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 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 ngẫu nhiên có phân phối 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. ]]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]0
Mả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]1
Mả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]3
Chọ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]4
Chọ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]6
Lậ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]8
Hy 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]9
Truyền nhiều mảng chỉ mục sẽ làm điều gì đó hơi khác một chút;
In [21]: arr1.dtype Out[21]: dtype['float64'] In [22]: arr2.dtype Out[22]: dtype['int64']0
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 đó
In [21]: arr1.dtype Out[21]: dtype['float64'] In [22]: arr2.dtype Out[22]: dtype['int64']1
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
In [21]: arr1.dtype Out[21]: dtype['float64'] In [22]: arr2.dtype Out[22]: dtype['int64']2
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
In [21]: arr1.dtype Out[21]: dtype['float64'] In [22]: arr2.dtype Out[22]: dtype['int64']3
Khi tính toán ma trận, bạn sẽ làm điều 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
In [21]: arr1.dtype Out[21]: dtype['float64'] In [22]: arr2.dtype Out[22]: dtype['int64']4
Đố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]
In [21]: arr1.dtype Out[21]: dtype['float64'] In [22]: arr2.dtype Out[22]: dtype['int64']5
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
In [21]: arr1.dtype Out[21]: dtype['float64'] In [22]: arr2.dtype Out[22]: dtype['int64']6
In [11]: data.shape Out[11]: [2, 3] In [12]: data.dtype Out[12]: dtype['float64']90 tương tự trả về một 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
In [21]: arr1.dtype Out[21]: dtype['float64'] In [22]: arr2.dtype Out[22]: dtype['int64']7
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ả
In [21]: arr1.dtype Out[21]: dtype['float64'] In [22]: arr2.dtype Out[22]: dtype['int64']8
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ụ, 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
In [21]: arr1.dtype Out[21]: dtype['float64'] In [22]: arr2.dtype Out[22]: dtype['int64']9
Xem và để 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_______4_______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 số mũ cũ của từng phần tử_______6_______05Lôgarit 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 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 giá trị 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ử_______6_______08Tính sàn của từng phần tử, i. e. số nguyên lớn nhất nhỏ hơn hoặc bằng mỗi phần tử_______6_______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 liệu 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 phổ nhị phân
Chức năngMô 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ừ mảng thứ nhất khỏi mảng thứ nhất_______6_______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 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ử 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. ]]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
In [23]: np.zeros[10] Out[23]: array[[ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]] In [24]: np.zeros[[3, 6]] Out[24]: array[[[ 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0.]]] In [25]: np.empty[[2, 3, 2]] Out[25]: array[[[[ 4.94065646e-324, 4.94065646e-324], [ 3.87491056e-297, 2.46845796e-130], [ 4.94065646e-324, 4.94065646e-324]], [[ 1.90723115e+083, 5.73293533e-053], [ -2.33568637e+124, -6.70608105e-012], [ 4.42786966e+160, 1.27100354e+025]]]]0
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
In [23]: np.zeros[10] Out[23]: array[[ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]] In [24]: np.zeros[[3, 6]] Out[24]: array[[[ 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0.]]] In [25]: np.empty[[2, 3, 2]] Out[25]: array[[[[ 4.94065646e-324, 4.94065646e-324], [ 3.87491056e-297, 2.46845796e-130], [ 4.94065646e-324, 4.94065646e-324]], [[ 1.90723115e+083, 5.73293533e-053], [ -2.33568637e+124, -6.70608105e-012], [ 4.42786966e+160, 1.27100354e+025]]]]1
Thấy. Ở đâ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 bậc ba
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ị
In [23]: np.zeros[10] Out[23]: array[[ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]] In [24]: np.zeros[[3, 6]] Out[24]: array[[[ 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0.]]] In [25]: np.empty[[2, 3, 2]] Out[25]: array[[[[ 4.94065646e-324, 4.94065646e-324], [ 3.87491056e-297, 2.46845796e-130], [ 4.94065646e-324, 4.94065646e-324]], [[ 1.90723115e+083, 5.73293533e-053], [ -2.33568637e+124, -6.70608105e-012], [ 4.42786966e+160, 1.27100354e+025]]]]2
Giả sử chúng ta 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ư
In [23]: np.zeros[10] Out[23]: array[[ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]] In [24]: np.zeros[[3, 6]] Out[24]: array[[[ 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0.]]] In [25]: np.empty[[2, 3, 2]] Out[25]: array[[[[ 4.94065646e-324, 4.94065646e-324], [ 3.87491056e-297, 2.46845796e-130], [ 4.94065646e-324, 4.94065646e-324]], [[ 1.90723115e+083, 5.73293533e-053], [ -2.33568637e+124, -6.70608105e-012], [ 4.42786966e+160, 1.27100354e+025]]]]3
Đ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
In [23]: np.zeros[10] Out[23]: array[[ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]] In [24]: np.zeros[[3, 6]] Out[24]: array[[[ 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0.]]] In [25]: np.empty[[2, 3, 2]] Out[25]: array[[[[ 4.94065646e-324, 4.94065646e-324], [ 3.87491056e-297, 2.46845796e-130], [ 4.94065646e-324, 4.94065646e-324]], [[ 1.90723115e+083, 5.73293533e-053], [ -2.33568637e+124, -6.70608105e-012], [ 4.42786966e+160, 1.27100354e+025]]]]4
Đố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
In [23]: np.zeros[10] Out[23]: array[[ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]] In [24]: np.zeros[[3, 6]] Out[24]: array[[[ 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0.]]] In [25]: np.empty[[2, 3, 2]] Out[25]: array[[[[ 4.94065646e-324, 4.94065646e-324], [ 3.87491056e-297, 2.46845796e-130], [ 4.94065646e-324, 4.94065646e-324]], [[ 1.90723115e+083, 5.73293533e-053], [ -2.33568637e+124, -6.70608105e-012], [ 4.42786966e+160, 1.27100354e+025]]]]5
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;
In [23]: np.zeros[10] Out[23]: array[[ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]] In [24]: np.zeros[[3, 6]] Out[24]: array[[[ 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0.]]] In [25]: np.empty[[2, 3, 2]] Out[25]: array[[[[ 4.94065646e-324, 4.94065646e-324], [ 3.87491056e-297, 2.46845796e-130], [ 4.94065646e-324, 4.94065646e-324]], [[ 1.90723115e+083, 5.73293533e-053], [ -2.33568637e+124, -6.70608105e-012], [ 4.42786966e+160, 1.27100354e+025]]]]6
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
In [23]: np.zeros[10] Out[23]: array[[ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]] In [24]: np.zeros[[3, 6]] Out[24]: array[[[ 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0.]]] In [25]: np.empty[[2, 3, 2]] Out[25]: array[[[[ 4.94065646e-324, 4.94065646e-324], [ 3.87491056e-297, 2.46845796e-130], [ 4.94065646e-324, 4.94065646e-324]], [[ 1.90723115e+083, 5.73293533e-053], [ -2.33568637e+124, -6.70608105e-012], [ 4.42786966e+160, 1.27100354e+025]]]]7
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
In [23]: np.zeros[10] Out[23]: array[[ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]] In [24]: np.zeros[[3, 6]] Out[24]: array[[[ 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0.]]] In [25]: np.empty[[2, 3, 2]] Out[25]: array[[[[ 4.94065646e-324, 4.94065646e-324], [ 3.87491056e-297, 2.46845796e-130], [ 4.94065646e-324, 4.94065646e-324]], [[ 1.90723115e+083, 5.73293533e-053], [ -2.33568637e+124, -6.70608105e-012], [ 4.42786966e+160, 1.27100354e+025]]]]8
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
In [23]: np.zeros[10] Out[23]: array[[ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]] In [24]: np.zeros[[3, 6]] Out[24]: array[[[ 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0.]]] In [25]: np.empty[[2, 3, 2]] Out[25]: array[[[[ 4.94065646e-324, 4.94065646e-324], [ 3.87491056e-297, 2.46845796e-130], [ 4.94065646e-324, 4.94065646e-324]], [[ 1.90723115e+083, 5.73293533e-053], [ -2.33568637e+124, -6.70608105e-012], [ 4.42786966e+160, 1.27100354e+025]]]]9
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ố
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ùy chọn để 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
In [26]: np.arange[15] Out[26]: array[[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]]0
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
In [26]: np.arange[15] Out[26]: array[[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]]1
Xem 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].
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. ]]72Tố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 [_______4_______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
In [26]: np.arange[15] Out[26]: array[[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]]2
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
In [26]: np.arange[15] Out[26]: array[[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]]3
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, mảng NumPy có thể được sắp xếp tại chỗ bằng cách sử dụ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
In [26]: np.arange[15] Out[26]: array[[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]]4
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
In [26]: np.arange[15] Out[26]: array[[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]]5
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 đã 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 toán 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ể
In [26]: np.arange[15] Out[26]: array[[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]]6
Để 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
In [26]: np.arange[15] Out[26]: array[[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]]7
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
In [26]: np.arange[15] Out[26]: array[[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]]8
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
In [26]: np.arange[15] Out[26]: array[[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]]9
Xem danh sách các chức năng thiết lập 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_______6_______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_______6_______98Tính toán tập hợp các phần tử đã sắp xếp_______6_______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ó nằm 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]02Tập hợp các phần tử 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. ]]07Set_________6 không đối xứng hay khô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]08
In [27]: arr1 = np.array[[1, 2, 3], dtype=np.float64] In [28]: arr2 = np.array[[1, 2, 3], dtype=np.int32] In [29]: arr1.dtype In [30]: arr2.dtype Out[29]: dtype['float64'] Out[30]: dtype['int32']0
Nế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]07
In [27]: arr1 = np.array[[1, 2, 3], dtype=np.float64] In [28]: arr2 = np.array[[1, 2, 3], dtype=np.int32] In [29]: arr1.dtype In [30]: arr2.dtype Out[29]: dtype['float64'] Out[30]: dtype['int32']1
Bạ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óa
In [27]: arr1 = np.array[[1, 2, 3], dtype=np.float64] In [28]: arr2 = np.array[[1, 2, 3], dtype=np.int32] In [29]: arr1.dtype In [30]: arr2.dtype Out[29]: dtype['float64'] Out[30]: dtype['int32']2
Khi tải một 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ếng
In [27]: arr1 = np.array[[1, 2, 3], dtype=np.float64] In [28]: arr2 = np.array[[1, 2, 3], dtype=np.int32] In [29]: arr1.dtype In [30]: arr2.dtype Out[29]: dtype['float64'] Out[30]: dtype['int32']3
Lư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 pandas. Đô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 chuyên biệt hơ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]16
Cá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 [27]: arr1 = np.array[[1, 2, 3], dtype=np.float64] In [28]: arr2 = np.array[[1, 2, 3], dtype=np.int32] In [29]: arr1.dtype In [30]: arr2.dtype Out[29]: dtype['float64'] Out[30]: dtype['int32']4
Điều này có thể được tải vào một mảng 2D như vậy
In [27]: arr1 = np.array[[1, 2, 3], dtype=np.float64] In [28]: arr2 = np.array[[1, 2, 3], dtype=np.int32] In [29]: arr1.dtype In [30]: arr2.dtype Out[29]: dtype['float64'] Out[30]: dtype['int32']5
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]17 thực hiện phép toán 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. 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ận
In [27]: arr1 = np.array[[1, 2, 3], dtype=np.float64] In [28]: arr2 = np.array[[1, 2, 3], dtype=np.int32] In [29]: arr1.dtype In [30]: arr2.dtype Out[29]: dtype['float64'] Out[30]: dtype['int32']6
Tí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 [27]: arr1 = np.array[[1, 2, 3], dtype=np.float64] In [28]: arr2 = np.array[[1, 2, 3], dtype=np.int32] In [29]: arr1.dtype In [30]: arr2.dtype Out[29]: dtype['float64'] Out[30]: dtype['int32']7
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]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 MKL
In [27]: arr1 = np.array[[1, 2, 3], dtype=np.float64] In [28]: arr2 = np.array[[1, 2, 3], dtype=np.int32] In [29]: arr1.dtype In [30]: arr2.dtype Out[29]: dtype['float64'] Out[30]: dtype['int32']8
Xem 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éo
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]21Phép nhân ma trậ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]27Tính tổng các phần tử đường chéo
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]28Tính toán định thức ma trậ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]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
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 trong Python với 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]38
In [27]: arr1 = np.array[[1, 2, 3], dtype=np.float64] In [28]: arr2 = np.array[[1, 2, 3], dtype=np.int32] In [29]: arr1.dtype In [30]: arr2.dtype Out[29]: dtype['float64'] Out[30]: dtype['int32']9
Ngượ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 để tạo ra các mẫu rất lớn
In [31]: arr = np.array[[1, 2, 3, 4, 5]] In [32]: arr.dtype Out[32]: dtype['int64'] In [33]: float_arr = arr.astype[np.float64] In [34]: float_arr.dtype Out[34]: dtype['float64']0
Xem danh sách một phần 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ă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]42Gieo bộ tạo số ngẫu nhiê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]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 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 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]45Lấy các mẫu từ một phân phối đồng nhấ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]46Rút các số nguyên ngẫu nhiên từ một phạm vi từ thấp đến cao nhất định
In [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 để triển khai 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ợp
In [31]: arr = np.array[[1, 2, 3, 4, 5]] In [32]: arr.dtype Out[32]: dtype['int64'] In [33]: float_arr = arr.astype[np.float64] In [34]: float_arr.dtype Out[34]: dtype['float64']1
Xem một biểu đồ ví dụ về 100 giá trị đầu tiên trên một trong những 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ũy
In [31]: arr = np.array[[1, 2, 3, 4, 5]] In [32]: arr.dtype Out[32]: dtype['int64'] In [33]: float_arr = arr.astype[np.float64] In [34]: float_arr.dtype Out[34]: dtype['float64']2
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 [31]: arr = np.array[[1, 2, 3, 4, 5]] In [32]: arr.dtype Out[32]: dtype['int64'] In [33]: float_arr = arr.astype[np.float64] In [34]: float_arr.dtype Out[34]: dtype['float64']3
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ỉ số của 10 hoặc -10 đầu tiên. Hóa ra điều này có thể được tính 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 [31]: arr = np.array[[1, 2, 3, 4, 5]] In [32]: arr.dtype Out[32]: dtype['int64'] In [33]: float_arr = arr.astype[np.float64] In [34]: float_arr.dtype Out[34]: dtype['float64']4
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ố đó, thì 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 thông qua 2 bộ 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 [31]: arr = np.array[[1, 2, 3, 4, 5]] In [32]: arr.dtype Out[32]: dtype['int64'] In [33]: float_arr = arr.astype[np.float64] In [34]: float_arr.dtype Out[34]: dtype['float64']5
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 [31]: arr = np.array[[1, 2, 3, 4, 5]] In [32]: arr.dtype Out[32]: dtype['int64'] In [33]: float_arr = arr.astype[np.float64] In [34]: float_arr.dtype Out[34]: dtype['float64']6
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 cách sử dụ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 [31]: arr = np.array[[1, 2, 3, 4, 5]] In [32]: arr.dtype Out[32]: dtype['int64'] In [33]: float_arr = arr.astype[np.float64] In [34]: float_arr.dtype Out[34]: dtype['float64']7
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 qua
In [31]: arr = np.array[[1, 2, 3, 4, 5]] In [32]: arr.dtype Out[32]: dtype['int64'] In [33]: float_arr = arr.astype[np.float64] In [34]: float_arr.dtype Out[34]: dtype['float64']8
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 có phân phối chuẩn với một số độ lệch chuẩn và trung bình