【科学计算包NumPy】NumPy数组的创建

Francek Chen

发布于 2025-01-22 20:47:15

1.1K00

代码可运行

运行总次数：0

代码可运行

NumPy 是在1995年诞生的 Python 库 Numeric 的基础上建立起来的，但真正促使 NumPy 的发行的是 Python 的 SciPy 库。但 SciPy 中并没有合适的类似于 Numeric 中的对于基础数据对象处理的功能。于是， SciPy 的开发者将 SciPy 中的一部分和 Numeric 的设计思想结合，在 2005 年发行了 NumPy。

科学计算包 NumPy 是 Python 的一种开源的数值计算扩展库。它包含很多功能，如创建 n 维数组（矩阵）、对数组进行函数运算、数值积分等。 NumPy 的诞生弥补了这些缺陷，它提供了两种基本的对象：

ndarray ：是储存单一数据类型的多维数组。
ufunc ：是一种能够对数组进行处理的函数。

NumPy 常用的导入格式： import numpy as np

一、创建数组对象

通常来说， ndarray 是一个通用的同构数据容器，即其中的所有元素都需要相同的类型。利用 array 函数可创建 ndarray 数组。

（一）利用array函数创建数组对象

array 函数的格式： np.array(object, dtype, ndmin)

array 函数的主要参数及说明：

参数名称	说明
object	接收 array ，表示想要创建的数组
dtype	接收 data-type ，表示数组所需的数据类型，未给定则选择保存对象所需的最小类型，默认为 None
ndmin	接收 int ，制定生成数组应该具有的最小维数，默认为 None

import numpy as np

data1 = [1,3,5,7]    # 列表
w1 = np.array(data1)
print('w1:',w1)

data2 = (2,4,6,8)    # 元组
w2 = np.array(data2)
print('w2:',w2)

data3 = [[1,2,3,4],[5,6,7,8]]    # 多维数组
w3 = np.array(data3)
print('w3:',w3)

输出：

w1: [1 3 5 7]
w2: [2 4 6 8]
w3: [[1 2 3 4]
 [5 6 7 8]]

（二）专门创建数组的函数

1、arange 函数：创建等差一维数组

格式： np.arange(start, stop, step, dtype)

参数名称	说明
start	起始值，可省略，默认从 0 开始；
stop	结束值；生成的元素不包括结束值；
step	步长，可省略，默认步长为1；
dtype	设置元素的数据类型，默认使用输入数据的类型。

a1 = np.arange(10)
print('a1:',a1)

a2 = np.arange(1,10,2)
print('a2:',a2)

print(a2.dtype)    # 元素类型是int32

输出：

a1: [0 1 2 3 4 5 6 7 8 9]
a2: [1 3 5 7 9]
int32

2、linspace 函数：创建等差一维数组，接收元素数量作为参数。

格式： np.linspace(start, stop, num, endpoint, retstep=False, dtype=None)

参数名称	说明
start	起始值，默认从 0 开始;
stop	结束值；生成的元素不包括结束值；
num	要生成的等间隔样例数量

a3 = np.linspace(0,100,11)   # 注意：连同首尾共11个端点，10个区间（最后一个参数表示数组中元素的数量）
print('a3:',a3)

print(a3.dtype)    # 元素类型是float64

输出：

a3: [   0.   10.   20.   30.   40.   50.   60.   70.   80.   90.  100.]
float64

3、logspace 函数：创建等比一维数组

格式： np.logspace(start, stop, num, endpoint=True, base=10.0, dtype=None)

logspace 的参数中， start, stop 代表的是 10 的幂，num 代表要生成的元素数量，默认基数 base 为 10 。

a4 = np.logspace(1,3,3)  # 参数含义与linespace相同，但这些元素将作为指数出现，默认底数是10
print('a4:',a4)

a5 = np.logspace(1,3,3,base=3)   # 修改底数为3
print('a5:',a5)

输出：

a4: [   10.   100.  1000.]
a5: [  3.   9.  27.]

4、ones 函数：创建指定长度或形状的全 1 数组

格式： np. ones(shape, dtype=None, order='C')

a6 = np.ones((3,4))  # 参数(3,4)用于指定形状，相当于np.ones(shape=(3,4))
print(a6)

输出：

[[ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]]

5、zeros 函数：创建指定长度或形状的全 0 数组

格式： np.zeros(shape, dtype=float, order='C')

a7 = np.zeros((3,3))
print(a7)

输出：

[[ 0.  0.  0.]
 [ 0.  0.  0.]
 [ 0.  0.  0.]]

np.zeros_like函数

a8 = np.zeros_like(a6)  # 用已有数组的形状来创建新数组常使用*_like函数
print(a8)

