NumPy比较运算符

NumPy中的比较运算符（>、<、==、!=、>=、<=）用于比较两个数组的元素是否满足一定的关系，结果是一个布尔类型的数组，其中 True 表示相应位置的元素满足条件，False 表示不满足。

常用的比较运算符：

运算符	说明
大于（>）	判断左侧的值是否大于右侧的值
小于（<）	判断左侧的值是否小于右侧的值
等于（==）	判断左侧的值是否等于右侧的值
不等于（!=）	判断左侧的值是否不等于右侧的值
大于等于（>=）	判断左侧的值是否大于或等于右侧的值
小于等于（<=）	判断左侧的值是否小于或等于右侧的值

import numpy as np

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

print(a > b)  # 输出：[False False  True]
print(a < b)  # 输出：[ True False False]
print(a == b)  # 输出：[False  True False]
print(a != b)  # 输出：[ True False  True]
print(a >= b)  # 输出：[False  True  True]
print(a <= b)  # 输出：[ True  True False]

import numpy as np

# 生成1-20范围 4行3列的二维数组
a = np.random.randint(1, 20, (4, 3))
print(a)
print()

# 取出前2行的前2列用于逻辑判断
b = a[:2, 0:2]

# 逻辑判断, 如果大于10就标记为True 否则为False
print(b > 10)
print()


# BOOL赋值, 将满足条件的设置为指定的值-布尔索引
b[b > 10] = 1
print(b)

[[ 5 16  5]
 [12  9 13]
 [ 8 18 11]
 [ 4 19 17]]

[[False  True]
 [ True False]]

[[5 1]
 [1 9]]

NumPy逻辑运算符

逻辑运算符（&（与）、|（或）、^（异或）、~（非））：用于对布尔数组进行逻辑运算，返回一个布尔数组。

逻辑与

其中 "&" 运算符表示逻辑与，当所有操作数均为 True 时结果才为 True，否则结果为 False。

import numpy as np

a = np.array([True, False, True])
b = np.array([False, True, True])
c = a & b  # 对 a 和 b 进行与运算，返回一个布尔数组
print(c) # [False False  True]

逻辑或

"|" 运算符表示逻辑或，在任意一个操作数为 True 时结果就为 True，只有所有操作数均为 False 时结果才为 False。

import numpy as np

a = np.array([True, False, True])
b = np.array([False, True, True])
c = a | b 
print(c) # [ True  True  True]

逻辑异或

"^" 运算符表示逻辑异或，在两个操作数相同时结果为 False，在操作数不同时结果为 True。

import numpy as np

a = np.array([True, False, True])
b = np.array([False, True, True])
c = a ^ b 
print(c) # [ True  True False]

逻辑非

"~" 运算符表示逻辑非，对操作数取反。

import numpy as np

a = np.array([True, False, True])
b = np.array([False, True, True])
c = ~a
print(c)  # False  True False]
c = ~b
print(c) # [ True False False] 

NumPy逻辑运算函数

NumPy库中的逻辑运算函数：

函数名	对应运算符	说明
logical_and()	&	对两个数组执行逻辑AND运算
logical_or()	丨	对两个数组执行逻辑OR运算
logical_not()	~	对数组进行逻辑NOT运算
logical_xor()	^	对数组进行逻辑异或XOR运算

logical_and()函数

logical_and()函数函数接受两个参数，返回一个布尔类型数组。

np.logical_and(x1, x2) ：对两个数组 x1 和 x2 中的每个元素进行逻辑与运算，并将结果以一个新的布尔类型数组返回。对于同一位置上的元素，只有在都为 True 时，结果才为 True；否则，结果为 False。

import numpy as np

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

c = np.logical_and(a, b)
print(c) #  True False False False]

# 大于0.5并且小于3的，换为1，否则为0
c = np.array([1, 2, 3, 4, 5])
d = np.logical_and(c > 0.5, c < 3)
print(d) # [ True  True False False False]
print(np.where(d, 1, 0)) # [1 1 0 0 0]

np.logical_or()函数

np.logical_or()函数接受两个参数，返回一个布尔类型数组。

