sh4d0w

公告

[旧博客放转转了，此博客还在完善] 学习过一些reverse、android，正在考虑学新东西ing

2048 字

10 分钟

python篇(1)

2025-11-20

AI

学习笔记

基础语法#

参考python官方文档学习即可

python官方文档直通车：https://docs.python.org/3.12

Numpy库#

用于科学计算的基础库

1. 数组/矩阵创建#

1
import numpy as np
2

3
# 一维数组
4
arr_1 = np.array([1, 2, 3])
5
"""
6
[1 2 3]
7
"""
8

9
# 2x3矩阵
10
arr_2 = np.array([[1, 2, 3], [4, 5, 6]])
11
"""
12
[[1 2 3]
13
 [4 5 6]]
14
"""
15

16
# 全0矩阵
17
arr_3 = np.zeros((3, 3), dtype=int)
18
"""
19
[[0 0 0]
20
 [0 0 0]
21
 [0 0 0]]
22
"""
23

24
# 全1矩阵
25
arr_4 = np.ones((2, 2), dtype=int)
26
"""
27
[[1 1]
28
 [1 1]]
29
"""
30

31
# 创建全指定值的矩阵
32
arr_5 = np.full((2, 2), 10, dtype=int)
33
"""
34
[[10 10]
35
 [10 10]]
36
"""
37

38
# 创建等差数列 (start, stop, step), stop不可取
39
arr_6 = np.arange(0,10,2)
40
"""
41
[0 2 4 6 8]
42
"""
43

44
# 创建等间隔数列 (start, stop, num), 包含stop
45
arr_7 = np.linspace(0,1,5)
46
print(arr_7)
47
"""
48
[0.   0.25 0.5  0.75 1.  ]
49
"""

dtype就是指定数据类型的，只要有可能为浮点数，就会生成默认dtype=float的矩阵，需要自己指定类型

2. 获得数组属性#

1
import numpy as np
2
"""
3
[[ 1.  2.  3.  4.]
4
 [ 5.  6.  7.  8.]
5
 [ 9. 10. 11. 12.]]
6
"""
7
arr = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]], dtype=float)
8
print(arr)
9

10
# 维度 2
11
print(arr.ndim)
12

13
# 形状 (3, 4), 表示3行4列, 每个参数代表每一维的大小
14
print(arr.shape)
15

16
# 总数 行 × 列 值 12
17
print(arr.size)
18

19
# 数据类型 float64
20
print(arr.dtype)

3. 数组切片/索引#

一维数组索引#

和普通python的列表索引切片没区别

1
import numpy as np
2

3
"""
4
[1 2 3 4 5]
5
"""
6
arr = np.array([1, 2, 3, 4, 5])
7

8
print(arr[0])
9
"""
10
1
11
"""
12

13
print(arr[-1])
14
"""
15
5
16
"""
17

18
print(arr[1:4])
19
"""
20
[2 3 4]
21
"""

二维/多维数组索引#

1
import numpy as np
2

3
"""
4
[[1 2 3]
5
 [4 5 6]
6
 [7 8 9]]
7
"""
8
arr = np.array([[1,2,3], [4,5,6], [7,8,9]])
9

10
# 获取某一个元素
11
print(arr[2,2])
12
"""
13
9
14
"""
15

16
# 获取某一行
17
print(arr[1])
18
"""
19
[4 5 6]
20
"""
21

22
# 获取某一列
23
print(arr[:,1])
24
"""
25
[2 5 8]
26
"""
27

28
# 获取某一个子矩阵，同样可以用来取某几个数据
29
print(arr[0:2,0:2])
30
"""
31
[[1 2]
32
 [4 5]]
33
"""

4. 数组计算#

逐元素计算#

1
import numpy as np
2

3
arr_1 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
4
"""
5
[[1 2 3]
6
 [4 5 6]
7
 [7 8 9]]
8
"""
9
arr_2 = np.full((3, 3), 2, dtype=int)
10
"""
11
[[2 2 2]
12
 [2 2 2]
13
 [2 2 2]]
14
"""
15

