Numpy常见操作总结

90后嫩男
已于 2024-07-23 14:41:43 修改
阅读量238
点赞数 3
文章标签： numpy pycharm
于 2024-07-23 14:41:31 首次发布
本文链接：https://blog.csdn.net/weixin_58351753/article/details/140635723
版权
NumPy 提供高效的多维数组对象 (ndarray) 用于大规模数据处理。它包含丰富的数学函数库，支持线性代数、傅里叶变换和随机数生成等操作。
以下代码内容包括对于数组对象的查看、数据处理等操作
import numpy as np

# 创建一个二维和三维数组
array_e1 = np.array([[1, 2, 3], [4, 5, 6]])
array_e2 = np.array([[[1, 2, 3], [4, 5, 6]],
                     [[7, 8, 9], [10, 11, 12]]])

print("array_e1=\n", array_e1, "\n")
print("array_e2=\n", array_e2, "\n")

# array.ndim 查看数组维度
print("array_e1_dim=", array_e1.ndim)
print("array_e2_dim=", array_e2.ndim, "\n")

# array.shape 数组的形状
print("array_e1_shape=", array_e1.shape)
print("array_e2_shaoe=", array_e2.shape, "\n")

# array.dtype 数组的数据类型
print("array_e1_dtype=", array_e1.dtype)
print("array_e2_dtype=", array_e2.dtype, "\n")

# array.reshape(new_shape)  数组重塑形状
array_e1_reshape = array_e1.reshape(3, 2)
print("array_e1_reshape=\n", array_e1_reshape, "\n")

# array.T 数组转置
array_e1_transposed = array_e1.T
print("array_e1_transposed=\n", array_e1_transposed, "\n")

# array.flatten() 将多维数组一维化
array_e2_flatten = array_e2.flatten()
print("array_e2_flatten=", array_e2_flatten, "\n")

# np.concatenate((array1, array2), axis=0) 沿指定轴拼接数组
array_e1_concatenate0 = np.concatenate((array_e1, array_e1), axis=0)        # 接在三四行
array_e1_concatenate1 = np.concatenate((array_e1, array_e1), axis=1)        # 接在四五六列
print("array_e1_concatenate0=\n", array_e1_concatenate0, "\n")
print("array_e1_concatenate1=\n", array_e1_concatenate1, "\n")

# np.split(array, indices_or_sections, axis=0) 分割多维数组
# 三维数组想象成多个二维数组的平面上下叠放
array_e2_split0 = np.split(array_e2, 2, axis=0)                             # 按面的维度切
array_e2_split1 = np.split(array_e2, 2, axis=1)                             # 按行的维度切
array_e2_split2 = np.split(array_e2, 3, axis=2)                             # 按列的维度切
print("array_e2_split0=\n", array_e2_split0, "\n")
print("array_e2_split1=\n", array_e2_split1, "\n")
print("array_e2_split2=\n", array_e2_split2, "\n")

# 数组求和，维度参数的选择分别代表总和、行和、列和
sum_all = np.sum(array_e1, axis=None)
sum_axis0 = np.sum(array_e1, axis=0)
sum_axis1 = np.sum(array_e1, axis=1)
print("sum_all =", sum_all, "\nsum_axis0 =", sum_axis0, "\nsum_axis1 =", sum_axis1, "\n")

# 下述函数用法与求和一致
np.mean(array_e1, axis=None)
np.max(array_e1, axis=None)
np.min(array_e1, axis=None)
np.std(array_e1, axis=None)         # 标准差
np.var(array_e1, axis=None)         # 方差

array_e3 = np.array([1, 2, 2, 3, 3, 3, 4, 4, 4, 4])
array_e4 = np.array([9, 3, 7, 1, 8, 0, 7, 1, 2])

# 数组内的元素（仅展示一次）
value_e3_unique = np.unique(array_e3)
print("value_e3_unique =", value_e3_unique, "\n")

# 数组内各元素的个数,会存在对 数值0 的计数
value_e3_count = np.bincount(array_e3)
print("value_e3_count =", value_e3_count, "\n")

