Lập trình mạng thời gian thực

Bảo mật hệ điều hành

Phần cứng máy tính nâng cao

Giới thiệu phân tích dữ liệu

Numerical Python

Numerical Programming

Numeric Pipeline

Number Processing

List tối ưu cho ma trận nhiều chiều

Array không hỗ trợ toán học đại số

List dùng ít bộ nhớ hơn nhiều

Array xử lý mảng lớn nhanh hơn

Chuyển sang kiểu chuỗi để tính

Dùng list và vòng lặp thuần

Dùng NumPy arrays và hàm toán học

Tránh dùng thư viện bên thứ ba

pip install numpy

pip get numpy

python install numpy

pip setup numpy

import numpy as num

import numpy as np

include numpy as np

from numpy import np

Sao chép thư mục Scripts bất kỳ

Cài đặt NumPy trước

Gỡ Python rồi cài lại

Cài đặt pip trước

Giảm dung lượng RAM

Tự động cập nhật Windows

Chạy Python nhanh hơn

Tránh xung đột hệ thống

pip -m venv myenv

venv -m python myenv

python venv create myenv

python -m venv myenv

myenv\Scripts\activate

python myenv/activate

source myenv/bin/activate

activate myenv now

pip list

pip tree

pip show all

pip config

print(python.scriptsdir)

from pip import pathinfo()

import os; print(os.home)

import sys; print(sys.path)

arr = numpy.array(value1 value2, )

arr = np.asarray{value1, value2, dtype=}

arr = np.array([value1, value2], dtype=)

arr = np.make([value1, value2], dtype=)

(6,) với sáu phần tử

(2, 3, 1) với một trục

(3, 2) với ba hàng

(2, 3) với hai hàng

[1, 2, 3] giữ nguyên hàng

[5, 7, 9] theo từng cột

[6, 15] theo từng hàng

15 theo toàn bộ mảng

Tính theo toàn bộ trục

Tính theo phần tử đơn

Tính theo các cột dọc

Tính theo các hàng ngang

np.array([(1, 2), (3, 4)])

np.array([1, 2, 3, 4])

np.array({[1, 2], [3, 4]})

np.array([[1, 2, 3, 4]])

Axis 0 là theo cột, Axis 1 theo hàng

Axis 0 là theo hàng, Axis 1 theo cột

Axis 0 và Axis 1 đều theo hàng

Axis 0 và Axis 1 đều theo cột

arr.sum(axis=1) cho từng hàng

arr.sum(axis=0) cho từng hàng

arr.total(axis=1) từng hàng

sum(arr, axis=None) từng hàng

np.array([[(1,),(2,)],[(3,),(4,)]])

np.array(((1),(2),(3)))

np.array({((1)),((2))})

np.array([[1,2],[3,4],[5]])

np.random.randn(shape)

np.full(shape)

np.ones(shape)

np.zeros(shape)

Sinh dãy đóng cả hai đầu đoạn

Sinh dãy với start < value ≤ stop

Sinh dãy chỉ gồm giá trị step

Sinh dãy với start ≤ value < stop

np.ones(n)

np.identity(1)

np.eye(n)

np.diag(n)

5

0

2

3

np.random.randn(id)

np.random.seed(id)

np.arange(seed)

np.full(seed)

for x in h: pass

for i in h.shape: print(i)

print(h[len(h)])

for i in range(len(h)): print(h[i])

for r,c in i.shape: print(i[r,c])

for r in range(i.shape[0]): for c in range(i.shape[1]): print(i[r,c])

for c in range(i.shape[1]): print(i[c])

for r in i: print(i[r])

np.ones([2,3,4])

np.arange([2,3,4])

np.eye([2,3,4])

np.diag([2,3,4])

np.savez("data.npy", arr)

np.savetxt("data.npy", arr)

np.save("data.npy", arr)

np.load("data.npy", arr)

np.savez với phần mở rộng .npz

np.save với phần mở rộng .npy

np.savetxt với phần mở rộng .csv

np.dump với phần mở rộng .zip

np.savetxt("data.txt", arr, fmt="%d")

np.save("data.txt", arr, fmt="%d")

np.dump("data.txt", arr, fmt="%d")

np.savez("data.txt", arr, fmt="%d")

loaded = np.import("data.npy")

loaded = np.read("data.npy")

loaded = np.load("data.npy")

loaded = np.loadtxt("data.npy")

data.get_array1

data["array1"]

data.array1()

np.load("array1")

np.loadtxt("data.txt", dtype=int)

np.load("data.txt", dtype=int)

np.savetxt("data.txt", dtype=int)

np.genfromtxt("data.npy", dtype=int)

arr[:-3:]

arr[:3]

arr[3:]

arr[-3:]

[40 50]

[10 20]

[30 40]

[20 30 40]

Start được tính từ 1 thay vì 0

Cả start và end đều bị bỏ qua

End bao gồm, lấy đến đúng chỉ số end

End không bao gồm, dừng trước chỉ số end

array[j, i]

array[i:j]

array[i, j]

array[i::j]

6

2

5

8

[[6,2],[9,1]]

[[5,6],[1,5]]

[[2,3],[5,6]]

[[5,6],[8,9]]

Hai dòng đầu, hai cột đầu

Hai dòng cuối, hai cột đầu

Hai dòng đầu, hai cột cuối

