数值与科学计算 on 扎塔-Zata

numpy使用教程

Wed, 18 Jun 2025 14:44:27 +0800

NumPy 教程

import numpy as np

# 1. 创建数组
arr1 = np.array([1, 2, 3, 4]) # 一维数组
arr2 = np.array([[1, 2], [3, 4]]) # 二维数组
zeros = np.zeros((2, 3)) # 2x3 零矩阵
ones = np.ones((3, 2)) # 3x2 全一矩阵
arange = np.arange(0, 10, 2) # 范围数组 [0, 2, 4, 6, 8]
linspace = np.linspace(0, 1, 5) # 等间距数组 [0. , 0.25, 0.5 , 0.75, 1. ]
random_arr = np.random.rand(2, 3) # 2x3 随机数组（0到1）

# 2. 数组属性
print(arr2.shape) # 形状 (2, 2)
print(arr2.ndim) # 维度 2
print(arr2.dtype) # 数据类型
print(arr2.size) # 元素总数 4

# 3. 数组操作
print(arr1 + 2) # 元素级加 [3, 4, 5, 6]
print(arr1 * 3) # 元素级乘 [3, 6, 9, 12]
print(arr2.reshape(4,)) # 改变形状 [1, 2, 3, 4]
print(arr2.T) # 转置 [[1, 3], [2, 4]]

# 4. 索引和切片
arr3 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr3[0, 1]) # 访问元素 2
print(arr3[0:2, 1:3]) # 切片 [[2, 3], [5, 6]]
print(arr3[arr3 > 5]) # 布尔索引 [6, 7, 8, 9]
print(arr3[[0, 2], [1, 2]]) # 花式索引 [2, 9]

# 5. 数学和统计函数
print(np.sqrt(arr1)) # 平方根
print(np.sum(arr3)) # 总和 45
print(np.mean(arr3)) # 均值 5.0
print(np.std(arr3)) # 标准差
print(np.max(arr3)) # 最大值 9
print(np.min(arr3, axis=1)) # 每行最小值 [1, 4, 7]

# 6. 线性代数
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
print(A @ B) # 矩阵乘法 [[19, 22], [43, 50]]
print(np.linalg.det(A)) # 行列式 -2.0
print(np.linalg.inv(A)) # 矩阵逆
eigvals, eigvecs = np.linalg.eig(A) # 特征值和特征向量
print(eigvals, eigvecs)

# 7. 广播
arr4 = np.array([1, 2, 3])
arr5 = np.array([[1], [2], [3]])
print(arr4 + arr5) # 广播运算

# 8. 拼接与分割
vstack = np.vstack((A, B)) # 垂直拼接
hstack = np.hstack((A, B)) # 水平拼接
split = np.split(arr3, 3, axis=0) # 沿轴0分成3部分

# 9. 排序与搜索
arr6 = np.array([3, 1, 4, 1, 5])
print(np.sort(arr6)) # 排序 [1, 1, 3, 4, 5]
print(np.argsort(arr6)) # 排序索引 [1, 3, 0, 2, 4]
print(np.argmax(arr6)) # 最大值索引 4
print(np.argmin(arr6)) # 最小值索引 1

# 10. 随机数
np.random.seed(42) # 设置种子
print(np.random.rand(2, 3)) # 均匀分布随机数
print(np.random.randn(2, 3)) # 正态分布随机数
print(np.random.randint(1, 10, size=(2, 3))) # 随机整数
arr7 = np.array([1, 2, 3, 4, 5])
np.random.shuffle(arr7) # 随机打乱
creplace = np.random.choice(arr7, size=3, replace=False) # 随机选择

# 11. 结构化数组
dtype = np.dtype([('name', 'U10'), ('age', 'i4')])
data = np.array([('Alice', 25), ('Bob', 30)], dtype=dtype)
print(data['name']) # ['Alice', 'Bob']

# 12. 高级数学
print(np.cumsum(arr1)) # 累积和 [1, 3, 6, 10]
print(np.cumprod(arr1)) # 累积积 [1, 2, 6, 24]
print(np.fft.fft(arr1)) # 快速傅里叶变换
print(np.gradient(arr1)) # 梯度

# 13. 保存和加载
np.save('array.npy', arr1) # 保存数组
loaded_arr = np.load('array.npy') # 加载数组
np.savetxt('array.txt', arr1, delimiter=',') # 保存为文本

# 14. 内存优化
arr8 = np.array([1, 2, 3], dtype=np.float32) # 指定类型减少内存
arr8 += 10 # 就地操作

2. 创建数组

NumPy 的核心是 ndarray 对象，用于表示多维数组。以下是常见创建方法：

# 一维数组
arr1 = np.array([1, 2, 3, 4])

# 二维数组
arr2 = np.array([[1, 2], [3, 4]])

# 全零数组
zeros = np.zeros((2, 3)) # 2x3 零矩阵

# 全一数组
ones = np.ones((3, 2)) # 3x2 全一矩阵

# 范围数组
arange = np.arange(0, 10, 2) # 从0到10（不含10），步长2

# 等间距数组
linspace = np.linspace(0, 1, 5) # 从0到1，生成5个等间距数

# 随机数组
random_arr = np.random.rand(2, 3) # 2x3 随机数（0到1）

3. 数组属性

查看数组的形状、维度和数据类型：

arr = np.array([[1, 2, 3], [4, 5, 6]])

# 形状
print(arr.shape) # (2, 3)

# 维度
print(arr.ndim) # 2

# 数据类型
print(arr.dtype) # int64（具体取决于系统）

# 元素总数
print(arr.size) # 6

4. 数组操作

NumPy 支持高效的元素级操作和广播机制。

arr = np.array([1, 2, 3, 4])

# 元素级运算
print(arr + 2) # [3, 4, 5, 6]
print(arr * 3) # [3, 6, 9, 12]

