Pandas库知识点总结（全）

最新推荐文章于 2025-03-20 23:23:56 发布

莫熠夜

最新推荐文章于 2025-03-20 23:23:56 发布

阅读量1k

点赞数 11

文章标签： pandas

本文链接：https://blog.youkuaiyun.com/qq_64301528/article/details/143307764

版权

Pandas库

基础

概述

- Pandas 是一个开源的第三方 Python 库，从 Numpy 和 Matplotlib 的基础上构建而来

- Pandas 名字衍生自术语 "panel data"（面板数据）和 "Python data analysis"（Python 数据分析）

- Pandas 已经成为 Python 数据分析的必备高级工具，它的目标是成为强大、灵活、可以支持任何编程语言的数据分析工具

- Pandas 是 Python 语言的一个扩展程序库，用于数据分析

- Pandas 是一个开放源码、BSD 许可的库，提供高性能、易于使用的数据结构和数据分析工具

- Pandas 一个强大的分析结构化数据的工具集，基础是 Numpy（提供高性能的矩阵运算）

- Pandas 可以从各种文件格式比如 CSV、JSON、SQL、Microsoft Excel 导入数据

- Pandas 可以对各种数据进行运算操作，比如归并、再成形、选择，还有数据清洗和数据加工特征

- Pandas 广泛应用在学术、金融、统计学等各个数据分析领域

- Pandas 的出现使得 Python 做数据分析的能力得到了大幅度提升，它主要实现了数据分析的五个重要环节：加载数据、整理数据、操作数据、构建数据模型、分析数据

安装

pip install pandas==1.1.5 -i https://pypi.tuna.tsinghua.edu.cn/simple/

内置数据结构

在 ndarray 数组（NumPy 中的数组）的基础上构建出了Series（一维数据结构）、DataFrame（二维数据结构）

- - - - Series 是带标签的一维数组，这里的标签可以理解为索引，但这个索引并不局限于整数，它也可以是字符类型，比如 a、b、c 等
      - DataFrame 是一种表格型数据结构，它既有行标签，又有列标签

Series

Pandas Series 类似表格中等一个列（column），类似于一维数组，可以保存任何数据类型 Series 由索引（index）和列组成

- - - - pandas.Series(data,index,dtype)
        data：一组数据（ndarray 类型） index：数据索引标签，如果不指定，默认从 0 开始 dtype：数据类型，默认会自己判断 copy：表示对 data 进行拷贝，默认为 False

创建 Series 对象的方式

- - - - import pandas as pd # Series 空对象 def one(): series_one = pd.Series(dtype='f8') print('空对象：\n', series_one)
      - 直接赋值创建Series 对象
        series_one = pd.Series([1,2,3,4,5], dtype='f8') print('Series对象：\n', series_one)
      - ndarray 创建 Series 对象
        array_one = np.array(['小明','小红','小紫']) index = np.arange(3) series_one = pd.Series(data=array_one, index=index)
      - 字典创建 Series 对象
        data = {"name":"陈蕾","gender":"男"} result = pd.Series(data=data)
      - 标量创建 Series 对象
        result = pd.Series(data=5,index=[1,2,3,4,5])

访问 Series 数据

- - - - result = pd.Series(data=data)

Series 常用属性

Series 常用方法

- - - - head() 和 tail()
        查看 Series 的某一部分数据，使用 head() 或者 tail() 方法。其中 head() 返回前 n 行数据，默认显示前 5 行数据，tail() 返回后 n 行数据，默认为后 5 行
      - isnull() 和 nonull()
        isnull() 和 nonull() 用于检测 Series、DataFrame 中的缺失值。所谓缺失值，顾名思义就是值不存在、丢失、缺少
        - isnull()：如果为值不存在或者缺失，则返回 True
        - notnull()：如果值不存在或者缺失，则返回 Fal

DataFrame

基本

- - - - DataFrame 一个表格型的数据结构，既有行标签（index），又有列标签（columns），它也被称异构数据表，所谓异构，指的是表格中每列的数据类型可以不同，比如可以是字符串、整型或者浮点型等。