Hai dòng cuối, hai cột cuối

[[9,1],[1,5]]

[[8,9],[5,1]]

[[6,2],[1,5]]

[[9,1],[5,5]]

Hai dòng 1 và 3, tất cả cột

Dòng 0 đến 2, bước 2

Hai cột 0 và 2, tất cả dòng

Hai dòng 0 và 2, tất cả cột

X[1:3, :]

X[[1, 3], :]

X[:, 1:3]

X[:, [1, 3]]

X[1:3, :2]

X[:3, 0:2]

X[1:2, 0:3]

X[1:3, 0:2]

X[:, 1:3]

X[[0,1],[1,2]]

X[1:3, 0:2]

X[0:2, 1:3]

X[0:4,0:4]

X[:, [0,1,2,1]]

X[[0,1,2,3],[0,1,2,3]]

X[[0,1,2,3],[0,1,2,1]]

X[0:2, [0, 3]]

X[[0,1], [0,3]]

X[[0,1], 0:3]

X[:2, 0:3:3]

np.expand_dims(array, axes)

np.concatenate(array, axes)

np.reshape(array, axes)

np.transpose(array, axes)

Tất cả phần tử sẽ được nhân đôi kích thước

Mảng sẽ được chuyển vị theo trục cuối

NumPy tự suy ra kích thước còn lại

Mảng sẽ được ép về kiểu một chiều

Cả hai chỉ hoạt động với mảng một chiều

stack tạo chiều mới, concatenate giữ nguyên số chiều

stack giữ nguyên số chiều, concatenate tạo chiều mới

Cả hai luôn thêm hàng vào mảng hai chiều

np.dstack([arr1, arr2])

np.hstack([arr1, arr2])

np.vstack([arr1, arr2])

np.expand_dims([arr1, arr2])

np.split luôn chia theo trục cuối cùng

np.vsplit chia theo trục hàng của mảng 2D

np.hsplit chia theo trục hàng của mảng 2D

np.dsplit áp dụng cho mảng 1D duy nhất

Hoán đổi vị trí hai trục liền kề

Ghép hai mảng theo trục đã có

Chia mảng thành nhiều phần bằng nhau

Thêm một chiều mới tại vị trí chỉ định

np.ndim(B)

B.size

B.shape

len(B)

B.reshape(3, 5)

B.reshape(2, 6)

B.reshape(6, 1)

B.reshape(2, 4)

B.reshape(-1, 5)

B.reshape(-1, -1)

B.reshape(3, -2)

B.reshape(2, -1)

np.random.randint(0, 20, 2352)

np.random.randint(1, 21, 2352)

np.arange(1, 2353)

np.random.rand(2352) * 20

-np.random.randint(1, 21, 2352)

np.random.randint(-20, 0, 2352)

np.random.randint(-21, -1, 2352)

np.random.randint(-20, -1, 2352)

A.max() < 28

A.dtype == int64

A.ndim == 3

A.size == 2352

np.vstack((C, D))

np.hstack((C, D))

np.concatenate((C, D), axis=2)

np.stack((C, D), axis=2)

Tích ma trận với chính nó

Tổng các phần tử trên đường chéo chính

Số hàng của ma trận đầu vào

Chuẩn Frobenius của ma trận

Luôn cho kết quả là một số vô hướng

Chỉ hợp lệ khi số cột A bằng số hàng B

Chỉ dùng được cho mảng một chiều

Không tuân thủ quy tắc nhân ma trận

Một số vô hướng là tích vô hướng

Một tensor ba chiều bất kỳ

Một vector có cùng kích thước

Một ma trận vuông cấp n

np.argsort(arr, axis=...)

np.maximum(arr1, arr2)

np.argmax(arr, axis=...)

np.max(arr, axis=...)

np.argmin(x, y)

np.min(x, y)

np.sortmin(x, y)

np.minimum(x, y)

4 vì là phần tử cuối cùng

6 vì là trung bình lớn

8 vì là phần tử lớn nhất

[8] vì giữ nguyên shape

Tăng gấp đôi số chiều của mảng

Luôn trả về một số vô hướng

Chỉ áp dụng cho hàm np.exp

Giữ nguyên số chiều sau khi giảm trục

np.exp(arr)

np.linalg.norm(arr)

np.mean(arr)

np.trace(arr)

Hàm np.trace(A,B) thực hiện nhân

Toán tử A * B phần tử tương ứng

Hàm np.max(A,B) thay thế nhân

Toán tử A @ B tuân quy tắc nhân

1

2

6

3

[2, 7]

[1, 6]

[1, 3]

[1, 2]

[1, 3, 6] khác

[1, 3, 6]

[1, 3, 9]

[1, 7, 6]

52

50

48

45

[0, 1]

[2, 2]

[1, 2]

[2, 1]

[0, 0, 0]

[1, 1, 0]

[0, 0, 1]

[1, 0, 0]

[2, 1, 1, 0, 1]

[2, 0, 2, 2, 1]

[2, 0, 1, 2, 1]

[0, 0, 1, 2, 1]

Trả về chỉ số của phần tử nhỏ nhất

Trả về chỉ số của phần tử lớn nhất

Trả về giá trị lớn nhất trong mảng

Trả về mảng đã được sắp xếp tăng

np.zeros([4, 2])

np.zeros((2, 4))

np.zeros(2, 4)

np.zero((2, 4))