pandas 安装与使用一文知

pandas 是基于 Python 的开源数据处理与分析库，由 Wes McKinney 于 2008 年开发，旨在提供高效、灵活的数据结构和工具，解决现实中的数据分析问题。其名称源自 “panel data”（面板数据）和 “python data analysis” 的结合。

pandas 是数据科学领域的核心工具，其设计哲学围绕 “让数据操作更简单、更直观” 展开。无论是处理几行的 Excel 数据，还是 TB 级的结构化数据，pandas 都能通过高效的接口和丰富的功能，大幅简化数据处理流程，成为连接原始数据与分析结论的桥梁。掌握 pandas，是进入数据科学、机器学习领域的必备基础。

想要学习它，离不开先要安装，我在这里整理了一下几种安装方式，大家可以根据自己的需要选取。

一、安装

以下是整理后的 pandas 安装指南，结构清晰、步骤明确，适合不同经验的 Python 用户参考：

1.1 通过 Anaconda 安装（推荐新手）

Anaconda 是包含 pandas、NumPy、Matplotlib 等科学计算库的一站式安装包，适合快速搭建数据分析环境。

1. 下载 Anaconda
   前往 Anaconda 官网，根据系统（Linux/macOS/Windows）下载对应版本的安装程序，按提示完成安装。

2. 验证安装
   打开终端（Windows 使用 Anaconda Prompt），输入：

   python -c "import pandas; print(pandas.__version__)"
   

   若输出 pandas 版本号（如 1.5.3），则安装成功。

1.2 通过 Miniconda 安装（轻量定制化，适合经验用户）

Miniconda 是 Anaconda 的最小化版本，需手动安装依赖库，适合需要自定义环境的用户。

1. 下载 Miniconda
   从 Miniconda 官网 下载对应系统的安装包，完成安装。

2. 创建独立 conda 环境
   打开终端，运行以下命令创建环境（name_of_my_env 为环境名，可自定义）：

   conda create -c conda-forge -n name_of_my_env python pandas
   

   • -c conda-forge：使用社区维护的高质量软件源。
   • -n name_of_my_env：指定环境名称。

3. 激活环境

   • Linux/macOS：

     source activate name_of_my_env
     

   • Windows：

     activate name_of_my_env
     

4. 验证环境
   激活后，输入 python 进入 Python 环境，尝试导入 pandas：

   import pandas as pd
   

   如果没有报错则表示 pandas 安装成功。

1.3 通过 PyPI 安装（使用 pip）

适合已安装 Python 且熟悉包管理的用户。

1. 基本安装
   打开终端，运行：

   pip install pandas
   

   • 确保 pip 版本 ≥ 19.3，可通过 pip --version 检查，旧版本用 pip install --upgrade pip 更新。

2. 安装可选依赖项
   根据需求安装额外功能（如 Excel 支持、SQL 引擎等）：

   # 支持 Excel 文件（xlsx/xls）
   pip install "pandas[excel]"  
   # 支持 HDF5 文件
   pip install "pandas[hdf5]"  
   # 完整可选依赖（谨慎使用，可能安装大量包）
   pip install "pandas[all]"  
   

1.4 处理导入错误（ImportError）

若遇到 ImportError: No module named pandas，可能原因及解决方法：

1. 检查 Python 环境

   • 确认当前使用的 Python 路径是否正确（避免系统自带 Python 与用户安装路径冲突）：
     • Linux/macOS：终端输入 which python 查看路径。
     • Windows：终端输入 where python 查看路径。
   • 若安装了多个 Python 版本，建议通过虚拟环境（如 conda/venv）隔离环境。

2. 检查包安装路径
   在 Python 中运行以下代码，确认 pandas 是否在 sys.path 包含的目录中：

   import sys
   print(sys.path)  # 查看 Python 搜索包的路径列表
   

3. 重新安装 pandas
   卸载后重新安装（避免版本冲突）：

   pip uninstall pandas -y
   pip install pandas
   

1.5 从源码安装（适合开发者/尝鲜者）

用于测试开发版功能或贡献代码。

1. 安装依赖
   先安装编译所需工具（如 Cython、gcc 等），具体见 pandas 贡献指南。

2. 拉取源码

   git clone https://github.com/pandas-dev/pandas.git
   cd pandas
   

3. 安装开发版

   pip install --pre --extra-index-url https://pypi.anaconda.org/scientific-python-nightly-wheels/simple pandas
   

1.6 推荐工具：虚拟环境

无论哪种安装方式，均建议使用虚拟环境隔离项目依赖：

• conda 环境（跨平台）：

  # 创建环境（已包含 pandas）
  conda create -n my_env python=3.9 pandas  
  # 激活/退出环境
  conda activate my_env / conda deactivate
  

• Python 内置 venv（轻量，无需额外安装）：

  python -m venv my_venv  # 创建环境
  source my_venv/bin/activate  # Linux/macOS 激活
  my_venv\Scripts\activate  # Windows 激活
  pip install pandas  # 在虚拟环境中安装 pandas
  

1.7 总结

