1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

import numpy as np

# 方式1：直接从 Python 列表转换（最直接的方式）
# 把一个普通列表扔给 np.array，它就自动变成数组了
arr1 = np.array([1, 2, 3, 4, 5])
print(arr1)
# [1 2 3 4 5]

# 也可以创建二维数组（矩阵）
arr2 = np.array([[1, 2, 3],
                 [4, 5, 6]])
print(arr2)
# [[1 2 3]
#  [4 5 6]]

# 方式2：np.zeros - 创建全0数组
# 想象一下你要初始化一个游戏地图，所有格子都是空的，那就用这个
zeros_arr = np.zeros((3, 4))  # 3行4列的全0数组
print(zeros_arr)
# [[0. 0. 0. 0.]
#  [0. 0. 0. 0.]
#  [0. 0. 0. 0.]]

# 方式3：np.ones - 创建全1数组
ones_arr = np.ones((2, 3))
print(ones_arr)
# [[1. 1. 1.]
#  [1. 1. 1.]]

# 方式4：np.arange - 类似 Python 的 range，但返回数组
# arange = array + range，天才的命名！
range_arr = np.arange(0, 10, 2)  # 从0开始，到10结束（不包含），步长2
print(range_arr)
# [0 2 4 6 8]

# 方式5：np.linspace - 创建等差数列
# linspace = linear space，在"线性空间"里均匀分布
# 常用于创建坐标轴上的点，比如 0 到 1 之间取 5 个点
linspace_arr = np.linspace(0, 1, 5)
print(linspace_arr)
# [0.   0.25 0.5  0.75 1.  ]

# 方式6：np.full - 创建一个填充了指定值的数组
# 想象一下你要创建一个"已读"通知数组，全是 True
full_arr = np.full((2, 2), 888)  # 2x2数组，所有元素都是888
print(full_arr)
# [[888 888]
#  [888 888]]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

import numpy as np

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

# shape - 形状，即各维度的长度
# 返回一个元组，比如 (2, 3) 表示2行3列
print("形状:", arr.shape)      # (2, 3)

# dtype - 数据类型
# NumPy 支持比 Python 更丰富的数据类型
print("数据类型:", arr.dtype)  # int64

# ndim - 维度数量
# 标量是0维，向量是1维，矩阵是2维，张量是3维及以上
print("维度:", arr.ndim)       # 2

# size - 总元素数量
print("元素总数:", arr.size)   # 6

# 还有一个很有用的属性：itemsize（每个元素的字节数）
print("每个元素字节数:", arr.itemsize)  # 8

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

import numpy as np

a = np.array([1, 2, 3, 4])
b = np.array([10, 20, 30, 40])

# 加法：对应元素相加（注意：是对应元素，不是向量加法）
print("a + b =", a + b)  # [11 22 33 44]

# 减法
print("a - b =", a - b)  # [-9 -18 -27 -36]

# 乘法：对应元素相乘（不是矩阵乘法！）
print("a * b =", a * b)  # [10 40 90 160]

# 除法
print("a / b =", a / b)  # [0.1 0.1 0.1 0.1]

# 标量运算：一个数字和整个数组运算
print("a * 10 =", a * 10)  # [10 20 30 40]
print("a ** 2 =", a ** 2)  # [1 4 9 16]（**是幂运算）

# ========== 矩阵乘法 @ ==========
# @ 运算符是 NumPy 的矩阵乘法符号
# 矩阵乘法的规则：左边矩阵的列数必须等于右边矩阵的行数
A = np.array([[1, 2],
              [3, 4]])
B = np.array([[5, 6],
              [7, 8]])

# A @ B 表示矩阵 A 乘以矩阵 B
C = A @ B
print("A @ B =")
print(C)
# [[19 22]
#  [43 46]]

# 验算一下：19 = 1*5 + 2*7，22 = 1*6 + 2*8，43 = 3*5 + 4*7，46 = 3*6 + 4*8

# np.dot 也可以做矩阵乘法（但它对1维数组有不同含义）
print("np.dot(A, B) =")
print(np.dot(A, B))
# [[19 22]
#  [43 46]]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

import numpy as np

# 场景1：一维数组和标量运算
# 这个最简单，标量会被"广播"到数组的每个元素
arr = np.array([1, 2, 3, 4])
print(arr + 100)  # [101 102 103 104]
# 相当于 [1,2,3,4] + [100,100,100,100]

