Python Pandas & NumPy 常用方法速查指南

📊 思维导图式总结

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
┌─────────────────────────────────────────────────────────────────────────────┐
│                           Python 数据分析双剑客                               │
├─────────────────────────────────┬───────────────────────────────────────────┤
│            NumPy                │               Pandas                       │
│         (数值计算基础)            │            (数据分析利器)                   │
├─────────────────────────────────┼───────────────────────────────────────────┤
│                                 │                                           │
│  ┌─────────┐    ┌─────────┐    │    ┌─────────┐    ┌─────────┐            │
│  │数组创建  │    │数组操作  │    │    │Series   │    │DataFrame│            │
│  └────┬────┘    └────┬────┘    │    └────┬────┘    └────┬────┘            │
│       │              │         │         │              │                  │
│  ·array()       ·reshape()     │    ·一维数据      ·二维表格                 │
│  ·zeros()       ·flatten()     │    ·带索引        ·行列索引                 │
│  ·ones()        ·transpose()   │                                           │
│  ·arange()      ·concatenate() │    ┌─────────────────────────┐            │
│  ·linspace()                   │    │      核心操作            │            │
│                                │    ├─────────────────────────┤            │
│  ┌─────────┐    ┌─────────┐    │    │ 读写 │ 选择 │ 清洗 │ 统计│            │
│  │数学运算  │    │统计函数  │    │    └─────────────────────────┘            │
│  └────┬────┘    └────┬────┘    │                                           │
│       │              │         │    read_csv  loc/iloc  dropna   describe  │
│  ·四则运算       ·mean()       │    to_csv    query     fillna   groupby   │
│  ·矩阵乘法       ·std()        │    to_excel  filter    replace  agg       │
│  ·广播机制       ·sum()        │                                           │
│                  ·max/min()    │    ┌─────────────────────────┐            │
│                                │    │      高级操作            │            │
│  ┌─────────┐    ┌─────────┐    │    ├─────────────────────────┤            │
│  │索引切片  │    │线性代数  │    │    │ 合并 │ 重塑 │ 时间序列 │            │
│  └────┬────┘    └────┬────┘    │    └─────────────────────────┘            │
│       │              │         │                                           │
│  ·基础索引       ·dot()        │    merge     pivot     resample           │
│  ·布尔索引       ·inv()        │    concat    melt      rolling            │
│  ·花式索引       ·eig()        │    join      stack     shift              │
│                                │                                           │
└─────────────────────────────────┴───────────────────────────────────────────┘

🔢 NumPy 核心方法

1. 数组创建

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
import numpy as np

# ═══════════ 基础创建 ═══════════
np.array([1, 2, 3])              # 从列表创建
np.array([[1,2], [3,4]])         # 二维数组

# ═══════════ 特殊数组 ═══════════
np.zeros((3, 4))                 # 全0数组 (3行4列)
np.ones((2, 3))                  # 全1数组
np.empty((2, 2))                 # 未初始化数组
np.full((3, 3), 7)               # 填充指定值
np.eye(4)                        # 单位矩阵
np.identity(3)                   # 单位矩阵

# ═══════════ 序列数组 ═══════════
np.arange(0, 10, 2)              # [0, 2, 4, 6, 8] 等差数列
np.linspace(0, 1, 5)             # [0, 0.25, 0.5, 0.75, 1] 等分
np.logspace(0, 2, 3)             # [1, 10, 100] 对数等分

# ═══════════ 随机数组 ═══════════
np.random.rand(3, 4)             # 0-1均匀分布
np.random.randn(3, 4)            # 标准正态分布
np.random.randint(0, 10, (3,4))  # 随机整数
np.random.choice([1,2,3], 5)     # 随机选择
np.random.shuffle(arr)           # 打乱数组

2. 数组属性与变形

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
arr = np.array([[1,2,3], [4,5,6]])

