减小字体
增大字体- ·上一篇内容：NumPy数组的相关属性
- ·下一篇内容：NumPy数组操作之修改数组形状
NumPy数组的创建函数
在前面文章中，介绍了使用NumPy库中的array函数创建数组的基本方法。为了方便用户在各种场景下创建出符合实际需求的数组，NumPy提供了众多的函数来实现各种数组的创建。
数组创建函数概览
下面列出了NumPy模块提供的一些创建数组的函数。
| 序号 | 函数名称 | 描述 |
|---|---|---|
| 1 | numpy.array() | NumPy中最基本的数组创建函数 |
| 2 | numpy.zeros() | 创建指定形状和数据类型的，数组元素全为0的数组 |
| 3 | numpy.ones() | 创建指定形状和数据类型的，数组元素都为1的数组 |
| 4 | numpy.arange() | 创建一个指定开始指和结束值的一维等差数列数组 |
| 5 | numpy.linspace() | 创建一个指定间隔均匀分布的数组 |
| 6 | numpy.logspace() | 创建一个对数刻度上均匀分布的数组 |
| 7 | numpy.geomspace() | 创建一个几何等比数字序列数组 |
| 8 | numpy.empty() | 创建一个指定形状和数据类型但未初始化的数组（数组数据未指定） |
| 9 | numpy.full() | 创建一个指定形状且数组全部数据为指定值的数组 |
| 10 | numpy.eye() | 创建一个二维数组，其对角线值为1，其余为0 |
| 11 | numpy.identity() | 创建一个行列数相同的二维数组，其对角线上的值为1，其余位置为0 |
| 12 | numpy.diag() | 从一个二维数组中提取对角线或根据给定的对角线元素创建二维数组 |
| 13 | numpy.vander() | 创建一个范德蒙德矩阵数组 |
| 14 | numpy.tri() | 创建一个下三角单位矩阵，其指定对角线及以下位置的元素为1，其余位置为0 |
| 15 | numpy.tril() | 返回指定数组的下三角矩阵的一个副本，其指定对角线及以上部分的元素为0. |
| 16 | numpy.triu() | 返回指定数组的上三角矩阵的一个部分，其指定对角线及以下部分的元素为0. |
| 17 | numpy.zeros_like() | 创建一个与给定数组具有相同形状和数据类型，且元素值都为0的数组。 |
| 18 | numpy.ones_like() | 创建一个与给定数组具有相同形状和数据类型，且元素值都为1的数组。 |
| 19 | numpy.empty_like() | 创建一个与给定数组具有相同形状和数据类型，但尚未初始化的数组。 |
| 20 | numpy.full_like() | 创建一个与给定数组具有相同形状和数据类型，且数组元素为给定值的数组。 |
1.numpy.array()
用户可以使用numpy.array()函数创建一个NumPy数组，在创建过程中可以向该函数传递一个列表或元组参数，numpy.array()函数将其转换成NumPy数组，其语法格式为：
numpy.array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0, like=None)
各参数的主要含义描述如下：
| 参数名称 | 参数含义 |
|---|---|
| object | 序列对象或嵌套的序列对象，用于生成数组中元素 |
| dtype | 可选参数，默认为None，表示数组元素的数据类型 |
| copy | 可选参数，默认为True，数组数据元素被复制（仅在通过复制方式创建新数组时起作用）。 |
| order |
可选参数， 在object参数为非数组时，指定数组数据元素的内存布局。取值有4种：
|
| subok | 可选参数，布尔类型，默认值为False，表示强制返回一个基类类型的数组，如果取值为True，则传递子类。 |
| ndmin | 可选参数，是一个整型数字，指定生成数组的最小维度 |
使用numpy.array()创建一维数组
下面是创建一维数组的例子。
import numpy as np lst = [1, 2, 3, 4, 5] arr = np.array(lst) print(arr)
输出结果如下：
[1 2 3 4 5]
使用numpy.array()创建二维数组
下面是使用numpy.array()创建二维数组的例子。
import numpy as np arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]]) print(arr)
输出结果如下：
[[1 2 3 4]
[5 6 7 8]]
从上面两个例子可以看出，NumPy数组各元素之间使用空格隔开，而非逗号之类的其他符号。
2. numpy.zeros()
使用numpy.zeros()函数创建一个指定形状和数据类型的数组，数组的数据全部为0。其语法格式如下：
numpy.zeros(shape, dtype=float, order='C')
各参数的主要含义：
shape - 待创建数组的形状，其值为一个整数或一个元组，如2 或 (2, 3)
dtype - 可选参数，数组的数据类型，默认为numpy.float64
order - 可选参数，取值为'C' 或 'F', 默认为'C'。在多维数组中，指定数据在内存中按行序优先（C风格）还是列序优先（Fortran风格）进行存储。
下面是使用该函数定义数组的例子：
import numpy as np arr1 = np.zeros(5) print('arr1:', arr1) arr2 = np.zeros((5,), dtype = int) print('arr2:', arr2) arr3 = np.zeros((2, 3)) print('arr3:\n', arr3) t = (2, 2) arr4 = np.zeros(t) print('arr4:\n', arr4)
输出结果如下：
arr1: [0. 0. 0. 0. 0.]
arr2: [0 0 0 0 0]
arr3:
[[0. 0. 0.]
[0. 0. 0.]]
arr4:
[[0. 0.]
[0. 0.]]
3. numpy.ones()
numpy.ones()函数用于创建一个元素都为1的数组。
其语法格式如下：
numpy.ones(shape, dtype=None, order='C')
其各参数的含义与numpy.zeros()函数相同。
下面使用几个例子来说明该函数的使用方法。
import numpy as np arr1 = np.ones(5) print('arr1:', arr1) arr2 = np.ones((5,), dtype = int) print('arr2:', arr2) arr3 = np.ones((2, 3)) print('arr3:\n', arr3) t = (2, 2) arr4 = np.ones(t) print('arr4:\n', arr4)
输出结果如下：
arr1: [1. 1. 1. 1. 1.]
arr2: [1 1 1 1 1]
arr3:
[[1. 1. 1.]
[1. 1. 1.]]
arr4:
[[1. 1.]
[1. 1.]]
4. numpy.arange()
numpy.arange()函数与Python当中的range()函数相似，其使用指定的start, stop及step创建一个等差序列构成的数组。
其语法格式如下：
numpy.arange([start,] stop[, step,] dtype=None, like=None)
各参数的含义描述如下：
start - 可选参数，一个整数或实数。间隔的开始项，其中间隔中包含该值，默认值为0。
stop - 一个整数或实数。生成间隔的截止数，间隔不包含该值。在一些特殊情况下有可能造成生成的间隔序列中包含该项，如在step为浮点数时，输出的间隔序列值经四舍五入后与stop值相同。
step - 可选参数，间隔序列值之间的间距。即输出的两个相邻数之间的差(out[i+1] - out[i])。该参数的默认值为1。如果step作为位置参数出现时，start参数也必须同时给出。
dtype - 可选参数，输出数组的数据类型。如dtype值未指定时，将从其他参数推定数组的数据类型。
like - 可选参数，类似数组的引用对象
下面通过例子来说明该函数的使用方式。
import numpy as np a1 = np.arange(4) a2 = np.arange(4.0) a3 = np.arange(3, 8) a4 = np.arange(3, 8, 2) print('a1:', a1) print('a2:', a2) print('a3:', a3) print('a4:', a4)
输出结果如下：
a1: [0 1 2 3]
a2: [0. 1. 2. 3.]
a3: [3 4 5 6 7]
a4: [3 5 7]
5. numpy.linspace()
numpy.linspace()函数是在指定的区间中生成均匀分布的数字。
该函数返回区间[start, stop]内计算得到的num个均匀分布的样本。
区间的端点可以选择排除在外。
其语法格式如下：
numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)
各参数的含义描述如下：
start - 区间序列值的起点，默认为0。
stop - 区间序列值的终点。
num - 可选参数，一个整型数，表示生成样本的数量。默认为50，不能为负值。
endpoint - 可选参数，布尔值，表示是否包含终点值。默认值为True，即stop是最后一个样本，否则不包含stop。
retstep - 可选参数，布尔值，表示是否返回step值。如果设置为True，则返回(samples, step)。默认为False。
dtype - 可选参数，表示生成数组的数据类型。若dtype未给出，则数据类型从start与stop参数进行推定。推定的数据类型不会是整数类型，即使设定的参数产生一个整数数列，数组数据类型也会被推定为float类型。
axis - 可选参数，其值为一个整数，表示存储样本结果值的轴，该参数只在start 或 stop 参数为数组类型时有效。默认值为0，表示样本沿着在开头插入的新轴存储。若设置为-1，则在结尾处插入新轴。
下面使用几个例子来讲解该函数的使用方法。
import numpy as np arr1 = np.linspace(1, 9, num=5)
print('arr1:', arr1,"\tarr1数据类型:", arr1.dtype)
arr2 = np.linspace(1, 9, num=5, endpoint=False)
print('arr2:', arr2,"\tarr2数据类型:", arr2.dtype)
arr3 = np.linspace(1, 9, num=5, retstep=True)
print('arr3:', arr3)
arr4 = np.linspace((1,2.5),(8, 12), num=5)
print('arr4:\n', arr4)
arr5 = np.linspace((1,2.5),(8, 12), num=5, axis=-1)
print('arr5:\n', arr5)
输出结果如下：
arr1: [1. 3. 5. 7. 9.] arr1数据类型: float64
arr2: [1. 2.6 4.2 5.8 7.4] arr2数据类型: float64
arr3: (array([1., 3., 5., 7., 9.]), 2.0)
arr4:
[[ 1. 2.5 ]
[ 2.75 4.875]
[ 4.5 7.25 ]
[ 6.25 9.625]
[ 8. 12. ]]
arr5:
[[ 1. 2.75 4.5 6.25 8. ]
[ 2.5 4.875 7.25 9.625 12. ]]
6. numpy.logspace()
Numpy中的logspace()函数用于生成一个在对数刻度上等间隔的数字数组。该函数适用于创建以指数方式增长的数值范围。
其语法格式如下：
numpy.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0)
各参数的含义如下：
start - 数组数据序列的开始值：base ** start，即:basestart .
stop - 数组数据序列的最后一个值：base ** stop，即: basestop 。当endpoint参数为False时，不包含该值。
num - 一个整数值，表示生成序列的样本值的数量，默认为50。
endpoint - 一个布尔值，表示是数据序列中是否包含stop值。默认值为True，如设置为False，则序列中不包含stop值。
base - 对数空间的底数，默认值为10。
dtype - 所产生数组的数据类型。在未指定该参数时，由start和stop参数推定，推定的类型不可能是整数类型，即使产生的数组数据序列都为整型，其推断的数据类型也是float。
axis - 存储数组数据值样本的轴。只有在start、stop或base参数为数组类型的才起作用。默认值为0，则产生的样本沿着在开始处创建的新轴进行分布。如果设置为-1，则在末尾创建新轴。
下面使用例子来说明该函数的具体使用方法。
import numpy as np arr1 = np.logspace(2, 3, num=5)
print('arr1:', arr1,"\tarr1数据类型:", arr1.dtype)
arr2 = np.logspace(2, 3, num=5, endpoint=False)
print('arr2:', arr2,"\tarr2数据类型:", arr2.dtype)
arr3 = np.logspace(2, 3, num=5, base=2)
print('arr3:', arr3)
arr4 = np.logspace(2, 3, num=5, base=(2, 3))
print('arr4:\n', arr4)
arr5 = np.logspace((2, 3),(5, 7), num=5, base=(2, 3))
print('arr5:\n', arr5)
arr6 = np.logspace((2, 3),(5, 7), num=5, base=(2, 3), axis=-1)
print('arr6:\n', arr6)
输出结果如下所示：
arr1: [ 100. 177.827941 316.22776602 562.34132519 1000. ] arr1数据类型: float64
arr2: [100. 158.48931925 251.18864315 398.10717055 630.95734448] arr2数据类型: float64
arr3: [4. 4.75682846 5.65685425 6.72717132 8. ]
arr4:
[[ 4. 9. ]
[ 4.75682846 11.84466612]
[ 5.65685425 15.58845727]
[ 6.72717132 20.51556351]
[ 8. 27. ]]
arr5:
[[ 4. 27. ]
[ 6.72717132 81. ]
[ 11.3137085 243. ]
[ 19.02731384 729. ]
[ 32. 2187. ]]
arr6:
[[ 4. 6.72717132 11.3137085 19.02731384 32. ]
[ 27. 81. 243. 729. 2187. ]]
7. numpy.geomspace
NumPy中的geomspace()函数用于生成一个几何等比序列，即每一项都是前一项与一个常数的乘积，该常数即等比序列的公比。
numpy.geomspace()函数的语法格式如下：
numpy.geomspace(start, stop, num=50, endpoint=True, dtype=None, axis=0)
各参数的含义描述如下：
start - 序列的开始值
stop - 序列的最后一个值。如果endpoint参数为False，则不包含该值。
num - 生成的样本数量，默认为50.
endpoint - 该参数设置为True时，则stop参数指定的值为最后一个样本，否则不不包含stop参数值。默认为True。
dtype - 输出数组的数据类型。如果未指定，则由start参数和stop参数进行推定。推断的数据类型一般为float，但不会是整数类型。
axis - 该参数只在多维数组中起作用，即start参数或stop参数设置为数组类型时才有用。当该参数为0时，则样本沿着在开头插入的新轴排列；当该参数为-1时，在末尾添加新轴并排列样本。
下面举例子说明该函数的使用方法。
import numpy as np arr1 = np.geomspace(1, 1000, num=4) print('arr1:', arr1) arr2 = np.geomspace(1, 1000, num=3, endpoint=False) print('arr2:', arr2) arr3 = np.geomspace(1, 1000, num=4, endpoint=False) print('arr3:', arr3) arr4 = np.geomspace(1, 256, num=9) print('arr4:', arr4) # 直接指定dtype arr5 = np.geomspace(1, 256, num=9, dtype=int) print('arr5:', arr5) # 先四舍五入后再转换为整型 arr6 = np.around(np.geomspace(1, 256, num=9)).astype(int) print('arr6:', arr6) # start > stop arr7 = np.geomspace(1000, 1, num=4) print('arr7:', arr7) # 使用负数 arr8 = np.geomspace(-1000, -1, num=4) print('arr8:', arr8) arr9 = np.geomspace(-1, -1000, num=4) print('arr9:', arr9) # 使用复数 arr10 = np.geomspace(1j, 1000j, num=4) print('arr10:', arr10) arr11 = np.geomspace(-1+0j, 1+0j, num=5) print('arr11:\n', arr11) # 多维 arr12 = np.geomspace((1, 3), (1000, 81), num=4) print('arr12:\n', arr12) arr13 = np.geomspace((1, 3), (1000, 81), num=4, axis=-1) print('arr13:\n', arr13)
输出结果如下所示：
arr1: [ 1. 10. 100. 1000.]
arr2: [ 1. 10. 100.]
arr3: [ 1. 5.62341325 31.6227766 177.827941 ]
arr4: [ 1. 2. 4. 8. 16. 32. 64. 128. 256.]
arr5: [ 1 2 4 7 16 32 63 127 256]
arr6: [ 1 2 4 8 16 32 64 128 256]
arr7: [1000. 100. 10. 1.]
arr8: [-1000. -100. -10. -1.]
arr9: [ -1. -10. -100. -1000.]
arr10: [0. +1.j 0. +10.j 0. +100.j 0.+1000.j]
arr11:
[-1.00000000e+00+0.j -7.07106781e-01+0.70710678j
6.12323400e-17+1.j 7.07106781e-01+0.70710678j
1.00000000e+00+0.j ]
arr12:
[[ 1. 3.]
[ 10. 9.]
[ 100. 27.]
[1000. 81.]]
arr13:
[[ 1. 10. 100. 1000.]
[ 3. 9. 27. 81.]]
8. numpy.empty()
NumPy模块中的empty()函数是创建一个未初始化的，且具有特定形状和数据类型的数组。即使用empty()函数创建的数组的数据元素值未确定，亦即使用该函数创建一个空数组。
numpy.empty()函数的语法格式如下：
numpy.empty(shape, dtype=float, order='C', like=None)
各参数的含义如下：
shape - 一个整型数或包含整型数的序列（如元组，列表），用于定义数组的形状（维数）。
dtype - 可选参数，用于指定数组的数据类型，默认为float64。
order - 可选参数，其值为 'C' 或 'F' ，用于指定数组的风格，默认为'C'，即C风格的数组（行优先），用户也可设置为 'F' ，即Fortran风格的数组（列优先）。
like - 可选参数，允许用户创建一个与已有数组形状和类型相似的数组。
下面使用几个例子来说明numpy.empty()函数的具体使用方式。
import numpy as np arr1 = np.empty(5) print('arr1:', arr1, ', arr1 dtype:', arr1.dtype) arr2 = np.empty((2, 2)) print('arr2:\n', arr2) arr3 = np.empty([2, 2], dtype=np.int32) print('arr3:\n', arr3)
输出结果如下：
arr1: [4.94065646e-324 3.95252517e-323 3.95252517e-323 3.95252517e-323
1.23492111e-311] , arr1 dtype: float64
arr2:
[[2.12199579e-314 1.23287955e-311]
[5.33590898e-321 1.23288784e-311]]
arr3:
[[-1412953232 32767]
[ 1 0]]
因为数组未初始化，其输出的值是内存中的随机值，并不是确定的。
9. numpy.full()
NumPy模块中的full()函数用于创建一个具有特定形状和数据类型，且数组元素都为指定值的数组。
其语法格式如下：
numpy.full(shape, fill_value, dtype=None, order='C', like=None)
各参数的含义描述如下：
shape - 数据的形状，其值为一个整型数或为整型数序列。
fill_value - 数组的填充值。
dtype - 可选参数，数组的数据类型，默认为None，则其与fill_value指定的填充值类型相同。
order - 可选参数，指定数组数据的存储风格，其值为{'C', 'F'}中的一个，默认值为'C'，即按C风格存储数据元素（行优先），若设定为'F'， 则指Fortran风格的数组（列优先）。
like - 可选参数，创建数组时指定参照的非NumPy数组对象。
下面使用例子来说明numpy.full()函数的具体使用方法。
import numpy as np arr1 = np.full(5, 2) print('arr1:', arr1) arr2 = np.full([2, 3], 18) print('arr2:\n', arr2) arr3 = np.full((2, 3), np.inf) print('arr3:\n', arr3) arr4 = np.full([2, 3], 'biye5u.com') print('arr4:\n', arr4) arr5 = np.full((2, 3), [1, 2, 3]) print('arr5:\n', arr5)
输出结果如下：
arr1: [2 2 2 2 2]
arr2:
[[18 18 18]
[18 18 18]]
arr3:
[[inf inf inf]
[inf inf inf]]
arr4:
[['biye5u.com' 'biye5u.com' 'biye5u.com']
['biye5u.com' 'biye5u.com' 'biye5u.com']]
arr5:
[[1 2 3]
[1 2 3]]
10. numpy.eye()
NumPy中的eye()函数用于创建一个对角线上的数值为1，其余地方为0的二维数组。该函数常用于数值计算中构造单位矩阵或类似结构。
numpy.eye()函数的语法格式如下：
numpy.eye(N, M=None, k=0, dtype=float, order='C', like=None)
各参数的含义描述如下：
N - 一个整型数，表示所构造数组的行数。
M - 可选参数，一个整型数，表示所构造数组的列数。
k - 可选参数，一个整型数，表示对角线的索引。0：代表主对角线；正整数：上对角线；负整数：下对角线。默认值为0.
dtype - 可选参数，表示数组的数据类型。
order - 可选参数，为集合{'C', 'F'}中的一个值。指示数组数据的存储风格，'C'：C风格存储风格（行优先），'F'：Fortran数组存储风格（列优先）。默认值为'C'。
like - 可选参数，指定可参照的非NumPy数组对象。
该函数返回一个二维数组，数组的第k对角线上的值为1， 其余位置为0。
下面使用例子来说明numpy.eye()函数的具体使用方法。
import numpy as np arr1 = np.eye(3, 4) print('arr1:\n', arr2) arr2 = np.eye(3, dtype=np.int32) print('arr2(k=0):\n', arr2) arr3 = np.eye(3, k=1) print('arr3(k=1):\n', arr3) arr4 = np.eye(3, k=2) print('arr4(k=2):\n', arr4) arr5 = np.eye(3, k=-1) print('arr5(k=-1):\n', arr5) arr6 = np.eye(3, k=-2) print('arr6(k=-2):\n', arr6)
输出结果如下所示：
arr1:
[[1. 0. 0. 0.]
[0. 1. 0. 0.]
[0. 0. 1. 0.]]
arr2(k=0):
[[1 0 0]
[0 1 0]
[0 0 1]]
arr3(k=1):
[[0. 1. 0.]
[0. 0. 1.]
[0. 0. 0.]]
arr4(k=2):
[[0. 0. 1.]
[0. 0. 0.]
[0. 0. 0.]]
arr5(k=-1):
[[0. 0. 0.]
[1. 0. 0.]
[0. 1. 0.]]
arr6(k=-2):
[[0. 0. 0.]
[0. 0. 0.]
[1. 0. 0.]]
11. numpy.identity()
NumPy模块中的identity()函数用于创建一个n×n的方形矩阵，矩阵的对角线上的值为1，其余位置为0。该函数常用于线性代数和数值计算中。
numpy.identity()函数的语法形式如下所示。
numpy.identity(n, dtype=None, like=None)
该函数的各参数的含义描述如下：
n - 一个整型数，表示数组的行数和列数。
dtype - 可选参数，表示数组的数据类型，默认为 float 。
like - 可选参数，用已存在的数组型对象的形式来创建当前数组。
下面是使用numpy.identity()函数的例子。
import numpy as np arr1 = np.identity(2) print('arr1:\n', arr1) arr2 = np.identity(3, dtype=np.int32) print('arr2:\n', arr2) arr3 = np.identity(3, dtype=complex) print('arr3:\n', arr3)
输出结果如下所示：
arr1:
[[1. 0.]
[0. 1.]]
arr2:
[[1 0 0]
[0 1 0]
[0 0 1]]
arr3:
[[1.+0.j 0.+0.j 0.+0.j]
[0.+0.j 1.+0.j 0.+0.j]
[0.+0.j 0.+0.j 1.+0.j]]
12. numpy.diag()
NumPy中的diag()函数用于从1个二维矩阵数组中提取对角线上的数据元素，或者使用列表或一维数组创建一个对角矩阵。
numpy.diag()函数的语法格式如下：
numpy.diag(v, k=0)
各参数的含义描述如下：
v - 数组形式的数据对象，如果v是一个二维数组，该函数将返回该数组第k条对角线上的元素；如果v是一个一维数组，该函数将返回第k条对角线上的数据元素为v的一个二维数组。
k - 可选参数，指定对角线。0：表示主对角线；k>0：主对角线上部；k<0：主对角线下部。
下面给出例子来说明numpy.diag()函数的使用方法。
import numpy as np x = np.arange(9).reshape((3, 3)) print('x=\n', x) a = np.diag(x) print('a=', a) b = np.diag(x, k=1) print('b=', b) c = np.diag(x, k=-1) print('c=', c) y = np.array([11, 22, 33]) d = np.diag(y) print('y=', y) print('d=\n', d)
输出结果如下：
x=
[[0 1 2]
[3 4 5]
[6 7 8]]
a= [0 4 8]
b= [1 5]
c= [3 7]
y= [11 22 33]
d=
[[11 0 0]
[ 0 22 0]
[ 0 0 33]]
13. numpy.vander()
NumPy模块中的vander()函数用于生成一个范德蒙德矩阵（矩阵的各行元素由等比数列构成）。
其语法格式如下：
numpy.vander(x, N=None, increasing=False)
各参数的含义描述如下：
x - 一个一维数组。
N - 可选参数，一个整数，代表生成数组的列数。若N未指定，则N为参数x的长度（N = len(x)），并生成一个方阵。
increasing - 可选参数，布尔类型，代表列的幂次顺序。如果该参数取值为True，则表示幂次从左到右递增；如果该参数取值为False，则表示幂次从左到右递减。默认值为False。
该函数生成一个范德蒙德矩阵。如果参数increasing为False，则第1列的是x^(N-1)，第2列是x^(N-2)，以此类推。如果increasing参数取值为True，矩阵的各列依次是：x^0, x^1, ..., x^(N-1).
下面使用例子来说明该函数的使用方法。
import numpy as np x = np.array([1, 2, 3, 5]) N = 3 arr1 = np.vander(x, N) print('arr1:') print(arr1) arr2 = np.vander(x) print('\narr2:') print(arr2) arr3 = np.vander(x, increasing=True) print('\narr3:') print(arr3)
输出结果如下：
arr1:
[[ 1 1 1]
[ 4 2 1]
[ 9 3 1]
[25 5 1]]
arr2:
[[ 1 1 1 1]
[ 8 4 2 1]
[ 27 9 3 1]
[125 25 5 1]]
arr3:
[[ 1 1 1 1]
[ 1 2 4 8]
[ 1 3 9 27]
[ 1 5 25 125]]
14. numpy.tri()
NumPy模块中的tri()函数产生的数组在其对角线及以下数据元素为1，而其他位置的元素为0.
numpy.tri()函数的语法格式如下：
numpy.tri(N, M=None, k=0, dtype=float, like=None)
各参数的含义描述如下：
N - 一个整型数，表示数组的行数。
M - 可选参数，一个整型数，表示数组的列数。在未设置该参数时，其值默认与N相同。
k - 可选参数， 一个整型数，用于指定对角线。k=0 表示主对角线；k<0表示主对角线以下部分；k>0表示主对角线以上的部分。默认值为0。
dtype - 可选参数，表示返回数组的数据类型，默认为float。
like - 可选参数。用于返回数组的参照数组。
下面使用例子来说明numpy.tri()函数的使用和结果情况。
import numpy as np arr1 = np.tri(3) print('arr1:') print(arr1) arr2 = np.tri(3, 4) print('\narr2:') print(arr2) arr3 = np.tri(4, dtype=np.int32, k=1) print('\narr3:') print(arr3) arr4 = np.tri(4, dtype=np.int32, k=-1) print('\narr4:') print(arr4)
输出结果如下所示：
arr1:
[[1. 0. 0.]
[1. 1. 0.]
[1. 1. 1.]]
arr2:
[[1. 0. 0. 0.]
[1. 1. 0. 0.]
[1. 1. 1. 0.]]
arr3:
[[1 1 0 0]
[1 1 1 0]
[1 1 1 1]
[1 1 1 1]]
arr4:
[[0 0 0 0]
[1 0 0 0]
[1 1 0 0]
[1 1 1 0]]
15. numpy.tril()
NumPy中的tril()函数用于返回一个数组的副本，其中返回数组第k条对角线以上的数据元素被置为0。当原数组的ndim超过2时，则该规则运用于最后两个轴。
numpy.tril()函数的语法格式如下：
numpy.tril(m, k=0)
其参数的含义描述如下：
m - 输入的数组。
k - 可选参数，一个整型数，用户指定的对角线。k=0表示主对角线，k>0表示主对角线上部的某一对角线，k<0表示主对角线下部的某一条对角线。默认值为0。
该函数返回以k为对角线的下三角矩阵（含对角线上的数据）。
下面给出numpy.tril()函数运用的一些例子。
import numpy as np m1 = np.array([[1,2,3],[4,5,6],[7,8,9]]) print(f'm1=\n{m1}') arr1 = np.tril(m1) print('\narr1:') print(arr1) arr2 = np.tril(m1, 1) print('\narr2:') print(arr2) arr3 = np.tril(m1, -1) print('\narr3:') print(arr3) m2 = np.arange(60).reshape(3,4,5) print('\nm2=') print(m2) arr4 = np.tril(m2) print('\narr4=') print(arr4)
输出结果如下所示：
m1=
[[1 2 3]
[4 5 6]
[7 8 9]]
arr1:
[[1 0 0]
[4 5 0]
[7 8 9]]
arr2:
[[1 2 0]
[4 5 6]
[7 8 9]]
arr3:
[[0 0 0]
[4 0 0]
[7 8 0]]
m2=
[[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]]
[[20 21 22 23 24]
[25 26 27 28 29]
[30 31 32 33 34]
[35 36 37 38 39]]
[[40 41 42 43 44]
[45 46 47 48 49]
[50 51 52 53 54]
[55 56 57 58 59]]]
arr4=
[[[ 0 0 0 0 0]
[ 5 6 0 0 0]
[10 11 12 0 0]
[15 16 17 18 0]]
[[20 0 0 0 0]
[25 26 0 0 0]
[30 31 32 0 0]
[35 36 37 38 0]]
[[40 0 0 0 0]
[45 46 0 0 0]
[50 51 52 0 0]
[55 56 57 58 0]]]
16. numpy.triu()
NumPy中的triu()函数用于返回一个数组的副本，其中返回数组第k条对角线以下的数据元素被置为0。当原数组的ndim超过2时，则该规则运用于最后两个轴。
numpy.triu()函数的语法格式如下：
numpy.triu(m, k=0)
其参数的含义描述如下：
m - 输入的数组。
k - 可选参数，一个整型数，用户指定的对角线。k=0表示主对角线，k>0表示主对角线上部的某一对角线，k<0表示主对角线下部的某一条对角线。默认值为0。
该函数返回原数组的上三角矩阵（含对角线上的数据）。
下面给出numpy.tril()函数运用的一些例子。
import numpy as np m1 = np.array([[1,2,3],[4,5,6],[7,8,9]]) print(f'm1=\n{m1}') arr1 = np.triu(m1) print('\narr1:') print(arr1) arr2 = np.triu(m1, 1) print('\narr2:') print(arr2) arr3 = np.triu(m1, -1) print('\narr3:') print(arr3) m2 = np.arange(60).reshape(3,4,5) print('\nm2=') print(m2) arr4 = np.triu(m2) print('\narr4=') print(arr4)
输出结果如下所示：
m1=
[[1 2 3]
[4 5 6]
[7 8 9]]
arr1:
[[1 2 3]
[0 5 6]
[0 0 9]]
arr2:
[[0 2 3]
[0 0 6]
[0 0 0]]
arr3:
[[1 2 3]
[4 5 6]
[0 8 9]]
m2=
[[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]]
[[20 21 22 23 24]
[25 26 27 28 29]
[30 31 32 33 34]
[35 36 37 38 39]]
[[40 41 42 43 44]
[45 46 47 48 49]
[50 51 52 53 54]
[55 56 57 58 59]]]
arr4=
[[[ 0 1 2 3 4]
[ 0 6 7 8 9]
[ 0 0 12 13 14]
[ 0 0 0 18 19]]
[[20 21 22 23 24]
[ 0 26 27 28 29]
[ 0 0 32 33 34]
[ 0 0 0 38 39]]
[[40 41 42 43 44]
[ 0 46 47 48 49]
[ 0 0 52 53 54]
[ 0 0 0 58 59]]]
17. numpy.zeros_like()
numpy.zeros_like()函数用于创建与给定数组具有相同形状和数据类型的数组，且数组的数据都为0。
该函数的语法形式如下：
numpy.zeros_like(a, dtype=None, order='K', subok=True, shape=None)
各参数的含义描述如下：
a - 用于定义新数组形状和数据类型的给定数组。
dtype - 可选参数，用于指定返回数组的数据类型，将覆盖给定数组的数据类型。
order - 可选参数，用于指定数组数据在内存中的布局情况。其取值为{'C', 'F', 'A', 'K'}中之一。'C' 指C风格（行优先）；'F' 指Fortran风格（列优先）；'A' 指若参数a给定的数组为Fortran风格的则为'F', 其他情况为'C' ；'K' 指尽可能的与参数a给定的数组存储顺序保持一致。
subok - 可选参数，布尔类型，表示是否返回子类，若取值为True，则新建数组为a的子类类型，否则新建数组为基类型的数组。默认为True。
shape - 新建数组的形状，指定后将会覆盖数组a所具有的形状。
下面使用例子来说明该函数的使用方法。
import numpy as np a = np.arange(6).reshape((2,3)) print('a=') print(a) arr1 = np.zeros_like(a) print('arr1:') print(arr1) b = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int32) print('\nb=') print(b) arr2 = np.zeros_like(b, dtype=np.float32) print('arr2:') print(arr2)
输出结果如下：
a=
[[0 1 2]
[3 4 5]]
arr1:
[[0 0 0]
[0 0 0]]
b=
[[1 2 3]
[4 5 6]]
arr2:
[[0. 0. 0.]
[0. 0. 0.]]
18. numpy.ones_like()
numpy.ones_like()函数用于生成一个与给定数组形状和数据类型相同的数组，且数组数据都为1。
其语法格式如下：
numpy.ones_like(a, dtype=None, order='K', subok=True, shape=None)
各参数的含义描述如下：
a - 用于定义新数组形状和数据类型的给定数组。
dtype - 可选参数，用于指定返回数组的数据类型，将覆盖给定数组的数据类型。
order - 可选参数，用于指定数组数据在内存中的布局情况。其取值为{'C', 'F', 'A', 'K'}中之一。'C' 指C风格（行优先）；'F' 指Fortran风格（列优先）；'A' 指若参数a给定的数组为Fortran风格的则为'F', 其他情况为'C' ；'K' 指尽可能的与参数a给定的数组存储顺序保持一致。
subok - 可选参数，布尔类型，表示是否返回子类，若取值为True，则新建数组为a的子类类型，否则新建数组为基类型的数组。默认为True。
shape - 新建数组的形状，指定后将会覆盖数组a所具有的形状。
下面使用例子来说明该函数的使用方法。
import numpy as np a = np.arange(6).reshape((2,3)) print('a=') print(a) arr1 = np.ones_like(a) print('arr1:') print(arr1) b = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int32) print('\nb=') print(b) arr2 = np.ones_like(b, dtype=np.float32) print('arr2:') print(arr2)
输出结果如下：
a=
[[0 1 2]
[3 4 5]]
arr1:
[[1 1 1]
[1 1 1]]
b=
[[1 2 3]
[4 5 6]]
arr2:
[[1. 1. 1.]
[1. 1. 1.]]
19. numpy.empty_like()
numpy.empty_like()函数用于创建与给定数组具有相同形状和数据类型的数组，且数组元素为未初始化状态。
其语法形式如下所示：
numpy.empty_like(prototype, dtype=None, order='K', subok=True, shape=None)
各参数的含义描述如下：
prototype - 用于定义新数组形状和数据类型的给定数组。
dtype - 可选参数，用于指定返回数组的数据类型，将覆盖给定数组的数据类型。
order - 可选参数，用于指定数组数据在内存中的布局情况。其取值为{'C', 'F', 'A', 'K'}中之一。'C' 指C风格（行优先）；'F' 指Fortran风格（列优先）；'A' 指若参数prototype给定的数组为Fortran风格的则为'F', 其他情况为'C' ；'K' 指尽可能的与参数prototype给定的数组存储顺序保持一致。
subok - 可选参数，布尔类型，表示是否返回子类，若取值为True，则新建数组为prototype的子类类型，否则新建数组为基类型的数组。默认为True。
shape - 新建数组的形状，指定后将会覆盖数组prototype所具有的形状。
该函数返回一个与prototype具有相同形状和数据类型且未初始化的数组。
下面使用例子来说明该函数的使用方法。
import numpy as np a = ([1, 2, 3], [4, 5, 6]) print('a=', a) arr1 = np.empty_like(a) print('arr1:') print(arr1) b = np.array([[11, 12, 13], [21, 22, 23]], dtype=np.int64) arr2 = np.empty_like(b, dtype=np.float32) print('\narr2:') print(arr2)
输出结果形式如下：
a= ([1, 2, 3], [4, 5, 6])
arr1:
[[1065353216 1065353216 1065353216]
[1065353216 1065353216 1065353216]]
arr2:
[[1.e-45 3.e-45 4.e-45]
[6.e-45 7.e-45 8.e-45]]
因为numpy.empty_like()函数创建的数组不会初始化，上面的输出值是内存中存储的任意值。在具体使用所创建的数组时，应对数组的每个值进行赋值。
20. numpy.full_like()
numpy.full_like函数的作用是创建一个与给定数组具有相同形状与数据类型，且由指定值进行填充的数组。
其语法格式如下：
numpy.full_like(a, fill_value, dtype=None, order='K', subok=True, shape=None)
各参数的含义描述如下：
a - 用于定义新数组形状和数据类型的给定数组。
fill_value - 数组要填充的值。
dtype - 可选参数，用于指定返回数组的数据类型，将覆盖给定数组的数据类型。
order - 可选参数，用于指定数组数据在内存中的布局情况。其取值为{'C', 'F', 'A', 'K'}中之一。'C' 指C风格（行优先）；'F' 指Fortran风格（列优先）；'A' 指若参数a给定的数组为Fortran风格的则为'F', 其他情况为'C' ；'K' 指尽可能的与参数a给定的数组存储顺序保持一致。
subok - 可选参数，布尔类型，表示是否返回子类，若取值为True，则新建数组为a的子类类型，否则新建数组为基类型的数组。默认为True。
shape - 新建数组的形状，若指定该参数，将会覆盖数组a所具有的形状。
下面使用例子来说明该函数的使用方法。
import numpy as np x = np.array([11, 12, 13]) print('x=', x) arr1 = np.full_like(x, 1) print('arr1=', arr1) arr2 = np.full_like(x, 1.5) print('arr2=', arr2) arr3 = np.full_like(x, 1.5, dtype=np.float32) print('arr3=', arr3) arr4 = np.full_like(x, np.nan, dtype=np.float64) print('arr4=', arr4) y = np.array([[11, 12, 13], [21, 22, 23]]) print('y=') print(y) arr5 = np.full_like(y, 1) print('arr5=') print(arr5) arr6 = np.full_like(y, [1, 2, 3]) print('arr6=') print(arr6)
输出结果如下：
x= [11 12 13]
arr1= [1 1 1]
arr2= [1 1 1]
arr3= [1.5 1.5 1.5]
arr4= [nan nan nan]
y=
[[11 12 13]
[21 22 23]]
arr5=
[[1 1 1]
[1 1 1]]
arr6=
[[1 2 3]
[1 2 3]]
微信搜索“优雅的代码”关注本站的公众号，或直接使用微信扫描下面二维码关注本站公众号，以获取最新内容。
个人成长离不开各位的关注，你的关注就是我继续前行的动力。
- 给好评 如果您觉得此内容好，就请您
0%(0) 
- 给差评 如果您觉得此内容差，就请您
0%(0) 