# 场景2：二维数组和一行数组
# 想象你有一张成绩表（3个学生，4门课）
grades = np.array([[85, 90, 78, 92],
                   [88, 76, 95, 81],
                   [92, 85, 88, 79]])
# 给每个学生加5分bonus
bonus = np.array([5, 5, 5, 5])  # 每门课加5分
print(grades + bonus)
# [[90 95 83 97]
#  [93 81 100 86]
#  [97 90 93 84]]

# 场景3：二维数组和一列数组
# 如果每个学生还有一个额外的加分（比如课堂表现分）
extra_bonus = np.array([[3],
                        [5],
                        [2]])  # 学生1加3分，学生2加5分，学生3加2分
print(grades + extra_bonus)
# [[88 93 81 95]
#  [93 81 100 86]
#  [94 87 90 81]]

# 场景4：挑战一下，3维和2维能广播吗？
a = np.zeros((3, 4, 2))
b = np.ones((4, 2))
print((a + b).shape)  # (3, 4, 2) - b 被广播到了第三个维度

# 场景5：不能广播的情况（会报错）
try:
    a = np.array([1, 2, 3])
    b = np.array([4, 5])  # 长度不同
    print(a + b)  # ValueError
except ValueError as e:
    print(f"报错了！{e}")
# 广播虽好，但也不是万能的！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

import numpy as np

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

print("原数组:")
print(arr)
# [[ 1  2  3  4]
#  [ 5  6  7  8]
#  [ 9 10 11 12]]

# -------- 基本索引 --------
# 获取第2行第3列的元素（从0开始数！）
print(arr[1, 2])  # 7

# -------- 切片 --------
# 取出第0行和第1行，第1列到第2列（不包含第3列）
sub = arr[0:2, 1:3]
print("arr[0:2, 1:3] =")
print(sub)
# [[2 3]
#  [6 7]]

# 所有行的第0列（也就是第一列）
col = arr[:, 0]
print("第一列:", col)  # [1 5 9]

# 所有列的第2行（也就是第三行）
row = arr[2, :]
print("第三行:", row)  # [9 10 11 12]

# -------- 高级索引（布尔索引）--------
# 找出所有大于5的元素
mask = arr > 5
print("大于5的元素:", arr[mask])  # [ 6  7  8  9 10 11 12]

# 也可以直接写条件
print("小于10的偶数:", arr[(arr < 10) & (arr % 2 == 0)])
# & 表示 AND，| 表示 OR，但记得加括号！

# -------- 花式索引（用数组来索引）--------
# 选取特定行：第0行、第2行、第1行
fancy_rows = arr[[0, 2, 1]]
print("按特定顺序取行:")
print(fancy_rows)
# [[ 1  2  3  4]
#  [ 9 10 11 12]
#  [ 5  6  7  8]]

# 选取特定位置的元素（配对索引）
selected = arr[[0, 1, 2], [0, 1, 2]]  # (0,0), (1,1), (2,2) 三个位置
print("对角线元素:", selected)  # [1 6 11]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

import numpy as np

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

# -------- 统计函数 --------
print("数组内容:")
print(arr)
# [[1 2 3]
#  [4 5 6]]

# sum - 求和
print("所有元素之和:", np.sum(arr))           # 21
print("每列之和:", np.sum(arr, axis=0))       # [5 7 9]
print("每行之和:", np.sum(arr, axis=1))       # [ 6 15]

# mean - 平均值
print("平均值:", np.mean(arr))                 # 3.5
print("每行平均值:", np.mean(arr, axis=1))     # [2. 5.]

# std - 标准差
# 标准差衡量数据的离散程度，越大说明数据越分散
print("标准差:", np.std(arr))                  # 约1.707

# var - 方差（标准差的平方）
print("方差:", np.var(arr))                    # 约2.916

# min / max - 最小值/最大值
print("最小值:", np.min(arr))                  # 1
print("最大值:", np.max(arr))                   # 6
print("每行最小值:", np.min(arr, axis=1))       # [1 4]

# -------- dot - 点积（内积）--------
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
# 点积 = a[0]*b[0] + a[1]*b[1] + a[2]*b[2] = 1*4 + 2*5 + 3*6 = 32
print("点积:", np.dot(a, b))                   # 32

# -------- transpose (T) - 转置 --------
# 转置就是行列互换：原来的行变成列，列变成行
print("转置:")
print(arr.T)
# [[1 4]
#  [2 5]
#  [3 6]]

