网上看到一份挺详细的Numpy教程，正好之前对相关API没有系统整理过，此篇来抽取一些有用的内容进行整理，以便后续使用时查阅。
参考教程：https://github.com/datawhalechina/powerful-numpy

创建数据

np.array(list)

直接通过一个列表来创建数据，可以使用dtype来指定数据类型。

# 创建一维数据
np.array([1,2,3])
# 创建二维数据
np.array([[1, 2, 3], [4, 5, 6]])
# 指定数据类型
np.array([1, 2, 3], dtype=np.float16)
np.array([1, 2, 3], dtype=np.int32)

  

np.arange

# 创建3x4的整型数据
np.arange(12).reshape(3, 4)
"""
输出：
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
"""
# 创建4x3的浮点型数据
np.arange(12.0).reshape(4, 3)
"""
输出：
array([[ 0.,  1.,  2.],
       [ 3.,  4.,  5.],
       [ 6.,  7.,  8.],
       [ 9., 10., 11.]])
"""

  

np.linspace

linspace即线性插值：需要传递3个参数：开头，结尾，数量；
与之类似，还有指数线性插值np.logspace

np.linspace(0, 9, 10).reshape(2, 5)
"""
array([[0., 1., 2., 3., 4.],
       [5., 6., 7., 8., 9.]])
"""

  

np.ones

生成全1矩阵

np.ones((2, 3))
"""
array([[1., 1., 1.],
       [1., 1., 1.]])
"""

  

np.zeros

生成全0矩阵

np.zeros((2,3,4))
"""
array([[[0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.]],

       [[0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.]]])
"""
np.zeros_like(np.ones((2,3,3)))
"""
array([[[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]],

       [[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]]])
"""

  

np.random

生成各随机数

# 0-1 连续均匀分布
np.random.rand(2, 3)
# 单个数
np.random.rand()
# 指定上下界的连续均匀分布
np.random.uniform(-1, 1, (2, 3))
# 随机整数（离散均匀分布），不超过给定的值（10）
np.random.randint(10, size=2)
# 正态分布
np.random.randn(2, 4)
# 高斯分布
np.random.normal(0, 1, (3, 5))

  

保存与读取

np.save

# 直接将给定矩阵存为 a.npy
np.save('./data/a', np.array([[1, 2, 3], [4, 5, 6]]))
# 可以将多个矩阵存在一起，名为 `b.npz`
np.savez("./data/b", a=np.arange(12).reshape(3, 4), b=np.arange(12.).reshape(4, 3))

  

np.load

# 加载单个 array
np.load("data/a.npy")
# 加载多个，可以像字典那样取出对应的 array
arr = np.load("data/b.npz")
arr["a"]
arr["b"]

  

统计与属性

array.ndim

返回维度

arr.ndim

  

array.shape

形状，返回一个 Tuple

arr.shape

  

array.size

返回数据量

arr.size

  

array.max

返回最大值

# 按维度（列）最大值
arr.max(axis=0)
# 按维度（行）最大值
arr.max(axis=1)

  

array.min

返回最小值

# 按维度（列）最小值
arr.min(axis=0)
# 按维度（行）最小值
arr.min(axis=1)

  

np.median

返回中位数

np.median(arr)

  

np.quantile

返回分位数

# 分位数，按列取1/4数
np.quantile(arr, q=0.25, axis=0)
# 分位数，按行取 3/4，同时保持维度
np.quantile(arr, q=0.75, axis=1, keepdims=True)

  

np.average

计算平均值

# 平均值
np.average(arr)
# 按维度平均（列）
np.average(arr, axis=0)

  

np.sum/np.cumsum

求和

np.sum(arr, axis=1)
# 按列累计求和
np.cumsum(arr, axis=0)
# 按行累计求和
np.cumsum(arr, axis=1)

  

np.std/np.var

计算标准差和方差

# 按列求标准差
np.std(arr, axis=0)
# 按行求方差
np.var(arr, axis=1)

  

形状转换

arr.ravel()

将一个array展平

# 将多维array展平
arr.ravel()

  