# 数组间运算
arr2 = np.array([5, 6, 7, 8])
print(arr + arr2) # [6, 8, 10, 12]

# 改变形状
arr3 = np.array([[1, 2], [3, 4]])
print(arr3.reshape(4,)) # [1, 2, 3, 4]

# 转置
print(arr3.T) # [[1, 3], [2, 4]]

5. 索引和切片

NumPy 数组支持灵活的索引和切片操作。

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 访问元素
print(arr[0, 1]) # 2

# 切片
print(arr[0:2, 1:3]) # [[2, 3], [5, 6]]

# 布尔索引
print(arr[arr > 5]) # [6, 7, 8, 9]

# 花式索引
print(arr[[0, 2], [1, 2]]) # [2, 9]

6. 数学和统计函数

NumPy 提供丰富的数学和统计操作。

arr = np.array([[1, 2, 3], [4, 5, 6]])

# 基本数学函数
print(np.sqrt(arr)) # 平方根
print(np.exp(arr)) # 指数
print(np.sin(arr)) # 正弦

# 统计函数
print(np.sum(arr)) # 总和：21
print(np.mean(arr)) # 均值：3.5
print(np.std(arr)) # 标准差
print(np.max(arr)) # 最大值：6
print(np.min(arr, axis=1)) # 每行最小值：[1, 4]

7. 线性代数

NumPy 支持矩阵运算和线性代数操作。

A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

# 矩阵乘法
print(np.dot(A, B)) # [[19, 22], [43, 50]]

# 矩阵 determinant
print(np.linalg.det(A)) # -2.0

# 矩阵逆
print(np.linalg.inv(A)) # [[-2, 1], [1.5, -0.5]]

# 特征值和特征向量
eigvals, eigvecs = np.linalg.eig(A)
print(eigvals) # 特征值
print(eigvecs) # 特征向量

8. 保存和加载数据

NumPy 支持将数组保存到文件或从文件加载。

arr = np.array([[1, 2, 3], [4, 5, 6]])

# 保存到文件
np.save('array.npy', arr)

# 加载文件
loaded_arr = np.load('array.npy')
print(loaded_arr)

# 保存为文本
np.savetxt('array.txt', arr, delimiter=',')

9. 性能优化提示

使用 NumPy 的向量化操作，避免 Python 循环。
预分配数组大小，避免动态扩展。
使用 inplace 操作（如 +=）减少内存分配。
选择合适的数据类型（如 float32 而非 float64）以节省内存。

10. 常见问题与调试

形状不匹配：检查 shape 属性，确保广播规则适用。
数据类型问题：使用 astype 转换类型，如 arr.astype(np.float32)。
内存问题：处理大数组时，考虑分块处理或使用 memmap。

好的！下面我将扩展 NumPy 教程，深入介绍更多高级功能和实用技巧，涵盖广播、数组拼接、排序、随机数生成、结构化数组、内存优化以及实际应用场景。每个部分都附上清晰的代码示例，放在代码块中，方便您直接使用。教程将保持简洁但全面，适合进一步学习 NumPy。

1. 广播机制（Broadcasting）

NumPy 的广播机制允许不同形状的数组进行运算，自动扩展维度以匹配。

import numpy as np

# 标量与数组运算
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr + 10) # 每个元素加10
# [[11, 12, 13], [14, 15, 16]]

# 不同形状数组运算
arr1 = np.array([1, 2, 3])
arr2 = np.array([[1], [2], [3]])
print(arr1 + arr2) # 广播后相加
# [[2, 3, 4], [3, 4, 5], [4, 5, 6]]

# 手动广播
arr3 = np.array([1, 2, 3]).reshape(1, 3)
print(arr3 + arr2) # 同上

提示：广播要求维度兼容（维度相同或其中一个为 1）。检查 shape 避免错误。

2. 数组拼接与分割

NumPy 提供多种方法来合并或拆分数组。

# 拼接数组
arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6], [7, 8]])

# 垂直拼接
vstack = np.vstack((arr1, arr2))
print(vstack)
# [[1, 2], [3, 4], [5, 6], [7, 8]]

# 水平拼接
hstack = np.hstack((arr1, arr2))
print(hstack)
# [[1, 2, 5, 6], [3, 4, 7, 8]]

# 沿指定轴拼接
concat = np.concatenate((arr1, arr2), axis=0) # 同 vstack
print(concat)

# 分割数组
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
split = np.split(arr, 2, axis=1) # 沿轴1分成2部分
print(split) # [array([[1, 2], [5, 6]]), array([[3, 4], [7, 8]])]

3. 排序与搜索

NumPy 支持高效的数组排序和元素搜索。

arr = np.array([3, 1, 4, 1, 5, 9, 2])

# 排序
sorted_arr = np.sort(arr)
print(sorted_arr) # [1, 1, 2, 3, 4, 5, 9]

# 获取排序索引
indices = np.argsort(arr)
print(indices) # [1, 3, 6, 0, 2, 4, 5]

# 二维数组按某列排序
arr2d = np.array([[3, 1], [2, 4], [1, 3]])
sorted_by_col0 = arr2d[arr2d[:, 0].argsort()]
print(sorted_by_col0) # [[1, 3], [2, 4], [3, 1]]

# 搜索最大/最小值索引
max_idx = np.argmax(arr)
min_idx = np.argmin(arr)
print(max_idx, min_idx) # 5, 1

4. 随机数生成

NumPy 的 random 模块提供多种随机数生成方法，适合模拟和机器学习。

# 设置随机种子以确保可重复性
np.random.seed(42)

# 均匀分布（0到1）
rand_uniform = np.random.rand(2, 3)
print(rand_uniform)

# 正态分布（均值0，标准差1）
rand_normal = np.random.randn(2, 3)
print(rand_normal)

# 随机整数
rand_int = np.random.randint(low=1, high=10, size=(2, 3))
print(rand_int)