# -------- 累计函数 --------
print("累加:", np.cumsum(arr))  # [1 3 6 10 15 21]
print("累乘:", np.cumprod(arr))  # [1 2 6 24 120 720]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

import numpy as np

arr = np.array([10, 25, 30, 45, 50, 65, 70, 85])

# -------- np.where - 条件替换 --------
# np.where(condition, x, y) = 如果条件成立输出x，否则输出y
# 找出一个数组中所有大于40的元素，替换成"大"，否则替换成"小"
result = np.where(arr > 40, "大", "小")
print("分类结果:", result)  # ['小' '小' '小' '大' '大' '大' '大' '大']

# 实际应用中：把负数替换成0（常用于数据预处理）
scores = np.array([85, -1, 90, -1, 75, 88, -1, 92])
# -1 表示缺考，我们把它替换成0
cleaned_scores = np.where(scores == -1, 0, scores)
print("清理后的成绩:", cleaned_scores)  # [85  0 90  0 75 88  0 92]

# 进阶：返回满足条件的索引
indices = np.where(arr > 40)
print("大于40的索引:", indices)  # (array([3, 4, 5, 6, 7]),)
print("大于40的元素:", arr[indices])  # [45 50 65 70 85]

# -------- np.extract - 直接提取元素 --------
# 语法：np.extract(condition, array)
# 相当于 arr[condition] 的快捷方式
condition = arr > 40
extracted = np.extract(condition, arr)
print("np.extract提取:", extracted)  # [45 50 65 70 85]

# -------- 结合多个条件 --------
# 找出 30 < arr < 60 的元素
multi_condition = (arr > 30) & (arr < 60)
print("30到60之间的元素:", np.extract(multi_condition, arr))  # [45 50]

# 注意：多个条件要用 & 连接，而不是 and！
# 而且每个条件都要加括号！

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100

import numpy as np

# -------- reshape - 改变形状 --------
arr = np.arange(12)  # [0 1 2 3 4 5 6 7 8 9 10 11]
print("原数组:", arr)

# 变成 3 行 4 列
reshaped = arr.reshape(3, 4)
print("reshape(3,4):")
print(reshaped)
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

# 变成 4 行 3 列
reshaped2 = arr.reshape(4, 3)
print("reshape(4,3):")
print(reshaped2)
# [[ 0  1  2]
#  [ 3  4  5]
#  [ 6  7  8]
#  [ 9 10 11]]

# 神奇的 -1：让 NumPy 自动计算维度
# 如果知道有4行，列数让它自己算
auto_col = arr.reshape(4, -1)
print("reshape(4,-1):")
print(auto_col)
# [[ 0  1  2]
#  [ 3  4  5]
#  [ 6  7  8]
#  [ 9 10 11]]

# -------- flatten - 展平 --------
# 把多维数组变成一维（就像把卷起的报纸展开）
flat = reshaped.flatten()
print("flatten后:", flat)  # [0 1 2 ... 11]

# ravel 和 flatten 的区别：
# flatten 返回副本，修改不影响原数组
# ravel 返回视图（如果可能），更省内存
flat2 = reshaped.ravel()
print("ravel后:", flat2)  # [0 1 2 ... 11]

# -------- concatenate - 拼接 --------
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# 沿 axis=0（默认）拼接
c = np.concatenate([a, b])
print("拼接结果:", c)  # [1 2 3 4 5 6]

# 拼接二维数组
A = np.array([[1, 2],
              [3, 4]])
B = np.array([[5, 6],
              [7, 8]])

# 按行拼接（vertical stack）
vstack = np.vstack([A, B])
print("按行拼接 (vstack):")
print(vstack)
# [[1 2]
#  [3 4]
#  [5 6]
#  [7 8]]

# 按列拼接（horizontal stack）
hstack = np.hstack([A, B])
print("按列拼接 (hstack):")
print(hstack)
# [[1 2 5 6]
#  [3 4 7 8]]

# -------- split - 分割 --------
# 把数组分成几份
arr = np.arange(12)
print("原数组:", arr)

# 分成3等份
pieces = np.split(arr, 3)
print("分成3份:", pieces)  # [array([0,1,2,3]), array([4,5,6,7]), array([8,9,10,11])]

# 在指定位置分割
left, right = np.split(arr, [5])  # 在索引5处分割
print("左半:", left)   # [0 1 2 3 4]
print("右半:", right)  # [ 5  6  7  8  9 10 11]