np.logical_or(x1, x2) ：对两个数组 x1 和 x2 中的每个元素进行逻辑或运算，并将结果以一个新的布尔类型数组返回。对于同一位置上的元素，只有在都为 False 时，结果才为 False；否则，结果为 True。

import numpy as np

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

c = np.logical_or(a, b)
print(c) # [ True  True  True False]

# 大于0.5并且小于3的，换为1，否则为0
c = np.array([1, 2, 3, 4, 5])
d = np.logical_or(c > 0.5, c < 3)
print(d) # [ True  True  True  True  True]
print(np.where(d, 1, 0)) # [1 1 1 1 1]

logical_not()函数

np.logical_not(x)：对 x 中的元素进行逻辑非（not）运算，返回一个新的数组。

import numpy as np

a = np.array([True, False, True])
print(np.logical_not(a))# [False  True False]

logical_xor()函数

np.logical_xor(x1, x2)：对 x1 和 x2 中的元素进行逻辑异或（xor）运算，返回一个新的数组。

import numpy as np

a = np.array([True, False, True])
b = np.array([False, True, True])
print(np.logical_xor(a, b)) # [ True  True False]

NumPy判断函数

all(a)函数

np.all()函数用于测试数组中的所有元素是否都是True

import numpy as np

a = np.array([1, 2, 3, 4])
b = np.array([0, 2, 3, 4])

print(np.all(a))   # True，因为所有元素都不为0
print(np.all(b))   # False，因为第一个元素为0

c = np.array([[1, 2, 3], [4, 5, 6]])

print(np.all(c))     # True，因为所有元素都不为0
# axis=0：沿着列方向测试所有元素是否都为True
print(np.all(c, axis=0))   # [True True False]
# axis=1：沿着行方向测试所有元素是否都为True
print(np.all(c, axis=1))   # [True  False]

d = np.array([True, False, True])
print(np.all(d))  # 输出 False

any(a)函数

np.any()函数用于测试给定数组的任意元素是否为True。它返回一个布尔值，表示数组中是否有任意一个元素为True。

import numpy as np

a = np.array([0, 1, 2])
print(np.any(a))  # 输出 True

b = np.array([False, False, False])
print(np.any(b))  # 输出 False

c = np.array([[True, False], [False, False]])
print(np.any(c))  # 输出 True

d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(d[0:2, :2]) # [[1 2]  [4 5]]
print(np.any(d[0:2, :2] > 5 ))

isnan(x)函数

np.isnan(x)函数判断一个数是否为 NaN (not a number)

import numpy as np

a = np.array([1, 2, np.nan, 4])
print(np.isnan(a))     # [False False  True False]

isinf(x)函数

np.isinf(x)函数判断一个数是否为正无穷或负无穷

import numpy as np

b = np.array([1, 2, np.inf, -np.inf])
print(np.isinf(b))     # [False False  True  True]

isfinite(x)函数

np.isfinite(x)函数判断一个数是否为有限的数值

import numpy as np

c = np.array([1, 2, np.nan, np.inf, -np.inf])
print(np.isfinite(c))  # [ True  True False False False]

allclose(a, b)函数

np.allclose(a, b)函数判断两个数组是否在一定误差范围内相等

import numpy as np

a = np.array([[1, 2], [3, 4]])
b = np.array([[1.01, 2.01], [3.01, 4.01]])

print(np.allclose(a, b))     # False
print(np.allclose(a, b, rtol=0.02))  # True

array_equal(a, b)函数

np.array_equal(a, b)函数判断两个数组是否完全相同

import numpy as np

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

print(np.array_equal(a, b))   # True

c = np.array([1, 2, 3])
d = np.array([1, 2, 4])

print(np.array_equal(c, d))   # False

greater(x, y)函数

np.greater(x, y)函数 对比两个数组中的元素，返回一个表示 x 是否大于 y 的布尔数组

import numpy as np

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

print(np.greater(a, b))      # [False False  True]

less(x, y)函数

np.less(x, y)函数对比两个数组中的元素，返回一个表示 x 是否小于 y 的布尔数组

import numpy as np

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