# 筛选数组内的元素,返回布尔值,可通过布尔值输出满足条件的元素
array_e4_condition = np.array(array_e4 > 2)
print("array_e4_condition =", array_e4_condition, "\n")
print("array_e4_condition_value =", array_e4[array_e4_condition], "\n")

# 根据条件返回数组内所需的元素,可根据True和False返回不同的值
array_e4_condition_value0 = np.where(array_e4_condition, array_e4, None)
print("array_e4_condition_value0 =", array_e4_condition_value0, "\n")

# Numpy的广播机制用于对不同形状的数组进行算术运算
array_e5 = np.array([1, 2, 3])
array_e6 = np.array([[4], [5], [6]])
array_broadcast = array_e5 + array_e6
print("array_broadcast =\n", array_broadcast, "\n")

# np.dot() 一维的运用为数组内积
array_dot55 = np.dot(array_e5, array_e5)                # 数值
print("array_dot55 =", array_dot55, "\n")

# np.dot() 二维以上的运用为矩阵乘法
array_e7 = np.array([[1, 2, 3], [4, 5, 6]])             # 两行三列
array_e8 = np.array([[1, 2], [3, 4], [5, 6]])           # 三行两列
array_dot78 = np.dot(array_e7, array_e8)                # 两行两列
array_dot87 = np.dot(array_e8, array_e7)                # 三行三列
print("array_dot78 =\n", array_dot78, "\n")
print("array_dot87 =\n", array_dot87, "\n")

# np.matmul(array1, array2) 用法与np.dot() 二维以上的一致
array_matmul78 = np.matmul(array_e7, array_e8)                  # 两行两列
array_matmul87 = np.matmul(array_e8, array_e7)                  # 三行三列
print("array_matmul78 =\n", array_matmul78, "\n")
print("array_matmul87 =\n", array_matmul87, "\n")

# np.cumsum() 累积和运算
array_e7_cumsum0 = np.cumsum(array_e7, axis=0)                  # 沿行累加
array_e7_cumsum1 = np.cumsum(array_e7, axis=1)                  # 沿列累加
print("array_e7_cumsum0 =\n", array_e7_cumsum0, "\n")
print("array_e7_cumsum1 =\n", array_e7_cumsum1, "\n")

# np.cumprod() 累积积运算
array_e7_cumprod0 = np.cumprod(array_e7, axis=0)                # 沿行累乘
array_e7_cumprod1 = np.cumprod(array_e7, axis=1)                # 沿列累乘
print("array_e7_cumprod0 =\n", array_e7_cumprod0, "\n")
print("array_e7_cumprod1 =\n", array_e7_cumprod1, "\n")

# np.diff(array, n=1, axis=-1) 差分运算，其中n表示阶数，axis=-1表示最后一个轴
# np.trapz(array, dx=1.0, axis=-1) 积分运算，使用一致
array_e7_diff01 = np.diff(array_e7, n=1, axis=0)                # 沿行一阶差分
print("array_e7_diff01 =\n", array_e7_diff01, "\n")
array_e7_diff11 = np.diff(array_e7, n=1, axis=1)                
# 沿列一阶差分
print("array_e7_diff11 =\n", array_e7_diff11, "\n")
array_e7_diff02 = np.diff(array_e7, n=2, axis=0)                
# 沿行二阶差分，因为数组行数较少，不足以进行二阶差分，因此返回空数组
print("array_e7_diff02 =\n", array_e7_diff02, "\n")
array_e7_diff12 = np.diff(array_e7, n=2, axis=1)                
# 沿列二阶差分，因为一阶差分是常数，所以二阶即为对一阶的求导，为0
print("array_e7_diff12 =\n", array_e7_diff12, "\n")

# 计算数组的 傅里叶变换 和 逆傅里叶变换
array_e7_fft = np.fft.fft(array_e7)
print("array_e7_fft =\n", array_e7_fft, "\n")
array_e7_fft_ifft = np.fft.ifft(array_e7_fft)
print("array_e7_fft_ifft =\n", array_e7_fft_ifft, "\n")