# vsplit / hsplit 是 vstack / hstack 的逆向操作
A = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])
top, bottom = np.vsplit(A, [2])  # 在第2行处分割
print("上半部分:")
print(top)
# [[1 2 3]
#  [4 5 6]]
print("下半部分:")
print(bottom)
# [[7 8 9]]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

import numpy as np

# 设置随机种子，让结果可复现
# 如果不设置种子，每次运行结果都不一样（这对调试很不友好）
np.random.seed(42)  # 42 是"宇宙终极答案"，很多人喜欢用它

# -------- 基础随机数 --------
# rand: 生成 [0, 1) 区间的均匀分布随机数
print("rand(3,2) - 3行2列的随机数:")
print(np.random.rand(3, 2))
# [[0.37454012 0.95071431]
#  [0.73199394 0.59865848]
#  [0.15601864 0.15599452]]

# randn: 生成标准正态分布（平均0，标准差1）的随机数
# 正态分布又叫高斯分布，形状像一口钟
print("randn(4) - 标准正态分布:")
print(np.random.randn(4))
# 类似 [-0.23, 1.15, -0.07, 0.42]

# randint: 生成随机整数
print("randint(1, 10, 5) - 1到10之间的5个随机整数:")
print(np.random.randint(1, 10, 5))  # 左闭右开区间 [1, 10)

# -------- 分布随机数 --------
# uniform: 均匀分布
print("uniform(0, 1, 3) - 0到1之间的3个随机数:")
print(np.random.uniform(0, 1, 3))

# normal: 正态分布（可指定均值和标准差）
print("normal(100, 15, 5) - IQ分数模拟:")
print(np.random.normal(100, 15, 5))  # 平均100，标准差15（真实的IQ分布）

# binomial: 二项分布（做n次实验，成功概率为p）
# 模拟抛10次硬币，重复5次实验
print("binomial(10, 0.5, 5) - 抛硬币模拟:")
print(np.random.binomial(10, 0.5, 5))

# choice: 从数组中随机挑选
colors = np.array(['红', '蓝', '绿'])
print("随机选3次:", np.random.choice(colors, 3))  # 可能得到 ['红' '红' '绿']

# -------- 打乱和抽样 --------
deck = np.array(['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K'])
np.random.shuffle(deck)  # 原地打乱（修改原数组）
print("洗牌后:", deck)

# 从大数据集中随机抽样（不放回）
population = np.arange(100)
sample = np.random.choice(population, 10, replace=False)
print("随机抽10个:", sample)

# -------- 随机漫步模拟 --------
# 随机漫步 = 每天股票价格的变化 = 醉汉走路
steps = np.random.choice([-1, 1], 100)  # 每天要么+1要么-1
walk = np.cumsum(steps)  # 累加每天的位置
print("随机漫步前10步:", walk[:10])
# 类似 [-1, 0, 1, 0, 1, 2, 1, 0, 1, 2]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

import numpy as np

A = np.array([[1, 2],
              [3, 4]])
b = np.array([5, 6])

# -------- 求解线性方程组 --------
# 求解：Ax = b，即：
# 1*x + 2*y = 5
# 3*x + 4*y = 6
x = np.linalg.solve(A, b)
print("线性方程组 Ax=b 的解:", x)
# 验证：1*1 + 2*2 = 5 ✓，3*1 + 4*2 = 11 ≠ 6 ... 呃，可能无解或数值误差

# 用最小二乘法求解超定方程组（最常用于拟合）
# 正常方程 Ax = b 的解：x = (A^T A)^(-1) A^T b
# np.linalg.lstsq 可以直接算这个

# -------- 矩阵分解 --------
# 行列式（determinant）
det = np.linalg.det(A)
print("行列式 det(A):", det)  # 1*4 - 2*3 = -2

# 逆矩阵（inverse matrix）
# A^(-1) * A = I（单位矩阵）
A_inv = np.linalg.inv(A)
print("逆矩阵:")
print(A_inv)
# 验证：A @ A_inv 应该接近单位矩阵
print("验证 (A @ A_inv):")
print(np.round(A @ A_inv))
# [[1. 0.]
#  [0. 1.]]

# 特征值和特征向量（eigenvalues and eigenvectors）
# 满足：Av = λv 的 λ 叫特征值，v 叫特征向量
# 这是 PCA（主成分分析）和很多算法的核心
eigenvalues, eigenvectors = np.linalg.eig(A)
print("特征值:", eigenvalues)
print("特征向量:")
print(eigenvectors)

