费曼学习法13 - 数据表格的魔法：Python Pandas DataFrame 详解 (Pandas 基础篇)-EW帮帮网

第二篇：数据表格的魔法：Python Pandas DataFrame 详解 (Pandas 基础篇)

开篇提问：

回忆一下，我们上一篇文章学习了 Pandas 的一维数据结构 Series，它可以看作是带 “标签” 的列表。但现实世界中的数据，往往更加 结构化、多维度。例如，一个 学生信息表，包含姓名、年龄、性别、班级、各科成绩等多列信息；一个 产品销售报表，包含产品名称、类别、销售地区、销售额、利润等多列数据。这些数据用 Excel 表格来表示非常直观和方便。

在 Pandas 中，处理这种 二维表格型数据 的 “魔法棒” 就是 DataFrame。 DataFrame 可以说是 Pandas 的 核心数据结构，也是进行数据分析的 主力工具。它就像一个 “万能的数据表格”，可以容纳各种类型的数据，并提供强大的功能来 查询、处理、分析 这些数据。今天，就让我们一起深入探索 Pandas DataFrame 的奥秘，掌握数据表格的魔法！

核心概念讲解 (费曼式解释):

Pandas DataFrame：二维 “数据表格” (Excel 的 Python 升级版)

Pandas DataFrame 是一个 二维的、表格型的数据结构。你可以把它想象成 Excel 表格 或 SQL 数据库中的表。 DataFrame 由 行和列 组成，每一列可以是不同的数据类型 (例如数值、字符串、布尔值等)。 DataFrame 非常适合 表示结构化数据，例如 CSV 文件、Excel 文件、数据库表格等。

DataFrame 的构成：行索引 (Index) + 列索引 (Columns) + 数据 (Values)

一个 Pandas DataFrame 对象由 三部分组成：
- 行索引 (Index): DataFrame 的 行标签，用于 唯一标识每一行数据。行索引类似于 Excel 表格中的行号，或者 SQL 表格中的主键。 DataFrame 的行索引可以是 整数、字符串、日期时间 等类型，默认情况下，Pandas 会自动创建从 0 开始的整数索引。
- 列索引 (Columns): DataFrame 的 列标签，用于 标识每一列数据，也就是列名。列索引通常是 字符串类型，DataFrame 通过列索引来访问和操作数据列。列索引 类似于 Excel 表格中的列头，或者 SQL 表格中的 字段名。
- 数据 (Values): DataFrame 中 存储的实际数据，是一个 二维的 NumPy 数组。 DataFrame 的数据 类似于 Excel 表格中的数据区域，或者 SQL 表格中的 数据行。
你可以把 Pandas DataFrame 想象成 带 “行标签” 和 “列标签” 的 NumPy 二维数组，或者 更强大的 Python 版 Excel 表格。 DataFrame 的 行索引和列索引 让数据 更结构化，更易于理解和操作。

DataFrame 与 Excel 表格的对比：

特性	Pandas DataFrame	Excel 表格
数据结构	二维表格型数据结构 (内存中的对象)	二维表格型数据 (文件或内存中的对象)
数据处理	Python 代码编程，高效、灵活、自动化	手动操作，点击拖拽，操作繁琐，自动化程度低
数据量	轻松处理 GB 甚至 TB 级别大数据	处理百万行级别数据开始缓慢卡顿
功能	强大的数据分析和处理功能，远超 Excel	基本的数据管理和简单分析功能，功能有限
可扩展性	Python 生态系统，可与各种库无缝集成，功能无限扩展	独立软件，功能扩展性有限
代码复用	Python 代码易于复用、版本控制和维护	手动操作步骤难以复用和版本控制
适用场景	各种复杂数据分析、数据科学、机器学习任务	简单数据管理、报表制作、少量数据分析

创建 Pandas DataFrame： pd.DataFrame()

可以使用 pd.DataFrame() 函数来 创建 Pandas DataFrame。 pd.DataFrame() 函数可以从 字典 (dict)、列表字典、NumPy 二维数组 (ndarray) 等多种数据类型创建 DataFrame。

从 Python 字典创建 DataFrame (字典的键作为列索引，值作为列数据):

import pandas as pd