# 随机打乱数组
arr = np.array([1, 2, 3, 4, 5])
np.random.shuffle(arr)
print(arr) # 顺序随机变化

# 随机选择
choices = np.random.choice(arr, size=3, replace=False)
print(choices) # 从arr中随机选3个数

5. 结构化数组

NumPy 支持结构化数组，类似数据库表，适合存储异构数据。

# 定义结构化数据类型
dtype = np.dtype([('name', 'U10'), ('age', 'i4'), ('score', 'f4')])

# 创建结构化数组
data = np.array([('Alice', 25, 85.5), ('Bob', 30, 90.0)], dtype=dtype)
print(data)
# [('Alice', 25, 85.5) ('Bob', 30, 90. )]

# 访问字段
print(data['name']) # ['Alice', 'Bob']
print(data[0]['score']) # 85.5

6. 高级数学运算

NumPy 提供丰富的数学函数，适合科学计算。

arr = np.array([1, 2, 3, 4])

# 累积和
cumsum = np.cumsum(arr)
print(cumsum) # [1, 3, 6, 10]

# 累积积
cumprod = np.cumprod(arr)
print(cumprod) # [1, 2, 6, 24]

# 快速傅里叶变换 (FFT)
fft = np.fft.fft(arr)
print(fft)

# 梯度计算
gradient = np.gradient(arr)
print(gradient) # [1., 1., 1., 1.]（均匀间隔）

7. 内存优化与大数组处理

处理大数组时，NumPy 提供内存高效的工具。

# 使用 memmap 处理大文件
arr = np.memmap('large_array.dat', dtype='float32', mode='w+', shape=(10000, 10000))
arr[:] = np.random.rand(10000, 10000)
print(arr.shape) # (10000, 10000)

# 指定数据类型减少内存
arr_float32 = np.array([1, 2, 3], dtype=np.float32)
print(arr_float32.nbytes) # 12 字节（比默认 float64 小）

# 就地操作
arr = np.array([1, 2, 3])
arr += 10 # 就地加10，节省内存
print(arr) # [11, 12, 13]

8. 实际应用示例：数据分析

以下是一个简单的数据分析示例，展示 NumPy 的实际应用。

# 模拟数据集：1000 个学生的成绩
np.random.seed(42)
scores = np.random.normal(loc=75, scale=10, size=1000)

# 计算统计指标
mean_score = np.mean(scores)
std_score = np.std(scores)
print(f"平均分: {mean_score:.2f}, 标准差: {std_score:.2f}")

# 筛选优秀学生（成绩 > 85）
excellent = scores[scores > 85]
print(f"优秀学生人数: {len(excellent)}")

# 分组统计（按分数段）
bins = np.array([0, 60, 70, 80, 90, 100])
hist, bin_edges = np.histogram(scores, bins=bins)
print("分数分布:", hist) # 每个区间的学生人数

9. 与 Pandas 结合

NumPy 是 Pandas 的底层引擎，结合使用非常常见。

import pandas as pd

# NumPy 数组转为 DataFrame
arr = np.array([[1, 2], [3, 4], [5, 6]])
df = pd.DataFrame(arr, columns=['A', 'B'])
print(df)

# DataFrame 转为 NumPy 数组
np_arr = df.to_numpy()
print(np_arr)

10. 调试与性能提升

调试：使用 np.seterr(all='raise') 捕获浮点错误。
性能：使用 @ 运算符进行矩阵乘法，替代 np.dot 以提高可读性。
向量化：避免 for 循环，使用 NumPy 的内置函数。
并行化：对于超大数组，考虑结合 numba 或 multiprocessing。

# 矩阵乘法简写
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
print(A @ B) # [[19, 22], [43, 50]]

# 错误捕获
np.seterr(all='raise')
try:
 np.array([1]) / 0
except FloatingPointError:
 print("捕获到除零错误")

pandas使用教程

Tue, 13 May 2025 11:12:26 +0800

Pandas 使用教程

Pandas 是 Python 中一个强大的数据分析和处理库。它提供了高性能、易于使用的数据结构和数据分析工具。本教程将介绍 Pandas 的基本概念和常用操作。

1. 安装 Pandas

如果你还没有安装 Pandas，可以使用 pip 进行安装：

pip install pandas

2. Pandas 的核心数据结构

Pandas 主要有两种核心数据结构：Series 和 DataFrame。

2.1 Series

Series 是一种一维的、类似数组的对象，能够保存任何数据类型（整数、字符串、浮点数、Python 对象等）。它由一组数据以及一组与之相关的数据标签（即索引）组成。

创建 Series

import pandas as pd
import numpy as np # 通常与 pandas 一起使用

# 从列表创建 Series
data_list = [10, 20, 30, 40, 50]
s1 = pd.Series(data_list)
print("从列表创建的 Series:")
print(s1)
print("-" * 30)

# 指定索引
index_list = ['a', 'b', 'c', 'd', 'e']
s2 = pd.Series(data_list, index=index_list)
print("指定索引的 Series:")
print(s2)
print("-" * 30)

# 从字典创建 Series
data_dict = {'x': 100, 'y': 200, 'z': 300}
s3 = pd.Series(data_dict)
print("从字典创建的 Series:")
print(s3)
print("-" * 30)

Series 的属性和方法

# 访问元素
print("访问 s2 中的元素 'c':", s2['c'])
print("访问 s2 中前两个元素:\n", s2[:2])
print("-" * 30)

# 属性
print("s2 的索引:", s2.index)
print("s2 的值:", s2.values)
print("s2 的数据类型:", s2.dtype)
print("s2 的形状:", s2.shape)
print("s2 的大小:", s2.size)
print("-" * 30)

# 常用方法
print("s1 的和:", s1.sum())
print("s1 的平均值:", s1.mean())
print("s1 大于 30 的元素:\n", s1[s1 > 30])
print("-" * 30)

