标签：
ufunc指universal function，是一种能够对数组中的所有元素进行操作的函数，ufunc是针对数组进行操作的函数，对一个数组进行重复的运算时，使用ufunc比math库中的函数效率要高很多，然而由于ufunc会对数组做一些特殊操作，所以在单一值的函数处理上就比math库中的效率要低；
在使用ufunc时，注意千万不要用循环遍历，而是应该使用列表推导式，否则就不叫ufunc了，而是对每一个元素分别运算，失去了ufunc的意义；
ufunc的结果可以直接保存到原始数组中，这样可以节省内存消耗；
1. 四则运算
ufunc支持全部四则运算，并且保留习惯的运算符，和数值运算使用一样，但是注意操作的是数组；
两个数组的四则运算表示对两个数组中的元素分别进行四则运算，所以进行四则运算的数组形状必须相同（其实也可以不同，numpy会对形状不同的数组进行广播操作）；
避免写出一些复杂的表达式，如：
x = a * b + c
上述表达式在内存中的过程相当于：
t = a * b
x = t + c
del t
在其中会由一个中间变量t的内存消耗，为了避免该消耗，应该将表达式写成：
x = a * b
x += c
2. 比较运算
ufunc中也可以用完整的比较运算：> 、< 、 == 、 >= 、 <= 、 !=
比较运算返回的结果是一个布尔数组，每个元素为两个数组对应元素的比较结果。
3. 逻辑运算
由于python中的逻辑运算：and、or、not使用的是关键字，无法被重载，所以numpy中的逻辑运算只能通过响应的ufunc函数进行；
这些函数都以logical_开头：np.logical_and、np.logical_or、np.logical_not、np.logical_xor
如果直接对两个布尔数组进行 and、or、not操作，则会对数组中的每个元素进行操作，对应的正确操作应该为逻辑谓词：存在和所有，
在numpy中的对应函数为：np.any()、np.all()
4. 位运算
位运算使用 &，~，|，^ 分别做按位与、按位反、按位或、按位异或；
将一些只对单一值操作的函数（以下称标量函数）进行转换，得到对应的ufunc，可以使用numpy中的两个函数：frompyfunc和vectorize
np.frompyfunc(func, nin, nout)函数需要指定三个参数，依次为：标量函数、输入参数个数、返回值个数；
np.frompyfunc的返回值其类型均为object，通过astype()方法可以将类型做出相应的转换；
np.vectorize(func, otypes=[])函数指定两个参数，依次为：标量参数、返回值的类型列表；
ufunc函数在对两个数组进行计算时，如果两个数组的形状不相同，则会进行广播处理，其处理的规则为：
1. 让所有数组都向其中维数最多的数组看齐，shape属性中不足的部分都通过在前面加1补齐；
2. 输出数组的shape属性是输入数组shape属性在各轴上的最大值；
3. 如果输入数组的某个轴长度为1或与输出数组对应轴的长度相同，这个数组就能够用来计算，否则出错；
4. 当输入数组的某个轴长度为1时，沿着此轴运算时都用此轴上的第一组值；
如：
a = np.array(0,60,10).reshape(-1,1)
b = np.array(0,5)
两个数组，其中a.shape = (6,1)， b.shape = (5,)，广播处理过程为：
1. b数组向a数组看齐，并且在shape属性前面加1，此时，b.shape = (1,5)
2. 输出数组的shape为(6,5)，是数组shape各轴上的最大值；
3. a.shape = (6,1)，0轴与输出数组长度相同，1轴为1，可以用来计算；b.shape = (1,5)，0轴为1，1轴与输出数组长度相同，可以用来计算；
4. a数组的1轴长度为1，故a数组在1轴上的值都沿用 a[:,0]的值；b数组的0轴长度为1，故b数组0轴上的值都沿用 b[0,:]的值，此时，a，b数组可以看做：
?a = array([[0, ?0, ?0, ?0, ?0],
? ? ? ? ? ? ? ? ?[10,10,10,10,10],
? ? ? ? ? ? ? ? ?[20,20,20,20,20],
? ? ? ? ? ? ? ? ?[30,30,30,30,30],
? ? ? ? ? ? ? ? ?[40,40,40,40,40],
? ? ? ? ? ? ? ? ?[50,50,50,50,50]])
?b = array([[0, 1, 2, 3, 4],
? ? ? ? ? ? ? ? ? [0, 1, 2, 3, 4],
? ? ? ? ? ? ? ? ? [0, 1, 2, 3, 4],
? ? ? ? ? ? ? ? ? [0, 1, 2, 3, 4],
? ? ? ? ? ? ? ? ? [0, 1, 2, 3, 4],
? ? ? ? ? ? ? ? ? [0, 1, 2, 3, 4]])
此时，a和b数组就可以进行相应的ufunc操作了；
numpy在内部真正运算时，并不会对数组进行重复的填充操作，这样太浪费空间；
事实上，numpy还提供了一个常用的网格对象来进行常用的广播操作：ogrid和mgrid
其中，np.ogrid必须对其进行切片操作，并且返回一个数组，数组的每个值都是一个只有单一轴的数组，如：
np.ogrid[:5,:4] =?
[array([[0],
[1],
[2],
[3],
[4]]), array([[0, 1, 2, 3]])]
而np.mgrid则是填充后的结果（由于比较消耗内存，应该使用ogrid代替）：
np.mgrid[:5,:5] =?
array([[[0, 0, 0, 0],
[1, 1, 1, 1],
[2, 2, 2, 2],
[3, 3, 3, 3],
[4, 4, 4, 4]],
[[0, 1, 2, 3],
[0, 1, 2, 3],
[0, 1, 2, 3],
[0, 1, 2, 3],
[0, 1, 2, 3]]])
对只有一个输入、一个输出的ufunc函数对象，numpy中有一些特定的方法以供调用
1. <op>.reduce(array, axis=0, dtype=None)：和python中的reduce()类似，该方法沿着axis指定轴进行reduce操作，如：
? ?np.add.reduce([1,2,3]) ? # 返回6
? ?np.add.reduce([[1,2,3],[4,5,6]],axis=1) ?# 返回[6,15]
? ?np.add.reduce([1,2,3],[4,5,6]) ?#返回 [5,7,9]
2. <op>.accumulate()功能和reduce相同，但是该方法会返回每一步的结果，并且返回一个和原数组形状相同的结果数组；
3. <op>.reduceat(array, indices=[])：indices参数指定一系列的起始和终止位置，当indices的最后一个元素小于倒数第二个时，会将该值作为新的起始值，而终止值为数组最大长度；
? ? 计算规则为：
? ? if indices[i] < indices[i+1]:
? ? ? ? result = <op>.reduce(a[indices[i]:indices[i+1]])
? ? else:
? ? ? ? result[i] = a[indices[i]]
? ?若最后一个元素小于倒数第二个，则：
? ?result[i] = <op>.reduce(a[indices[-1]:])
4. <op>.outer(array1,array2)：方法对两个参数数组中每两个元素的组合依次进行运算，结果数组的形状为两个数组形状的组合，如第一个数组的形状为(2,3)，第二个数组的形状为(4,5)，则结果数组的形状为(2,3,4,5)，如：
? ? np.multiply.outer([1,2,3,4],[2,3,4])
? ? array([[ 2, 3, 4],
? ? [ 4, 6, 8],
? ? [ 6, 9, 12],
? ? [ 8, 12, 16]])
标签：
原文地址：http://www.cnblogs.com/lyon2014/p/4696989.html