# SVD 奇异值分解（Singular Value Decomposition）
# A = U Σ V^T，任何矩阵都可以分解成这三个矩阵的乘积
# SVD 是降维、推荐系统、图像压缩的神器
U, S, Vt = np.linalg.svd(A)
print("U:", U)
print("奇异值 S:", S)
print("V^T:", Vt)

# -------- 范数（norm）--------
# 范数衡量向量或矩阵的"大小"
v = np.array([3, 4])

# L2 范数（欧几里得距离）= sqrt(3² + 4²) = 5
print("L2范数:", np.linalg.norm(v))  # 5.0
print("L2范数（显式）:", np.sqrt(np.sum(v**2)))  # 5.0

# L1 范数 = |3| + |4| = 7
print("L1范数:", np.linalg.norm(v, ord=1))  # 7.0

# -------- 矩阵范数 --------
# Frobenius 范数（类比 L2 范数对矩阵的推广）
print("Frobenius范数:", np.linalg.norm(A, 'fro'))  # sqrt(1+4+9+16) = sqrt(30)

# -------- QR 分解 --------
Q, R = np.linalg.qr(A)
print("Q:", Q)
print("R:", R)
# 验证：A ≈ Q @ R
print("Q @ R:", Q @ R)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

import numpy as np

# 假设我们要拟合：y = w0 + w1*x1 + w2*x2
# 训练数据
X = np.array([[1, 1, 2],
              [1, 2, 4],
              [1, 3, 6],
              [1, 4, 5],
              [1, 5, 8]])
y = np.array([5, 8, 11, 13, 17])

# 正规方程：w = (X^T X)^(-1) X^T y
w = np.linalg.inv(X.T @ X) @ X.T @ y
print("拟合参数 w:", np.round(w, 2))
# w[0] 是截距，w[1] 和 w[2] 是系数

# 预测
y_pred = X @ w
print("预测值:", np.round(y_pred, 2))
print("真实值:", y)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

import pandas as pd
import numpy as np

# -------- Series --------
# Series = 一维带索引的数组
s = pd.Series([10, 20, 30, 40, 50])
print("Series示例:")
print(s)
# 0    10
# 1    20
# 2    30
# 3    40
# 4    50
# dtype: int64

# 自定义索引
s2 = pd.Series([98, 85, 92, 78, 88],
               index=['语文', '数学', '英语', '物理', '化学'])
print("\n带标签的Series:")
print(s2)
# 语文    98
# 数学    85
# 英语    92
# 物理    78
# 化学    88
# dtype: int64

# 用字典创建 Series
dict_data = {'苹果': 5, '香蕉': 3, '橙子': 7, '葡萄': 2}
s3 = pd.Series(dict_data)
print("\n字典转Series:")
print(s3)
# 苹果    5
# 香蕉    3
# 橙子    7
# 葡萄    2
# dtype: int64

# -------- DataFrame --------
# DataFrame = 二维表格，每个列可以是不同的数据类型

# 创建 DataFrame 的方式1：字典
data = {
    '姓名': ['张三', '李四', '王五', '赵六'],
    '年龄': [25, 30, 35, 28],
    '城市': ['北京', '上海', '广州', '深圳'],
    '年薪(万)': [30, 45, 35, 40]
}
df = pd.DataFrame(data)
print("\nDataFrame示例:")
print(df)
#    姓名  年龄  城市  年薪(万)
# 0  张三  25  北京      30
# 1  李四  30  上海      45
# 2  王五  35  广州      35
# 3  赵六  28  深圳      40

# 创建 DataFrame 的方式2：二维数组
arr = np.array([[1, 2, 3],
                [4, 5, 6],
                [7, 8, 9]])
df2 = pd.DataFrame(arr, columns=['A列', 'B列', 'C列'])
print("\n数组转DataFrame:")
print(df2)

# -------- DataFrame 基本操作 --------
print("\n前2行:")
print(df.head(2))  # 默认前5行

print("\n后2行:")
print(df.tail(2))

print("\n数据类型:")
print(df.dtypes)

print("\n列名:")
print(df.columns)

print("\n形状:")
print(df.shape)  # (4, 4)

print("\n描述统计:")
print(df.describe())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

import pandas as pd

# -------- read_csv --------
# CSV = Comma Separated Values，逗号分隔值
# 这是最常用的数据格式之一，Excel可以直接导出CSV

# 读取CSV（假设当前目录有一个叫 data.csv 的文件）
# df = pd.read_csv('data.csv')

