pandas 入门与常用用法详解

pandas 是 Python 中用于数据处理和分析的核心库，提供了高效的数据结构和数据分析工具。以下从基础到进阶，全面介绍 pandas 的常用用法。

一、核心数据结构

1. Series（一维数组）
import pandas as pd
import numpy as np

# 创建 Series
s = pd.Series([10, 20, 30, 40], index=['a', 'b', 'c', 'd'])
print(s)
# a    10
# b    20
# c    30
# d    40
# dtype: int64

# 访问元素
print(s['a'])  # 10
print(s[0])   # 10

# 切片
print(s[1:3])  # b    20\nc    30
2. DataFrame（二维表格）
# 创建 DataFrame
data = {
    '姓名': ['张三', '李四', '王五'],
    '年龄': [25, 30, 22],
    '分数': [85.5, 90.0, 78.5]
}
df = pd.DataFrame(data)
print(df)
#   姓名  年龄  分数
# 0  张三  25  85.5
# 1  李四  30  90.0
# 2  王五  22  78.5

# 查看基本信息
print(df.info())     # 数据类型和非空值统计
print(df.describe()) # 数值列的统计摘要

二、数据读取与保存

1. 读取数据
# 从 CSV 读取
df_csv = pd.read_csv('data.csv')

# 从 Excel 读取
df_excel = pd.read_excel('data.xlsx', sheet_name='Sheet1')

# 从 SQL 读取
import sqlalchemy as sa
engine = sa.create_engine('sqlite:///database.db')
df_sql = pd.read_sql('SELECT * FROM users', engine)

# 从 JSON 读取
df_json = pd.read_json('data.json')
2. 保存数据
# 保存为 CSV
df.to_csv('output.csv', index=False)  # index=False 不保存索引列

# 保存为 Excel
df.to_excel('output.xlsx', sheet_name='数据', index=False)

# 保存为 SQL
df.to_sql('users_new', engine, if_exists='replace')

三、数据探索与清洗

1. 数据查看
print(df.head())      # 查看前5行
print(df.tail(3))     # 查看后3行
print(df.shape)       # 查看行列数 (3, 3)
print(df.columns)     # 查看列名 Index(['姓名', '年龄', '分数'], dtype='object')
2. 处理缺失值
# 查看缺失值
print(df.isnull().sum())  # 各列缺失值数量

# 丢弃缺失值
df_clean = df.dropna()

# 填充缺失值
df_filled = df.fillna(0)  # 用0填充
df_filled = df.fillna(method='ffill')  # 用前一个值填充
3. 数据类型转换
# 转换年龄列为字符串
df['年龄'] = df['年龄'].astype(str)

# 转换分数列为整数（向下取整）
df['分数'] = df['分数'].astype(int)

四、数据操作与分析

1. 数据筛选与过滤
# 按条件筛选
young_people = df[df['年龄'] < 25]

# 多条件筛选
high_score = df[(df['分数'] > 80) & (df['年龄'] < 30)]

# 按索引筛选
print(df.loc[0])       # 按标签索引
print(df.iloc[0])      # 按位置索引
print(df.loc[[0, 2]])  # 筛选多行
2. 数据排序
# 按年龄升序排序
df_sorted = df.sort_values('年龄')

# 按分数降序排序
df_sorted = df.sort_values('分数', ascending=False)

# 多列排序
df_sorted = df.sort_values(['年龄', '分数'])
3. 数据分组与聚合
# 按年龄分组并计算分数平均值
grouped = df.groupby('年龄')['分数'].mean()

# 多列聚合
agg_data = df.groupby('年龄').agg({
    '分数': 'mean',
    '姓名': 'count'
})

# 分组后应用函数
def get_top_score(group):
    return group.nlargest(1, '分数')

top_scores = df.groupby('年龄').apply(get_top_score)

五、数据合并与重塑

1. 合并数据
# 纵向合并（追加）
df1 = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
df2 = pd.DataFrame({'A': [5, 6], 'B': [7, 8]})
combined = pd.concat([df1, df2])

# 横向合并（连接）
df3 = pd.DataFrame({'A': [1, 2], 'C': [9, 10]})
merged = pd.merge(df1, df3, on='A')  # 按A列合并
2. 数据透视表
# 创建透视表
pivot = pd.pivot_table(df, index='姓名', columns='年龄', values='分数', aggfunc='mean')

