科学计算NumPy之Ndarray运算函数操作示例汇总

更新时间：2023年04月28日 14:44:01 作者：CodeDevMaster

这篇文章主要为大家介绍了科学计算NumPy之Ndarray运算函数操作示例汇总，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪

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] &gt; 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 &gt; 3)
print(indices) # (array([3, 4], dtype=int64),)
# 返回满足条件的元素的值
values = np.where(a &gt; 3, a, b)
# 根据条件 (a &gt; 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]

以上就是科学计算NumPy之Ndarray运算函数操作示例汇总的详细内容，更多关于NumPy Ndarray运算函数的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

python创建子类的方法分析
这篇文章主要介绍了python创建子类的方法,结合实例形式分析了Python子类的具体定义与使用方法,需要的朋友可以参考下
2019-11-11
Python的组合模式与责任链模式编程示例
这篇文章主要介绍了Python的组合模式与责任链模式编程示例,组合模式与责任链模式都属于Python的设计模式,需要的朋友可以参考下
2016-02-02
python绘制雪景图
这篇文章主要为大家详细介绍了python绘制雪景图，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2019-12-12
Python实现的栈、队列、文件目录遍历操作示例
这篇文章主要介绍了Python实现的栈、队列、文件目录遍历操作,结合实例形式分析了Python数据结构中栈与队列的定义、使用,以及文件目录的遍历相关操作技巧,需要的朋友可以参考下
2019-05-05
Python实现贪吃蛇小游戏(双人模式)
这篇文章主要为大家详细介绍了Python实现双人模式的贪吃蛇小游戏，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2021-09-09
使用Ray集群简单创建Python分布式应用程序
面对计算密集型的任务，除了多进程，就是分布式计算，如何用 Python 实现分布式计算呢？今天分享一个很简单的方法，那就是借助于 Ray
2021-09-09
Python函数实现学员管理系统
这篇文章主要为大家详细介绍了Python函数实现学员管理系统，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2021-07-07
Numpy如何检查数组全为零的几种方法
本文主要介绍了Numpy如何检查数组全为零的几种方法，文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2021-10-10
django学习之ajax post传参的2种格式实例
AJAX除了异步的特点外，还有一个就是：浏览器页面局部刷新,下面这篇文章主要给大家介绍了关于django学习之ajax post传参的2种格式的相关资料，需要的朋友可以参考下
2021-05-05
Python脚本化Git的操作详解
如何判定此次测试是否达标,代码覆盖率是衡量的标准之一,利用fastapi框架重写了覆盖率统计服务,然后通过diff操作统计增量代码覆盖率,当然要使用diff操作,避免不了与git打交道,那python如何操作gi t呢,本文将详细介绍了Python脚本化Git的操作
2024-03-03