Numpy入门[11]——生成数组的函数

Numpy入门[11]——生成数组的函数

参考：

https://ailearning.apachecn.org/

使用Jupyter进行练习

import numpy as np
1

arange

arange 类似于Python中的 range 函数，只不过返回的不是列表，而是数组：

arange(start, stop = None, step = 1, dtype = None)
1

产生一个在区间 [start, stop) 之间，以 step为间隔的数组，如果只输入一个参数，则默认从 0 开始，并以这个值为结束：

np.arange(4)
1

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

与 range 不同， arange 允许非整数值输入，产生一个非整型的数组：

np.arange(0, 2 * np.pi, np.pi/4)
1

array([0.        , 0.78539816, 1.57079633, 2.35619449, 3.14159265,
       3.92699082, 4.71238898, 5.49778714])
1
2

数组的类型默认由参数 start, stop, step 来确定，也可以指定：

np.arange(0, 2 * np.pi, np.pi / 4, dtype=np.float32)
1

array([0.       , 0.7853982, 1.5707964, 2.3561945, 3.1415927, 3.926991 ,
       4.712389 , 5.4977875], dtype=float32)
1
2

由于存在精度问题，使用浮点数可能出现问题：

np.arange(1.5, 2.1, 0.3)
1

array([1.5, 1.8, 2.1])
1

stop 的值 2.1 出现在了数组中，所以使用浮点数的时候需要注意。

linspace

linspace(start, stop, N) 
1

产生 N 个等距分布在 [start, stop]间的元素组成的数组，包括 start, stop。

np.linspace(0, 1, 5)
1

array([0.  , 0.25, 0.5 , 0.75, 1.  ])
1

logspace

logspace(start, stop, N) 
1

产生 N 个对数等距分布的数组，默认以10为底：

np.logspace(0, 1, 5)
1

array([ 1.        ,  1.77827941,  3.16227766,  5.62341325, 10.        ])
1

产生的值为$\left[10^0,10^{0.25},10^{0.5},10^{0.75},10^1\right]$

meshgrid

有时候需要在二维平面中生成一个网格，这时候可以使用 meshgrid 来完成这样的工作：

x_ticks = np.linspace(-1, 1, 5)
y_ticks = np.linspace(-1, 1, 5)

x, y = np.meshgrid(x_ticks, y_ticks)
1
2
3
4

生成的x,y如下：

y
1

array([[-1. , -1. , -1. , -1. , -1. ],
       [-0.5, -0.5, -0.5, -0.5, -0.5],
       [ 0. ,  0. ,  0. ,  0. ,  0. ],
       [ 0.5,  0.5,  0.5,  0.5,  0.5],
       [ 1. ,  1. ,  1. ,  1. ,  1. ]])
1
2
3
4
5

x
1

array([[-1. , -0.5,  0. ,  0.5,  1. ],
       [-1. , -0.5,  0. ,  0.5,  1. ],
       [-1. , -0.5,  0. ,  0.5,  1. ],
       [-1. , -0.5,  0. ,  0.5,  1. ],
       [-1. , -0.5,  0. ,  0.5,  1. ]])
1
2
3
4
5

x对应网格的第一维，y对应网格的第二维。

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm

def f(x, y):
    # sinc 函数
    r = np.sqrt(x ** 2 + y ** 2)
    result = np.sin(r) / r
    result[r == 0] = 1.0
    return result

x_ticks = np.linspace(-10, 10, 51)
y_ticks = np.linspace(-10, 10, 51)

x, y = np.meshgrid(x_ticks, y_ticks)

z = f(x, y)

fig = plt.figure()

ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(x, y, z,
                rstride=1, cstride=1,
                cmap=cm.YlGnBu_r)
                
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')

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

C:\Users\26969\AppData\Local\Temp\ipykernel_14436\1660655670.py:8: RuntimeWarning: invalid value encountered in true_divide
  result = np.sin(r) / r

Text(0.5, 0, 'z')
1
2
3
4

​

事实上，x, y 中有很多冗余的元素，这里提供了一个 sparse 的选项，在这个选项下，x, y 变成了单一的行向量和列向量。

x_ticks = np.linspace(-1, 1, 5)
y_ticks = np.linspace(-1, 1, 5)

x, y = np.meshgrid(x_ticks, y_ticks, sparse=True)
print(x)
print(y)
1
2
3
4
5
6

[[-1.  -0.5  0.   0.5  1. ]]
[[-1. ]
 [-0.5]
 [ 0. ]
 [ 0.5]
 [ 1. ]]
1
2
3
4
5
6

但并不影响结果：

meshgrid 可以设置轴排列的先后顺序：

• 默认为 indexing='xy' 即笛卡尔坐标，对于2维数组，返回行向量 x 和列向量 y

• 或者使用 indexing='ij' 即矩阵坐标，对于2维数组，返回列向量 x 和行向量 y。

行向量与列向量

可以使用r_ / c_来产生行向量或者列向量

np.r_[0:1: 0.25]
1

array([0.  , 0.25, 0.5 , 0.75])
1

np.r_[0:1:5j]
1

array([0.  , 0.25, 0.5 , 0.75, 1.  ])
1

连接多个序列，产生数组：

np.r_[(3, 22, 11), 4.0, [15,6]]
1

array([ 3., 22., 11.,  4., 15.,  6.])
1

列向量：

np.c_[1:3:5j]
1

array([[1. ],
       [1.5],
       [2. ],
       [2.5],
       [3. ]])
1
2
3
4
5

全0或全1数组

ones(shape, dtype=float64)
zeros(shape, dtype=float64)
1
2

产生一个制定形状的全 0 或全 1 的数组，还可以制定数组类型：

np.zeros(3)
1

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

np.ones([2,3], dtype=np.float32)
1

array([[1., 1., 1.],
       [1., 1., 1.]], dtype=float32)
1
2

产生一个全是4的数组：

np.ones([2,2]) * 4
1

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

空数组

empty(shape, dtype=float64, order='C') 
1

使用 empty 方法产生一个制定大小的数组，再用 fill 方法填充：

a = np.empty(2)
a
1
2

array([inf, inf])
1

a.fill(5)
a
1
2

array([5., 5.])
1

empty_like, ones_like, zeros_like

empty_like(a)
ones_like(a)
zeros_like(a) 
1
2
3

产生一个跟 a 大小一样，类型一样的对应数组。

a = np.arange(0, 10, 2.5)
a
1
2

array([0. , 2.5, 5. , 7.5])
1

np.empty_like(a)
1

array([0. , 2.5, 5. , 7.5])
1

np.zeros_like(a)
1

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

np.ones_like(a)
1

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