# 从 Python 字典创建 DataFrame
data_dict = {
    'Name': ['Alice', 'Bob', 'Charlie', 'David'], # 姓名列数据 (列表)
    'Age': [25, 30, 28, 35], # 年龄列数据 (列表)
    'City': ['New York', 'London', 'Paris', 'Tokyo'] # 城市列数据 (列表)
} # 字典数据，键为列名，值为列数据列表
df1 = pd.DataFrame(data_dict) # 从字典创建 DataFrame，字典的键作为列索引
print("从字典创建的 DataFrame:\n", df1)
print("\nDataFrame 的列索引 (df1.columns):\n", df1.columns) # 列索引 (Index 对象，列名)
print("\nDataFrame 的行索引 (df1.index):\n", df1.index) # 默认 RangeIndex (整数索引)
print("\nDataFrame 的值 (df1.values):\n", df1.values) # 二维 NumPy 数组
print("\nDataFrame 的数据类型 (df1.dtypes):\n", df1.dtypes) # 每列的数据类型

从列表字典创建 DataFrame (列表中的每个字典作为一行数据):

import pandas as pd

# 从列表字典创建 DataFrame
data_list_dict = [
    {'Name': 'Alice', 'Age': 25, 'City': 'New York'}, # 字典表示第一行数据
    {'Name': 'Bob', 'Age': 30, 'City': 'London'}, # 字典表示第二行数据
    {'Name': 'Charlie', 'Age': 28, 'City': 'Paris'} # 字典表示第三行数据
] # 列表字典数据，每个字典代表一行数据，键为列名，值为单元格数据
df2 = pd.DataFrame(data_list_dict) # 从列表字典创建 DataFrame
print("\n从列表字典创建的 DataFrame:\n", df2)
print("\nDataFrame 的列索引 (df2.columns):\n", df2.columns) # 列索引 (Index 对象，列名)
print("\nDataFrame 的行索引 (df2.index):\n", df2.index) # 默认 RangeIndex (整数索引)
print("\nDataFrame 的值 (df2.values):\n", df2.values)
print("\nDataFrame 的数据类型 (df2.dtypes):\n", df2.dtypes)

从 NumPy 二维数组创建 DataFrame (需要指定列索引):

import pandas as pd
import numpy as np

# 从 NumPy 二维数组创建 DataFrame
data_numpy_2d = np.array([
    ['Alice', 25, 'New York'], # NumPy 数组表示数据行
    ['Bob', 30, 'London'],
    ['Charlie', 28, 'Paris']
]) # NumPy 二维数组数据
column_names = ['Name', 'Age', 'City'] # 列名列表 (作为列索引)
df3 = pd.DataFrame(data_numpy_2d, columns=column_names) # 从 NumPy 数组创建 DataFrame，指定列索引
print("\n从 NumPy 二维数组创建的 DataFrame:\n", df3)
print("\nDataFrame 的列索引 (df3.columns):\n", df3.columns) # 列索引 (Index 对象，列名)
print("\nDataFrame 的行索引 (df3.index):\n", df3.index) # 默认 RangeIndex (整数索引)
print("\nDataFrame 的值 (df3.values):\n", df3.values)
print("\nDataFrame 的数据类型 (df3.dtypes):\n", df3.dtypes) # 注意： 从 NumPy 数组创建的 DataFrame，如果数据类型不一致，可能会被转换为 object 类型

代码解释：

pd.DataFrame(data=None, index=None, columns=None, dtype=None, copy=False): pd.DataFrame() 函数的主要参数：
- data: 数据源，可以是字典、列表字典、NumPy 二维数组、Series 等。如果 data 为字典，则字典的键会作为 DataFrame 的列索引，字典的值 (列表或 Series) 会作为 DataFrame 的列数据。如果 data 为列表字典，则列表中的每个字典会作为 DataFrame 的一行数据，字典的键会作为列索引，字典的值会作为单元格数据。如果 data 为 NumPy 二维数组，则需要使用 columns 参数指定列索引。
- index: 行索引，可以是列表、NumPy 数组、Index 对象。如果 不指定 index，Pandas 会自动创建默认的整数索引 (RangeIndex)。 行索引的长度必须与数据行数一致。
- columns: 列索引，可以是列表、NumPy 数组、Index 对象。如果不指定 columns，并且 data 是字典或列表字典，则列索引会自动从字典的键中提取。如果 data 是 NumPy 二维数组，则必须手动指定 columns，列索引的长度必须与数据列数一致。
- dtype: 数据类型，用于 指定 DataFrame 的数据类型。如果不指定，Pandas 会 自动推断数据类型。可以指定整个 DataFrame 的数据类型，或者 按列指定数据类型 (字典形式)。
- copy=False: 是否 复制数据，默认为 False (不复制，使用视图)。设置为 True 则复制数据。