2.2 DataFrame

DataFrame 是一个二维的、表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔值等）。DataFrame 既有行索引也有列索引，可以被看作是由 Series 组成的字典。

创建 DataFrame

# 从字典创建 DataFrame (字典的键是列名，值是列表或 Series)
data_df = {
 '姓名': ['张三', '李四', '王五', '赵六'],
 '年龄': [25, 30, 22, 28],
 '城市': ['北京', '上海', '广州', '深圳']
}
df1 = pd.DataFrame(data_df)
print("从字典创建的 DataFrame:")
print(df1)
print("-" * 30)

# 指定行索引
df2 = pd.DataFrame(data_df, index=['a', 'b', 'c', 'd'])
print("指定行索引的 DataFrame:")
print(df2)
print("-" * 30)

# 从列表的列表创建 DataFrame
data_list_of_lists = [
 ['Alice', 25, 'New York'],
 ['Bob', 30, 'London'],
 ['Charlie', 35, 'Paris']
]
df3 = pd.DataFrame(data_list_of_lists, columns=['Name', 'Age', 'City'])
print("从列表的列表创建的 DataFrame:")
print(df3)
print("-" * 30)

# 从 NumPy ndarray 创建 DataFrame
data_np = np.random.randn(4, 3) # 生成 4x3 的随机数数组
df4 = pd.DataFrame(data_np, columns=['A', 'B', 'C'])
print("从 NumPy ndarray 创建的 DataFrame:")
print(df4)
print("-" * 30)

3. 数据加载与保存

Pandas 可以轻松地从多种文件格式中读取数据，并将数据保存到这些格式中。

3.1 读取数据

# 创建一个示例 CSV 文件 (在实际使用中，你通常会有一个已存在的文件)
csv_data = """id,name,score
1,Alice,85
2,Bob,90
3,Charlie,78
"""
with open("example.csv", "w") as f:
 f.write(csv_data)

# 从 CSV 文件读取数据
df_csv = pd.read_csv('example.csv')
print("从 CSV 文件读取的 DataFrame:")
print(df_csv)
print("-" * 30)

# 读取 Excel 文件 (需要安装 openpyxl 或 xlrd 库: pip install openpyxl xlrd)
# 假设你有一个 example.xlsx 文件
# df_excel = pd.read_excel('example.xlsx', sheet_name='Sheet1')
# print("从 Excel 文件读取的 DataFrame:")
# print(df_excel)
# print("-" * 30)

# 读取 JSON 文件
# json_data = """
# [
# {"id": 1, "name": "David", "score": 92},
# {"id": 2, "name": "Eve", "score": 88}
# ]
# """
# with open("example.json", "w") as f:
# f.write(json_data)
# df_json = pd.read_json('example.json')
# print("从 JSON 文件读取的 DataFrame:")
# print(df_json)
# print("-" * 30)

3.2 保存数据

# 将 DataFrame 保存到 CSV 文件
df1.to_csv('output.csv', index=False) # index=False 表示不将行索引写入文件
print("df1 已保存到 output.csv")
print("-" * 30)

# 将 DataFrame 保存到 Excel 文件
# df1.to_excel('output.xlsx', sheet_name='Data', index=False)
# print("df1 已保存到 output.xlsx")
# print("-" * 30)

# 将 DataFrame 保存到 JSON 文件
# df1.to_json('output.json', orient='records', lines=True) # orient='records' 每行一个 JSON 对象
# print("df1 已保存到 output.json")
# print("-" * 30)

4. 数据查看与选择

4.1 查看数据

print("查看 df1 的前几行 (默认 5 行):")
print(df1.head())
print("-" * 30)

print("查看 df1 的后几行 (默认 5 行):")
print(df1.tail(3)) # 查看后 3 行
print("-" * 30)

print("查看 df1 的索引:")
print(df1.index)
print("-" * 30)

print("查看 df1 的列名:")
print(df1.columns)
print("-" * 30)

print("查看 df1 的数据类型:")
print(df1.dtypes)
print("-" * 30)

print("查看 df1 的形状 (行数, 列数):")
print(df1.shape)
print("-" * 30)

print("获取 df1 的描述性统计信息:")
print(df1.describe(include='all')) # include='all' 包括非数值列
print("-" * 30)

print("获取 df1 的简要信息:")
df1.info()
print("-" * 30)

4.2 选择数据

Pandas 提供了多种选择数据的方式。

选择列

# 选择单列 (返回 Series)
ages = df1['年龄']
print("选择 '年龄' 列:")
print(ages)
print(type(ages))
print("-" * 30)

# 选择多列 (返回 DataFrame)
name_city = df1[['姓名', '城市']]
print("选择 '姓名' 和 '城市' 列:")
print(name_city)
print(type(name_city))
print("-" * 30)

选择行

`loc`: 基于标签的索引

print("使用 df2 (有自定义行索引):")
print(df2)
print("-" * 30)

# 选择单行
row_b = df2.loc['b']
print("选择行 'b':")
print(row_b)
print("-" * 30)

# 选择多行
rows_ac = df2.loc[['a', 'c']]
print("选择行 'a' 和 'c':")
print(rows_ac)
print("-" * 30)

# 选择行和列
name_age_b = df2.loc['b', ['姓名', '年龄']]
print("选择行 'b' 的 '姓名' 和 '年龄':")
print(name_age_b)
print("-" * 30)

# 选择所有行的特定列
all_rows_name_age = df2.loc[:, ['姓名', '年龄']]
print("选择所有行的 '姓名' 和 '年龄':")
print(all_rows_name_age)
print("-" * 30)

`iloc`: 基于整数位置的索引

print("使用 df1 (默认整数行索引):")
print(df1)
print("-" * 30)

# 选择第一行 (位置 0)
row_0 = df1.iloc[0]
print("选择第一行:")
print(row_0)
print("-" * 30)