# np.linalg.inv(array) 求逆矩阵，AB=I，A和B互为逆矩阵，且均为方阵
array_e9 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
array_e9_inv = np.linalg.inv(array_e9)
print("array_e9_inv =\n", array_e9_inv, "\n")

# np.linalg.eig(array) 求特征值和特征向量
# Ab = λb   其中 b为特征向量（非零向量），λ为特征值（标量）
# array_e9_eig_values 包含全部特征值
# array_e9_eig_vectors 包含全部与特征值对应的特征向量
array_e9_eig_values, array_e9_eig_vectors = np.linalg.eig(array_e9)
print("array_e9_eig_values =", array_e9_eig_values, "\n")
print("array_e9_eig_vectors =\n", array_e9_eig_vectors, "\n")

# np.linalg.svd(array) 奇异值分解
# A = UQ(VT)
# 其中，U表示 m×m 的正交矩阵，列向量称为左奇异向量
# Q表示一个 𝑚×𝑛 的对角矩阵，对角线上的 非负实数 称为奇异值，且奇异值个数等于A的秩，并按降序排列。奇异值表示了矩阵A在其对应的奇异向量方向上的“拉伸”或“压缩”的程度
# (VT)表示V的转置矩阵，V表示一个 n×n 的正交矩阵，列向量称为右奇异向量
array_e9_svd_U, array_e9_svd_S, array_e9_svd_VT = np.linalg.svd(array_e9)
print("array_e9_svd_U =\n", array_e9_svd_U, "\n")
print("array_e9_svd_S =\n", array_e9_svd_S, "\n")           # 对角线上的元素
print("array_e9_svd_VT =\n", array_e9_svd_VT, "\n")

# np.linalg.matrix_rank(array) 矩阵的秩
array_e9_rank = np.linalg.matrix_rank(array_e9)
print("array_e9_rank =", array_e9_rank, "\n")
# 此处秩为2 < array_e9_svd_S的个数3       注： array_e9_svd_S的第三个值很小
# 原因: 如果奇异值非常小但不是严格的零，它们可能在数值上被认为是零，导致数值秩小于理论秩

# np.linalg.norm(array, ord=None) 求范数（Norm）是一个函数，它赋予每个数组一个非负长度或大小，用于衡量数组大小
# L2范数（欧几里得范数）：数组元素平方和的平方根  （默认）
array_e9_norm_L2 = np.linalg.norm(array_e9, ord=None, axis=0)           
# 等同于 array_e9_norm_L2 = np.linalg.norm(array_e9, ord=2, axis=0)
print("array_e9_norm_L2 =\n", array_e9_norm_L2, "\n")

# L1 范数：数组元素绝对值的和。
array_e9_norm_L1 = np.linalg.norm(array_e9, ord=1, axis=0)              
# 沿行计算，即三行叠加的结果
print("array_e9_norm_L1 =\n", array_e9_norm_L1, "\n")

# 无穷范数：数组元素绝对值的最大值
array_e9_norm_inf = np.linalg.norm(array_e9, ord=np.inf,  axis=0)       
# 沿行比较
print("array_e9_norm_inf =\n", array_e9_norm_inf, "\n")

# np.linalg.cond(array) 计算条件数，一个衡量矩阵对特定运算（如线性方程求解）敏感度的指标
# 如果一个矩阵的条件数很高，意味着它在计算中容易受到小的扰动影响，导致结果的较大误差，不可靠
array_e9_cond = np.linalg.cond(array_e9)
print("array_e9_cond =", array_e9_cond, "\n")

# np.linalg.solve(A, b) 求解线性方程组 Ax = b
# 其中 矩阵A必须是方阵 且 必须不是奇异的，即它需要有唯一的解
# 奇异矩阵： 不满秩的，行列式为0，没有逆矩阵，条件数无限大
array_A = np.array([[3, 1], [1, 2]])
array_b = np.array([9, 8])
array_x = np.linalg.solve(array_A, array_b)
print("array_x =", array_x, "\n")

# np.linalg.det() 计算行列式，只对于方阵
array_A_det = np.linalg.det(array_A)
print("array_A_det =", array_A_det, "\n")