# 交叉表
crosstab = pd.crosstab(df['姓名'], df['年龄'])

六、数据可视化

pandas 与 matplotlib/seaborn 结合可轻松可视化数据：

import matplotlib.pyplot as plt

# 绘制柱状图
df.plot(kind='bar', x='姓名', y='分数', title='分数分布')
plt.show()

# 绘制折线图
time_series = pd.Series([10, 15, 12, 18, 20], index=pd.date_range('2023-01-01', periods=5))
time_series.plot(kind='line')
plt.show()

# 绘制饼图
df['年龄'].value_counts().plot(kind='pie', autopct='%1.1f%%')
plt.show()

七、高级功能：时间序列处理

# 创建时间序列
dates = pd.date_range('2023-01-01', periods=5, freq='D')
ts = pd.Series([10, 12, 15, 11, 14], index=dates)

# 重采样（将日数据转为周数据求和）
weekly_sum = ts.resample('W').sum()

# 滚动窗口计算
rolling_mean = ts.rolling(window=2).mean()

八、性能优化技巧

  1. 向量化操作：避免循环，使用 pandas 内置函数 
    # 低效写法
# for i in range(len(df)):
#     df.loc[i, '分数翻倍'] = df.loc[i, '分数'] * 2

# 高效写法
df['分数翻倍'] = df['分数'] * 2
  2. 使用 dtype 优化：指定合适的数据类型减少内存占用 
    df['年龄'] = df['年龄'].astype('int8')  # 若年龄范围小，用 int8 代替 int64
  3. 分块处理大数据： 
    # 分块读取大文件
chunks = pd.read_csv('large_file.csv', chunksize=1000)
for chunk in chunks:
    # 处理每个数据块
    processed_chunk = chunk.dropna()
    # ...

九、实战案例：学生成绩分析

# 假设已有学生成绩数据
data = {
    '姓名': ['张三', '李四', '王五', '赵六'],
    '数学': [85, 92, 78, 88],
    '英语': [76, 88, 90, 82],
    '语文': [90, 85, 82, 79]
}
df = pd.DataFrame(data)

# 1. 计算总分和平均分
df['总分'] = df[['数学', '英语', '语文']].sum(axis=1)
df['平均分'] = df[['数学', '英语', '语文']].mean(axis=1)

# 2. 找出各科最高分学生
max_scores = df[['姓名', '数学', '英语', '语文']].set_index('姓名').idxmax()
print("各科最高分学生:", max_scores)

# 3. 分析分数分布
print("数学分数描述统计:", df['数学'].describe())

# 4. 可视化
df[['数学', '英语', '语文']].plot(kind='box')
plt.title('各科分数箱线图')
plt.show()

总结

pandas 是数据处理的核心工具，掌握以上用法可应对大部分数据处理需求。进阶学习可关注：

  • pandas 官方文档：pandas - Python Data Analysis Library
  • 时间序列分析（pd.Timestamp, pd.date_range）
  • 数据清洗与特征工程
  • 与其他库（如 numpy, scikit-learn）的集成

通过大量实践（如 Kaggle 数据集练习），可逐步提升 pandas 应用能力。

pandas 进阶学习指南

掌握 pandas 基础后，进阶学习可大幅提升数据处理效率和代码质量。以下从高级数据操作、性能优化、复杂分析到与其他工具集成，提供系统性的进阶路径。

一、高级数据处理技巧

1. 高级索引与选择
# 1.1 多层索引（MultiIndex）
arrays = [['bar', 'bar', 'baz', 'baz'], ['one', 'two', 'one', 'two']]
index = pd.MultiIndex.from_arrays(arrays, names=['first', 'second'])
df = pd.DataFrame({'A': [1, 2, 3, 4]}, index=index)

# 选择第一层索引
print(df.loc['bar'])

# 交叉选择
print(df.xs('one', level='second'))

# 1.2 布尔索引高级用法
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
mask = df['A'].between(1, 2)
print(df[mask])

# 1.3 query() 方法
print(df.query('A > 1 and B < 6'))
2. 数据转换与映射
# 2.1 map() 应用于 Series
df = pd.DataFrame({'A': ['a', 'b', 'a'], 'B': [1, 2, 3]})
mapping = {'a': 'apple', 'b': 'banana'}
df['A_mapped'] = df['A'].map(mapping)

