登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 安全 ›[Python/数据分析] Pandas：数据分析库

[Python/数据分析] Pandas：数据分析库

阎怀慕 2025-5-31 23:38:27
序


  • 千行百业，自然语言处理、大模型、人工智能技术变革、数智化转型热潮进行得如火如荼，熟悉 Python 及其核心库————成为进入AI领域的基本能力。
  • 数据处理与分析方面的 numpy 和 pandas 库首当其冲。
概述：Pandas

Pandas 是什么？


  • Pandas 是 Python 语言的一个扩展程序库，用于数据分析。
  • Pandas 名字衍生自术语 "panel data"（面板数据）和 "ython data analysis"（Python 数据分析）。
  • Pandas 是一个开放源码、BSD 许可的库，提供高性能、易于使用的数据结构和数据分析工具。


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


  • Pandas诞生于2008年，它的开发者是Wes McKinney，一个量化金融分析工程师。
因为疲于应付繁杂的财务数据，Wes McKinney便自学Python，并开发了Pandas。大神就是这么任性，没有，就创造。
为什么叫作Pandas，其实这是“Python data analysis”的简写，同时也衍生自计量经济学术语“panel data”（面板数据）。
所以说，Pandas的诞生是为了分析金融财务数据，当然现在它已经应用在各个领域了。
Pandas 应用


  • Pandas 可以从各种文件格式比如 CSV、JSON、SQL、Microsoft Excel 导入数据。
  • Pandas 可以对各种数据进行运算操作，比如归并、再成形、选择，还有数据清洗和数据加工特征。
  • Pandas 广泛应用在学术、金融、统计学等各个数据分析领域。
Pandas 功能


  • Pandas 是数据分析的利器，它不仅提供了高效、灵活的数据结构，还能帮助你以极低的成本完成复杂的数据操作和分析任务。
Pandas 提供了丰富的功能，包括：

  • 数据清洗：处理缺失数据、重复数据等。
  • 数据转换：改变数据的形状、结构或格式。
  • 数据分析：进行统计分析、聚合、分组等。
  • 数据可视化：通过整合 Matplotlib 和 Seaborn 等库，可以进行数据可视化。
数据结构


  • Pandas 的主要数据结构是 Series （一维数据）与 DataFrame（二维数据）。


  • Series 是一种类似于一维数组的对象，它由一组数据（各种 Numpy 数据类型）以及一组与之相关的数据标签（即索引）组成。
  • DataFrame 是一个二维表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔型值）。
DataFrame 既有行索引也有列索引，它可以被看做由 Series 组成的字典（共同用一个索引）。


  • Pandas 是 Python 数据科学领域中不可或缺的工具之一，它的灵活性和强大的功能使得数据处理和分析变得更加简单和高效。
Series


  • Series： 类似于一维数组或列表，是由一组数据以及与之相关的数据标签（索引）构成。
Series 可以看作是 DataFrame 中的一列，也可以是单独存在的一维数据结构。
1.png

DataFrame


  • DataFrame： 类似于一个二维表格，它是 Pandas 中最重要的数据结构。
DataFrame 可以看作是由多个 Series 按列排列构成的表格，它既有行索引也有列索引。
因此可以方便地进行行列选择、过滤、合并等操作。
2.png

DataFrame 可视为由多个 Series 组成的数据结构：
3.png

下面这张图展示了两个 Series 对象相加得到一个 DataFrame 对象：
4.png


  • DataFrame 由 Index、Key、Value 组成：
5.png

Demo
  1. import pandas as pd
  3. # 创建两个Series对象
  4. series_apples = pd.Series([1, 3, 7, 4])
  5. series_bananas = pd.Series([2, 6, 3, 5, 6])
  7. # 将两个Series对象相加，得到DataFrame，并指定列名
  8. df = pd.DataFrame({ 'Apples': series_apples, 'Bananas': series_bananas })
  10. # 显示DataFrame
  11. print(df)
复制代码
out
  1.    Apples  Bananas
  2. 0     1.0        2
  3. 1     3.0        6
  4. 2     7.0        3
  5. 3     4.0        5
  6. 4     NaN        6
复制代码
第1个 pandas 示例
  1. import pandas as pd
  3. # 创建一个简单的 DataFrame
  4. data = {'Name': ['Google', 'Runoob', 'Taobao'], 'Age': [25, 30, 35]}
  5. df = pd.DataFrame(data)
  7. # 查看 DataFrame
  8. print(df)
复制代码
out
  1.      Name  Age
  2. 0  Google   25
  3. 1  Runoob   30
  4. 2  Taobao   35
复制代码
Pandas 特点

高效的数据结构：

  • Series：一维数据结构，类似于列表（List），但拥有更强的功能，支持索引。
  • DataFrame：二维数据结构，类似于表格或数据库中的数据表，行和列都具有标签（索引）。
数据清洗与预处理：

  • Pandas 提供了丰富的函数来处理缺失值、重复数据、数据类型转换、字符串操作等，帮助用户轻松清理和转换数据。
数据操作与分析：

  • 支持高效的数据选择、筛选、切片，按条件提取数据、合并、连接多个数据集、数据分组、汇总统计等操作。
  • 可以进行复杂的数据变换，如数据透视表、交叉表、时间序列分析等。
数据读取与导出：

  • 支持从各种格式的数据源读取数据，如 CSV、Excel、JSON、SQL 数据库等。
  • 也可以将处理后的数据导出为不同格式，如 CSV、Excel 等。
数据可视化：

  • 通过与 Matplotlib 和其他可视化工具的集成，Pandas 可以快速生成折线图、柱状图、散点图等常见图表。
时间序列分析：

  • 支持强大的时间序列处理功能，包括日期的解析、重采样、时区转换等。
性能与优化：

  • Pandas 优化了大规模数据处理，提供高效的向量化操作，避免了使用 Python 循环处理数据的低效。
  • 还支持一些内存优化技术，比如使用 category 类型处理重复的数据。
Pandas 应用


  • Pandas 在数据科学和数据分析领域中具有广泛的应用，其主要优势在于能够处理和分析结构化数据。
以下是 Pandas 的一些主要应用领域：


  • 金融领域：金融机构使用 Pandas 来处理和分析股票市场数据、财务数据、交易数据等。Pandas 的灵活性和高效性使得金融分析师能够快速进行数据清洗、统计分析、建模等工作。
  • 科学研究：科学研究领域经常涉及大量的实验数据、观测数据等，Pandas 提供了强大的工具来处理和分析这些数据，例如天文学、生物学、地球科学等领域。
  • 企业数据分析：各种企业和组织都需要对业务数据进行分析，以支持决策和战略规划。Pandas 提供了处理和分析企业数据的功能，包括销售数据、客户数据、运营数据等。
  • 社交媒体分析：社交媒体平台产生的海量数据需要进行分析来了解用户行为、趋势和情感倾向。Pandas 可以帮助分析师处理和分析社交媒体数据，进行用户行为分析、情感分析等。
  • 医疗保健：医疗保健领域需要处理和分析大量的医疗数据，包括患者数据、临床试验数据、医疗图像数据等。Pandas 提供了处理和分析这些数据的工具，支持医疗研究和临床决策。
  • 教育研究：教育领域可以利用 Pandas 来处理学生表现数据、教学评估数据、课程数据等，从而进行教育研究和改进教学质量。
  • 市场营销：市场营销专业人员可以使用 Pandas 分析市场数据、客户数据、广告数据等，以制定营销策略和优化市场活动效果。