# ═══════════ 属性查看 ═══════════
arr.shape                        # (2, 3) 形状
arr.ndim                         # 2 维度
arr.size                         # 6 元素总数
arr.dtype                        # 数据类型

# ═══════════ 形状变换 ═══════════
arr.reshape(3, 2)                # 重塑为3行2列
arr.reshape(-1)                  # 展平为一维 (自动计算)
arr.flatten()                    # 展平 (返回副本)
arr.ravel()                      # 展平 (返回视图)
arr.T                            # 转置
arr.transpose()                  # 转置

# ═══════════ 维度操作 ═══════════
np.expand_dims(arr, axis=0)      # 增加维度
np.squeeze(arr)                  # 删除长度为1的维度

3. 数组索引与切片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
arr = np.array([[1,2,3], [4,5,6], [7,8,9]])

# ═══════════ 基础索引 ═══════════
arr[0]                           # 第一行 [1,2,3]
arr[0, 1]                        # 第一行第二列 = 2
arr[-1]                          # 最后一行

# ═══════════ 切片 ═══════════
arr[0:2]                         # 前两行
arr[:, 1]                        # 所有行的第二列
arr[0:2, 1:3]                    # 子矩阵
arr[::2]                         # 每隔一行

# ═══════════ 布尔索引 ═══════════
arr[arr > 5]                     # 大于5的元素
arr[(arr > 2) & (arr < 8)]       # 组合条件

# ═══════════ 花式索引 ═══════════
arr[[0, 2]]                      # 第1、3行
arr[[0,1], [1,2]]                # arr[0,1]和arr[1,2]

4. 数学运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# ═══════════ 基础运算 (元素级) ═══════════
a + b                            # [5, 7, 9]
a - b                            # [-3, -3, -3]
a * b                            # [4, 10, 18]
a / b                            # [0.25, 0.4, 0.5]
a ** 2                           # [1, 4, 9]
np.sqrt(a)                       # 平方根
np.exp(a)                        # e的幂
np.log(a)                        # 自然对数
np.sin(a)                        # 三角函数

# ═══════════ 矩阵运算 ═══════════
A = np.array([[1,2], [3,4]])
B = np.array([[5,6], [7,8]])

A @ B                            # 矩阵乘法 (推荐)
np.dot(A, B)                     # 矩阵乘法
A * B                            # 元素级乘法 (哈达玛积)
np.linalg.inv(A)                 # 逆矩阵
np.linalg.det(A)                 # 行列式
np.linalg.eig(A)                 # 特征值和特征向量

5. 统计函数

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
arr = np.array([[1,2,3], [4,5,6]])

# ═══════════ 聚合统计 ═══════════
np.sum(arr)                      # 总和 = 21
np.sum(arr, axis=0)              # 按列求和 [5,7,9]
np.sum(arr, axis=1)              # 按行求和 [6,15]

np.mean(arr)                     # 均值
np.median(arr)                   # 中位数
np.std(arr)                      # 标准差
np.var(arr)                      # 方差

np.max(arr)                      # 最大值
np.min(arr)                      # 最小值
np.argmax(arr)                   # 最大值索引
np.argmin(arr)                   # 最小值索引

np.cumsum(arr)                   # 累计和
np.cumprod(arr)                  # 累计积

# ═══════════ 比较统计 ═══════════
np.all(arr > 0)                  # 是否全部满足
np.any(arr > 5)                  # 是否存在满足
np.where(arr > 3)                # 返回满足条件的索引
np.where(arr > 3, arr, 0)        # 条件替换

6. 数组合并与分割

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# ═══════════ 合并 ═══════════
np.concatenate([a, b])           # [1,2,3,4,5,6]
np.vstack([a, b])                # 垂直堆叠 (按行)
np.hstack([a, b])                # 水平堆叠 (按列)
np.stack([a, b], axis=0)         # 沿新轴堆叠