DataFrame 的基本操作： “查看表格的 “概况””

创建 DataFrame 后，我们通常需要先 查看 DataFrame 的基本信息，了解数据的 整体结构、数据类型、缺失值情况 等，为后续的数据分析做好准备。 Pandas 提供了多种方法来查看 DataFrame 的 “概况”：

.info()：查看 DataFrame 的总体信息 (索引、列、数据类型、内存占用等)

.info() 方法可以 打印 DataFrame 的简洁摘要信息，包括 DataFrame 的索引类型、列名和数据类型、非空值数量、内存占用 等。 .info() 是 快速了解 DataFrame 结构和数据质量 的重要工具。

import pandas as pd

# 创建一个 DataFrame (示例数据)
data = {'col1': [1, 2, None, 4], 'col2': ['A', 'B', 'C', 'D'], 'col3': [True, False, True, False]}
df = pd.DataFrame(data)

# 使用 .info() 查看 DataFrame 信息
print("DataFrame 信息 (df.info()):")
df.info() # 打印 DataFrame 的信息摘要

.describe()：查看数值列的统计摘要 (计数、均值、标准差、最小值、四分位数、最大值)

.describe() 方法可以 生成 DataFrame 数值列的描述性统计信息摘要，包括 计数 (count)、均值 (mean)、标准差 (std)、最小值 (min)、四分位数 (25%, 50%, 75%)、最大值 (max) 等。 .describe() 可以 快速了解数值列的数据分布和统计特征。 默认情况下，.describe() 只统计数值列。可以通过 include='all' 参数来统计所有列 (包括非数值列)。

import pandas as pd

# 创建一个 DataFrame (示例数据)
data = {'col1': [1, 2, 3, 4, 5], 'col2': [10, 20, 30, 40, 50], 'col3': ['A', 'B', 'C', 'D', 'E']}
df = pd.DataFrame(data)

# 使用 .describe() 查看数值列的统计摘要
print("\n数值列的统计摘要 (df.describe()):\n", df.describe()) # 默认只统计数值列 (col1, col2)

# 统计所有列 (包括非数值列) 的摘要信息 (include='all')
print("\n所有列的统计摘要 (df.describe(include='all')):\n", df.describe(include='all')) #  include='all' 统计所有列，非数值列会显示 count, unique, top, freq 等统计信息

.head(n)：查看 DataFrame 的前 n 行 (默认前 5 行)

.head(n) 方法可以 返回 DataFrame 的前 n 行数据，用于 快速查看 DataFrame 的数据样例，了解数据的大致内容和格式。 默认显示前 5 行，可以自定义 n 的值来显示更多或更少的行数。

import pandas as pd

# 创建一个 DataFrame (示例数据，假设有很多行)
data = {'col1': range(1, 21), 'col2': range(10, 30)} # 创建 20 行数据
df = pd.DataFrame(data)

# 使用 .head() 查看 DataFrame 的前几行
print("\nDataFrame 的前 5 行 (df.head()):\n", df.head()) # 默认显示前 5 行

print("\nDataFrame 的前 10 行 (df.head(10)):\n", df.head(10)) # 显示前 10 行

.tail(n)：查看 DataFrame 的后 n 行 (默认后 5 行)

.tail(n) 方法可以 返回 DataFrame 的后 n 行数据，与 .head(n) 类似，用于 查看 DataFrame 尾部的数据样例。 默认显示后 5 行，可以自定义 n 的值。

import pandas as pd

# ... (使用上面的 df) ...

# 使用 .tail() 查看 DataFrame 的后几行
print("\nDataFrame 的后 5 行 (df.tail()):\n", df.tail()) # 默认显示后 5 行

print("\nDataFrame 的后 3 行 (df.tail(3)):\n", df.tail(3)) # 显示后 3 行

.sample(n)：随机抽样查看 DataFrame 的 n 行数据 (默认随机抽样 1 行)

.sample(n) 方法可以 从 DataFrame 中随机抽取 n 行数据，用于 随机查看 DataFrame 的数据样例，了解数据的随机分布情况。 默认随机抽样 1 行，可以自定义 n 的值来抽样更多行数。