16
# 加法
17
add_result = arr_1 + arr_2
18
print(add_result)
19
"""
20
[[ 3  4  5]
21
 [ 6  7  8]
22
 [ 9 10 11]]
23
"""
24

25
# 减法
26
sub_result = arr_1 - arr_2
27
print(sub_result)
28
"""
29
[[ -1   0   1]
30
 [  2   3   4]
31
 [  5   6   7]]
32
"""
33

34
# 乘法
35
mul_result = arr_1 * arr_2
36
print(mul_result)
37
"""
38
[[ 2  4  6]
39
 [ 8 10 12]
40
 [14 16 18]]
41
"""
42

43
# 除法
44
div_result = arr_1 / arr_2
45
print(div_result)
46
"""
47
[[0.5 1.  1.5]
48
 [2.  2.5 3. ]
49
 [3.5 4.  4.5]]
50
"""
51

52
# 单矩阵和参数计算
53
new_arr_1 = arr_1 + 1
54
print(new_arr_1)
55
"""
56
[[ 2  3  4]
57
 [ 5  6  7]
58
 [ 8  9 10]]
59
"""
60
new_arr_2 = arr_1 * 3
61
print(new_arr_2)
62
"""
63
[[ 3  6  9]
64
 [12 15 18]
65
 [21 24 27]]
66
"""

矩阵乘法#

C_{ij} = A_{i1} B_{1j} + A_{i2} B_{2j} + A_{i3} B_{3j}

1
import numpy as np
2

3
arr_1 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
4
"""
5
[[1 2 3]
6
 [4 5 6]
7
 [7 8 9]]
8
"""
9

10
arr_2 = np.full((3, 2), 2, dtype=int)
11
"""
12
[[2 2]
13
 [2 2]
14
 [2 2]]
15
"""
16

17
# 矩阵相乘，前行乘后列
18
mul_result2 = np.dot(arr_1 , arr_2)
19
print(mul_result2)
20
"""
21
[[12 12]
22
 [30 30]
23
 [48 48]]
24
"""

5. 统计函数#

1
import numpy as np
2

3
arr = np.array([[1, 2, 3, 4, 5],
4
                [5, 4, 3, 2, 1],
5
                [6, 7, 8, 9, 10],
6
                [10, 9, 8, 7, 6]])
7
"""
8
[[ 1  2  3  4  5]
9
 [ 5  4  3  2  1]
10
 [ 6  7  8  9 10]
11
 [10  9  8  7  6]]
12
"""
13

14
sum_arr = np.sum(arr)
15
"""
16
110 对矩阵所有元素求和
17
"""
18

19
mean_arr = np.mean(arr)
20
"""
21
5.5 对矩阵所有元素求平均值
22
"""
23
mean_arr2 = np.mean(arr[2, :])
24
"""
25
8.0 对矩阵第三行元素求平均值
26
"""
27

28
max_arr = np.max(arr)
29
"""
30
10 矩阵中最大值
31
"""
32

33
min_arr = np.min(arr)
34
"""
35
1 矩阵中最小值
36
"""
37

38
std_arr = np.std(arr)
39
"""
40
2.8722813232690143 矩阵中所有元素的标准差
41
"""
42

43
var_arr = np.var(arr)
44
print(var_arr)
45
"""
46
8.25 矩阵中所有元素的方差
47
"""

标准差公式: \sigma = \sqrt{\frac{1}{N}\sum_{i=1}^{N} (x_i - \mu)^2}

方差公式: \sigma^2 = \frac{1}{N}\sum_{i=1}^{N} (x_i - \mu)^2

6. 数组变形拼接#

1
import numpy as np
2

3
# 拆分， 同样可以用来行向量转为列向量(1, -1) -> (-1, 1)
4
arr_1 = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
5
reshape_arr = arr_1.reshape(2, 5)
6
"""
7
[[ 1  2  3  4  5]
8
 [ 6  7  8  9 10]]
9
"""
10