# ═══════════ 分割 ═══════════
arr = np.arange(9)
np.split(arr, 3)                 # 等分为3份
np.array_split(arr, 4)           # 不等分
np.vsplit(arr2d, 2)              # 垂直分割
np.hsplit(arr2d, 2)              # 水平分割

🐼 Pandas 核心方法

1. 数据结构创建

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import pandas as pd

# ═══════════ Series (一维) ═══════════
s = pd.Series([1, 2, 3, 4])
s = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
s = pd.Series({'a': 1, 'b': 2, 'c': 3})

# ═══════════ DataFrame (二维) ═══════════
# 从字典创建
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 35],
    'city': ['NY', 'LA', 'SF']
})

# 从列表创建
df = pd.DataFrame(
    [[1, 2], [3, 4]], 
    columns=['A', 'B'],
    index=['row1', 'row2']
)

# 从NumPy数组创建
df = pd.DataFrame(np.random.randn(3, 4), columns=list('ABCD'))

2. 数据读写

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# ═══════════ 读取数据 ═══════════
df = pd.read_csv('file.csv')                    # CSV
df = pd.read_csv('file.csv', encoding='utf-8')  # 指定编码
df = pd.read_csv('file.csv', usecols=['A','B']) # 指定列
df = pd.read_csv('file.csv', nrows=100)         # 读取前N行

df = pd.read_excel('file.xlsx')                 # Excel
df = pd.read_excel('file.xlsx', sheet_name='Sheet1')

df = pd.read_json('file.json')                  # JSON
df = pd.read_sql(query, connection)             # SQL数据库
df = pd.read_html('url')[0]                     # 网页表格

# ═══════════ 保存数据 ═══════════
df.to_csv('output.csv', index=False)            # 不保存索引
df.to_excel('output.xlsx', sheet_name='Data')
df.to_json('output.json')
df.to_sql('table_name', connection)

3. 数据查看与信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# ═══════════ 查看数据 ═══════════
df.head(10)                      # 前10行
df.tail(5)                       # 后5行
df.sample(5)                     # 随机5行

# ═══════════ 基本信息 ═══════════
df.shape                         # (行数, 列数)
df.info()                        # 数据类型、内存等
df.dtypes                        # 各列数据类型
df.columns                       # 列名
df.index                         # 索引
df.values                        # 转为NumPy数组

# ═══════════ 统计摘要 ═══════════
df.describe()                    # 数值列统计摘要
df.describe(include='all')       # 所有列统计摘要
df['col'].value_counts()         # 值计数
df['col'].unique()               # 唯一值
df['col'].nunique()              # 唯一值数量

4. 数据选择与过滤

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
# ═══════════ 列选择 ═══════════
df['name']                       # 单列 (Series)
df[['name', 'age']]              # 多列 (DataFrame)

# ═══════════ 行选择 ═══════════
df[0:3]                          # 前3行 (切片)
df.iloc[0]                       # 第1行 (位置索引)
df.iloc[0:3]                     # 前3行
df.iloc[0:3, 0:2]                # 前3行前2列

df.loc['row1']                   # 按标签索引
df.loc['row1':'row3']            # 标签范围
df.loc['row1', 'col1']           # 指定单元格

# ═══════════ 条件过滤 ═══════════
df[df['age'] > 25]               # 年龄大于25
df[df['city'] == 'NY']           # 城市是NY
df[(df['age'] > 25) & (df['city'] == 'NY')]  # 组合条件
df[df['city'].isin(['NY', 'LA'])]            # 在列表中
df[df['name'].str.contains('A')]             # 字符串包含

# ═══════════ query方法 (推荐) ═══════════
df.query('age > 25')
df.query('age > 25 and city == "NY"')
df.query('city in ["NY", "LA"]')