# 常用参数：
# df = pd.read_csv('data.csv', encoding='utf-8')  # 指定编码
# df = pd.read_csv('data.csv', sep=';')           # 分隔符是分号而不是逗号
# df = pd.read_csv('data.csv', header=0)           # 第0行是表头
# df = pd.read_csv('data.csv', names=['列1','列2'])# 自己指定列名
# df = pd.read_csv('data.csv', index_col=0)        # 第0列作为索引
# df = pd.read_csv('data.csv', nrows=100)          # 只读取前100行

# 模拟演示：读取字符串格式的CSV
from io import StringIO
csv_data = """姓名,年龄,城市,年薪(万)
张三,25,北京,30
李四,30,上海,45
王五,35,广州,35
赵六,28,深圳,40"""
df = pd.read_csv(StringIO(csv_data))
print("从CSV读取:")
print(df)

# -------- read_excel --------
# 读取Excel文件（需要安装 openpyxl 或 xlrd）
# df = pd.read_excel('data.xlsx', sheet_name='Sheet1')
# sheet_name 参数可以指定读取哪个工作表

# 模拟演示：读取字典列表格式
excel_data = [
    {'姓名': '张三', '年龄': 25, '城市': '北京'},
    {'姓名': '李四', '年龄': 30, '城市': '上海'},
]
df_excel = pd.DataFrame(excel_data)
print("\n模拟Excel数据:")
print(df_excel)

# -------- read_json --------
# JSON = JavaScript Object Notation，键值对格式
# API接口返回的数据通常是这个格式

json_data = [
    {'name': 'Alice', 'age': 25, 'city': 'Beijing'},
    {'name': 'Bob', 'age': 30, 'city': 'Shanghai'}
]
df_json = pd.read_json(pd.DataFrame(json_data).to_json(orient='records'))
print("\n从JSON读取:")
print(df_json)

# JSON 的不同格式：
# orient='records': [{"a":1}, {"a":2}]
# orient='index': {"0":{"a":1}, "1":{"a":2}}
# orient='columns': {"a":{"0":1, "1":2}}

# -------- 读取大文件的技巧 --------
# 如果文件很大，不需要全部读入内存
# df = pd.read_csv('big_data.csv', chunksize=10000)  # 分块读取
# for chunk in pd.read_csv('big_data.csv', chunksize=10000):
#     process(chunk)  # 每次处理10000行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

import pandas as pd
import numpy as np

df = pd.DataFrame({
    '姓名': ['张三', '李四', '王五', '赵六', '钱七'],
    '年龄': [25, 30, 35, 28, 32],
    '城市': ['北京', '上海', '广州', '深圳', '杭州'],
    '年薪(万)': [30, 45, 35, 40, 50]
}, index=['a', 'b', 'c', 'd', 'e'])

print("原数据:")
print(df)
#    姓名  年龄  城市  年薪(万)
# a  张三  25  北京      30
# b  李四  30  上海      45
# c  王五  35  广州      35
# d  赵六  28  深圳      40
# e  钱七  32  杭州      50

# -------- loc：基于标签的选择 --------
# 选择一行
print("用loc选择'a'行:")
print(df.loc['a'])
# 姓名    张三
# 年龄    25
# 城市    北京
# 年薪(万)    30
# Name: a, dtype: object

# 选择多行
print("\n选择'a','c','e'行:")
print(df.loc[['a', 'c', 'e']])

# 条件选择（布尔索引）
print("\n年龄大于30的行:")
print(df.loc[df['年龄'] > 30])

# 选择特定行+特定列
print("\n选择'b'行，姓名和城市:")
print(df.loc['b', ['姓名', '城市']])  # 姓名    李四, 城市    上海

# 切片选择（包含两端）
print("\n选择'a'到'c'行:")
print(df.loc['a':'c'])
# 包含 a, b, c 三行（注意：这是闭区间，不是半开区间！）

# -------- iloc：基于位置的选择 --------
# 选择第0行（第一行）
print("\niloc[0]:")
print(df.iloc[0])

# 选择前3行
print("\niloc[:3]:")
print(df.iloc[:3])

# 选择第1行和第3行
print("\niloc[[1,3]]:")
print(df.iloc[[1, 3]])

# 选择第0列和第2列
print("\n选择第0列和第2列:")
print(df.iloc[:, [0, 2]])

