NumPy 按数字范围创建数组

说明

NumPy 教程持续更新中，提供建议、纠错、催更等加作者微信: gairuo123（备注：pandas教程）和关注公众号「盖若」ID: gairuo。跟作者学习，请进入 Python学习课程。欢迎关注作者出版的书籍：《深入浅出Pandas》和《Python之光》。

本文介绍如何用 NumPy 按数字范围创建一些数组，这将经常用在数据分析模型的搭建和数据集的构造。

概述

有以下常用的方法，可以根据给定的数据范围创建一个数组（按 np.xxx 格式使用）。

方法	说明
np.arange([start,] stop[, step,][, dtype])	在给定的间隔内返回均匀分布的值
np.linspace(start, stop[, num, endpoint, …])	返回指定间隔内的等距数字
np.logspace(start, stop[, num, endpoint, base, …])	数字以对数刻度均匀分布
np.geomspace(start, stop[, num, endpoint, …])	在对数刻度上均匀分布的数字（几何级数）
np.meshgrid(*xi[, copy, sparse, indexing])	生成网格点坐标矩阵
np.mgrid	密集多维网格矩阵 meshgrid 的 nd_grid 实例
np.ogrid	开放的多维网格矩阵 meshgrid 的 nd_grid 实例

范围均匀值 np.arange

np.arange 在给定的间隔内返回均匀分布的值。值是在半开区间 [start，stop) 内生成的（换句话说，区间包括 start，但不包括 stop）。对于整数参数，该函数相当于Python 内置的 range 函数，但返回的是 ndarray 而不是 list。

使用非整数步长（如 0.1）时，结果通常与需求不相符，最好使用 numpy.linspace 来解决这个需求。

np.arange(3)
# array([0, 1, 2])
np.arange(3.0)
# array([ 0.,  1.,  2.])
np.arange(3,7)
# array([3, 4, 5, 6])
np.arange(3,7,2)
# array([3, 5])
np.arange(3,4,.2)
# array([3. , 3.2, 3.4, 3.6, 3.8])

等距数字 np.linspace

语法：

np.linspace(start, stop, num=50,
            endpoint=True, retstep=False,
            dtype=None, axis=0)

np.linspace() 返回指定间隔内的等距数字。返回在 [start，stop] 间隔内计算的等距采样数。可以选择排除间隔的端点。

# 指定数量
np.linspace(2.0, 3.0, num=5)
# array([2.  , 2.25, 2.5 , 2.75, 3.  ])
# 右开区间（不包含右值）
np.linspace(2.0, 3.0, num=5, endpoint=False)
# array([2. ,  2.2,  2.4,  2.6,  2.8])
# (数组, 样本之间的间距)
np.linspace(2.0, 3.0, num=5, retstep=True)
# (array([2.  ,  2.25,  2.5 ,  2.75,  3.  ]), 0.25)

对数均匀分布 np.logspace

返回数以对数刻度均匀分布。在线性空间中，序列从 start 开始，并以 stop 结束。相当于代码：

y = np.linspace(start, stop, num=num, endpoint=endpoint)
power(base, y).astype(dtype)

语法为：

np.logspace(start, stop, num=50,
            endpoint=True, base=10.0,
            dtype=None, axis=0)

案例：

np.logspace(2.0, 3.0, num=4)
# array([ 100.        ,  215.443469  ,  464.15888336, 1000.        ])
np.logspace(2.0, 3.0, num=4, endpoint=False)
# array([100.        ,  177.827941  ,  316.22776602,  562.34132519])
np.logspace(2.0, 3.0, num=4, base=2.0)
# array([4.        ,  5.0396842 ,  6.34960421,  8.        ])

几何均匀分布 np.geomspace

与 logspace 类似，np.geomspace 返回几何级数均匀分布的数字，每个输出样本是前一个样本的常数倍数。

# 语法
np.geomspace(start, stop, num=50, endpoint=True,
             dtype=None, axis=0)
# 指定数据数量
np.geomspace(1, 1000, num=4)
# array([   1.,   10.,  100., 1000.])
# 指定数量
np.geomspace(1, 256, num=9)
# array([   1.,    2.,    4.,    8.,   16.,   32.,   64.,  128.,  256.])
# 指定类型
np.geomspace(1, 256, num=9, dtype=int)
# array([  1,   2,   4,   7,  16,  32,  63, 127, 256])
# 不包含右端
np.geomspace(1, 1000, num=3, endpoint=False)
# array([   1.,   10.,  100.])
# 负值
np.geomspace(-1000, -1, num=4)
# array([-1000.,  -100.,   -10.,    -1.])

