ufunc函数

　　无灯可看。雨水从教正月半。探茧推盘。探得千秋字字看。

　　铜驼故老。说著宣和似天宝。五百年前。曾向杭州看上元。

　　ufunc是universal function的缩写，他是一种对数组的每个元素进行运算的函数。NumPy的内置许多函数都是用C语言实现的因此，他们的计算速度十分的快。

>>> x = np.linspace(0,2*np.pi,10)
>>> x
array([ 0.        ,  0.6981317 ,  1.3962634 ,  2.0943951 ,  2.7925268 ,
        3.4906585 ,  4.1887902 ,  4.88692191,  5.58505361,  6.28318531])
>>> y = np.sin(x)
>>> y
array([  0.00000000e+00,   6.42787610e-01,   9.84807753e-01,
         8.66025404e-01,   3.42020143e-01,  -3.42020143e-01,
        -8.66025404e-01,  -9.84807753e-01,  -6.42787610e-01,
        -2.44929360e-16])

　　可以查看函数的使用方法，得到使用方法。

　　下面我们比较一下np.sin()和math.sin()的时间复杂度。

#coding:utf-8
import math
import datetime
import numpy as np

x = np.array([i* 0.001 for i in range(3000000)])

def sin_math(x):
    beg = datetime.datetime.now()
    for i,t in enumerate(x):  # 返回下标和元素。
        x[i] = math.sin(t)
    end = datetime.datetime.now()
    return end-beg

def sin_np(x):
    beg = datetime.datetime.now()
    np.sin(x,x)
    end = datetime.datetime.now()
    return end-beg

print(sin_math(x),sin_np(x))

最后得到的结构大概 np.sin()的速度比math.sin()快5倍。这得益于np.sin()的C语言级别的计算。

　　

　　实际上标准的Python中可以用列表推导式的方法得到比for循环更快的计算效果。x = [math.sin(t) for t in x] ，但是列表推导式将产生一个新的列表，而不是修改原来的列表，相当于用 空间换了时间。

四则运算

　　NumPy提供了许多的ufunc函数，例如计算两个数组之和的add()函数。

>>> a+b
array([ 5,  7,  9, 11])
>>> a = np.arange(0,4)
>>> b = np.arange(5,9)
>>> a+b
array([ 5,  7,  9, 11])
>>> np.add(a,b)
array([ 5,  7,  9, 11])

　　add()将返回一个数组，这个同样可以指定out参数，如果没有指定则创建一个新的数组来保存计算结果。

>>> np.add(a,b,a)
array([ 5,  7,  9, 11])
>>> a
array([ 5,  7,  9, 11])

　　NumPy位数组定义了各种数学运算操作符，因此计算两个数组想家可以简单的写成a+b而，而np.add(a,b,a)则可以用a += b来表示。下标列出了数组的运算符，以及与之对应的ufunc

　　数组对象支持操作符，极大地简化了算式的编写，但是需要注意，如果算式很复杂，要产生大量的中间结果这样就会降低程序的运算速度，例如堆a，b，c，三个数组采用算法进行 x = a * b + c 它相当于

t = a * b
x = t + c
del t

　　我们可以通过分解算式来将上述的一句话，变成两句话，且减少一次内存分配。

x = a * b
x += c

　　使用比较运算符堆两个数组进行运算的时候，将返回一个Bool 数组， 他的每个元素值都是两个数组对应元素的比较结果 eg：

>>> np.array([1,2,3,4]) < np.array([4,3,2,1])
array([ True,  True, False, False], dtype=bool)

每个比较运算符都有一个ufunc 函数对应， 表2-2是比较运算符与ufunc 函数的对照表。

　　因为Python中的布尔运算使用，and，or和not等关键字，他们无法被重载，因此数组的布尔运算只能通过相应的ufunc函数进行，这些函数都以logical_开头，可以通过自动补齐来找到相应函数。

　　

>>> a = np.arange(5)
>>> a
array([0, 1, 2, 3, 4])
>>> b = np.arange(4,-1,-1)
>>> b
array([4, 3, 2, 1, 0])
>>> print (a == b)
[False False  True False False]
>>> print(a>b)
[False False False  True  True]
>>> print(np.logical_and(a,b))
[False  True  True  True False]
>>> print(a == b,a>b)
[False False  True False False] [False False False  True  True]

