一文带你详解Python如何使用Pandas玩转表格数据

  import pandas as pd
  import numpy as np
  ​
  # 创建 Series
  s = pd.Series([1, 3, 5, np.nan, 6, 8])
  print(s)

 # 创建 DataFrame
  dates = pd.date_range('20260101', periods=6)
  df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list('ABCD'))
  ​
  print(df)

 # CSV 文件
  df = pd.read_csv('data.csv')
  df.to_csv('output.csv', index=False)
  ​
  # Excel 文件
  df = pd.read_excel('data.xlsx', sheet_name='Sheet1')
  df.to_excel('output.xlsx', sheet_name='Sheet1')
  ​
  # SQL 数据库
  from sqlalchemy import create_engine
  engine = create_engine('sqlite:///:memory:')
  df.to_sql('my_table', engine)
  ​
  # JSON 数据
  df = pd.read_json('data.json')
  ​
  # 从字典创建
  data = {'name': ['Alice', 'Bob'], 'age': [25, 30]}
  df = pd.DataFrame(data)

 df.head(5)        # 前5行
  df.tail(3)        # 后3行
  df.shape          # 维度 (行数, 列数)
  df.columns        # 列名
  df.index          # 索引
  df.describe()     # 统计摘要
  df.info()         # 详细信息

 # 按列选择
  df['A']           # 选择单列，返回 Series
  df[['A', 'B']]    # 选择多列，返回 DataFrame
  ​
  # 按行选择（不推荐直接用索引）
  df[0:3]           # 切片选择前3行
  ​
  # 标签选择 .loc[]
  df.loc['20260101']                    # 选择单行
  df.loc[:, ['A', 'B']]                 # 选择多列
  df.loc['20260101':'20260103', 'A':'C'] # 行列切片
  ​
  # 位置选择 .iloc[]
  df.iloc[3]                            # 第4行（从0开始）
  df.iloc[3:5, 0:2]                     # 行3-4，列0-1
  df.iloc[[1, 2, 4], [0, 2]]            # 特定行列
  ​
  # 布尔索引（条件筛选）
  df[df['A'] > 0]                       # A列大于0的行
  df[(df['A'] > 0) & (df['B'] < 0)]     # 多条件组合
  df[df['A'].isin([1, 2, 3])]           # 包含判断

 # 检测缺失值
  df.isnull()           # 返回布尔矩阵
  df.isnull().sum()     # 每列缺失值计数
  ​
  # 删除缺失值
  df.dropna()           # 删除包含NaN的行
  df.dropna(axis=1)     # 删除包含NaN的列
  df.dropna(how='all')  # 只删除全为NaN的行
  ​
  # 填充缺失值
  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=['A', 'B'], keep='last')  # 基于特定列

 df['A'].astype(float)           # 转换为浮点型
  df['B'].astype('category')      # 转换为类别型（节省内存）
  pd.to_datetime(df['date'])      # 转换为日期时间
  pd.to_numeric(df['col'], errors='coerce')  # 强制转换，无效值变NaN

 df['name'].str.lower()          # 转小写
  df['name'].str.contains('John') # 包含判断
  df['name'].str.replace('a', 'b')# 替换
  df['email'].str.split('@')      # 分割
  df['name'].str[:3]              # 切片

 # apply：沿轴应用函数
  df.apply(np.cumsum)             # 累积和
  df.apply(lambda x: x.max() - x.min())  # 极差
  ​
  # applymap：逐元素应用（仅DataFrame）
  df.applymap(lambda x: len(str(x)))
  ​
  # map：仅用于 Series
  df['A'].map(lambda x: x**2)

 # concat：轴向连接
  pd.concat([df1, df2])           # 纵向拼接（行）
  pd.concat([df1, df2], axis=1)   # 横向拼接（列）
  ​
  # merge：数据库风格的合并
  pd.merge(df1, df2, on='key')                    # 内连接
  pd.merge(df1, df2, on='key', how='left')        # 左连接
  pd.merge(df1, df2, left_on='lkey', right_on='rkey')  # 不同键名
  ​
  # join：基于索引合并
  df1.join(df2, how='outer')

 # pivot：透 视表
  df.pivot(index='date', columns='variable', values='value')
  ​
  # melt：宽格式转长格式
  pd.melt(df, id_vars=['id'], value_vars=['A', 'B'])
  ​
  # stack/unstack：层级索引操作
  df.stack()                      # 列旋转为行
  df.unstack()                    # 行旋转为列
  ​
  # pivot_table：高级透 视表
  df.pivot_table(values='D', index='A', columns='B', aggfunc=np.sum)

 # 基础分组
  df.groupby('A').sum()           # 按A分组求和
  df.groupby(['A', 'B']).mean()   # 多列分组求均值
  ​
  # 多聚合操作
  df.groupby('A').agg({
      'B': ['min', 'max', 'mean'],
      'C': 'sum'
  })
  ​
  # 转换（保持原形状）
  df.groupby('A').transform(lambda x: (x - x.mean()) / x.std())
  ​
  # 过滤
  df.groupby('A').filter(lambda x: x['B'].sum() > 100)
  ​
  # apply：自定义操作
  df.groupby('A').apply(lambda x: x.sort_values('B').iloc[0])

 # 创建时间范围
  rng = pd.date_range('2026-01-01', periods=100, freq='D')  # 日频
  rng = pd.date_range('2026-01-01', periods=12, freq='M')   # 月频
  ​
  # 时间索引
  ts = pd.Series(np.random.randn(len(rng)), index=rng)
  ​
  # 重采样（Resampling）
  ts.resample('M').mean()         # 降采样：月均值
  ts.resample('D').interpolate()  # 升采样：插值
  ​
  # 移动窗口
  ts.rolling(window=7).mean()     # 7日移动平均
  ts.expanding().sum()            # 扩展窗口求和
  ​
  # 时间偏移
  ts.shift(1)                     # 滞后1期
  ts.shift(-1)                    # 超前1期
  ​
  # 时区处理
  ts_utc = ts.tz_localize('UTC')
  ts_sh = ts_utc.tz_convert('Asia/Shanghai')

 # 查看内存使用
  df.info(memory_usage='deep')
  ​
  # 优化数据类型
  df['int_col'] = df['int_col'].astype('int32')      # 默认 int64 → int32
  df['float_col'] = df['float_col'].astype('float32')
  df['category_col'] = df['category_col'].astype('category')  # 类别型

 # ❌ 慢：Python 循环
  result = []
  for idx, row in df.iterrows():
      result.append(row['A'] + row['B'])
  ​
  # ✅ 快：向量化
  result = df['A'] + df['B']
  ​
  # ✅ 更快：NumPy 底层
  result = df['A'].values + df['B'].values

 # 大型 DataFrame 的表达式计算
  df.eval('C = A + B', inplace=True)
  df.query('A > 0 and B < 0')

 import pandas as pd
  import numpy as np
  ​
  # 1. 加载数据
  df = pd.read_csv('sales_data.csv', parse_dates=['date'])
  ​
  # 2. 数据清洗
  df.drop_duplicates(inplace=True)
  df.dropna(subset=['sales', 'quantity'], inplace=True)
  df['category'] = df['category'].astype('category')
  ​
  # 3. 特征工程
  df['revenue'] = df['sales'] * df['quantity']
  df['month'] = df['date'].dt.to_period('M')
  ​
  # 4. 数据分析
  monthly_sales = df.groupby('month')['revenue'].sum()
  category_stats = df.groupby('category').agg({
      'revenue': ['sum', 'mean', 'count'],
      'quantity': 'sum'
  })
  ​
  # 5. 透 视分析
  pivot = df.pivot_table(
      values='revenue', 
      index='month', 
      columns='category', 
      aggfunc='sum',
      fill_value=0
  )
  ​
  # 6. 导出结果
  monthly_sales.to_csv('monthly_report.csv')
  category_stats.to_excel('category_report.xlsx')

 # 启用 PyArrow 后端（推荐）
  df = pd.read_csv('data.csv', dtype_backend='pyarrow')