# 选择第1到第3行，第0到第2列
print("\niloc[1:4, 0:3]:")
print(df.iloc[1:4, 0:3])

# -------- at 和 iat：快速访问单个值 --------
# at 类似于 loc，但只能访问单个值（更快）
print("\nat['b', '年薪(万)']:", df.at['b', '年薪(万)'])  # 45

# iat 类似于 iloc，但只能访问单个值（最快）
print("iat[1, 3]:", df.iat[1, 3])  # 45

# -------- 选择列的简便方法 --------
print("\n选择'姓名'列（返回Series）:")
print(df['姓名'])

# 也可以用属性语法（列名是字符串时）
print("\ndf.姓名:")
print(df.姓名)

# 选择多列（必须用双括号！）
print("\n选择姓名和城市:")
print(df[['姓名', '城市']])

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

import pandas as pd
import numpy as np

# 创建一些"脏"数据
df = pd.DataFrame({
    '姓名': ['张三', '李四', '王五', '张三', '赵六', None],
    '年龄': [25, None, 35, 28, 32, 45],
    '城市': ['北京', '上海', None, '深圳', '杭州', '广州'],
    '年薪(万)': [30, 45, 35, 40, 50, 35]
})

print("脏数据:")
print(df)
print(df.isnull())  # 查看哪些位置是空值

# -------- dropna：删除缺失值 --------
print("\n--- dropna 删除空值 ---")

# 默认删除任何含有空值的行
print("删除含有空值的行:")
print(df.dropna())
#     姓名  年龄  城市  年薪(万)
# 4   赵六  32.0  杭州        50

# 只删除全为空值的行（没有这种情况）

# 删除含有空值的列
print("删除含有空值的列:")
print(df.dropna(axis=1))

# 只删除'年龄'列为空值的行
print("删除'年龄'为空值的行:")
print(df.dropna(subset=['年龄']))

# -------- fillna：填充空值 --------
print("\n--- fillna 填充空值 ---")

# 用固定值填充
df_filled = df.copy()
df_filled['姓名'].fillna('未知', inplace=True)
print("'姓名'空值填充为'未知':")
print(df_filled)

# 用均值填充（数值列）
df_filled2 = df.copy()
df_filled2['年龄'].fillna(df['年龄'].mean(), inplace=True)
print("\n'年龄'空值填充为均值:")
print(df_filled2)

# 用前一个值填充（forward fill）
print("\n用前向填充:")
print(df.fillna(method='ffill'))

# 用后一个值填充（backward fill）
print("\n用后向填充:")
print(df.fillna(method='bfill'))

# -------- drop_duplicates：删除重复行 --------
df_dup = pd.DataFrame({
    '姓名': ['张三', '李四', '张三', '王五', '李四'],
    '年龄': [25, 30, 25, 35, 30],
    '城市': ['北京', '上海', '北京', '广州', '上海']
})

print("\n--- drop_duplicates 删除重复行 ---")
print("有重复行的数据:")
print(df_dup)
print("\n删除完全重复的行:")
print(df_dup.drop_duplicates())

# 只考虑某些列
print("\n只根据'姓名'和'城市'去重:")
print(df_dup.drop_duplicates(subset=['姓名', '城市']))

# 保留最后一个
print("\n保留最后一个重复:")
print(df_dup.drop_duplicates(keep='last'))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

import pandas as pd
import numpy as np

df = pd.DataFrame({
    '姓名': ['张三', '李四', '王五', '赵六'],
    '数学': [85, 92, 78, 88],
    '语文': [90, 85, 92, 80],
    '英语': [88, 90, 85, 92]
})

print("原始数据:")
print(df)

# -------- apply：对行或列应用函数 --------
print("\n--- apply ---")

# 计算每人的总分（沿 axis=1，即跨列）
df['总分'] = df[['数学', '语文', '英语']].apply(np.sum, axis=1)
print("加总分列:")
print(df)

# 用自定义函数
def grade_level(score):
    """根据分数评级"""
    if score >= 90:
        return 'A'
    elif score >= 80:
        return 'B'
    elif score >= 70:
        return 'C'
    else:
        return 'D'

df['数学等级'] = df['数学'].apply(grade_level)
print("\n加数学等级列:")
print(df)

# -------- map：对 Series 应用函数 --------
print("\n--- map ---")

