NumPy 常用整理

导入 numpy

约定俗成的以 np为numpy简称的导入方式

import numpy as np

numpy.array

创建一个数组

• 参数:
  1. object：类数组
  2. dtype：数据类型（data-type），默认为 None
  3. copy：是否拷贝，默认为 True
  4. order：内存布局（’K’，’A’，’C’，’F’），默认为 ‘K’
  5. subok：传递子类还是基类，默认为 False，即传递基类
  6. ndmin：最小维度，默认为 0
• 返回值：
  • out：ndarray

一些简单的🌰

1. 创建一个简单一维数组

1
2

np.array([1, 2, 3])
# array([1, 2, 3])

2. 创建一个简单二维数组

1
2
3
4

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

3. 创建一个最小维度为 2 的数组

1
2

np.array([1,2,3], ndmin=2)
# array([[1, 2, 3]])

4. 使用矩阵创建数组

1
2
3

np.array(np.mat('1 2; 3 4'))
# array([[1, 2],
#        [3, 4]])

5. 使用 array 返回子类

1
2
3

np.array(np.mat('1 2; 3 4'), subok=True)
# matrix([[1, 2],
#         [3, 4]])

ndarray 的一些常用属性

ndarray 的一些常用方法

数组的运算

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

# 数组的四则运算
# 1. shape 相同，对应元素的四则运算
# 2. shape 不同，使用广播机制，然后按 shape 相同的规则计算
# 加法
np.eye(2) + np.eye(2)
# 减法
np.eye(2) - np.eye(2)
# 乘法
np.eye(2) * np.eye(2)
# 除法
np.eye(2) / np.eye(2)
# 矩阵相乘
np.eye(2) @ np.eye(2)
# 指数运算 2次方
np.eye(2) ** 2 
# 取余运算
np.eye(2) % 10

# 创建一个二维数组
a = np.eye(2)
# 和
a.sum()
# 平均数
a.mean()
# 加权平均值
a.average()
# 最大值
a.max()
# 最小值
a.min()
# 中位数
np.median(a)
# 最大值与最小值的差
a.ptp()

# 方差
a.var()
# 标准差
a.std()

# 三角函数
# sin
np.sin(a)
# cos
np.cos(a)
# tan
np.tan(a)

# 向下取整
np.floor(a)
# 进一取整
np.ceil(a)

numpy.arange

返回给定间隔内均匀间隔的数组

• 参数

  1. start：开始值，默认为 0
  2. stop：结束值
  3. step：步长，默认为 1
  4. dtype：数据类型，默认为 None

• 返回值

  • out：ndarray

一些简单的🌰

1. 创建 0-2 的数组

1
2

np.arange(3)
# array([0, 1, 2])

2. 创建一个 2-7 的数组

1
2

np.arange(2, 7)
# array([2, 3, 4, 5, 6])

numpy.linspace

Return evenly spaced numbers over a specified interval.

返回指定间隔内的等间隔数字

• 参数
  1. start：开始值
  2. stop：结束值
  3. num：数量，默认为 50
  4. endpoint：是否包含stop 这个数字，默认为 True
  5. retstep：是否返回间隔数字之间的间隔，默认 False
  6. dtype：数据类型，默认为 None
  7. axis：按哪个轴获取。默认为 0
• 返回值：
  • samples：ndarray
  • step：步长，只有当 retstep 为True 时才有该值。

一些简单的🌰

1. 创建一个 2.0 到 3.0 之间的 5 个等间距数字数组

1
2

np.linspace(2.0, 3.0, num=5)
# array([2.  , 2.25, 2.5 , 2.75, 3.  ])

2. 上面的例子中，创建不包含结束值的数组

1
2

np.linspace(2.0, 3.0, num=5, endpoint=False)
# array([2. , 2.2, 2.4, 2.6, 2.8])

3. 第一个例子，返回步长

1
2

np.linspace(2.0, 3.0, num=5, retstep=True)
# (array([2.  , 2.25, 2.5 , 2.75, 3.  ]), 0.25)

numpy.ones, numpy.zeros, numpy.empty

ones：按照形状创建一个元素全为 1 的数组

zeros：按照形状创建一个元素全为 0 的数组

empty：按照形状创建一个元素全部无意义的数组

• 参数：
  1. shape：形状
  2. dtype：数据类型，默认为 None
  3. order：内存布局（’C’, ‘F’），默认为 C
• 返回值
  • out：ndarray

一些简单的🌰

1. 创建一个形状为 2 的数组

1
2
3
4
5
6