5. 数据清洗

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
# ═══════════ 缺失值处理 ═══════════
df.isnull()                      # 检查缺失值
df.isnull().sum()                # 每列缺失值数量
df.dropna()                      # 删除含缺失值的行
df.dropna(subset=['col1'])       # 指定列有缺失才删除
df.dropna(how='all')             # 全为空才删除
df.fillna(0)                     # 填充为0
df.fillna(df.mean())             # 填充为均值
df.fillna(method='ffill')        # 向前填充
df.fillna(method='bfill')        # 向后填充
df.interpolate()                 # 插值填充

# ═══════════ 重复值处理 ═══════════
df.duplicated()                  # 检查重复行
df.drop_duplicates()             # 删除重复行
df.drop_duplicates(subset=['col1'])  # 按指定列去重
df.drop_duplicates(keep='last')  # 保留最后一个

# ═══════════ 数据替换 ═══════════
df.replace('old', 'new')         # 替换值
df.replace({'old1': 'new1', 'old2': 'new2'})
df['col'].map({'A': 1, 'B': 2})  # 映射替换

# ═══════════ 数据类型转换 ═══════════
df['col'].astype('int')          # 转为整数
df['col'].astype('float')        # 转为浮点数
df['col'].astype('str')          # 转为字符串
pd.to_datetime(df['date'])       # 转为日期
pd.to_numeric(df['col'], errors='coerce')  # 转为数值

# ═══════════ 重命名 ═══════════
df.rename(columns={'old': 'new'})
df.columns = ['A', 'B', 'C']     # 直接赋值

6. 数据统计与聚合

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
# ═══════════ 基础统计 ═══════════
df['col'].sum()                  # 求和
df['col'].mean()                 # 均值
df['col'].median()               # 中位数
df['col'].std()                  # 标准差
df['col'].var()                  # 方差
df['col'].min()                  # 最小值
df['col'].max()                  # 最大值
df['col'].count()                # 非空计数
df['col'].mode()                 # 众数

# ═══════════ 分组聚合 (核心!) ═══════════
df.groupby('city').mean()                    # 按城市分组求均值
df.groupby('city')['age'].mean()             # 指定列
df.groupby(['city', 'gender']).mean()        # 多列分组

# 多种聚合函数
df.groupby('city').agg({
    'age': 'mean',
    'salary': ['sum', 'max'],
    'name': 'count'
})

# 自定义聚合
df.groupby('city').agg(
    avg_age=('age', 'mean'),
    total_salary=('salary', 'sum'),
    count=('name', 'count')
)

# ═══════════ 透视表 ═══════════
pd.pivot_table(df, 
    values='salary',              # 值
    index='department',           # 行
    columns='gender',             # 列
    aggfunc='mean'                # 聚合函数
)

7. 数据合并

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# ═══════════ concat 拼接 ═══════════
pd.concat([df1, df2])                    # 纵向拼接
pd.concat([df1, df2], axis=1)            # 横向拼接
pd.concat([df1, df2], ignore_index=True) # 重置索引

# ═══════════ merge 合并 (类似SQL JOIN) ═══════════
pd.merge(df1, df2, on='key')             # 内连接
pd.merge(df1, df2, on='key', how='left') # 左连接
pd.merge(df1, df2, on='key', how='right')# 右连接
pd.merge(df1, df2, on='key', how='outer')# 外连接
pd.merge(df1, df2, left_on='a', right_on='b')  # 不同列名

# ═══════════ join 索引合并 ═══════════
df1.join(df2, how='left')                # 按索引合并

8. 数据变形

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# ═══════════ 排序 ═══════════
df.sort_values('age')                    # 按值排序
df.sort_values('age', ascending=False)   # 降序
df.sort_values(['city', 'age'])          # 多列排序
df.sort_index()                          # 按索引排序

# ═══════════ 重塑 ═══════════
# 长变宽
df.pivot(index='date', columns='city', values='temp')

# 宽变长
df.melt(id_vars=['date'], var_name='city', value_name='temp')

# 堆叠
df.stack()                               # 列转行
df.unstack()                             # 行转列