import pandas as pd

# ... (使用上面的 df) ...

# 使用 .sample() 随机抽样查看 DataFrame 数据
print("\nDataFrame 随机抽样 1 行 (df.sample()):\n", df.sample()) # 默认随机抽样 1 行，每次运行结果可能不一样

print("\nDataFrame 随机抽样 5 行 (df.sample(5)):\n", df.sample(5)) # 随机抽样 5 行，每次运行结果可能不一样

.shape：查看 DataFrame 的形状 (行数和列数)

.shape 属性可以 返回 DataFrame 的形状，也就是 行数和列数，以 元组 (rows, columns) 形式返回。 .shape 属性可以 快速了解 DataFrame 的数据规模。
```
import pandas as pd

# ... (使用上面的 df) ...

# 使用 .shape 查看 DataFrame 的形状
print("\nDataFrame 的形状 (df.shape):\n", df.shape) # (20, 2)  表示 20 行 2 列
```

.dtypes：查看 DataFrame 每列的数据类型

.dtypes 属性可以 返回一个 Series，包含 DataFrame 每列的数据类型。 .dtypes 可以 快速了解 DataFrame 各列的数据类型，方便后续的数据处理和分析。

import pandas as pd

# ... (使用上面的 df) ...

# 使用 .dtypes 查看 DataFrame 每列的数据类型
print("\nDataFrame 每列的数据类型 (df.dtypes):\n", df.dtypes) # col1    int64, col2    int64, dtype: object (Series 类型)

.index：查看 DataFrame 的行索引

.index 属性可以 返回 DataFrame 的行索引对象。行索引用于 标识和访问 DataFrame 的行数据。

import pandas as pd

# ... (使用上面的 df) ...

# 使用 .index 查看 DataFrame 的行索引
print("\nDataFrame 的行索引 (df.index):\n", df.index) # RangeIndex(start=0, stop=20, step=1)

.columns：查看 DataFrame 的列索引 (列名)

.columns 属性可以 返回 DataFrame 的列索引对象。列索引用于 标识和访问 DataFrame 的列数据。

import pandas as pd

# ... (使用上面的 df) ...

# 使用 .columns 查看 DataFrame 的列索引 (列名)
print("\nDataFrame 的列索引 (df.columns):\n", df.columns) # Index(['col1', 'col2'], dtype='object')

.values：查看 DataFrame 的值 (NumPy 二维数组)

.values 属性可以 返回 DataFrame 的值，以 NumPy 二维数组形式返回。 .values 可以将 DataFrame 数据转换为 NumPy 数组，方便进行 NumPy 的数值计算和操作。

import pandas as pd

# ... (使用上面的 df) ...

# 使用 .values 查看 DataFrame 的值 (NumPy 二维数组)
print("\nDataFrame 的值 (df.values):\n", df.values) # 返回 NumPy 二维数组
print("\nDataFrame 的值的数据类型 (df.values.dtype):\n", df.values.dtype) # int64 (NumPy 数组的数据类型)

DataFrame 的数据选择： “精准定位，提取数据子集”

DataFrame 提供了灵活强大的数据选择方法，可以 根据列名、行索引、切片、条件表达式 等多种方式，精准地提取 DataFrame 中的数据子集。数据选择是 DataFrame 操作的 核心技能，也是进行数据分析的基础。

列选择 (Column Selection)： “选择你需要的列”

选择单列： df['列名'] 或 df.列名 (返回 Series)

可以使用 列名字符串 作为键，通过 字典式索引 df['列名'] 或 属性访问方式 df.列名 来 选择 DataFrame 的单列数据。 返回的是 Pandas Series 对象。 注意：属性访问方式 df.列名 只在列名符合 Python 变量命名规范时有效 (例如不包含空格、特殊字符等)。

import pandas as pd

# 创建一个 DataFrame (示例数据)
data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 28], 'City': ['New York', 'London', 'Paris']}
df = pd.DataFrame(data)
print("DataFrame:\n", df)

# 1. 使用字典式索引选择单列 ('Age' 列)
age_column_series_1 = df['Age'] # 选择 'Age' 列，返回 Series
print("\n选择 'Age' 列 (字典式索引 df['Age']):\n", age_column_series_1)
print("选择的列的数据类型:", type(age_column_series_1)) # <class 'pandas.core.series.Series'>