Pandas 在许多领域中都是一种强大而灵活的工具，为数据科学家、分析师和工程师提供了处理和分析数据的便捷方式。
Pandas 安装


  • 安装 pandas 需要基础环境是 Python，Pandas 是一个基于 Python 的库，因此你需要先安装 Python，然后再通过 Python 的包管理工具 pip 安装 Pandas。
使用 pip 安装 pandas:
  1. pip install pandas
复制代码
安装成功后，我们就可以导入 pandas 包使用：
  1. import pandas
复制代码
查看版本
  1. >>> import pandas
  2. >>> pandas.__version__  # 查看版本
  3. '1.1.5'
复制代码
导入 pandas 一般使用别名 pd 来代替：
  1. import pandas as pd
复制代码
  1. >>> import pandas as pd
  2. >>> pd.__version__  # 查看版本
  3. '1.1.5'
复制代码

  • 一个简单的 pandas 实例：
  1. import pandas as pd
  3. mydataset = {
  4.   'sites': ["Google", "Runoob", "Wiki"],
  5.   'number': [1, 2, 3]
  6. }
  8. myvar = pd.DataFrame(mydataset)
  10. print(myvar)
复制代码
out
  1.     sites  number
  2. 0  Google       1
  3. 1  Runoob       2
  4. 2    Wiki       3
复制代码
Pandas 数据结构 - Series


  • Series 是 Pandas 中的一个核心数据结构，类似于一个一维的数组，具有数据和索引。
  • Series 可以存储任何数据类型（整数、浮点数、字符串等），并通过标签（索引）来访问元素。
  • Series 的数据结构是非常有用的，因为它可以处理各种数据类型，同时保持了高效的数据操作能力，比如可以通过标签来快速访问和操作数据。
Series 特点


  • 一维数组：Series 中的每个元素都有一个对应的索引值。
  • 索引： 每个数据元素都可以通过标签（索引）来访问，默认情况下索引是从 0 开始的整数，但你也可以自定义索引。
  • 数据类型： Series 可以容纳不同数据类型的元素，包括整数、浮点数、字符串、Python 对象等。
  • 大小不变性：Series 的大小在创建后是不变的，但可以通过某些操作（如 append 或 delete）来改变。
  • 操作：Series 支持各种操作，如数学运算、统计分析、字符串处理等。
  • 缺失数据：Series 可以包含缺失数据，Pandas 使用NaN（Not a Number）来表示缺失或无值。
  • 自动对齐：当对多个 Series 进行运算时，Pandas 会自动根据索引对齐数据，这使得数据处理更加高效。
CASE 创建Series 对象时，指定索引（Index）、名称（Name）以及值（Values）


  • 我们可以使用 Pandas 库来创建一个 Series 对象，并且可以为其指定索引（Index）、名称（Name）以及值（Values）：
6.png
  1. import pandas as pd
  3. # 创建一个Series对象，指定名称为'A'，值分别为1, 2, 3, 4
  4. # 默认索引为0, 1, 2, 3
  5. series = pd.Series([1, 2, 3, 4], name='A')
  7. # 显示Series对象
  8. print(series)
  10. # 如果你想要显式地设置索引，可以这样做：
  11. custom_index = [1, 2, 3, 4]  # 自定义索引
  12. series_with_index = pd.Series([1, 2, 3, 4], index=custom_index, name='A')
  14. # 显示带有自定义索引的Series对象
  15. print(series_with_index)
复制代码
out
  1. 0    1
  2. 1    2
  3. 2    3
  4. 3    4
  5. Name: A, dtype: int64
  7. 1    1
  8. 2    2
  9. 3    3
  10. 4    4
  11. Name: A, dtype: int64
复制代码
Series 是 Pandas 中的一种基本数据结构，类似于一维数组或列表，但具有标签（索引），使得数据在处理和分析时更具灵活性。
以下是关于 Pandas 中的 Series 的详细介绍。
创建 Series 对象


  • 可以使用 pd.Series() 构造函数创建一个 Series 对象，传递一个数据数组（可以是列表、NumPy 数组等）和一个可选的索引数组。
  1. pandas.Series(data=None, index=None, dtype=None, name=None, copy=False, fastpath=False)
复制代码

  • 参数说明：


  • data：Series 的数据部分，可以是列表、数组、字典、标量值等。如果不提供此参数，则创建一个空的 Series。
  • index：Series 的索引部分，用于对数据进行标记。可以是列表、数组、索引对象等。如果不提供此参数，则创建一个默认的整数索引。
  • dtype：指定 Series 的数据类型。可以是 NumPy 的数据类型，例如 np.int64、np.float64 等。如果不提供此参数，则根据数据自动推断数据类型。
  • name：Series 的名称，用于标识 Series 对象。如果提供了此参数，则创建的 Series 对象将具有指定的名称。
  • copy：是否复制数据。默认为 False，表示不复制数据。如果设置为 True，则复制输入的数据。
  • fastpath：是否启用快速路径。默认为 False。启用快速路径可能会在某些情况下提高性能。
demo
  1. import pandas as pd
  3. a = [1, 2, 3]
  5. myvar = pd.Series(a)
  6. print(myvar)
复制代码
out
7.png


  • 从上图可知: 如果没有指定索引，索引值就从 0 开始，我们可以根据索引值读取数据：
CASE 通过索引获取指定数组元素的值

demo 指定默认的索引，获取目标元素的值
  1. import pandas as pd
  3. a = [1, 2, 3]
  5. myvar = pd.Series(a)
  7. print(myvar[1]) # out: 2
复制代码
demo 可以指定索引值，如下实例：
  1. import pandas as pd
  3. a = ["Google", "Runoob", "Wiki"]
  5. myvar = pd.Series(a, index = ["x", "y", "z"])
  7. print(myvar)
复制代码
8.png

demo 根据索引值读取数据
  1. import pandas as pd
  3. a = ["Google", "Runoob", "Wiki"]
  5. myvar = pd.Series(a, index = ["x", "y", "z"])
  7. print(myvar["y"])
复制代码
out
  1. Runoob
复制代码
CASE 使用 key/value 对象来创建 Series 对象


  • 我们也可以使用 key/value 对象，类似字典来创建 Series：
  1. import pandas as pd
  3. sites = {1: "Google", 2: "Runoob", 3: "Wiki"}
  5. myvar = pd.Series(sites)
  7. print(myvar)
