Numpy系列（二）：数组函数ufunc

已于 2022-01-19 19:20:58 修改
阅读量1.4k 收藏 7
点赞数 1
分类专栏： Python科学计算和数据分析 文章标签： python 数据分析 科学计算 ufunc numpy
于 2021-12-18 13:43:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hustlei/article/details/122011299
版权

Numpy系列目录

文章目录

一、 简介

Numpy数组支持很多数学运算，运算函数都被成为ufunc。
ufunc是universal function的缩写，是对数组的每个元素进行运算的函数。

NumPy内置的许多ufunc函数都是用C语言实现的，因此它们的计算速度非常快。

ufunc的特点：

  • 对数组逐个元素进行运算
  • ufunc速度比循环和列表推导式都快的多
  • ufunc函数会自动对维度不同的数组进行广播

二、 思维导图

Numpy数组函数

三、 Numpy数组函数

1. 基本运算

1.1 四则运算

逐个元素做运算，得到新的数组。

  • y=x1+x2或者y=np.add(x1,x2)：加法
  • y=x1-x2或者y=np.subtract(x1,x2)：减法
  • y=-x或者np.negative(x)：负值
  • y=x1*x2或者y=np.multiply(x1,x2)：乘法
  • y=x1/x2或者np.divide(x1,x2)：除法
  • y=x1//x2或者np.floor_divide(x1,x2)：整除
  • y=x1**x2或者np.power(x1,x2)：乘方
  • y=x1%x2或者np.mod(x1,x2)：求余

逐个元素运算，自动广播（广播见本文第5节），示例如下：

>>> x1=np.array([[0,1],[2,3]])
>>> x2=np.array([[2,2],[3,3]])
>>> x1+x2
array([[2, 3],
       [5, 6]])
>>> np.add(x1,x2)   #注意不能用x1.add(x2)
array([[2, 3],
       [5, 6]])

>>> x1+1            #常量广播
array([[1, 2],
       [3, 4]])

>>> x1+np.array([2,1])  #广播
array([[2, 2],
       [4, 4]])

1.2 比较运算

返回每个元素运算后得到的布尔数组。

  • y = x1==x2或者np.equal(x1,x2)：相等判断
  • y = x1!=x2或者np.not_equal(x1,x2)：不相等判断
  • y = x1<x2或者np.less(x1,x2)：小于判断
  • y = x1<=x2或者np.less_equal(x1,x2)：小于等于判断
  • y = x1>x2或者np.greater(x1,x2)：大于判断
  • y = x1>=x2或者np.greater_eaual(x1,x2)：大于等于判断

逐个元素运算，示例如下：

>>> x1=np.array([[0,1],[2,3]])
>>> x2=np.array([[3,1],[2,0]])
>>> x1 == x2
array([[False,  True],
       [ True, False]])

>>> x1 == 2            #常量广播
array([[False, False],
       [ True, False]])

>>> x1 == np.array([2,1])  #广播
array([[False,  True],
       [ True, False]])

1.3 布尔运算

python中的and，or，not等关键字无法重载，所以numpy数组不能用and，or，not进行布尔运算。

  • np.all(a)：是否数组所有元素是True
  • np.any(a)：是否任意元素是True
  • np.logical_not(a==a)
  • np.logical_and(a==b,a>b)
  • np.logical_or(a==b,a>b)
  • np.logical_xor(a==b,a>b)

示例如下：

>>> x1=np.array([[0,1],[2,3]])
>>> x2=np.array([[3,1],[2,0]])

>>> np.all(x1)
False
>>> np.any(x1)
True

>>> np.logical_and(x1,x2)  #0被认为是False，其他被认为是True
array([[False,  True],
       [ True, False]])

>>> x1==x2
array([[False,  True],
       [ True, False]])
>>> x1 > x2
array([[False, False],
       [False,  True]])
>>> np.logical_or(x1>x2,x1==x2)
array([[False,  True],
       [ True,  True]])

