1).NumPy 数组形状
数组的形状
数组的形状是每个维中元素的数量。
获取数组的形状
NumPy 数组有一个名为 shape 的属性,该属性返回一个元组,每个索引具有相应元素的数量。
实例
打印 2-D 数组的形状:
import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
print(arr.shape #(2, 4))
上面的例子返回 (2, 4),这意味着该数组有 2 个维,每个维有 4 个元素。
实例
利用 ndmin 使用值 1,2,3,4 的向量创建有 5 个维度的数组,并验证最后一个维度的值为 4:
import numpy as np arr = np.array([1, 2, 3, 4], ndmin=5) print(arr) print('shape of array :', arr.shape) #shape of array : (1, 1, 1, 1, 4)
元组的形状代表什么?
每个索引处的整数表明相应维度拥有的元素数量。
上例中的索引 4,我们的值为 4,因此可以说第 5 个 ( 4 + 1 th) 维度有 4 个元素。
2).NumPy 数组重塑
数组重塑
重塑意味着更改数组的形状。
数组的形状是每个维中元素的数量。
通过重塑,我们可以添加或删除维度或更改每个维度中的元素数量。
从 1-D 重塑为 2-D
实例
将以下具有 12 个元素的 1-D 数组转换为 2-D 数组。
最外面的维度将有 4 个数组,每个数组包含 3 个元素:
import numpy as np arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]) newarr = arr.reshape(4, 3) print(newarr) #[[ 1 2 3] [ 4 5 6] [ 7 8 9] [10 11 12]]
从 1-D 重塑为 3-D
实例
将以下具有 12 个元素的 1-D 数组转换为 3-D 数组。
最外面的维度将具有 2 个数组,其中包含 3 个数组,每个数组包含 2 个元素:
import numpy as np arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]) newarr = arr.reshape(2, 3, 2) print(newarr) #[[[ 1 2] [ 3 4] [ 5 6]]
我们可以重塑成任何形状吗?
是的,只要重塑所需的元素在两种形状中均相等。
我们可以将 8 元素 1D 数组重塑为 2 行 2D 数组中的 4 个元素,但是我们不能将其重塑为 3 元素 3 行 2D 数组,因为这将需要 3x3 = 9 个元素。
实例
尝试将具有 8 个元素的 1D 数组转换为每个维度中具有 3 个元素的 2D 数组(将产生错误):
import numpy as np arr = np.array([1, 2, 3, 4, 5, 6, 7, 8]) newarr = arr.reshape(3, 3) print(newarr) #
Traceback (most recent call last): File "demo_python_numpy_array_reshape_error.py", line 5, in <module> ValueError: cannot reshape array of size 8 into shape (3,3)
返回副本还是视图?
实例
检查返回的数组是副本还是视图:
import numpy as np arr = np.array([1, 2, 3, 4, 5, 6, 7, 8]) print(arr.reshape(2, 4).base) #[1 2 3 4 5 6 7 8]
未知的维
您可以使用一个“未知”维度。
这意味着您不必在 reshape 方法中为维度之一指定确切的数字。
传递 -1 作为值,NumPy 将为您计算该数字。
实例
将 8 个元素的 1D 数组转换为 2x2 元素的 3D 数组:
import numpy as np arr = np.array([1, 2, 3, 4, 5, 6, 7, 8]) newarr = arr.reshape(2, 2, -1) print(newarr) #[[[1 2] [3 4]] [[5 6] [7 8]]]
展平数组
展平数组(Flattening the arrays)是指将多维数组转换为 1D 数组。
我们可以使用 reshape(-1) 来做到这一点。
实例
把数组转换为 1D 数组:
import numpy as np arr = np.array([[1, 2, 3], [4, 5, 6]]) newarr = arr.reshape(-1) print(newarr) #[1 2 3 4 5 6]
注释:有很多功能可以更改 numpy flatten、ravel 中数组形状,还可以重新排列元素 rot90、flip、fliplr、flipud 等。这些功能属于 numpy 的中级至高级部分。
NumPy 数组迭代
3).数组迭代
迭代意味着逐一遍历元素。
当我们在 numpy 中处理多维数组时,可以使用 python 的基本 for 循环来完成此操作。
如果我们对 1-D 数组进行迭代,它将逐一遍历每个元素。
实例
迭代以下一维数组的元素:
import numpy as np arr = np.array([1, 2, 3]) for x in arr: print(x) # 1 2 3
迭代 2-D 数组
在 2-D 数组中,它将遍历所有行。
实例
迭代以下二维数组的元素:
import numpy as np arr = np.array([[1, 2, 3], [4, 5, 6]]) for x in arr: print(x) #[1 2 3] [4 5 6]
如果我们迭代一个 n-D 数组,它将逐一遍历第 n-1 维。
如需返回实际值、标量,我们必须迭代每个维中的数组。
实例
迭代 2-D 数组的每个标量元素:
import numpy as np arr = np.array([[1, 2, 3], [4, 5, 6]]) for x in arr: for y in x: print(y) #1 2 3 4 5 6
迭代 3-D 数组
在 3-D 数组中,它将遍历所有 2-D 数组。
实例
迭代以下 3-D 数组的元素:
import numpy as np arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]) for x in arr: print("x represents the 2-D array:") print(x) #x represents the 2-D array: [[1 2 3] [4 5 6]] x represents the 2-D array: [[ 7 8 9] [10 11 12]]
要返回实际值、标量,我们必须迭代每个维中的数组。
实例
迭代到标量:
import numpy as np arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]) for x in arr: for y in x: for z in y: print(z) #1 2 3 4 5 6 7 8 9 10 11 12
使用 nditer() 迭代数组
函数 nditer() 是一个辅助函数,从非常基本的迭代到非常高级的迭代都可以使用。它解决了我们在迭代中面临的一些基本问题,让我们通过例子进行介绍。
迭代每个标量元素
在基本的 for 循环中,迭代遍历数组的每个标量,我们需要使用 n 个 for 循环,对于具有高维数的数组可能很难编写。
实例
遍历以下 3-D 数组:
import numpy as np
arr = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
for x in np.nditer(arr)
:
print(x)
#1
2
3
4
5
6
7
8
迭代不同数据类型的数组
我们可以使用 op_dtypes 参数,并传递期望的数据类型,以在迭代时更改元素的数据类型。
NumPy 不会就地更改元素的数据类型(元素位于数组中),因此它需要一些其他空间来执行此操作,该额外空间称为 buffer,为了在 nditer() 中启用它,我们传参 flags=['buffered']。
实例
以字符串形式遍历数组:
import numpy as np arr = np.array([1, 2, 3]) for x in np.nditer(arr,flags=['buffered']
,op_dtypes=['S']
): print(x) #b'1' b'2' b'3'
以不同的步长迭代
我们可以使用过滤,然后进行迭代。
实例
每遍历 2D 数组的一个标量元素,跳过 1 个元素:
import numpy as np arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]]) for x in np.nditer(arr[:, ::2]): print(x) #1 3 5 7
使用 ndenumerate() 进行枚举迭代
枚举是指逐一提及事物的序号。
有时,我们在迭代时需要元素的相应索引,对于这些用例,可以使用 ndenumerate() 方法。
实例
枚举以下 1D 数组元素:
import numpy as np arr = np.array([1, 2, 3]) for idx, x in np.ndenumerate(arr): print(idx, x) #(0,) 1 (1,) 2 (2,) 3
实例
枚举以下 2D 数组元素:
import numpy as np arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]]) for idx, x in np.ndenumerate(arr): print(idx, x) #(0, 0) 1 (0, 1) 2 (0, 2) 3 (0, 3) 4 (1, 0) 5 (1, 1) 6 (1, 2) 7 (1, 3) 8
4).NumPy 数组连接
连接 NumPy 数组
连接意味着将两个或多个数组的内容放在单个数组中。
在 SQL 中,我们基于键来连接表,而在 NumPy 中,我们按轴连接数组。
我们传递了一系列要与轴一起连接到 concatenate() 函数的数组。如果未显式传递轴,则将其视为 0。
实例
连接两个数组:
import numpy as np arr1 = np.array([1, 2, 3]) arr2 = np.array([4, 5, 6]) arr = np.concatenate((arr1, arr2)) print(arr) #[1 2 3 4 5 6]
实例
沿着行 (axis=1) 连接两个 2-D 数组(或许axis可以理解为列,这里值为1,可能是分为1列):
import numpy as np arr1 = np.array([[1, 2], [3, 4]]) arr2 = np.array([[5, 6], [7, 8]]) arr = np.concatenate((arr1, arr2), axis=1) print(arr) #[[1 2 5 6] [3 4 7 8]]
使用堆栈函数连接数组
堆栈与级联相同,唯一的不同是堆栈是沿着新轴完成的。
我们可以沿着第二个轴连接两个一维数组,这将导致它们彼此重叠,即,堆叠(stacking)。
我们传递了一系列要与轴一起连接到 concatenate() 方法的数组。如果未显式传递轴,则将其视为 0。
实例
import numpy as np arr1 = np.array([1, 2, 3]) arr2 = np.array([4, 5, 6]) arr = np.stack((arr1, arr2), axis=1) print(arr) #[[1 4] [2 5] [3 6]]
沿行堆叠
NumPy 提供了一个辅助函数:hstack() 沿行堆叠。
实例
import numpy as np arr1 = np.array([1, 2, 3]) arr2 = np.array([4, 5, 6]) arr = np.hstack((arr1, arr2)) print(arr) #[1 2 3 4 5 6]
沿列堆叠
NumPy 提供了一个辅助函数:vstack() 沿列堆叠。
实例
import numpy as np arr1 = np.array([1, 2, 3]) arr2 = np.array([4, 5, 6]) arr = np.vstack((arr1, arr2)) print(arr) #[[1 2 3] [4 5 6]]
沿高度堆叠(深度)
NumPy 提供了一个辅助函数:dstack() 沿高度堆叠,该高度与深度相同。
实例
import numpy as np arr1 = np.array([1, 2, 3]) arr2 = np.array([4, 5, 6]) arr = np.dstack((arr1, arr2)) print(arr) #[[[1 4] [2 5] [3 6]]]
5).NumPy 数组拆分
拆分 NumPy 数组
拆分是连接的反向操作。
连接(Joining)是将多个数组合并为一个,拆分(Spliting)将一个数组拆分为多个。
我们使用 array_split() 分割数组,将要分割的数组和分割数传递给它。
实例
将数组分为 3 部分:
import numpy as np arr = np.array([1, 2, 3, 4, 5, 6]) newarr = np.array_split(arr, 3) print(newarr)#[array([1, 2]), array([3, 4]), array([5, 6])]
注释:返回值是一个包含三个数组的数组。
如果数组中的元素少于要求的数量,它将从末尾进行相应调整。
实例
将数组分为 4 部分:
import numpy as np arr = np.array([1, 2, 3, 4, 5, 6]) newarr = np.array_split(arr, 4) print(newarr)#[array([1, 2]), array([3, 4]), array([5]), array([6])]
提示:我们也有 split() 方法可用,但是当源数组中的元素较少用于拆分时,它将不会调整元素,如上例那样,array_split() 正常工作,但 split() 会失败。
拆分为数组
array_split() 方法的返回值是一个包含每个分割的数组。
如果将一个数组拆分为 3 个数组,则可以像使用任何数组元素一样从结果中访问它们:
实例
访问拆分的数组:
import numpy as np arr = np.array([1, 2, 3, 4, 5, 6]) newarr = np.array_split(arr, 3) print(newarr[0]) print(newarr[1]) print(newarr[2]) #[1 2] [3 4] [5 6]
分割二维数组
拆分二维数组时,请使用相同的语法。
使用 array_split() 方法,传入要分割的数组和想要分割的数目。
实例
把这个 2-D 拆分为三个 2-D 数组。
import numpy as np arr = np.array([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12]]) newarr = np.array_split(arr, 3) print(newarr) #[array([[1, 2], [3, 4]]), array([[5, 6], [7, 8]]), array([[ 9, 10], [11, 12]])]
上例返回三个 2-D 数组。
让我们看另一个例子,这次 2-D 数组中的每个元素包含 3 个元素。
实例
把这个 2-D 拆分为三个 2-D 数组。
import numpy as np arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15], [16, 17, 18]]) newarr = np.array_split(arr, 3) print(newarr) #[array([[1, 2, 3], [4, 5, 6]]), array([[ 7, 8, 9], [10, 11, 12]]), array([[13, 14, 15], [16, 17, 18]])]
上例返回三个 2-D 数组。
此外,您可以指定要进行拆分的轴。
下面的例子还返回三个 2-D 数组,但它们沿行 (axis=1) 分割,这里的axis可理解为1列。
实例
沿行把这个 2-D 拆分为三个 2-D 数组。
import numpy as np arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15], [16, 17, 18]]) newarr = np.array_split(arr, 3, axis=1) print(newarr) #[array([[ 1], [ 4], [ 7], [10], [13], [16]]), array([[ 2], [ 5], [ 8], [11], [14], [17]]), array([[ 3], [ 6], [ 9], [12], [15], [18]])]
另一种解决方案是使用与 hstack() 相反的 hsplit()。
实例
使用 hsplit() 方法将 2-D 数组沿着行分成三个 2-D 数组。
import numpy as np arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15], [16, 17, 18]]) newarr = np.hsplit(arr, 3) print(newarr) #[array([[ 1], [ 4], [ 7], [10], [13], [16]]), array([[ 2], [ 5], [ 8], [11], [14], [17]]), array([[ 3], [ 6], [ 9], [12], [15], [18]])]
提示:vsplit() 和 dsplit() 可以使用与 vstack() 和 dstack() 类似的替代方法。
6).NumPy 数组搜索
搜索数组
您可以在数组中搜索(检索)某个值,然后返回获得匹配的索引。
要搜索数组,请使用 where() 方法。
实例
查找值为 4 的索引:
import numpy as np arr = np.array([1, 2, 3, 4, 5, 4, 4]) x = np.where(arr == 4) print(x) #(array([3, 5, 6], dtype=int64),)
上例会返回一个元组:(array([3, 5, 6],)
意思就是值 4 出现在索引 3、5 和 6。
实例
查找值为偶数的索引:
import numpy as np arr = np.array([1, 2, 3, 4, 5, 6, 7, 8]) x = np.where(arr%2 == 0) print(x)
实例
查找值为奇数的索引:
import numpy as np arr = np.array([1, 2, 3, 4, 5, 6, 7, 8]) x = np.where(arr%2 == 1) print(x)
搜索排序
有一个名为 searchsorted() 的方法,该方法在数组中执行二进制搜索,并返回将在其中插入指定值以维持搜索顺序的索引。
假定 searchsorted() 方法用于排序数组。
实例
查找应在其中插入值 7 的索引:
import numpy as np arr = np.array([6, 7, 8, 9]) x = np.searchsorted(arr, 7) print(x)#1
例子解释:应该在索引 1 上插入数字 7,以保持排序顺序。
该方法从左侧开始搜索,并返回第一个索引,其中数字 7 不再大于下一个值。
从右侧搜索
默认情况下,返回最左边的索引,但是我们可以给定 side='right',以返回最右边的索引。
实例
从右边开始查找应该插入值 7 的索引:
import numpy as np arr = np.array([6, 7, 8, 9]) x = np.searchsorted(arr, 7, side='right') print(x)
例子解释:应该在索引 2 上插入数字 7,以保持排序顺序。
该方法从右边开始搜索,并返回第一个索引,其中数字 7 不再小于下一个值。
多个值
要搜索多个值,请使用拥有指定值的数组。
实例
查找应在其中插入值 2、4 和 6 的索引:
import numpy as np arr = np.array([1, 3, 5, 7]) x = np.searchsorted(arr, [2, 4, 6]) print(x) #[1 2 3]
返回值是一个数组:[1 2 3] 包含三个索引,其中将在原始数组中插入 2、4、6 以维持顺序。
7).NumPy 数组排序
数组排序
排序是指将元素按有序顺序排列。
有序序列是拥有与元素相对应的顺序的任何序列,例如数字或字母、升序或降序。
NumPy ndarray 对象有一个名为 sort() 的函数,该函数将对指定的数组进行排序。
实例
对数组进行排序:
import numpy as np arr = np.array([3, 2, 0, 1]) print(np.sort(arr)) #[0 1 2 3]
注释:此方法返回数组的副本,而原始数组保持不变。
您还可以对字符串数组或任何其他数据类型进行排序:
实例
对数组以字母顺序进行排序:
import numpy as np arr = np.array(['banana', 'cherry', 'apple']) print(np.sort(arr)) #['apple' 'banana' 'cherry']
实例
对布尔数组进行排序:
import numpy as np arr = np.array([True, False, True]) print(np.sort(arr)) #[False True True]
对 2-D 数组排序
如果在二维数组上使用 sort() 方法,则将对两个数组进行排序(各自项中的元素,项本身的顺序不变):
实例
对 2-D 数组排序
import numpy as np arr = np.array([[3, 2, 4], [5, 0, 1]]) print(np.sort(arr)) #[[2 3 4] [0 1 5]]
8).NumPy 数组过滤
数组过滤
从现有数组中取出一些元素并从中创建新数组称为过滤(filtering)。
在 NumPy 中,我们使用布尔索引列表来过滤数组。
布尔索引列表是与数组中的索引相对应的布尔值列表。
如果索引处的值为 True,则该元素包含在过滤后的数组中;如果索引处的值为 False,则该元素将从过滤后的数组中排除。
实例
用索引 0 和 2、4 上的元素创建一个数组:
import numpy as np arr = np.array([61, 62, 63, 64, 65]) x = [True, False, True, False, True] newarr = arr[x] print(newarr)#[61 63 65]
上例将返回 [61, 63, 65],为什么?
因为新过滤器仅包含过滤器数组有值 True 的值,所以在这种情况下,索引为 0 和 2、4。
创建过滤器数组
在上例中,我们对 True 和 False 值进行了硬编码,但通常的用途是根据条件创建过滤器数组。
实例
创建一个仅返回大于 62 的值的过滤器数组:
import numpy as np arr = np.array([61, 62, 63, 64, 65]) # 创建一个空列表 filter_arr = [] # 遍历 arr 中的每个元素 for element in arr: # 如果元素大于 62,则将值设置为 True,否则为 False: if element > 62: filter_arr.append(True) else: filter_arr.append(False) newarr = arr[filter_arr] print(filter_arr) print(newarr) #[False, False, True, True, True] [63 64 65]
实例
创建一个过滤器数组,该数组仅返回原始数组中的偶数元素:
import numpy as np arr = np.array([1, 2, 3, 4, 5, 6, 7]) # 创建一个空列表 filter_arr = [] # 遍历 arr 中的每个元素 for element in arr: # 如果元素可以被 2 整除,则将值设置为 True,否则设置为 False if element % 2 == 0: filter_arr.append(True) else: filter_arr.append(False) newarr = arr[filter_arr] print(filter_arr) print(newarr) #[False, True, False, True, False, True, False] [2 4 6]
直接从数组创建过滤器
上例是 NumPy 中非常常见的任务,NumPy 提供了解决该问题的好方法。
我们可以在条件中直接替换数组而不是 iterable 变量,它会如我们期望地那样工作。
实例
创建一个仅返回大于 62 的值的过滤器数组:
import numpy as np arr = np.array([61, 62, 63, 64, 65]) filter_arr = arr > 62 newarr = arr[filter_arr] print(filter_arr) print(newarr) #[False False True True True] [63 64 65]
实例
创建一个过滤器数组,该数组仅返回原始数组中的偶数元素:
import numpy as np arr = np.array([1, 2, 3, 4, 5, 6, 7]) filter_arr = arr % 2 == 0 newarr = arr[filter_arr] print(filter_arr) print(newarr) #[False True False True False True False] [2 4 6]
9).NumPy 中的随机数
什么是随机数?
随机数并不意味着每次都有不同的数字。随机意味着无法在逻辑上预测的事物。
伪随机和真随机
计算机在程序上工作,程序是权威的指令集。因此,这意味着必须有某种算法来生成随机数。
如果存在生成随机数的程序,则可以预测它,因此它就不是真正的随机数。
通过生成算法生成的随机数称为伪随机数。
我们可以生成真正的随机数吗?
是的。为了在我们的计算机上生成一个真正的随机数,我们需要从某个外部来源获取随机数据。外部来源通常是我们的击键、鼠标移动、网络数据等。
我们不需要真正的随机数,除非它与安全性(例如加密密钥)有关或应用的基础是随机性(例如数字轮盘赌轮)。
在本教程中,我们将使用伪随机数。
生成随机数
NumPy 提供了 random 模块来处理随机数。
实例
生成一个 0 到 100 之间的随机整数:
from numpy import random x = random.randint(100) print(x)
生成随机浮点
random 模块的 rand() 方法返回 0 到 1 之间的随机浮点数。
实例
生成一个 0 到 100 之间的随机浮点数:
from numpy import random x = random.rand() print(x) #0.10599176326885196
生成随机数组
在 NumPy 中,我们可以使用上例中的两种方法来创建随机数组。
整数
randint() 方法接受 size 参数,您可以在其中指定数组的形状。
实例
生成一个 1-D 数组,其中包含 5 个从 0 到 100 之间的随机整数:
from numpy import random x=random.randint(100, size=(5)) print(x) #[71 70 33 52 23]
实例
生成有 3 行的 2-D 数组,每行包含 5 个从 0 到 100 之间的随机整数:
from numpy import random x = random.randint(100, size=(3, 5)) #3行,每行5个 print(x) #[[92 89 24 18 67] [15 91 29 8 35] [51 90 70 62 97]]
浮点数
rand() 方法还允许您指定数组的形状。
实例
生成包含 5 个随机浮点数的 1-D 数组:
from numpy import random x = random.rand(5) print(x) #[0.36517865 0.72925288 0.52385338 0.81641053 0.87472623]
实例
生成有 3 行的 2-D 数组,每行包含 5 个随机数:
from numpy import random x = random.rand(3, 5) print(x) #[[0.81500632 0.7930121 0.66888648 0.49111345 0.91481266] [0.46544679 0.10669415 0.42292901 0.37137563 0.49955766] [0.06629587 0.05910737 0.38987998 0.56787151 0.28589713]]
从数组生成随机数
choice() 方法使您可以基于值数组生成随机值。
choice() 方法将数组作为参数,并随机返回其中一个值。
实例
返回数组中的值之一:
from numpy import random x = random.choice([3, 5, 7, 9]) print(x)#3
choice() 方法还允许您返回一个值数组。
请添加一个 size 参数以指定数组的形状。
实例
生成由数组参数(3、5、7 和 9)中的值组成的二维数组:
from numpy import random x = random.choice([3, 5, 7, 9], size=(3, 5)) print(x) #[[9 3 5 3 9] [5 9 9 7 5] [3 3 7 3 9]]
10).NumPy ufuncs
什么是 ufuncs?
ufuncs 指的是“通用函数”(Universal Functions),它们是对 ndarray 对象进行操作的 NumPy 函数。
为什么要使用 ufuncs?
ufunc 用于在 NumPy 中实现矢量化,这比迭代元素要快得多。
它们还提供广播和其他方法,例如减少、累加等,它们对计算非常有帮助。
ufuncs 还接受其他参数,比如:
where 布尔值数组或条件,用于定义应在何处进行操作。
dtype 定义元素的返回类型。
out 返回值应被复制到的输出数组。
什么是向量化?
将迭代语句转换为基于向量的操作称为向量化。
由于现代 CPU 已针对此类操作进行了优化,因此速度更快。
对两个列表的元素进行相加:
list 1: [1, 2, 3, 4]
list 2: [4, 5, 6, 7]
一种方法是遍历两个列表,然后对每个元素求和。
实例
如果没有 ufunc,我们可以使用 Python 的内置 zip() 方法:
x = [1, 2, 3, 4] y = [4, 5, 6, 7] z = [] for i, j in zip(x, y): z.append(i + j) print(z) #[5, 7, 9, 11]
对此,NumPy 有一个 ufunc,名为 add(x, y),它会输出相同的结果。
实例
通过 ufunc,我们可以使用 add() 函数:
import numpy as np x = [1, 2, 3, 4] y = [4, 5, 6, 7] z = np.add(x, y) print(z)