# 2. 使用属性访问方式选择单列 ('Name' 列)
name_column_series_2 = df.Name # 选择 'Name' 列，返回 Series (列名符合变量命名规范)
print("\n选择 'Name' 列 (属性访问方式 df.Name):\n", name_column_series_2)
print("选择的列的数据类型:", type(name_column_series_2)) # <class 'pandas.core.series.Series'>

选择多列： df[['列名1', '列名2', ...]] (返回 DataFrame)

可以使用 列名列表 作为键，通过 字典式索引 df[['列名1', '列名2', ...]] 来 选择 DataFrame 的多列数据。 返回的是 Pandas DataFrame 对象，包含选择的列。 注意：列名列表需要用 两层方括号 [[...]] 括起来，外层方括号表示索引操作，内层方括号表示列名列表。

import pandas as pd

# ... (使用上面的 df) ...

# 选择多列 (['Name', 'City'] 列)
subset_df_columns = df[['Name', 'City']] # 选择 'Name' 和 'City' 列，返回 DataFrame
print("\n选择多列 (['Name', 'City'] 列，df[['Name', 'City']]):\n", subset_df_columns)
print("选择的多列的数据类型:", type(subset_df_columns)) # <class 'pandas.core.frame.DataFrame'>

行选择 (Row Selection)： “选择你需要的行”

DataFrame 的行选择主要使用 基于标签的 .loc[] 和 基于位置的 .iloc[] 两种索引器，以及切片和 条件表达式 等方法。

基于标签的行选择： .loc[] (根据行索引标签选择)

.loc[] 索引器 基于行索引标签 进行行选择。可以使用 单个标签、标签列表、标签切片 等方式来选择行。 .loc[] 是 “label-based” 的，包含结束标签。

import pandas as pd

# 创建一个 DataFrame，自定义行索引 (标签)
data = {'col1': [1, 2, 3], 'col2': ['A', 'B', 'C']}
index_labels = ['row1', 'row2', 'row3'] # 自定义行索引标签
df = pd.DataFrame(data, index=index_labels)
print("DataFrame (自定义行索引):\n", df)

# 1. 选择单行 (根据行索引标签 'row2')
row_series_loc_single = df.loc['row2'] # 选择行索引为 'row2' 的行，返回 Series
print("\n选择单行 (df.loc['row2']):\n", row_series_loc_single)
print("选择的行的数据类型:", type(row_series_loc_single)) # <class 'pandas.core.series.Series'>

# 2. 选择多行 (根据行索引标签列表 ['row1', 'row3'])
subset_df_loc_list = df.loc[['row1', 'row3']] # 选择行索引为 ['row1', 'row3'] 的多行，返回 DataFrame
print("\n选择多行 (df.loc[['row1', 'row3']]):\n", subset_df_loc_list)
print("选择的多行的数据类型:", type(subset_df_loc_list)) # <class 'pandas.core.frame.DataFrame'>

# 3. 选择连续多行 (根据行索引标签切片 'row1':'row3')
subset_df_loc_slice = df.loc['row1':'row3'] # 选择行索引标签为 'row1' 到 'row3' (包含 'row3') 的连续多行，返回 DataFrame
print("\n选择连续多行 (df.loc['row1':'row3']):\n", subset_df_loc_slice) # 注意： 标签切片是包含结束标签的！
print("选择的连续多行的数据类型:", type(subset_df_loc_slice)) # <class 'pandas.core.frame.DataFrame'>

基于位置的行选择： .iloc[] (根据行位置索引选择)

.iloc[] 索引器 基于行位置索引 (整数索引) 进行行选择。可以使用 整数索引、整数索引列表、整数索引切片 等方式来选择行。 .iloc[] 是 “integer-location based” 的，不包含结束位置。 .iloc[] 的用法与 NumPy 数组的整数索引和切片非常相似。

import pandas as pd

# ... (使用上面的 df，自定义行索引的 DataFrame) ...

# 1. 选择单行 (根据行位置索引 1，即第二行)
row_series_iloc_single = df.iloc[1] # 选择行位置索引为 1 的行 (第二行)，返回 Series
print("\n选择单行 (df.iloc[1]):\n", row_series_iloc_single)
print("选择的行的数据类型:", type(row_series_iloc_single)) # <class 'pandas.core.series.Series'>