# 选择前两行 (位置 0 和 1)
rows_01 = df1.iloc[[0, 1]] # 或 df1.iloc[0:2]
print("选择前两行:")
print(rows_01)
print("-" * 30)

# 选择第一行、第一列的元素
element_00 = df1.iloc[0, 0]
print("选择第一行、第一列的元素:", element_00)
print("-" * 30)

# 选择特定行和列
subset_iloc = df1.iloc[[0, 2], [0, 1]] # 第 0, 2 行 和 第 0, 1 列
print("选择特定行和列:")
print(subset_iloc)
print("-" * 30)

条件选择 (布尔索引)

# 选择年龄大于 25 的行
older_than_25 = df1[df1['年龄'] > 25]
print("年龄大于 25 的行:")
print(older_than_25)
print("-" * 30)

# 组合条件 (使用 & 表示 AND, | 表示 OR)
condition = (df1['年龄'] > 25) & (df1['城市'] == '深圳')
filtered_df = df1[condition]
print("年龄大于 25 且城市为深圳的行:")
print(filtered_df)
print("-" * 30)

# 使用 isin() 方法
cities_of_interest = ['北京', '深圳']
df_in_cities = df1[df1['城市'].isin(cities_of_interest)]
print("城市为北京或深圳的行:")
print(df_in_cities)
print("-" * 30)

5. 数据清洗

数据清洗是数据分析中非常重要的一步。

5.1 处理缺失值 (NaN)

# 创建一个包含缺失值的 DataFrame
data_missing = {
 'A': [1, 2, np.nan, 4],
 'B': [5, np.nan, np.nan, 8],
 'C': [9, 10, 11, 12],
 'D': [np.nan, np.nan, np.nan, np.nan]
}
df_missing = pd.DataFrame(data_missing)
print("包含缺失值的 DataFrame:")
print(df_missing)
print("-" * 30)

# 检查缺失值
print("检查每列是否有缺失值:")
print(df_missing.isnull()) # 返回布尔型 DataFrame
print("-" * 30)
print("统计每列缺失值的数量:")
print(df_missing.isnull().sum())
print("-" * 30)

# 删除包含缺失值的行或列
# 删除任何包含 NaN 的行
df_dropped_rows = df_missing.dropna()
print("删除包含 NaN 的行后的 DataFrame:")
print(df_dropped_rows)
print("-" * 30)

# 删除任何包含 NaN 的列
df_dropped_cols = df_missing.dropna(axis=1) # axis=1 表示按列操作
print("删除包含 NaN 的列后的 DataFrame:")
print(df_dropped_cols)
print("-" * 30)

# 删除所有值都为 NaN 的列
df_dropped_all_nan_cols = df_missing.dropna(axis=1, how='all')
print("删除所有值都为 NaN 的列后的 DataFrame:")
print(df_dropped_all_nan_cols)
print("-" * 30)

# 填充缺失值
# 用特定值填充所有 NaN
df_filled_zero = df_missing.fillna(0)
print("用 0 填充所有 NaN 后的 DataFrame:")
print(df_filled_zero)
print("-" * 30)

# 用列的平均值填充 NaN (仅对数值列有效)
df_filled_mean_A = df_missing.copy() # 创建副本以避免修改原始 DataFrame
df_filled_mean_A['A'] = df_filled_mean_A['A'].fillna(df_filled_mean_A['A'].mean())
print("用列 'A' 的平均值填充 NaN 后的 DataFrame:")
print(df_filled_mean_A)
print("-" * 30)

# 使用前一个有效值填充 (向前填充)
df_ffill = df_missing.fillna(method='ffill')
print("向前填充后的 DataFrame:")
print(df_ffill)
print("-" * 30)

# 使用后一个有效值填充 (向后填充)
df_bfill = df_missing.fillna(method='bfill')
print("向后填充后的 DataFrame:")
print(df_bfill)
print("-" * 30)

5.2 处理重复数据

data_duplicates = {
 'col1': ['A', 'B', 'A', 'C', 'B', 'B'],
 'col2': [1, 2, 1, 3, 2, 2]
}
df_duplicates = pd.DataFrame(data_duplicates)
print("包含重复数据的 DataFrame:")
print(df_duplicates)
print("-" * 30)

# 检查重复行
print("检查重复行 (除第一次出现外，其余标记为 True):")
print(df_duplicates.duplicated())
print("-" * 30)

# 删除重复行 (默认保留第一个出现的)
df_no_duplicates = df_duplicates.drop_duplicates()
print("删除重复行后的 DataFrame:")
print(df_no_duplicates)
print("-" * 30)

# 删除重复行 (保留最后一个出现的)
df_no_duplicates_last = df_duplicates.drop_duplicates(keep='last')
print("删除重复行 (保留最后一个) 后的 DataFrame:")
print(df_no_duplicates_last)
print("-" * 30)

# 基于特定列删除重复项
df_no_duplicates_subset = df_duplicates.drop_duplicates(subset=['col1'])
print("基于 'col1' 删除重复项后的 DataFrame:")
print(df_no_duplicates_subset)
print("-" * 30)

5.3 数据类型转换

print("df1 的数据类型:")
print(df1.dtypes)
print("-" * 30)

# 将 '年龄' 列转换为浮点数
df_copy = df1.copy()
df_copy['年龄'] = df_copy['年龄'].astype(float)
print("将 '年龄' 列转换为浮点数后的数据类型:")
print(df_copy.dtypes)
print(df_copy)
print("-" * 30)

# 处理可能出现的错误 (例如，将包含非数字的字符串列转换为数字)
df_error = pd.DataFrame({'vals': ['1', '2', 'apple', '4']})
# df_error['vals'] = df_error['vals'].astype(int) # 这会报错
df_error['vals_numeric'] = pd.to_numeric(df_error['vals'], errors='coerce') # 'coerce' 会将无法转换的值设为 NaT 或 NaN
print("使用 to_numeric 处理转换错误:")
print(df_error)
print("-" * 30)