# 2.2 apply() 应用于 DataFrame
def multiply_by_two(x):
    return x * 2

df['B_doubled'] = df['B'].apply(multiply_by_two)

# 2.3 applymap() 应用于全量元素
df = df.applymap(lambda x: str(x).upper() if isinstance(x, str) else x)
3. 缺失值高级处理
# 3.1 插值填充
df = pd.DataFrame({'A': [1, np.nan, 3, np.nan, 5]})
df['A_interpolated'] = df['A'].interpolate(method='linear')

# 3.2 缺失值预测模型
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(strategy='median')
df['A_imputed'] = imputer.fit_transform(df[['A']])

二、性能优化与内存管理

1. 高效数据类型
# 1.1 使用 category 替代 object
df['A'] = df['A'].astype('category')  # 节省内存，提升排序/分组速度

# 1.2 数值类型优化
df['B'] = df['B'].astype('int8')      # 适用于范围小的整数
df['C'] = df['C'].astype('float32')   # 降低浮点数精度节省内存
2. 向量化操作 vs 循环
# 低效：循环操作
result = []
for i in range(len(df)):
    result.append(df.iloc[i]['A'] * 2)

# 高效：向量化操作
result = df['A'] * 2

# 更高效：numba 加速
from numba import njit

@njit
def compute_squares(arr):
    result = np.empty_like(arr)
    for i in range(len(arr)):
        result[i] = arr[i] ** 2
    return result

df['A_squared'] = compute_squares(df['A'].values)
3. 内存优化工具
# 查看内存占用
print(df.memory_usage(deep=True))

# 分块处理大文件
chunksize = 1000
for chunk in pd.read_csv('large_file.csv', chunksize=chunksize):
    # 处理每个数据块
    processed_chunk = chunk[chunk['A'] > 100]
    processed_chunk.to_csv('output.csv', mode='a', header=not os.path.exists('output.csv'))

三、复杂数据处理与分析

1. 窗口函数
# 1.1 滚动窗口
df = pd.DataFrame({'A': [1, 2, 3, 4, 5]})
df['rolling_mean'] = df['A'].rolling(window=3).mean()

# 1.2 扩展窗口（累计计算）
df['expanding_sum'] = df['A'].expanding().sum()

# 1.3 指数加权窗口
df['ewm_mean'] = df['A'].ewm(alpha=0.3).mean()
2. 时间序列高级处理
# 2.1 时区处理
ts = pd.Series(pd.date_range('2023-01-01', periods=3, tz='UTC'))
ts_localized = ts.dt.tz_convert('Asia/Shanghai')

# 2.2 移动/滞后
df['A_shifted'] = df['A'].shift(1)       # 滞后1期
df['A_lead'] = df['A'].shift(-1)         # 超前1期

# 2.3 时间序列重采样
ts = pd.Series(np.random.randn(1000), index=pd.date_range('2023-01-01', periods=1000))
daily_to_weekly = ts.resample('W').mean()
3. 分组高级应用
# 3.1 分组后应用多个聚合函数
df.groupby('category').agg({'A': ['sum', 'mean'], 'B': ['min', 'max']})

# 3.2 分组后转换
df['group_mean'] = df.groupby('category')['A'].transform('mean')

# 3.3 分组后过滤
df_filtered = df.groupby('category').filter(lambda x: x['A'].mean() > 10)

四、与其他工具集成

1. 与 SQL 对比与互操作
# SQL 风格查询
result = df.query('A > 1 and B < 10')

# DataFrame 转 SQL
from sqlalchemy import create_engine
engine = create_engine('sqlite:///mydata.db')
df.to_sql('mytable', con=engine, if_exists='replace')

# SQL 查询到 DataFrame
query_result = pd.read_sql('SELECT * FROM mytable WHERE A > 1', engine)
2. 与机器学习集成
# 2.1 特征工程
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
df['A_scaled'] = scaler.fit_transform(df[['A']])

# 2.2 与 scikit-learn 管道集成
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.ensemble import RandomForestRegressor

pipeline = Pipeline([
    ('imputer', SimpleImputer(strategy='median')),
    ('model', RandomForestRegressor())
])

# 2.3 交叉验证
from sklearn.model_selection import cross_val_score
X = df[['A', 'B']]
y = df['target']
scores = cross_val_score(pipeline, X, y, cv=5)
3. 并行计算
# 使用 pandarallel 并行加速
from pandarallel import pandarallel
pandarallel.initialize()