• 新手首选：Anaconda 一键安装，内置常用库，开箱即用。
• 轻量高效：Miniconda + conda 环境，灵活管理依赖。
• 快速安装：pip install pandas，适合已有 Python 环境的用户。
• 遇到问题：优先检查 Python 环境路径，使用虚拟环境避免版本冲突。

通过以上方法，可快速完成 pandas 安装，开启数据处理之旅！

二、使用

接下来我们就来探索一下这个让数据处理变的直观简单的工具 – pandas：

根据功能，Pandas 函数大致可以分为以下几组：

2.1 数据结构创建与初始化

数据结构创建与初始化函数主要用于创建 Pandas 的核心数据结构，即 Series 和 DataFrame。

1. pd.Series()：创建一维带标签的数组，可通过列表、字典等初始化。

   从列表创建 Series

   import pandas as pd
   
   # 创建一个列表
   data_list = [10, 20, 30, 40, 50]
   # 从列表创建 Series
   series_from_list = pd.Series(data_list)
   print("从列表创建的 Series：")
   print(series_from_list)
   

   从字典创建 Series

   import pandas as pd
   
   # 创建一个字典
   data_dict = {'a': 100, 'b': 200, 'c': 300}
   # 从字典创建 Series
   series_from_dict = pd.Series(data_dict)
   print("从字典创建的 Series：")
   print(series_from_dict)
   

   从标量值创建 Series

   import pandas as pd
   
   # 定义一个标量值和索引
   scalar_value = 5
   index = ['x', 'y', 'z']
   # 从标量值创建 Series
   series_from_scalar = pd.Series(scalar_value, index=index)
   print("从标量值创建的 Series：")
   print(series_from_scalar)
   

2. pd.DataFrame()：创建二维带标签的数据结构，可接受多种数据类型作为输入，如列表、字典、NumPy 数组等。

   从列表的列表创建 DataFrame

   import pandas as pd
   
   # 创建一个列表的列表
   data_list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
   # 从列表的列表创建 DataFrame
   df_from_list_of_lists = pd.DataFrame(data_list_of_lists)
   print("从列表的列表创建的 DataFrame：")
   print(df_from_list_of_lists)
   

   从字典列表创建 DataFrame

   import pandas as pd
   
   # 创建一个字典列表
   data_dict_list = [{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}]
   # 从字典列表创建 DataFrame
   df_from_dict_list = pd.DataFrame(data_dict_list)
   print("从字典列表创建的 DataFrame：")
   print(df_from_dict_list)
   

   从字典创建 DataFrame

   import pandas as pd
   
   # 创建一个字典，键为列名，值为列表
   data_dict = {'col1': [1, 2, 3], 'col2': [4, 5, 6]}
   # 从字典创建 DataFrame
   df_from_dict = pd.DataFrame(data_dict)
   print("从字典创建的 DataFrame：")
   print(df_from_dict)
   

   从 Series 创建 DataFrame

   import pandas as pd
   
   # 创建一个 Series
   series = pd.Series([10, 20, 30], index=['a', 'b', 'c'])
   # 从 Series 创建 DataFrame
   df_from_series = pd.DataFrame(series, columns=['values'])
   print("从 Series 创建的 DataFrame：")
   print(df_from_series)
   

2. 数据读取与写入

用于从不同格式的文件中读取数据，以及将处理后的数据写入文件。

1. 读取函数
   • pd.read_csv()：从 CSV 文件中读取数据。

     import pandas as pd
     
     # 读取 CSV 文件
     file_path = 'example.csv'
     df = pd.read_csv(file_path)
     print("从 CSV 文件读取的数据：")
     print(df.to_csv(sep='\t', na_rep='nan'))
     

   • pd.read_excel()：从 Excel 文件中读取数据。

     import pandas as pd
     
     # 读取 Excel 文件
     file_path = 'example.xlsx'
     df = pd.read_excel(file_path)
     print("从 Excel 文件读取的数据：")
     print(df.to_csv(sep='\t', na_rep='nan'))
     

   • pd.read_json()：从 JSON 文件中读取数据。

     import pandas as pd
     
     # 读取 JSON 文件
     file_path = 'example.json'
     df = pd.read_json(file_path)
     print("从 JSON 文件读取的数据：")
     print(df.to_csv(sep='\t', na_rep='nan'))
     

   • pd.read_sql()：从 SQL 数据库中读取数据。

     import pandas as pd
     from sqlalchemy import create_engine
     
     # 创建数据库连接
     engine = create_engine('sqlite:///example.db')
     
     # 从数据库中读取数据
     query = 'SELECT * FROM table_name'
     df = pd.read_sql(query, engine)
     print("从 SQL 数据库读取的数据：")
     print(df.to_csv(sep='\t', na_rep='nan'))
     