自定义ufunc函数　　

　　通过NumPy提供的标准ufunc函数，可以组合出复杂的表达式，在C语言级别堆数组的每个元素进行计算。但是这种表达式不易编写，而对元素进行计算的程序却很容易用Python实现，这时候可以通过frompyfunc()将计算单个元素的函数转换成ufunc函数，这样就可以很方便的用所产生的ufunc函数对数组进行计算了。

　　例如我们可以通过一个分段函数描述三角波，三角波的形状如图所示，它分为三段：上升段，下降段和平坦段。

　　根据图2-5，我们可以很容易的写出计算三角波上某点的Y坐标函数，显然triangle_wave()只能计算单个数值，不能直接堆数组进行处理。

　　

import numpy as np
import matplotlib.pyplot as plt 

def triangle_wave(x,c,c0,hc):
    x = x - int(x) #三角波的周期位1，因此只取x坐标的小数部分进行计算。
    if x > c:
        r = 0.0
    elif x < c0:
        r = x / c0 * hc
    else:
        r = (c - x)/(c - c0) * hc

    return r

x = np.linspace(0,2,1000)
y1 = np.array([triangle_wave(t,0.6,0.4,1.0) for t in x])

plt.plot(x,y1)
plt.show()

　　通过frompyfunc()可以将计算单个值的函数转换为能对数组的每个元素进行计算的ufunc函数。frompyfunc的调用格式为：

frompyfunc(func,nin,nout)

　　其中func是计算单个元素的函数，nin是func的输入参数的个数，nout是func的返回值的个数。下面的程序使用frompyfunc()将triangle_wave()转换为ufunc函数对象triangle_ufunc1：

# -*- coding: utf-8 -*-
"""
Created on Tue Mar 14 13:24:50 2017

@author: x-power
"""
import numpy as np
import matplotlib.pyplot as plt 

def triangle_wave(x,c,c0,hc):
    x = x - int(x) #三角波的周期位1，因此只取x坐标的小数部分进行计算。
    if x > c:
        r = 0.0
    elif x < c0:
        r = x / c0 * hc
    else:
        r = (c - x)/(c - c0) * hc

    return r

x = np.linspace(0,2,1000)
y1 = np.array([triangle_wave(t,0.6,0.4,1.0) for t in x])

triangle_ufunc = np.frompyfunc(triangle_wave,4,1)
y2 = triangle_ufunc(x,0.6,0.3,1)

print("y1的类型是：" + str(y1.dtype))

print("y2的类型是：" + str(y2.dtype))

y2 = y2.astype(np.float)

print("转换之后的y2类型是：" + str(y2.dtype))

print("如果使用np.frompyfunc的话，返回值的类型是object很尴尬，如果需要方便的使用的话，需要转换类型。")

#plt.plot(x,y1)
#plt.plot(x,y2)
#
#plt.show()

广播

　　当使用ufunc函数堆两个数组进行计算的时候，ufunc函数会对这两个数组的对应元素进行计算，因此其要求两个数组的shape相同，不同的话会进行广播处理( broadcasting )处理：

　　　　1）让所有的输入数组都向其中维数最多的数组看齐，shape属性中不足的部分都通过向前面加1 的当时补齐。

　　　　2）输出的数组的shape属性是输入数组的shape属性的各个轴上的最大值。

　　　　3）如果输入数组的某个轴长度为 1 时，沿着此轴运算时都用此轴上的第一组值。

　　talk is cheap ， show me your code ！

import numpy as np
import matplotlib.pyplot as plt 

a = np.arange(0,60,10).reshape(-1,1)
b = np.arange(0,5)

c = a + b

print("a的形状是：" + str(a.shape))
print(a)

print("b的形状是：" + str(b.shape))
print(a)

print("c的形状是：" + str(c.shape))
print(c)

a的形状是：(6, 1)
[[ 0]
 [10]
 [20]
 [30]
 [40]
 [50]]
b的形状是：(5,)
[[ 0]
 [10]
 [20]
 [30]
 [40]
 [50]]
c的形状是：(6, 5)
[[ 0  1  2  3  4]
 [10 11 12 13 14]
 [20 21 22 23 24]
 [30 31 32 33 34]
 [40 41 42 43 44]
 [50 51 52 53 54]]