def complex_operation(row):
    # 复杂计算逻辑
    return row['A'] ** 2 + row['B'] ** 3

df['result'] = df.parallel_apply(complex_operation, axis=1)

五、实用技巧与最佳实践

1. 条件赋值
# np.where()
df['label'] = np.where(df['A'] > 10, 'high', 'low')

# df.loc[]
df.loc[df['A'] > 10, 'label'] = 'high'
df.loc[df['A'] <= 10, 'label'] = 'low'
2. 自定义聚合函数
def custom_agg(x):
    return x.max() - x.min()

df.groupby('category')['A'].agg(custom_agg)
3. 合并多个 DataFrame
# 多 DataFrame 合并
dfs = [df1, df2, df3]
combined = pd.concat(dfs, ignore_index=True)

# 合并时保留来源信息
combined = pd.concat(dfs, keys=['df1', 'df2', 'df3'])
4. 数据透视表高级应用
# 多级透视表
pivot = pd.pivot_table(
    df, 
    index=['category', 'subcategory'],
    columns='year',
    values='sales',
    aggfunc=['sum', 'mean']
)

六、性能调优实战案例

场景：处理 1GB+ 的 CSV 文件，包含用户行为数据，需计算每日活跃用户数。

优化前代码：

# 内存占用高，速度慢
df = pd.read_csv('big_data.csv')
df['date'] = pd.to_datetime(df['timestamp'])
daily_active = df.groupby(df['date'].dt.date)['user_id'].nunique()

优化后代码：

# 分块处理 + 类型优化
chunksize = 100000
result = pd.Series(dtype='int64')

for chunk in pd.read_csv('big_data.csv', chunksize=chunksize):
    # 优化数据类型
    chunk['user_id'] = chunk['user_id'].astype('category')
    
    # 转换日期
    chunk['date'] = pd.to_datetime(chunk['timestamp']).dt.date
    
    # 分块聚合
    chunk_agg = chunk.groupby('date')['user_id'].nunique()
    result = result.add(chunk_agg, fill_value=0)

print(result)

七、学习资源推荐

  1. 官方文档：

  2. 经典书籍：

    • 《Python 数据分析实战》（Wes McKinney，pandas 作者）
    • 《Python 数据科学手册》

  3. 进阶课程：

  4. 性能优化：

总结

pandas 进阶学习的核心在于：

  1. 数据处理效率：掌握向量化操作、内存优化和并行计算
  2. 复杂分析能力：熟练运用窗口函数、时间序列和多级聚合
  3. 工具集成：与 SQL、机器学习和大数据工具无缝对接
  4. 最佳实践：避免低效循环，合理使用 pandas 内置函数

通过持续练习真实数据集（如 Kaggle 竞赛），结合性能监控工具（如 %timeit），可逐步掌握这些高级技巧。

# pandas # python
Logo
脑启社区

脑启社区是一个专注类脑智能领域的开发者社区。欢迎加入社区，共建类脑智能生态。社区为开发者提供了丰富的开源类脑工具软件、类脑算法模型及数据集、类脑知识库、类脑技术培训课程以及类脑应用案例等资源。

更多推荐

cover

突破 Transformer 极限：一文看懂类脑架构 MT-LNN 最新的“超神”评测结果！

avatar 脑启社区

人工智能导论：模型与算法（未来发展与趋势）

人工智能作为引领新一轮科技革命和产业变革的战略性技术，正在深刻改变人类社会。本章从类脑计算、自动化机器学习、神经网络压缩、人工智能芯片、量子机器学习、人工智能伦理与治理、人工智能算法开发框架等方面，简要总结人工智能的未来发展方向和趋势。

avatar 脑启社区

CNSH通用翻译引擎 | 全语言互译+AI鉴定+来源追溯

《CNSH通用翻译引擎v1.0》摘要：该神经网络式翻译系统采用类脑架构设计，核心包含智能路由中枢（决策前额叶）和模块神经网络。具备多语言互译、AI伪代码识别、代码溯源三大功能，支持动态路径调整和双向反馈学习。系统通过特征感知、智能路由、并行处理实现高效翻译，并采用DNA追溯和三色审计确保可靠性。相比传统流水线架构，新设计具有神经网络的自适应优势，各模块可互相激活协作，实现更接近人类思维的翻译过程。

avatar 脑启社区