1.4 位运算

位运算符对每个元素进行运算。可以用~, &, |, ^等操作符。也可以使用bitwise_开头的ufunc。

  • ~a或者np.bitwise_not(a)：按位非运算
  • a&b或者np.bitwise_and(a,b)：按位与运算
  • a|b或者np.bitwise_or(a,b)：按位或运算
  • a^b或者np.bitwise_xor(a,b)：按位异或运算

示例如下：

>>> x1=np.array([[0,1],[2,3]])
>>> x2=np.array([[3,1],[2,0]])

>>> ~x1
array([[-1, -2],
       [-3, -4]], dtype=int32)
>>> x1 & x2
array([[0, 1],
       [2, 0]], dtype=int32)
>>> x1 | x2
array([[3, 1],
       [2, 3]], dtype=int32)
>>> x1 ^ x2
array([[3, 0],
       [0, 3]], dtype=int32)

2. 自定义ufunc

python中也可以自定义ufunc，比直接使用python函数速度要快。方法如下：

  1. 定义任意函数f()
    • 函数的参数列表数量的确定方法
      • 方法一：f()与目标ufunc参数数量相同
      • 方法二：运算时指定部分参数。yfunc1=yfunc(x, 0.1, 0.2)
  2. 转换为ufunc
    • 方法1：yfun = np.frompyfunc(f, 1, 1) ：参数为输入输出参数个数
    • 方法2： yfunc = np.vectorize(f, otypes=[np.float])
  3. 计算 y = yfun(x)
  4. y.astype(np.float)：返回类型为object时，可以转为float

示例如下：

#1.定义函数
>>> def fsum2(x1, x2):
...    return x1 + x2/2


>>> x1 = np.array([1,2])
>>> x2 = np.array([2,2])

#2.转换ufunc方法一
>>> yfun1 = np.frompyfunc(fsum2, 2, 1)
>>>  yfun1(x1,x2)     #可以用_.astype(np.float)转换object为float类型
array([2.0, 3.0], dtype=object)

#3.转换ufunc方法二
>>> yfun2 = np.vectorize(fsum2, otypes=[np.float16])
>>> yfun2(x1,x2)
array([2., 3.], dtype=float16)

3. ufunc广播

ufunc计算需要计算数组形状相同。对于不同形状的数组，则会尝试转换为相同形状后再运算。
ufunc自动对计算数组形状进行扩展的过程，称为广播。

  • 最简单的广播：数组与常量的运算
  • 最经典广播案例 ：行向量与列向量形状分别为(M,) (1,N) 运算后得到(M,N)形状数组

3.1 广播的步骤及条件

步骤

  • 数组扩展为相同的维度
    • 所有数组都向维度最多的数组看齐
    • 维度不足的部分通过前面加1个维度补齐(增加的维度长度为1)
    • 如[1,2]增加第0维[[1,2]]，增加第1维[[1],[2]]
  • 对长度为1的维度进行repeat复制操作，使对应维度长度相同

可广播条件

  • 维度扩展后并可以repeat到形状相同，是数组可广播的基本要求
  • 如果两个数组某个维度上长度不同，必须有一个长度为1才能repeat。
    • 数组形状(3,1)可以repeat到(3,4)
    • 数组形状(3,2)不能repeat到(3,4)

示例：

>>> x1=np.array([1,2])           #shape为(2,)
>>> x2=np.array([[1,2],[3,4]])   #shape为(2,2)

#x1扩展为(2,2)的过程
#1. x1前面加一个维度，变为[[1,2]]    形状为(1,2)
#2. repeat复制长度为1的维度。变为[[1,2],[1,2]]   形状为(2,2)

>>> x1+x2
array([[2, 4],
       [4, 6]])

3.2 创建可广播数组

可广播数组即只进行广播第一步操作，数组扩展到相同的维度，但是形状不同。

3.2.1 ogrid