6. 数据操作

6.1 添加和删除列

# 添加新列
df_copy = df1.copy()
df_copy['职业'] = ['工程师', '医生', '学生', '教师'] # 列表长度需与行数一致
print("添加 '职业' 列后的 DataFrame:")
print(df_copy)
print("-" * 30)

df_copy['工龄'] = 0 # 添加值为常量的列
print("添加 '工龄' 列后的 DataFrame:")
print(df_copy)
print("-" * 30)

# 基于现有列创建新列
df_copy['年龄_加五'] = df_copy['年龄'] + 5
print("添加 '年龄_加五' 列后的 DataFrame:")
print(df_copy)
print("-" * 30)

# 删除列
df_dropped_city = df_copy.drop('城市', axis=1) # axis=1 表示删除列, inplace=True 可以直接修改原 DataFrame
print("删除 '城市' 列后的 DataFrame:")
print(df_dropped_city)
print("-" * 30)

# 删除多列
df_dropped_multi = df_copy.drop(['职业', '工龄'], axis=1)
print("删除 '职业' 和 '工龄' 列后的 DataFrame:")
print(df_dropped_multi)
print("-" * 30)

6.2 应用函数 (apply, map, applymap)

`apply()`

可以作用于行或列。

df_apply = df1[['年龄']].copy() # 只取年龄列，方便演示
print("原始 '年龄' 列:")
print(df_apply)
print("-" * 30)

# 对列应用函数
def square(x):
 return x * x

df_apply['年龄平方_apply_col'] = df_apply['年龄'].apply(square)
print("对 '年龄' 列应用 square 函数:")
print(df_apply)
print("-" * 30)

# 对行应用函数 (通常与 lambda 函数结合)
df_numeric_data = pd.DataFrame(np.random.randn(3, 3), columns=['A', 'B', 'C'])
print("数值型 DataFrame:")
print(df_numeric_data)
df_numeric_data['Row_Sum'] = df_numeric_data.apply(lambda row: row.sum(), axis=1)
print("对行应用求和函数:")
print(df_numeric_data)
print("-" * 30)

`map()`

作用于 Series 的每个元素。

s_map = df1['城市'].copy()
city_mapping = {'北京': 'BJ', '上海': 'SH', '广州': 'GZ', '深圳': 'SZ'}
s_map_transformed = s_map.map(city_mapping)
print("原始 '城市' Series:")
print(s_map)
print("使用 map 转换后的 '城市' Series:")
print(s_map_transformed)
print("-" * 30)

# 如果映射字典中没有某个键，则对应元素会变为 NaN
s_map_partial = pd.Series(['北京', '上海', '成都'])
s_map_partial_transformed = s_map_partial.map(city_mapping)
print("部分映射:")
print(s_map_partial_transformed)
print("-" * 30)

`applymap()`

作用于 DataFrame 的每个元素。

df_applymap_data = df1[['年龄']].copy() # 使用数值列
print("原始 DataFrame (年龄):")
print(df_applymap_data)
df_applymap_transformed = df_applymap_data.applymap(lambda x: x + 10) # DataFrame 中所有元素加 10
print("使用 applymap 将所有元素加 10:")
print(df_applymap_transformed)
print("-" * 30)

6.3 排序

# 按索引排序
df_sorted_index = df2.sort_index(ascending=False) # 按行索引降序
print("按行索引降序排序:")
print(df_sorted_index)
print("-" * 30)

df_sorted_columns = df1.sort_index(axis=1, ascending=True) # 按列名升序
print("按列名升序排序:")
print(df_sorted_columns)
print("-" * 30)

# 按值排序
df_sorted_age = df1.sort_values(by='年龄', ascending=False)
print("按 '年龄' 降序排序:")
print(df_sorted_age)
print("-" * 30)

# 按多列排序
df_sorted_city_age = df1.sort_values(by=['城市', '年龄'], ascending=[True, False])
print("按 '城市'(升序) 和 '年龄'(降序) 排序:")
print(df_sorted_city_age)
print("-" * 30)

7. 分组 (Group By)

分组操作通常涉及以下一个或多个步骤：

分割 (Splitting): 根据某些条件将数据分成组。
应用 (Applying): 对每个组独立应用一个函数。
合并 (Combining): 将结果组合成一个数据结构。

data_sales = {
 'Store': ['A', 'B', 'A', 'B', 'A', 'C', 'B', 'C'],
 'Product': ['Apple', 'Banana', 'Orange', 'Apple', 'Banana', 'Orange', 'Orange', 'Apple'],
 'Sales': [100, 150, 80, 90, 120, 70, 130, 60],
 'Quantity': [10, 15, 8, 9, 12, 7, 13, 6]
}
df_sales = pd.DataFrame(data_sales)
print("销售数据 DataFrame:")
print(df_sales)
print("-" * 30)

# 按 'Store' 分组并计算每家店的总销售额
grouped_by_store_sales = df_sales.groupby('Store')['Sales'].sum()
print("按 'Store' 分组计算总销售额:")
print(grouped_by_store_sales)
print(type(grouped_by_store_sales)) # 返回 Series
print("-" * 30)

# 按 'Store' 分组并计算每家店的平均销售额和总数量
grouped_by_store_agg = df_sales.groupby('Store').agg({'Sales': 'mean', 'Quantity': 'sum'})
print("按 'Store' 分组计算平均销售额和总数量:")
print(grouped_by_store_agg)
print(type(grouped_by_store_agg)) # 返回 DataFrame
print("-" * 30)

# 按多个列分组
grouped_by_store_product = df_sales.groupby(['Store', 'Product'])['Sales'].sum()
print("按 'Store' 和 'Product' 分组计算总销售额:")
print(grouped_by_store_product) # 返回多级索引的 Series
print("-" * 30)