np.expand_dims

扩展维度

# 扩展 1 个维度，需要（必须）指定维度
# 其实就是多嵌套了一下
np.expand_dims(arr, 1)

  

np.squeeze

去除维度

# 如果指定了维度，那就只会去除该维度，指定的维度必须为 1
# 如果不指定，就去除所有为1的维度
np.squeeze(expanded, axis=1).shape

  

arr.reshape

改变形状

# reshape 成另一个形状
arr.reshape(2, 2, 3)

  

arr.T

矩阵转置

arr
'''
array([[ 9, 77, 65],
       [44, 43, 86],
       [ 9, 70, 20],
       [10, 53, 97]])
'''
arr.T
"""
array([[ 9, 44,  9, 10],
       [77, 43, 70, 53],
       [65, 86, 20, 97]])
"""

  

np.concatenate

拼接

arr1 = rng.random((2, 3))
arr2 = rng.random((2, 3))
arr1, arr2
"""
arr1, arr2
(array([[0.77395605, 0.43887844, 0.85859792],
        [0.69736803, 0.09417735, 0.97562235]]),
 array([[0.7611397 , 0.78606431, 0.12811363],
        [0.45038594, 0.37079802, 0.92676499]]))
"""
# 默认沿axis=0（列）连接
np.concatenate((arr1, arr2))
"""
array([[0.77395605, 0.43887844, 0.85859792],
       [0.69736803, 0.09417735, 0.97562235],
       [0.7611397 , 0.78606431, 0.12811363],
       [0.45038594, 0.37079802, 0.92676499]])
"""
# 沿 axis=1（行）连接
np.concatenate((arr1, arr2), axis=1)
"""
array([[0.77395605, 0.43887844, 0.85859792, 0.7611397 , 0.78606431,
        0.12811363],
       [0.69736803, 0.09417735, 0.97562235, 0.45038594, 0.37079802,
        0.92676499]])
"""

  

np.stack

堆叠

# 堆叠，默认根据 axis=0 进行
np.stack((arr1, arr2))
"""
array([[[0.77395605, 0.43887844, 0.85859792],
        [0.69736803, 0.09417735, 0.97562235]],

       [[0.7611397 , 0.78606431, 0.12811363],
        [0.45038594, 0.37079802, 0.92676499]]])
"""

  

np.repeat

重复

arr
"""
array([[0, 7, 6, 4],
       [4, 8, 0, 6],
       [2, 0, 5, 9]])
"""
# 在 axis=0（沿着列）上重复 2 次
np.repeat(arr, 2, axis=0)
"""
array([[0, 7, 6, 4],
       [0, 7, 6, 4],
       [4, 8, 0, 6],
       [4, 8, 0, 6],
       [2, 0, 5, 9],
       [2, 0, 5, 9]])
"""
# 在 axis=1（沿着行）上重复 3 次
np.repeat(arr, 3, axis=1)
"""
array([[0, 0, 0, 7, 7, 7, 6, 6, 6, 4, 4, 4],
       [4, 4, 4, 8, 8, 8, 0, 0, 0, 6, 6, 6],
       [2, 2, 2, 0, 0, 0, 5, 5, 5, 9, 9, 9]])
"""

  

np.split

拆分

arr
"""
array([[ 9, 77, 65, 44],
       [43, 86,  9, 70],
       [20, 10, 53, 97],
       [73, 76, 72, 78],
       [51, 13, 84, 45],
       [50, 37, 19, 92]])
"""
# 默认切分列（axis=0），切成 3 份
np.split(arr, 3)
"""
[array([[ 9, 77, 65, 44],
        [43, 86,  9, 70]]),
 array([[20, 10, 53, 97],
        [73, 76, 72, 78]]),
 array([[51, 13, 84, 45],
        [50, 37, 19, 92]])]
"""
# （axis=1）切分行
np.split(arr, 2, axis=1)
[array([[ 9, 77],
        [43, 86],
        [20, 10],
        [73, 76],
        [51, 13],
        [50, 37]]),
 array([[65, 44],
        [ 9, 70],
        [53, 97],
        [72, 78],
        [84, 45],
        [19, 92]])]

  