np.ones(2)
# array([1., 1.])
np.zeros(2)
# array([0., 0.])
np.empty(2)
# array([0., 0.]) 未初始化的值，无意义

2. 创建一个形状为 (2, 2) 数组

1
2
3
4
5
6
7
8
9

np.ones((2, 2))
# array([[1., 1.],
#        [1., 1.]])
np.zeros((2, 2))
# array([[0., 0.],
#        [0., 0.]])
np.empty((2, 2))
# array([[0.25, 0.5 ],
#        [0.75, 1.  ]]) 未初始化的值，无意义

numpy.eye（任意对角线为 1 的数组）

Return a 2-D array with ones on the diagonal and zeros elsewhere.

返回一个二维数组，对角线为 1，其他都为 0

• 参数：
  1. N：行数
  2. M：列数，默认等于行
  3. k：对角线索引，默认为 0，即主对角线，正数往右上平移，负数往左下平移。
  4. dtype：数据类型
  5. order：内存布局 （’C’, ‘F’），默认为 C
• 返回值
  • I：ndarray of shape (N, M)

一些简单的🌰

1. 创建一个 2 行 2 列的主对角线为 1 的数组

1
2
3

np.eye(2)
# array([[1., 0.],
#        [0., 1.]])

2. 创建一个3 行 3 列，第 k=1 条对角线为 1 的数组

1
2
3
4

np.eye(3, k=1)
# array([[0., 1., 0.],
#        [0., 0., 1.],
#        [0., 0., 0.]])

numpy.identity（单位数组）

返回单位数组，即主对角线为 1

该方法等同于 numpy.eye(n, M=n, k=0)

• 参数：
  1. n：行列数
  2. dtype：数据类型，默认为 None
• 返回值：
  • out：ndarray

1. 创建一个 2 行 2 列的主对角线为 1 的数组

1
2
3

np.identity(2)
# array([[1., 0.],
#        [0., 1.]])

行向量与列向量

numpy 中一维数组的行向量和列向量没有什么区别

1
2
3

a = np.arange(3)
a     # array([0, 1, 2])
a.T # array([0, 1, 2])

二维的行列向量才有差别

1
2
3
4
5
6

a = np.array([[1, 2, 3]])
a        # array([[1, 2, 3]])
a.T 
# array([[1],
#        [2],
#        [3]])

一维行向量变成二维列向量

1
2
3
4
5
6

a = np.arange(3)
a     # array([0, 1, 2])
a.reshape(-1, 1)
# array([[0],
#        [1],
#        [2]])

使用特殊方法创建行列向量

1. 创建行向量

1

np.r_[1,2,3,4] # array([1, 2, 3, 4])

2. 创建列向量

1
2
3
4

np.c_[[1,2,3]]
# array([[1],
#        [2],
#        [3]])

数组的切片和索引

一维数组的切片和索引

1

a = np.arange(10)

二维数组的切片和索引

1

a = np.arange(25).reshape(5, 5)

还有掩码切割的方式

1. 黄色区域

1
2

mask = np.array([True, False, True, True, False])
a[1::3, mask]

2. 紫色区域

1
2

mask = np.array([False, True, True, True, False])
a[1, mask]

数组拆分

1

a = np.arange(9).reshape(3, 3)

1. 按行拆分

1
2

np.vsplit(a, 3)
# [array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]

2. 按列拆分

1
2
3
4
5
6
7
8

np.hsplit(a, 3)
# [array([[0],
#         [3],
#         [6]]), array([[1],
#         [4],
#         [7]]), array([[2],
#         [5],
#         [8]])]

数组合并

1
2

a = np.arange(4).reshape(2, 2)
b = np.arange(4).reshape(2, 2)

1. 竖直合并

1
2
3
4
5

np.vstack([a,b])
# array([[0, 1],
#        [2, 3],
#        [0, 1],
#        [2, 3]])

2. 水平合并

1
2
3

np.hstack([a,b])
# array([[0, 1, 0, 1],
#        [2, 3, 2, 3]])

numpy的广播机制

以下内容来自菜鸟教程

广播的规则:

• 让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加 1 补齐。
• 输出数组的形状是输入数组形状的各个维度上的最大值。
• 如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错。
• 当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值。

简单理解：对两个数组，分别比较他们的每一个维度（若其中一个数组没有当前维度则忽略），满足：

• 数组拥有相同形状。
• 当前维度的值相等。
• 当前维度的值有一个是 1。

若条件不满足，抛出 “ValueError: frames are not aligned” 异常。