print(np.less(a, b))         # [ True False False]

equal(x, y)函数

np.equal(x, y)函数对比两个数组中的元素，返回一个表示 x 是否等于 y 的布尔数组

import numpy as np

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

print(np.equal(a, b))        # [ True False  True]

NumPy条件筛选函数

NumPy中可以使用条件筛选函数进行条件选择操作。

where()函数

numpy.where(condition, x, y)

where()函数说明：

np.where函数用于根据给定条件返回输入数组中满足条件的元素的索引或值。

参数：

condition：一个布尔型数组或条件表达式，用于指定筛选条件

x：满足条件时的返回值

y：不满足条件时的返回值

使用np.where函数找出数组a中大于3的元素的索引，并且将满足条件的元素从a和b对应位置的值中取出来

import numpy as np

a = np.array([1, 2, 3, 4, 5])
b = np.array([10, 20, 30, 40, 50])

# 返回满足条件的元素的索引
indices = np.where(a > 3)
print(indices) # (array([3, 4], dtype=int64),)

# 返回满足条件的元素的值
values = np.where(a > 3, a, b)
# 根据条件 (a > 3) 可以得到一个布尔类型的数组 [False False True True True]。对于这个数组中每个元素，如果是 True 则返回 a 数组中对应的元素，否则返回 b 数组中对应的元素。所以最终结果是 [10 20 30 4 5]。
print(values) # [10 20 30  4  5]

choose()函数

numpy.choose 函数可以根据给定的索引数组从一组备选的值中进行选择。

numpy.choose(a, choices, out=None, mode='raise')

a：表示从中选择值的整数数组，每个值必须是非负的且小于 len(choices)

choices：表示备选值的序列。可以是列表、元组或数组等对象，且每个对象的形状必须相同

out：可选参数，表示输出数组

mode：表示边界处理方式，默认为 'raise'（抛出异常），还可以设置为 'wrap'（循环）或 'clip'（剪切）

import numpy as np

# 定义选择数组a和备选值数组choices 
a = np.array([0, 1, 2, 2])
choices = (10, 11, 12, 13)

# 使用 choose 函数进行选择
# 从 choices 中根据 a 中的索引进行选择，得到最终的结果数组。
result = np.choose(a, choices)

print(result)  # 输出 [10 11 12 12]

select()函数

numpy.select函数则是一种更加灵活的选择方式，它可以根据多个条件来进行选择。其函数签名为：

numpy.select(condlist, choicelist, default=0)

condlist：表示条件列表的序列。每个条件都是一个布尔数组，且所有条件必须具有相同形状。
choicelist：表示备选值的序列。每个备选值也必须具有相同的形状
default：可选参数，表示默认值

import numpy as np

# 定义条件列表condlist和备选值列表choicelist 
condlist = [np.array([True, False]), np.array([False, True])]
choicelist = [np.array([1, 2]), np.array([3, 4])]

# 使用 select 函数进行选择
# 使用 numpy.select 函数根据条件列表从备选值列表中进行选择，得到最终的结果数组
result = np.select(condlist, choicelist)
# 第一个条件为 [True, False]，因此选择了第一个备选值 [1, 2] 中的第一个元素 1
# 第二个条件为 [False, True]，因此选择了第二个备选值 [3, 4] 中的第二个元素 4。最终得到的结果为 [1, 4]
print(result)  # 输出 [1 4]

NumPy统计运算

统计运算是指对一组数据进行统计分析的运算，常见的统计运算包括：

求和（Sum）：将一组数值加起来得到总和。

平均数（Mean）：将一组数值相加后除以数量，得到平均值。

中位数（Median）：将一组数值按从小到大的顺序排列，取中间的那个数值作为中位数。

众数（Mode）：一组数值中出现次数最多的数值。

方差（Variance）：表示数据集合各项数据与其平均数之差平方的平均数。

标准差（Standard Deviation）：是方差的正平方根。

百分位数（Percentile）：将一组数值按从小到大的顺序排列，然后找出某个百分比所处的位置

求和（Sum）

numbers = [1, 2, 3, 4, 5]
total = sum(numbers)
print(total)  # 输出：15

