Python数据可视化与数据处理全解析：Matplotlib图形控制与Pandas高效数据分析实战

前言

书接上文

Python数据可视化实战：Matplotlib从基础图表到高级布局全解析-CSDN博客文章浏览阅读943次，点赞27次，收藏13次。本教程以Matplotlib为核心工具，完整演示Python数据可视化流程，覆盖散点图、柱状图、饼图、直方图等基础图表实现，深入解析Figure对象管理、子图布局策略与图像输出优化，结合正态分布数据生成、颜色映射、多图叠加等实战案例，提供从参数配置到专业级图表输出的系统性指导，助力开发者高效掌握数据可视化核心技能。https://blog.csdn.net/qq_58364361/article/details/146494070?fromshare=blogdetail&sharetype=blogdetail&sharerId=146494070&sharerefer=PC&sharesource=qq_58364361&sharefrom=from_link

一、 plt.gcf

三、Line2D类函数

# 导入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()  # 渲染并弹出图形窗口，显示更新后的折线图

# 导入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之间

# 导入必要的库（虽然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()

# 导入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库

7.2 Series的访问  

# 导入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）

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

进程已结束，退出代码为 0

7.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对象行轴标签的列表。

# 导入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)

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数据结构

# 导入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)

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

进程已结束，退出代码为 0

# 导入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"]])  # 使用双括号包含列名列表选择多列，保持表格结构输出

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

进程已结束，退出代码为 0

# 导入 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])

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

进程已结束，退出代码为 0

8.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 

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上修改，不返回新的对象

# 导入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()

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


进程已结束，退出代码为 0

9.2.2 transform

# 导入必要的库，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()

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


进程已结束，退出代码为 0

9.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，排序前执行自定义函数

# 导入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. 排序时保持行数据完整性，整行数据会跟着排序键一起移动位置

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


进程已结束，退出代码为 0

9.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 进行排序

# 导入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)

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

进程已结束，退出代码为 0

9.4 数据筛选 

根据条件或布尔数组进行数据筛选。

# 导入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)

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

进程已结束，退出代码为 0

9.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(快排)

# 导入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)

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，则在计数之前排除缺失值。  

# 导入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()  # 输出空行分隔不同结果

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文件

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在数据探索、可视化交互及结构化数据处理中的协同应用，为数据分析全流程提供完整工具链支持。