　　由于a和b的维数不同，根据规则1），需要让b的shape属性向a 对齐，于是在b的 shape属性前 加 1，补齐位（1,5）.相当于做了如下计算：

b.shape = 1,5

　　这样加法运算的两个输入数组的shape属性分别为（6,1）和（1,5），根据规则2）输出数组的各个轴的长度位输入数组的各个轴长度的最大值，可知输出数组的shape属性为（6,5）。

　　由于b的第0轴长度为1，而a的第0轴长度为6，为了让他们在第0轴上能够相加，需要将b的第0轴的长度扩展为6，这相当于：

　　

b
Out[16]: array([[0, 1, 2, 3, 4]])

b = b.repeat(6,0)

b
Out[18]:
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]])

　　这里的repeat()方法沿着axis参数指定的轴复制数组中的各个元素的值。由于a的第 1 轴的长度为 1 而b的第1轴的长度为5，为了能够让他们相加，需要将a的第一轴的长度扩展为5 这相当于：

a
Out[19]:
array([[ 0],
       [10],
       [20],
       [30],
       [40],
       [50]])

a = a.repeat(5,1)

a
Out[21]:
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]])

　　经过上述处理就可以让 a 和 b进行相加计算了。可是这样不是很浪费内存么？由于这种广播计算使用频率比较高，所以一定是要有解决办法的。因此NumPy提供了ogrid对象，用于创建广播运算用的数组。

x,y = np.ogrid[:5,:5]
print(x)
print(y)

[[0]
 [1]
 [2]
 [3]
 [4]]
[[0 1 2 3 4]]

　　此外，NumPy还提供了mgrid对象，它的用法和ogrid对象类似，但是它所返回的是进行广播之后的数组：

x,y = np.mgrid[:5,:5]
print(x)
print(y)

[[0 0 0 0 0]
 [1 1 1 1 1]
 [2 2 2 2 2]
 [3 3 3 3 3]
 [4 4 4 4 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]]

　　ogrid是一个很有趣的对象，它像是多维数组一样，用切片元祖作为下标，返回的是一组可以用来广播计算的数组，其切片下标有两种形式：

• 　　开始值：结束值：步长，和np.arange(开始，结束，步长)类似
• 开始值：结束值：长度j，当第三个参数为虚数的时候，它表示所返回数组的长度和np.linspace（开始值，结束值，长度）类似。

x = np.arange(0,1,0.1)
y = np.linspace(0,1,10)
print(x)
print(y)

x,y = np.ogrid[:1:4j,:1:3j]
print(x)
print(y)

x,y = np.ogrid[-2:2:20j,-2:2:20j]
z = x + np.exp(-x**2 - y**2)

下图则位使用ogrid()函数，计算二元函数在等间隔网格上的值，下面是绘制三维曲面（x，y）= xe^{x^2-y^2}的图形。

　　为了充分利用ufunc的广播功能，我们经常需要调整数组的形状，因此数组支持特殊的下标对象None，它表示在None对应的位置创建一个长度为1的新轴。例如堆一维数组a，a[None，：]和a.reshape(1,-1)等效，而a[:,None]和a.shape(-1,1)等效：

a = np.arange(4)
print(a[:,None])
print("\n\n\n")
print(a[None,:])

runfile('/home/x-power/untitled0.py', wdir='/home/x-power')
[[0]
 [1]
 [2]
 [3]]

[[0 1 2 3]]

　　下面的例子以None作为下标，实现广播运算。

x = np.array([0,1,4,10])
y = np.array([2,3,8])
print(x[None,:])
print(y[:,None])
print(x[None,:]+y[:,None])

[[ 0  1  4 10]]
[[2]
 [3]
 [8]]
[[ 2  3  6 12]
 [ 3  4  7 13]
 [ 8  9 12 18]]

　　真正的英雄都是在最后力挽狂澜的，这句话说的真他么的对，狗日的。　　

x = np.array([0,1,4,10])
y = np.array([2,3,8])
gy,gx = np.ix_(y,x)
print(gy + gx)

[[ 2  3  6 12]
 [ 3  4  7 13]
 [ 8  9 12 18]]

　　在上面的例子中，通过ix_()将数组x和y转换成能进行广播运算的二维数组，注意数组y对应广播运算结果中的0轴，而数组x与第1轴相对应。