# ═══════════ 新增/删除列 ═══════════
df['new_col'] = df['a'] + df['b']        # 新增列
df.assign(new_col=df['a'] * 2)           # assign方法
df.drop('col', axis=1)                   # 删除列
df.drop(['col1', 'col2'], axis=1)        # 删除多列
df.drop(0, axis=0)                       # 删除行

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
# ═══════════ 日期处理 ═══════════
df['date'] = pd.to_datetime(df['date'])
df['year'] = df['date'].dt.year
df['month'] = df['date'].dt.month
df['day'] = df['date'].dt.day
df['weekday'] = df['date'].dt.weekday
df['quarter'] = df['date'].dt.quarter

# ═══════════ 日期索引 ═══════════
df.set_index('date', inplace=True)
df['2023']                               # 2023年数据
df['2023-06']                            # 2023年6月
df['2023-01':'2023-06']                  # 日期范围

# ═══════════ 重采样 ═══════════
df.resample('M').mean()                  # 月度均值
df.resample('Q').sum()                   # 季度求和
df.resample('Y').count()                 # 年度计数

# ═══════════ 滑动窗口 ═══════════
df['col'].rolling(window=7).mean()       # 7日移动平均
df['col'].rolling(window=30).std()       # 30日滚动标准差
df['col'].ewm(span=7).mean()             # 指数加权移动平均

# ═══════════ 移位 ═══════════
df['col'].shift(1)                       # 向下移1位
df['col'].shift(-1)                      # 向上移1位
df['col'].diff()                         # 差分
df['col'].pct_change()                   # 百分比变化

10. apply 函数应用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# ═══════════ apply (最灵活) ═══════════
# Series apply
df['col'].apply(lambda x: x * 2)
df['col'].apply(np.sqrt)

# DataFrame apply
df.apply(np.sum, axis=0)                 # 按列
df.apply(np.sum, axis=1)                 # 按行

# 自定义函数
def custom_func(x):
    return x.max() - x.min()
df.apply(custom_func)

# ═══════════ map (Series专用) ═══════════
df['col'].map({'A': 1, 'B': 2})

# ═══════════ applymap (元素级) ═══════════
df.applymap(lambda x: f'{x:.2f}')        # 格式化所有元素

🎯 快速记忆口诀

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
┌────────────────────────────────────────────────────────────┐
│                      NumPy 记忆口诀                         │
├────────────────────────────────────────────────────────────┤
│  创建记住: array, zeros, ones, arange, linspace           │
│  变形记住: reshape, flatten, transpose (或 .T)            │
│  运算记住: +,-,*,/,@, dot                                 │
│  统计记住: sum, mean, std, max, min                        │
│  索引记住: 切片[:], 布尔[arr>0], 花式[[0,2]]               │
└────────────────────────────────────────────────────────────┘

┌────────────────────────────────────────────────────────────┐
│                      Pandas 记忆口诀                        │
├────────────────────────────────────────────────────────────┤
│  读写记住: read_csv/to_csv, read_excel/to_excel           │
│  选择记住: loc[标签], iloc[位置], query('条件')            │
│  清洗记住: dropna, fillna, drop_duplicates, replace       │
│  聚合记住: groupby + agg, pivot_table                      │
│  合并记住: concat(拼), merge(连), join(索引)               │
│  时间记住: to_datetime, resample, rolling                  │
└────────────────────────────────────────────────────────────┘

📋 常用操作速查表

任务 NumPy Pandas
创建数据 np.array() pd.DataFrame()
查看形状 arr.shape df.shape
选择数据 arr[0:3] df.loc[]/df.iloc[]
条件筛选 arr[arr>0] df[df['col']>0]/df.query()
统计均值 np.mean(arr) df.mean()
排序 np.sort(arr) df.sort_values()
去重 np.unique(arr) df.drop_duplicates()
缺失值 np.isnan(arr) df.isna()/df.fillna()
合并 np.concatenate() pd.concat()/pd.merge()
分组 - df.groupby()