生成网格点坐标矩阵 np.meshgrid

坐标向量生成坐标矩阵，通常使用在数据的矢量化上。它用于生成网格型数据，可以接受两个一维数组生成两个二维矩阵，对应两个数组中所有的 (x,y) 对。在坐标空间（二维或者三维等）中每个交叉点都是网格点，描述这些网格点的坐标的矩阵，就是坐标矩阵。

简单说，np.meshgrid 就是把两个数组的笛卡尔积内的元素的第一二个坐标分别放入两个矩阵中。

nx, ny = (3, 2)
x = np.linspace(0, 1, nx)
y = np.linspace(0, 1, ny)
xv, yv = np.meshgrid(x, y)
xv
'''
array([[0. , 0.5, 1. ],
       [0. , 0.5, 1. ]])
'''
yv
'''
array([[0.,  0.,  0.],
       [1.,  1.,  1.]])
'''
xv, yv = np.meshgrid(x, y, sparse=True)  # 稀疏数组
xv
# array([[0. ,  0.5,  1. ]])
yv
'''
array([[0.],
       [1.]])
'''

meshgrid 函数在计算网格上的非常有用。

密集多维网格 np.mgrid

nd_grid instance which returns a dense multi-dimensional “meshgrid”.

语法为 np.mgrid[start:end:step]，返回多维结构，常见的如2D图形，3D图形。nd_grid 例子返回一个密集的多维网格，一个 numpy.lib.index_tricks.nd_grid 例子当其被索引时返回一个密集的网格，所以每一个返回的 argument 有相同的 shape。输出数组的维度和数量于索引维度的数量相同。如果复数 (step length) 不是一个复杂的数，则停止就不具有包含性。

然而如果 step length 时一个复数(例如5j)，然后它的 magnitude 的整数部分得到解释。然后，它的大小的整数部分被解释为在开始和停止值之间指定要创建的点的数量，其中停止值是包容的。

# 案例
np.mgrid[0:5,0:5]
'''
array([[[0, 0, 0, 0, 0],
        [1, 1, 1, 1, 1],
        [2, 2, 2, 2, 2],
        [3, 3, 3, 3, 3],
        [4, 4, 4, 4, 4]],
       [[0, 1, 2, 3, 4],
        [0, 1, 2, 3, 4],
        [0, 1, 2, 3, 4],
        [0, 1, 2, 3, 4],
        [0, 1, 2, 3, 4]]])
'''
np.mgrid[-1:1:5j]
# array([-1. , -0.5,  0. ,  0.5,  1. ])

# 在 1:5 间切的间隔为 0.2，1:3 间切的间隔为 0.1
np.mgrid[1:6:0.2, 1:3:0.1]
# 在 1:3 间均匀取数，取 3 个，1:5 间均匀取数，取 4 个
np.mgrid[1:3:3j, 1:5:4j]

简单说，np.mgrid[start1:end1:step1, start2:end2:step2] 创造两层二维数组，每个数组的大小相同（行数由 start1:end1:step1 决定，列数由start2:end2:step2 决定）。其中第一个二维数组按列存储，即从 start1 到 end1，然后第二列 start1 到end1，第三列…；第二个二维数组a是按行存储，第一行从 start2 到 end2，第二行重复…

开放的多维网格 np.ogrid

nd_grid instance which returns an open multi-dimensional “meshgrid”.

ogrid 函数产生的数组，第一个数组是以纵向产生的，即数组第二维的大小始终为1。第二个数组是以横向产生的，即数组第一维的大小始终为1。

np.ogrid[-1:1:5j]
# array([-1. , -0.5,  0. ,  0.5,  1. ])
np.ogrid[0:5,0:5]
'''
[array([[0],
        [1],
        [2],
        [3],
        [4]]), array([[0, 1, 2, 3, 4]])]
'''

<< 创建特殊值数组 NumPy 教程构建规则矩阵 >>

更新时间：2021-01-05 11:06:36 标签：numpy array