• 写入函数
  • df.to_csv()：将 DataFrame 保存为 CSV 文件。

    import pandas as pd
    
    # 创建一个示例 DataFrame
    data = {
        'Name': ['Alice', 'Bob', 'Charlie'],
        'Age': [25, 30, 35],
        'Score': [85, 90, 78]
    }
    df = pd.DataFrame(data)
    
    # 将 DataFrame 写入 CSV 文件
    output_file = 'output.csv'
    df.to_csv(output_file, index=False)
    

  • df.to_excel()：将 DataFrame 保存为 Excel 文件。

    import pandas as pd
    
    # 创建一个示例 DataFrame
    data = {
        'Fruit': ['Apple', 'Banana', 'Cherry'],
        'Quantity': [10, 15, 20]
    }
    df = pd.DataFrame(data)
    
    # 将 DataFrame 写入 Excel 文件
    output_file = 'output.xlsx'
    df.to_excel(output_file, index=False)
    

  • df.to_json()：将 DataFrame 保存为 JSON 文件。

    import pandas as pd
    
    # 创建一个示例 DataFrame
    data = {
        'City': ['New York', 'Los Angeles', 'Chicago'],
        'Population': [8500000, 4000000, 2700000]
    }
    df = pd.DataFrame(data)
    
    # 将 DataFrame 写入 JSON 文件
    output_file = 'output.json'
    df.to_json(output_file, orient='records')
    

  • df.to_sql()：将 DataFrame 写入 SQL 数据库。

    import pandas as pd
    from sqlalchemy import create_engine
    
    # 创建一个示例 DataFrame
    data = {
        'Product': ['Laptop', 'Smartphone', 'Tablet'],
        'Price': [1000, 500, 300]
    }
    df = pd.DataFrame(data)
    
    # 创建数据库连接
    engine = create_engine('sqlite:///output.db')
    
    # 将 DataFrame 写入数据库
    table_name = 'products'
    df.to_sql(table_name, engine, index=False, if_exists='replace')
    

3. 数据查看与基本信息获取

帮助用户快速了解数据的基本情况和内容。

• df.head()：查看 DataFrame 的前几行。

  import pandas as pd
  
  data = {
      'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank'],
      'Age': [25, 30, 35, 40, 45, 50],
      'Score': [85, 90, 78, 92, 88, 75]
  }
  df = pd.DataFrame(data)
  
  # 查看前 5 行
  print("前 5 行数据：")
  print(df.head().to_csv(sep='\t', na_rep='nan'))
  
  # 查看前 3 行
  print("\n前 3 行数据：")
  print(df.head(3).to_csv(sep='\t', na_rep='nan'))
  

• df.tail()：查看 DataFrame 的后几行。

  import pandas as pd
  
  data = {
      'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank'],
      'Age': [25, 30, 35, 40, 45, 50],
      'Score': [85, 90, 78, 92, 88, 75]
  }
  df = pd.DataFrame(data)
  
  # 查看后 5 行
  print("后 5 行数据：")
  print(df.tail().to_csv(sep='\t', na_rep='nan'))
  
  # 查看后 2 行
  print("\n后 2 行数据：")
  print(df.tail(2).to_csv(sep='\t', na_rep='nan'))
  

• df.info()：显示 DataFrame 的基本信息，包括列名、数据类型、非空值数量等。

  import pandas as pd
  
  data = {
      'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank'],
      'Age': [25, 30, 35, 40, 45, 50],
      'Score': [85, 90, 78, 92, 88, 75]
  }
  df = pd.DataFrame(data)
  
  print("DataFrame 基本信息：")
  df.info()
  

• df.describe()：生成 DataFrame 的描述性统计信息，如均值、标准差、最小值、最大值等。

  import pandas as pd
  
  data = {
      'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank'],
      'Age': [25, 30, 35, 40, 45, 50],
      'Score': [85, 90, 78, 92, 88, 75]
  }
  df = pd.DataFrame(data)
  
  print("DataFrame 描述性统计信息：")
  print(df.describe().to_csv(sep='\t', na_rep='nan'))
  

• df.shape：返回 DataFrame 的行数和列数。

  import pandas as pd
  
  data = {
      'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank'],
      'Age': [25, 30, 35, 40, 45, 50],
      'Score': [85, 90, 78, 92, 88, 75]
  }
  df = pd.DataFrame(data)
  
  rows, columns = df.shape
  print(f"DataFrame 的行数：{rows}，列数：{columns}")
  

• df.columns：返回 DataFrame 的列名。

  import pandas as pd
  
  data = {
      'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank'],
      'Age': [25, 30, 35, 40, 45, 50],
      'Score': [85, 90, 78, 92, 88, 75]
  }
  df = pd.DataFrame(data)
  
  print("DataFrame 的列名：", df.columns)
  

• df.index：返回 DataFrame 的索引。

  import pandas as pd
  
  data = {
      'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank'],
      'Age': [25, 30, 35, 40, 45, 50],
      'Score': [85, 90, 78, 92, 88, 75]
  }
  df = pd.DataFrame(data)
  
  print("DataFrame 的索引：", df.index)
  

• df.dtypes：返回一个 Series，包含 DataFrame 每列的数据类型。

  import pandas as pd
  
  data = {
      'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank'],
      'Age': [25, 30, 35, 40, 45, 50],
      'Score': [85, 90, 78, 92, 88, 75]
  }
  df = pd.DataFrame(data)
  
  print("DataFrame 每列的数据类型：")
  print(df.dtypes)
  

4. 数据选择与过滤

用于从 DataFrame 或 Series 中选择特定的数据子集。

