再见了，Numpy！！
再见了，Numpy！！
本文核心点：15个Numpy的操作汇总！
《机器学习学习&面试题》PDF版本，准备了亮色和暗色
16大块的内容，124个问题的总结！ 文末获取！
Hi，我是Johngo~
今天周日，继续周末，继续愉快！！！
这几天在社群里，听到很多关于数据预处理、数据计算相关的话题。
什么Python方面的，Numpy、Pandas，大数据处理方面的Hive、Spark、Flink等等等等。
所以有两天时间了，想和大家聊聊关于数据处理方面的事情，咱们就从最基础的开始干！
最基础最重要的莫过于：Numpy！！
老规矩：大家伙如果觉得近期文章还不错！欢迎大家点个赞、转个发，让更多的朋友看到。
所有做数据的同学，我估计都逃不过Numpy带给你的超燃能量。
NumPy 在数据分析和机器学习领域扮演着极为重要的角色！！
咱们列举几项：
- 高效的多维数组操作：NumPy提供了一个强大的N维数组对象，它允许用户以高效和直观的方式进行复杂数值计算和数据处理。
- 广泛的数学函数库：NumPy内置了大量的数学函数，包括线性代数运算、傅里叶变换、统计学函数等，这些都是数据分析和机器学习中常用的数学工具。
- 性能优化：NumPy的核心是用C语言编写的，能够提供快速的数组计算和操作。这对于处理大型数据集，尤其是在机器学习和大数据应用中非常重要。
- 内存效率：NumPy的数组结构使用连续的内存块，提高了数据存储和处理的效率。
- 与其他库的集成：NumPy可以与许多其他数据分析和机器学习库（如Pandas、SciPy、Scikit-learn、TensorFlow和PyTorch）无缝集成，形成了Python科学计算的核心。
- 数据预处理：在机器学习中，数据预处理是一个关键步骤，NumPy提供了多种处理数据的工具，如数据筛选、清洗、转换等。
总结，种种原因，NumPy为我们，或者说数据学习者、工作者提供了一个强大、高效且易于使用的工具，使得咱们能够更专注于数据的分析和模型的构建，而不是低级的数值计算。
好了，咱们就Numpy最常用最重要的 15 个方面进行实际的数据处理。
- 数组创建
- 数组形状和大小操作
- 数组索引和切片
- 数学运算
- 线性代数运算
- 随机数生成
- 通用函数
- 聚合函数
- 广播
- 文件输入输出
- 数组排序和搜索
- 数组拼接和分割
- 数组的复制和视图
- 条件逻辑
- 元素唯一性和集合运算
以下内容，一定一定要收藏起来，慢慢学习。
也可以当做一个小册子，拿来即用，立即套到自己的实际应用中。
1. 数组创建
numpy.array(): 从常规Python列表或元组创建数组。numpy.zeros(),numpy.ones(),numpy.empty(): 创建特定大小的初始化为0、1或未初始化的数组。numpy.arange(),numpy.linspace(): 创建数值范围内的数组。
1. 使用 numpy.array() 从列表或元组创建数组
从列表创建数组
np.array([1, 2, 3]) # 输出：[1, 2, 3]从元组创建数组
np.array((6, 7, 8, 9, 10)) # 输出：[6, 7, 8, 9, 10]
2. 使用 numpy.zeros(), numpy.ones(), numpy.empty() 创建特定大小的数组
创建全0数组（向量）
np.zeros(5) # 输出：[0., 0., 0., 0., 0.]
创建全1数组（向量）
np.ones(5) # 输出：[1., 1., 1., 1., 1.]
创建未初始化数组（向量）
np.empty(5) # 输出：随机数（取决于内存状态）
创建全0矩阵
np.zeros((3, 4)) # 输出：3x4的全0矩阵
创建全1矩阵
np.ones((2, 3)) # 输出：2x3的全1矩阵
创建未初始化矩阵
np.empty((2, 2)) # 输出：2x2的未初始化矩阵
3. 使用 numpy.arange() 和 numpy.linspace() 创建数值范围内的数组
使用 arange 创建数组
np.arange(1, 10, 2) # 输出：[1, 3, 5, 7, 9]
np.arange(10) # 输出：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
使用 linspace 创建等间距的点
np.linspace(0, 1, 5) # 输出：[0., 0.25, 0.5, 0.75, 1.]
np.linspace(0, 10, 10) # 输出：[0., 1.11, 2.22, 3.33, 4.44, 5.56, 6.67, 7.78, 8.89, 10.]
这些代码提供了如何使用NumPy进行数组创建的具体示例。
2. 数组形状和大小操作
numpy.reshape(): 改变数组的形状而不改变其数据。numpy.resize(): 改变数组的大小。numpy.transpose(),.T: 数组的转置。
1. 使用 numpy.reshape() 改变数组形状
# 创建一个初始数组作为示例
initial_array = np.arange(1, 13) # 创建一个1到12的数组
将1到12的一维数组重塑为3行4列
initial_array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
np.reshape(initial_array, (3, 4))
输出:
[[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12]]
重塑为2行6列
np.reshape(initial_array, (2, 6))
输出:
[[ 1, 2, 3, 4, 5, 6],
[ 7, 8, 9, 10, 11, 12]]
重塑为4行3列
np.reshape(initial_array, (4, 3))
输出:
[[ 1, 2, 3],
[ 4, 5, 6],
[ 7, 8, 9],
[10, 11, 12]]
2. 使用 numpy.resize() 改变数组大小
将数组改变为2行5列，多余的部分重复初始元素
np.resize(initial_array, (2, 5))
输出:
[[ 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10]]
改变为4行4列
np.resize(initial_array, (4, 4))
输出:
[[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12],
[ 1, 2, 3, 4]]
3. 使用 numpy.transpose() 和 .T 进行数组转置
转置3行4列的数组
np.transpose(reshaped_array_1)
输出:
[[ 1, 5, 9],
[ 2, 6, 10],
[ 3, 7, 11],
[ 4, 8, 12]]
另一种转置方法，转置2行6列的数组
reshaped_array_2.T
输出:
[[ 1, 7],
[ 2, 8],
[ 3, 9],
[ 4, 10],
[ 5, 11],
[ 6, 12]]
以上就是如何使用NumPy进行数组形状和大小调整的示例。
3. 数组索引和切片
- 使用切片语法访问和修改数组的元素。
- 布尔索引使用布尔条件来索引数组。
# 创建一个初始数组作为示例
initial_array = np.arange(1, 11) # 创建一个1到10的数组
1. 使用切片语法访问和修改数组的元素
访问前三个元素
initial_array[:3] # 输出：[100, 200, 300]
访问最后三个元素
initial_array[-3:] # 输出：[8, 9, 10]
访问中间的元素（从索引3到索引5，不包括5）
initial_array[3:5] # 输出：[4, 5]
修改数组的一部分（将前三个元素修改为100, 200, 300）
initial_array[0:3] = [100, 200, 300]
2. 布尔索引 - 使用布尔条件来索引数组
创建一个布尔条件数组（例如条件为元素大于5）
condition = initial_array > 5
使用布尔数组索引原始数组
initial_array[condition] # 输出：[100, 200, 300, 6, 7, 8, 9, 10]
这些代码展示了如何使用NumPy进行数组的切片访问和修改，以及如何利用布尔索引来选择满足特定条件的元素。
4. 数学运算
- 基本算数运算加法、减法、乘法、除法等。
numpy.dot(),@: 矩阵乘法。- 统计运算如
numpy.mean(),numpy.median(),numpy.std()等。
1. 基本算数运算
# 创建两个数组作为示例
array1 = np.array([1, 2, 3, 4])
array2 = np.array([5, 6, 7, 8])
加法
array1 + array2 # 输出：[6, 8, 10, 12]
减法
array1 - array2 # 输出[-4, -4, -4, -4]
乘法
array1 * array2 # 输出：[5, 12, 21, 32]
除法
array1 / array2 # 输出：[0.2, 0.33333333, 0.42857143, 0.5]
2. 矩阵乘法
# 创建两个2x2矩阵
matrix1 = np.array([[1, 2], [3, 4]])
matrix2 = np.array([[5, 6], [7, 8]])
使用 numpy.dot() 进行矩阵乘法
np.dot(matrix1, matrix2) # 输出：[[19, 22], [43, 50]]
使用 @ 符号进行矩阵乘法
matrix1 @ matrix2 # 输出：[[19, 22], [43, 50]]
3. 统计运算
# 创建一个数组
stat_array = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
平均值
np.mean(stat_array) # 输出：5.5
中位数
np.median(stat_array) # 输出：5.5
标准差
np.std(stat_array) # 输出：2.8722813232690143
这些代码示例展示了如何使用NumPy进行基础的数学和统计运算。
5. 线性代数运算
numpy.linalg: 包含矩阵分解、特征值、解线性方程组等功能。
1. 矩阵的特征值和特征向量
# 创建一个矩阵作为示例
matrix = np.array([[4, 2], [3, 1]])
# 创建一个线性方程组 Ax = B
A = np.array([[3, 1], [1, 2]])
B = np.array([9, 8])
计算给定矩阵的特征值和特征向量
eigenvalues, eigenvectors = np.linalg.eig(matrix)
# eigenvalues 输出：[5.37228132, -0.37228132]
# eigenvectors 输出：
# [[ 0.82456484, -0.41597356],
# [ 0.56576746, 0.90937671]]
2. 奇异值分解（SVD）
对矩阵进行奇异值分解
u, s, vh = np.linalg.svd(matrix)
# u 输出：
# [[-0.81741556, -0.57604844],
# [-0.57604844, 0.81741556]]
# s 输出：[5.4649857 , 0.36596619]
# vh 输出：
# [[-0.9145143 , -0.40455358],
# [ 0.40455358, -0.9145143 ]]
3. 解线性方程组
解线性方程组 Ax = B
x = np.linalg.solve(A, B)
# x 输出：[2., 3.]
4. 计算行列式和逆矩阵
计算矩阵的行列式
determinant = np.linalg.det(matrix)
# determinant 输出：-2.0
计算矩阵的逆
inverse_matrix = np.linalg.inv(matrix)
# inverse_matrix 输出：
# [[-0.5, 1. ],
# [ 1.5, -2. ]]
以上展示了如何使用NumPy的线性代数模块进行各种矩阵操作，包括计算特征值、特征向量、进行奇异值分解、解线性方程组，以及计算行列式和逆矩阵。
6. 随机数生成
numpy.random: 生成各种概率分布的随机数。
生成均匀分布的随机数
在0到1之间生成10个均匀分布的随机数
np.random.uniform(0, 1, 10)
生成正态分布的随机数
生成均值为0，标准差为1的正态分布随机数（10个）
np.random.normal(0, 1, 10)
生成整数随机数
在0到10之间生成10个随机整数
np.random.randint(0, 10, 10)
生成二项分布的随机数
进行10次试验，每次成功概率为0.5，生成10个二项分布随机数
np.random.binomial(n=10, p=0.5, size=10)
设置随机种子
设置一个种子以产生可复现的结果
np.random.seed(0)
以上代码表述了使用NumPy生成不同类型的随机数，包括均匀分布、正态分布、整数随机数、二项分布。通过设置随机种子，可以确保每次生成的随机数序列是一致的，这一点对于需要可复现结果的实验和分析是非常重要的。
7. 通用函数
- 快速、元素级别的数组函数，例如
numpy.sin(),numpy.exp(),numpy.sqrt()等。
# 创建一个初始数组作为示例
initial_array = np.array([0, np.pi/4, np.pi/2, np.pi, 2*np.pi])
使用 numpy.sin() 计算数组元素的正弦值:
对数组元素计算正弦值
np.sin(initial_array)
使用 numpy.exp() 计算数组元素的指数值:
对数组元素计算指数值（(e^x)）
np.exp(initial_array)
使用 numpy.sqrt() 计算数组元素的平方根:
对数组元素计算平方根
np.sqrt(initial_array)
其他快速元素级别的函数:
计算余弦值 (numpy.cos()):
np.cos(initial_array)
计算自然对数 (numpy.log())，为避免对0取对数，在数组元素上加1
np.log(initial_array + 1)
计算绝对值 (numpy.abs()):
np.abs([-1, -2, 3, -4, 5])
上面代码，阐述了使用NumPy对数组执行各种快速的元素级别操作，包括三角函数、指数函数、对数函数和其他基本数学函数。通过这些操作，可以方便地对数组中的每个元素应用复杂的数学计算。
8. 聚合函数
- 如
numpy.sum(),numpy.min(),numpy.max(),numpy.cumsum()用于数据聚合。
# 创建一个初始数组作为示例
initial_array = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
使用 numpy.sum() 计算数组元素的总和:
计算数组元素的总和
np.sum(initial_array)
# 输出：55
使用 numpy.min() 找出数组中的最小值:
找出数组中的最小值
np.min(initial_array)
# 输出：1
使用 numpy.max() 找出数组中的最大值:
找出数组中的最大值
np.max(initial_array)
# 输出：10
使用 numpy.cumsum() 计算数组元素的累积和:
计算数组元素的累积和
np.cumsum(initial_array)
# 输出：[ 1, 3, 6, 10, 15, 21, 28, 36, 45, 55]
以上代码，详细说明了，使用NumPy进行基本的数据聚合操作，如计算总和、最小值、最大值以及累积和。这些操作是数据分析中常见的任务。
9. 广播
- 使用NumPy进行不同大小数组之间的运算（广播机制）。
# 创建两个不同大小的数组作为示例
array1 = np.array([1, 2, 3]) # 小数组
array2 = np.array([[0, 10, 20], [30, 40, 50], [60, 70, 80]]) # 大数组
不同大小数组之间的加法（广播）
小数组（1维）和大数组（2维）之间的加法
array1 + array2
# 输出：
# [[ 1, 12, 23],
# [31, 42, 53],
# [61, 72, 83]]
不同大小数组之间的乘法（广播）
小数组和大数组之间的乘法
array1 * array2
# 输出：
# [[ 0, 20, 60],
# [ 30, 80, 150],
# [ 60, 140, 240]]
不同大小数组之间的减法（广播）
大数组和小数组之间的减法
array2 - array1
# 输出：
# [[-1, 8, 17],
# [29, 38, 47],
# [59, 68, 77]]
不同形状数组之间的加法（广播）
列向量（2维）和大数组（2维）之间的加法
array2 + array3
# 输出：
# [[ 1, 11, 21],
# [32, 42, 52],
# [63, 73, 83]]
这些代码展示了NumPy中的广播机制，即如何处理不同大小或形状数组之间的运算。在这些操作中，较小的数组会“广播”以匹配较大数组的形状，从而使元素级别的运算成为可能。广播机制是NumPy中一个强大的特性，它允许进行更灵活的数组操作而无需显式地调整数组的形状。
10. 文件输入输出
numpy.loadtxt(),numpy.savetxt(): 读写文本文件。numpy.save(),numpy.load(): 读写NumPy的二进制文件格式。
使用 numpy.savetxt() 和 numpy.loadtxt() 读写文本文件:
首先创建一个示例数组 sample_array。
使用 numpy.savetxt() 保存数组到文本文件
np.savetxt('sample_array.txt', sample_array)
使用 numpy.loadtxt() 从文本文件读取数组
loaded_array_from_txt = np.loadtxt('sample_array.txt')
使用 numpy.save() 和 numpy.load() 读写NumPy的二进制文件格式:
使用 numpy.save() 保存数组到二进制文件
np.save('sample_array.npy', sample_array)
使用 numpy.load() 从二进制文件读取数组
loaded_array_from_npy = np.load('sample_array.npy')
上面代码，展示了如何使用NumPy读写文本和二进制文件。这对于数据持久化非常有用。
11. 数组排序和搜索
numpy.sort(): 对数组进行排序。numpy.argsort(): 返回排序后的索引。numpy.argmax(),numpy.argmin(): 查找数组中最大或最小元素的索引。numpy.where(): 根据条件返回数组中的索引。
# 创建一个初始数组作为示例
initial_array = np.array([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5])
使用 numpy.sort() 对数组进行排序
对数组进行排序
sorted_array = np.sort(initial_array)
# 输出：[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
使用 numpy.argsort() 返回排序后的索引
返回排序后元素的原始索引
sorted_indices = np.argsort(initial_array)
# 输出：[1, 3, 6, 0, 9, 2, 4, 8, 10, 7, 5]
使用 numpy.argmax() 和 numpy.argmin() 查找数组中最大或最小元素的索引
查找最大元素的索引
max_index = np.argmax(initial_array)
# 输出：5
查找最小元素的索引
min_index = np.argmin(initial_array)
# 输出：1
使用 numpy.where() 根据条件返回数组中的索引
查找数组中所有大于3的元素的索引
indices_greater_than_3 = np.where(initial_array > 3)
# 输出：(array([2, 4, 5, 7, 8, 10]),)
这些代码示例展示了如何使用NumPy进行数组的排序、查找特定条件下元素的索引、以及查找最大值和最小值所在的索引。这些功能对于数据分析和处理非常有用。
12. 数组拼接和分割
numpy.concatenate(),numpy.vstack(),numpy.hstack(): 将多个数组沿指定轴拼接。numpy.split(),numpy.vsplit(),numpy.hsplit(): 将数组沿特定轴分割。
# 创建几个数组作为示例
array1 = np.array([1, 2, 3])
array2 = np.array([4, 5, 6])
array3 = np.array([[7, 8, 9], [10, 11, 12]])
使用 numpy.concatenate() 将多个数组沿指定轴拼接:
将两个一维数组 array1 和 array2 沿着默认轴（第一维）拼接
np.concatenate((array1, array2))
# 输出：[1, 2, 3, 4, 5, 6]
将二维数组 array3 与自身沿着第一维拼接
np.concatenate((array3, array3), axis=0)
# 输出：
# [[ 7, 8, 9],
# [10, 11, 12],
# [ 7, 8, 9],
# [10, 11, 12]]
使用 numpy.vstack() 和 numpy.hstack() 进行垂直和水平拼接:
垂直拼接一维数组 array1 和二维数组 array3
np.vstack((array1, array3))
# 输出：
# [[ 1, 2, 3],
# [ 7, 8, 9],
# [10, 11, 12]]
水平拼接二维数组 array3 与自身
np.hstack((array3, array3))
# 输出：
# [[ 7, 8, 9, 7, 8, 9],
# [10, 11, 12, 10, 11, 12]]
使用 numpy.split(), numpy.vsplit() 和 numpy.hsplit() 将数组沿特定轴分割:
将一维数组 array2 分割为三个等份
np.split(array2, 3)
# 输出：[array([4]), array([5]), array([6])]
将二维数组 array3 垂直分割为两个等份
np.vsplit(array3, 2)
# 输出：[array([[7, 8, 9]]), array([[10, 11, 12]])]
将二维数组 array3 水平分割为三个等份
np.hsplit(array3, 3)
# 输出：[array([[ 7], [10]]), array([[ 8], [11]]), array([[ 9], [12]])]
数组的拼接和分割操作这部分很重要。灵活地组合和分解数组以满足数据处理的需求。
13. 数组的复制和视图
.copy(): 创建数组的深度副本。- 视图（View）: 创建数组的浅副本，当原数组改变时，视图也会跟着改变。
# 创建一个初始数组作为示例
initial_array = np.array([1, 2, 3, 4, 5])
使用 .copy() 创建数组的深度副本:
创建 initial_array 的深度副本
deep_copy_array = initial_array.copy()
修改深度副本中的一个元素，比如将第一个元素改为100。原始数组不会受此修改影响
deep_copy_array[0] = 100
创建数组的视图（浅副本）:
创建 initial_array 的视图
view_array = initial_array.view()
修改视图中的一个元素，比如将第二个元素改为200。这将影响原始数组
view_array[1] = 200
查看原始数组、深度副本和视图的变化，我们可以观察到：
- 原始数组
initial_array变为[1, 200, 3, 4, 5]，因为视图view_array的修改影响了它。 - 深度副本
deep_copy_array为[100, 2, 3, 4, 5]，修改不影响原始数组。 - 视图
view_array和原始数组一样，为[1, 200, 3, 4, 5]。
这些代码示例展示了深度副本和视图（浅副本）之间的区别：深度副本不影响原始数组，而视图的修改会影响原始数组。
14. 条件逻辑
numpy.where(): 用于基于条件选择数组元素。
# 创建一个初始数组作为示例
initial_array = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
查找数组中满足特定条件的元素的位置:
查找数组中所有大于5的元素的位置
indices_greater_than_5 = np.where(initial_array > 5)
# 输出：(array([5, 6, 7, 8, 9]),)
基于条件替换元素:
将数组中大于5的元素替换为-1，其余保持原值
replaced_array = np.where(initial_array > 5, -1, initial_array)
# 输出：[ 1, 2, 3, 4, 5, -1, -1, -1, -1, -1]
使用复合条件进行选择:
找出数组中所有大于3且小于8的元素的位置
indices_between_3_and_8 = np.where((initial_array > 3) & (initial_array < 8))
# 输出：(array([3, 4, 5, 6]),)
上述代码展示了 numpy.where()的重要操作，这个函数非常灵活，可以用于查找满足特定条件的元素的索引、基于条件替换数组中的元素，以及进行更复杂的基于多个条件的数组操作。
15. 元素唯一性和集合运算
numpy.unique(): 找出数组中的唯一元素。numpy.intersect1d(),numpy.union1d(): 执行集合的交集和并集操作。
# 创建两个数组作为示例
array1 = np.array([1, 2, 3, 4, 5, 6, 3, 2])
array2 = np.array([3, 4, 5, 6, 7, 8])
使用 numpy.unique() 找出数组中的唯一元素:
从数组 array1 中找出所有唯一的元素
unique_elements = np.unique(array1)
# 输出：[1, 2, 3, 4, 5, 6]
使用 numpy.intersect1d() 执行两个数组的交集操作:
找出数组 array1 和 array2 的交集
intersection = np.intersect1d(array1, array2)
# 输出：[3, 4, 5, 6]
使用 numpy.union1d() 执行两个数组的并集操作:
找出数组 array1 和 array2 的并集
union = np.union1d(array1, array2)
# 输出：[1, 2, 3, 4, 5, 6, 7, 8]
这些代码示例展示了如何使用NumPy进行数组的唯一元素查找以及集合的交集和并集操作。这些函数在处理数据集时非常有用，特别是当需要从数组中去除重复元素或者比较不同数组中元素的关系时。
腾讯云开发者