11
# 拼接
12
arr_2 = np.array([[1, 2, 3], [4, 5, 6]])
13
arr_3 = np.array([[7, 8, 9], [10, 11, 12]])
14
concat_arr = np.concatenate((arr_2, arr_3), axis=1)
15
"""
16
axis=0 按行拼接(上下), 等价于 np.vstack((arr_2, arr_3))
17
[[ 1  2  3]
18
 [ 4  5  6]
19
 [ 7  8  9]
20
 [10 11 12]]
21

22
axis=1 按列拼接(左右),等价于 np.hstack((arr_2, arr_3))
23
[[ 1  2  3  7  8  9]
24
 [ 4  5  6 10 11 12]]
25
"""

7. 过滤元素#

1
import numpy as np
2

3
arr = np.array([1,2,3,4,5,6,7,8])
4
arr1 = arr > 3 # 生成布尔数组
5
"""
6
[False False False  True  True  True  True  True]
7
"""
8
arr2 = arr[arr1] # 过滤小于等于3的元素
9
"""
10
[4 5 6 7 8]
11
"""

8. 矩阵转置&逆矩阵#

转置公式: A = [a_{ij}] \;\Rightarrow\; A^{T} = [a_{ji}]

检查矩阵是否可逆

A = \begin{bmatrix} a & b & c \\ d & e & f \\ g & h & i \end{bmatrix}

求行列式: \det(A) = a(ei - fh) - b(di - fg) + c(dh - eg)

求逆矩阵的常规计算方法

我们知道逆矩阵和原矩阵的关系是

A A^{-1} = A^{-1} A = I

据此有基础的计算2x2矩阵和3x3矩阵计算过程

2x2矩阵：

A = \begin{bmatrix} a & b \\ c & d \end{bmatrix}

A^{-1} = \frac{1}{ad - bc} \begin{bmatrix} d & -b \\ -c & a \end{bmatrix}, \quad \text{前提：} ad-bc \neq 0

3x3矩阵：

step1 计算行列式

A = \begin{bmatrix} a & b & c \\ d & e & f \\ g & h & i \end{bmatrix}

\det(A) = a(ei - fh) - b(di - fg) + c(dh - eg)

step2 求代数余子式矩阵

C_{11} = +(ei - fh), \quad C_{12} = -(di - fg), \quad C_{13} = +(dh - eg)...

C = \begin{bmatrix} C_{11} & C_{12} & C_{13} \\ C_{21} & C_{22} & C_{23} \\ C_{31} & C_{32} & C_{33} \end{bmatrix}

step3 转置代数余子式矩阵➡️伴随矩阵:

\operatorname{adj}(A) = C^T

step4 除以行列式得到逆矩阵

A^{-1} = \frac{1}{\det(A)} \operatorname{adj}(A)

1
import numpy as np
2

3
arr = np.array([[1,2,3],
4
                [4,5,6],
5
                [7,21,10]])
6

7
arr_t = arr.T
8

9
# 检查矩阵是否可逆
10
check = np.linalg.det(arr)
11
if check != 0:
12
    arr_inv = np.linalg.inv(arr)
13
    print(arr_inv)
14
    """
15
    [[-1.01333333  0.57333333 -0.04      ]
16
     [ 0.02666667 -0.14666667  0.08      ]
17
     [ 0.65333333 -0.09333333 -0.04      ]]
18
    """
19

20
    # 验证逆矩阵和矩阵相乘是否等于单位矩阵
21
    result = np.dot(arr_inv, arr)
22
    print(result)
23
    """
24
    [[ 1.00000000e+00  2.15105711e-16  6.52256027e-16]
25
     [-1.52655666e-16  1.00000000e+00 -1.38777878e-16]
26
     [ 2.08166817e-17  6.24500451e-17  1.00000000e+00]]
27
    """

Pandas库#

用于数据处理和分析的强大库，它提供了高效且灵活的数据结构

Pandas 支持多种文件格式的读写操作，如 CSV、Excel、SQL 数据库等，具体操作时再去搜索即可，这里不展开。

Series数组 - 一维带标签数组#