筛选提取

np.where

返回各维度符合条件的index

arr
"""
array([[ 9, 77, 65, 44],
       [43, 86,  9, 70],
       [20, 10, 53, 97]])
"""
# 返回满足条件的索引，因为是两个维度，所以会返回两组结果
np.where(arr > 50)
"""
(array([0, 0, 1, 1, 2, 2]), array([1, 2, 1, 3, 2, 3]))
"""
# 不满足条件的赋值，将 <=50 的替换为 -1
np.where(arr > 50, arr, -1)
"""
array([[-1, 77, 65, -1],
       [-1, 86, -1, 70],
       [-1, -1, 53, 97]])
"""

  

np.extract

在array中提取指定条件的值

# 提取指定条件的值
np.extract(arr > 50, arr)
"""
array([77, 65, 86, 70, 53, 97])
"""

  

np.unique

提取唯一值

np.unique(arr)
"""
array([ 9, 10, 20, 43, 44, 53, 65, 70, 77, 86, 97])
"""

  

np.argmax

提取最大值下标

# 按列（axis=0）最大值的 Index
np.argmax(arr, axis=0)

  

np.argmin

提取最小值下标

# 按行（axis=1）最小值的 Index
np.argmin(arr, axis=1)

  

矩阵运算

基本运算

# +-*/ 四则运算，就跟两个数字计算一样
arr * 2
# 平方运算
arr ** 2
# 开方
np.sqrt(arr)
# log
np.log(arr)
# mod <=> x % 3
np.mod(arr, 3)

  

np.minimum

# 超过5的都换成5
np.minimum(arr, 5)

  

np.maximum

# 低于5的都换成5
np.maximum(arr, 5)

  

np.round

# 四舍五入
np.round(np.sqrt(arr), 2)

  

np.floor

# 向下取整
np.floor(np.sqrt(arr))

  

np.ceil

# 向上取整
np.ceil(np.sqrt(arr))

  

矩阵乘法

a, b
"""
array([[1, 7],
        [6, 4],
        [4, 8]]),
array([[1, 7, 2, 1],
       [5, 9, 7, 7]])
"""
# array 乘法
np.dot(a, b)
"""
array([[ 36,  70,  51,  50],
       [ 26,  78,  40,  34],
       [ 44, 100,  64,  60]])
"""
# 或者这样乘
a.dot(b)
"""
array([[ 36,  70,  51,  50],
       [ 26,  78,  40,  34],
       [ 44, 100,  64,  60]])
"""
# 矩阵乘法
# 与 dot 的主要区别是：matmul 矩阵（好像元素一样）堆叠在一起广播
np.matmul(a, b)
"""
array([[ 36,  70,  51,  50],
       [ 26,  78,  40,  34],
       [ 44, 100,  64,  60]])
"""
# 同上，写起来比较好看的方法
a @ b
"""
array([[ 36,  70,  51,  50],
       [ 26,  78,  40,  34],
       [ 44, 100,  64,  60]])
"""
# 点积
np.vdot(a, a)
"""
182
"""
# 内积
np.inner(a, a)
"""
array([[50, 34, 60],
       [34, 52, 56],
       [60, 56, 80]])
"""
# 内积另一种计算方法
a.dot(a.T)
"""
array([[50, 34, 60],
       [34, 52, 56],
       [60, 56, 80]])
"""
# 行列式
np.linalg.det(c)
"""
-19.999999999999996
"""
# 逆矩阵（方阵）
np.linalg.inv(c)
"""
array([[ 0.2 , -0.2 ,  0.  ],
       [-1.05,  0.55,  1.25],
       [ 1.6 , -0.6 , -2.  ]])
"""

  

总结

本篇根据自己的实际应用筛选了一部分常用的numpy的API，如需了解更多内容，可以查阅官方文档。

文章来源: zstar.blog.csdn.net，作者：zstar-_，版权归原作者所有，如需转载，请联系作者。

原文链接：zstar.blog.csdn.net/article/details/126304306