# 2. 选择多行 (根据行位置索引列表 [0, 2]，即第一行和第三行)
subset_df_iloc_list = df.iloc[[0, 2]] # 选择行位置索引为 [0, 2] 的多行，返回 DataFrame
print("\n选择多行 (df.iloc[[0, 2]]):\n", subset_df_iloc_list)
print("选择的多行的数据类型:", type(subset_df_iloc_list)) # <class 'pandas.core.frame.DataFrame'>

# 3. 选择连续多行 (根据行位置索引切片 0:3，即前三行)
subset_df_iloc_slice = df.iloc[0:3] # 选择行位置索引为 0 到 3 (不包含 3) 的连续多行，返回 DataFrame
print("\n选择连续多行 (df.iloc[0:3]):\n", subset_df_iloc_slice) # 注意： 位置索引切片是不包含结束位置的！
print("选择的连续多行的数据类型:", type(subset_df_iloc_slice)) # <class 'pandas.core.frame.DataFrame'>

行切片 (Row Slicing)： “选择连续的行”

可以直接使用 切片语法 df[start:stop:step] 对 DataFrame 进行 行切片，根据行位置索引 (整数索引) 选择连续的行。 行切片与 .iloc[] 的整数索引切片类似，但不完全相同。行切片是 “position-based” 的，不包含结束位置。 注意：行切片不能使用行索引标签，只能使用行位置索引。

import pandas as pd

# ... (使用上面的 df，自定义行索引的 DataFrame) ...

# 使用行切片选择前两行 (位置索引 0:2)
subset_df_row_slice = df[0:2] # 选择行位置索引为 0 到 2 (不包含 2) 的前两行，返回 DataFrame
print("\n行切片选择前两行 (df[0:2]):\n", subset_df_row_slice) # 注意： 行切片是不包含结束位置的！
print("选择的行切片的数据类型:", type(subset_df_row_slice)) # <class 'pandas.core.frame.DataFrame'>

#  注意： 行切片不能使用行索引标签，会报错 KeyError
# subset_df_row_slice_label = df['row1':'row3'] # KeyError: 'row1:row3' # 错误！ 行切片不能使用标签切片！

行列同时选择 (Row and Column Selection)： “行列 “坐标” 定位”

可以 组合行选择和列选择，同时选择指定的行和列，提取 DataFrame 的 数据子集。常用的行列同时选择方法包括：

.loc[行索引, 列索引]：基于标签的行列选择

.loc[] 索引器可以 同时接收行索引和列索引，使用标签进行行列选择。行列索引都可以是 单个标签、标签列表、标签切片。

import pandas as pd

# ... (使用上面自定义行索引的 DataFrame df) ...

# 1. 选择指定行和指定列的单个单元格 (根据标签 'row2' 和 'col1')
cell_value_loc_single = df.loc['row2', 'col1'] # 选择行索引为 'row2'，列索引为 'col1' 的单元格值
print("\n选择单个单元格 (df.loc['row2', 'col1']):\n", cell_value_loc_single) # 3

# 2. 选择指定行和多列 (行标签 'row2'，列标签列表 ['col1', 'col2'])
row_series_loc_multi_cols = df.loc['row2', ['col1', 'col2']] # 选择行索引为 'row2'，列索引为 ['col1', 'col2'] 的数据，返回 Series
print("\n选择指定行和多列 (df.loc['row2', ['col1', 'col2']]):\n", row_series_loc_multi_cols)

# 3. 选择多行和指定列 (行标签列表 ['row1', 'row3']，列标签 'col2')
col_series_loc_multi_rows = df.loc[['row1', 'row3'], 'col2'] # 选择行索引为 ['row1', 'row3']，列索引为 'col2' 的数据，返回 Series
print("\n选择多行和指定列 (df.loc[['row1', 'row3'], 'col2']):\n", col_series_loc_multi_rows)

# 4. 选择多行和多列 (行标签切片 'row1':'row3'，列标签列表 ['col1', 'col2'])
subset_df_loc_multi_rows_cols = df.loc['row1':'row3', ['col1', 'col2']] # 选择行索引标签为 'row1' 到 'row3'，列索引为 ['col1', 'col2'] 的数据，返回 DataFrame
print("\n选择多行和多列 (df.loc['row1':'row3', ['col1', 'col2']]):\n", subset_df_loc_multi_rows_cols)

.iloc[行位置索引, 列位置索引]：基于位置的行列选择

