开发者

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

目录
  • NumPy比较运算符
  • NumPy逻辑运算符
    • 逻辑与
    • 逻辑或
    • 逻辑异或
    • 逻辑非
  • NumPy逻辑运算函数
    • logical_and()函数
    • np.logical_or()函数
    • logical_not()函数
    • logical_xor()函数
  • NumPy判断函数
    • all(a)函数
    • any(a)函数
    • isnan(x)函数
    • isinf(x)函数
    • isfinite(x)函数
    • allclose(a, b)函数
    • array_equal(a, b)函数
    • greater(x, y)函数
    • less(x, y)函数
    • equal(x, y)函数
  • NumPy条件筛选函数
    • where()函数
    • choose()函数
    • select()函数
  • NumPy统计运算
    • 求和(Sum)
    • 平均数(Mean)
    • 中位数(Median)
    • 众数(Mode)
    • 方差(Variance)
    • 标准差(Standard Deviation)
    • 百分位数(Percentile)
  • NumPy算术函数
    • NumPy数学函数
      • NumPy字符串函数
        • NumPy排序函数

          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 
          prinjst(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([Fjsalse, 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 nump开发者_JAVA开发y 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)
          

          cevOzVAAbondlist:表示条件列表的序列。每个条件都是一个布尔数组,且所有条件必须具有相同形状。

          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 提供了许多排序函数,用于对数组进行排序。

          函数名说明
          numpyevOzVAAb.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运算函数的资料请关注我们其它相关文章!

          0

          上一篇:

          下一篇:

          精彩评论

          暂无评论...
          验证码 换一张
          取 消

          最新开发

          开发排行榜