ogrid可以根据指定范围，创建可广播的二维数组

>>> x,y = np.ogrid[:3,:3]   #注意是方括号
>>> x
array([[0],
       [1],
       [2]])
>>> y
array([[0, 1, 2]])

>>> x + y                   #运算中自动广播
array([[0, 1, 2],
       [1, 2, 3],
       [2, 3, 4]])

实际上就是创建"2维列向量+2维行向量"

3.2.2 一维数组手工创建可广播数组

根据ogrid结果，可以看出一维数组转换为二维行、列向量就可以广播了。

expand_dims增加维度

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

>>> np.expand_dims(a,0)   #扩展为1行n列
array([[1, 2, 3]])
>>> np.expand_dims(a,1)   #扩展为n行1列
array([[1],
       [2],
       [3]])

用None下标增加维度

>>> a[None,:]             #扩展为1行n列
array([[1, 2, 3]])

>>> a[:,None]             #扩展为n行1列
array([[1],
       [2],
       [3]])

用np.ix_增加维度

>>> x,y=np.ix_(a,a)
>>> x
array([[1],
       [2],
       [3]])
>>> y
array([[1, 2, 3]])
3.2.3 创建广播后的数组

mgrid根据范围创建广播后的数组

相比ogrid，mgrid更进一步，执行了广播的扩展维度和repeat两步操作。

>>> x,y = np.mgrid[:3,:3]   #创建ogrid[:3,:3]广播之后得到的数组
>>> x                       #列向量扩展列数
array([[0, 0, 0],
       [1, 1, 1],
       [2, 2, 2]])
>>> y                       #行向量扩展行数
array([[0, 1, 2],
       [0, 1, 2],
       [0, 1, 2]])

meshgrid根据已有数组创建广播后的数组

计算两个一维数组广播后得到的数组

>>> a=np.array([10,20])
>>> b=np.array([0,1,2])
>>> x,y=np.meshgrid(a,b)
>>> x
array([[10, 20],
       [10, 20],
       [10, 20]])
>>> y
array([[0, 0],
       [1, 1],
       [2, 2]])

4. ufunc的方法

函数自身的函数

4.1 reduce

按指定的维度依次计算，比如：累加，累减。指定的维度长度运算后变为1。结果比输入维度减少

>>> a=np.array([[ 0,  1,  2,  3],
... [ 4,  5,  6,  7],
... [ 8,  9, 10, 11],
... [12, 13, 14, 15]])

>>> np.add.reduce(a)
array([24, 28, 32, 36])
>>> np.add.reduce(a)
array([24, 28, 32, 36])

>>> np.subtract.reduce(a)
array([-24, -26, -28, -30])

两个输入一个输出的ufunc都可以进行reduce操作。比如：

  • np.subtract.reduce(a)：第0个元素依次减其他元素
  • np.multiply.reduce(a)：第0个元素依次乘其他元素
  • np.divide.reduce(a)：第0个元素依次除其他元素
  • …
  • np.logical_and.reduce(a)
  • …
  • np.bitwise_and.reduce(a)
  • …

4.2 accumulate

根据指定维度，对当前位置之前的元素进行累计计算，结果和输入维度相同

>>> a=np.array([[ 0,  1,  2,  3],
... [ 4,  5,  6,  7],
... [ 8,  9, 10, 11],
... [12, 13, 14, 15]])

>>> np.add.accumulate(a)
array([[ 0,  1,  2,  3],
       [ 4,  6,  8, 10],
       [12, 15, 18, 21],
       [24, 28, 32, 36]], dtype=int32)
>>> np.add.accumulate(a,axis=1)
array([[ 0,  1,  3,  6],
       [ 4,  9, 15, 22],
       [ 8, 17, 27, 38],
       [12, 25, 39, 54]], dtype=int32)