• 基于标签的选择

  • df.loc[]：通过标签选择行和列。

    import pandas as pd
    
    data = {
        'Name': ['Alice', 'Bob', 'Charlie', 'David'],
        'Age': [25, 30, 35, 40],
        'Score': [85, 90, 78, 92]
    }
    df = pd.DataFrame(data, index=['a', 'b', 'c', 'd'])
    
    # 选择单个值
    print("选择单个值：", df.loc['b', 'Age'])
    
    # 选择整行
    print("\n选择整行：")
    print(df.loc['c'].to_csv(sep='\t', na_rep='nan'))
    
    # 选择整列
    print("\n选择整列：")
    print(df.loc[:, 'Score'].to_csv(sep='\t', na_rep='nan'))
    
    # 选择一个区域
    print("\n选择一个区域：")
    print(df.loc['a':'c', 'Name':'Age'].to_csv(sep='\t', na_rep='nan'))
    

  • df.at[]：通过标签获取单个值。

    import pandas as pd
    
    data = {
        'Name': ['Alice', 'Bob', 'Charlie', 'David'],
        'Age': [25, 30, 35, 40],
        'Score': [85, 90, 78, 92]
    }
    df = pd.DataFrame(data, index=['a', 'b', 'c', 'd'])
    
    print("使用 at 获取单个值：", df.at['b', 'Score'])
    

• 基于位置的选择

  • df.iloc[]：通过整数位置选择行和列。

    import pandas as pd
    
    data = {
        'Name': ['Alice', 'Bob', 'Charlie', 'David'],
        'Age': [25, 30, 35, 40],
        'Score': [85, 90, 78, 92]
    }
    df = pd.DataFrame(data)
    
    # 选择单个值
    print("选择单个值：", df.iloc[1, 2])
    
    # 选择整行
    print("\n选择整行：")
    print(df.iloc[2].to_csv(sep='\t', na_rep='nan'))
    
    # 选择整列
    print("\n选择整列：")
    print(df.iloc[:, 1].to_csv(sep='\t', na_rep='nan'))
    
    # 选择一个区域
    print("\n选择一个区域：")
    print(df.iloc[0:2, 0:2].to_csv(sep='\t', na_rep='nan'))
    

  • df.iat[]：通过整数位置获取单个值。

    import pandas as pd
    
    data = {
        'Name': ['Alice', 'Bob', 'Charlie', 'David'],
        'Age': [25, 30, 35, 40],
        'Score': [85, 90, 78, 92]
    }
    df = pd.DataFrame(data)
    
    print("使用 iat 获取单个值：", df.iat[1, 0])
    

• 条件过滤

  • 使用布尔索引，如 df[df['column'] > value]，筛选满足特定条件的行。

    import pandas as pd
    
    data = {
        'Name': ['Alice', 'Bob', 'Charlie', 'David'],
        'Age': [25, 30, 35, 40],
        'Score': [85, 90, 78, 92]
    }
    df = pd.DataFrame(data)
    
    # 筛选年龄大于 30 的行
    print("年龄大于 30 的行：")
    print(df[df['Age'] > 30].to_csv(sep='\t', na_rep='nan'))
    
    # 筛选分数在 80 到 90 之间的行
    print("\n分数在 80 到 90 之间的行：")
    print(df[(df['Score'] >= 80) & (df['Score'] <= 90)].to_csv(sep='\t', na_rep='nan'))
    

  • df.query()：使用字符串表达式进行条件筛选，语法更简洁易读。

    import pandas as pd
    
    data = {
        'Name': ['Alice', 'Bob', 'Charlie', 'David'],
        'Age': [25, 30, 35, 40],
        'Score': [85, 90, 78, 92]
    }
    df = pd.DataFrame(data)
    
    # 筛选年龄小于 35 且分数大于 80 的行
    print("年龄小于 35 且分数大于 80 的行：")
    print(df.query('Age < 35 and Score > 80').to_csv(sep='\t', na_rep='nan'))
    

5. 数据处理与清洗

处理数据中的缺失值、重复值、异常值等，以及进行数据类型转换。

