Python条件筛选函数（4个）

在 Python 的 NumPy 库中，条件筛选是一种常用的操作，它允许你根据特定的条件从数组中选择元素。

NumPy 提供了多种函数来进行条件筛选，以下是一些常用的条件筛选函数：

1) unique()函数

unique() 函数用于对数组对象进行唯一化处理，即删除数组对象中重复的元素，并进行排序，其语法格式如下：

unique(ar,return_index,axis)

• 参数 ar 表示数组对象；
• 参数 return_index 表示是否返回由唯一化数组对象、唯一化数组对象中的轴索引，以及数组对象类型所组成的元组，该参数为可选参数，其默认值为 False；
• 参数 axis 表示轴索引，该参数为可选参数，其默认值为 None，需要注意的是，如果省略该参数，则数组对象将被转换为一维数组对象后再进行唯一化，如果给定值为数组对象中的轴索引，则在指定的轴上进行唯一化处理。

2) where()函数

where() 函数用于获取数组对象中符合给定条件的元素所对应的索引，其语法格式如下：

where(condition,x,y)

其中，参数 condition 表示给定的条件；参数 x 表示符合给定条件的元素所执行的表达式；参数 y 表示不符合给定条件的元素所执行的表达式。

3) extract()函数

extract() 函数用于获取数组对象中符合给定条件的元素，其语法格式如下：

extract(condition,a)

其中，参数 condition 表示给定的条件；参数 a 表示数组对象。

4) nonzero()函数

nonzero()函数用于获取非零元素所对应的索引，其语法格式如下：

nonzero(a)

其中，参数 a 表示数组对象。

示例代码如下：

import numpy as np

# 创建一维数组a
a = np.array([7, 3, 4, 0, 1, 12, 0])

# 打印数组a中的唯一元素
print(np.unique(a))

# 打印数组a中唯一元素及其出现的次数
print(np.unique(a, True))

# 打印数组a中大于5的元素的索引
print(np.where(a > 5))

# 如果a中的元素大于5，则打印a中的元素，否则打印a中的元素加100
print(np.where(a > 5, a, a + 100))

# 从数组a中提取大于5的元素
print(np.extract(a > 5, a))

# 打印数组a中非零元素的索引
print(np.nonzero(a))

# 创建二维数组b
b = np.array([[14, 2, 32, 12],
              [15, 6, 0, 8],
              [92, 0, 7, 12],
              [14, 2, 32, 12]])

# 打印数组b中的唯一元素
print(np.unique(b))

# 打印数组b中每一列的唯一元素及其出现的次数
print(np.unique(b, True, axis=0))

# 打印数组b中大于5的元素的索引
print(np.where(b > 5))

# 如果b中的元素大于1，则打印b中的元素，否则打印b中的元素加100
print(np.where(b > 1, b, b + 100))

# 从数组b中提取大于30的元素
print(np.extract(b > 30, b))

# 打印数组b中非零元素的索引
print(np.nonzero(b))

# 创建三维数组c
c = np.array([[[13, 21, 3, 42],
               [15, 0, 6, 1],
               [2, 21, 33, 7]],
              [[16, 18, 21, 31],
               [66, 0, 41, 13],
               [65, 23, 22, 51]],
              [[54, 22, 43, 14],
               [14, 12, 0, 21],
               [33, 34, 5, 12]]])

# 打印数组c中的唯一元素
print(np.unique(c))

# 打印数组c中每一行每一列的唯一元素及其出现的次数
print(np.unique(c, True, axis=0))

# 打印数组c中大于10的元素的索引
print(np.where(c > 10))

# 如果c中的元素大于50，则打印c中的元素，否则打印c中的元素加100
print(np.where(c > 50, c, c + 100))

# 从数组c中提取大于50的元素
print(np.extract(c > 50, c))

# 打印数组c中非零元素的索引
print(np.nonzero(c))

运行结果为：

# 打印数组a中的唯一元素
[ 0  1  3  4  7 12]
# 打印数组a中唯一元素及其出现的次数
(array([0, 1, 3, 4, 7, 12]), array([2, 1, 1, 1, 1, 1]))
# 打印数组a中大于5的元素的索引
(array([0, 2, 5]),)
# 如果a中的元素大于5，则打印a中的元素，否则打印a中的元素加100
[107  3  4 100  1 112  100]
# 从数组a中提取大于5的元素
[ 7 12]
# 打印数组a中非零元素的索引
(array([0, 1, 2, 3, 5]),)
# 打印数组b中的唯一元素
[ 2  6  7  8  9 12 14 15 32 92]
# 打印数组b中每一列的唯一元素及其出现的次数
(array([[14, 2, 32, 12], [15, 6, 0, 8], [92, 0, 7, 12]]), array([[2, 2, 1, 1], [2, 2, 1, 1], [2, 1, 1, 1]]))
# 打印数组b中大于5的元素的索引
(array([0, 0, 1, 1, 2, 2, 2, 3, 3]), array([0, 2, 0, 2, 0, 1, 3, 0, 2]))
# 如果b中的元素大于1，则打印b中的元素，否则打印b中的元素加100
[[ 14 100   2 100]
[ 15   6 100   8]
[ 92 100   7 100]
[ 14 100 100 100]]
# 从数组b中提取大于30的元素
[92  7]
# 打印数组b中非零元素的索引
(array([0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3]), array([0, 1, 2, 0, 1, 3, 0, 1, 2, 0, 1, 2]))
# 打印数组c中的唯一元素
[ 0  1  2  3  5  6  7 12 13 14 15 16 18 21 22 23 33 34 41 42 43 51 65 66]
# 打印数组c中每一行每一列的唯一元素及其出现的次数
(array([[[13, 21,  3, 42], [15,  0,  6,  1], [ 2, 21, 33,  7]], [[16, 18, 21, 31], [66,  0, 41, 13], [65, 23, 22, 51]], [[54, 22, 43, 14], [14, 12,  0, 21], [33, 34,  5, 12]]]), array([[[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]], [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]], [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]]))
# 打印数组c中大于10的元素的索引
(array([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2]), array([0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]), array([0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]))
# 如果c中的元素大于50，则打印c中的元素，否则打印c中的元素加100
[[[100   3 100  42]
  [100   0   6 100]
  [  2 100 100   7]]

[[100  18 100 100]
  [100   0 100  13]
  [100  23 100  51]]

[[ 54 100 100  14]
  [ 14 100   0  21]
  [ 33 100   5 100]]]
# 从数组c中提取大于50的元素
[13 21 33 7 16 18 21 31 66 41 65 22 51 54 43 33 34]
# 打印数组c中非零元素的索引
(array([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2]), array([0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]), array([0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]))