复制代码
out
``log
1    Google
2    Runoob
3      Wiki
dtype: object
  1. > 从上图可知，**字典的 key** 变成了**索引值**。> 如果我们只需要字典中的一部分数据，只需要指定需要数据的索引即可，如下实例：```pythonimport pandas as pd
  3. sites = {1: "Google", 2: "Runoob", 3: "Wiki"}
  5. myvar = pd.Series(sites)
  7. print(myvar)myvar2 = pd.Series(sites, index = [1, 2])print(myvar2)
复制代码
out
  1. 1    Google
  2. 2    Runoob
  3. 3      Wiki
  4. dtype: object
  6. 1    Google
  7. 2    Runoob
  8. dtype: object
复制代码
CASE 设置 Series 的名称
  1. import pandas as pd
  3. sites = {1: "Google", 2: "Runoob", 3: "Wiki"}
  5. myvar = pd.Series(sites, index = [1, 2], name="RUNOOB-Series-TEST" )
  7. print(myvar)
复制代码
out
  1. 1    Google
  2. 2    Runoob
  3. Name: RUNOOB-Series-TEST, dtype: object
复制代码
Series 方法

方法名称功能描述index获取 Series 的索引values获取 Series 的数据部分（返回 NumPy 数组）head(n)返回 Series 的前 n 行（默认为 5）tail(n)返回 Series 的后 n 行（默认为 5）dtype返回 Series 中数据的类型shape返回 Series 的形状（行数）describe()返回 Series 的统计描述（如均值、标准差、最小值等）isnull()返回一个布尔 Series，表示每个元素是否为 NaNnotnull()返回一个布尔 Series，表示每个元素是否不是 NaNunique()返回 Series 中的唯一值（去重）value_counts()返回 Series 中每个唯一值的出现次数map(func)将指定函数应用于 Series 中的每个元素apply(func)将指定函数应用于 Series 中的每个元素，常用于自定义操作astype(dtype)将 Series 转换为指定的类型sort_values()
sort_values(ascending=True, inplace=Flase)对 Series 中的元素进行排序（按值排序）
ascending：默认为True升序排列，为Flase降序排序
inplace：是否修改原始的Seriessort_index()对 Series 的索引进行排序dropna()删除 Series 中的缺失值（NaN）fillna(value)填充 Series 中的缺失值（NaN）replace(to_replace, value)替换 Series 中指定的值cumsum()返回 Series 的累计求和cumprod()返回 Series 的累计乘积shift(periods)将 Series 中的元素按指定的步数进行位移rank()返回 Series 中元素的排名corr(other)计算 Series 与另一个 Series 的相关性（皮尔逊相关系数）cov(other)计算 Series 与另一个 Series 的协方差to_list()将 Series 转换为 Python 列表to_frame()将 Series 转换为 DataFrameiloc[]通过位置索引来选择数据loc[]通过标签索引来选择数据CASE 查看基本信息 / map 函数运算 / 累计求和 / 查找缺失值 / 排序
  1. import pandas as pd
  3. # 创建 Series
  4. data = [1, 2, 3, 4, 5, 6]
  5. index = ['a', 'b', 'c', 'd', 'e', 'f']
  6. s = pd.Series(data, index=index)
  8. # 查看基本信息
  9. print("索引：", s.index)
  10. print("数据：", s.values)
  11. print("数据类型：", s.dtype)
  12. print("前两行数据：\n", s.head(2))
  14. # 使用 map 函数将每个元素加倍
  15. s_doubled = s.map(lambda x: x * 2)
  16. print("元素加倍后：\n", s_doubled)
  18. # 计算累计和
  19. cumsum_s = s.cumsum()
  20. print("累计求和：\n", cumsum_s)
  22. # 查找缺失值（这里没有缺失值，所以返回的全是 False）
  23. print("缺失值判断：\n", s.isnull())
  25. # 排序
  26. sorted_s = s.sort_values()
  27. # sorted_s = s.sort_values(ascending=True)
  28. print("排序后的 Series：\n", sorted_s)
复制代码
out
  1. 索引： Index(['a', 'b', 'c', 'd', 'e', 'f'], dtype='object')
  2. 数据： [1 2 3 4 5 6]
  3. 数据类型： int64
  4. 前两行数据：
  5. a    1
  6. b    2
  7. dtype: int64
  9. 元素加倍后：
  10. a     2
  11. b     4
  12. c     6
  13. d     8
  14. e    10
  15. f    12
  16. dtype: int64
  18. 累计求和：
  19. a     1
  20. b     3
  21. c     6
  22. d    10
  23. e    15
  24. f    21
  25. dtype: int64
  26. 缺失值判断： a    False
  27. b    False
  28. c    False
  29. d    False
  30. e    False
  31. f    False
  32. dtype: bool
  34. 排序后的 Series：
  35. a    1
  36. b    2
  37. c    3
  38. d    4
  39. e    5
  40. f    6
  41. dtype: int64
复制代码
更多 Series 说明

CASE 使用列表、字典或数组创建一个默认索引的 Series
  1. import numpy as np;
  2. import pandas as pd;
  4. # 使用列表创建 Series
  5. s = pd.Series([1, 2, 3, 4])
  6. print(s)
  8. # 使用 NumPy 数组创建 Series
  9. s = pd.Series(np.array([1, 2, 3, 4]))
  10. print(s)
  12. # 使用字典创建 Series
  13. s = pd.Series({'a': 1, 'b': 2, 'c': 3, 'd': 4})
  14. print(s)
复制代码
out
  1. 0    1
  2. 1    2
  3. 2    3
  4. 3    4
  5. dtype: int64
  7. 0    1
  8. 1    2
  9. 2    3
  10. 3    4
  11. dtype: int64
  13. a    1
  14. b    2
  15. c    3
  16. d    4
  17. dtype: int64
复制代码
CASE 基本操作
  1. # 指定索引创建 Series
  2. s = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
  4. # 获取值
  5. value = s[2]  # 获取索引为2的值
  6. print(s['a'])  # 返回索引标签 'a' 对应的元素
  8. # 获取多个值
  9. subset = s[1:4]  # 获取索引为1到3的值
  11. # 使用自定义索引
  12. value = s['b']  # 获取索引为'b'的值
  14. # 索引和值的对应关系
  15. for index, value in s.items():
  16.     print(f"Index: {index}, Value: {value}")
  19. # 使用切片语法来访问 Series 的一部分
  20. print(s['a':'c'])  # 返回索引标签 'a' 到 'c' 之间的元素
  21. print(s[:3])  # 返回前三个元素
  23. # 为特定的索引标签赋值
  24. s['a'] = 10  # 将索引标签 'a' 对应的元素修改为 10
  26. # 通过赋值给新的索引标签来添加元素
  27. s['e'] = 5  # 在 Series 中添加一个新的元素，索引标签为 'e'
  29. # 使用 del 删除指定索引标签的元素。
  30. del s['a']  # 删除索引标签 'a' 对应的元素
  32. # 使用 drop 方法删除一个或多个索引标签，并返回一个新的 Series。
  33. s_dropped = s.drop(['b'])  # 返回一个删除了索引标签 'b' 的新 Series
复制代码
CASE 基本运算
  1. # 算术运算
  2. result = series * 2  # 所有元素乘以2
  4. # 过滤
  5. filtered_series = series[series > 2]  # 选择大于2的元素
  7. # 数学函数
  8. import numpy as np
  9. result = np.sqrt(series)  # 对每个元素取平方根
复制代码
CASE 计算统计数据：使用 Series 的方法来计算描述性统计
  1. print(s.sum())  # 输出 Series 的总和
  2. print(s.mean())  # 输出 Series 的平均值
  3. print(s.max())  # 输出 Series 的最大值
  4. print(s.min())  # 输出 Series 的最小值
  5. print(s.std())  # 输出 Series 的标准差
复制代码
CASE 属性和方法
  1. # 获取索引
  2. index = s.index
  4. # 获取值数组
  5. values = s.values
  7. # 获取描述统计信息
  8. stats = s.describe()
  10. # 获取最大值和最小值的索引
  11. max_index = s.idxmax()
  12. min_index = s.idxmin()
  14. # 其他属性和方法
  15. print(s.dtype)   # 数据类型
  16. print(s.shape)   # 形状
  17. print(s.size)    # 元素个数
  18. print(s.head())  # 前几个元素，默认是前 5 个
  19. print(s.tail())  # 后几个元素，默认是后 5 个
  20. print(s.sum())   # 求和
  21. print(s.mean())  # 平均值
  22. print(s.std())   # 标准差
  23. print(s.min())   # 最小值
  24. print(s.max())   # 最大值
复制代码
CASE 使用布尔表达式：根据条件过滤 Series
  1. # 使用字典创建 Series
  2. s = pd.Series({'a': 1, 'b': 2, 'c': 3, 'd': 4})
  3. print(s)
  5. print("result:\n", s > 2)  # 返回一个布尔 Series，其中的元素值是否大于 2
复制代码
out
  1. result:
  2. a    False
  3. b    False
  4. c    True
  5. d    True
  6. dtype: bool
复制代码
CASE 查看数据类型：使用 dtype 属性查看 Series 的数据类型
  1. print(s.dtype)  # 输出 Series 的数据类型
复制代码
CASE 转换数据类型：使用 astype 方法将 Series 转换为另一种数据类型
  1. s = s.astype('float64')  # 将 Series 中的所有元素转换为 float64 类型
复制代码
注意事项


  • Series 中的数据是有序的。
  • 可以将 Series 视为带有索引的一维数组。
  • 索引可以是唯一的，但不是必须的。
  • 数据可以是标量、列表、NumPy 数组等。
Pandas 数据结构 - DataFrame


  • DataFrame 是 Pandas 中的另一个核心数据结构，类似于一个二维的表格或数据库中的数据表。
  • DataFrame 是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔型值）。
  • DataFrame 既有行索引也有列索引，它可以被看做由 Series 组成的字典（共同用一个索引）。
  • DataFrame 提供了各种功能来进行数据访问、筛选、分割、合并、重塑、聚合以及转换等操作。
  • DataFrame 是一个非常灵活且强大的数据结构，广泛用于数据分析、清洗、转换、可视化等任务。
9.png


DataFrame 特点


  • 二维结构： DataFrame 是一个二维表格，可以被看作是一个 Excel 电子表格或 SQL 表，具有行和列。可以将其视为多个 Series 对象组成的字典。
  • 列的数据类型： 不同的列可以包含不同的数据类型，例如整数、浮点数、字符串或 Python 对象等。
  • 索引：DataFrame 可以拥有行索引和列索引，类似于 Excel 中的行号和列标。
  • 大小可变：可以添加和删除列，类似于 Python 中的字典。
  • 自动对齐：在进行算术运算或数据对齐操作时，DataFrame 会自动对齐索引。
  • 处理缺失数据：DataFrame 可以包含缺失数据，Pandas 使用 NaN（Not a Number）来表示。
  • 数据操作：支持数据切片、索引、子集分割等操作。
  • 时间序列支持：DataFrame 对时间序列数据有特别的支持，可以轻松地进行时间数据的切片、索引和操作。
  • 丰富的数据访问功能：通过 .loc、.iloc 和 .query() 方法，可以灵活地访问和筛选数据。
  • 灵活的数据处理功能：包括数据合并、重塑、透视、分组和聚合等。
  • 数据可视化：虽然 DataFrame 本身不是可视化工具，但它可以与 Matplotlib 或 Seaborn 等可视化库结合使用，进行数据可视化。
  • 高效的数据输入输出：可以方便地读取和写入数据，支持多种格式，如 CSV、Excel、SQL 数据库和 HDF5 格式。
  • 描述性统计：提供了一系列方法来计算描述性统计数据，如 .describe()、.mean()、.sum() 等。
  • 灵活的数据对齐和集成：可以轻松地与其他 DataFrame 或 Series 对象进行合并、连接或更新操作。
  • 转换功能：可以对数据集中的值进行转换，例如使用 .apply() 方法应用自定义函数。
  • 滚动窗口和时间序列分析：支持对数据集进行滚动窗口统计和时间序列分析。
构造方法


  • DataFrame 构造方法：
  1. pandas.DataFrame(data=None, index=None, columns=None, dtype=None, copy=False)
复制代码

  • 参数说明：


  • data：DataFrame 的数据部分，可以是字典、二维数组、Series、DataFrame 或其他可转换为 DataFrame 的对象。如果不提供此参数，则创建一个空的 DataFrame。
  • index：DataFrame 的行索引，用于标识每行数据。可以是列表、数组、索引对象等。如果不提供此参数，则创建一个默认的整数索引。
  • columns：DataFrame 的列索引，用于标识每列数据。可以是列表、数组、索引对象等。如果不提供此参数，则创建一个默认的整数索引。
  • dtype：指定 DataFrame 的数据类型。可以是 NumPy 的数据类型，例如 np.int64、np.float64 等。如果不提供此参数，则根据数据自动推断数据类型。
  • copy：是否复制数据。默认为 False，表示不复制数据。如果设置为 True，则复制输入的数据。


  • Pandas DataFrame 是一个二维的数组结构，类似二维数组。
  • Demo
  1. import pandas as pd
  3. data = [['Google', 10], ['Runoob', 12], ['Wiki', 13]]
  5. # 创建DataFrame
  6. df = pd.DataFrame(data, columns=['Site', 'Age'])
  8. # 使用astype方法设置每列的数据类型
  9. df['Site'] = df['Site'].astype(str)
  10. df['Age'] = df['Age'].astype(float)
  12. print(df)
复制代码
也可以使用字典来创建：
  1. import pandas as pd
  3. data = {'Site':['Google', 'Runoob', 'Wiki'], 'Age':[10, 12, 13]}
  5. df = pd.DataFrame(data)
  7. print (df)
复制代码
out
  1.      Site  Age
  2. 0  Google   10
  3. 1  Runoob   12
  4. 2    Wiki   13
复制代码
以下实例使用 ndarrays 创建，ndarray 的长度必须相同


  • 如果传递了 index，则索引的长度应等于数组的长度。
如果没有传递索引，则默认情况下，索引将是range(n)，其中n是数组长度。


  • ndarrays 可以参考： NumPy Ndarray 对象
Demo - 使用 ndarrays 创建
  1. import numpy as np
  2. import pandas as pd
  4. # 创建一个包含网站和年龄的二维ndarray
  5. ndarray_data = np.array([
  6.     ['Google', 10],
  7.     ['Runoob', 12],
  8.     ['Wiki', 13]
  9. ])
  11. # 使用DataFrame构造函数创建数据帧
  12. df = pd.DataFrame(ndarray_data, columns=['Site', 'Age'])
  14. # 打印数据帧
  15. print(df)
复制代码
out
  1.      Site Age
  2. 0  Google  10
  3. 1  Runoob  12
  4. 2    Wiki  13
复制代码
从以上输出结果可以知道， DataFrame 数据类型一个表格，包含 rows（行） 和 columns（列）：
11.png

Demo - 使用字典创建
  1. import pandas as pd
  3. data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
  5. df = pd.DataFrame(data)
  7. print (df)
复制代码
out
  1.    a   b     c
  2. 0  1   2   NaN
  3. 1  5  10  20.0
复制代码
没有对应数据的部分为 NaN。
CASE 通过loc属性返回指定行的数据


  • Pandas 可以使用 loc 属性返回指定行的数据
  • 如果没有设置索引，第一行索引为 0，第二行索引为 1，以此类推：
  1. import pandas as pd
  3. data = {
  4.   "calories": [420, 380, 390],
  5.   "duration": [50, 40, 45]
  6. }
  8. # 数据载入到 DataFrame 对象
  9. df = pd.DataFrame(data)
  11. # 返回第一行
  12. print(df.loc[0])
  13. # 返回第二行
  14. print(df.loc[1])
复制代码
out
  1. calories    420
  2. duration     50
  3. Name: 0, dtype: int64
  4. calories    380
  5. duration     40
  6. Name: 1, dtype: int64
复制代码

  • 注意：返回结果其实就是一个 Pandas Series 数据。
也可以返回多行数据，使用 [[ ... ]] 格式，... 为各行的索引，以逗号隔开：
CASE 以字典创建DataFrame对象
  1. import pandas as pd
  3. data = {
  4.   "calories": [420, 380, 390],
  5.   "duration": [50, 40, 45]
  6. }
  8. # 数据载入到 DataFrame 对象
  9. df = pd.DataFrame(data)
  11. # 返回第一行
  12. print(df.loc[0])
  14. # 返回第一行和第二行
  15. print("\n", df.loc[[0, 1]])
复制代码
out
  1.    calories  duration
  2. 0       420        50
  4.     calories  duration
  5. 0       420        50
  6. 1       380        40
复制代码
注意：返回结果其实就是一个 Pandas DataFrame 数据。


  • 我们可以指定索引值
如下实例：
  1. import pandas as pd
  3. data = {
  4.   "calories": [420, 380, 390],
  5.   "duration": [50, 40, 45]
  6. }
  8. df = pd.DataFrame(data, index = ["day1", "day2", "day3"])
  10. print(df)
复制代码
out
  1.       calories  duration
  2. day1       420        50
  3. day2       380        40
  4. day3       390        45
复制代码
CASE 基于loc属性获取指定索引的元素数据


  • Pandas 可以使用 loc 属性返回指定索引对应到某一行：
  1. import pandas as pd
  3. data = {
  4.   "calories": [420, 380, 390],
  5.   "duration": [50, 40, 45]
  6. }
  8. df = pd.DataFrame(data, index = ["day1", "day2", "day3"])
  10. # 指定索引
  11. print(df.loc["day2"])
复制代码
out
  1. calories    380
  2. duration     40
  3. Name: day2, dtype: int64
复制代码
DataFrame 方法

方法清单

方法名称功能描述head(n)返回 DataFrame 的前 n 行数据（默认前 5 行）tail(n)返回 DataFrame 的后 n 行数据（默认后 5 行）info()显示 DataFrame 的简要信息，包括列名、数据类型、非空值数量等describe()返回 DataFrame 数值列的统计信息，如均值、标准差、最小值等shape返回 DataFrame 的行数和列数（行数, 列数）columns返回 DataFrame 的所有列名index返回 DataFrame 的行索引dtypes返回每一列的数值数据类型sort_values(by)
按照指定列排序sort_index()
sort_index(by=None, axis=0, level=None, ascending=True, inplace=False, kind='quicksort', na_position='last', sort_remaining=True)按行索引排序
by：按照某一列或几列数据进行排序，但是by参数貌似不建议使用
axis：0按照行名排序；1按照列名排序
level：默认None，否则按照给定的level顺序排列---貌似并不是，文档
ascending：默认True升序排列；False降序排列
inplace：默认False，否则排序之后的数据直接替换原来的数据框
kind：排序方法，{"quicksort", "mergesort", "heapsort"}, default 'quicksort'。
na_position：缺失值默认排在最后dropna()删除含有缺失值（NaN）的行或列fillna(value)用指定的值填充缺失值isnull()判断缺失值，返回一个布尔值 DataFramenotnull()判断非缺失值，返回一个布尔值 DataFrameloc[]按标签索引选择数据iloc[]按位置索引选择数据at[]访问 DataFrame 中单个元素（比 loc[] 更高效）iat[]访问 DataFrame 中单个元素（比 iloc[] 更高效）apply(func)对 DataFrame 或 Series 应用一个函数applymap(func)对 DataFrame 的每个元素应用函数（仅对 DataFrame）groupby(by)分组操作，用于按某一列分组进行汇总统计pivot_table()创建透视表merge()合并多个 DataFrame（类似 SQL 的 JOIN 操作）concat()按行或按列连接多个 DataFrameto_csv()将 DataFrame 导出为 CSV 文件to_excel()将 DataFrame 导出为 Excel 文件to_json()将 DataFrame 导出为 JSON 格式to_sql()将 DataFrame 导出为 SQL 数据库query()使用 SQL 风格的语法查询 DataFrameduplicated()返回布尔值 DataFrame，指示每行是否是重复的drop_duplicates()删除重复的行set_index()设置 DataFrame 的索引reset_index()重置 DataFrame 的索引transpose()转置 DataFrame（行列交换）使用示例
  1. import pandas as pd
  3. # 创建 DataFrame
  4. data = {
  5.     'Name': ['Alice', 'Bob', 'Charlie', 'David'],
  6.     'Age': [25, 30, 35, 40],
  7.     'City': ['New York', 'Los Angeles', 'Chicago', 'Houston']
  8. }
  9. df = pd.DataFrame(data)
  11. # 查看前两行数据
  12. print(df.head(2))
  14. # 查看 DataFrame 的基本信息
  15. print("info:\n", df.info())
  17. # 获取描述统计信息
  18. print("describe:\n", df.describe())
  20. # 按列排序 (列名=年龄，排序方式=降序)
  21. df_sorted = df.sort_values(by='Age', ascending=False)
  22. print("df_sorted:\n", df_sorted)
  24. # 选择指定列
  25. print("Name, Age:\n", df[['Name', 'Age']])
  27. # 按索引选择行
  28. print("df.iloc[1:3]:\n", df.iloc[1:3])  # 选择第二到第三行（按位置）
  30. # 按标签选择行
  31. print("df.loc[1:2]:\n", df.loc[1:2])  # 选择第二到第三行（按标签）
  33. # 计算分组统计（按城市分组，计算平均年龄）
  34. print("groupby:\n", df.groupby('City')['Age'].mean())
  36. # 处理缺失值（填充缺失值）
  37. df['Age'] = df['Age'].fillna(30)
  39. # 导出为 CSV 文件
  40. df.to_csv('output.csv', index=False)
复制代码
out
  1.     Name  Age         City
  2. 0  Alice   25     New York
  3. 1    Bob   30  Los Angeles
  4. <class 'pandas.core.frame.DataFrame'>
  5. RangeIndex: 4 entries, 0 to 3
  6. Data columns (total 3 columns):
  7. #   Column  Non-Null Count  Dtype
  8. ---  ------  --------------  -----
  9. 0   Name    4 non-null      object
  10. 1   Age     4 non-null      int64
  11. 2   City    4 non-null      object
  12. dtypes: int64(1), object(2)
  13. memory usage: 228.0+ bytes
  14. info:
  15. None
  16. describe:
  17.               Age
  18. count   4.000000
  19. mean   32.500000
  20. std     6.454972
  21. min    25.000000
  22. 25%    28.750000
  23. 50%    32.500000
  24. 75%    36.250000
  25. max    40.000000
  26. df_sorted:
  27.        Name  Age         City
  28. 3    David   40      Houston
  29. 2  Charlie   35      Chicago
  30. 1      Bob   30  Los Angeles
  31. 0    Alice   25     New York
  32. Name, Age:
  33.        Name  Age
  34. 0    Alice   25
  35. 1      Bob   30
  36. 2  Charlie   35
  37. 3    David   40
  38. df.iloc[1:3]:
  39.        Name  Age         City
  40. 1      Bob   30  Los Angeles
  41. 2  Charlie   35      Chicago
  42. df.loc[1:2]:
  43.        Name  Age         City
  44. 1      Bob   30  Los Angeles
  45. 2  Charlie   35      Chicago
  46. groupby:
  47. City
  48. Chicago        35.0
  49. Houston        40.0
  50. Los Angeles    30.0
  51. New York       25.0
  52. Name: Age, dtype: float64
复制代码
访问 DataFrame 元素 【推荐】

试验数据
  1. import pandas as pd
  2. import numpy as np
  4. # 生成DataFrame
  5. df= pd.DataFrame(np.arange(30).reshape((6,5)),
  6.                     columns=['A','B','C','D','E'])
  7. print(df)
  9. # 写入本地
  10. # df.to_excel("D:\\实验数据\\data.xls", sheet_name="data")
复制代码
out
  1.     A   B   C   D   E
  2. 0   0   1   2   3   4
  3. 1   5   6   7   8   9
  4. 2  10  11  12  13  14
  5. 3  15  16  17  18  19
  6. 4  20  21  22  23  24
  7. 5  25  26  27  28  29
复制代码
访问列


  • 访问列：使用列名作为属性或通过 .loc[]、.iloc[] 访问，也可以使用标签或位置索引。


  • loc：通过行、列的名称或标签来索引
  • iloc：通过行、列的索引位置来寻找数据
  1. # 通过列名访问
  2. print("column=A: `df['A']`\n", df['A'])
  4. ## 访问多个列
  5. # print("column=A,B: `df['A', 'B']`\n", df['A', 'B']) # 错误语法
  6. print("column=A,B: `df[['A', 'B']]`\n", df[['A', 'B']]) # 正确语法
  8. # 通过属性访问
  9. print("column=B: `df.B`\n", df.B)
  11. # 通过 .loc[] 访问列 by 列名
  12. print("column=A: `df.loc[:, 'A']`\n", df.loc[:, 'A'])
  14. # 通过 .iloc[] 访问列 by 列下标
  15. print("column=A: `df.iloc[:, 0]`\n", df.iloc[:, 0])  # 假设 'A' 是第一列
  17. # 访问单个元素
  18. print("`df['B'][0]`:",df['B'][0])
  19. print("`df.loc[ 0, "B"]`:", df.loc[ 0, "B"])
复制代码
out
  1. column=A: `df['A']`
  2. 0     0
  3. 1     5
  4. 2    10
  5. 3    15
  6. 4    20
  7. 5    25
  8. Name: A, dtype: int64
  10. column=A,B: `df[['A', 'B']]`
  11.      A   B
  12. 0   0   1
  13. 1   5   6
  14. 2  10  11
  15. 3  15  16
  16. 4  20  21
  17. 5  25  26
  19. column=B: `df.B`
  20. 0     1
  21. 1     6
  22. 2    11
  23. 3    16
  24. 4    21
  25. 5    26
  26. Name: B, dtype: int64
  27. column=A: `df.loc[:, 'A']`
  28. 0     0
  29. 1     5
  30. 2    10
  31. 3    15
  32. 4    20
  33. 5    25
  34. Name: A, dtype: int64
  36. column=A: `df.iloc[:, 0]`
  37. 0     0
  38. 1     5
  39. 2    10
  40. 3    15
  41. 4    20
  42. 5    25
  43. Name: A, dtype: int64
  45. `df['B'][0]`: 1
  46. `df.loc[ 0, "B"]`: 1
复制代码
访问行


  • 访问行：使用行的标签和 .loc[] 访问。
  1. # 通过 .loc[] 访问行 by 行索引名/标签 (可自定义，默认是数值)
  2. print("row=2: `df.loc[1]`\n", df.loc[1]) # 访问第2行 | df.loc[1] 等效于 df.loc[1, :]
  3. #print("row=2: `df.loc[1, :]`\n", df.loc[1, :])
  4. print("df.loc[1:2]:\n", df.loc[1:2])  # 选择第二到第三行（按标签）
  6. # 通过 .iloc[] 访问列 by 行下标(位置)
  7. print("row=2: `df.iloc[1]`\n", df.iloc[1])
  8. # print("row=2: `df.iloc[1, :]`\n", df.iloc[1, :]) # 访问第2行 | df.iloc[1] 等效于 df.iloc[1, :]
  9. print("df.iloc[1:3]:\n", df.iloc[1:3])  # 选择第二到第三行（按位置）
  11. # 访问单个元素
  12. print("`df.loc[ 0, "B"]`:", df.loc[ 0, "B"])
  13. print("`df['B'][0]`:",df['B'][0])
复制代码
out
  1. row=2: `df.loc[1]`
  2. A    5
  3. B    6
  4. C    7
  5. D    8
  6. E    9
  7. Name: 1, dtype: int64
  9. df.loc[1:2]:
  10.      A   B   C   D   E
  11. 1   5   6   7   8   9
  12. 2  10  11  12  13  14
  14. row=2: `df.iloc[1]`
  15. A    5
  16. B    6
  17. C    7
  18. D    8
  19. E    9
  20. Name: 1, dtype: int64
  22. df.iloc[1:3]:
  23.      A   B   C   D   E
  24. 1   5   6   7   8   9
  25. 2  10  11  12  13  14
  27. `df.loc[ 0, "B"]`: 1
  28. `df['B'][0]`: 1
复制代码
访问前n行/后n行
  1. df= pd.DataFrame(
  2.                 np.arange(30).reshape((6,5))
  3.                 , columns=['A','B','C','D','E']
  4.         );
  6. print(df);
  8. print( "前3行:\n", df.head(3) );
  9. print( "后3行:\n", df.tail(3) );
复制代码
out
  1.     A   B   C   D   E
  2. 0   0   1   2   3   4
  3. 1   5   6   7   8   9
  4. 2  10  11  12  13  14
  5. 3  15  16  17  18  19
  6. 4  20  21  22  23  24
  7. 5  25  26  27  28  29前3行:     A   B   C   D   E0   0   1   2   3   41   5   6   7   8   92  10  11  12  13  14后3行:     A   B   C   D   E3  15  16  17  18  194  20  21  22  23  245  25  26  27  28  29
复制代码
读取某行某列/单个元素
  1. # 访问单个元素
  2. print("`df.loc[ 0, "B"]`:", df.loc[ 0, "B"])
  3. print("`df['B'][0]`:",df['B'][0])
复制代码
out
  1. `df.loc[ 0, "B"]`: 1
  2. `df['B'][0]`: 1
复制代码
读取指定区域 & 根据条件读取
  1. # 读取第1行到第3行，第B列到第D列这个区域内的值
  2. print("\n`df.loc[ 1:3, "B":"D"]`\n", df.loc[ 1:3, "B":"D"])
  3. # 按index和columns进行切片操作 : 读取第2、3行(即 [1+1,3+1)，第3、4列(即: [2+1, 4+1) )
  4. print("`df.iloc[1:3, 2:4]`:\n", df.iloc[1:3, 2:4])
  6. # df.loc[ df.B > 6] 等价于 df[df.B > 6]
  7. print("`df.loc[ df.B > 6]`:\n", df.loc[ df.B > 6]) # 读取第B列中大于6的值
  9. # 切片操作 : 选择B，C，D，E四列区域内，B列大于6的值
  10. print("`df.loc[ df.B >6, ["B","C","D","E"]]`:\n", df.loc[ df.B > 6, ["B","C","D","E"]])
复制代码
out
  1. `df.loc[ 1:3, "B":"D"]`
  2.      B   C   D
  3. 1   6   7   8
  4. 2  11  12  13
  5. 3  16  17  18
  7. `df.iloc[1:3, 2:4]`:
  8.      C   D
  9. 1   7   8
  10. 2  12  13
  12. `df.loc[ df.B > 6]`:
  13.      A   B   C   D   E
  14. 2  10  11  12  13  14
  15. 3  15  16  17  18  19
  16. 4  20  21  22  23  24
  17. 5  25  26  27  28  29
  19. `df.loc[ df.B >6, ["B","C","D","E"]]`:
  20.      B   C   D   E
  21. 2  11  12  13  14
  22. 3  16  17  18  19
  23. 4  21  22  23  24
  24. 5  26  27  28  29
复制代码
排序

关键函数: sort_index / sort_values


  • sort_index
  1. dataFrameObject.sort_index(
  2.   by=None,
  3.   axis=0, level=None,
  4.   ascending=True,
  5.   inplace=False,
  6.   kind='quicksort',
  7.   na_position='last',
  8.   sort_remaining=True
  9. )
复制代码


  • by：按照某一列或几列数据进行排序，但是by参数貌似不建议使用
  • axis：0按照行名排序；1按照列名排序
  • level：默认None，否则按照给定的level顺序排列---貌似并不是，文档
  • ascending：默认True升序排列；False降序排列
  • inplace：默认False，否则排序之后的数据直接替换原来的数据框
  • kind：排序方法，{‘quicksort’, ‘mergesort’, ‘heapsort’}, default ‘quicksort’。
  • na_position：缺失值默认排在最后


  • sort_values
  1. dataFrameObjecy.sort_values(
  2.   by,
  3.   axis=0,
  4.   ascending=True,
  5.   inplace=False,
  6.   kind='quicksort',
  7.   na_position='last'
  8. )
复制代码


  • by：字符串或者List；如果axis=0，那么by="列名"；如果axis=1，那么by="行名"。
  • axis：{0 or ‘index’, 1 or ‘columns’}, default 0，默认按照列排序，即纵向排序；如果为1，则是横向排序。
  • ascending：布尔型，True则升序，如果by=['列名1','列名2']，则该参数可以是[True, False]，即第一字段升序，第二个降序。
  • inplace：布尔型，是否用排序后的数据框替换现有的数据框。
  • kind：排序方法，{‘quicksort’, ‘mergesort’, ‘heapsort’}, default ‘quicksort’。
  • na_position：{‘first’, ‘last’}, default ‘last’，默认缺失值排在最后面。
试验数据
  1. import numpy  as np
  2. import pandas as pd
  3. data = pd.DataFrame(
  4.     np.arange(9).reshape(3,3)
  5.     , index   = ["0","2","1"]
  6.     , columns = ["col_a","col_c","col_b"]
  7. )
复制代码
out
  1. data
  2.    col_a  col_c  col_b
  3. 0      0      1      2
  4. 2      3      4      5
  5. 1      6      7      8
复制代码
按【行索引】排序


  • 按行的索引升序进行排序，默认按行，升序
  1. data.sort_index()
  3.    col_a  col_c  col_b
  4. 0      0      1      2
  5. 1      6      7      8
  6. 2      3      4      5
复制代码

  • 按行的索引按降序进行排序
  1. data.sort_index(ascending=False)
  3.    col_a  col_c  col_b
  4. 2      3      4      5
  5. 1      6      7      8
  6. 0      0      1      2
复制代码
按【列索引】排序


  • 按列升序的索引进行排序
  1. # axis : 0按照行名排序；1按照列名排序
  2. print( data.sort_index(axis=1) )
  4. Out:
  5.    col_a  col_b  col_c
  6. 0      0      2      1
  7. 2      3      5      4
  8. 1      6      8      7
复制代码
按【指定列名的值】排序


  • 按指定列的值大小顺序进行排序
  1. print(data.sort_values(by="col_a"))
  2. # 等效于: print(data.sort_values(by="col_a", axis=0, ascending=True))
复制代码
out
  1.    col_a  col_c  col_b
  2. 0      0      1      2
  3. 2      3      4      5
  4. 1      6      7      8
复制代码

  • 按多列进行排序
  1. print( data.sort_values(by=['col_b','col_a']) )
复制代码
out
  1.    col_a  col_c  col_b
  2. 0      0      1      2
  3. 2      3      4      5
  4. 1      6      7      8
复制代码

  • 先按col_b列的值降序，再按col_a列的值升序排序
  1. print( data.sort_values(by=['col_b','col_a'], axis=0,ascending=[False,True]) )
复制代码
out
  1.    col_a  col_c  col_b
  2. 1      6      7      8
  3. 2      3      4      5
  4. 0      0      1      2
复制代码
按【行名的值】排序


  • 按【指定行名的值】排序
  1. print( data.sort_values(by='2',axis=1)  ) # 第 2 +1 行
复制代码
out
  1.    col_a  col_c  col_b
  2. 0      0      1      2
  3. 2      3      4      5
  4. 1      6      7      8
复制代码

  • 按 2 行的值 降序，0行的值升序排列
  1. print( data.sort_values(by=['2','0'],axis=1, ascending=[False,True])  )
复制代码
out
  1.    col_b  col_c  col_a
  2. 0      2      1      0
  3. 2      5      4      3
  4. 1      8      7      6
复制代码
更多 DataFrame 说明

创建 DataFrame

CASE 从字典创建 DataFrame


  • 从字典创建：字典的键成为列名，值成为列数据。
  1. import pandas as pd
  3. # 通过字典创建 DataFrame
  4. df = pd.DataFrame({'Column1': [1, 2, 3], 'Column2': [4, 5, 6]})
复制代码
CASE 从二维数组创建


  • 从二维数组创建：外层列表代表行，内层列表代表列。
  1. df = pd.DataFrame(
  2.     [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
  3.     columns=['Column1', 'Column2', 'Column3']
  4. )
复制代码
CASE 从 NumPy 数组创建 DataFrame


  • 从 NumPy 数组创建：提供一个二维 NumPy 数组。
  1. import numpy as np
  3. # 通过 NumPy 数组创建 DataFrame
  4. df = pd.DataFrame(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
复制代码
CASE 从 Series 创建 DataFrame


  • 从 Series 创建 DataFrame：通过 pd.Series() 创建。
  1. # 从 Series 创建 DataFrame
  2. s1 = pd.Series(['Alice', 'Bob', 'Charlie'])
  3. s2 = pd.Series([25, 30, 35])
  4. s3 = pd.Series(['New York', 'Los Angeles', 'Chicago'])
  5. df = pd.DataFrame({'Name': s1, 'Age': s2, 'City': s3})
复制代码
DataFrame 的属性和方法


  • DataFrame 对象有许多属性和方法，用于数据操作、索引和处理，例如：shape、columns、index、head()、tail()、info()、describe()、mean()、sum() 等。
  1. # DataFrame 的属性和方法
  2. print(df.shape)     # 形状
  3. print(df.columns)   # 列名
  4. print(df.index)     # 索引
  5. print(df.head())    # 前几行数据，默认是前 5 行
  6. print(df.tail())    # 后几行数据，默认是后 5 行
  7. print(df.info())    # 数据信息
  8. print(df.describe())# 描述统计信息
  9. print(df.mean())    # 求平均值
  10. print(df.sum())     # 求和
复制代码
删除 DataFrame 元素

删除列：使用 drop 方法。
  1. df_dropped = df.drop('Column1', axis=1)
复制代码
删除行：同样使用 drop 方法。
  1. df_dropped = df.drop(0)  # 删除索引为 0 的行
复制代码
DataFrame 的统计分析

描述性统计：使用 .describe() 查看数值列的统计摘要。
  1. df.describe()
复制代码
计算统计数据：使用聚合函数如 .sum()、.mean()、.max() 等。
  1. df['Column1'].sum()
  2. df.mean()
复制代码
DataFrame 的索引操作

重置索引：使用 .reset_index()。
  1. df_reset = df.reset_index(drop=True)
复制代码
设置索引：使用 .set_index()。
  1. df_set = df.set_index('Column1')
复制代码
DataFrame 的布尔索引

使用布尔表达式：根据条件过滤 DataFrame。
  1. df[df['Column1'] > 2]
复制代码
DataFrame 的数据类型

查看数据类型：使用 dtypes 属性。
  1. df.dtypes
复制代码
转换数据类型：使用 astype 方法。
  1. df['Column1'] = df['Column1'].astype('float64')
复制代码
DataFrame 的合并与分割

合并：使用 concat 或 merge 方法。
  1. # 纵向合并
  2. pd.concat([df1, df2], ignore_index=True)
  4. # 横向合并
  5. pd.merge(df1, df2, on='Column1')
复制代码
分割：使用 pivot、melt 或自定义函数。
  1. # 长格式转宽格式
  2. df_pivot = df.pivot(index='Column1', columns='Column2', values='Column3')
  4. # 宽格式转长格式
  5. df_melt = df.melt(id_vars='Column1', value_vars=['Column2', 'Column3'])
复制代码
索引和切片


  • DataFrame 支持对行和列进行索引和切片操作。
实例 : 索引和切片
print(df[['Name', 'Age']]) # 提取多列
print(df[1:3])        # 切片行
print(df.loc[:, 'Name'])   # 提取单列
print(df.loc[1:2, ['Name', 'Age']]) # 标签索引提取指定行列
print(df.iloc[:, 1:])     # 位置索引提取指定列
注意事项


  • DataFrame 是一种灵活的数据结构，可以容纳不同数据类型的列。
  • 列名和行索引可以是字符串、整数等。
  • DataFrame 可以通过多种方式进行数据选择、过滤、修改和分析。
  • 通过对 DataFrame 的操作，可以进行数据清洗、转换、分析和可视化等工作。
Z FAQ for Pandas

Q: 使用基于 OpenPyXL 的 Pandas 读取 Excel 数据集?


  • Python = 3.12
  • Pandas = 2.2.3
内部依赖 openpyxl 组件


  • OpenPyXL = 3.1.5
  1. #!/usr/bin/python3
  2. ## #!/usr/bin/python
  3. # -*- coding: UTF-8 -*-
  5. import pandas as pd;
  7. """
  8. Excel 文件 转 Parquet 文件
  9. """
  12. # 从 Excel 文件，读取信号数据集合
  13. def readDataset(excelFilePath):
  14.     # 读取 Excel 文件
  15.     df = pd.read_excel(excelFilePath, sheet_name=None)
  16.     # 获取所有工作表的名称
  17.     sheet_names = df.keys()
  18.     # 将所有工作表的数据合并为一个 DataFrame
  19.     combined_df = pd.concat(df.values(), ignore_index=True)
  20.     return combined_df
  22. dataset = readDataset(excelFilePath="../dataset/signals.xlsx");
  23. print(dataset)
复制代码
Y 推荐文献


  • Pandas


  • https://pandas.pydata.org/
  • https://github.com/pandas-dev/pandas


  • [Python/数学] Numpy : 支持多维数组与矩阵运算的线性代数库 - 博客园/千千寰宇
  • [Python/Java] 数据科学与人工智能开源库 - 博客园/千千寰宇
  • [Excel/Python] OpenPyXl : Python 的 Excel 库 - 博客园/千千寰宇
X 参考文献


  • Pandas 教程 - 菜鸟教程
  • Pandas 数据结构 - Series - 菜鸟教程
  • Pandas读取某列、某行数据——loc、iloc用法总结 - CSDN
    本文作者：        千千寰宇   
    本文链接：         https://www.cnblogs.com/johnnyzen   
    关于博文：评论和私信会在第一时间回复，或直接私信我。   
    版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA     许可协议。转载请注明出处！
    日常交流：大数据与软件开发-QQ交流群: 774386015        【入群二维码】参见左下角。您的支持、鼓励是博主技术写作的重要动力！   

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
阎怀慕
2025-5-31 23:38:27

0

粉丝关注

21

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