两个输入一个输出的ufunc都可以进行accumulate操作。比如：

  • np.subtract.accumulate(a)：第0个元素依次减其他元素
  • np.multiply.accumulate(a)：第0个元素依次乘其他元素
  • np.divide.accumulate(a)：第0个元素依次除其他元素
  • …
  • np.logical_and.accumulate(a)
  • …
  • np.bitwise_and.accumulate(a)
  • …

4.3 outer

np.add.outer(a,b)：a中每一个元素，依次对b中的每个元素进行运算。
(M,N)形状数组和(J,K)形状数组运算后形状为(M,N,J,K)

>>> a=np.array([[10,20],[2,4]])
>>> b=np.array([1,2,3])
>>> np.add.outer(a,b)
array([[[11, 12, 13],
        [21, 22, 23]],

       [[ 3,  4,  5],
        [ 5,  6,  7]]])

两个输入一个输出的ufunc都可以进行outer操作。比如：

  • np.subtract.outer(a)：第0个元素依次减其他元素
  • np.multiply.outer(a)：第0个元素依次乘其他元素
  • np.divide.outer(a)：第0个元素依次除其他元素
  • …
  • np.logical_and.outer(a)
  • …
  • np.bitwise_and.outer(a)
  • …

5. ufunc广播特例

针对一维向量，以下操作结果相同。

5.1 行向量和列向量自动广播

>>> a=np.array([[10],[20]])
>>> b=np.array([0,1,2])
>>> a+b
array([[10, 11, 12],
       [20, 21, 22]])

5.2 创建可广播数组

根据范围用ogrid创建

>>> x,y=np.ogrid[10:30:10,:3]
>>> x
array([[10],
       [20]])
>>> y
array([[0, 1, 2]])
>>> x+y
array([[10, 11, 12],
       [20, 21, 22]])

expand_dims扩展维度为可广播数组

>>> a=np.expand_dims(np.array([10,20]),1)
>>> a
array([[10],
       [20]])
>>> b=np.array([0,1,2])
>>> b
array([0, 1, 2])
>>> a+b
array([[10, 11, 12],
       [20, 21, 22]])

None下标扩展维度为可广播数组

>>> a=np.array([10,20])
>>> b=np.array([0,1,2])

>>> a[:,None]
array([[10],
       [20]])
>>> b[None,:]
array([[0, 1, 2]])

>>> a[:,None]+b[None,:]
array([[10, 11, 12],
       [20, 21, 22]])

np.ix_扩展维度为可广播数组

>>> a=np.array([10,20])
>>> b=np.array([0,1,2])

>>> x,y=np.ix_([10,20],[0,1,2])
>>> x
array([[10],
       [20]])
>>> y
array([[0, 1, 2]])

>>> x+y
array([[10, 11, 12],
       [20, 21, 22]])

5.3 根据范围创建广播后数组

根据范围创建

>>> x,y=np.mgrid[10:30:10,:3]
>>> x
array([[10, 10, 10],
       [20, 20, 20]])
>>> y
array([[0, 1, 2],
       [0, 1, 2]])

根据已有数组创建

>>> x,y=np.meshgrid([0,1,2],[10,20])
>>> x
array([[0, 1, 2],
       [0, 1, 2]])
>>> y
array([[10, 10, 10],
       [20, 20, 20]])

5.4 outer方法模拟向量广播

>>> np.add.outer([10,20],[0,1,2])
array([[10, 11, 12],
       [20, 21, 22]])


Numpy系列目录

个人总结，部分内容进行了简单的处理和归纳，如有谬误，希望大家指出，持续修订更新中。

修订历史版本见：https://github.com/hustlei/AI_Learning_MindMap

未经允许请勿转载。

