1 数组运算
1.1 算术运算
如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a和b 进行基本运算的结果就是 a 与 b 数组对应位相运算，前提是两个数组的形状相同。
1.1.1 加法运算
NumPy支持数组加法运算，可以使用numpy.add()函数或 + 运算符。
import numpy as np
# 创建两个形状相同的数组
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
# 方法1：使用 + 运算符
add_result1 = a + b
print("运算符+: ", add_result1) # [5 7 9]
# 方法2：使用 numpy.add()
add_result2 = np.add(a, b)
print("numpy.add():", add_result2) # [5 7 9]
"""
np.add() 函数：
是二元操作，每次只能处理两个数组
语法：np.add(array1, array2)
不支持直接添加三个或更多数组
+ 运算符：
支持链式操作，可以一次性添加多个数组
语法：array1 + array2 + array3 + ...
实际执行时会按顺序进行多次二元加法
嵌套 np.add() 的等价操作：
temp = np.add(a, b) # [1+4, 2+5, 3+6] = [5 7 9]
final = np.add(temp, c) # [5+7, 7+8, 9+9] = [12 15 18]
通过嵌套效果执行np.add()
"""
1.1.2 减法运算
NumPy数组同样支持减法运算，可以使用numpy.subtract()函数或 - 运算符
import numpy as np
# 创建两个形状相同的数组
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
# 方法1：使用 - 运算符
sub_result1 = a - b
print("运算符-: ", sub_result1) # [-3 -3 -3]
# 方法2：使用 numpy.subtract()
sub_result2 = np.subtract(a, b)
print("numpy.subtract():", sub_result2) # [-3 -3 -3]
1.1.3 乘法运算
NumPy数组同样支持乘法运算，它是元素级运算，意味着数组中每个元素分别与其他数组（或标量）中对应位置的元素进行相乘运算。
可以使用 * 或函数numpy.multiply。
import numpy as np
# 创建两个形状相同的数组
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
# 方法1：使用 * 运算符
mul_result1 = a * b
print("运算符*: ", mul_result1) # [ 4 10 18]
# 方法2：使用 numpy.multiply()
mul_result2 = np.multiply(a, b)
print("numpy.multiply():", mul_result2) # [ 4 10 18]
1.1.4 除法运算
NumPy数组同样支持除法运算，可以使用numpy.divide()函数或 / 运算符
import numpy as np
# 创建两个形状相同的数组
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
# 方法1：使用 / 运算符
div_result1 = a / b
print("运算符/: ", div_result1) # [0.25 0.4 0.5 ]
# 方法2：使用 numpy.divide()
div_result2 = np.divide(a, b)
print("numpy.divide():", div_result2) # [0.25 0.4 0.5 ]
|
运算 |
函数 |
运算符 |
多数组支持 |
|
加法 |
np.add() |
+ |
仅运算符 |
|
减法 |
np.subtract() |
- |
仅运算符 |
|
乘法 |
np.multiply() |
* |
仅运算符 |
|
除法 |
np.divide() |
/ |
仅运算符 |
1.1.5 开根号
NumPy数组同样支持除法运算，可以使用numpy.power()函数或 **0.5 运算符.
使用numpy.power函数来完成两个数组之间的幂运算，如果两个数组的形状相同，那么它就会将对应位置的元素进行幂运算.
numpy.power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True)
参数：x1：数组或标量，是底数
x2：数组或标量，表示幂(指数)
import numpy as np
a = np.array([1, 2, 3, 4, 5])
#对a开根号的几种写法
print(a ** 0.5)
print(a ** (1 / 2))
print(np.power(a, 0.5))
# 对数组每个元素求n次方数
print(np.power(a, 2)) #a^2
1.2 广播机制
广播(Broadcast)机制是 numpy用于处理数组形状不一致时的元素级操作的，当运算中的 2 个数组的形状不同时，numpy 将自动触发广播机制。
广播机制的实现规则：
1. 如果两个数组的维度不同，形状较小的数组会在前面补1，直到维度数相同。
2. 如果两个数组维度相同，形状上不匹配，且其中一个维度长度为1，那么可以在该维度上进行广播（即会沿该维度复制扩展以匹配另一个数组的形状）。
3.如果在任一维度上形状不匹配且没有维度等于1，则会广播失败，会引发异常。
import numpy as np
a = np.array([1, 2, 3])
b = np.array([[1, 2, 3], [4, 5, 6]])
print(a + b)
# 形状不匹配且没有维度等于1，则会广播失败，会引发异常。
# c = np.array([1, 2, 3, 4])
# d = np.array([[1, 2, 3], [4, 5, 6]])
# print(c+d)
# 练习：
import numpy as np
c = np.array([[1, 2, 3], [4, 5, 6]])
d = np.array(7)
print(c + d)
#输出： [[ 8 9 10]
# [11 12 13]]
1.3 矩阵乘法
要求两个数组的形状兼容（第一个数组的列数等于第二个数组的行数），并且使用 @ 运算符或 numpy.dot 函数。
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]]) # （2,3）
b = np.array([[4, 5, 6], [7, 8, 8]]) # （3,3）
# 数组乘法
print(a * b) # 数组元素相乘
# 输出：[[ 4 10 18]
# [28 40 48]]
c = np.array([[1, 2, 3], [4, 5, 6]]) # （2,3）
d = np.array([[4, 5, 6], [7, 8, 8], [7, 8, 9]]) # （3,3）
# 矩阵乘法 c2,3*d3,3=e2,3
e = c @ d
# e = c dot d
print(e)
# 输出： [[ 39 45 49]
# [ 93 108 118]]
1.4 逻辑运算
NumPy 支持逐元素的逻辑运算，如逻辑与（&）、逻辑或（|）、逻辑非（~）等。这些运算符可以直接应用于布尔数组。
逻辑与：全真则真，一假则假
逻辑或：一真则真，全假则假
逻辑非：真为假，假为真
import numpy as np
a = np.array([True, False, True, False])
b = np.array([False, False, False, True])
print(a & b) # 逻辑与：全真则真，一假则假
# [False False False False]
print(a | b) # 逻辑或：一真则真，全假则假
# [ True False True True]
print(~a) # 逻辑非：真为假，假为真
# [False True False True]
1.5 关系运算
NumPy 支持逐元素的比较运算，比较的两个数组要求形状相同；
如等于（==）、不等于（!=）、大于（>）、小于（<）等。
比较运算的结果是一个布尔数组
import numpy as np
a = np.array([3, 5, 1, 6, 7])
b = a > 5
print(b)
# [False False False True True]
c = np.array([[3, 5], [1, 7]])
d = c > 5
print(d)
# [[False False]
# [False True]]
e = np.array([[3, 5], [1, 7]])
f = np.array([[4, 5], [2, 6]])
g = e > f
print(g)
# 输入：[[False False]
# [False True]]
1.6 统计运算
NumPy数组的统计计算功能是其重要的一部分，它允许用户对数组中的数据进行各种统计分析。NumPy提供了多种统计函数，用于计算数组的平均值、标准差、方差、最大值、最小值等。这些函数可以应用于整个数组，也可以沿着指定的轴进行计算。
1.6.1 sum求和
该函数用于计算数组中所有元素的和，或者沿指定轴计算元素的和。
numpy.sum(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
参数：
a：输入数组，可以是任何形状的数组。
axis：可选参数，用于指定计算和的轴。如果没有指定，则计算整个数组的和。如果指定了轴，则计算该轴上元素的和。可以是整数或元组，用于指定多个轴。
dtype：可选参数，指定返回和的数据类型。如果未指定，则通常与输入数组的类型相同，除非输入数组为布尔型，此时默认返回 `int64` 或 `int32`。
out：可选参数，如果提供，结果会直接写入到这个数组中。这个数组必须具有正确的形状。
keepdims：可选参数，如果设置为 `True`，则计算后的和会保留原始数组的维度，其值默认为 `False`。
initial：可选参数，如果提供，则用于指定当数组为空时的初始值。
where：可选参数，用于指定计算和的条件。
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
# 计算数组所有元素和
print(np.sum(arr))
# 延行增长方向进行累加，列累加
print(np.sum(arr, axis=0)) # [5 7 9]
# 延列增长方向进行累加，行累加
print(np.sum(arr, axis=1)) # [ 6 15]
# 三维暂不考虑
brr = np.array([[[1, 2], [3, 4]], [[4, 5], [5, 6]]])
# 相当于两个平面，对应点相加
print(np.sum(brr, axis=0))
# 输出：[[ 5 7]
# [ 8 10]]
# 相当于两个平面竖着，平边内列相加
print(np.sum(brr, axis=1))
# 输出：[[ 4 6]
# [ 9 11]]
1.6.2 mean平均值
计算数组所有元素的平均值或者延指定轴计算平均值
numpy.mean(a, axis=None, dtype=None, out=None, keepdims=<no value>)
参数：
a：输入数组，可以是任意维度的数组。
axis：用于指定要计算平均值的轴。默认值为None，表示计算整个数组的平均值。如果指定了轴，则在该轴上计算平均值，并返回结果数组。
dtype：用于指定返回值的类型。如果未指定，则使用输入数组的类型。
out：用于指定存放结果的数组。如果提供了该参数，则结果将存储在此数组中，而不是返回一个新的数组。
keepdims：如果设置为True，则保持结果数组的维度与输入数组相同（即不减少维度）。默认值为False。
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(np.mean(arr))
# 延行增长方向进行求平均值,同列相加再求平均值
print(np.mean(arr, axis=0)) # [2.5 3.5 4.5]
# 延列增长方向进行求平均值，同行相加再求平均值
print(np.mean(arr, axis=1)) # [2. 5.]
1.6.3 max和min
numpy.max(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
numpy.min(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
参数：
a：输入数组。
axis：指定要查找最大值的轴。默认值为None，表示在整个数组中查找。
out：指定存放结果的数组。
keepdims：如果为True，则保持结果数组的维度与输入数组相同。
initial：用于指定在计算最大值时的初始值，结果会基于这个初始值进行计算。
where：指定一个布尔数组，用于选择哪些元素参与计算。
功能：计算最大值和最小值的下标
numpy.argmax(a, axis=None, out=None)
numpy.argmin(a, axis=None, out=None)
import numpy as np
arr = np.array([[7, 8, 3], [4, 0, 6]])
print(np.max(arr)) # 8
print(np.min(arr)) # 0
# 计算最大值和最小值下标
print(np.argmax(arr)) # 1
print(np.argmin(arr)) # 4
print(np.argmax(arr, axis=0)) # [0 0 1]
print(np.argmin(arr, axis=0)) # [1 1 0]
1.6.4 cumsum累积和
numpy.cumsum(a, axis=None, dtype=None, out=None, keepdims=False)
import numpy as np
arr = np.array([0, 1, 3, 4, 6])
print(np.cumsum(arr))
# [ 0 1 4 8 14]
brr = np.array([[1, 2, 3], [4, 5, 6]])
print(np.cumsum(brr, axis=0)) # 列累加
# 输出：[[1 2 3]
# [5 7 9]]
print(np.cumsum(brr, axis=1)) # 行累加
# 输出：[[ 1 3 6]
# [ 4 9 15]]
1.6.5 cumprod累积积
numpy.cumprod(a, axis=None, dtype=None, out=None, keepdims=False)
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
print(np.cumprod(arr))
# [ 1 2 6 24 120]
brr = np.array([[1, 2, 3], [4, 5, 6]])
print(np.cumprod(brr))
# [ 1 2 6 24 120 720]
print(np.cumprod(brr, axis=0)) # 列相乘
# 输出：[[ 1 2 3]
# [ 4 10 18]]
print(np.cumprod(brr, axis=1)) # 行相乘
# 输出：[[ 1 2 6]
# [ 4 20 120]]
1.6.6 var方差
numpy.var用于计算数组中所有元素或沿指定轴的方差。方差是衡量一组数值分散程度的统计量，它是各个数值与其平均数差的平方的平均数。
numpy.var(a, axis=None, dtype=None, out=None,ddof=0, keepdims=<no value>)
参数：ddof：自由度调整量
默认值为 0，表示计算总体方差。
设置为 1，则计算样本方差。样本方差的分母为 N−ddof，其中 N 是数据点的数量
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
v = np.var(arr)
print(v)
1.6.7 std标准差
用于计算数组中所有元素的标准差，或者沿着指定轴计算标准差。标准差是方差的平方根，它也是一种衡量数据分散程度的统计量。
numpy.std(a, axis=None, dtype=None, out=None, keepdims=<no value>)
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
# 计算标准差
print(np.std(arr))
print(np.power(arr, 0.5))
1.7 数学函数
1.7.1 三角函数
numpy.sin(x)
功能：计算正弦值
numpy.cos(x)
功能：计算余弦值
numpy.tan(x)
功能：计算正切值
返回值：返回与输入相同形状的数组，包含计算后的三角函数值
import numpy as np
# a = np.arange(0, 2 * np.pi, 0.1)
a = np.linspace(0, 2 * np.pi, 20)
# a = np.random.uniform(0, 2*np.pi, 20)
"""
最好使用第二个，第三个的生成数是随机的，不太适用
"""
print(a)
b = np.sin(a)
print(b)
# # print(np.array(list(zip(a, b))))#坐标x,y的对应输出
c = np.cos(a)
print(c)
d = np.tan(a)
print(d)
1.7.2 指数函数
numpy.exp(x)
功能：计算 e^x，e约等于2.71828
numpy.exp2(x)
功能：计算 2^x
返回值：返回与输入相同形状的数组，包含计算后的指数值。
import numpy as np
arr = np.arange(1, 6, 1)
print(np.exp(arr)) # 计算 e^x，e约等于2.71828
# [ 2.71828183 7.3890561 20.08553692 54.59815003 148.4131591 ]
print(np.exp2(arr)) # 计算计算 2^x
# [ 2. 4. 8. 16. 32.]
1.7.3 对数函数
numpy.log(x)
功能：计算自然对数 ln(x)，log以e为底的对数
numpy.log2(x)
功能：计算以 2 为底的对数 log2(x)
返回值：返回与输入相同形状的数组，包含计算后的对数值。
import numpy as np
arr = np.arange(1, 6, 1) # 起始值要大于0 log2(0)错误
print(arr) # [1 2 3 4 5]
print(np.log(arr)) # 计算自然对数 ln(x)，log以e为底的对数
print(np.log2(arr)) # 计算以 2 为底的对数 log2(x)
1.7.4 排序函数
numpy.sort(a, axis=-1, kind=None, order=None)
参数：kind：指定排序算法。可选值包括：
'quicksort'：快速排序（默认）。
'mergesort'：归并排序。
'heapsort'：堆排序。
'stable'：稳定排序（通常为归并排序）。
import numpy as np
a = np.array([1, 5, 3, 8, 6, 4, 9, 2, 0])
print(a)
# [1 5 3 8 6 4 9 2 0]
b = np.sort(a)
print(b)
# [0 1 2 3 4 5 6 8 9]
print(b[::-1])
# [9 8 6 5 4 3 2 1 0]
c = np.sort(a, kind='quicksort')
print(c)
# [0 1 2 3 4 5 6 8 9]
d = np.sort(a, kind='mergesort')
print(d)
# [0 1 2 3 4 5 6 8 9]
e = np.sort(a, kind='heapsort')
print(e)
# [0 1 2 3 4 5 6 8 9]
f = np.sort(a, kind='stable')
print(f)
# [0 1 2 3 4 5 6 8 9]
sort排序结果从小到大升序，要想改变，要在sort后面[::-1]
2 numpy数组的操作
2.1 数组的插入
2.1.1 append
该函数用于将值追加到数组的末尾，要求追加的数组和原数组维度相同，且除了要追加的轴之外的所有轴上兼容。
numpy.append(arr, values, axis=None)
参数：arr：原始数组，可以是任何形状
values：要追加的值，它们会被追加到arr的末尾。values的形状必须与 arr在除了要追加的轴之外的所有轴上兼容(维度要一致)
axis：可选参数，指定要追加值的轴。如果axis没有被指定，arr会被展平，values会被追加到结果数组的末尾。
import numpy as np
# append
# 一维插入
arr = np.array([1, 2, 3, 4, 5])
print(np.append(arr, [2, 3]))
# [1 2 3 4 5 2 3]
# 二维插入
arr = np.array([[1, 2, 3], [4, 5, 6]])
# 将二维数组铺平，再末尾追加
print(np.append(arr, [2, 3]))
# [1 2 3 4 5 6 2 3]
# 追加一行，值要和原数组的列数一致且维度一致
print(np.append(arr, [[7, 7, 7]], axis=0))
#[[1 2 3]
# [4 5 6]
# [7 7 7]]
# 追加一列，值要和原数组的行数一致且维度一致
print(np.append(arr, [[8], [8]], axis=1))
# [[1 2 3 8]
# [4 5 6 8]]
2.1.2 insert
该函数用于在数组的指定位置插入元素
numpy.insert(arr, obj, values, axis=None)
参数：arr：原数组
obj：表示插入位置的索引。它可以是整数或者整数数组。如果是整数，则表示在哪个位置插入。如果是整数数组，则表示在哪些位置插入。
values：要插入的值。如果 arr是多维数组，则 values 的形状必须在除了 axis指定的轴以外的所有轴上与 arr 保持一致
axis：可选参数，指定插入操作的轴。如果未指定，则arr会被展平，然后values会被插入到一维数组中。
返回值：新的数组
import numpy as np
a = np.array([1, 2, 3, 4, 5])
print(np.insert(a, [2, 4], [66, 99]))
# [ 1 2 66 3 4 99 5]
b = np.array([[1, 2, 3], [3, 4, 5]])
print(np.insert(b, 1, [9, 9, 9], axis=0))
# 输出：[[1 2 3]
# [9 9 9]
# [3 4 5]]
print(np.insert(b, 1, [10, 10], axis=1))
# 输出：[[ 1 10 2 3]
# [ 3 10 4 5]]
2.2 数组的删除
delete 该函数用于从数组中删除指定的子数组，并返回一个新的数组。这个函数允许用户删除数组中的单个元素或多个连续的元素。
numpy.delete(arr, obj, axis=None)
参数：obj：表示要删除的子数组的索引。它可以是单个整数、一个整数列表或一个整数数组。如果是一个整数，它表示要删除单个元素的位置；如果是列表或数组，则表示要删除多个元素的位置。
import numpy as np
a = np.array([1, 2, 3, 4, 5])
print(np.delete(a, 4)) # 按照下标删除
# [1 2 3 4]
b = np.array([[1, 2, 3], [3, 4, 5]])
print(np.delete(b, 1, axis=0)) # 删除行
# [[1 2 3]]
print(np.delete(b, 0, axis=1)) # 删除列
# [[2 3]
# [4 5]]
2.3 数组的升维降维
2.3.1 squeeze降维
numpy.squeeze(a, axis=None)
参数：a: 输入数组。它可以是任何形状的数组，但至少有一个维度的大小为1。
axis: 可选参数。一个整数或整数元组。如果指定了该参数，则只压缩指定的轴。如果该轴在数组 a 中不是单维度的，则不会进行压缩。如果未指定，则所有单维度的轴都将被压缩。
import numpy as np
a = np.array([[1, 2, 3, 4, 5]])
print(a.shape) # (1, 5)
# 降维操作：有一维为1
b = np.squeeze(a)
print(b) # [1 2 3 4 5] #一维数组
print(b.shape) # (5,)
2.3.2 expand_dims升维
该函数的作用是在指定的位置增加一个单一维度，即在指定的位置增加一个形状为1的维度。
numpy.expand_dims(a, axis)
参数：a: 输入数组
axis: 整数或者整数元组。表示在哪个位置增加单一维度
import numpy as np
a = np.array([1, 2, 3, 4, 5])
print(a.shape) # (5,)#只是个数组
b = np.expand_dims(a, axis=0)
print(b) # [[1 2 3 4 5]] 一行五列，二维
print(b.shape) # (1, 5)
c = np.expand_dims(a, axis=1)
print(c) # 一列五行
# 输出：[[1]
# [2]
# [3]
# [4]
# [5]]
print(c.shape) # (5, 1)
2.4 数组的连接
2.4.1 concatenate
该函数用于将多个数组沿指定的轴连接起来，形成一个更大的数组。要连接的多个数组可以是任意维度，但它们在除了要连接的轴之外的所有维度上必须具有相同的形状。
numpy.concatenate((a1, a2, ..., arr_n), axis=0, out=None)
参数：第一个：数组的元组
axis：整数，指定沿着哪个轴进行连接 =0沿着行连接，=1沿着列连接
# 数组的连接
# concatenate
# 要连接的多个数组可以是任意维度，
# 但它们在除了要连接的轴之外的所有维度上必须具有相同的形状。
import numpy as np
#
# 按行连接
a = np.array([[0, 0, 0], [1, 1, 1]]) # 2行3列
b = np.array([[0, 1, 2]]) # 1行3列
c = np.array([[4, 4, 4], [3, 4, 5], [7, 8, 9]]) # 3行3列
d = np.concatenate((a, b, c), axis=0)
print(d)
# [[0 0 0]
# [1 1 1]
# [0 1 2]
# [4 4 4]
# [3 4 5]
# [7 8 9]]
# 按列连接
import numpy as np
a = np.array([[0, 0, 0], [1, 1, 1]]) # 2行3列
b = np.array([[2], [11]]) # 2行1列
c = np.array([[4, 7], [3, 5]]) # 2行2列
d = np.concatenate((a, b, c), axis=1)
print(d)
# [[ 0 0 0 2 4 7]
# [ 1 1 1 11 3 5]]
2.4.2 stack
该函数可以实现多个数组的堆叠(连接)，会创建新的轴，用于沿着新的轴连接一系列数组，所有数组必须具有相同的形状。
numpy.stack(arrays, axis=0, out=None)
参数：arrays：数组元素或列表
import numpy as np
a = np.array([1, 2, 3, 4, 5])
b = np.array([6, 7, 8, 9, 0])
c = np.stack([a, b], axis=0)
print(c)
# [[1 2 3 4 5]
# [6 7 8 9 0]]
d = np.stack([a, b], axis=1)
print(d)
# [[1 6]
# [2 7]
# [3 8]
# [4 9]
# [5 0]]
2.5 数组分割
2.5.1 split
该函数用于沿着指定的轴将数组分割成多个子数组，可以指定要分割的数组、分割的位置或子数组的数量。
numpy.split(ary, indices_or_sections, axis=0)
参数：ary：数组
indices_or_sections：可以是一个整数，表示要将数组平均分割成多少个子数组；也可以是一个整数列表，表示分割的位置。
import numpy as np
arr = np.ones([3, 6])
# 数组的分割，可以指定整数或下标的列表
# 1.指定下标分割
b, c, d = np.split(arr, [1, 2], axis=1)
print(b)
# [[1.]
# [1.]
# [1.]]
print(c)
# [[1.]
# [1.]
# [1.]]
print(d)
# [[1. 1. 1. 1.]
# [1. 1. 1. 1.]
# [1. 1. 1. 1.]]
# 2.指定整数分割
brr = np.ones([3, 6])
b, c, d = np.split(brr, 3, axis=0)
print(b)
# [[1. 1. 1. 1. 1. 1.]]
print(c)
# [[1. 1. 1. 1. 1. 1.]]
print(d)
# [[1. 1. 1. 1. 1. 1.]]
2.6 where函数
numpy.where是 NumPy 库中的一个函数，它可以根据指定的条件返回满足该条件的元素的索引。
当 numpy.where 接受一个条件作为参数时，它会返回一个元组，每个元素是一个numpy数组，其中包含满足该条件的元素的索引（行索引、列索引）。
numpy.where(condition)
参数：一个布尔数组或条件表达式
返回值：一个元组，其中包含满足条件的元素的索引
import numpy as np
a = np.array([1, 12, 3, 4, 6, 25])
b = a > 5
print(b)
# [False True False False True True]
# 返回符合条件的数组的下标
ret = np.where(b)
print(a[ret])
# [12 6 25]
扫一扫
788
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
