前言
书接上文
一、 plt.gcf
该函数用于返回当前活动的图形对象，如果没有活动的图形，这个函数将创建一个新的图形，并将其作为当前活动的图形。
通过此函数获取了当前图形的Figure对象后，可以调用Figure类中的相关操作，对图形进行添加子图、调整布局、保存图形等操作
二、clo se
plt.close(fig=None)
功能：该函数用于关闭一个或多个打开的图形窗口，释放资源参数：fig：指定要关闭的图形，可以是Figure对象，也可以是图形对应的整数
all：关闭所有图形，如果参数省略，关闭当前图像
三、Line2D类函数
plt.plot函数的返回值表示包含一个或多个 Line2D 对象
Line2D 是 Matplotlib 中用于表示二维线条的类。通过返回 Line2D 对象，你可以访问和修改线条的各种属性，例如颜色、线型、标签等。这使得 plt.plot() 不仅仅是绘制图形，还可以让你对绘制的线条进行进一步的定制。
3.1 get_label
该方法用于获取坐标轴（例如，线和柱状图）的标签。这个方法通常用于获取已经设置好的标签，以便于后续的检查或修改.
3.2 set_data
该函数功能为用于动态更新线条的 x 和 y 数据。主要在需要实时更新图形（例如动画）的场景中。
Line2D.set_ data ( xdata , ydata )
调用该方法后，图形会根据新的数据重新绘制。它不会自动刷新图形，但可以与 plt.draw() 或 plt.pause() 等方法结合使用，以实现动态更新的效果。
python
# 导入matplotlib的pyplot模块，通常别名为plt
import matplotlib.pyplot as plt
# 示例中被注释的原始绘图代码
# plt.plot([1,2], [3,4])
# ----------------------------
# 1. 获取当前Figure对象（被注释的示例）
# ----------------------------
# fig = plt.gcf() # gcf = Get Current Figure
# fig.suptitle('line') # 设置Figure的全局标题
# ----------------------------
# 2. 关闭当前图像窗口（被注释的示例）
# ----------------------------
# plt.close() # 关闭当前绘图窗口，常用于批量生成图表时释放内存
# ----------------------------
# 3. 绘制折线图并获取Line2D对象
# ----------------------------
# plt.plot返回包含Line2D对象的列表
# 逗号解包语法用于直接获取列表中的唯一元素（Line2D实例）
ld, = plt.plot(
[1, 7], # X轴数据：起点1，终点7
[6, 4], # Y轴数据：起点6，终点4
label='line', # 设置线条标签（用于图例显示）
marker='o' # 设置数据点标记为圆圈
)
# ----------------------------
# 4. 获取并打印线条的label属性
# ----------------------------
ret = ld.get_label() # 从Line2D对象获取标签文本
print(ret) # 输出：line
# ----------------------------
# 5. 动态更新绘图数据
# ----------------------------
# 使用set_data方法修改线条数据（需传入两个包含坐标的列表）
# 注意：此时需要重新计算坐标轴范围，建议后续添加 plt.xlim()/plt.ylim()
ld.set_data(
[1, 2, 3], # 新X轴数据：三点数据（原只有两个点）
[6, 5, 4] # 新Y轴数据：三点数据（原只有两个点）
)
# ----------------------------
# 显示最终图形
# ----------------------------
plt.show() # 渲染并弹出图形窗口，显示更新后的折线图四、pause
用于在绘图时暂停程序执行，并在指定的时间间隔后继续执行。它常用于动态更新图形或创建简单的动画效果。
函数的作用：
暂停程序 ：plt.pause(interval) 会暂停程序的执行，暂停的时间由参数 interval（单位为秒）决定。
刷新图形窗口 ：在暂停期间，plt.pause() 会强制刷新图形窗口，显示最新的图形内容。这使得它特别适合用于动态更新图形的场景。
函数原型：
pyplot.pause ( interval )
参数：interval：时间，秒
python
# 导入matplotlib的pyplot模块用于绘图，并简写为plt
import matplotlib.pyplot as plt
# 导入numpy模块用于数值计算，并简写为np
import numpy as np
# 生成从0到2π的等差数列作为x轴数据，步长为0.1
x = np.arange(0, 2 * np.pi, 0.1)
# 计算x对应的正弦函数值作为y轴初始数据
y = np.sin(x)
# 绘制初始曲线，返回的ln是一个线条对象列表
# 用逗号解包获取列表中的第一个（唯一）线条对象
ln, = plt.plot(x, y)
# 暂停程序1秒，此时会显示初始的正弦曲线图像
# （plt.pause会短暂打开GUI窗口并更新画布）
plt.pause(1)
# 将y轴数据更新为余弦函数值
y = np.cos(x)
# 使用set_data方法动态更新线条对象的坐标数据
ln.set_data(x, y)
# 显示最终更新后的图像窗口
# （plt.show()会进入主事件循环，保持窗口打开直到用户关闭）
plt.show()【练习】绘制一个点沿着y=x+1的线动态移动，子图坐标范围设置在0~10之间
python
# 【练习】绘制一个点沿着y=x+1的线动态移动，子图坐标范围设置在0~10之间
# 导入必要的库（虽然numpy在此代码片段中未被实际使用）
import numpy as np
import matplotlib.pyplot as plt
# 初始化图形：创建一个红色圆点对象，初始位置在原点(0,0)
# 注意：plt.plot返回一个列表，逗号用于解包获取线条对象
ln, = plt.plot(0, 0, 'ro')
# 获取当前坐标轴对象
ax = plt.gca()
# 设置坐标轴显示范围：x轴0-10，y轴0-12（因x=10时y=11，需留出余量）
ax.set_xlim(0, 10)
ax.set_ylim(0, 12)
# 动态更新点坐标：x从0到9遍历（range(10)生成10个整数）
for x in range(10):
y = x + 1 # 根据直线方程y=x+1计算纵坐标
# 更新点的坐标数据（参数需为列表形式）
ln.set_data([x], [y])
# 暂停0.5秒实现动画效果（plt.pause用于更新图像显示）
plt.pause(0.5)
# 显示最终图形窗口（放在循环外部，避免窗口提前关闭）
plt.show()五、gridspec.GridSpec
在 Matplotlib 中，GridSpec 对象提供了一种灵活的方式来创建子图网格（subplots grid），允许子图跨越多个行和列，以及具有不均匀的行高和列宽。
GridSpec 的构造函数原型及其参数如下：
from matplotlib . gridspec import GridSpecGridSpec(nrows, ncols, figure=None, left=None, right=None, bottom=None, top=None, wspace=None, hspace=None, width_ratios=None, height_ratios=None, w_pad=None, h_pad=None)
参数：nrows: int子图网格的行数。
ncols: int子图网格的列数。
figure: matplotlib.figure.Figure,
optional,
default: None
指定的图形对象。如果未提供，则默认创建一个新的图形对象。
left: float, optional, default: None子图网格左侧的相对位置（0 到 1 的比例）。如果未指定，则使用默认的左边界。
right: float, optional, default: None子图网格右侧的相对位置（0 到 1 的比例）。如果未指定，则使用默认的右边界。
bottom: float, optional, default: None子图网格底部的相对位置（0 到 1 的比例）。如果未指定，则使用默认的底边界。
top: float, optional, default: None子图网格顶部的相对位置（0 到 1 的比例）。如果未指定，则使用默认的顶边界。
wspace: float or None, optional, default: None子图之间的水平间距（以英寸为单位）或作为子图宽度的比例。如果未指定，则使用默认的间距。
hspace: float or None, optional, default: None子图之间的垂直间距（以英寸为单位）或作为子图高度的比例。如果未指定，则使用默认的间距。
width_ratios: list of floats, optional, default: None
指定每一列的宽度比例。如果指定，则 ncols 必须与列表长度匹配。
height_ratios: list of floats, optional, default: None
指定每一行的高度比例。如果指定，则 nrows 必须与列表长度匹配。
w_pad: float, optional, default: None子图之间的水平填充（以英寸为单位）。如果未指定，则使用默认的填充。
h_pad: float, optional, default: None子图之间的垂直填充（以英寸为单位）。如果未指定，则使用默认的填充。
python
# 导入matplotlib的pyplot模块用于绘图，gridspec模块用于复杂子图布局
import matplotlib.pyplot as plt
import matplotlib.gridspec as gs # 导入网格布局工具
# 创建一个新的图形窗口
fig = plt.figure()
# 创建2行3列的网格布局（GridSpec）
# 参数说明：(行数, 列数) -> 这里创建2行3列共6个单元格的布局
g = gs.GridSpec(2, 3) # 总布局为2行3列
# 在第一行第一列的位置添加子图（索引从0开始）
fig.add_subplot(g[0, 0]) # 位置：行0列0
# 在第一行第二列的位置添加子图
fig.add_subplot(g[0, 1]) # 位置：行0列1
# 在第一行第三列的位置添加子图
fig.add_subplot(g[0, 2]) # 位置：行0列2
# 在第二行合并所有列（使用冒号:表示范围）添加一个跨列子图
fig.add_subplot(g[1, :]) # 位置：行1，跨所有列（0-2）
plt.tight_layout() # 自动调整子图间距
plt.show()
六、Pandas库
Pandas是一个基于NumPy的Python数据分析库，它在数据分析领域扮演着至关重要的角色。
Pandas的主要作用有以下几点：
- Pandas提供了一系列易于使用的数据结构和工具，包括Series（一维标签化数据结构）和DataFrame（二维标签化数据结构）。
- Pandas擅长处理和分析结构化数据，如表格数据、时间序列数据等
- Pandas支持从多种数据源读取数据，包括CSV文件、Excel文件、SQL数据库、网页等
- Pandas提供了强大的数据分组和聚合功能，如求和、计数、平均值、中位数等
- Pandas与Matplotlib、Seaborn等数据可视化库结合使用，可以轻松地绘制各种图表，如线图、柱状图、散点图、箱线图等。
七、series数据结构
pandas中具有两种基本的数据存储结构，存储一维values的Series和存储二维values的DataFrame，在这两种结构上定义了很多的属性和方法。
Series是Pandas中的一维标签化数据结构，它可以存储任何数据类型（整数、字符串、浮点数、Python对象等），Series对象中每个元素都有一组索引与之对应，可以将其看做是特殊的字典
7.1 Series 的创建
可以通过多种方式创建Series，包括从列表、元组、字典、NumPy数组等
pandas.Series ( data = None , index = None , dtype = None , name = None , copy = False , fastpath = False )
参数：data：表示传入的数据，可以是列表、数组、字典等。index：表示索引，唯一且与数据长度相等。如果不指定，默认会自动创建一个从0开始的整数索引。
dtype：数据类型，默认会自己判断。可以显式指定数据类型以确保数据的一致性。
name：设置Series的名称，方便后续操作。
copy：拷贝数据，默认为False。如果设置为True，则会复制数据以避免在原始数据上进行修改。
fastpath：内部参数，通常不需要用户指定。
7.2 Series的访问
Series的访问有四种方式：
- 位置索引访问
直接通过默认索引进行访问
- 标签索引访问
使用标签进行索引，与访问字典中的元素类似。
- 切片索引访问
都是通过start:stop进行切片，开始值与终止值可以省略。
第一种是使用位置切片，其使用方法与列表的切片类似；遵循左闭右开，只包含start，不包含stop
第二种是使用标签切片，其语法与位置切片类似，遵循左右都闭合，即既包含start，又包含stop。
- 函数访问
get(key, default=None):通过标签来获取Series中的元素
参数：key: 你想要获取的元素的标签。default: 可选参数，如果key不在标签中，返回这个默认值。如果没有指定，默认为 None。
head(n=5)：返回Series的前n个元素，默认为前5个。
tail(n=5)：返回Series的后n个元素，默认为后5个。
isin():判断Series中的每个元素是否在指定的一组值中，它会返回一个与原Series长度相同的布尔型Series，其中对应位置为True表示该位置的元素在指定的值集合中，False则表示不在。
python
# 导入pandas库（Python数据分析工具），使用pd作为别名方便调用
import pandas as pd
# ------------------------------
# 示例1：使用列表创建Series
# ------------------------------
# 创建包含混合数据类型的列表（包含int, float, str类型）
data = [1, 2.3, 3, 4, "a"]
# 将列表转换为Pandas Series对象（自动生成0-4的整数索引）
se = pd.Series(data)
print(type(se)) # 打印对象类型 → 输出 <class 'pandas.core.series.Series'>
print(se) # 输出Series内容（索引0-4，数据类型自动推断为object类型）
print() # 打印空行分隔不同示例的输出
# ------------------------------
# 示例2：使用元组+自定义索引创建Series
# ------------------------------
# 使用元组作为数据源（元组与列表功能相同，但不可修改）
data = (1, 2.3, 3, 4, "a")
# 自定义字符索引列表（索引数量必须与数据元素数量一致）
index = ["a", "b", "c", "d", "e"]
# 创建Series时显式指定索引标签
se = pd.Series(data, index=index)
print(type(se)) # 类型与列表示例相同 → 仍为Series对象
print(se) # 输出内容索引变为a-e（不再显示默认的0-4数字索引）
print()
# ------------------------------
# 示例3：使用字典创建Series（键自动转为索引）
# ------------------------------
# 创建字典，键作为索引标签，值作为数据元素
data = {"a": 1, "b": 2.3, "c": 3, "d": 4, "e": "a"}
# 直接转换字典，键作为索引，值作为数据
se = pd.Series(data)
print(type(se)) # 类型仍然为Series对象
print(se) # 输出结果与示例2相同（索引a-e，值1,'a'等）
print()
# ------------------------------
# 数据访问演示
# ------------------------------
print(se["a"]) # 通过索引标签访问 → 输出1（标签访问）
print(se[0]) # 通过位置索引访问 → 同样输出1（位置访问，此时索引a对应位置0）
print()
# ------------------------------
# 切片操作演示
# ------------------------------
# 位置切片（左闭右开原则：包含起始位置，不包含结束位置）
print(se[1:3]) # 输出索引b(位置1)和c(位置2)的值 → 2.3和3
print()
# 标签切片（闭区间原则：包含起始和结束标签）
print(se["b":"d"]) # 输出索引b到d的值 → 2.3,3,4（包含d标签）
print()
# ------------------------------
# 数据查询方法
# ------------------------------
print(se.get("a")) # 使用get方法安全访问 → 输出1
print(se.get(5, "Not Found")) # 当标签/位置不存在时返回默认值 → 输出"Not Found"
print()
# ------------------------------
# 首尾数据查看
# ------------------------------
print(se.head(2)) # 输出前两个元素（默认显示前5个，此处指定2个）
print()
print(se.tail(2)) # 输出后两个元素（默认显示后5个，此处指定2个）
print()
# ------------------------------
# 成员关系判断
# ------------------------------
vel = [2, 10] # 创建验证值列表
# 检查Series中的每个元素是否存在于vel列表，返回布尔型Series
print(se.isin(vel)) # 输出示例：a-False, b-False...（只有元素2和10会返回True）
python
D:\python_huanjing\.venv1\Scripts\python.exe C:\Users\98317\PycharmProjects\study_python\study_1\study.py
<class 'pandas.core.series.Series'>
0 1
1 2.3
2 3
3 4
4 a
dtype: object
<class 'pandas.core.series.Series'>
a 1
b 2.3
c 3
d 4
e a
dtype: object
<class 'pandas.core.series.Series'>
a 1
b 2.3
c 3
d 4
e a
dtype: object
1
1
b 2.3
c 3
dtype: object
b 2.3
c 3
d 4
dtype: object
1
Not Found
a 1
b 2.3
dtype: object
d 4
e a
dtype: object
a False
b False
c False
d False
e False
dtype: bool
进程已结束，退出代码为 07.3 Series属性
values：返回Series的值数组，以NumPy数组的形式返回。
index：返回Series的索引数组，索引用于标识每个数据点的位置。dtype：返回Series的数据类型，例如int64、float64或object等。
size：返回Series的大小，即数据点的数量。
shape：返回Series的形状，以元组的形式表示，对于Series来说，其形状是一个一维数组的长度。
name：返回Series的名称，可以通过在创建Series时指定name参数来设置。
hasnans:返回数组中是否包含NaN值，存在NaN返回True否则返回False。
is_unique:用于返回数组中的元素是否为独一无二的，如果所有的元素都是独一无二的，即数组中没有重复元素，那么就返回True，否则返回False。
empty:用来表示Series数组是否为空，返回值一个布尔值，如果数组里一个元素都没有就返回True，否则返回False。
axes:用于返回series对象行轴标签的列表。
python
# 导入pandas库，并使用pd作为别名
import pandas as pd
# 创建一个包含混合类型数据的Python列表
data = [1, 2, 4.4, "Hello"]
# 定义索引标签列表（索引长度需要与数据长度一致）
index = ["a", "b", "c", "d"]
# 创建Pandas Series对象
# data参数：包含数据的列表
# index参数：指定自定义索引标签
se = pd.Series(data, index=index)
# 打印整个Series对象（包含索引和值）
print(se)
# 获取Series的值数组（返回numpy.ndarray）
print(se.values)
# 获取Series的索引对象（返回Index对象）
print(se.index)
# 获取Series中元素的个数
print(se.size)
# 获取/设置Series的名称（当前未设置返回None）
print(se.name)
# 检查Series是否包含缺失值（NaN）
print(se.hasnans)
# 检查Series的所有值是否唯一
print(se.is_unique)
# 返回包含行轴标签的列表（等价于[se.index]）
print(se.axes)
# 显示Series中元素的数据类型（混合类型时会显示object）
print(se.dtypes)
# 返回Series的维度形状（n个元素的一维数组返回(n, )）
print(se.shape)
python
D:\python_huanjing\.venv1\Scripts\python.exe C:\Users\98317\PycharmProjects\study_python\study_1\study.py
a 1
b 2
c 4.4
d Hello
dtype: object
[1 2 4.4 'Hello']
Index(['a', 'b', 'c', 'd'], dtype='object')
4
None
False
True
[Index(['a', 'b', 'c', 'd'], dtype='object')]
object
(4,)
进程已结束，退出代码为 0八、DataFrame数据结构
DataFrame是Pandas库中的另一个核心数据结构，它用于表示二维表格型数据；它类似于Excel中的表格或SQL表，具有行和列。
DataFrame由一组有序的列组成，每列可以是不同的数据类型（如数值、字符串、布尔型值等）。DataFrame既有行索引也有列索引，提供了丰富的功能来进行数据访问、筛选、分割、合并、重塑、聚合以及转换等操作。
8.1 Dataframe 的 创建
pandas.DataFrame ( data = None , index = None , columns = None , dtype = None , copy = False )
参数：data：数据输入，可以是ndarray、series、map、lists、dict等类型。如果为dict，则dict的键会被用作列名，除非columns参数被显式指定。
index：行标签索引，如果没有提供，则默认为整数索引。
columns：列标签，如果没有提供且没有通过data参数传递列名，则默认为整数索引。
dtype：数据类型，可选。如果指定，则数据类型会被强制转换为dtype类型。
copy：复制数据，默认为False。如果为True，则复制数据以避免在原始数据上进行修改。
python
# 导入pandas库并使用pd作为别名（数据处理常用库）
import pandas as pd
import numpy as np
# 示例1：创建包含单一列的DataFrame
# 原始数据（只有姓名信息的字符串列表）
data = ["zhangsan", "lisi", "wangwu"]
# 将列表转换为DataFrame对象，指定列名为"name"
# 每个列表元素会自动成为新的一行
df = pd.DataFrame(data, columns=["name"])
# 打印DataFrame（默认显示行列索引和表格格式）
print(df)
print() # 打印空行分隔两个示例
# 示例2：创建包含多列的DataFrame
# 包含嵌套列表的二维数据（姓名+年龄的复合数据）
data = [["zhangsan", 18], ["lisi", 22], ["wangwu", 19]]
# 创建DataFrame时同时指定列名（name列和age列）
# 每个子列表对应一行数据，元素与列名一一对应
df = pd.DataFrame(data, columns=["name", "age"])
# 打印包含多列的DataFrame
print(df)
# 使用numpy库生成一个2行3列的随机数矩阵，数值范围在[0,1)之间
nrr = np.random.rand(2, 3)
# 将numpy数组转换为Pandas DataFrame结构
# index参数指定行标签为中文"第一行"和"第二行"
# columns参数指定列标签为中文"第一列"、"第二列"和"第三列"
df = pd.DataFrame(
nrr,
index=["第一行", "第二行"],
columns=["第一列", "第二列", "第三列"]
)
# 打印输出DataFrame，默认显示表格格式：
# - 包含行列标签
# - 自动对齐数据
# - 显示索引列
print(df)
python
D:\python_huanjing\.venv1\Scripts\python.exe C:\Users\98317\PycharmProjects\study_python\study_1\study.py
name
0 zhangsan
1 lisi
2 wangwu
name age
0 zhangsan 18
1 lisi 22
2 wangwu 19
第一列 第二列 第三列
第一行 0.597730 0.508274 0.243986
第二行 0.193776 0.039252 0.861752
进程已结束，退出代码为 08.2 D a t a F r a m e 的 访问
8.2.1 使用列名访问
在DataFrame的访问中要先指定列再指定行
python
# 导入pandas库并使用pd作为别名（数据处理常用库，DataFrame核心数据结构）
import pandas as pd
# 导入numpy库并使用np作为别名（数值计算库，本代码片段中暂未实际使用）
import numpy as np
# 创建包含姓名和年龄的字典数据
data = {
"name": ["xiaoming", "xiaohong", "xiaohua"],
"age": [18, 19, 20] # 年龄列表与姓名列表长度需保持一致
}
# 将字典数据转换为pandas的二维表格数据结构DataFrame
# 自动生成行列标签，索引为默认数字索引
df = pd.DataFrame(data)
# 打印age列数据（单列选择返回Series对象）
print(df["age"]) # 使用单括号选择单列，输出效果为垂直排列的带索引数据
print() # 打印空行分隔两次输出
# 打印name和age两列数据（多列选择返回DataFrame对象）
print(df[["name", "age"]]) # 使用双括号包含列名列表选择多列，保持表格结构输出
python
D:\python_huanjing\.venv1\Scripts\python.exe C:\Users\98317\PycharmProjects\study_python\study_1\study.py
0 18
1 19
2 20
Name: age, dtype: int64
name age
0 xiaoming 18
1 xiaohong 19
2 xiaohua 20
进程已结束，退出代码为 08.2.2 使用 loc 和 iloc 函数 访问
df.loc[row_label, column_label]
功能：是基于标签的索引，用于通过行标签和列标签访问数据。参数：row_label：行标签，可以是单个标签、标签列表、切片或布尔数组。
column_label：列标签，可以是单个标签、标签列表、切片或布尔数组
df.iloc[row_position, column_position]
功能：是基于位置的索引，用于通过行和列的位置访问数据。
参数：row_position：行的位置，可以是整数、整数列表、切片或布尔数组。
column_position：列的位置，可以是整数、整数列表、切片或布尔数组。
python
# 导入 pandas 库并使用 pd 作为别名（数据处理常用库）
import pandas as pd
# 创建原始数据字典，包含姓名和年龄两列数据
data = {'name': ['zhangsan', 'lisi', 'wangwu'], 'age': [12, 23, 22]}
# 定义行索引标签列表（自定义索引替代默认数字索引）
index = ['a', 'b', 'c']
# 使用数据和自定义索引创建 DataFrame 对象
# DataFrame 是 pandas 中的二维表格数据结构
df = pd.DataFrame(data, index=index)
# 打印完整 DataFrame（展示表格结构，包含三行两列）
print(df)
print() # 打印空行分隔不同输出结果
# 使用 loc 按标签选择索引为 'a' 的行（返回 Series 对象）
print("行标签'a'的数据:")
print(df.loc['a'])
print()
# 使用 loc 同时指定行标签和列标签获取具体值
print("行标签'a'，列标签'name'的值:")
print(df.loc['a', 'name']) # 返回单个标量值 'zhangsan'
print()
# 使用 iloc 按位置选择第一行第一列的值（索引从0开始计数）
print("第0行第0列的值:")
print(df.iloc[0, 0]) # 等效于 df.iloc[0][0]
print()
# 使用 iloc 进行切片操作：
# 选择前两行（0-1行）和前两列（0-1列）的数据
# 切片规则：左闭右开区间（包含0，1；不包含2）
print("前两行前两列的子数据集:")
print(df.iloc[0:2, 0:2])
python
D:\python_huanjing\.venv1\Scripts\python.exe C:\Users\98317\PycharmProjects\study_python\study_1\study.py
name age
a zhangsan 12
b lisi 23
c wangwu 22
行标签'a'的数据:
name zhangsan
age 12
Name: a, dtype: object
行标签'a'，列标签'name'的值:
zhangsan
第0行第0列的值:
zhangsan
前两行前两列的子数据集:
name age
a zhangsan 12
b lisi 23
进程已结束，退出代码为 08.3 DataFrame的属性
index ：返回行标签。
columns：返回列标签。axes:返回行轴和列轴的列表。
values：返回DataFrame中的数据，以NumPy数组的形式。
dtypes：返回DataFrame中各列的数据类型。
shape：返回DataFrame的形状，即数据的维度（行数和列数）。
size：返回DataFrame中的元素个数。
ndim：返回DataFrame的维度（对于DataFrame来说，总是2）。
empty：判断DataFrame是否为空，如果为空则返回True，否则返回False。
T：返回DataFrame的转置。
九、数据操作
9.1 数据清洗
9.1.1 dropna
dropna ( axis = 0 , inplace = False )
功能：删除包含NaN值的行参数：axis：用于指定按哪个轴删除缺失值，默认为0(一维数据结构不用修改)
inplace：True，直接在原数据上删除缺失值
False，返回一个删除了缺失值的新结构
9.1.2 fillna
fillna ( value = None )
功能：填充NaN的值参数：value：可以是单个值，也可以是字典（对不同的列填充不同的值），或者一个 Series。
9.1.3 isnull
isnull()
功能：检测数据对象中的缺失值，它会返回一个布尔型结构，其中每个元素表示原数据对应位置的值是否为缺失值（NaN）。
9.1.4 drop_duplicates
drop_duplicates ( keep = 'first' , inplace = False , ignore_index = False )
功能：用于去除数据对象中的重复项参数：keep：决定了如何处理重复项
first：默认值，保留第一次出现的重复项
last：保留最后一次出现的重复项
False：不保留任何重复项，即删除所有重复项
ignore_index：默认False，True表示重置索引为默认整数索引
9.2 数据转换
9.2.1 replace
DataFrame . replace ( to_replace = None , value = None , inplace = False , limit = None , regex = False , method = 'pad' )
功能：替换特定的值、一系列值或者使用字典映射进行替换参数：to_replace：要替换的值，标量、列表、字典都可以
value：替换后的新值，格式和to_replace相同
inplace：True，则直接在原 Series上修改，不返回新的对象
python
# 导入pandas库并使用pd作为别名
import pandas as pd
# 创建包含空值（None）的二维数据列表
data = [[12, 88, 99], [23, None, 54], [12, 88, 56], [45, 67, 89]]
# 定义数据框的列名
columns = ['a', 'b', 'c']
# 使用数据列表和列名创建DataFrame
df = pd.DataFrame(data, columns=columns)
print("原始数据框:")
print(df)
print()
# 将单个值88替换为100（返回新DataFrame）
ret = df.replace(88, 100)
print("替换单个值结果:")
print(ret)
print()
# 使用列表形式批量替换值：88->45，67->100（一一对应替换）
ret = df.replace([88, 67], [45, 100])
print("列表形式替换结果:")
print(ret)
print()
# 使用字典形式进行精确替换：88替换为45，67替换为100
ret = df.replace({88: 45, 67: 100})
print("字典形式替换结果:")
print(ret)
print()
python
D:\python_huanjing\.venv1\Scripts\python.exe C:\Users\98317\PycharmProjects\study_python\study_1\study.py
原始数据框:
a b c
0 12 88.0 99
1 23 NaN 54
2 12 88.0 56
3 45 67.0 89
替换单个值结果:
a b c
0 12 100.0 99
1 23 NaN 54
2 12 100.0 56
3 45 67.0 89
列表形式替换结果:
a b c
0 12 45.0 99
1 23 NaN 54
2 12 45.0 56
3 45 100.0 89
字典形式替换结果:
a b c
0 12 45.0 99
1 23 NaN 54
2 12 45.0 56
3 45 100.0 89
进程已结束，退出代码为 09.2.2 transform
函数在 Pandas 中用于对数据进行逐行或逐列的转换操作，它通常接受一个函数(内置函数或自定义函数)作为参数，并将该函数应用于 DataFrame 的每一列或每一行，返回Dataframe和原数组形状一致
DataFrame.transform(func, axis=0, *args, **kwargs)
功能：对DataFrame中的数据进行自定义转换操作
参数：func：应用于Series的函数。这个函数可以是内置函数，或者自定义的函数
python
# 导入必要的库，numpy用于数学运算，pandas用于数据处理
import numpy as np
import pandas as pd
# 创建原始数据，包含一个None（在pandas中会自动转换为NaN）
data = [[12, 88, 99], [23, None, 54], [12, 88, 56], [45, 67, 89]]
columns = ['a', 'b', 'c'] # 定义DataFrame的列名
df = pd.DataFrame(data, columns=columns) # 将数据转换为DataFrame结构
# 使用transform方法对每个元素应用自然对数函数，None对应的位置会保持NaN
# 注意：若数值<=0时np.log会输出-inf或报错，但本例数据均为正数
tr = df.transform(np.log)
print(tr)
print() # 打印空行分隔结果
# 自定义转换函数：将输入数据（每个元素）除以2
def han(x):
x /= 2 # 向量化操作，适用于Series（对每个元素生效）
return x
# 应用自定义函数，处理DataFrame中的每个元素（NaN会保持不变）
tr = df.transform(han)
print(tr)
print()
python
D:\python_huanjing\.venv1\Scripts\python.exe C:\Users\98317\PycharmProjects\study_python\study_1\study.py
a b c
0 2.484907 4.477337 4.595120
1 3.135494 NaN 3.988984
2 2.484907 4.477337 4.025352
3 3.806662 4.204693 4.488636
a b c
0 6.0 44.0 49.5
1 11.5 NaN 27.0
2 6.0 44.0 28.0
3 22.5 33.5 44.5
进程已结束，退出代码为 09.3 数据排序
9.3.1 sort_values
函数是用于对 DataFrame 或 Series 的数据进行排序。它可以根据一个或多个列的值对数据进行升序或降序排列
DataFrame.sort_ values ( by , axis=0 , ascending=True , inplace=False , kind= 'quicksort' , na_position= 'last' , ignore_index=False , key=None )
功能：根据一个或多个列的值对 DataFrame 进行排序参数：
by: 用于排序的列名或列名列表
axis：默认0，对Series无效
ascending：默认True，True：升序，False：降序
inplace：默认False，True：在原始数据上修改
kind：排序算法，默认quicksort(快排)
na_position：默认last，表示NAN放在末尾，first放在开头
ignore_index：默认False，True表示重置索引为默认整数索引
key：函数，默认为None，排序前执行自定义函数
python
# 导入pandas库并使用pd作为别名（数据处理常用库）
import pandas as pd
# 创建原始数据集（包含空值None）
data = [[12, 88, 99], [23, None, 54], [12, 88, 56], [45, 67, 89]]
# 定义数据框的列名
columns = ['a', 'b', 'c']
# 使用pandas创建DataFrame对象（二维表格型数据结构）
df = pd.DataFrame(data, columns=columns)
print("原始数据框:")
print(df)
print() # 打印空行分隔输出内容
# 按列'a'的值进行排序（默认升序排列，空值NaN会自动排在最后）
ret = df.sort_values(by=["a"])
print("按a列排序后的数据框:")
print(ret)
print()
# 扩展说明：
# 1. sort_values()支持多列排序，例如 by=["a", "b"]
# 2. 可以通过参数 ascending=False 改为降序排列
# 3. None在pandas中会被自动转换为NaN（Not a Number）表示缺失值
# 4. 排序时保持行数据完整性，整行数据会跟着排序键一起移动位置
python
D:\python_huanjing\.venv1\Scripts\python.exe C:\Users\98317\PycharmProjects\study_python\study_1\study.py
a b c
0 12 88.0 99
1 23 NaN 54
2 12 88.0 56
3 45 67.0 89
a b c
0 12 88.0 99
2 12 88.0 56
1 23 NaN 54
3 45 67.0 89
进程已结束，退出代码为 09.3.2 sort_index
DataFrame.sort_index(axis=0, level=None, ascending=True, inplace=False, kind='quicksort', na_position='last', sort_remaining=True, ignore_index=False, key=None)
功能：根据索引对 DataFrame 进行排序
python
# 导入pandas库并使用pd作为别名（用于数据分析和处理的常用库）
import pandas as pd
# 创建原始数据集（注意第二个子列表包含空值None，用于演示缺失值场景）
data = [[12, 88, 99], [23, None, 54], [12, 88, 56], [45, 67, 89]]
# 定义数据框的列名（将对应三维数据集中的三个特征列）
columns = ['a', 'b', 'c']
# 定义自定义索引（使用字符串格式的数字，创建非连续、非顺序的索引）
index = ["1", "4", "3", "2"]
# 创建Pandas DataFrame对象
# 参数说明：
# data: 原始数据集
# columns: 定义的列名
# index: 自定义的行索引（将显示在输出最左侧）
df = pd.DataFrame(data, columns=columns, index=index)
# 按索引排序（默认升序排列）
# 注意：由于索引是字符串类型，将按字典顺序排序（"1", "2", "3", "4"）
# 原始索引顺序 ["1", "4", "3", "2"] 排序后变为 ["1", "2", "3", "4"]
ret = df.sort_index()
# 打印排序后的数据框
# 输出说明：
# - 索引列将按新顺序排列
# - 空值会显示为NaN（Not a Number）
print(ret)
python
D:\python_huanjing\.venv1\Scripts\python.exe C:\Users\98317\PycharmProjects\study_python\study_1\study.py
a b c
1 12 88.0 99
2 45 67.0 89
3 12 88.0 56
4 23 NaN 54
进程已结束，退出代码为 09.4 数据筛选
根据条件或布尔数组进行数据筛选。
python
# 导入pandas库并使用pd作为别名（该库专门用于数据分析和处理，提供DataFrame等高效数据结构）
import pandas as pd
# 创建原始数据：二维列表表示4个学生的成绩数据（每个子列表依次包含语文、数学、英语、物理成绩）
data = [[78, 55, 33, 44], [98, 56, 34, 45], [99, 57, 35, 46], [99, 58, 36, 47]]
# 设置DataFrame的行索引（学生编号）和列索引（科目名称）
index = ["1", "2", "3", "4"]
columns = ["语文", "数学", "英语", "物理"]
# 创建DataFrame对象（相当于带行列标签的二维表格）
df = pd.DataFrame(data=data, index=index, columns=columns)
# 条件筛选：选取语文成绩大于80分的所有行（返回新DataFrame）
# 原理：df["语文"] > 80 会生成布尔序列，用于索引符合条件的行
ret = df[df["语文"] > 80]
print("语文成绩大于80分的学生：")
print(ret)
print() # 打印空行分隔输出
# 布尔索引演示：通过布尔列表筛选行数据（True表示保留，False表示过滤）
# 注意：布尔列表长度必须与DataFrame行数一致
# 此处保留索引为"1"和"3"的行（对应第1行和第3行数据）
code = [True, False, True, False]
ret = df[code]
print("通过布尔列表筛选的学生：")
print(ret)
python
D:\python_huanjing\.venv1\Scripts\python.exe C:\Users\98317\PycharmProjects\study_python\study_1\study.py
语文成绩大于80分的学生：
语文 数学 英语 物理
2 98 56 34 45
3 99 57 35 46
4 99 58 36 47
通过布尔列表筛选的学生：
语文 数学 英语 物理
1 78 55 33 44
3 99 57 35 46
进程已结束，退出代码为 09.5 数据拼接
pandas . concat ( objs , * , axis = 0 , join = 'outer' , ignore_index = False , keys = None , levels = None , names = None , verify_integrity = False , sort = False , copy = None )
功能：将多个Pandas数据沿着一个轴连接起来参数：objs：参与连接的Pandas对象的列表或元组
axis：连接的轴，0：沿着航方向连接，1沿着列方向连接
join：outer：取所有索引的并集 inner：取所有索引的交集
ignore_index：默认False，True表示重置索引为默认整数索引
inplace：默认False，True：在原始数据上修改
kind：排序算法，默认quicksort(快排)
python
# 导入pandas库并使用pd作为别名（常规缩写）
import pandas as pd
# 创建原始数据（二维列表格式，包含4个学生的四科成绩）
data = [[78, 55, 33, 44], [98, 56, 34, 45], [99, 57, 35, 46], [99, 58, 36, 47]]
# 定义行索引（学生编号）
index = ["1", "2", "3", "4"]
# 定义列名（学科名称）
columns = ["语文", "数学", "英语", "物理"]
# 创建DataFrame对象（二维表格数据结构）
df = pd.DataFrame(data, index=index, columns=columns)
print("原始成绩表：")
print(df)
print() # 打印空行分隔输出
# 创建包含新学生成绩的DataFrame（单行数据）
# 注意：每个学科的值需要用列表包裹，即使只有一个值
new_df = pd.DataFrame({
"语文": [100],
"数学": [100],
"英语": [100],
"物理": [100]
})
print("新增学生成绩：")
print(new_df)
print()
# 使用concat合并两个DataFrame（纵向堆叠）
# axis=0 表示按行合并（纵向扩展）
# ignore_index=True 会重置索引，生成新索引（0-4）
ret = pd.concat([df, new_df], axis=0, ignore_index=True)
print("合并后的完整成绩表：")
print(ret)
python
D:\python_huanjing\.venv1\Scripts\python.exe C:\Users\98317\PycharmProjects\study_python\study_1\study.py
原始成绩表：
语文 数学 英语 物理
1 78 55 33 44
2 98 56 34 45
3 99 57 35 46
4 99 58 36 47
新增学生成绩：
语文 数学 英语 物理
0 100 100 100 100
合并后的完整成绩表：
语文 数学 英语 物理
0 78 55 33 44
1 98 56 34 45
2 99 57 35 46
3 99 58 36 47
4 100 100 100 100
进程已结束，退出代码为 0十、统计运算
value_counts ( subset = None , normalize = False , sort = True , ascending = False , dropna = True )
功能：用于计算Series中各个值出现的频率或个数的一个方法。参数：subset：可选参数，用于指定要进行计算操作的列名列表。如果未指定，则对整个DataFrame的所有列进行操作。
normalize：布尔值，默认为False。如果设置为True，则返回每个值的相对频率，而不是计数。
sort：布尔值，如果设置为True，则结果将按计数值降序排序。
ascending：布尔值，当`sort=True`时，此参数指定排序顺序。如果设置为True，则结果将按计数值升序排序。
dropna：布尔值，如果设置为True，则在计数之前排除缺失值。
python
# 导入pandas库并使用pd作为行业标准别名
# pandas 是Python处理表格数据的核心库
import pandas as pd
# 创建原始成绩数据（二维列表格式）
# 数据结构说明：
# - 外层列表包含4个子列表，每个子列表对应一个学生的成绩
# - 内层列表元素顺序为：[语文, 数学, 英语, 物理] 成绩
data = [
[78, 55, 33, 44], # 学生1成绩
[98, 56, 34, 45], # 学生2成绩
[99, 57, 35, 46], # 学生3成绩
[99, 58, 36, 47] # 学生4成绩
]
# 定义行索引（学生编号）
# 使用字符串格式的编号（避免与数值计算混淆）
index = ["1", "2", "3", "4"]
# 定义列索引（学科名称）
# 列名对应成绩数据中的科目顺序
columns = ["语文", "数学", "英语", "物理"]
# 创建DataFrame对象
# DataFrame是pandas的核心数据结构，用于存储二维表格数据
# 参数说明：
# - data: 原始数据
# - index: 行标签（学生编号）
# - columns: 列标签（学科名称）
df = pd.DataFrame(data, index=index, columns=columns)
# 打印原始成绩表（带格式的空行分隔）
print("原始成绩表：")
print(df)
print() # 输出空行分隔不同结果
# 统计语文成绩出现次数
# df.value_counts() 功能说明：
# - 统计指定列中每个唯一值出现的次数
# - 返回结果按频次降序排列
# - subset参数指定要统计的列（这里只统计语文成绩）
ret = df.value_counts(subset=["语文"])
# 打印统计结果
print("语文成绩统计（值-出现次数）：")
print(ret)
print() # 输出空行分隔不同结果
python
D:\python_huanjing\.venv1\Scripts\python.exe C:\Users\98317\PycharmProjects\study_python\study_1\study.py
原始成绩表：
语文 数学 英语 物理
1 78 55 33 44
2 98 56 34 45
3 99 57 35 46
4 99 58 36 47
语文成绩统计（值-出现次数）：
语文
99 2
78 1
98 1
Name: count, dtype: int64
进程已结束，退出代码为 0十一、文件的读取写入
可以读写.csv和.xlsx文件
python
pandas.read_csv(filepath, sep=',', header='infer', usecols=None,...)
功能：读取csv类型的文件
参数：filepath：读取的文件名
sep：字段分隔符，默认为逗号
header：指定第一行作为列名，默认为0（第一行）
usecols：返回一个数据子集，需要读取的列
pandas.read_excel(filepath, sheet_name=0, header=0, usecols=None, ...)
功能：读取execl类型文件
参数：sheet_name：工作表名称或索引，默认为0（第一个工作表）
其他同上
DataFrame.to_csv(path=None, sep=',', columns=None, index=True, ...)
功能：将DataFrame写入csv类型的文件
参数：columns:要写入的列名列表
index：是否写行（索引）名称。默认为True。
DataFrame.to_excel(excel_writer, sheet_name='Sheet1', ...)
功能：将DataFrame写入excel类型的文件
参数：同上总结
本文系统梳理了Python两大核心库Matplotlib与Pandas的核心功能及应用场景。在数据可视化方面，Matplotlib通过plt.gcf()实现图形对象管理，Line2D类支持动态数据更新与动画效果，gridspec.GridSpec提供灵活的子图布局控制，结合plt.pause()可创建实时动态图表。Pandas作为数据分析利器，重点解析了Series和DataFrame两大数据结构，涵盖数据清洗（dropna/fillna）、转换（replace/transform）、排序筛选（sort_values/loc/iloc）、统计运算（value_counts）等操作链，并演示了CSV/Excel文件的高效读写方法。通过动态点移动动画、数据分布统计、表格合并等实战案例，展现了Matplotlib与Pandas在数据探索、可视化交互及结构化数据处理中的协同应用，为数据分析全流程提供完整工具链支持。