Đảo ngược thứ tự của các phần tử trong một mảng dọc theo trục đã cho. Hình dạng của mảng được bảo tồn, nhưng các yếu tố được sắp xếp lại. Mới trong phiên bản 1.12.0. Mảng đầu vào. Trục hoặc trục dọc theo đó để lật qua. Mặc định, trục = không có, sẽ lật trên tất cả các trục của mảng đầu vào. Nếu trục âm thì nó được tính từ trục cuối cùng đến trục đầu tiên. Nếu trục là một bộ dữ liệu của INT, việc lật được thực hiện trên tất cả các trục được chỉ định trong bộ tuple. Đã thay đổi trong phiên bản 1.15.0: Không có và bộ dữ liệu của trục được hỗ trợNone and tuples of axes are supported Một cái nhìn của M với các mục của trục đảo ngược. Vì một chế độ xem được trả về, hoạt động này được thực hiện trong thời gian không đổi. Xem thêm Lật một mảng theo chiều dọc [trục = 0]. Lật một mảng theo chiều ngang [trục = 1]. Ghi chú
6import numpy as np
a = np.array[[1, 2, 3]] # Tạo một numpy array với rank = 1
print[type[a]] # Sẽ in ra ""
print[a.shape] # Sẽ in ra "[3,]"
print[a[0], a[1], a[2]] # Sẽ in ra "1 2 3"
a[0] = 5 # Thay đổi giá trị của 1 phần tử trong mảng
print[a] # Sẽ in ra kết quả là "[5, 2, 3]"
b = np.array[[[1,2,3],[4,5,6]]] # Tạo một numpy array với rank =2
print[b.shape] # In ra "[2, 3]"
print[b[0, 0], b[0, 1], b[1, 0]] # Sẽ in ra "1 2 4"
7import numpy as np
a = np.array[[1, 2, 3]] # Tạo một numpy array với rank = 1
print[type[a]] # Sẽ in ra ""
print[a.shape] # Sẽ in ra "[3,]"
print[a[0], a[1], a[2]] # Sẽ in ra "1 2 3"
a[0] = 5 # Thay đổi giá trị của 1 phần tử trong mảng
print[a] # Sẽ in ra kết quả là "[5, 2, 3]"
b = np.array[[[1,2,3],[4,5,6]]] # Tạo một numpy array với rank =2
print[b.shape] # In ra "[2, 3]"
print[b[0, 0], b[0, 1], b[1, 0]] # Sẽ in ra "1 2 4"
lật [m, 0] tương đương với flipud [m].
lật [m, 1] tương đương với fliplr [m].
lật [m, n] tương ứng với
import numpy as np
a = np.array[[1, 2, 3]] # Tạo một numpy array với rank = 1
print[type[a]] # Sẽ in ra ""
print[a.shape] # Sẽ in ra "[3,]"
print[a[0], a[1], a[2]] # Sẽ in ra "1 2 3"
a[0] = 5 # Thay đổi giá trị của 1 phần tử trong mảng
print[a] # Sẽ in ra kết quả là "[5, 2, 3]"
b = np.array[[[1,2,3],[4,5,6]]] # Tạo một numpy array với rank =2
print[b.shape] # In ra "[2, 3]"
print[b[0, 0], b[0, 1], b[1, 0]] # Sẽ in ra "1 2 4"
import numpy as np
a = np.array[[1, 2, 3]] # Tạo một numpy array với rank = 1
print[type[a]] # Sẽ in ra ""
print[a.shape] # Sẽ in ra "[3,]"
print[a[0], a[1], a[2]] # Sẽ in ra "1 2 3"
a[0] = 5 # Thay đổi giá trị của 1 phần tử trong mảng
print[a] # Sẽ in ra kết quả là "[5, 2, 3]"
b = np.array[[[1,2,3],[4,5,6]]] # Tạo một numpy array với rank =2
print[b.shape] # In ra "[2, 3]"
print[b[0, 0], b[0, 1], b[1, 0]] # Sẽ in ra "1 2 4"
lật [m] tương ứng với
import numpy as np
a = np.zeros[[2,2]] # Tạo một numpy array với tất cả phẩn tử là 0
print[a] # "[[ 0. 0.]
# [ 0. 0.]]"
b = np.ones[[1,2]] # Tạo một numpy array với tất cả phẩn tử là 1
print[b] # "[[ 1. 1.]]"
c = np.full[[2,2], 7] # Tạo một mảng hằng
print[c] # "[[ 7. 7.]
# [ 7. 7.]]"
d = np.eye[2] # Tạo một ma trận đơn vị 2 x 2
print[d] # "[[ 1. 0.]
# [ 0. 1.]]"
e = np.random.random[[2,2]] # Tạo một mảng với các giá trị ngẫu nhiên
print[e] # Có thể là "[[ 0.91940167 0.08143941]
# [ 0.68744134 0.87236687]]"
f = np.arange[10] # Tạo 1 numpy array với các phẩn tử từ 0 đến 9
print[f] # "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
import numpy as np
a = np.array[[1, 2, 3]] # Tạo một numpy array với rank = 1
print[type[a]] # Sẽ in ra ""
print[a.shape] # Sẽ in ra "[3,]"
print[a[0], a[1], a[2]] # Sẽ in ra "1 2 3"
a[0] = 5 # Thay đổi giá trị của 1 phần tử trong mảng
print[a] # Sẽ in ra kết quả là "[5, 2, 3]"
b = np.array[[[1,2,3],[4,5,6]]] # Tạo một numpy array với rank =2
print[b.shape] # In ra "[2, 3]"
print[b[0, 0], b[0, 1], b[1, 0]] # Sẽ in ra "1 2 4"
lật [m, [0, 1]] tương ứng với
import numpy as np
a = np.zeros[[2,2]] # Tạo một numpy array với tất cả phẩn tử là 0
print[a] # "[[ 0. 0.]
# [ 0. 0.]]"
b = np.ones[[1,2]] # Tạo một numpy array với tất cả phẩn tử là 1
print[b] # "[[ 1. 1.]]"
c = np.full[[2,2], 7] # Tạo một mảng hằng
print[c] # "[[ 7. 7.]
# [ 7. 7.]]"
d = np.eye[2] # Tạo một ma trận đơn vị 2 x 2
print[d] # "[[ 1. 0.]
# [ 0. 1.]]"
e = np.random.random[[2,2]] # Tạo một mảng với các giá trị ngẫu nhiên
print[e] # Có thể là "[[ 0.91940167 0.08143941]
# [ 0.68744134 0.87236687]]"
f = np.arange[10] # Tạo 1 numpy array với các phẩn tử từ 0 đến 9
print[f] # "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
import numpy as np
a = np.array[[1, 2, 3]] # Tạo một numpy array với rank = 1
print[type[a]] # Sẽ in ra ""
print[a.shape] # Sẽ in ra "[3,]"
print[a[0], a[1], a[2]] # Sẽ in ra "1 2 3"
a[0] = 5 # Thay đổi giá trị của 1 phần tử trong mảng
print[a] # Sẽ in ra kết quả là "[5, 2, 3]"
b = np.array[[[1,2,3],[4,5,6]]] # Tạo một numpy array với rank =2
print[b.shape] # In ra "[2, 3]"
print[b[0, 0], b[0, 1], b[1, 0]] # Sẽ in ra "1 2 4"
Ví dụ
>>> A = np.arange[8].reshape[[2,2,2]] >>> A array[[[[0, 1], [2, 3]], [[4, 5], [6, 7]]]] >>> np.flip[A, 0] array[[[[4, 5], [6, 7]], [[0, 1], [2, 3]]]] >>> np.flip[A, 1] array[[[[2, 3], [0, 1]], [[6, 7], [4, 5]]]] >>> np.flip[A] array[[[[7, 6], [5, 4]], [[3, 2], [1, 0]]]] >>> np.flip[A, [0, 2]] array[[[[5, 4], [7, 6]], [[1, 0], [3, 2]]]] >>> A = np.random.randn[3,4,5] >>> np.all[np.flip[A,2] == A[:,:,::-1,...]] True
Numpy
Lo là Numpy Đ-c biệt hữu ích khich thực hiện cac hàn liên Quan tới đại số tuyến tính.
Để Cài ĐặT
Sau Khim Vì nump .np
import numpy as np
a = np.zeros[[2,2]] # Tạo một numpy array với tất cả phẩn tử là 0
print[a] # "[[ 0. 0.]
# [ 0. 0.]]"
b = np.ones[[1,2]] # Tạo một numpy array với tất cả phẩn tử là 1
print[b] # "[[ 1. 1.]]"
c = np.full[[2,2], 7] # Tạo một mảng hằng
print[c] # "[[ 7. 7.]
# [ 7. 7.]]"
d = np.eye[2] # Tạo một ma trận đơn vị 2 x 2
print[d] # "[[ 1. 0.]
# [ 0. 1.]]"
e = np.random.random[[2,2]] # Tạo một mảng với các giá trị ngẫu nhiên
print[e] # Có thể là "[[ 0.91940167 0.08143941]
# [ 0.68744134 0.87236687]]"
f = np.arange[10] # Tạo 1 numpy array với các phẩn tử từ 0 đến 9
print[f] # "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
Mảng
Một mảng numpy là một lưới các gir trị, và tất Số Nguyễn Đưa ra Kích thước Của Mảng Theo Mỗi Chiều.rank của mảng Numpy, và shape là một tuple các số nguyên đưa ra kích thước của mảng theo mỗi chiều.
Chún ta ue thể khởi tạo numpy mảng từ danh sách python nest
import numpy as np
a = np.array[[1, 2, 3]] # Tạo một numpy array với rank = 1
print[type[a]] # Sẽ in ra ""
print[a.shape] # Sẽ in ra "[3,]"
print[a[0], a[1], a[2]] # Sẽ in ra "1 2 3"
a[0] = 5 # Thay đổi giá trị của 1 phần tử trong mảng
print[a] # Sẽ in ra kết quả là "[5, 2, 3]"
b = np.array[[[1,2,3],[4,5,6]]] # Tạo một numpy array với rank =2
print[b.shape] # In ra "[2, 3]"
print[b[0, 0], b[0, 1], b[1, 0]] # Sẽ in ra "1 2 4"
Numpy cũng cung cấp rất nhiều ha để khởi tạo
import numpy as np
a = np.zeros[[2,2]] # Tạo một numpy array với tất cả phẩn tử là 0
print[a] # "[[ 0. 0.]
# [ 0. 0.]]"
b = np.ones[[1,2]] # Tạo một numpy array với tất cả phẩn tử là 1
print[b] # "[[ 1. 1.]]"
c = np.full[[2,2], 7] # Tạo một mảng hằng
print[c] # "[[ 7. 7.]
# [ 7. 7.]]"
d = np.eye[2] # Tạo một ma trận đơn vị 2 x 2
print[d] # "[[ 1. 0.]
# [ 0. 1.]]"
e = np.random.random[[2,2]] # Tạo một mảng với các giá trị ngẫu nhiên
print[e] # Có thể là "[[ 0.91940167 0.08143941]
# [ 0.68744134 0.87236687]]"
f = np.arange[10] # Tạo 1 numpy array với các phẩn tử từ 0 đến 9
print[f] # "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
CNn rất nhiều hảm Để Khởi tạo mảng
Lập chỉ mục mảng
Numpy Cung Cấp Một Số Cách Để Truy Xuất Phần Tử Trong Mảng
Cắt lát: tương tự NH: Tương tự như list trong python, numpy arrays cũng có thể được cắt.
import numpy as np
# Khởi tạo numpy array có shape = [3, 4] có giá trị như sau:
# [[ 1 2 3 4]
# [ 5 6 7 8]
# [ 9 10 11 12]]
a = np.array[[[1,2,3,4], [5,6,7,8], [9,10,11,12]]]
# Sử dụng slicing để tạo numpy array b bằng cách lấy 2 hàng đầu tiên
# và cột 1, 2. Như vậy b sẽ có shape = [2, 2]:
# [[2 3]
# [6 7]]
b = a[:2, 1:3]
# Một array tạo ra từ slicing sẽ có cùng địa chỉ với array gốc.
# Nếu thay đổi 1 trong 2 thì array còn lại cũng thay đổi.
print[a[0, 1]] # Prints "2"
b[0, 0] = 77 # b[0, 0] ở đây tương đương với a[0, 1]
print[a[0, 1]] # Prints "77"
Bạn cũng đó là Kết Tuy Nhiênn, Cách lÀm Đó sẽ Cho ra một mảng mới đó là thứ hạng thấp hơn mảng gốc.
import numpy as np
# Tạo một numpy array có shape [3, 4] với giá trị như sau:
# [[ 1 2 3 4]
# [ 5 6 7 8]
# [ 9 10 11 12]]
a = np.array[[[1,2,3,4], [5,6,7,8], [9,10,11,12]]]
# Hai cách truy cập dữ liệu ở hàng giữa của mảng
# Dùng kết hợp chỉ số và slice -> được array mới có rank thấp hơn,
# Nếu chỉ dùng slice ta sẽ có 1 array mới có cùng rank
# với array gốc
row_r1 = a[1, :] # Rank 1, hàng thứ 2 của a
row_r2 = a[1:2, :] # Rank 2, vẫn là hàng thứ 2 của a
print[row_r1, row_r1.shape] # Prints "[5 6 7 8] [4,]"
print[row_r2, row_r2.shape] # Prints "[[5 6 7 8]] [1, 4]"
# Chúng ta có thể làm tương tự với cột của numpy array:
col_r1 = a[:, 1]
col_r2 = a[:, 1:2]
print[col_r1, col_r1.shape] # Prints "[ 2 6 10] [3,]"
print[col_r2, col_r2.shape] # Prints "[[ 2]
# [ 6]
# [10]] [3, 1]"
Integer Array Indexing: Khi Bạn Truy Xuất Mảng Dùng Clo,: Khi bạn truy xuất mảng dùng slicing, kết quả trả về sẽ là mảng con của mảng ban đầu, tuy nhiên sử dụng chỉ số mảng cho phép bạn xây dựng mảng tùy ý từ một mảng khác
import numpy as np
a = np.array[[[1,2], [3, 4], [5, 6]]]
# Truy xuất mảng dùng chỉ số.
# Kết quả thu được là 1 mảng có shape [3,]
print[a[[0, 1, 2], [0, 1, 0]]] # Prints "[1 4 5]"
# Sẽ thu được kết quả tương đương như trên với cách này:
print[np.array[[a[0, 0], a[1, 1], a[2, 0]]]] # Prints "[1 4 5]"
# Bạn được phép sử dụng chỉ số mảng để
# truy xuất tới 1 phần tử
# của mảng gốc nhiều hơn 1 lần
print[a[[0, 0], [1, 1]]] # Prints "[2 2]"
# Một cách làm khác tương đương:
print[np.array[[a[0, 1], a[0, 1]]]] # Prints "[2 2]"
Một mẹo hữu não
import numpy as np
# Tạo một mảng mới từ đó ta sẽ chọn các phần tử
a = np.array[[[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]]]
print[a] # prints "array[[[ 1, 2, 3],
# [ 4, 5, 6],
# [ 7, 8, 9],
# [10, 11, 12]]]"
# Tạo một mảng các chỉ số
b = np.array[[0, 2, 0, 1]]
# Lấy 1 phần tử từ mỗi hàng của a dùng với chỉ số ở mảng b
print[a[np.arange[4], b]] # Prints "[ 1 6 7 11]"
# Thay đổi một phẩn tử từ mỗi hàng của a dùng với chỉ số ở mảng b
a[np.arange[4], b] += 10
print[a] # prints "array[[[11, 2, 3],
# [ 4, 5, 16],
# [17, 8, 9],
# [10, 21, 12]]]
Lập chỉ mục mảng boolean: Cho Phép bạn chọn ra cac phần tử Tùy ý của một mảng: Cho phép bạn chọn ra các phần tử tùy ý của một mảng, thường được sử dụng để chọn ra các phần tử thỏa mãn điều kiện nào đó
import numpy as np
a = np.array[[[1,2], [3, 4], [5, 6]]]
bool_idx = [a > 2] # Tìm các phần tử lớn hơn 2;
# Trả về 1 numpy array of Booleans có shape như mảng a
# và giá trị tại mỗi phần tử là
# True nếu phần tử của a tại đó > 2,
# False cho trường hợp ngược lại.
print[bool_idx] # Prints "[[False False]
# [ True True]
# [ True True]]"
# Sử dụng một boolean array indexing để lấy
# các phần tử thỏa mãn điều kiện nhất định trong a
# Ví dụ ở đây in ra các giá trị của a > 2
# sử dụng array bool_idx đã tạo
print[a[bool_idx]] # Prints "[3 4 5 6]"
# Một cách ngắn gọn hơn:
print[a[a > 2]] # Prints "[3 4 5 6]"
Nếu bạn muốn tìm hiều nhiều hơn về numpy array lập chỉ mục
Loại dữ liệu
Mỗi numpy mảng là một lưới cac phần tử cùng kiểu dữ liệu. Numpy cung cấp một tập hợp lớn các kiểu dữ liệu số mà bạn đó Numpy cố gắng đroán một kiểu dữ liệu khim bạn tạo mộng
import numpy as np
x = np.array[[1, 2]] # Để numpy xác định kiểu dữ liệu
print[x.dtype] # Prints "int64"
x = np.array[[1.0, 2.0]] # Để numpy xác định kiểu dữ liệu
print[x.dtype] # Prints "float64"
x = np.array[[1, 2], dtype=np.int64] # Chỉ định kiều dữ liệu củ thể cho mảng
print[x.dtype] # Prints "int64"
Mảng Toán
Ghéph, cộng, NHÂN, Hoán vị chỉ với một dNng mã. Dưới đây là một số ví dụ về các phép Toán
import numpy as np
x = np.array[[[1,2],[3,4]], dtype=np.float64]
y = np.array[[[5,6],[7,8]], dtype=np.float64]
# Tổng của 2 mảng, cả 2 cách cho cùng một kết quả
# [[ 6.0 8.0]
# [10.0 12.0]]
print[x + y]
print[np.add[x, y]]
# Hiệu 2 mảng
# [[-4.0 -4.0]
# [-4.0 -4.0]]
print[x - y]
print[np.subtract[x, y]]
# Tính tích từng phần tử của x nhân với từng phần tử của y
# [[ 5.0 12.0]
# [21.0 32.0]]
print[x * y]
print[np.multiply[x, y]]
# Tương tự thương của từng phần x chia với từng phần tử y
# [[ 0.2 0.33333333]
# [ 0.42857143 0.5 ]]
print[x / y]
print[np.divide[x, y]]
# Bình phương từng phần tử trong x
# [[ 1. 1.41421356]
# [ 1.73205081 2. ]]
print[np.sqrt[x]]
Để Nhândot
import numpy as np
a = np.array[[1, 2, 3]] # Tạo một numpy array với rank = 1
print[type[a]] # Sẽ in ra ""
print[a.shape] # Sẽ in ra "[3,]"
print[a[0], a[1], a[2]] # Sẽ in ra "1 2 3"
a[0] = 5 # Thay đổi giá trị của 1 phần tử trong mảng
print[a] # Sẽ in ra kết quả là "[5, 2, 3]"
b = np.array[[[1,2,3],[4,5,6]]] # Tạo một numpy array với rank =2
print[b.shape] # In ra "[2, 3]"
print[b[0, 0], b[0, 1], b[1, 0]] # Sẽ in ra "1 2 4"
Numpy cung cấp nhiều hàu hữu ích để thực hiện tính toán trên mảng; một trong nhsum
import numpy as np
a = np.array[[1, 2, 3]] # Tạo một numpy array với rank = 1
print[type[a]] # Sẽ in ra ""
print[a.shape] # Sẽ in ra "[3,]"
print[a[0], a[1], a[2]] # Sẽ in ra "1 2 3"
a[0] = 5 # Thay đổi giá trị của 1 phần tử trong mảng
print[a] # Sẽ in ra kết quả là "[5, 2, 3]"
b = np.array[[[1,2,3],[4,5,6]]] # Tạo một numpy array với rank =2
print[b.shape] # In ra "[2, 3]"
print[b[0, 0], b[0, 1], b[1, 0]] # Sẽ in ra "1 2 4"
Bạn bạn thể tìm thấy danh sách Đầy Đủ Các
Ngoài việc tính toán trênn mảng, chún ta thường xuyênn phải định hình lại hoặc thao tac dữ liệu Theo mảng. Ví dụ đơn giản nhp Để Chuyển Vị Một Ma Trận, Chỉ Cần Sử Dụng Thuộc Tính T Của Một
import numpy as np
a = np.array[[1, 2, 3]] # Tạo một numpy array với rank = 1
print[type[a]] # Sẽ in ra ""
print[a.shape] # Sẽ in ra "[3,]"
print[a[0], a[1], a[2]] # Sẽ in ra "1 2 3"
a[0] = 5 # Thay đổi giá trị của 1 phần tử trong mảng
print[a] # Sẽ in ra kết quả là "[5, 2, 3]"
b = np.array[[[1,2,3],[4,5,6]]] # Tạo một numpy array với rank =2
print[b.shape] # In ra "[2, 3]"
print[b[0, 0], b[0, 1], b[1, 0]] # Sẽ in ra "1 2 4"
Numpy cung cấp nhiều hơn Để THAO TAC CAC MảNG; Bạn Có Thể Xem Danh Sách Đầy Đủ TạI ĐÂY Tài liệu.
Phát thanh truyền hình
Phát sóng là một cơ chế mạNH Chúnt ta thường đó là mộng NHỏ hơn và một
Ví dụ: Giả sử rằng chúng ta muốn thêm một vectơ không đổi vào mỗi hàng của ma trận. Chúng ta có thể làm như thế này
import numpy as np
a = np.array[[1, 2, 3]] # Tạo một numpy array với rank = 1
print[type[a]] # Sẽ in ra ""
print[a.shape] # Sẽ in ra "[3,]"
print[a[0], a[1], a[2]] # Sẽ in ra "1 2 3"
a[0] = 5 # Thay đổi giá trị của 1 phần tử trong mảng
print[a] # Sẽ in ra kết quả là "[5, 2, 3]"
b = np.array[[[1,2,3],[4,5,6]]] # Tạo một numpy array với rank =2
print[b.shape] # In ra "[2, 3]"
print[b[0, 0], b[0, 1], b[1, 0]] # Sẽ in ra "1 2 4"
Cách này hoạt động bình thường, khi ma trận x quá lớn, việc sử dụng vòng lặp này sẽ rất chậm. Nếu bạn để ý thì việc thêm vectơ v vào mỗi hàng của ma trận x tương đương với việc tạo một ma trận vv bằng cách xếp chồng nhiều bản sao của v theo chiều dọc, sau đó thực hiện phép tính tổng của x và vv. Chúng ta có thể thực hiện phương pháp này như thế này
import numpy as np
a = np.array[[1, 2, 3]] # Tạo một numpy array với rank = 1
print[type[a]] # Sẽ in ra ""
print[a.shape] # Sẽ in ra "[3,]"
print[a[0], a[1], a[2]] # Sẽ in ra "1 2 3"
a[0] = 5 # Thay đổi giá trị của 1 phần tử trong mảng
print[a] # Sẽ in ra kết quả là "[5, 2, 3]"
b = np.array[[[1,2,3],[4,5,6]]] # Tạo một numpy array với rank =2
print[b.shape] # In ra "[2, 3]"
print[b[0, 0], b[0, 1], b[1, 0]] # Sẽ in ra "1 2 4"
Numpy broadcasting cho phép chúng ta thực thi tính toán này mà không cần phải tạo ra nhiều bản sao của v. Và đây là code khi sử dụng broadcasting
import numpy as np
a = np.array[[1, 2, 3]] # Tạo một numpy array với rank = 1
print[type[a]] # Sẽ in ra ""
print[a.shape] # Sẽ in ra "[3,]"
print[a[0], a[1], a[2]] # Sẽ in ra "1 2 3"
a[0] = 5 # Thay đổi giá trị của 1 phần tử trong mảng
print[a] # Sẽ in ra kết quả là "[5, 2, 3]"
b = np.array[[[1,2,3],[4,5,6]]] # Tạo một numpy array với rank =2
print[b.shape] # In ra "[2, 3]"
print[b[0, 0], b[0, 1], b[1, 0]] # Sẽ in ra "1 2 4"
Về nguyên tắc thực thi của broadcasting bạn có thể tham khảo tại đây documentation
Các hàm hỗ trợ broadcasting được gọi là universal functions. Bạn có thể tìm danh sách các hàm universal functions tại đây documentation
Kết luận
Nhưng kiến thức trên đây đã cung cấp cho bạn những hiểu biết cần thiết về numby, đó không phải là tất cả, hãy đọc tài liệu này documentation để tìm hiểu thêm về numby
Tài liệu tham khảo
Bài viết được dịch từ nguồn: Python Numpy Tutorial