# 给城市换个标签
city_map = {'北京': '北方', '上海': '南方', '广州': '南方', '深圳': '南方'}
df2 = pd.DataFrame({
    '姓名': ['张三', '李四', '王五', '赵六'],
    '城市': ['北京', '上海', '广州', '深圳']
})
df2['区域'] = df2['城市'].map(city_map)
print("城市映射到区域:")
print(df2)

# 用 lambda
df2['城市简称'] = df2['城市'].map(lambda x: x[0])
print("城市简称:")
print(df2)

# -------- transform：同时返回相同形状的结果 --------
print("\n--- transform ---")

# transform 和 apply 的区别：
# apply 可以返回不同形状，transform 必须返回相同形状
# transform 更快（支持向量化操作）

df3 = pd.DataFrame({
    '班级': ['A', 'A', 'B', 'B', 'A'],
    '成绩': [85, 92, 78, 88, 90]
})

# 计算每个班级的平均分，然后广播到每个人
df3['班级平均'] = df3.groupby('班级')['成绩'].transform('mean')
print("添加班级平均分:")
print(df3)

# -------- assign：链式添加列 --------
df = df.assign(
    平均分=lambda x: x['总分'] / 3,
    最高分=lambda x: x[['数学', '语文', '英语']].max(axis=1),
    最低分=lambda x: x[['数学', '语文', '英语']].min(axis=1)
)
print("\n用assign添加多列:")
print(df)

# -------- replace：替换值 --------
s = pd.Series(['红', '蓝', '绿', '红'])
s_replaced = s.replace(['红', '蓝'], ['RED', 'BLUE'])
print("\n替换颜色:")
print(s_replaced)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

import pandas as pd
import numpy as np

# 模拟电商销售数据
df = pd.DataFrame({
    '日期': ['2024-01-01', '2024-01-02', '2024-01-03', '2024-01-04', '2024-01-05', '2024-01-06'],
    '商品类别': ['电子产品', '服装', '电子产品', '食品', '服装', '电子产品'],
    '商品': ['手机', 'T恤', '耳机', '面包', '裤子', '充电器'],
    '销量': [100, 50, 80, 30, 60, 90],
    '单价': [2000, 100, 300, 5, 150, 50],
    '城市': ['北京', '上海', '北京', '广州', '深圳', '上海']
})
df['销售额'] = df['销量'] * df['单价']
print("原始销售数据:")
print(df)

# -------- groupby 基础 --------
print("\n--- groupby 基础 ---")

# 按商品类别分组
grouped = df.groupby('商品类别')
print("分组后的组数:", grouped.ngroups)  # 3

# 遍历每个组
for name, group in grouped:
    print(f"\n{name}组:")
    print(group[['商品', '销量', '销售额']])

# -------- 聚合函数 agg --------
print("\n--- agg 聚合 ---")

# 单个聚合
print("按类别求销量总和:")
print(df.groupby('商品类别')['销量'].sum())

# 多个聚合
print("\n按类别聚合（销量总和、销量均值、销售额总和）:")
result = df.groupby('商品类别').agg({
    '销量': ['sum', 'mean'],
    '销售额': 'sum'
})
print(result)
# 列名会变成多级索引

# 使用命名聚合（更清晰）
result2 = df.groupby('商品类别').agg(
    总销量=('销量', 'sum'),
    平均销量=('销量', 'mean'),
    总销售额=('销售额', 'sum')
)
print("\n命名聚合（更清晰）:")
print(result2)

# -------- 内置聚合函数 --------
# 常用聚合函数：sum, mean, median, std, var, min, max, count, first, last, std

# -------- pivot 透视表 --------
print("\n--- pivot 透视表 ---")

pivot = df.pivot_table(
    values='销售额',
    index='商品类别',
    columns='城市',
    aggfunc='sum',
    fill_value=0  # 空值填0
)
print("销售额透视表（类别 x 城市）:")
print(pivot)

# 多个聚合函数
pivot2 = df.pivot_table(
    values='销售额',
    index='商品类别',
    aggfunc=['sum', 'mean', 'count']
)
print("\n多聚合透视表:")
print(pivot2)

# -------- crosstab 交叉表 --------
print("\n--- crosstab 交叉表 ---")
ct = pd.crosstab(df['商品类别'], df['城市'], margins=True)
print("交叉表（计数）:")
print(ct)

# -------- 分组后过滤 --------
print("\n--- 分组过滤 ---")
# 找出销售额总计超过 10000 的类别
def filter_group(group):
    return group['销售额'].sum() > 10000

print("销售额超过1万的类别:")
print(df.groupby('商品类别').filter(filter_group))