# 分组后迭代
for name, group in df_sales.groupby('Store'):
 print(f"Store: {name}")
 print(group)
 print("-" * 10)
print("-" * 30)

# 分组后应用自定义函数
def top_sales_product(df_group):
 return df_group.sort_values(by='Sales', ascending=False).iloc[0]

top_product_by_store = df_sales.groupby('Store').apply(top_sales_product)
print("每家店销售额最高的产品记录:")
print(top_product_by_store)
print("-" * 30)

8. 合并与连接 (Merge, Join, Concat)

8.1 `concat()`: 拼接

用于沿某个轴将多个 Pandas 对象（Series 或 DataFrame）拼接在一起。

df_c1 = pd.DataFrame({'A': ['A0', 'A1'], 'B': ['B0', 'B1']})
df_c2 = pd.DataFrame({'A': ['A2', 'A3'], 'B': ['B2', 'B3']})
df_c3 = pd.DataFrame({'C': ['C0', 'C1'], 'D': ['D0', 'D1']})

# 沿行拼接 (默认 axis=0)
concatenated_rows = pd.concat([df_c1, df_c2])
print("沿行拼接 df_c1 和 df_c2:")
print(concatenated_rows)
print("-" * 30)

# 沿行拼接，忽略原始索引并重置索引
concatenated_rows_reset_index = pd.concat([df_c1, df_c2], ignore_index=True)
print("沿行拼接并重置索引:")
print(concatenated_rows_reset_index)
print("-" * 30)

# 沿列拼接 (axis=1)
concatenated_cols = pd.concat([df_c1, df_c3], axis=1)
print("沿列拼接 df_c1 和 df_c3:")
print(concatenated_cols)
print("-" * 30)

8.2 `merge()`: 数据库风格的连接

根据一个或多个键将 DataFrame 的行连接起来。

left = pd.DataFrame({
 'key': ['K0', 'K1', 'K2', 'K3'],
 'A': ['A0', 'A1', 'A2', 'A3'],
 'B': ['B0', 'B1', 'B2', 'B3']
})
right = pd.DataFrame({
 'key': ['K0', 'K1', 'K4', 'K5'],
 'C': ['C0', 'C1', 'C2', 'C3'],
 'D': ['D0', 'D1', 'D2', 'D3']
})
print("Left DataFrame:")
print(left)
print("Right DataFrame:")
print(right)
print("-" * 30)

# 内连接 (Inner Join - 默认): 基于 'key' 列的交集
merged_inner = pd.merge(left, right, on='key')
print("内连接结果:")
print(merged_inner)
print("-" * 30)

# 左连接 (Left Join): 使用左边 DataFrame 的所有键
merged_left = pd.merge(left, right, on='key', how='left')
print("左连接结果:")
print(merged_left)
print("-" * 30)

# 右连接 (Right Join): 使用右边 DataFrame 的所有键
merged_right = pd.merge(left, right, on='key', how='right')
print("右连接结果:")
print(merged_right)
print("-" * 30)

# 外连接 (Outer Join): 使用两个 DataFrame 键的并集
merged_outer = pd.merge(left, right, on='key', how='outer')
print("外连接结果:")
print(merged_outer)
print("-" * 30)

# 基于不同列名的键合并
left_diff_key = pd.DataFrame({'lkey': ['K0', 'K1'], 'A': ['A0', 'A1']})
right_diff_key = pd.DataFrame({'rkey': ['K0', 'K1'], 'C': ['C0', 'C1']})
merged_diff_keys = pd.merge(left_diff_key, right_diff_key, left_on='lkey', right_on='rkey')
print("基于不同列名合并:")
print(merged_diff_keys)
print("-" * 30)

8.3 `join()`: 基于索引的连接

join() 方法用于基于索引或指定列将两个 DataFrame 连接起来。默认情况下，它尝试按索引进行左连接。

left_join_df = pd.DataFrame(
 {'A': ['A0', 'A1', 'A2']},
 index=['K0', 'K1', 'K2']
)
right_join_df = pd.DataFrame(
 {'B': ['B0', 'B1', 'B2']},
 index=['K0', 'K1', 'K3'] # K2 不同
)
print("Left Join DataFrame:")
print(left_join_df)
print("Right Join DataFrame:")
print(right_join_df)
print("-" * 30)

# 默认左连接 (基于索引)
joined_df = left_join_df.join(right_join_df)
print("默认左连接结果:")
print(joined_df)
print("-" * 30)

# 外连接 (how='outer')
joined_outer_df = left_join_df.join(right_join_df, how='outer')
print("外连接结果:")
print(joined_outer_df)
print("-" * 30)

# 在列上连接 (需要先将列设置为索引)
left_on_col = pd.DataFrame({
 'key': ['K0', 'K1', 'K2'],
 'A': ['A0', 'A1', 'A2']
})
right_on_col = pd.DataFrame({
 'other_key': ['K0', 'K1', 'K3'],
 'B': ['B0', 'B1', 'B2']
})
joined_on_key = left_on_col.join(right_on_col.set_index('other_key'), on='key')
print("在 'key' 和 'other_key' 列上连接:")
print(joined_on_key)
print("-" * 30)

9. 时间序列数据

Pandas 在处理时间序列数据方面非常强大。

# 创建日期范围
date_rng = pd.date_range(start='2024-01-01', end='2024-01-10', freq='D') # 每天
print("日期范围:")
print(date_rng)
print("-" * 30)

# 创建一个带时间索引的 Series
time_series = pd.Series(np.random.randn(len(date_rng)), index=date_rng)
print("时间序列数据:")
print(time_series)
print("-" * 30)