hustlei
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Numpy的ufunc函数
zm_1900的博客
04-06 715
ufunc函数是针对数组进行操作的，且都以数组作为输出。 常用的ufunc函数运算有四则运算、比较运算、逻辑运算。 ufunc函数支持全部的四则运算，其表示对数组中的各元素分别进行四则运算，所以进行四则运算的两个数组形状必须相同。 import numpy as np #ufunc函数运算 x=np.array([1,2,3]) y=np.array([4,5,6]) print(x+y...
ufunc函数常用运算、ufunc函数广播机制——《Python数据分析与应用》笔记
12-21
ufunc 函数全称为通用函数，是一种能够对 数组 中的所有元素进行操作的函数。 Numpy ufunc函数常用的 ufunc 函数运算数组的四则运算数组的比较运算逻辑运算ufunc 函数的广播机制 常用的 ufunc 函数运算 常用的 ufunc 函数运算有四则运算、比较运算和逻辑运算等。 数组的四则运算 数组间的四则运算是对每个数组中的对应位置的元素分别进行四则运算，所以进行四则运算的两个数组的 形状必须相同，如果不同，在满足一定条件下，数组广播之后还可以进行运算。 # 数组相加 x = np.array([1, 2, 3]) y = np.array([4, 5, 6]) print('
numpy的ufunc
qq_42413820的博客
06-20 3552
介绍点高级的东西，numpy中的ufunc。ufunc(universal function)能够作用于narray对象上的元素级函数，这些函数在对narray对象进行运算的速度比使用循环或者列表推导式要快很多。numpy中的ufunc函数：python 中的逻辑运算and、or、not 在numpy中均以以logical_开头。ufunc方法ufunc函数对象本身还有一些方法函数，这些方法只对两...
【Numpy基础知识】通用函数ufunc基础知识
谢谢你们的关注
12-23 1152
【Numpy基础知识】通用函数ufunc基础知识
Numpy简易教程6——ufunc函数
热门推荐
mighty13的专栏
08-13 3万+
ufunc函数 ufunc函数即通用函数（universal function），是一种能够对数组中的所有元素进行操作的函数。ufunc函数是针对数组进行操作的，并且都以NumPy数组作为输出，因此不需要对数组的每一个元素都进行操作。对一个数组进行重复运算时，使用ufunc函数比使用math库中的函数效率要高很多。 1. 常用的ufunc函数运算 常用的ufunc函数运算有四则运算、比较运算和逻辑运算等。 1.1 四则运算 ufunc函数支持全部的四则运算，并且保留习惯的运算符，和数值运算的使用方式一样（原
python科学计算之numpy——ufunc函数
南极企鹅
11-15 1万+
写在前面ufunc是universal function的缩写，意思是这些函数能够作用于narray对象的每一个元素上，而不是针对narray对象操作，numpy提供了大量的ufunc的函数。这些函数在对narray进行运算的速度比使用循环或者列表推导式要快很多，但请注意，在对单个数值进行运算时，python提供的运算要比numpy效率高。四则运算numpy提供的四则ufunc有如下一些： n
python科学计算之numpy——ufunc函数用法
09-18
Numpy中的ufunc（universal function，通用函数）是一类对数组进行元素级操作的函数，具有广播（broadcasting）功能，可以加速数组的运算，它们是Numpy实现高效科学计算的核心组件之一。 在本篇内容中，我们主要...
Numpy中的矢量化ufunc.pptx
05-05
例如，定义一个自增函数`func_x`，然后使用`np.frompyfunc`将其转换为ufunc： ```python def func_x(a): return a + 1 A = [0, 1, 2] func_ = np.frompyfunc(func_x, 1, 1) y = func_(A) print(y) # 输出：[1 2 3...
《Hello NumPy》系列-运算与函数应用
01-20
总的来说，《Hello NumPy》系列的这一部分详细介绍了NumPy中的数组运算和函数应用，包括基本的四则运算、矩阵运算、转置操作以及通用函数的使用。掌握这些知识对于在Python中进行大规模数值计算和数据分析至关重要。
Python数据分析应用：数组的转置和轴对称.pptx
02-04
通用函数的一个优点是它们能够自动处理数组的广播规则，这意味着即使输入数组的形状不同，ufuncs也能正确地处理并返回一个适当形状的结果。 例如，我们可以用`add()`函数将一个一维数组与一个标量相加： ```python...
ufunc函数
weixin_34321977的博客
03-14 760
　　无灯可看。雨水从教正月半。探茧推盘。探得千秋字字看。 　　铜驼故老。说著宣和似天宝。五百年前。曾向杭州看上元。 　　ufunc是universal function的缩写，他是一种对数组的每个元素进行运算的函数。NumPy的内置许多函数都是用C语言实现的因此，他们的计算速度十分的快。 >>> x = np.linspace(0,2*np.pi,10) >...
NumPy-ufunc 函数
烟雨
01-03 1226
ufunc  函数     全称通用函数（universal function），是一种能够对数组中所有元素进行操作的函数。以 Numpy 数组作为输出，因此不需要对数组每个元素都操作，比 math 库中的函数操作效率更高。 (1)四则运算：加（+）、减（-）、乘（*）、除（/）、幂（**）。数组间的四则运算表示对每个数组中的元素分别进行四则运算，所以形状必须相同。 (2)比较运算：&gt;、...
NumPy基础 数据类型和通用函数（`ufunc`）基础
最新发布
数智笔记
02-21 886
数组标量与Python标量有所不同，但在大多数情况下可以互换使用（主要的例外是对于早于v2.x的Python版本，整数数组标量不能用作列表和元组的索引）。数据类型可以用作函数，将Python数字转换为数组标量（请参阅数组标量部分以了解解释），将Python数字序列转换为该类型的数组，或作为许多NumPy函数或方法接受的dtype关键字的参数。许多内置函数是用编译的C代码实现的。基本的ufunc操作于标量，但也有一种广义的ufunc，其基本元素是子数组（向量、矩阵等），并且广播是在其他维度上进行的。
NumPy ——（二）ufunc函数
邱邱邱的博客
10-01 562
ufunc是universal function的缩写，它是一种能对数组的每个元素进行运算的函数。 NumPy提供了许多ufunc函数，本篇博文主要介绍一些常见的ufunc 目录一、四则运算比较运算和布尔运算 一、四则运算 表达式 对应的ufunc函数 y = x1 + x2 add(x1, x2[,y]) y = x1 - x2 subtract(x1, x2[,y]) ...
Numpy：ufunc函数的方法
bqw的博客
07-22 2425
import numpy as np 一、介绍 ufunc函数对象本身还有一些方法函数，这些方法只有对两个输入、一个输出的ufunc函数有效，其他的ufunc对象调用这些方法时会抛出ValueError异常 二、ufunc方法 1.reduce()：将运算符插入到沿axis轴的所有元素之间 r1 = np.add.reduce([1,2,3])#1+2+3=6 r2 = ...
numpy中常用ufunc
吟游诗人——吟唱生命的不朽
07-30 226
本文转载自《利用python进行数据分析-第二版》
ufunc 对象
echo_1994的博客
01-17 604
Numpy 有两种基本对象：ndarray (N-dimensional array object) 和 ufunc (universal function object)。ndarray 是存储单一数据类型的多维数组，而 ufunc 则是能够对数组进行处理的函数。 例如，我们之前所接触到的二元操作符对应的 Numpy 函数，如 add，就是一种 ufunc 对象，它可以作用于数组的每个
numpy的函数对象ufunc详解
MIss-Y的博客
09-05 2889
一、什么是ufunc对象？ ufunc对象是numpy的两大基本对象之一，另一个是array。ufunc是universal function object的缩写。在Python里面，一切皆为对象，包括我们的函数，而numpy里面的函数是ufunc对象的实例，如下所示： type(np.add)#返回的是   &lt;class 'numpy.ufunc'&gt;  即ufunc对象 既然是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

hustlei

您的鼓励将是我创作的最大动力!

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值