输出：

[[ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]]

6、full 函数：根据指定形状，并用同一参数填充的新数组

格式：np.full(shape, fill_value, dtype=None, order='C')

a9 = np.full((2,4),5)    # 第1个参数(2,4)指明了形状，第2个参数给出了元素值
print(a9)                # 等价于5*np.ones((2,4))

输出：

[[5 5 5 5]
 [5 5 5 5]]

7、identity 函数：用于创建一个

n*n

的单位矩阵(主对角线元素全为1，其余全为0的矩阵)

格式：np.identity(n, dtype=float）

b1 = np.identity(3)    # 必须是n阶方阵，而且1只能在主对角线上
print(b1)

输出：

[[ 1.  0.  0.]
 [ 0.  1.  0.]
 [ 0.  0.  1.]]

8、eye 函数：返回一个N×M阶的矩阵（k所代表的对角线为上的元素1）

格式：np.eye(N,M=None, k=0, dtype=<class 'float'>, order='C)

参数名称	说明
N	int型，代表返回的矩阵的行数是N
M	int型，代表返回的矩阵的列数是M（默认是None）
k	int型，k=0代表是主对角线，k每增加1就往上移动一位对角线，k每减小1就往下移动一位对角线。(默认是0，即主对角线)
dtype	数组元素的类型，默认为float64

b2 = np.eye(3)     # 与上面相同,相当于np.eye(3,k=0) 参数k=0表示元素1出现主对角线上
print(b2)

输出：

[[ 1.  0.  0.]
 [ 0.  1.  0.]
 [ 0.  0.  1.]]

虽然 eye 函数和 identity 函数都能创建单位阵，但 eye比 identity 更灵活，见下面。

元素1都出现在主对角线之上：

b3 = np.eye(3,k=1)    # 元素1都出现在主对角线之上
print(b3)

输出：

[[ 0.  1.  0.]
 [ 0.  0.  1.]
 [ 0.  0.  0.]]

元素1都出现在主对角线之下：

b4 = np.eye(3,k=-1)    # 元素1都出现在主对角线之下
print(b4)

输出：

[[ 0.  0.  0.]
 [ 1.  0.  0.]
 [ 0.  1.  0.]]

前2个参数用于指定形状，可以不是方阵：

b5 = np.eye(3,4,k=1)
print(b5)

输出：

[[ 0.  1.  0.  0.]
 [ 0.  0.  1.  0.]
 [ 0.  0.  0.  1.]]

9、diag 函数：创建一个对角阵

格式： np.diag(v, k=0)

列表作为参数指定了对角线的元素：

b6 = np.diag([5,6,7])
print(b6)

输出：

[[5 0 0]
 [0 6 0]
 [0 0 7]]

diag 是 eye 的推广，允许指定对角线的元素是非1的值：

b7 = np.diag([5,6,7],k=1)
print(b7)

输出：

[[0 5 0 0]
 [0 0 6 0]
 [0 0 0 7]
 [0 0 0 0]]

二、ndarray对象属性和数组转置

（一）数组对象属性

属性	说明
ndim	返回数组的轴的个数
shape	返回数组的维度
size	返回数组元素个数
dtype	返回数据类型
itemsize	返回数组中每个元素的字节大小

c1 = np.array([1,2,3,4])
print('秩为：',c1.ndim)
print('形状为：',c1.shape)    # 结果显示的(4,)不应该理解为沿轴0有4行，而应该理解为沿着唯一的维度(其实是轴1)方向有4个元素
print('元素个数为：',c1.size)
print('数据类型为：',c1.dtype)
print('每个元素的字节大小：',c1.itemsize)
print(c1.nbytes)
type(c1)    # 最后一个不用print就可以输出

输出：

秩为： 1
形状为： (4,)
元素个数为： 4
数据类型为： int32
每个元素的字节大小： 4
16
numpy.ndarray

（二）数组的转置

1、一维数组的转置还是它本身

c2 = c1.T
print(c2.shape)
c2

输出：

(4,)
array([1, 2, 3, 4])

2、二维数组的转置

c3 = np.array([[1],[2],[3]])    # 形状为(3,1)的列向量
print(c3)
print(c3.shape)
c4 = c3.T      # 转置后变成形状为(1,3)的行向量
print(c4)
print(c4.shape)

输出：

[[1]
 [2]
 [3]]
(3, 1)
[[1 2 3]]
(1, 3)

三、生成随机数组

（一）通过random模块创建随机数组

在 NumPy.random 模块中，提供了多种随机数的生成函数。如 randint 函数生成指定范围的随机整数来构成指定形状的数组。注意：涉及到区间时均是左闭右开。

用法：np.random.randint(low, high = None, size = None)

1、设定随机数种子，这样每次运行的数据都相同。

np.random.seed(666)

2、产生[0,1）范围内的5个随机小数构成的一维数组。

d1 = np.random.random(5)
print(d1)

输出：

[ 0.70043712  0.84418664  0.67651434  0.72785806  0.95145796]

3、产生[0,1）范围内的随机小数构成的二维数组。

d2 = np.random.random((2,3))     # 此处需要使用元组，与下面的rand函数不同
d2

输出：

array([[ 0.0127032 ,  0.4135877 ,  0.04881279],
       [ 0.09992856,  0.50806631,  0.20024754]])

4、产生[1,100）范围内的6个随机整数构成的一维数组。

d3 = np.random.randint(1,100,6)
print(d3)

输出：

[40 70 83 77 80 14]

5、产生[1,100）范围内的随机整数构成的二维数组。

d4 = np.random.randint(1,100,(2,3))
d4

输出：

array([[70, 21, 12],
       [25, 21, 37]])

random模块的常用随机数生成函数：

函数	说明
seed	确定随机数生成器的种子
permutation	返回一个序列的随机排列或返回一个随机排列的范围，不会改变原数组
shuffle	对一个序列进行随机排序，会改变原数组
binomial	产生二项分布的随机数
normal	产生正态（高斯）分布的随机数
beta	产生 beta 分布的随机数
chisquare	产生卡方分布的随机数
gamma	产生 gamma 分布的随机数
uniform	产生在 [0,1) 中均匀分布的随机数

（二）分布函数

下面四个与分布有关，其中前两个分布函数是后两个的简化形式。

1、产生[0，1）范围且服从均匀分布的随机小数构成的数组

d5 = np.random.rand(2,3)    # 此处数组形状不能使用元组，与上面的random函数不同
print(d5)

输出：

[[ 0.8578588   0.76741234  0.95323137]
 [ 0.29097383  0.84778197  0.3497619 ]]

2、产生服从标准正态分布（均值为0、标准差为1）的随机小数构成的数组

d6 = np.random.randn(2,3)    # 此处数组形状不能使用元组，与上面的random函数不同
print(d6)

输出：

[[-0.21326813  0.44076692  0.69339587]
 [ 0.03820097 -0.18592982 -0.35371521]]

3、产生[a,b)范围内的均匀分布数组

d7 = np.random.uniform(1,11,(2,3))    # 此处数组形状需要使用元组
print(d7)

输出：

[[ 5.67585496  4.15815319  4.90162586]
 [ 3.68329811  8.53663841  7.66737465]]

4、产生更一般的正态分布（均值为a，标准差为b）数组

d8 = np.random.normal(5,2,(2,3))     # 此处数组形状需要使用元组
print(d8)

输出：

[[ 5.12204808,  7.15712276,  3.40432856],
 [ 7.3402652 ,  5.22424341,  5.06370777]]

（三）choice函数

choice 函数原型：numpy.random.choice(a, size=None, replace=True, p=None)

choice 函数表示从给定一维数组 a 或由 n 确定的 arange(n) 数列中以一定概率 p 随机采样 size 次，当 replace 为 True 时表示有放回取样（取样元素可能重复），否则是不放回取样（取样元素不会重复）。

d9 = np.random.choice(5,3)    # 从整数0~4中均匀采样，并且可以有重复元素
print(d9)
d10 = np.random.choice(5,3,replace=False,p=[0,0.2,0.3,0.4,0.1])    # 以指定概率不重复采样
print(d10)

ls = ['a','b','c','e','f','g']
d11 = np.random.choice(ls,5,p=[0.15,0.15,0.2,0.05,0.2,0.25])
d11

输出：

[0 3 3]
[3 2 4]
array(['f', 'f', 'b', 'f', 'f'],
      dtype='<U1')

（四）随机排序

1、shuffle 函数

shuffle 函数会修改原数组。

print(d3)     # 输出排序前的c3
np.random.shuffle(d3)
print(d3)     # 输出排序后的c3，发现shuffle函数会修改原数组

输出：

[40 70 83 77 80 14]
[77 70 14 80 40 83]

2、permutation 函数

permutation 函数不会改变原数组，而会创建一个新数组。

d12 = np.random.permutation(d3)    # permutation不会改变原数组，而会创建一个新数组
print(d3)
d12

输出：

[77 70 14 80 40 83]
array([83, 80, 77, 40, 14, 70])

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2024-03-26，如有侵权请联系 cloudcommunity@tencent.com 删除

函数

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度