.iloc[] 索引器可以 同时接收行位置索引和列位置索引，使用 整数索引 进行行列选择。行列位置索引都可以是 整数索引、整数索引列表、整数索引切片。

import pandas as pd

# ... (使用上面自定义行索引的 DataFrame df) ...

# 1. 选择指定行和指定列的单个单元格 (根据位置索引 [1, 0]，即第二行第一列)
cell_value_iloc_single = df.iloc[1, 0] # 选择行位置索引为 1，列位置索引为 0 的单元格值
print("\n选择单个单元格 (df.iloc[1, 0]):\n", cell_value_iloc_single) # 2

# 2. 选择指定行和多列 (行位置索引 1，列位置索引列表 [0, 1])
row_series_iloc_multi_cols = df.iloc[1, [0, 1]] # 选择行位置索引为 1，列位置索引为 [0, 1] 的数据，返回 Series
print("\n选择指定行和多列 (df.iloc[1, [0, 1]]):\n", row_series_iloc_multi_cols)

# 3. 选择多行和指定列 (行位置索引列表 [0, 2]，列位置索引 1)
col_series_iloc_multi_rows = df.iloc[[0, 2], 1] # 选择行位置索引为 [0, 2]，列位置索引为 1 的数据，返回 Series
print("\n选择多行和指定列 (df.iloc[[0, 2], 1]):\n", col_series_iloc_multi_rows)

# 4. 选择多行和多列 (行位置索引切片 0:3，列位置索引切片 0:2)
subset_df_iloc_multi_rows_cols = df.iloc[0:3, 0:2] # 选择行位置索引为 0 到 3，列位置索引为 0 到 2 的数据，返回 DataFrame
print("\n选择多行和多列 (df.iloc[0:3, 0:2]):\n", subset_df_iloc_multi_rows_cols)

案例应用：用 Pandas DataFrame 表示学生信息表

我们来做一个案例应用，展示如何使用 Pandas DataFrame 表示学生信息表，并进行基本的数据查看和选择操作。假设我们要创建一个学生信息表，包含姓名、年龄、班级、成绩等信息。

import pandas as pd

# 学生信息数据 (字典列表)
student_data = [
    {'Name': 'Alice', 'Age': 18, 'Class': 'Class A', 'Score': 95},
    {'Name': 'Bob', 'Age': 19, 'Class': 'Class B', 'Score': 88},
    {'Name': 'Charlie', 'Age': 18, 'Class': 'Class A', 'Score': 92},
    {'Name': 'David', 'Age': 20, 'Class': 'Class C', 'Score': 75},
    {'Name': 'Eve', 'Age': 19, 'Class': 'Class B', 'Score': 90}
] # 列表字典数据

# 创建 Pandas DataFrame 表示学生信息表
student_df = pd.DataFrame(student_data)
print("学生信息表 (DataFrame):\n", student_df)

# 1. 查看 DataFrame 的基本信息
print("\nDataFrame 信息 (student_df.info()):")
student_df.info()

# 2. 查看数值列的统计摘要
print("\n数值列的统计摘要 (student_df.describe()):\n", student_df.describe())

# 3. 查看前 3 行数据
print("\n前 3 行数据 (student_df.head(3)):\n", student_df.head(3))

# 4. 查看后 2 行数据
print("\n后 2 行数据 (student_df.tail(2)):\n", student_df.tail(2))

# 5. 查看 'Name' 列和 'Score' 列
print("\n'Name' 列和 'Score' 列 (student_df[['Name', 'Score']]):\n", student_df[['Name', 'Score']])

# 6. 选择 'Class' 为 'Class A' 的学生信息 (布尔索引，后续文章讲解)
class_a_students_df = student_df[student_df['Class'] == 'Class A'] # 布尔索引筛选 (后续文章讲解)
print("\n'Class' 为 'Class A' 的学生信息 (student_df[student_df['Class'] == 'Class A']):\n", class_a_students_df)

# 7. 选择前两行 (行切片)
first_two_rows_df = student_df[0:2] # 行切片选择前两行
print("\n前两行 (student_df[0:2]):\n", first_two_rows_df)

# 8. 选择第一行和第三行 (基于位置索引 .iloc[])
first_third_rows_df = student_df.iloc[[0, 2]] # 基于位置索引选择第一行和第三行
print("\n第一行和第三行 (student_df.iloc[[0, 2]]):\n", first_third_rows_df)