• 缺失值处理

  • df.isnull()：判断数据中的缺失值。
  • df.notnull()：判断数据中的非缺失值。

    import pandas as pd
    import numpy as np
    
    data = {
        'Name': ['Alice', 'Bob', np.nan, 'David'],
        'Age': [25, np.nan, 35, 40],
        'Score': [85, 90, 78, np.nan]
    }
    df = pd.DataFrame(data)
    
    print("判断缺失值：")
    print(df.isnull().to_csv(sep='\t', na_rep='nan'))
    
    print("\n判断非缺失值：")
    print(df.notnull().to_csv(sep='\t', na_rep='nan'))
    

  • df.dropna()：删除包含缺失值的行或列。

    import pandas as pd
    import numpy as np
    
    data = {
        'Name': ['Alice', 'Bob', np.nan, 'David'],
        'Age': [25, np.nan, 35, 40],
        'Score': [85, 90, 78, np.nan]
    }
    df = pd.DataFrame(data)
    
    # 删除包含缺失值的行
    df_drop_rows = df.dropna()
    print("删除包含缺失值的行：")
    print(df_drop_rows.to_csv(sep='\t', na_rep='nan'))
    
    # 删除包含缺失值的列
    df_drop_cols = df.dropna(axis=1)
    print("\n删除包含缺失值的列：")
    print(df_drop_cols.to_csv(sep='\t', na_rep='nan'))
    

  • df.fillna()：填充缺失值。

    import pandas as pd
    import numpy as np
    
    data = {
        'Name': ['Alice', 'Bob', np.nan, 'David'],
        'Age': [25, np.nan, 35, 40],
        'Score': [85, 90, 78, np.nan]
    }
    df = pd.DataFrame(data)
    
    # 用 0 填充缺失值
    df_fill_zero = df.fillna(0)
    print("用 0 填充缺失值：")
    print(df_fill_zero.to_csv(sep='\t', na_rep='nan'))
    
    # 用不同的值填充不同列的缺失值
    fill_values = {'Name': 'Unknown', 'Age': df['Age'].mean(), 'Score': df['Score'].min()}
    df_fill_dict = df.fillna(fill_values)
    print("\n用不同的值填充不同列的缺失值：")
    print(df_fill_dict.to_csv(sep='\t', na_rep='nan'))
    
    # 向前填充
    df_fill_ffill = df.fillna(method='ffill')
    print("\n向前填充：")
    print(df_fill_ffill.to_csv(sep='\t', na_rep='nan'))
    

• 重复值处理

  • df.duplicated()：判断数据中的重复值。

    import pandas as pd
    
    data = {
        'Name': ['Alice', 'Bob', 'Alice', 'David'],
        'Age': [25, 30, 25, 40],
        'Score': [85, 90, 85, 92]
    }
    df = pd.DataFrame(data)
    
    print("判断重复行：")
    print(df.duplicated().to_csv(sep='\t', na_rep='nan'))
    

  • df.drop_duplicates()：删除重复的行。

    import pandas as pd
    
    data = {
        'Name': ['Alice', 'Bob', 'Alice', 'David'],
        'Age': [25, 30, 25, 40],
        'Score': [85, 90, 85, 92]
    }
    df = pd.DataFrame(data)
    
    # 删除重复行，保留第一个
    df_drop_duplicates_first = df.drop_duplicates()
    print("删除重复行，保留第一个：")
    print(df_drop_duplicates_first.to_csv(sep='\t', na_rep='nan'))
    
    # 根据 Name 列删除重复行，保留最后一个
    df_drop_duplicates_last = df.drop_duplicates(subset=['Name'], keep='last')
    print("\n根据 Name 列删除重复行，保留最后一个：")
    print(df_drop_duplicates_last.to_csv(sep='\t', na_rep='nan'))
    

• 数据类型转换

  • df.astype()：将列的数据类型转换为指定类型。

    import pandas as pd
    
    data = {
        'Age': [25, 30, 35, 40],
        'Score': [85.5, 90.0, 78.2, 92.1]
    }
    df = pd.DataFrame(data)
    
    # 将 Age 列转换为字符串类型
    df['Age'] = df['Age'].astype(str)
    print("将 Age 列转换为字符串类型：")
    print(df.dtypes)
    

  • pd.to_numeric()：将列转换为数值类型。

    import pandas as pd
    
    data = {
        'Score': ['85', '90', '78', '92']
    }
    df = pd.DataFrame(data)
    
    # 将 Score 列转换为数值类型
    df['Score'] = pd.to_numeric(df['Score'])
    print("将 Score 列转换为数值类型：")
    print(df.dtypes)
    

  • pd.to_datetime()：将列转换为日期时间类型。

    import pandas as pd
    
    data = {
        'Date': ['2023-01-01', '2023-02-01', '2023-03-01']
    }
    df = pd.DataFrame(data)
    
    # 将 Date 列转换为日期时间类型
    df['Date'] = pd.to_datetime(df['Date'])
    print("将 Date 列转换为日期时间类型：")
    print(df.dtypes)
    

• 数替换

  • df.replace()：替换数据中的特定值。可以使用单个值替换、字典映射替换或正则表达式替换。

    import pandas as pd
    
    data = {
        'Name': ['Alice', 'Bob', 'Charlie', 'David'],
        'Grade': ['A', 'B', 'C', 'A']
    }
    df = pd.DataFrame(data)
    
    # 用 D 替换 A
    df_replace_single = df.replace('A', 'D')
    print("用 D 替换 A：")
    print(df_replace_single.to_csv(sep='\t', na_rep='nan'))
    
    # 用字典映射替换
    replace_dict = {'A': 'Excellent', 'B': 'Good', 'C': 'Average'}
    df_replace_dict = df.replace(replace_dict)
    print("\n用字典映射替换：")
    print(df_replace_dict.to_csv(sep='\t', na_rep='nan'))
    

6. 数据排序与排名

对数据进行排序和排名操作。

