切片和索引
ndarray对象的内容可以通过索引或切片来访问和修改，就像 Python 的内置容器对象一样。如前所述，ndarray对象中的元素遵循基于零的索引。有三种可用的索引方法类型：字段访问，基本切片和高级索引。
基本切片
基本切片是 Python 中基本切片概念到 n 维的扩展。 通过将start，stop和step参数提供给内置的slice函数来构造一个 Python slice对象。此slice对象被传递给数组来提取数组的一部分。
如果只输入一个参数，则将返回与索引对应的单个项目。 如果使用a:，则从该索引向后的所有项目将被提取。 如果使用两个参数（以:分隔），则对两个索引（不包括停止索引）之间的元素以默认步骤进行切片。
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | import numpy as np a = np.arange(10) s = slice(2, 7, 2) b = a[2:7:2] c = a[2:7] d = a[2:] e = a[2] print("a:",a) print("a[s]:",a[s]) print("b:",b) print("c:",c) print("d:",d) print("e:",e) # output: # a: [0 1 2 3 4 5 6 7 8 9] # a[s]: [2 4 6] # b: [2 4 6] # c: [2 3 4 5 6] # d: [2 3 4 5 6 7 8 9] # e: 2 |
上面的描述也可用于多维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 | import numpy as np a = np.array([[1, 2, 3], [3, 4, 5], [4, 5, 6]]) b = a[1:] c = a[..., 1] d = a[1, ...] e = a[..., 1:] print("a:", a) print("b:", b) print("c:", c) print("d:", d) print("e:", e) # output: # a: [[1 2 3] # [3 4 5] # [4 5 6]] # b: [[3 4 5] # [4 5 6]] # c: [2 4 5] # d: [3 4 5] # e: [[2 3] # [4 5] # [5 6]] |
高级索引
如果一个ndarray是非元组序列，数据类型为整数或布尔值的ndarray，或者至少一个元素为序列对象的元组，我们就能够用它来索引ndarray。高级索引始终返回数据的副本。 与此相反，切片只提供了一个视图。有两种类型的高级索引：整数和布尔值。
整数索引
这种机制有助于基于 N 维索引来获取数组中任意元素。 每个整数数组表示该维度的下标值。 当索引的元素个数就是目标ndarray的维度时，会变得相当直接。
1 2 3 4 5 6 7 8 9 10 11 12 13 | import numpy as np a = np.array([[1, 2], [3, 4], [5, 6]]) b = a[[0, 1, 2], [0, 1, 0]] print("a:", a) print("b:", b) # output: # a: [[1 2] # [3 4] # [5 6]] # b: [1 4 5] |
行索引包含所有行号，列索引指定要选择的元素。高级和基本索引可以通过使用切片:或省略号…与索引数组组合。 以下示例使用slice作为列索引和高级索引。 当切片用于两者时，结果是相同的。 但高级索引会导致复制，并且可能有不同的内存布局。
示例：
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 | import numpy as np a = np.array([[1, 2], [3, 4], [5, 6]]) b = a[[0, 1, 2], [0, 1, 0]] c = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]) rows = np.array([[0, 0], [3, 3]]) cols = np.array([[0, 2], [0, 2]]) d = c[rows, cols] e = c[1:4, 1:3] f = c[1:4, [1, 2]] print("a:", a) print("b:", b) print("c:", c) print("d:", d) print("e:", e) print("f:", f) # output: # a: [[1 2] # [3 4] # [5 6]] # b: [1 4 5] # c: [[ 0 1 2] # [ 3 4 5] # [ 6 7 8] # [ 9 10 11]] # d: [[ 0 2] # [ 9 11]] # e: [[ 4 5] # [ 7 8] # [10 11]] # f: [[ 4 5] # [ 7 8] # [10 11]] |
布尔索引
当结果对象是布尔运算（例如比较运算符）的结果时，将使用此类型的高级索引。
示例：
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 | import numpy as np a = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]) b = a[a > 5] c = np.array([np.nan, 1, 2, np.nan, 3, 4, 5]) d = c[~np.isnan(c)] e = np.array([1, 2 + 6j, 5, 3.5 + 5j]) f = e[np.iscomplex(e)] print("a:", a) print("b:", b) print("c:", c) print("d:", d) print("e:", e) print("f:", f) # output: # a: [[ 0 1 2] # [ 3 4 5] # [ 6 7 8] # [ 9 10 11]] # b: [ 6 7 8 9 10 11] # c: [nan 1. 2. nan 3. 4. 5.] # d: [1. 2. 3. 4. 5.] # e: [1. +0.j 2. +6.j 5. +0.j 3.5+5.j] # f: [2. +6.j 3.5+5.j] |
广播
术语广播是指NumPy在算术运算期间处理不同形状的数组的能力。对数组的算术运算通常在相应的元素上进行。如果两个阵列具有完全相同的形状，则这些操作被无缝执行。
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | import numpy as np a = np.array([1, 2, 3, 4]) b = np.array([10, 20, 30, 40]) c = a * b print("a:", a) print("b:", b) print("c:", c) # output: # a: [1 2 3 4] # b: [10 20 30 40] # c: [ 10 40 90 160] |
如果两个数组的维数不相同，则元素到元素的操作是不可能的。 然而，在 NumPy 中仍然可以对形状不相似的数组进行操作，因为它拥有广播功能。 较小的数组会广播到较大数组的大小，以便使它们的形状可兼容。如果满足以下规则，可以进行广播：
- ndim较小的数组会在前面追加一个长度为 1 的维度。
- 输出数组的每个维度的大小是输入数组该维度大小的最大值。
- 如果输入在每个维度中的大小与输出大小匹配，或其值正好为 1，则在计算中可它。
- 如果输入的某个维度大小为 1，则该维度中的第一个数据元素将用于该维度的所有计算。
如果上述规则产生有效结果，并且满足以下条件之一，那么数组被称为可广播的。
- 数组拥有相同形状。
- 数组拥有相同的维数，每个维度拥有相同长度，或者长度为 1。
- 数组拥有极少的维度，可以在其前面追加长度为 1 的维度，使上述条件成立。
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | import numpy as np a = np.array([[0, 0, 0], [10, 10, 10], [20, 20, 20], [30, 30, 30]]) b = np.array([1, 2, 3]) c = a + b print("a:", a) print("b:", b) print("c:", c) # output: # a: [[ 0 0 0] # [10 10 10] # [20 20 20] # [30 30 30]] # b: [1 2 3] # c: [[ 1 2 3] # [11 12 13] # [21 22 23] # [31 32 33]] |
下面的图片展示了数组b如何通过广播来与数组a兼容。
数组上的迭代
NumPy 包包含一个迭代器对象numpy.nditer。 它是一个有效的多维迭代器对象，可以用于在数组上进行迭代。 数组的每个元素可使用 Python 的标准Iterator接口来访问。
迭代的顺序匹配数组的内容布局，而不考虑特定的排序。 这可以通过迭代上述数组的转置来看到。
示例：
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 | import numpy as np a = np.arange(0, 60, 5) a = a.reshape(3, 4) b = a.T # 转置 print("a:", a) print("b:", b) print("--- start print x ---") for x in np.nditer(a): print(x, end=" ") print("\n--- start print y ---") for y in np.nditer(b): print(y, end=" ") # output: # a: [[ 0 5 10 15] # [20 25 30 35] # [40 45 50 55]] # b: [[ 0 20 40] # [ 5 25 45] # [10 30 50] # [15 35 55]] # --- start print x --- # 0 5 10 15 20 25 30 35 40 45 50 55 # --- start print y --- # 0 5 10 15 20 25 30 35 40 45 50 55 |
迭代顺序
如果相同元素使用 F 风格顺序存储，则迭代器选择以更有效的方式对数组进行迭代。
示例：
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 | import numpy as np a = np.arange(0, 60, 5) a = a.reshape(3, 4) b = a.T # 转置 c = a.copy(order='C') d = a.copy(order='F') e = b.copy(order='C') f = b.copy(order='F') print("a:", a) print("b:", b) print("c:", c) print("d:", d) print("e:", e) print("f:", f) print("--- start print aC ---") for aC in np.nditer(c): print(aC, end=" ") print("\n--- start print aF ---") for aF in np.nditer(d): print(aF, end=" ") print("\n--- start print bC ---") for bC in np.nditer(e): print(bC, end=" ") print("\n--- start print bF ---") for bF in np.nditer(f): print(bF, end=" ") # output: # a: [[ 0 5 10 15] # [20 25 30 35] # [40 45 50 55]] # b: [[ 0 20 40] # [ 5 25 45] # [10 30 50] # [15 35 55]] # c: [[ 0 5 10 15] # [20 25 30 35] # [40 45 50 55]] # d: [[ 0 5 10 15] # [20 25 30 35] # [40 45 50 55]] # e: [[ 0 20 40] # [ 5 25 45] # [10 30 50] # [15 35 55]] # f: [[ 0 20 40] # [ 5 25 45] # [10 30 50] # [15 35 55]] # --- start print aC --- # 0 5 10 15 20 25 30 35 40 45 50 55 # --- start print aF --- # 0 20 40 5 25 45 10 30 50 15 35 55 # --- start print bC --- # 0 20 40 5 25 45 10 30 50 15 35 55 # --- start print bF --- # 0 5 10 15 20 25 30 35 40 45 50 55 |
修改数组的值
nditer对象有另一个可选参数op_flags。 其默认值为只读，但可以设置为读写或只写模式。 这将允许使用此迭代器修改数组元素。
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | import numpy as np a = np.arange(0, 60, 5) a = a.reshape(3, 4) print("a:", a) for x in np.nditer(a, op_flags=['readwrite']): x[...] = 2 * x print("a_readwrite:", a) # output: # a: [[ 0 5 10 15] # [20 25 30 35] # [40 45 50 55]] # a_readwrite: [[ 0 10 20 30] # [ 40 50 60 70] # [ 80 90 100 110]] |
外部循环
nditer类的构造器拥有flags参数，它可以接受下列值：
| 序号 | 参数及描述 |
| 1. | c_index 可以跟踪 C 顺序的索引 |
| 2. | f_index 可以跟踪 Fortran 顺序的索引 |
| 3. | multi-index 每次迭代可以跟踪一种索引类型 |
| 4. | external_loop 给出的值是具有多个值的一维数组，而不是零维数组 |
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | import numpy as np a = np.arange(0, 60, 5) a = a.reshape(3, 4) print("a:", a) print("--- start print x ---") for x in np.nditer(a, flags=['external_loop'], order='F'): print(x, end=" ") # output: # a: [[ 0 5 10 15] # [20 25 30 35] # [40 45 50 55]] # --- start print x --- # [ 0 20 40] [ 5 25 45] [10 30 50] [15 35 55] |
广播迭代
如果两个数组是可广播的，nditer组合对象能够同时迭代它们。 假设数组a具有维度 3X4，并且存在维度为 1X4 的另一个数组b，则使用以下类型的迭代器（数组b被广播到a的大小）。
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | import numpy as np a = np.arange(0, 60, 5) a = a.reshape(3, 4) b = np.array([1, 2, 3, 4], dtype=int) print("a:", a) print("b:", b) print("--- start print x,y ---") for x, y in np.nditer([a, b]): print("%d:%d" % (x, y), end=" ") # output: # a: [[ 0 5 10 15] # [20 25 30 35] # [40 45 50 55]] # b: [1 2 3 4] # --- start print x,y --- # 0:1 5:2 10:3 15:4 20:1 25:2 30:3 35:4 40:1 45:2 50:3 55:4 |
数组操作
NumPy包中有几个例程用于处理ndarray对象中的元素。 它们可以分为以下类型：
修改形状
| 序号 | 形状及描述 |
| 1. | reshape 不改变数据的条件下修改形状 |
| 2. | flat 数组上的一维迭代器 |
| 3. | flatten 返回折叠为一维的数组副本 |
| 4. | ravel 返回连续的展开数组 |
numpy.reshape这个函数在不改变数据的条件下修改形状，它接受如下参数：
numpy.reshape(arr, newshape, order=’C’)
其中：
- arr：要修改形状的数组
- newshape：整数或者整数数组，新的形状应当兼容原有形状
- order：’C’为 C 风格顺序，’F’为 F 风格顺序，’A’为保留原顺序。
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 | import numpy as np a = np.arange(8) b = a.reshape(4, 2) print("a:", a) print("b:", b) # output: # a: [0 1 2 3 4 5 6 7] # b: [[0 1] # [2 3] # [4 5] # [6 7]] |
numpy.ndarray.flat该函数返回数组上的一维迭代器，行为类似 Python 内建的迭代器。
示例：
1 2 3 4 5 6 7 8 9 10 11 | import numpy as np a = np.arange(8).reshape(2, 4) b = a.flat[5] print("a:", a) print("b:", b) # output: # a: [[0 1 2 3] # [4 5 6 7]] # b: 5 |
numpy.ndarray.flatten该函数返回折叠为一维的数组副本，函数接受下列参数：ndarray.flatten(order=’C’)
其中：order：’C’ – 按行，’F’ – 按列，’A’ – 原顺序，’k’ – 元素在内存中的出现顺序。
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | import numpy as np a = np.arange(8).reshape(2, 4) b = a.flatten() c = a.flatten(order='F') print("a:", a) print("b:", b) print("c:", c) # output: # a: [[0 1 2 3] # [4 5 6 7]] # b: [0 1 2 3 4 5 6 7] # c: [0 4 1 5 2 6 3 7] |
numpy.ravel这个函数返回展开的一维数组，并且按需生成副本。返回的数组和输入数组拥有相同数据类型。这个函数接受两个参数。
numpy.ravel(a, order=’C’)
构造器接受下列参数：order：’C’ – 按行，’F’ – 按列，’A’ – 原顺序，’k’ – 元素在内存中的出现顺序。
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | import numpy as np a = np.arange(8).reshape(2, 4) b = a.ravel() c = a.ravel(order='F') print("a:", a) print("b:", b) print("c:", c) # output: # a: [[0 1 2 3] # [4 5 6 7]] # b: [0 1 2 3 4 5 6 7] # c: [0 4 1 5 2 6 3 7] |
翻转操作
| 序号 | 操作及描述 |
| 1. | transpose 翻转数组的维度 |
| 2. | ndarray.T 和self.transpose()相同 |
| 3. | rollaxis 向后滚动指定的轴 |
| 4. | swapaxes 互换数组的两个轴 |
numpy.transpose这个函数翻转给定数组的维度。如果可能的话它会返回一个视图。函数接受下列参数：numpy.transpose(arr, axes)
其中：
- arr：要转置的数组
- axes：整数的列表，对应维度，通常所有维度都会翻转。
numpy.ndarray.T该函数属于ndarray类，行为类似于numpy.transpose。
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | import numpy as np a = np.arange(12).reshape(3, 4) b = np.transpose(a) c = a.T print("a:", a) print("b:", b) print("c:", c) # output: # a: [[ 0 1 2 3] # [ 4 5 6 7] # [ 8 9 10 11]] # b: [[ 0 4 8] # [ 1 5 9] # [ 2 6 10] # [ 3 7 11]] # c: [[ 0 4 8] # [ 1 5 9] # [ 2 6 10] # [ 3 7 11]] |
数组的连接
| 序号 | 数组及描述 |
| 1. | concatenate 沿着现存的轴连接数据序列 |
| 2. | stack 沿着新轴连接数组序列 |
| 3. | hstack 水平堆叠序列中的数组（列方向） |
| 4. | vstack 竖直堆叠序列中的数组（行方向） |
numpy.concatenate数组的连接是指连接。 此函数用于沿指定轴连接相同形状的两个或多个数组。 该函数接受以下参数。numpy.concatenate((a1, a2, …), axis)
其中：
- a1, a2, …：相同类型的数组序列
- axis：沿着它连接数组的轴，默认为 0
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | import numpy as np a = np.array([[1, 2], [3, 4]]) b = np.array([[5, 6], [7, 8]]) c = np.concatenate((a, b)) d = np.concatenate((a, b), axis=1) print("a:", a) print("b:", b) print("c:", c) print("d:", d) # output: # a: [[1 2] # [3 4]] # b: [[5 6] # [7 8]] # c: [[1 2] # [3 4] # [5 6] # [7 8]] # d: [[1 2 5 6] # [3 4 7 8]] |
numpy.stack此函数沿新轴连接数组序列。 此功能添加自 NumPy 版本 1.10.0。 需要提供以下参数。numpy.stack(arrays, axis)
其中：
- arrays：相同形状的数组序列
- axis：返回数组中的轴，输入数组沿着它来堆叠
示例：
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 | import numpy as np a = np.array([[1, 2], [3, 4]]) b = np.array([[5, 6], [7, 8]]) c = np.stack((a, b), 0) d = np.stack((a, b), 1) print("a:", a) print("b:", b) print("c:", c) print("d:", d) # output: # a: [[1 2] # [3 4]] # b: [[5 6] # [7 8]] # c: [[[1 2] # [3 4]] # # [[5 6] # [7 8]]] # d: [[[1 2] # [5 6]] # # [[3 4] # [7 8]]] |
numpy.hstack numpy.stack函数的变体，通过堆叠来生成水平的单个数组。
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | import numpy as np a = np.array([[1, 2], [3, 4]]) b = np.array([[5, 6], [7, 8]]) c = np.hstack((a, b)) print("a:", a) print("b:", b) print("c:", c) # output: # a: [[1 2] # [3 4]] # b: [[5 6] # [7 8]] # c: [[1 2 5 6] # [3 4 7 8]] |
numpy.vstack numpy.stack函数的变体，通过堆叠来生成竖直的单个数组。
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | import numpy as np a = np.array([[1, 2], [3, 4]]) b = np.array([[5, 6], [7, 8]]) c = np.vstack((a, b)) print("a:", a) print("b:", b) print("c:", c) # output: # a: [[1 2] # [3 4]] # b: [[5 6] # [7 8]] # c: [[1 2] # [3 4] # [5 6] # [7 8]] |
数组分割
| 序号 | 数组及操作 |
| 1. | split 将一个数组分割为多个子数组 |
| 2. | hsplit 将一个数组水平分割为多个子数组（按列） |
| 3. | vsplit 将一个数组竖直分割为多个子数组（按行） |
numpy.split 该函数沿特定的轴将数组分割为子数组。函数接受三个参数：numpy.split(ary, indices_or_sections, axis)
其中：
- ary：被分割的输入数组
- indices_or_sections：可以是整数，表明要从输入数组创建的，等大小的子数组的数量。 如果此参数是一维数组，则其元素表明要创建新子数组的点。
- axis：默认为 0
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 | import numpy as np a = np.arange(9) b = np.split(a, 3) c = np.split(a, [4, 7]) print("a:", a) print("b:", b) print("c:", c) # output: # a: [0 1 2 3 4 5 6 7 8] # b: [array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])] # c: [array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])] |
numpy.hsplit numpy.hsplit是split()函数的特例，其中轴为 1 表示水平分割，无论输入数组的维度是什么。
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | import numpy as np a = np.arange(16).reshape(4, 4) b = np.hsplit(a, 2) print("a:", a) print("b:", b) # output: # a: [[ 0 1 2 3] # [ 4 5 6 7] # [ 8 9 10 11] # [12 13 14 15]] # b: [array([[ 0, 1], # [ 4, 5], # [ 8, 9], # [12, 13]]), array([[ 2, 3], # [ 6, 7], # [10, 11], # [14, 15]])] |
numpy.vsplit numpy.vsplit是split()函数的特例，其中轴为 0 表示竖直分割，无论输入数组的维度是什么。下面的例子使之更清楚。
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | import numpy as np a = np.arange(16).reshape(4, 4) b = np.vsplit(a, 2) print("a:", a) print("b:", b) # output: # a: [[ 0 1 2 3] # [ 4 5 6 7] # [ 8 9 10 11] # [12 13 14 15]] # b: [array([[0, 1, 2, 3], # [4, 5, 6, 7]]), array([[ 8, 9, 10, 11], # [12, 13, 14, 15]])] |
添加/删除元素
| 序号 | 元素及描述 |
| 1. | resize 返回指定形状的新数组 |
| 2. | append 将值添加到数组末尾 |
| 3. | insert 沿指定轴将值插入到指定下标之前 |
| 4. | delete 返回删掉某个轴的子数组的新数组 |
| 5. | unique 寻找数组内的唯一元素 |
numpy.resize此函数返回指定大小的新数组。 如果新大小大于原始大小，则包含原始数组中的元素的重复副本。 该函数接受以下参数。numpy.resize(arr, shape)
其中：
- arr：要修改大小的输入数组
- shape：返回数组的新形状
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | import numpy as np a = np.array([[1, 2, 3], [4, 5, 6]]) b = np.resize(a, (3, 2)) c = np.resize(a, (3, 3)) print("a:", a) print("b:", b) print("c:", c) # output: # a: [[1 2 3] # [4 5 6]] # b: [[1 2] # [3 4] # [5 6]] # c: [[1 2 3] # [4 5 6] # [1 2 3]] |
numpy.append此函数在输入数组的末尾添加值。 附加操作不是原地的，而是分配新的数组。 此外，输入数组的维度必须匹配否则将生成ValueError。
函数接受下列函数：numpy.append(arr, values, axis)
其中：
- arr：输入数组
- values：要向arr添加的值，比如和arr形状相同（除了要添加的轴）
- axis：沿着它完成操作的轴。如果没有提供，两个参数都会被展开。
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | import numpy as np a = np.array([[1, 2, 3], [4, 5, 6]]) b = np.append(a, [7, 8, 9]) c = np.append(a, [[7, 8, 9]], axis=0) d = np.append(a, [[5, 5, 5], [7, 8, 9]], axis=1) print("a:", a) print("b:", b) print("c:", c) print("d:", d) # output: # a: [[1 2 3] # [4 5 6]] # b: [1 2 3 4 5 6 7 8 9] # c: [[1 2 3] # [4 5 6] # [7 8 9]] # d: [[1 2 3 5 5 5] # [4 5 6 7 8 9]] |
numpy.insert此函数在给定索引之前，沿给定轴在输入数组中插入值。 如果值的类型转换为要插入，则它与输入数组不同。 插入没有原地的，函数会返回一个新数组。 此外，如果未提供轴，则输入数组会被展开。insert()函数接受以下参数：numpy.insert(arr, obj, values, axis)
其中：
- arr：输入数组
- obj：在其之前插入值的索引
- values：要插入的值
- axis：沿着它插入的轴，如果未提供，则输入数组会被展开
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | import numpy as np a = np.array([[1, 2], [3, 4], [5, 6]]) b = np.insert(a, 3, [11, 12]) c = np.insert(a, 1, [11], axis=0) d = np.insert(a, 1, 11, axis=1) print("a:", a) print("b:", b) print("c:", c) print("d:", d) # output: # a: [[1 2] # [3 4] # [5 6]] # b: [ 1 2 3 11 12 4 5 6] # c: [[ 1 2] # [11 11] # [ 3 4] # [ 5 6]] # d: [[ 1 11 2] # [ 3 11 4] # [ 5 11 6]] |
numpy.delete 此函数返回从输入数组中删除指定子数组的新数组。 与insert()函数的情况一样，如果未提供轴参数，则输入数组将展开。 该函数接受以下参数：Numpy.delete(arr, obj, axis)
其中：
- arr：输入数组
- obj：可以被切片，整数或者整数数组，表明要从输入数组删除的子数组
- axis：沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | import numpy as np a = np.arange(12).reshape(3, 4) b = np.delete(a, 5) c = np.delete(a, 1, axis=1) d = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) e = np.delete(a, np.s_[::2]) print("a:", a) print("b:", b) print("c:", c) print("d:", d) print("e:", e) # output: # a: [[ 0 1 2 3] # [ 4 5 6 7] # [ 8 9 10 11]] # b: [ 0 1 2 3 4 6 7 8 9 10 11] # c: [[ 0 2 3] # [ 4 6 7] # [ 8 10 11]] # d: [ 1 2 3 4 5 6 7 8 9 10] # e: [ 1 3 5 7 9 11] |
numpy.unique 此函数返回输入数组中的去重元素数组。 该函数能够返回一个元组，包含去重数组和相关索引的数组。 索引的性质取决于函数调用中返回参数的类型。
numpy.unique(arr, return_index, return_inverse, return_counts)
其中：
- arr：输入数组，如果不是一维数组则会展开
- return_index：如果为true，返回输入数组中的元素下标
- return_inverse：如果为true，返回去重数组的下标，它可以用于重构输入数组
- return_counts：如果为true，返回去重数组中的元素在原数组中的出现次数
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | import numpy as np a = np.array([5, 2, 6, 2, 7, 5, 6, 8, 2, 9]) b = np.unique(a) print("a:", a) print("b:", b) u, indices = np.unique(a, return_index=True) print(indices) u, indices = np.unique(a, return_inverse=True) print(indices) u, indices = np.unique(a, return_counts=True) print(indices) # output: # a: [5 2 6 2 7 5 6 8 2 9] # b: [2 5 6 7 8 9] # [1 0 2 4 7 9] # [1 0 2 0 3 1 2 4 0 5] # [3 2 2 1 1 1] |
位操作
下面是 NumPy 包中可用的位操作函数。
| 序号 | 操作及描述 |
| 1. | bitwise_and 对数组元素执行位与操作 |
| 2. | bitwise_or 对数组元素执行位或操作 |
| 3. | invert 计算位非 |
| 4. | left_shift 向左移动二进制表示的位 |
| 5. | right_shift 向右移动二进制表示的位 |
- bitwise_and 通过np.bitwise_and()函数对输入数组中的整数的二进制表示的相应位执行位与运算。
- bitwise_or 通过np.bitwise_or()函数对输入数组中的整数的二进制表示的相应位执行位或运算。
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | import numpy as np a, b = 13, 17 print("bin_a:", bin(a)) print("bin_b:", bin(b)) c = np.bitwise_and(a, b) d = np.bitwise_or(a, b) print("bitwise_and:", c) print("bitwise_or:", d) # output: # bin_a: 0b1101 # bin_b: 0b10001 # bitwise_and: 1 # bitwise_or: 29 |
invert 此函数计算输入数组中整数的位非结果。 对于有符号整数，返回补码。注意，np.binary_repr()函数返回给定宽度中十进制数的二进制表示。
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 | import numpy as np a = np.invert(np.array([13], dtype=np.uint8)) b = np.binary_repr(13, width=8) c = np.binary_repr(242, width=8) print("13 的位反转:", a) print("13 的二进制表示：", b) print("242 的二进制表示：", c) # output: # 13 的位反转: [242] # 13 的二进制表示： 00001101 # 242 的二进制表示： 11110010 |
left_shift numpy.left shift()函数将数组元素的二进制表示中的位向左移动到指定位置，右侧附加相等数量的 0。
right_shift numpy.right_shift()函数将数组元素的二进制表示中的位向右移动到指定位置，左侧附加相等数量的 0。
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | import numpy as np a = np.left_shift(10, 2) b = np.right_shift(40, 2) c = np.binary_repr(10, width=8) d = np.binary_repr(40, width=8) print("将 10 左移两位：", a) print("将 40 右移两位：", b) print("10 的二进制表示：", c) print("40 的二进制表示：", d) # output: # 将 10 左移两位： 40 # 将 40 右移两位： 10 # 10 的二进制表示： 00001010 # 40 的二进制表示： 00101000 |
字符串函数
以下函数用于对dtype为numpy.string_或numpy.unicode_的数组执行向量化字符串操作。 它们基于 Python 内置库中的标准字符串函数。
| 序号 | 函数及描述 |
| 1. | add() 返回两个str或Unicode数组的逐个字符串连接 |
| 2. | multiply() 返回按元素多重连接后的字符串 |
| 3. | center() 返回给定字符串的副本，其中元素位于特定字符串的中央 |
| 4. | capitalize() 返回给定字符串的副本，其中只有第一个字符串大写 |
| 5. | title() 返回字符串或 Unicode 的按元素标题转换版本 |
| 6. | lower() 返回一个数组，其元素转换为小写 |
| 7. | upper() 返回一个数组，其元素转换为大写 |
| 8. | split() 返回字符串中的单词列表，并使用分隔符来分割 |
| 9. | splitlines() 返回元素中的行列表，以换行符分割 |
| 10. | strip() 返回数组副本，其中元素移除了开头或者结尾处的特定字符 |
| 11. | join() 返回一个字符串，它是序列中字符串的连接 |
| 12. | replace() 返回字符串的副本，其中所有子字符串的出现位置都被新字符串取代 |
| 13. | decode() 按元素调用str.decode |
| 14. | encode() 按元素调用str.encode |
这些函数在字符数组类（numpy.char）中定义。 较旧的 Numarray 包包含chararray类。 numpy.char类中的上述函数在执行向量化字符串操作时非常有用。
numpy.char.add() 函数执行按元素的字符串连接。
示例：
1 2 3 4 5 6 7 8 | a = np.char.add(['hello'],[' xyz']) b = np.char.add(['hello', 'hi'],[' abc', ' xyz']) print("a:", a) print("b:", b) # output: # a: ['hello xyz'] # b: ['hello abc' 'hi xyz'] |
numpy.char.multiply() 这个函数执行多重连接。
示例：
1 2 3 4 5 6 7 | import numpy as np a = np.char.multiply('Hello ', 3) print("a:", a) # output: # a: Hello Hello Hello |
numpy.char.center() 此函数返回所需宽度的数组，以便输入字符串位于中心，并使用fillchar在左侧和右侧进行填充。
示例：
1 2 3 4 5 6 7 | import numpy as np a = np.char.center('hello', 20, fillchar='*') print("a:", a) # output: # a: *******hello******** |
numpy.char.capitalize() 函数返回字符串的副本，其中第一个字母大写
numpy.char.title() 返回输入字符串的按元素标题转换版本，其中每个单词的首字母都大写。
numpy.char.lower() 函数返回一个数组，其元素转换为小写。它对每个元素调用str.lower。
numpy.char.upper() 函数返回一个数组，其元素转换为大写。它对每个元素调用str.upper。
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | import numpy as np a = np.char.capitalize(['hello', 'world']) b = np.char.title(['hello', 'world']) c = np.char.lower(['Hello', 'World']) d = np.char.upper(['hello', 'world']) print("a:", a) print("b:", b) print("c:", c) print("d:", d) # output: # a: ['Hello' 'World'] # b: ['Hello' 'World'] # c: ['hello' 'world'] # d: ['HELLO' 'WORLD'] |
numpy.char.split() 此函数返回输入字符串中的单词列表。 默认情况下，空格用作分隔符。 否则，指定的分隔符字符用于分割字符串。
numpy.char.splitlines() 函数返回数组中元素的单词列表，以换行符分割。
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | import numpy as np a = np.char.split('hello how are you?') b = np.char.split('TutorialsPoint,Hyderabad,Telangana', sep=',') c = np.char.splitlines('hello\nhow are you?') d = np.char.splitlines('hello\rhow are you?') print("a:", a) print("b:", b) print("c:", c) print("d:", d) # output: # a: ['hello', 'how', 'are', 'you?'] # b: ['TutorialsPoint', 'Hyderabad', 'Telangana'] # c: ['hello', 'how are you?'] # d: ['hello', 'how are you?'] |
numpy.char.strip() 函数返回数组的副本，其中元素移除了开头或结尾处的特定字符。
示例：
1 2 3 4 5 6 7 8 9 10 | import numpy as np a = np.char.strip('ashok arora', 'a') b = np.char.strip(['arora', 'admin', 'java'], 'a') print("a:", a) print("b:", b) # output: # a: shok aror # b: ['ror' 'dmin' 'jav'] |
numpy.char.join() 这个函数返回一个字符串，其中单个字符由特定的分隔符连接。
示例：
1 2 3 4 5 6 7 8 9 10 | import numpy as np a = np.char.join(':', 'dmy') b = np.char.join([':', '-'], ['dmy', 'ymd']) print("a:", a) print("b:", b) # output: # a: d:m:y # b: ['d:m:y' 'y-m-d'] |
numpy.char.replace() 这个函数返回字符串副本，其中所有字符序列的出现位置都被另一个给定的字符序列取代。
示例：
1 2 3 4 5 6 7 | import numpy as np a = np.char.replace('He is a good boy', 'is', 'was') print("a:", a) # output: # a: He was a good boy |
numpy.char.decode() 这个函数在给定的字符串中使用特定编码调用str.decode()。
numpy.char.encode() 此函数对数组中的每个元素调用str.encode函数。 默认编码是utf_8，可以使用标准 Python 库中的编解码器。
示例：
1 2 3 4 5 6 7 8 9 10 | import numpy as np a = np.char.encode('hello', 'cp500') b = np.char.decode(a, 'cp500') print("a:", a) print("b:", b) # output: # a: b'\x88\x85\x93\x93\x96' # b: hello |
算数函数
NumPy 包含大量的各种数学运算功能。 NumPy 提供标准的三角函数，算术运算的函数，复数处理函数等。
三角函数
NumPy 拥有标准的三角函数，它为弧度制单位的给定角度返回三角函数比值。arcsin，arccos，和arctan函数返回给定角度的sin，cos和tan的反三角函数。
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | import numpy as np a = np.array([0, 30, 45, 60, 90]) b = np.sin(a * np.pi / 180) c = np.cos(a * np.pi / 180) d = np.tan(a * np.pi / 180) print("a:", a) print("b:", b) print("c:", c) print("d:", d) # output: # a: [ 0 30 45 60 90] # b: [0. 0.5 0.70710678 0.8660254 1. ] # c: [1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01 # 6.12323400e-17] # d: [0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00 # 1.63312394e+16] |
舍入函数
numpy.around() 这个函数返回四舍五入到所需精度的值。该函数接受以下参数：numpy.around(a,decimals)
其中：
| 序号 | 参数及描述 |
| 1. | a 输入数组 |
| 2. | decimals 要舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置 |
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | import numpy as np a = np.array([1.0, 5.55, 123, 0.567, 25.532]) b = np.around(a) c = np.around(a, decimals=1) d = np.around(a, decimals=-1) print("a:", a) print("b:", b) print("c:", c) print("d:", d) # output: # a: [ 1. 5.55 123. 0.567 25.532] # b: [ 1. 6. 123. 1. 26.] # c: [ 1. 5.6 123. 0.6 25.5] # d: [ 0. 10. 120. 0. 30.] |
numpy.floor() 此函数返回不大于输入参数的最大整数。 即标量x 的下限是最大的整数i ，使得i <= x。 注意在Python中，向下取整总是从 0 舍入。
numpy.ceil() 此函数返回输入值的上限，即，标量x的上限是最小的整数i ，使得i> = x。
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | import numpy as np a = np.array([-1.7, 1.5, -0.2, 0.6, 10]) b = np.floor(a) c = np.ceil(a) print("a:", a) print("b:", b) print("c:", c) # output: # a: [-1.7 1.5 -0.2 0.6 10. ] # b: [-2. 1. -1. 0. 10.] # c: [-1. 2. -0. 1. 10.] |
算数运算
用于执行算术运算（如add()，subtract()，multiply()和divide()）的输入数组必须具有相同的形状或符合数组广播规则。
示例：
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 | import numpy as np a = np.arange(9, dtype=np.float_).reshape(3, 3) b = np.array([10, 10, 10]) c = np.add(a, b) d = np.subtract(a, b) e = np.multiply(a, b) f = np.divide(a, b) print("a:", a) print("b:", b) print("c:", c) print("d:", d) print("e:", e) print("f:", f) # output: # a: [[0. 1. 2.] # [3. 4. 5.] # [6. 7. 8.]] # b: [10 10 10] # c: [[10. 11. 12.] # [13. 14. 15.] # [16. 17. 18.]] # d: [[-10. -9. -8.] # [ -7. -6. -5.] # [ -4. -3. -2.]] # e: [[ 0. 10. 20.] # [30. 40. 50.] # [60. 70. 80.]] # f: [[0. 0.1 0.2] # [0.3 0.4 0.5] # [0.6 0.7 0.8]] |
numpy.reciprocal() 此函数返回参数逐元素的倒数，由于 Python 处理整数除法的方式，对于绝对值大于 1 的整数元素，结果始终为 0， 对于整数 0，则发出溢出警告。
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | import numpy as np a = np.array([0.25, 1.33, 1, 0, 100]) b = np.reciprocal(a) c = np.array([100], dtype=int) d = np.reciprocal(c) print("a:", a) print("b:", b) print("c:", c) print("d:", d) # output: # F:/np_learn/demo.py:6: RuntimeWarning: divide by zero encountered in reciprocal # a: [ 0.25 1.33 1. 0. 100. ] # b = np.reciprocal(a) # b: [4. 0.7518797 1. inf 0.01 ] # c: [100] # d: [0] |
numpy.power() 此函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | import numpy as np a = np.array([10, 100, 1000]) b = np.power(a, 2) c = np.array([1, 2, 3]) d = np.power(a, c) print("a:", a) print("b:", b) print("c:", c) print("d:", d) # output: # a: [ 10 100 1000] # b: [ 100 10000 1000000] # c: [1 2 3] # d: [ 10 10000 1000000000] |
numpy.mod() 此函数返回输入数组中相应元素的除法余数。 函数numpy.remainder()也产生相同的结果。
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | import numpy as np a = np.array([10, 20, 30]) b = np.array([3, 5, 7]) c = np.mod(a, b) d = np.remainder(a, b) print("a:", a) print("b:", b) print("c:", c) print("d:", d) # output: # a: [10 20 30] # b: [3 5 7] # c: [1 0 2] # d: [1 0 2] |
以下函数用于对含有复数的数组执行操作。
- real()返回复数类型参数的实部。
- imag()返回复数类型参数的虚部。
- conj()返回通过改变虚部的符号而获得的共轭复数。
- angle()返回复数参数的角度。 函数的参数是degree。 如果为true，返回的角度以角度制来表示，否则为以弧度制来表示。
示例：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | import numpy as np a = np.array([-5.6j, 0.2j, 11., 1 + 1j]) b = np.real(a) c = np.imag(a) d = np.conj(a) e = np.angle(a) f = np.angle(a, deg=True) print("a:", a) print("b:", b) print("c:", c) print("d:", d) print("e:", e) print("f:", f) # output: # a: [-0.-5.6j 0.+0.2j 11.+0. j 1.+1. j] # b: [-0. 0. 11. 1.] # c: [-5.6 0.2 0. 1. ] # d: [-0.+5.6j 0.-0.2j 11.-0. j 1.-1. j] # e: [-1.57079633 1.57079633 0. 0.78539816] # f: [-90. 90. 0. 45.] |
未完待续…