# 创建一个带时间索引的 DataFrame
df_time = pd.DataFrame({'value': np.random.randint(0, 100, len(date_rng))}, index=date_rng)
df_time['day_of_week'] = df_time.index.day_name()
print("带时间索引的 DataFrame:")
print(df_time)
print("-" * 30)

# 选择特定日期的数据
print("选择 2024-01-05 的数据:")
print(df_time.loc['2024-01-05'])
print("-" * 30)

# 选择日期范围的数据
print("选择 2024-01-03 到 2024-01-07 的数据:")
print(df_time['2024-01-03':'2024-01-07'])
print("-" * 30)

# 重采样 (Resampling) - 例如，按周汇总数据
weekly_sum = df_time['value'].resample('W').sum() # 'W' 表示每周
print("按周汇总的总值:")
print(weekly_sum)
print("-" * 30)

# 移动窗口计算 (Moving Window Calculations)
df_time['rolling_mean_3D'] = df_time['value'].rolling(window=3).mean() # 3 天的移动平均值
print("带 3 天移动平均值的 DataFrame:")
print(df_time)
print("-" * 30)

10. 绘图 (Plotting)

Pandas 可以与 Matplotlib 集成，方便地绘制图表。 (需要安装 matplotlib: pip install matplotlib)

import matplotlib.pyplot as plt

# Series 绘图
ts = pd.Series(np.random.randn(1000), index=pd.date_range('1/1/2020', periods=1000))
ts = ts.cumsum() # 累积和
ts.plot()
plt.title("Random Walk Time Series")
plt.show() # 在脚本中运行时需要此行来显示图形

# DataFrame 绘图
df_plot = pd.DataFrame(np.random.randn(10, 4), columns=['A', 'B', 'C', 'D'])
df_plot.plot(kind='bar') # 柱状图
plt.title("DataFrame Bar Plot")
plt.show()

df_sales.groupby('Store')['Sales'].sum().plot(kind='pie', autopct='%1.1f%%')
plt.title("Sales by Store")
plt.ylabel('') # 隐藏 y 轴标签
plt.show()

这只是 Pandas 功能的冰山一角。Pandas 非常强大，有许多高级功能和用法。建议查阅官方文档以获取更全面的信息：https://pandas.pydata.org/pandas-docs/stable/

使用技巧

不同的写csv文件方法

#################################################
############# csv模块 ##################
#################################################
import csv
# 要写入的数据
data = [
 ['Name', 'Age', 'City'],
 ['John', 30, 'New York'],
 ['Alice', 25, 'Los Angeles'],
 ['Bob', 35, 'Chicago']
]

# 打开CSV文件并写入数据
with open('output.csv', 'w', newline='') as csvfile:
 # 创建一个CSV写入对象
 csv_writer = csv.writer(csvfile)

 # 循环写入每一行数据
 for row in data:
 csv_writer.writerow(row)

print("数据已成功写入到 output.csv 文件中。")


#################################################
############# Pandas ##################
#################################################

import pandas as pd

# 创建一个DataFrame对象，包含要写入的数据
data = {
 'Name': ['John', 'Alice', 'Bob'],
 'Age': [30, 25, 35],
 'City': ['New York', 'Los Angeles', 'Chicago']
}
df = pd.DataFrame(data)

# 将DataFrame写入CSV文件
df.to_csv('output.csv', index=False)

print("数据已成功写入到 output.csv 文件中。")

# 追加写入
new_data = {
 'Name': 'Sarah',
 'Age': 20,
 'City':'toky'
}
df_new = pd.DataFrame(new_data,index=[0])
existing_csv_file = 'output.csv'
# 将新数据追加到现有的CSV文件中
df_new.to_csv(existing_csv_file, mode='a', header=False, index=False)

matplotlib教程-zata——v0.0.0

Sun, 11 May 2025 05:59:00 +0800

参考菜鸟教程

matplotlib中文显示乱码问题


对于 Windows：

plt.rcParams['font.family'] = 'SimHei' # 替换为你选择的字体
在 Windows 系统上，选择 SimHei（黑体）或其他中文字体，并将其设置为 Matplotlib 的默认字体。

对于 Linux：

plt.rcParams['font.family'] = 'WenQuanYi Micro Hei' # 替换为你选择的字体

如果不知道有哪些字体可以，可以先执行以下代码

from matplotlib import pyplot as plt
import matplotlib
a=sorted([f.name for f in matplotlib.font_manager.fontManager.ttflist])

for i in a:
 print(i)

scipy

Thu, 27 Feb 2025 00:00:00 +0000

SCiPY

scipy.interpolate

interp1d

代码

from scipy.interpolate import interp1d
import numpy as np

# 示例数据
x_original = np.array([400, 500, 600, 700]) # 原始波长
y_original = np.array([0.1, 0.3, 0.6, 0.9]) # 对应的测量值
x_new = np.linspace(400, 700, 100) # 新的波长点（目标插值点）

# 创建插值函数
interp_func = interp1d(x_original, y_original, kind='linear', fill_value="extrapolate")

# 使用插值函数计算新点的值
y_new = interp_func(x_new)

# 打印结果
print("原始波长:", x_original)
print("原始测量值:", y_original)
print("插值后的波长:", x_new)
print("插值后的测量值:", y_new)

参数解释

x_original 和 y_original:
- 这是已知的原始数据点，分别表示波长和对应的测量值。
- 它们必须是一维数组，并且长度相同。
kind:
- 指定插值方法，常用选项包括：
  - 'linear'：线性插值（默认）。
  - 'nearest'：最近邻插值。
  - 'quadratic' 或 'cubic'：二次或三次样条插值。
- 根据数据的平滑性和需求选择合适的插值方法。
fill_value:
- 当插值点超出原始数据范围时的处理方式。
- 默认情况下会抛出错误，但可以通过设置 fill_value="extrapolate" 允许外推。
x_new:
- 需要插值到的新点，可以是一个标量或数组。