平均数（Mean）

numbers = [1, 2, 3, 4, 5]
average = sum(numbers) / len(numbers)
print(average)  # 输出：3.0

中位数（Median）

import statistics

numbers = [1, 2, 3, 4, 5]
median = statistics.median(numbers)
print(median)  # 输出：3

众数（Mode）

from collections import Counter

numbers = [1, 2, 3, 3, 4, 4, 4, 5, 5]
counter = Counter(numbers)
mode = counter.most_common(1)[0][0]
print(mode)  # 输出：4

方差（Variance）

import statistics

numbers = [1, 2, 3, 4, 5]
variance = statistics.variance(numbers)
print(variance)  # 输出：2.5

标准差（Standard Deviation）

import statistics

numbers = [1, 2, 3, 4, 5]
stdev = statistics.stdev(numbers)
print(stdev)  # 输出：1.5811388300841898

百分位数（Percentile）

import numpy as np

numbers = [1, 2, 3, 4, 5]
percentile = np.percentile(numbers, 50)
print(percentile)  # 输出：3.0

NumPy算术函数

函数名	说明
numpy.add()	将两个数组相加
numpy.subtract()	从第一个数组中减去第二个数组
numpy.multiply()	将两个数组相乘
numpy.divide()	将第一个数组除以第二个数组
numpy.power()	对第一个数组中的每个元素求指数
numpy.mod()	计算两个数组的元素之间的模数（余数）
numpy.abs()	返回数组中每个元素的绝对值
numpy.exp()	对数组中的每个元素进行指数运算
numpy.log()	对数组中的每个元素进行自然对数运算

两个数组相加

import numpy as np

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

c = np.add(a, b)

print(c) # [5 7 9]

NumPy数学函数

NumPy 提供了许多数学函数，用于对数组进行各种数学运算。

函数名	说明
numpy.sin()	计算数组中每个元素的正弦值。
numpy.cos()	计算数组中每个元素的余弦值。
numpy.tan()	计算数组中每个元素的正切值。
numpy.arcsin()	计算数组中每个元素的反正弦值。
numpy.arccos()	计算数组中每个元素的反余弦值。
numpy.arctan()	计算数组中每个元素的反正切值。
numpy.exp()	计算数组中每个元素的指数函数值。
numpy.log()	计算数组中每个元素的自然对数值。
numpy.log10()	计算数组中每个元素的以 10 为底的对数值。

计算数组中每个元素的正弦值：

import numpy as np

arr = np.array([0, np.pi/2, np.pi])
sin_arr = np.sin(arr)

print(sin_arr) # [0.0000000e+00 1.0000000e+00 1.2246468e-16]

NumPy字符串函数

NumPy提供了一些字符串函数，用于处理数组中的字符串元素。

函数名	说明
numpy.char.add()	将两个字符串连接为一个字符串
numpy.char.multiply()	将字符串重复多次
numpy.char.lower()	将字符串中的字母转换为小写
numpy.char.upper()	将字符串中的字母转换为大写
numpy.char.title()	将字符串中每个单词的首字母大写
numpy.char.split()	将字符串分割成子字符串，并返回一个数组
numpy.char.strip()	从字符串的开头和结尾删除空格或指定字符
numpy.char.replace()	使用另一个字符串替换字符串中的指定字符

将两个字符串连接起来：

import numpy as np

a = np.array(['Hello', 'world'])
b = np.array(['!', '?'])

c = np.char.add(a, b)

print(c) # ['Hello!' 'world?']

NumPy排序函数

NumPy 提供了许多排序函数，用于对数组进行排序。

函数名	说明
numpy.sort()	对数组进行排序
numpy.argsort()	返回数组中元素排序后的索引
numpy.lexsort()	对多个序列进行排序
numpy.partition()	按照指定顺序对数组进行分区
numpy.argpartition()	返回将数组分成多个部分所需的索引

对数组进行排序，并返回排序后的索引：

import numpy as np

arr = np.array([3, 8, 1, 6, 0])
sorted_indices = np.argsort(arr)

print(sorted_indices) # [4 2 0 3 1]