5. Numpy的创建数组

《玩转Numpy计算库》视频课程
《玩转Numpy计算库》视频课程链接：https://edu.csdn.net/course/detail/28656

创建数组 (Creating Arrays)

首先，可以从列表和元组创建Numpy数组。

另外，Numpy提供了一些函数来创建在给定间隔内具有均匀间隔值的数组。

• arange使用给定的间隔；
• 另一个linspace需要知道元素的数量而自动创建元素之间的间隔。

使用np.array()创建数组

创建简单数组所需要做的就是将列表传递给它。还可以在列表中指定数据类型。

import numpy as np
a = np.array([1, 2, 3])
print(a)

[1 2 3]

指定数据类型

默认数据类型为浮点（np.float64）。可以使用dtype关键字明确指定要使用的数据类型。

x = np.ones(2)
x

array([1., 1.])

x = np.ones(2, dtype=np.int64)
x

array([1, 1], dtype=int64)

使用arange创建具有均匀间隔值的数组

arrange的语法：

arange([start,] stop[, step], [, dtype=None])

arange在给定间隔内返回均匀间隔的值。这些值是在半开区间[start，stop）内生成的。如果函数与整数一起使用，它几乎等同于Python内置函数range，但是arange返回一个ndarray而不是一个列表迭代器。

• 如果未给出start参数，则将其设置为0。

• 间隔的结束由参数stop确定。通常，间隔不包括此值，除非在某些情况下step不是整数，浮点舍入会影响输出ndarray的长度。

• 使用可选参数step设置输出数组的两个相邻值之间的间距。 step的默认值是1。如果给出参数step，start参数不能是可选的，即它也必须给出。

• 可以使用参数dtype指定输出数组的类型。如果未给出，则将从其他输入参数自动推断类型。

import numpy as np
a = np.arange(1, 10)
print(a)
x = range(1, 10)
print(x)    # x is an iterator
print(list(x))

[1 2 3 4 5 6 7 8 9]
range(1, 10)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

# further arange examples:
x = np.arange(10.7)
print(x)

[ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]

x = np.arange(0.5, 10.4, 0.8)
print(x)
x = np.arange(0.5, 10.4, 0.8, int)
print(x)

[ 0.5  1.3  2.1  2.9  3.7  4.5  5.3  6.1  6.9  7.7  8.5  9.3 10.1]
[ 0  1  2  3  4  5  6  7  8  9 10 11 12]

使用linspace创建数组

linspace的语法：

linspace(start, stop, num=50, endpoint=True, retstep=False)

linspace返回一个ndarray，由闭区间[start，stop]或半开区间[start，stop]中的num个等间隔样本组成。

返回闭或半开间隔，则取决于endpoint是True还是False。

• 参数start定义将要创建的序列的起始值。

• stop将是序列的结束值，除非endpoint设置为False。 在后一种情况下，得到的序列将由除num+1个样本外的均匀间隔的样本组成。 这意味着排除stop。

请注意，当endpoint为False时，步长会发生变化。

• 可以使用num设置要生成的样本数，默认为50。如果可选参数endpoint设置为True（默认值），stop将是序列的最后一个样本。 否则，它不包括在内。

import numpy as np
# 50 values between 1 and 10:
print(np.linspace(1, 10))
# 7 values between 1 and 10:
print(np.linspace(1, 10, 7))
# excluding the endpoint:
print(np.linspace(1, 10, 7, endpoint=False))

[ 1.          1.18367347  1.36734694  1.55102041  1.73469388  1.91836735
  2.10204082  2.28571429  2.46938776  2.65306122  2.83673469  3.02040816
  3.20408163  3.3877551   3.57142857  3.75510204  3.93877551  4.12244898
  4.30612245  4.48979592  4.67346939  4.85714286  5.04081633  5.2244898
  5.40816327  5.59183673  5.7755102   5.95918367  6.14285714  6.32653061
  6.51020408  6.69387755  6.87755102  7.06122449  7.24489796  7.42857143
  7.6122449   7.79591837  7.97959184  8.16326531  8.34693878  8.53061224
  8.71428571  8.89795918  9.08163265  9.26530612  9.44897959  9.63265306
  9.81632653 10.        ]
[ 1.   2.5  4.   5.5  7.   8.5 10. ]
[1.         2.28571429 3.57142857 4.85714286 6.14285714 7.42857143
 8.71428571]

如果设置了可选参数retstep，则该函数还将返回相邻值之间的间距值。 因此，该函数将返回一个元组(‘samples’, ‘step’)：

import numpy as np
samples, spacing = np.linspace(1, 10, retstep=True)
print(spacing)
samples, spacing = np.linspace(1, 10, 20, endpoint=True, retstep=True)
print(spacing)
samples, spacing = np.linspace(1, 10, 20, endpoint=False, retstep=True)
print(spacing)

0.1836734693877551
0.47368421052631576
0.45

零维数组

可以在numpy中创建多维数组。 标量是零维度的。

在下面的示例中，我们将创建标量42。将ndim方法应用于标量，得到数组的维度为0。 我们还可以看到该类型是numpy.ndarray类型。

import numpy as np
x = np.array(42)
print("x: ", x)
print("The type of x: ", type(x))
print("The dimension of x:", np.ndim(x))

x:  42
The type of x:  <class 'numpy.ndarray'>
The dimension of x: 0

一维数组

一个1维数组又称为向量(或矢量)。 numpy数组是同类型元素的容器。 可以使用属性dtype确定数组元素的类型：

F = np.array([1, 1, 2, 3, 5, 8, 13, 21])
V = np.array([3.4, 6.9, 99.8, 12.8])
print("F: ", F)
print("V: ", V)
print("Type of F: ", F.dtype)
print("Type of V: ", V.dtype)
print("Dimension of F: ", np.ndim(F))
print("Dimension of V: ", np.ndim(V))

F:  [ 1  1  2  3  5  8 13 21]
V:  [ 3.4  6.9 99.8 12.8]
Type of F:  int32
Type of V:  float64
Dimension of F:  1
Dimension of V:  1

二维和多维数组 (Two- and Multidimensional Arrays)

当然，NumPy的数组不限于一个维度。 它们可以具有任意维度。 可以通过将嵌套列表（或元组）传递给numpy的数组方法来创建它们。

可以传递列表的Python列表以创建一个二维数组（或“矩阵”）以在NumPy中表示它们。

data = np.array([[1, 2], [3, 4]])
data

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

data[0, 1]

2

data[1:3]

array([[3, 4]])

data[0:2, 0]

array([1, 3])

A = np.array([ [3.4, 8.7, 9.9], 
               [1.1, -7.8, -0.7],
               [4.1, 12.3, 4.8]])
print(A)
print(A.ndim)

[[ 3.4  8.7  9.9]
 [ 1.1 -7.8 -0.7]
 [ 4.1 12.3  4.8]]
2

B = np.array([ [[111, 112], [121, 122]],
               [[211, 212], [221, 222]],
               [[311, 312], [321, 322]] ])
print(B)
print(B.ndim)

[[[111 112]
  [121 122]]

 [[211 212]
  [221 222]]

 [[311 312]
  [321 322]]]
3

数组的形状 （Shape of an Array）

函数shape返回数组的形状。 形状是一个整数元组。 这些数字表示相应数组维度的长度。

换句话说：数组的形状是一个元组，代表每个轴的元素数量（维度）。

在下面的例子中，形状等于(6, 3)，即有6行和3列。

x = np.array([ [67, 63, 87],
               [77, 69, 59],
               [85, 87, 99],
               [79, 72, 71],
               [63, 89, 93],
               [68, 92, 78]])
print(np.shape(x))

(6, 3)

还有一个等效的数组属性：

print(x.shape)

(6, 3)

数组的形状也告诉我们处理索引的顺序，即首先是行，然后是列，然后是其他维度。

“shape”也可用于改变数组的形状。

x.shape = (3, 6)
print(x)

[[67 63 87 77 69 59]
 [85 87 99 79 72 71]
 [63 89 93 68 92 78]]

x.shape = (2, 9)
print(x)

[[67 63 87 77 69 59 85 87 99]
 [79 72 71 63 89 93 68 92 78]]

新形状必须与数组元素的数量相对应，即新数组的总大小必须与旧数组的大小相同。 如果不是这种情况，将抛出一个异常。

让我们看看其他示例。

一个标量的形状是一个空的元组：

x = np.array(11)
print(np.shape(x))

()

B = np.array([ [[111, 112, 113], [121, 122, 123]],
               [[211, 212, 213], [221, 222, 223]],
               [[311, 312, 313], [321, 322, 323]],
               [[411, 412, 413], [421, 422, 423]] ])
print(B.shape)

(4, 2, 3)

用1、0和空创建数组（Creating Arrays with Ones, Zeros and Empty）

有两种方法可以用0或1初始化数组。 方法ones(t)接收具有数组形状的元组t并相应地用1填充数组。

默认情况下，它将填充float类型的1。 如果需要整数1，则必须将可选参数dtype设置为int：

import numpy as np
E = np.ones((2,3))
print(E)
F = np.ones((3,4),dtype=int)
print(F)

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

方法zeros()类似方法ones()，只是它做的是0填充：

Z = np.zeros((2,4))
print(Z)

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

如果产生的数组必须与另一个现有数组a具有相同的形状，还有另一种方法来创建具有0或1的数组。 Numpy为此提供了方法ones_like(a)和zeros_like(a)。

x = np.array([2,5,18,14,4])
E = np.ones_like(x)
print(E)
Z = np.zeros_like(x)
print(Z)

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

还有一种使用empty函数创建数组的方法。 它创建并返回对给定形状和类型的新数组的引用，而不初始化元素。 有时元素是零，但你不应该被误导。 通常，它们是任意值。

np.empty((2, 4))

array([[0., 0., 0., 0.],
       [0., 0., 0., 0.]])

单位数组 (Identity Array)

在线性代数中，大小为n的单位矩阵或单位矩阵是n×n方阵，其中主对角线上为1和其他地方为零。

Numpy有两种创建单位数组的方法：

identity

eye

identity函数

我们可以使用函数identiy创建单位数组：

identity(n, dtype=None)

参数含义：

• n 一个整数，用于定义输出的行数和列数，即nxn

• dtype 一个可选参数，用于定义输出的数据类型。 默认为float

• identity 的输出是nxn数组，其主对角线设置为1，所有其他元素为0。

import numpy as np
np.identity(4)

array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.]])

np.identity(4, dtype=int) # equivalent to np.identity(3, int)

array([[1, 0, 0, 0],
       [0, 1, 0, 0],
       [0, 0, 1, 0],
       [0, 0, 0, 1]])

eye函数

创建单位数组的另一种方法是使用eye函数。 此函数也是创建仅由1组成的对角线数组。

它返回一个二维数组，其中对角线为1，其他地方为零。

eye(N, M=None, k=0, dtype=float)

参数含义:

• N定义输出数组行的整数。
• M一个可选的整数，用于设置输出中的列数。 如果为None，则默认为“N”。
• k定义对角线的位置。 默认值为0。0表示主对角线。 正值表示上对角线，负值表示下对角线。
• dtype返回数组的可选数据类型。

eye返回一个形状的(N，M)的ndarray。 除了第k个对角线为1之外，该数组的所有元素都等于零。

import numpy as np
np.eye(5, 8, k=1, dtype=int)

array([[0, 1, 0, 0, 0, 0, 0, 0],
       [0, 0, 1, 0, 0, 0, 0, 0],
       [0, 0, 0, 1, 0, 0, 0, 0],
       [0, 0, 0, 0, 1, 0, 0, 0],
       [0, 0, 0, 0, 0, 1, 0, 0]])