• 排序

  • df.sort_values()：根据指定列的值对 DataFrame 进行排序。

    import pandas as pd
    
    data = {
        'Name': ['Alice', 'Bob', 'Charlie', 'David'],
        'Score': [85, 90, 78, 92]
    }
    df = pd.DataFrame(data)
    
    # 根据 Score 列升序排序
    df_sort_asc = df.sort_values(by='Score')
    print("根据 Score 列升序排序：")
    print(df_sort_asc.to_csv(sep='\t', na_rep='nan'))
    
    # 根据 Score 列降序排序
    df_sort_desc = df.sort_values(by='Score', ascending=False)
    print("\n根据 Score 列降序排序：")
    print(df_sort_desc.to_csv(sep='\t', na_rep='nan'))
    

  • df.sort_index()：根据索引对 DataFrame 进行排序。

    import pandas as pd
    
    data = {
        'Name': ['Alice', 'Bob', 'Charlie', 'David'],
        'Score': [85, 90, 78, 92]
    }
    df = pd.DataFrame(data, index=[3, 1, 4, 2])
    
    # 根据索引升序排序
    df_sort_index_asc = df.sort_index()
    print("根据索引升序排序：")
    print(df_sort_index_asc.to_csv(sep='\t', na_rep='nan'))
    
    # 根据索引降序排序
    df_sort_index_desc = df.sort_index(ascending=False)
    print("\n根据索引降序排序：")
    print(df_sort_index_desc.to_csv(sep='\t', na_rep='nan'))
    

• 排名

  • df.rank()：为数据中的每个元素分配排名。

    import pandas as pd
    
    # 创建示例 DataFrame
    data = {
        'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
        'Score': [85, 92, 78, 85, 92]
    }
    df = pd.DataFrame(data)
    
    # 按 Score 列排名，使用默认的 average 方法
    df['Rank_average'] = df['Score'].rank()
    print("按 Score 列排名，使用 average 方法：")
    print(df[['Name', 'Score', 'Rank_average']].to_csv(sep='\t', na_rep='nan'))
    
    # 按 Score 列排名，使用 min 方法
    df['Rank_min'] = df['Score'].rank(method='min')
    print("\n按 Score 列排名，使用 min 方法：")
    print(df[['Name', 'Score', 'Rank_min']].to_csv(sep='\t', na_rep='nan'))
    
    # 按 Score 列排名，使用 first 方法（根据出现顺序排名）
    df['Rank_first'] = df['Score'].rank(method='first')
    print("\n按 Score 列排名，使用 first 方法：")
    print(df[['Name', 'Score', 'Rank_first']].to_csv(sep='\t', na_rep='nan'))
    

7. 数据分组与聚合

将数据按照某个或多个列进行分组，并对每个组进行聚合操作。

• 分组

  • df.groupby()：根据指定列对 DataFrame 进行分组。

    import pandas as pd
    
    # 创建示例 DataFrame
    data = {
        'Category': ['A', 'B', 'A', 'B', 'A'],
        'Value': [10, 20, 15, 25, 30]
    }
    df = pd.DataFrame(data)
    
    # 按 Category 列进行分组
    grouped = df.groupby('Category')
    
    # 查看分组后的结果
    for category, group in grouped:
        print(f"Category: {category}")
        print(group)
        print()
    

• 聚合

  • grouped.agg()：对分组后的数据进行聚合操作，可同时使用多个聚合函数。

    import pandas as pd
    
    data = {
        'Category': ['A', 'B', 'A', 'B', 'A'],
        'Value': [10, 20, 15, 25, 30]
    }
    df = pd.DataFrame(data)
    
    # 同时应用多个聚合函数
    agg_result = df.groupby('Category')['Value'].agg(['sum', 'mean', 'min', 'max', 'count'])
    print("同时应用多个聚合函数的结果：")
    print(agg_result)
    
    # 使用字典为不同列指定不同的聚合函数
    data = {
        'Category': ['A', 'B', 'A', 'B', 'A'],
        'Value1': [10, 20, 15, 25, 30],
        'Value2': [5, 10, 15, 20, 25]
    }
    df = pd.DataFrame(data)
    agg_dict_result = df.groupby('Category').agg({'Value1': ['sum', 'mean'], 'Value2': ['min', 'max']})
    print("\n使用字典为不同列指定不同聚合函数的结果：")
    print(agg_dict_result)
    

  • 常见的聚合函数：sum()、mean()、min()、max()、count() 等。

import pandas as pd

data = {
    'Category': ['A', 'B', 'A', 'B', 'A'],
    'Value': [10, 20, 15, 25, 30]
}
df = pd.DataFrame(data)

# 按 Category 列分组并计算每组的总和
sum_result = df.groupby('Category')['Value'].sum()
print("每组的总和：")
print(sum_result)

# 按 Category 列分组并计算每组的平均值
mean_result = df.groupby('Category')['Value'].mean()
print("每组的平均值：")
print(mean_result)

# 按 Category 列分组并计算每组的最小值
min_result = df.groupby('Category')['Value'].min()
print("每组的最小值：")
print(min_result)

# 按 Category 列分组并计算每组的最大值
max_result = df.groupby('Category')['Value'].max()
print("\n每组的最大值：")
print(max_result)

# 按 Category 列分组并计算每组的元素数量
count_result = df.groupby('Category')['Value'].count()
print("每组的元素数量：")
print(count_result)

8. 数据合并与连接

将多个 DataFrame 或 Series 进行合并或连接。