# 9. 选择第一行和 'Name' 列、'Score' 列 (基于位置索引 .iloc[] 和列位置索引)
first_row_name_score = student_df.iloc[0, [0, 3]] # 选择第一行，'Name' 列和 'Score' 列 (列位置索引)
print("\n第一行和 'Name' 列、'Score' 列 (student_df.iloc[0, [0, 3]]):\n", first_row_name_score)

代码解释：

用 DataFrame 表示学生信息表： 我们使用 pd.DataFrame() 创建了一个 Pandas DataFrame student_df，字典列表 student_data 作为数据源，自动创建了列索引 (列名) 和默认整数行索引。
DataFrame 基本操作演示： 案例代码演示了如何使用 .info(), .describe(), .head(), .tail(), 列选择, 行选择 (切片, .iloc[]), 行列同时选择等基本操作，查看和提取 DataFrame 的数据子集。 布尔索引 (条件筛选) 在代码中也有初步展示，会在后续文章中详细讲解。

费曼回顾 (知识巩固):

现在，请你用自己的话，总结一下今天我们学习的 Pandas DataFrame 的知识，包括：

什么是 Pandas DataFrame？它由哪三部分组成？行索引 (Index)、列索引 (Columns) 和值 (Values) 分别是什么意思？ DataFrame 有什么特点和用途？ DataFrame 与 Excel 表格有什么异同？
我们学习了哪些创建 Pandas DataFrame 的方法？ pd.DataFrame() 函数如何使用？如何从字典、列表字典、NumPy 数组创建 DataFrame？如何指定 DataFrame 的行索引和列索引？
我们学习了哪些 DataFrame 的基本操作？ .info(), .describe(), .head(), .tail(), .sample(), .shape, .dtypes, .index, .columns, .values 分别有什么作用？如何使用它们查看 DataFrame 的基本信息和数据概况？
我们学习了哪些 DataFrame 的数据选择方法？如何进行列选择 (单列、多列)？如何进行行选择 (基于标签 .loc[]，基于位置 .iloc[]，切片)？如何进行行列同时选择？
在学生信息表案例中，我们是如何使用 Pandas DataFrame 来表示数据，并进行基本的数据查看和选择操作的？

尝试用最简洁、最形象的语言来解释，就像你是一位数据分析老师，正在给你的学生讲解一样。如果你能清晰地解释出来，就说明你已经掌握了今天学习的内容！

课后思考 (拓展延伸):

尝试修改学生信息表案例的代码，例如：
- 增加更多学生数据，或者增加更多列 (例如添加 “出生日期”、“家庭住址” 等列)，看看 DataFrame 如何处理更大规模、更复杂的数据？
- 尝试使用不同的方法创建 DataFrame，例如从 CSV 文件读取数据创建 DataFrame (提示：可以使用 pd.read_csv() 函数，我们会在下一篇文章中学习)？
- 尝试使用更复杂的数据选择操作，例如选择特定年龄段、特定班级的学生信息？或者选择特定行和特定列交叉区域的数据？
- 查阅 Pandas 文档，了解更多 DataFrame 的属性和方法，例如 .ndim (维度), .size (元素数量), .empty (是否为空), .axes (行索引和列索引列表) 等。
思考一下，除了学生信息表，Pandas DataFrame 还可以用来表示哪些二维表格型数据？例如，产品销售数据、股票交易数据、用户行为日志等等。你有什么有趣的应用想法吗？
预习 Pandas 数据读取和写入的相关知识，为下一篇文章的学习做好准备。

恭喜你！完成了 Pandas 费曼学习法的第二篇文章学习！你已经掌握了 Pandas 的核心数据结构 DataFrame 的基本概念、创建和操作方法，可以开始用 Pandas 处理结构化数据，告别 Excel 的 “低效时代” 了！下一篇文章，我们将学习 Pandas 的 数据读取和写入 功能，掌握如何从各种文件格式 导入数据到 DataFrame，以及如何将 DataFrame 数据 导出到文件，让你的数据分析流程更加完整和高效！敬请期待！

费曼学习法13 - 数据表格的魔法：Python Pandas DataFrame 详解 (Pandas 基础篇)

第二篇：数据表格的魔法：Python Pandas DataFrame 详解 (Pandas 基础篇)

开篇提问：

核心概念讲解 (费曼式解释):

费曼回顾 (知识巩固):

课后思考 (拓展延伸):

网站公告

今日签到

热门文章

最新发布