- - - - - DataFrame 的每一列数据都可以看成一个 Series 结构，只不过，DataFrame 为这些行中每个数据值增加了一个列标签
      - - 同 Series 一样，DataFrame 自带行标签索引，默认为“隐式索引”即从 0 开始依次递增，行标签与 DataFrame 中的数据项一一对应当然你也可以用“显式索引”的方式来设置行标签

pd.DataFrame( data, index, columns, dtype, copy)

- - - - | data：一组数据（ndarray、series, map, lists, dict 等类型） index：索引值，或者可以称为行标签 coumns：列标签，默认为 RangeIndex （0, 1, 2, …, n） dtype：数据类型 copy：默认为 False，表示复制数据 data |

创建 DataFrame 对象

- - - - **创建 DataFrame 对象的方式：**
        - 列表
        - 字典
        - Series
        - Numpy ndarrays
        - 另一个 DataFrame
      - 创建 DataFrame 空对象
        result = pd.DataFrame()
      - 列表创建 DataFrame 对象
        data = ['小明','小红','小紫'] column = ['name'] result = pd.DataFrame(data=data,columns=column)
      - 列表嵌套列表创建 DataFrame 对象
        data = [['小米', 18], ['小红', 19], ['小紫', 20]] result = pd.DataFrame(data=data,columns=['name','age'])
      - 列表嵌套字典创建 DataFrame 对象
        data = [{'name': "张三", 'age': 18},{'name': "小红", 'gender': "男", 'age': 19}] result = pd.DataFrame(data=data)
      - 字典创建 DataFrame 对象
        data = {"name":['小米','小红','小紫'],"age":[18,19,20]} result = pd.DataFrame(data=data,dtype=float)
      - Series 创建 DataFrame 对象
        data = {'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
        'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
        result = pd.DataFrame(data=data)

列索引操作

- - - - DataFrame 可以使用列索（columns index）引来完成数据的选取、添加和删除操作
      - 选取数据
        dname['name']
      - 添加数据
        添加新列
        使用 df['列'] = 值，插入新的数据列： result['three'] = pd.Series(data=[11, 22, 33], index=['a', 'b', 'c'])
        添加新行
        df.loc['e'] = [17, 18, 19, 20]
        在指定的位置插入新列
        # 使用 insert 方法在位置 1 插入新列 'D' df.insert(1, 'D', [13, 14, 15, 16])
      - 修改数据
        result = pd.DataFrame(data=data) result['two'] = pd.Series(data=[1,2,3],index=['a','b','c'])
      - 删除数据
        通过drop方法删除 DataFrame 中的数据，默认情况下，drop() 不会修改原 DataFrame，而是返回一个新的 DataFrame。axis=1，删除列
        DataFrame.drop(labels=None, axis=0, index=None, columns=None, level=None, inplace=False, errors='raise')

行索引操作

- - - - loc 选取数据
        DataFrame.loc[row_indexer, column_indexer]
        - row_indexer：行标签或布尔数组。
        - column_indexer：列标签或布尔数组。
        不能通过索引位置获取
      - iloc 选取数据
        iloc 方法用于基于位置（integer-location based）的索引，即通过行和列的整数位置来选择数据。
        不能通过索引标签获取
        DataFrame.iloc[row_indexer, column_indexer]
        - row_indexer：行位置或布尔数组。
        - column_indexer：列位置或布尔数组。
      - 切片多行选取
        通过切片的方式进行多行数据的选取
        切片获取行和通过iloc方法获取行从结果上没有区别，切片是基于位置的切片操作，iloc是基于位置的索引操作。
      - 添加数据行
        append()方法 ##pandas1.4.0后已弃用
        append() 方法用于将一个 Series 或 DataFrame 追加到另一个 DataFrame 的末尾。#已弃用
        DataFrame.append(other, ignore_index=False, verify_integrity=False, sort=False) #已弃用
        other：
        - 类型：Series 或 DataFrame。
        - 描述：要追加的数据。
        ignore_index：
        - 类型：Series 或 DataFrame。
        - 描述：要追加的数据。
        verify_integrity：
        - 类型：布尔值，默认为 False。
        - 描述：如果为 True，则在创建具有重复索引的 DataFrame 时引发 ValueError。
        sort：
        - 类型：布尔值，默认为 False。
        - 描述：如果为 True，则在追加之前对列进行排序。
        loc方法添加新行
        data = { 'A': [1, 2, 3, 4], 'B': [5, 6, 7, 8], 'C': [9, 10, 11, 12] } df = pd.DataFrame(data, index=['a', 'b', 'c', 'd']) # 添加新行 'e' df.loc['e'] = [17, 18, 19, 20]
        **concat**
        pd.concat(objs, axis=0, join='outer', ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, sort=False, copy=True)
        objs: 要连接的 DataFrame 或 Series 对象的列表或字典。
        axis: 指定连接的轴，0 或 'index' 表示按行连接↓，1 或 'columns' 表示按列连接→。
        join: 指定连接方式，'outer' 表示并集（默认），'inner' 表示交集。
        ignore_index: 如果为 True，则忽略原始索引并生成新的索引。
        keys: 用于在连接结果中创建层次化索引。
        levels: 指定层次化索引的级别。
        names: 指定层次化索引的名称。
        verify_integrity: 如果为 True，则在连接时检查是否有重复索引。
        sort: 如果为 True，则在连接时对列进行排序。
        copy: 如果为 True，则复制数据。
      - 删除数据行
        您可以使用行索引标签，从 DataFrame 中删除某一行数据。如果索引标签存在重复，那么它们将被一起删除。使用的是 drop 函数
        dorp(),默认axis=0，删除行

常用属性和方法

- - - - head()tail()默认值为5

函数

常用的统计学函数

其他常用函数

重置索引

重置索引（reindex）可以更改原 DataFrame 的行标签或列标签，并使更改后的行、列标签与 DataFrame 中的数据逐一匹配。通过重置索引操作，您可以完成对现有数据的重新排序。如果重置的索引标签在原 DataFrame 中不存在，那么该标签对应的元素值将全部填充为 NaN

reindex

- - - - reindex() 方法用于重新索引 DataFrame 或 Series 对象。重新索引意味着根据新的索引标签重新排列数据，并填充缺失值。如果重置的索引标签在原 DataFrame 中不存在，那么该标签对应的元素值将全部填充为 NaN。
      - DataFrame.reindex(labels=None, index=None, columns=None, axis=None, method=None, copy=True, level=None, fill_value=np.nan, limit=None, tolerance=None)
        labels：
        - 类型：数组或列表，默认为 None。
        - 描述：新的索引标签。
        index：
        - 类型：数组或列表，默认为 None。
        - 描述：新的行索引标签。
        columns：
        - 类型：数组或列表，默认为 None。
        - 描述：新的列索引标签。
        axis：
        - 类型：整数或字符串，默认为 None。
        - 描述：指定重新索引的轴。0 或 'index' 表示行，1 或 'columns' 表示列。
        method：
        - 类型：字符串，默认为 None。
        - 描述：用于填充缺失值的方法。可选值包括 'ffill'（前向填充）、'bfill'（后向填充）等。
        copy：
        - 类型：布尔值，默认为 True。
        - 描述：是否返回新的 DataFrame 或 Series。
        level：
        - 类型：整数或级别名称，默认为 None。
        - 描述：用于多级索引（MultiIndex），指定要重新索引的级别。
        fill_value：
        - 类型：标量，默认为 np.nan。
        - 描述：用于填充缺失值的值。
        limit：
        - 类型：整数，默认为 None。
        - 描述：指定连续填充的最大数量。
        tolerance：
        - 类型：标量或字典，默认为 None。
        - 描述：指定重新索引时的容差。

reindex_like

- - - - reindex_like 方法用于将一个 DataFrame 或 Series 的索引重新排列，使其与另一个 DataFrame 或 Series 的索引相匹配。如果在重新索引的过程中，新的索引与原始索引不完全匹配，那么不匹配的位置将会被填充为 NaN 值。
        DataFrame.reindex_like(other, method=None, copy=True, limit=None, tolerance=None)
        1. other：
           - 类型：DataFrame 或 Series。
           - 描述：用于对齐索引和列的参考对象。
        2. method：
           - 类型：字符串，默认为 None。
           - 描述：用于填充缺失值的方法。可选值包括 'ffill'（前向填充）、'bfill'（后向填充）等。
        3. copy：
           - 类型：布尔值，默认为 True。
           - 描述：是否返回新的 DataFrame 或 Series。
        4. limit：
           - 类型：整数，默认为 None。
           - 描述：指定连续填充的最大数量。
        5. tolerance：
           - 类型：标量或字典，默认为 None。
           - 描述：指定重新索引时的容差。

遍历

Series遍历

- - - - 使用 items()
        import pandas as pd # 创建一个示例 Series series = pd.Series([1, 2, 3], index=['a', 'b', 'c']) for index, value in series.items(): print(f"Index: {index}, Value: {value}")
      - **使用 index 属性**
        import pandas as pd # 创建一个示例 Series series = pd.Series([1, 2, 3], index=['a', 'b', 'c']) # 遍历索引 for index in series.index: print(f"Index: {index}, Value: {series[index]}")
      - **使用 values 属性**
        import pandas as pd # 创建一个示例 Series series = pd.Series([1, 2, 3], index=['a', 'b', 'c']) # 遍历值 for value in series.values: print(f"Value: {value}")

DataFrame 遍历

- - - - 迭代器返回的是原数据的副本
      - **遍历行**
        iterrows() 方法用于遍历 DataFrame 的行，返回一个包含索引和行的迭代器。
        当处理大型数据集时，应尽量避免使用 iterrows()，因为它的性能相对较差。
        itertuples() 方法用于遍历 DataFrame 的行，返回一个包含行数据的命名元组。
        itertuples() 是遍历 DataFrame 的推荐方法，因为它在速度和内存使用上都更高效。
      - **遍历列**
        items() 方法用于遍历 DataFrame 的列，返回一个包含列名和列数据的迭代器。
      - **使用属性遍历**
        loc 和 iloc 方法可以用于按索引或位置遍历 DataFrame 的行和列。

排序

sort_index

- - - - sort_index 方法用于对 DataFrame 或 Series 的索引进行排序。
      - DataFrame.sort_index(axis=0, ascending=True, inplace=False) Series.sort_index(axis=0, ascending=True, inplace=False)
        - axis：指定要排序的轴。默认为 0，表示按行索引排序。如果设置为 1，将按列索引排序。
        - ascending：布尔值，指定是升序排序（True）还是降序排序（False）。
        - inplace：布尔值，指定是否在原地修改数据。如果为 True，则会修改原始数据；如果为 False，则返回一个新的排序后的对象。

sort_values

- - - - sort_values 方法用于根据一个或多个列的值对 DataFrame 进行排序。
      - DataFrame.sort_values(by, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last')
        - by：列的标签或列的标签列表。指定要排序的列。
        axis：指定沿着哪个轴排序。默认为 0，表示按列排序（行间排序）。如果设置为 1，将按行排序（列间排序）。
        - ascending：布尔值或布尔值列表，指定是升序排序（True）还是降序排序（False）。可以为每个列指定不同的排序方向。
        - inplace：布尔值，指定是否在原地修改数据。如果为 True，则会修改原始数据；如果为 False，则返回一个新的排序后的对象。
        - kind：排序算法。默认为 'quicksort'，也可以选择 'mergesort' 或 'heapsort'。
        - na_position：指定缺失值（NaN）的位置。可以是 'first' 或 'last'。

去重

drop_duplicates 方法用于删除 DataFrame 或 Series 中的重复行或元素。

drop_duplicates(by=None, subset=None, keep='first', inplace=False) Series.drop_duplicates(keep='first', inplace=False)

- - - - - **by**：用于标识重复项的列名或列名列表。如果未指定，则使用所有列。
      - - subset：与 by 类似，但用于指定列的子集。
      - - **keep**：指定如何处理重复项。可以是：
          - 'first'：保留第一个出现的重复项（默认值）。
          - 'last'：保留最后一个出现的重复项。
          - False：删除所有重复项。
      - - inplace：布尔值，指定是否在原地修改数据。如果为 True，则会修改原始数据；如果为 False，则返回一个新的删除重复项后的对象。
      - **案例

分组

groupby

- - - - groupby 方法用于对数据进行分组操作，这是数据分析中非常常见的一个步骤。通过 groupby，你可以将数据集按照某个列（或多个列）的值分组，然后对每个组应用聚合函数，比如求和、平均值、最大值等。
      - DataFrame.groupby(by, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, observed=False, **kwargs)
        - by：用于分组的列名或列名列表。
        - axis：指定沿着哪个轴进行分组。默认为 0，表示按行分组。
        - level：用于分组的 MultiIndex 的级别。
        - as_index：布尔值，指定分组后索引是否保留。如果为 True，则分组列将成为结果的索引；如果为 False，则返回一个列包含分组信息的 DataFrame。
        - sort：布尔值，指定在分组操作中是否对数据进行排序。默认为 True。
        - group_keys：布尔值，指定是否在结果中添加组键。
        - squeeze：布尔值，如果为 True，并且分组结果返回一个元素，则返回该元素而不是单列 DataFrame。
        - observed：布尔值，如果为 True，则只考虑数据中出现的标签。

filter

- - - - 通过 filter() 函数可以实现数据的筛选，该函数根据定义的条件过滤数据并返回一个新的数据集

合并

merge 函数用于将两个 DataFrame 对象根据一个或多个键进行合并，类似于 SQL 中的 JOIN 操作。这个方法非常适合用来基于某些共同字段将不同数据源的数据组合在一起，最后拼接成一个新的 DataFrame 数据表。

pandas.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)

- - - - - left：左侧的 DataFrame 对象。
      - - right：右侧的 DataFrame 对象。
      - - how
          ：合并方式，可以是 'inner'、'outer'、'left' 或 'right'。默认为 'inner'。
          - 'inner'：内连接，返回两个 DataFrame 共有的键。
          - 'outer'：外连接，返回两个 DataFrame 的所有键。
          - 'left'：左连接，返回左侧 DataFrame 的所有键，以及右侧 DataFrame 匹配的键。
          - 'right'：右连接，返回右侧 DataFrame 的所有键，以及左侧 DataFrame 匹配的键。
      - - on：用于连接的列名。如果未指定，则使用两个 DataFrame 中相同的列名。
      - - left_on 和 right_on：分别指定左侧和右侧 DataFrame 的连接列名。
      - - left_index 和 right_index：布尔值，指定是否使用索引作为连接键。
      - - sort：布尔值，指定是否在合并后对结果进行排序。
      - - suffixes：一个元组，指定当列名冲突时，右侧和左侧 DataFrame 的后缀。
      - - copy：布尔值，指定是否返回一个新的 DataFrame。如果为 False，则可能修改原始 DataFrame。
      - - indicator：布尔值，如果为 True，则在结果中添加一个名为 __merge 的列，指示每行是如何合并的。
      - - validate：验证合并是否符合特定的模式。

时间

datetime

- - - - datetime 模块提供了用于处理日期和时间的类。
      - from datetime import datetime dt = datetime(2024, 5, 19, 16, 45, 30)

Timestamp

- - - - Timestamp 是一个特殊的 datetime 类型，用于表示单个时间点。它是 pandas 时间序列功能的核心组件，提供了丰富的方法和属性来处理日期和时间数据。
        import pandas as pd # 从日期字符串创建 ts = pd.Timestamp('2024-05-19 16:45:00') print(ts) # 从时间戳创建 ts = pd.Timestamp(1652937700) # Unix 时间戳 print(ts)

日期解析

- - - - pd.to_datetime() 方法用于将字符串或其他格式的日期转换为 Pandas 的 Datetime 对象。
        import pandas as pd # 将字符串转换为 Datetime 对象 date_str = '2023-10-01' date_obj = pd.to_datetime(date_str) print(date_obj) # 获取当前时间 print('当前时间：') print(datetime.now())

date_range

- - - - date_range() 函数用于生成一个固定频率的日期时间索引（DatetimeIndex）。这个函数非常灵活，可以用于生成各种时间序列数据。
      - pandas.date_range(start=None, end=None, periods=None, freq=None, tz=None, normalize=False, name=None, closed=None, **kwargs)
        1. start：
           - 类型：字符串或日期时间对象，默认为 None。
           - 描述：起始日期时间。
        2. end：
           - 类型：字符串或日期时间对象，默认为 None。
           - 描述：结束日期时间。
        3. periods：
           - 类型：整数，默认为 None。
           - 描述：生成的日期时间索引的数量。
        4. freq：
           - 类型：字符串或日期偏移对象，默认为 None。
           - 描述：时间频率。常见的频率包括 'D'（天）、'H'（小时）、'T' 或 'min'（分钟）、'S'（秒）等。
        5. tz：
           - 类型：字符串或时区对象，默认为 None。
           - 描述：指定时区。
        6. normalize：
           - 类型：布尔值，默认为 False。
           - 描述：是否将时间归一化到午夜。
        7. name：
           - 类型：字符串，默认为 None。
           - 描述：生成的日期时间索引的名称。
        8. closed：
           - 类型：字符串，默认为 None。
           - 描述：指定区间是否包含起始或结束日期时间。可选值为 'left'、'right' 或 None。

时间差

- - - - Timedelta 是一个用于表示时间间隔的对象。它可以表示两个时间点之间的差异，或者表示某个时间段的长度。Timedelta 对象可以用于时间序列分析、日期运算等场景。
      - **创建 Timedelta**
        使用字符串表示
        import pandas as pd td1 = pd.Timedelta('1 days 2 hours 30 minutes') print(td1) # 输出: 1 days 02:30:00
        使用参数
        td2 = pd.Timedelta(days=1, hours=2, minutes=30) print(td2) # 输出: 1 days 02:30:00
        使用整数和单位
        td3 = pd.Timedelta(5, unit='days') # 5天 print(td3) # 输出: 5 days 00:00:00
        时间差加减
        import pandas as pd td1 = pd.Timedelta('1 days 2 hours 30 minutes') print(td1) # 输出: 1 days 02:30:00 ts = pd.Timestamp('2024-01-01') new_ts = ts + td1 print(new_ts) # 输出: 2024-01-02 02:30:00

时间日期格式化

- - - - strftime 用于将日期时间对象转换为指定格式的字符串，而 strptime 用于将字符串解析为日期时间对象。
        from datetime import datetime # 创建一个日期时间对象 date_obj = datetime(2023, 10, 1, 14, 30, 45) # 将日期时间对象转换为字符串 date_str = date_obj.strftime("%Y-%m-%d %H:%M:%S") print(f"Formatted date string: {date_str}") # 将字符串解析为日期时间对象 parsed_date_obj = datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S") print(f"Parsed datetime object: {parsed_date_obj}")
      - 时间日期符号：

随机抽样

DataFrame.sample(n=None, frac=None, replace=False, weights=None, random_state=None, axis=None)

- - - - - n：要抽取的行数
      - - frac：抽取的比例，比如 frac=0.5，代表抽取总体数据的50%
      - - replace：布尔值参数，表示是否以有放回抽样的方式进行选择，默认为 False，取出数据后不再放回
      - - weights：可选参数，代表每个样本的权重值，参数值是字符串或者数组
      - - random_state：可选参数，控制随机状态，默认为 None，表示随机数据不会重复；若为 1 表示会取得重复数据
      - - axis：示在哪个方向上抽取数据(axis=1 表示列/axis=0 表示行)

空值处理

检测空值

- - - - isnull()用于检测 DataFrame 或 Series 中的空值，返回一个布尔值的 DataFrame 或 Series。
      - notnull()用于检测 DataFrame 或 Series 中的非空值，返回一个布尔值的 DataFrame 或 Series。

填充空值

- - - - fillna() 方法用于填充 DataFrame 或 Series 中的空值

删除空值

- - - - dropna() 方法用于删除 DataFrame 或 Series 中的空值。

读取CSV文件

CSV（Comma-Separated Values，逗号分隔值，有时也称为字符分隔值，因为分隔字符也可以不是逗号），其文件以纯文本形式存储表格数据（数字和文本

CSV 是一种通用的、相对简单的文件格式，被用户、商业和科学广泛应用。

to_csv()

to_csv() 方法将 DataFrame 存储为 csv 文件

- - - - path：存储csv的路径，可以是相对路径，也可以是绝对路径
      - index：True表示将行索引存入csv文件，False表示不存行索引

import pandas as pd # 创建一个简单的 DataFrame data = { 'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35], 'City': ['New York', 'Los Angeles', 'Chicago'] } df = pd.DataFrame(data) # 将 DataFrame 导出为 CSV 文件 df.to_csv('output.csv', index=False)