1
import pandas as pd
2
# 从列表创建Series数组 不指定标签 标签默认为角标
3
s1 = pd.Series([1,True,3.14,"Hello"])
4
print(s1)
5

6
# 指定标签
7
s2 = pd.Series([1,True,3.14,"Hello"], index=['a','b','c','d'])
8
print(s2)
9

10
# 从字典创建Series数组
11
dic = {'a':10, 'b':20, 'c':30, 'd':40}
12
s3 = pd.Series(dic)
13
print(s3)
14

15
"""
16
0        1
17
1     True
18
2     3.14
19
3    Hello
20
dtype: object
21
a        1
22
b     True
23
c     3.14
24
d    Hello
25
dtype: object
26
a    10
27
b    20
28
c    30
29
d    40
30
dtype: int64
31
"""

DataFrame - 二维表格型数据结构#

1
import pandas as pd
2

3
# 从字典创建DataFrame
4
dic = {
5
    'name': ['Alice', 'Bob', 'Charlie', 'David'],
6
    'age': [24, 27, 22, 32],
7
    'city': ['New York', 'Los Angeles', 'Chicago', 'Houston']
8
}
9
df1 = pd.DataFrame(dic)
10
print(df1)
11
"""
12
      name  age         city
13
1    Alice   24     New York
14
2      Bob   27  Los Angeles
15
3  Charlie   22      Chicago
16
4    David   32      Houston
17
"""
18

19
# 从列表创建DataFrame
20
lst = [['Alice', 24, 'New York'],
21
       ['Bob', 27, 'Los Angeles'],
22
       ['Charlie', 22, 'Chicago'],
23
       ['David', 32, 'Houston']]
24
df2 = pd.DataFrame(lst, columns=['name', 'age', 'city'])
25
print(df2)
26
"""
27
      name  age         city
28
0    Alice   24     New York
29
1      Bob   27  Los Angeles
30
2  Charlie   22      Chicago
31
3    David   32      Houston
32
"""

同样也可以加index来指定标签，默认是从0开始的数字标签

数据合并与连接#

pd.merge() 可以根据一个或多个键将不同 DataFrame 的行连接起来

内连接（默认）：仅返回两个 DataFrame 中键匹配的行。
左连接：返回左 DataFrame 的所有行，以及右 DataFrame 中匹配的行，若右表无匹配则用 NaN 填充。
右连接：返回右 DataFrame 的所有行，以及左 DataFrame 中匹配的行，若左表无匹配则用 NaN 填充。
外连接：返回两个 DataFrame 中所有行，无匹配的位置用 NaN 填充。

1
import pandas as pd
2

3
df1 = pd.DataFrame(
4
    {
5
        'key':['A','B','C','D'],
6
        'value':[1,2,3,4]
7
    }
8
)
9
df2 = pd.DataFrame({
10
    'key':['B', 'D', 'E', 'F'],
11
    'value':[4,6,7,8]
12
})
13

14
# 内链接 按指定的列来取交集, 默认方式
15
print(pd.merge(df1, df2, on='key', how='inner'))
16
"""
17
  key  value_x  value_y
18
0   B        2        4
19
1   D        4        6
20
"""
21
# 左链接 左边与交集的并集
22
print(pd.merge(df1, df2, on='key', how="left"))
23
"""
24
  key  value_x  value_y
25
0   A        1      NaN
26
1   B        2      4.0
27
2   C        3      NaN
28
3   D        4      6.0
29
"""
30
# 右链接 右边与交集的并集
31
print(pd.merge(df1, df2, on="key", how='right'))
32
"""
33
  key  value_x  value_y
34
0   B      2.0        4
35
1   D      4.0        6
36
2   E      NaN        7
37
3   F      NaN        8
38

39
"""
40
# 外链接 并集
41
print(pd.merge(df1, df2, on="key", how='outer'))
42
"""
43
  key  value_x  value_y
44
0   A      1.0      NaN
45
1   B      2.0      4.0
46
2   C      3.0      NaN
47
3   D      4.0      6.0
48
4   E      NaN      7.0
49
5   F      NaN      8.0
50
"""