• pd.concat()：沿着指定轴（行或列）将多个 DataFrame 或 Series 进行拼接。

  import pandas as pd
  
  # 创建示例 DataFrame
  df1 = pd.DataFrame({
      'A': ['A0', 'A1', 'A2', 'A3'],
      'B': ['B0', 'B1', 'B2', 'B3']
  })
  
  df2 = pd.DataFrame({
      'A': ['A4', 'A5', 'A6', 'A7'],
      'B': ['B4', 'B5', 'B6', 'B7']
  })
  
  # 沿行方向（axis=0）拼接
  result_axis0 = pd.concat([df1, df2], axis=0)
  print("沿行方向拼接的结果：")
  print(result_axis0)
  
  # 沿列方向（axis=1）拼接
  result_axis1 = pd.concat([df1, df2], axis=1)
  print("\n沿列方向拼接的结果：")
  print(result_axis1)
  

• df.merge()：根据一个或多个键将两个 DataFrame 进行连接，类似于 SQL 中的 JOIN 操作。

  import pandas as pd
  
  # 创建示例 DataFrame
  left = pd.DataFrame({
      'key': ['K0', 'K1', 'K2', 'K3'],
      'A': ['A0', 'A1', 'A2', 'A3'],
      'B': ['B0', 'B1', 'B2', 'B3']
  })
  
  right = pd.DataFrame({
      'key': ['K0', 'K1', 'K2', 'K3'],
      'C': ['C0', 'C1', 'C2', 'C3'],
      'D': ['D0', 'D1', 'D2', 'D3']
  })
  
  # 内连接（how='inner'），默认情况
  inner_result = pd.merge(left, right, on='key')
  print("内连接的结果：")
  print(inner_result)
  
  # 左连接（how='left'）
  left_result = pd.merge(left, right, on='key', how='left')
  print("\n左连接的结果：")
  print(left_result)
  
  # 右连接（how='right'）
  right_result = pd.merge(left, right, on='key', how='right')
  print("\n右连接的结果：")
  print(right_result)
  
  # 外连接（how='outer'）
  outer_result = pd.merge(left, right, on='key', how='outer')
  print("\n外连接的结果：")
  print(outer_result)
  

• df.join()：主要用于根据索引将多个 DataFrame 进行连接。

  import pandas as pd
  
  # 创建示例 DataFrame
  left = pd.DataFrame({
      'A': ['A0', 'A1', 'A2', 'A3'],
      'B': ['B0', 'B1', 'B2', 'B3']
  }, index=['K0', 'K1', 'K2', 'K3'])
  
  right = pd.DataFrame({
      'C': ['C0', 'C1', 'C2', 'C3'],
      'D': ['D0', 'D1', 'D2', 'D3']
  }, index=['K0', 'K1', 'K2', 'K3'])
  
  # 连接操作
  join_result = left.join(right)
  print("根据索引连接的结果：")
  print(join_result)
  

• pd.merge_ordered()：pd.merge_ordered() 用于按顺序合并两个 DataFrame，通常用于时间序列数据。

  import pandas as pd
  
  # 创建示例 DataFrame
  df1 = pd.DataFrame({
      'date': ['2023-01-01', '2023-01-03', '2023-01-05'],
      'value1': [10, 20, 30]
  })
  df1['date'] = pd.to_datetime(df1['date'])
  
  df2 = pd.DataFrame({
      'date': ['2023-01-02', '2023-01-04', '2023-01-06'],
      'value2': [15, 25, 35]
  })
  df2['date'] = pd.to_datetime(df2['date'])
  
  # 按顺序合并
  ordered_result = pd.merge_ordered(df1, df2, on='date')
  print("按顺序合并的结果：")
  print(ordered_result)
  

• pd.merge_asof()：pd.merge_asof() 用于根据最近匹配的键合并两个 DataFrame，常用于时间序列数据。

  import pandas as pd
  
  # 创建示例 DataFrame
  df1 = pd.DataFrame({
      'time': [pd.Timestamp('2023-01-01 09:00:00'), pd.Timestamp('2023-01-01 09:02:00'),
               pd.Timestamp('2023-01-01 09:05:00')],
      'value1': [10, 20, 30]
  })
  
  df2 = pd.DataFrame({
      'time': [pd.Timestamp('2023-01-01 09:01:00'), pd.Timestamp('2023-01-01 09:03:00'),
               pd.Timestamp('2023-01-01 09:04:00')],
      'value2': [15, 25, 35]
  })
  
  # 按最近匹配的时间合并
  asof_result = pd.merge_asof(df1, df2, on='time')
  print("按最近匹配的时间合并的结果：")
  print(asof_result)
  

9. 数据重塑与透视

改变数据的结构，以更方便地进行分析。

• df.pivot()：将长格式数据转换为宽格式数据。

  import pandas as pd
  
  # 创建示例 DataFrame
  data = {
      'Name': ['Alice', 'Alice', 'Bob', 'Bob'],
      'Subject': ['Math', 'English', 'Math', 'English'],
      'Score': [85, 90, 78, 82]
  }
  df = pd.DataFrame(data)
  
  # 使用 pivot 进行数据重塑
  pivot_df = df.pivot(index='Name', columns='Subject', values='Score')
  print("使用 pivot 重塑后的数据：")
  print(pivot_df)
  

