（第三次）Numpy & Pandas
在大数据分析与计算领域，Python的Numpy和Pandas库是不可或缺的核心工具。Numpy凭借高效的数值计算能力，成为处理海量数值数据的“快剑”；Pandas则以灵活的数据管理功能，化身打理复杂数据的“重剑”。二者协同工作，为大数据分析提供从基础计算到高级数据处理的全流程支持。本文将系统梳理Numpy和Pandas的核心知识点，助力学习者构建完整的技术框架。
一、Numpy：大数据的“数值计算引擎”
Numpy的核心是多维数组（ndarray），它是实现高效数值计算的性能基石，围绕数组展开的创建、操作、运算等功能，构成了Numpy的核心体系。
（一）数组操作：从创建到索引的全流程
- 数组创建
数组创建是使用Numpy的第一步，除了从基础数据结构转换，还可生成各类特殊用途的数组，满足不同计算场景需求。
①从基础结构创建：直接将Python列表、元组转换为ndarray数组，可指定数据类型确保计算效率。
点击查看代码
import numpy as np
# 从列表创建1维数组
arr1d = np.array([1, 2, 3, 4], dtype=np.int32)
# 从嵌套列表创建2维数组
arr2d = np.array([[1, 2], [3, 4]], dtype=np.float64)
②生成特殊数组：针对全0、全1、等差序列等常见场景，提供专用函数快速创建。
点击查看代码
# 生成3行4列全0数组（默认float64类型）
zeros_arr = np.zeros((3, 4))
# 生成2行5列全1数组（指定int32类型）
ones_arr = np.ones((2, 5), dtype=np.int32)
# 生成[0,10)区间、步长为2的等差数组
arange_arr = np.arange(0, 10, 2) # 结果：[0 2 4 6 8]
# 生成[0,10]区间内5个等间隔数值的数组
linspace_arr = np.linspace(0, 10, 5) # 结果：[0. 2.5 5. 7.5 10.]
# 生成4行4列随机值数组（仅分配内存，元素值随机）
empty_arr = np.empty((4, 4))
- 数组核心属性
通过数组属性可快速了解数组的“身份信息”，为后续操作提供基础判断，常用属性如下：
属性：说明
ndarray.ndim ：数组维度个数（轴数）。(1维数组返回1，2维数组返回2 )
ndarray.shape ：数组各维度大小，以元组形式呈现。(如3行4列数组返回 (3, 4) )
ndarray.size ：数组元素总个数，等于 shape 属性元组元素的乘积。(如3行4列数组返回12 )
ndarray.dtype ：数组元素的数据类型。(如 int32 、 float64 ，可通过 dtype.name 查看类型名 )
ndarray.itemsize ：单个元素的字节大小。(如 float64 类型元素返回8（64bit/8))
点击查看代码
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(f"维度：{arr.ndim}") # 输出：维度：2
print(f"形状：{arr.shape}") # 输出：形状：(2, 3)
print(f"元素总数：{arr.size}") # 输出：元素总数：6
print(f"数据类型：{arr.dtype}") # 输出：数据类型：int64（64位系统默认）
print(f"单个元素字节数：{arr.itemsize}") # 输出：单个元素字节数：8
- 形状操作
在不改变数组元素值的前提下，调整数组形状以适配不同计算需求，是数据“重塑”的核心操作。
①reshape()：将数组转换为指定形状，需保证新形状的元素总数与原数组一致。
点击查看代码
arr = np.arange(12) # 1维数组，共12个元素
# 转换为3行4列的2维数组
reshaped_arr = arr.reshape(3, 4)
点击查看代码
flattened_arr = reshaped_arr.ravel() # 展平为1维数组
点击查看代码
arr.shape = (4, 3) # 原数组变为4行3列
- 元素访问与索引
灵活的索引方式是精准提取数据的关键，Numpy支持切片、整数索引、布尔索引、花式索引等多种方式。
①切片索引：类似Python列表切片，通过 [start🔚step] 格式选取连续元素，适用于1维、2维及更高维数组。
点击查看代码
arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 取前2行，第2列及以后元素（行：0-1，列：1-2）
slice_arr = arr2d[:2, 1:] # 结果：[[2 3],[5 6]]
点击查看代码
# 取(0,2)和(2,0)位置的元素（行索引[0,2]，列索引[2,0]）
index_arr = arr2d[[0, 2], [2, 0]] # 结果：[3 7]
点击查看代码
# 筛选数组中大于5的元素
bool_arr = arr2d[arr2d > 5] # 结果：[6 7 8 9]
点击查看代码
demo_arr = np.empty((4, 4))
for i in range(4):demo_arr[i] = np.arange(i, i + 4) # 生成4行4列数组
# 选取第0行和第2行
row_fancy = demo_arr[[0, 2]]
# 选取(1,1)和(3,2)位置的元素
elem_fancy = demo_arr[[1, 3], [1, 2]]
- 数组转置与轴对称
数组转置是线性代数和数据重组的常用操作，Numpy提供多种方式实现维度调整。
①T属性：直接对数组进行转置，交换数组的行和列，适用于2维数组。
点击查看代码
arr = np.array([[1, 2], [3, 4]])
transposed_arr = arr.T # 结果：[[1 3],[2 4]]
点击查看代码
# 生成3维数组（shape：(2,3,4)）
arr3d = np.arange(24).reshape(2, 3, 4)
# 交换0轴和1轴（新shape：(3,2,4)）
transposed_3d = arr3d.transpose(1, 0, 2)
点击查看代码
# 交换1轴和2轴（新shape：(2,4,3)）
swapped_arr = arr3d.swapaxes(1, 2)
- 数据类型操作
明确数据类型可节省内存、提升计算效率，Numpy支持创建时指定类型和后续类型转换。
①创建时指定类型：通过 dtype 参数指定数据类型，如 int32 、 float64 等。
点击查看代码
# 创建int32类型的数组
int_arr = np.array([1, 2, 3], dtype=np.int32)
点击查看代码
# 将int32类型转换为float64类型
float_arr = int_arr.astype(np.float64)
- 广播机制
广播机制是Numpy实现“向量化计算”的核心，它能自动扩展维度不同的数组，使二者形状匹配后进行元素级运算，避免循环，提升效率。
广播规则：满足以下任一条件即可触发广播：
1. 两个数组的某一维度长度相等；
2. 其中一个数组为1维数组。
例：2行3列数组与1行3列数组相加，1行3列数组自动扩展为2行3列，再进行元素级加法。
点击查看代码
arr1 = np.array([[1, 2, 3], [4, 5, 6]]) # shape：(2,3)
arr2 = np.array([10, 20, 30]) # shape：(1,3)
result = arr1 + arr2 # 广播后arr2变为[[10,20,30],[10,20,30]]，结果：[[11,22,33],[14,25,36]]
（二）数学运算：大数据计算的“火力网”
Numpy的数学运算覆盖基础算术、通用函数、线性代数、统计运算等，是实现数值计算的核心能力。
- 基础算术运算
支持元素级的加减乘除、幂运算等，运算规则为对应位置元素进行计算，返回新数组。
点击查看代码
arr_a = np.array([[1, 2], [3, 4]])
arr_b = np.array([[5, 6], [7, 8]])
# 元素级加法
add_result = arr_a + arr_b # 结果：[[6 8],[10 12]]
# 元素级减法
sub_result = arr_a - arr_b # 结果：[[-4 -4],[-4 -4]]
# 元素级乘法（非矩阵点乘）
mul_result = arr_a * arr_b # 结果：[[5 12],[21 32]]
# 元素级除法
div_result = arr_a / arr_b # 结果：[[0.2 0.333...],[0.428... 0.5]]
# 幂运算（每个元素的2次方）
pow_result = arr_a ** 2 # 结果：[[1 4],[9 16]]
- 通用函数（ufunc）
通用函数是针对ndarray的元素级运算函数，分为一元函数（接收1个数组）和二元函数（接收2个数组），运算效率远高于Python循环。
①一元通用函数：
函数：说明
np.abs() ：计算元素的绝对值
np.sqrt() ：计算元素的平方根（仅对非负数有效）
np.square() ：计算元素的平方
np.exp() ：计算元素的指数（e的x次方）
np.log() ：计算元素的自然对数（ln(x)）， np.log10() 为以10为底的对数
np.ceil() ：计算元素的上取整（大于等于该值的最小整数）
np.floor() ：计算元素的下取整（小于等于该值的最大整数）
np.isnan() ：返回布尔数组，标记哪些元素是NaN（缺失值）
点击查看代码
arr = np.array([-2, 4, -9, np.nan])
print(np.abs(arr)) # 结果：[2. 4. 9. nan]
print(np.sqrt(np.abs(arr))) # 结果：[1.414... 2. 3. nan]
print(np.ceil(arr[:3])) # 结果：[-2. 4. -9.]
print(np.isnan(arr)) # 结果：[False False False True]
点击查看代码
arr1 = np.array([1, 3, 5])
arr2 = np.array([2, 2, 6])
print(np.maximum(arr1, arr2)) # 结果：[2 3 6]
print(np.greater(arr1, arr2)) # 结果：[False True False]
print(np.logical_and(arr1>1, arr2<6)) # 结果：[False True False]
- 线性代数运算
Numpy的 numpy.linalg 模块提供了矩阵点乘、求逆、行列式、特征值等线性代数核心操作，是建模和数据分析的基础。
函数：说明
np.dot() ：矩阵点乘（或向量内积），要求前一个矩阵的列数等于后一个矩阵的行数
np.linalg.inv() ：计算可逆方阵的逆矩阵
np.linalg.det() ：计算方阵的行列式
np.linalg.diag() ：提取方阵的对角线元素，或把1维数组转换为对角方阵
np.trace() ：计算方阵对角线元素的和（迹）
np.linalg.eig() ：计算方阵的特征值和特征向量
点击查看代码
# 矩阵点乘
mat_a = np.array([[1, 2, 3], [4, 5, 6]]) # shape：(2,3)
mat_b = np.array([[1, 2], [3, 4], [5, 6]]) # shape：(3,2)
dot_result = np.dot(mat_a, mat_b) # 结果：[[22 28],[49 64]]# 求逆矩阵与行列式
inv_mat = np.array([[1, 2], [3, 4]])
inv_result = np.linalg.inv(inv_mat) # 逆矩阵：[[-2. 1.],[1.5 -0.5]]
det_result = np.linalg.det(inv_mat) # 行列式：-2.0# 提取对角线与迹
diag_mat = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
diag_elements = np.linalg.diag(diag_mat) # 对角线元素：[1 5 9]
trace_result = np.trace(diag_mat) # 迹：15
- 随机数模块（numpy.random）
随机数生成是模拟、抽样等场景的基础，Numpy的 random 模块提供了比Python原生 random 更丰富的功能，支持多种概率分布的随机数生成。
①常用随机数函数：
函数：说明
np.random.rand() ：生成[0,1)区间内的均匀分布随机数，参数为数组形状
np.random.randn() ：生成标准正态分布（均值0，标准差1）的随机数，参数为数组形状
np.random.randint(low, high, size) ：生成[low, high)区间内的整数随机数， size 为数组形状
np.random.seed(seed) ：设置随机数种子，保证随机数可重复（相同种子生成相同序列）
点击查看代码
# 生成3行3列的[0,1)均匀分布随机数
rand_arr = np.random.rand(3, 3)# 生成2行4列的标准正态分布随机数
randn_arr = np.random.randn(2, 4)# 生成[0,10)区间内的5个整数随机数
randint_arr = np.random.randint(0, 10, size=5)# 设置种子，保证随机数可重复
np.random.seed(10)
print(np.random.rand(2)) # 结果：[0.77132064 0.02075195]
np.random.seed(10)
print(np.random.rand(2)) # 结果与上一次相同：[0.77132064 0.02075195]
- 数组统计运算
统计运算用于快速提取数组的数值特征，如总和、均值、最值、累计和等，是数据分析的基础操作。
函数：说明
np.sum() ：计算数组元素的总和，可通过 axis 指定按行（ axis=1 ）或按列（ axis=0 ）计算
np.mean() ：计算数组元素的算术均值，支持 axis 参数
np.min() / np.max() ：计算数组元素的最小值/最大值，支持 axis 参数
np.argmin() / np.argmax() ：返回最小值/最大值的索引，支持 axis 参数
np.cumsum() ：计算元素的累计和，返回与原数组形状相同的数组
np.cumprod() ：计算元素的累计积，返回与原数组形状相同的数组
np.all() ：判断数组所有元素是否满足条件，返回 True 或 False
np.any() ：判断数组是否存在满足条件的元素，返回 True 或 False
点击查看代码
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 按行计算均值，按列计算最大值
row_mean = arr.mean(axis=1) # 结果：[2. 5. 8.]
col_max = arr.max(axis=0) # 结果：[7 8 9]
# 最小值索引（全局）和最大值索引（按行）
min_idx = arr.argmin() # 结果：0（对应元素1）
row_max_idx = arr.argmax(axis=1) # 结果：[2 2 2]
# 累计和与累计积（按行）
cumsum_row = arr.cumsum(axis=1) # 结果：[[1 3 6],[4 9 15],[7 15 24]]
# 条件判断：是否所有元素大于0，是否存在元素大于8
all_gt0 = np.all(arr > 0) # 结果：True
any_gt8 = np.any(arr > 8) # 结果：True（元素9）
- 条件逻辑与数组排序
①条件逻辑运算：使用 np.where() 函数实现三元表达式（ x if condition else y ）的矢量化操作，避免循环，效率更高。
点击查看代码
arr_x = np.array([1, 5, 7])
arr_y = np.array([2, 6, 8])
condition = np.array([True, False, True])
# 条件为True取arr_x元素，False取arr_y元素
where_result = np.where(condition, arr_x, arr_y) # 结果：[1 6 7]
点击查看代码
sort_arr = np.array([[6, 2, 7], [3, 6, 2], [4, 3, 2]])
# 按行排序（默认axis=-1）
sort_row = sort_arr.sort() # 结果：[[2 6 7],[2 3 6],[2 3 4]]
# 按列排序（axis=0）
sort_col = sort_arr.sort(axis=0) # 结果：[[2 3 2],[2 3 6],[4 6 7]]
点击查看代码
unique_arr = np.array([12, 11, 34, 23, 12, 8, 11])
unique_result = np.unique(unique_arr) # 结果：[8 11 12 23 34]
二、Pandas：大数据的“数据管家”
Pandas基于Numpy构建，核心数据结构为Series（一维）和DataFrame（二维），提供数据清洗、筛选、分组、统计等全流程数据管理功能，是数据分析的“一站式工具”。
（一）Series：一维数据的“精致容器”
Series是带索引的一维数组，可看作“强化版的Numpy数组”，除了存储数据，还关联了标签（索引），支持更灵活的数据访问。
- Series创建
可从列表、字典、Numpy数组等多种数据源创建，支持自定义索引。
点击查看代码
import pandas as pd
import numpy as np
# 从列表创建，自定义索引（索引与数据长度需一致）
s1 = pd.Series([88, 95, 76], index=['数学', '语文', '英语'])
# 从字典创建（字典的键作为索引，值作为数据）
score_dict = {'数学': 88, '语文': 95, '英语': 76}
s2 = pd.Series(score_dict)
# 从Numpy数组创建
np_arr = np.array([88, 95, 76])
s3 = pd.Series(np_arr, index=['数学', '语文', '英语'])
- Series核心属性
通过属性可快速获取Series的结构信息，常用属性如下：
属性 说明
Series.index Series的索引（标签），可通过 tolist() 转换为列表
Series.values Series的数据，返回Numpy数组
Series.dtype 数据类型，如 int64 、 object
Series.shape 数据形状，一维数组返回 (n,) ， n 为数据长度
Series.size 数据元素总个数
点击查看代码
print(s1.index) # 输出：Index(['数学', '语文', '英语'], dtype='object')
print(s1.values) # 输出：[88 95 76]
print(s1.dtype) # 输出：int64
print(s1.shape) # 输出：(3,)
print(s1.size) # 输出：3
- Series元素操作
包括数据访问、修改、统计计算等，支持按索引或位置访问。
①数据访问：
按索引访问：通过 [索引名] 或 loc[索引名] 获取数据。
按位置访问：通过 iloc[位置索引] 获取数据（位置从0开始）。
点击查看代码
# 按索引访问
print(s1['语文']) # 输出：95
print(s1.loc['英语'])# 输出：76
# 按位置访问
print(s1.iloc[0]) # 输出：88（第0个位置，对应“数学”）
点击查看代码
s1['数学'] = 90 # 按索引修改
s1.iloc[2] = 80 # 按位置修改（第2个位置，对应“英语”）
点击查看代码
print(s1.mean()) # 输出：(90+95+80)/3 ≈ 88.333
print(s1.median()) # 输出：90.0
print(s1.max()) # 输出：95
print(s1.min()) # 输出：80
print(s1.describe()) # 输出完整统计信息（计数、均值、标准差、四分位数、最值）
（二）DataFrame：二维数据的“豪华表格”
DataFrame是Pandas的核心结构，可看作“带列名和行索引的二维数组集合”，每列可视为一个Series，支持类似Excel表格的灵活操作，是大数据表的“标准格式”。
- DataFrame创建
可从字典、列表、Numpy数组、外部文件（CSV、Excel）等多种方式创建，满足不同数据导入场景。
①从字典创建：字典的键作为列名，值（列表或数组）作为列数据，行索引默认从0开始。
点击查看代码
data = {'姓名': ['张三', '李四', '王五'],'班级': ['23大数据1班', '23大数据1班', '23大数据2班'],'成绩': [85, np.nan, 92] # np.nan表示缺失值
}
df = pd.DataFrame(data)
点击查看代码
np_data = np.array([['张三', '23大数据1班', 85], ['李四', '23大数据1班', np.nan], ['王五', '23大数据2班', 92]])
df_np = pd.DataFrame(np_data, columns=['姓名', '班级', '成绩'])
# 注意：从数组创建时，数据类型可能为object，需手动转换（如成绩列转为float）
df_np['成绩'] = df_np['成绩'].astype(float)
点击查看代码
# 从CSV文件读取（需指定文件路径，默认逗号分隔）
df_csv = pd.read_csv('student_data.csv')# 从Excel文件读取（需安装openpyxl库，指定工作表）
df_excel = pd.read_excel('student_data.xlsx', sheet_name='Sheet1')# 从HTML表格读取（返回包含多个DataFrame的列表，需指定匹配条件）
df_html = pd.read_html('student_table.html', match='学生信息')[0]
- DataFrame核心属性与结构查看
快速了解DataFrame的“骨架”，包括行索引、列名、数据类型、缺失值等信息。
属性/方法 说明
DataFrame.index 行索引（索引对象）
DataFrame.columns 列名（索引对象）
DataFrame.values 数据，返回Numpy数组
DataFrame.dtypes 各列的数据类型
DataFrame.shape 数据形状，返回 (行数, 列数)
DataFrame.size 数据元素总个数（行数×列数）
DataFrame.head(n) 查看前 n 行数据，默认 n=5
DataFrame.tail(n) 查看后 n 行数据，默认 n=5
DataFrame.info() 查看数据概览（行数、列数、各列非空值数量、数据类型）
DataFrame.describe() 查看数值列的统计信息（计数、均值、标准差、四分位数、最值）
点击查看代码
print(df.index) # 输出：RangeIndex(start=0, stop=3, step=1)
print(df.columns) # 输出：Index(['姓名', '班级', '成绩'], dtype='object')
print(df.dtypes) # 输出：姓名 object；班级 object；成绩 float64
print(df.shape) # 输出：(3, 3)
print(df.head(2)) # 输出前2行数据
print(df.info()) # 输出数据概览（如“成绩”列有1个非空值）
print(df.describe()) # 输出“成绩”列的统计信息（均值、标准差等）
- 索引与列管理
灵活调整行索引和列，包括设置索引、重命名列、新增/删除列等，适配不同分析需求。
①设置行索引：使用 set_index() 方法将某一列设为行索引， inplace=True 表示直接修改原DataFrame。
点击查看代码
# 将“姓名”列设为行索引
df.set_index('姓名', inplace=True)
点击查看代码
# 重置行索引，保留原索引（“姓名”列）
df.reset_index(inplace=True)
点击查看代码
# 将“成绩”列重命名为“最终成绩”
df.rename(columns={'成绩': '最终成绩'}, inplace=True)
点击查看代码
# 新增“排名”列
df['排名'] = [2, 3, 1]
# 新增“是否及格”列（基于“最终成绩”判断）
df['是否及格'] = df['最终成绩'] >= 60 # 布尔值列
点击查看代码
# 删除“班级”列
df.drop('班级', axis=1, inplace=True)
- 数据清洗
数据清洗是数据分析的前置环节，主要处理缺失值、重复值、异常值，确保数据质量。
①处理缺失值：
- 查看缺失值：使用 isnull() 方法查看缺失值（ True 表示缺失）， sum() 统计每列缺失值数量。
- 填充缺失值：使用 fillna() 方法填充缺失值，如用均值、中位数或指定值填充。
- 删除缺失值：使用 dropna() 方法删除包含缺失值的行或列。
点击查看代码
# 查看每列缺失值数量
print(df['最终成绩'].isnull().sum())
# 用“最终成绩”列的均值填充缺失值
df['最终成绩'].fillna(df['最终成绩'].mean(), inplace=True)
# 删除包含缺失值的行（默认axis=0）
df.dropna(inplace=True)
点击查看代码
# 查看重复行数量
print(df.duplicated().sum())
# 删除重复行，保留第一次出现的行
df.drop_duplicates(inplace=True)
点击查看代码
# 将“最终成绩”列中小于0的值设为0，大于100的值设为100
df['最终成绩'] = df['最终成绩'].apply(lambda x: 0 if x < 0 else (100 if x > 100 else x))
- 数据筛选与查询
按条件提取目标数据，支持单条件、多条件筛选，以及按列选择数据。
①按列选择：直接通过列名选择单列或多列（多列需传入列名列表）。
点击查看代码
# 选择单列（返回Series）
name_col = df['姓名']
# 选择多列（返回DataFrame）
score_rank_col = df[['姓名', '最终成绩', '排名']]
点击查看代码
# 单条件：筛选“最终成绩”大于90的行
high_score = df[df['最终成绩'] > 90]
# 多条件：筛选“最终成绩”大于85且“排名”小于3的行
filtered = df[(df['最终成绩'] > 85) & (df['排名'] < 3)]
点击查看代码
# loc筛选：行索引为“张三”，列名为“最终成绩”“排名”
zhang_score = df.loc['张三', ['最终成绩', '排名']]
# iloc筛选：第0行到第1行（不包含第2行），第1列到第2列（不包含第3列）
row_col_slice = df.iloc[0:2, 1:3]
- 数据排序
按值或索引排序，支持多列排序，通过 ascending 参数指定升序（ True ）或降序（ False ）。
①按值排序：使用 sort_values() 方法， by 参数指定排序的列（多列排序传入列名列表）。
点击查看代码
# 按“最终成绩”降序排序
sorted_by_score = df.sort_values(by='最终成绩', ascending=False)
# 多列排序：先按“班级”升序，再按“最终成绩”降序
df['班级'] = ['23大数据1班', '23大数据1班', '23大数据2班'] # 恢复班级列
sorted_by_multi = df.sort_values(by=['班级', '最终成绩'], ascending=[True, False])
点击查看代码
# 按行索引升序排序（默认axis=0）
sorted_by_index = df.sort_index()
# 按列索引降序排序（axis=1）
sorted_by_col_index = df.sort_index(axis=1, ascending=False)
- 分组聚合（Groupby）
按类别分组后进行聚合分析，是“维度拆解”数据的核心操作，支持单组分组、多组分组及多指标聚合。
①单组分组+单指标聚合：按某一列分组，对另一列计算聚合指标（如均值、最大值）。
点击查看代码
# 按“班级”分组，计算“最终成绩”的均值、最大值、最小值
grouped_single = df.groupby('班级')['最终成绩'].agg(['mean', 'max', 'min'])
点击查看代码
# 新增“性别”列
df['性别'] = ['男', '女', '男']
# 按“班级”和“性别”分组，对“最终成绩”计算均值，对“排名”计算最小值
grouped_multi = df.groupby(['班级', '性别']).agg({'最终成绩': 'mean','排名': 'min'
})
点击查看代码
# 迭代“班级”分组结果
for group_name, group_data in df.groupby('班级'):print(f"班级：{group_name}")print(f"该班数据：\n{group_data}\n")
- 算术运算与数据对齐
Pandas执行算术运算时，会先按索引（行索引和列索引）对齐，未对齐的位置用 NaN 填充；也可通过 fill_value 参数指定填充值，避免 NaN 。
①Series算术运算：按行索引对齐，未对齐位置填充 NaN 。
点击查看代码
s_a = pd.Series([10, 20, 30], index=['a', 'b', 'c'])
s_b = pd.Series([5, 15, 25], index=['b', 'c', 'd'])
# 加法运算（未对齐的“a”“d”位置填充NaN）
s_add = s_a + s_b # 结果：a:NaN, b:25, c:45, d:NaN
# 加法运算，用0填充未对齐位置
s_add_fill = s_a.add(s_b, fill_value=0) # 结果：a:10, b:25, c:45, d:25
点击查看代码
df_a = pd.DataFrame({'A': [1, 2], 'B': [3, 4]}, index=['x', 'y'])
df_b = pd.DataFrame({'B': [5, 6], 'C': [7, 8]}, index=['y', 'z'])
# 加法运算（未对齐的位置填充NaN）
df_add = df_a + df_b
# 结果：
# A B C
# x NaN NaN NaN
# y NaN 9 NaN
# z NaN NaN 8
# 加法运算，用0填充未对齐位置
df_add_fill = df_a.add(df_b, fill_value=0)
- 层次化索引
层次化索引（MultiIndex）是在单个轴（行或列）上设置多层索引，用于处理多维数据的扁平化表示，支持更灵活的分组和筛选。
①创建层次化索引Series：通过嵌套列表指定多层索引。
点击查看代码
# 外层索引为“省份”，内层索引为“城市”
multi_ser = pd.Series([15848, 13472, 12073.8, 7813, 7446, 6444, 15230, 8269],index=[['河北省', '河北省', '河北省', '河北省', '河南省', '河南省', '河南省', '河南省'],['石家庄市', '唐山市', '邯郸市', '秦皇岛市', '郑州市', '开封市', '洛阳市', '新乡市']]
)
# 设置索引名称
multi_ser.index.names = ['省份', '城市']
点击查看代码
# 用from_tuples创建多层行索引
index_tuples = [('河北省', '石家庄市'), ('河北省', '唐山市'), ('河南省', '郑州市')]
multi_index = pd.MultiIndex.from_tuples(index_tuples, names=['省份', '城市'])
# 创建层次化索引DataFrame
multi_df = pd.DataFrame({'面积': [15848, 13472, 7446], '人口': [1123, 771, 988]},index=multi_index
)
点击查看代码
# 筛选“河北省”的所有城市数据（外层索引筛选）
hebei_data = multi_ser['河北省']
# 筛选所有省份的“郑州市”数据（内层索引筛选，用“:”表示所有外层索引）
zhengzhou_data = multi_ser[:, '郑州市']
# 交换索引层级（省份和城市互换）
swapped_ser = multi_ser.swaplevel()
# 按外层索引（省份）升序排序
sorted_ser = multi_ser.sort_index(level=0)
- 读写数据操作
Pandas支持读写多种格式的外部文件，是数据导入导出的核心功能，常见格式包括CSV、Excel、HTML、数据库等。
①读写CSV文件：
点击查看代码
# 读取CSV文件（指定编码、分隔符等参数）
df_read_csv = pd.read_csv('student_data.csv',encoding='utf-8', # 编码格式sep=',', # 分隔符header=0 # 第0行作为列名
)
# 写入CSV文件（不保存行索引，指定缺失值填充方式）
df.to_csv('output_data.csv',index=False, # 不保存行索引na_rep='NaN', # 缺失值用“NaN”表示encoding='utf-8'
)
点击查看代码
# 读取Excel文件（指定工作表、列名行）
df_read_excel = pd.read_excel('student_data.xlsx',sheet_name='Sheet1', # 工作表名称header=0, # 第0行作为列名engine='openpyxl' # 引擎（.xlsx文件用openpyxl）
)
# 写入Excel文件（保存到指定工作表，不保存行索引）
with pd.ExcelWriter('output_data.xlsx', engine='openpyxl') as writer:df.to_excel(writer, sheet_name='Output', index=False)
③读取HTML表格：需安装 lxml 库，返回包含多个DataFrame的列表（对应网页中的多个表格）。
点击查看代码
# 读取HTML文件中的表格（匹配包含“学生信息”的表格）
df_list = pd.read_html('student_table.html',match='学生信息', # 匹配表格内容header=0 # 第0行作为列名
)
df_read_html = df_list[0] # 取第一个表格
点击查看代码
from sqlalchemy import create_engine
# 创建MySQL数据库连接（格式：数据库类型+驱动://用户名:密码@主机:端口/数据库名）
engine = create_engine('mysql+mysqlconnector://root:123456@localhost:3306/student_db')
# 读取数据库表（读取“student_info”表）
df_read_db = pd.read_sql_table('student_info', con=engine)
# 写入数据库表（若表已存在则追加数据，不保存行索引）
df.to_sql('student_info',con=engine,if_exists='append', # 表存在时追加数据index=False
)
三、Numpy与Pandas的“协同作战”
在实际大数据分析中，Numpy和Pandas并非独立使用，而是常常配合工作，发挥各自优势：Numpy负责高效的数值计算，Pandas负责灵活的数据管理，二者数据格式互通，形成完整的分析流程。
（一）数据格式互通
①Pandas转Numpy：DataFrame或Series的 values 属性可直接返回Numpy数组，用于后续数值计算。
点击查看代码
# Series转Numpy数组
ser = pd.Series([88, 95, 76])
ser_np = ser.values # 结果：array([88, 95, 76])
# DataFrame转Numpy数组
df = pd.DataFrame({'成绩': [88, 95, 76], '排名': [2, 1, 3]})
df_np = df.values # 结果：array([[88, 2],[95, 1],[76, 3]])
点击查看代码
# Numpy数组转Series
np_arr = np.array([88, 95, 76])
ser = pd.Series(np_arr, index=['数学', '语文', '英语'])
# Numpy数组转DataFrame
np_data = np.array([[88, 2], [95, 1], [76, 3]])
df = pd.DataFrame(np_data, columns=['成绩', '排名'], index=['张三', '李四', '王五'])
（二）协同分析示例
以“学生成绩分析”为例，展示Numpy与Pandas的协同工作流程：
1. 用Pandas读取并清洗数据：从CSV文件读取学生成绩数据，处理缺失值和异常值。
点击查看代码
# 读取数据
df = pd.read_csv('student_scores.csv')
# 用均值填充成绩缺失值
df['成绩'] = df['成绩'].fillna(df['成绩'].mean())
# 处理异常值（成绩<0设为0，>100设为100）
df['成绩'] = df['成绩'].apply(lambda x: 0 if x < 0 else (100 if x > 100 else x))
点击查看代码
# 提取成绩的Numpy数组
score_np = df['成绩'].values
# 计算标准差（Numpy的std()函数）
std_score = np.std(score_np)
# 统计各分数段人数（0-60、60-80、80-100）
low = np.sum((score_np >= 0) & (score_np < 60)) # 不及格人数
mid = np.sum((score_np >= 60) & (score_np < 80)) # 中等人数
high = np.sum((score_np >= 80) & (score_np <= 100))# 优秀人数
点击查看代码
# 整理分数段分布结果
result_df = pd.DataFrame({'分数段': ['0-60（不及格）', '60-80（中等）', '80-100（优秀）'],'人数': [low, mid, high],'占比': [f"{low/len(score_np)*100:.2f}%", f"{mid/len(score_np)*100:.2f}%", f"{high/len(score_np)*100:.2f}%"]
})
print(result_df)
四、行业应用：大数据分析中的“双剑实战”
Numpy和Pandas广泛应用于金融、电商、科研、医疗等多个领域，成为解决实际业务问题的核心工具。
（一）金融领域
场景1：股票收益率计算：用Numpy计算股票价格的日收益率、波动率（标准差），用Pandas清洗和管理交易数据（如筛选某时间段的股价）。
点击查看代码
# 用Pandas读取股票数据（日期、收盘价）
stock_df = pd.read_csv('stock_data.csv', parse_dates=['日期'], index_col='日期')
# 用Numpy计算日收益率（(当日收盘价-前一日收盘价)/前一日收盘价）
close_price = stock_df['收盘价'].values
daily_return = np.diff(close_price) / close_price[:-1]
# 用Pandas整理收益率结果
stock_df['日收益率'] = np.append(np.nan, daily_return)
# 筛选2023年的收益率数据
stock_2023 = stock_df[stock_df.index.year == 2023]
点击查看代码
# 用Pandas读取订单数据
order_df = pd.read_csv('order_data.csv')
# 清洗数据：删除重复订单，填充缺失的消费金额（用均值）
order_df.drop_duplicates(subset=['订单号'], inplace=True)
order_df['消费金额'] = order_df['消费金额'].fillna(order_df['消费金额'].mean())
# 提取用户消费金额的Numpy数组，用于聚类
user_spend = order_df.groupby('用户ID')['消费金额'].sum().values
五、学习建议：从入门到精通的路径
掌握Numpy和Pandas需要循序渐进，结合理论学习和实践练习，建议按以下步骤构建知识体系：
（一）基础阶段：夯实Numpy核心
1. 掌握数组操作：重点学习数组的创建、形状调整、索引方式（尤其是切片、布尔索引），理解广播机制的原理和应用场景。
2. 熟练数学运算：掌握基础算术运算、通用函数、线性代数运算，能够用Numpy解决简单的数值计算问题（如统计分析、矩阵运算）。
3. 实践练习：完成基础练习题，如“生成指定形状的数组并计算行均值”“用广播机制实现数组间的运算”。
（二）进阶阶段：精通Pandas数据管理
1. 掌握数据结构：深入理解Series和DataFrame的属性与方法，能够熟练创建、修改、查询数据。
2. 重点突破数据清洗：熟练处理缺失值、重复值、异常值，掌握分组聚合（Groupby）的高级用法（如多组分组、多指标聚合）。
3. 学习数据读写：掌握CSV、Excel、数据库等外部文件的读写方法，能够处理实际业务中的数据导入导出需求。
4. 实践练习：完成综合案例，如“学生成绩数据分析”“电商订单数据清洗与统计”，模拟实际业务场景。
（三）融合阶段：实现Numpy与Pandas协同
1. 掌握数据格式互通：熟练在Numpy数组和Pandas对象之间转换，理解二者的优势互补场景。
2. 解决复杂问题：结合实际项目（如金融数据回测、科研数据分析），运用Numpy进行高效计算，Pandas进行数据管理，形成完整的分析流程。
3. 拓展学习：结合数据可视化库（如Matplotlib、Seaborn），将分析结果以图表形式展示，提升数据分析的完整性和说服力。
Numpy和Pandas作为Python大数据分析的“双剑”，分别在数值计算和数据管理领域发挥着不可替代的作用。掌握二者的核心知识点，不仅能够提升数据处理的效率，更能为后续的机器学习、深度学习等高级技术学习奠定坚实基础。建议在学习过程中注重实践，通过解决实际问题巩固知识，逐步成长为具备高效数据分析能力的从业者。