• df.pivot_table()：创建数据透视表，可进行分组和聚合操作。

  import pandas as pd
  
  # 创建示例 DataFrame
  data = {
      'Name': ['Alice', 'Alice', 'Bob', 'Bob'],
      'Subject': ['Math', 'English', 'Math', 'English'],
      'Score': [85, 90, 78, 82]
  }
  df = pd.DataFrame(data)
  
  # 使用 pivot_table 创建数据透视表
  pivot_table_df = df.pivot_table(index='Name', columns='Subject', values='Score', aggfunc='sum')
  print("使用 pivot_table 创建的数据透视表：")
  print(pivot_table_df)
  

• df.melt()：将宽格式数据转换为长格式数据。

  import pandas as pd
  
  # 创建示例 DataFrame
  data = {
      'Name': ['Alice', 'Bob'],
      'Math': [85, 78],
      'English': [90, 82]
  }
  df = pd.DataFrame(data)
  
  # 使用 melt 进行数据重塑
  melted_df = df.melt(id_vars='Name', var_name='Subject', value_name='Score')
  print("使用 melt 重塑后的数据：")
  print(melted_df)
  

• df.stack()：将列索引转换为最内层的行索引，将数据从宽格式转换为长格式。

• df.unstack()：将最内层的行索引转换为列索引，将数据从长格式转换为宽格式。

  import pandas as pd
  
  # 创建示例 DataFrame
  data = {
      'Name': ['Alice', 'Bob'],
      'Math': [85, 78],
      'English': [90, 82]
  }
  df = pd.DataFrame(data)
  df = df.set_index('Name')
  
  # 使用 stack 进行数据重塑
  stacked_df = df.stack()
  print("使用 stack 重塑后的数据：")
  print(stacked_df)
  
  # 使用 unstack 进行逆操作
  unstacked_df = stacked_df.unstack()
  print("\n使用 unstack 逆操作后的数据：")
  print(unstacked_df)
  

• df.crosstab()：计算两个或多个分类变量的交叉表，可用于统计频数。

  import pandas as pd
  
  # 创建示例数据
  gender = ['Male', 'Female', 'Male', 'Female']
  department = ['IT', 'HR', 'IT', 'HR']
  
  # 使用 crosstab 计算交叉表
  cross_tab = pd.crosstab(gender, department)
  print("使用 crosstab 计算的交叉表：")
  print(cross_tab)
  

10. 数据可视化

虽然 Pandas 本身的可视化功能相对基础，但可以方便地调用 matplotlib 或 seaborn 进行数据可视化。

• df.plot()：绘制各种类型的图表，如折线图、柱状图、散点图等。

  import pandas as pd
  import matplotlib.pyplot as plt
  
  # 创建示例数据
  data = {
      'Year': [2015, 2016, 2017, 2018, 2019],
      'Sales': [100, 120, 150, 130, 160]
  }
  df = pd.DataFrame(data)
  
  # 设置 Year 列为索引
  df.set_index('Year', inplace=True)
  
  # 绘制折线图
  df.plot()
  plt.title('Sales Trend Over Years')
  plt.xlabel('Year')
  plt.ylabel('Sales')
  plt.show()
  

• df.hist()：绘制直方图。

  import pandas as pd
  import matplotlib.pyplot as plt
  
  # 创建示例数据
  data = {
      'Fruit': ['Apple', 'Banana', 'Orange', 'Grape'],
      'Quantity': [30, 25, 20, 15]
  }
  df = pd.DataFrame(data)
  
  # 设置 Fruit 列为索引
  df.set_index('Fruit', inplace=True)
  
  # 绘制垂直柱状图
  df.plot(kind='bar')
  plt.title('Fruit Quantity')
  plt.xlabel('Fruit')
  plt.ylabel('Quantity')
  plt.show()
  
  # 绘制水平柱状图
  df.plot(kind='barh')
  plt.title('Fruit Quantity')
  plt.xlabel('Quantity')
  plt.ylabel('Fruit')
  plt.show()
  
  # 绘制直方图
  df.plot(kind='hist', bins=20)
  plt.title('Histogram of Random Data')
  plt.xlabel('Value')
  plt.ylabel('Frequency')
  plt.show()
  
  # 绘制箱线图
  df.plot(kind='box')
  plt.title('Box Plot of Data')
  plt.ylabel('Value')
  plt.show()
  
  # 绘制散点图
  df.plot(kind='scatter', x='x', y='y')
  plt.title('Scatter Plot of Two Variables')
  plt.xlabel('x')
  plt.ylabel('y')
  plt.show()
  
  # 绘制饼图
  df['Percentage'].plot(kind='pie', autopct='%1.1f%%')
  plt.title('Pie Chart of Categories')
  plt.ylabel('')
  plt.show()
  

到这里关于 pandas 里面的常用函数就介绍的差不多了，如果还有想要了解的，也可以在评论区一起讨论，资源是 pandas 官方 Zipped HTML 文档，大家可以按自己需要自取，感谢阅读，再见！