numpy教程：函数库和ufunc函数

http://blog.csdn.net/pipisorry/article/details/39235753

numpy函数库：对数组进行处理

ufunc函数: ufunc是universal function的缩写，它是一种能对数组的每个元素进行操作的函数。NumPy内置的许多ufunc函数都是在C语言级别实现的，因此它们的计算速度非常快。

numpy函数和方法(method)总览

创建数组

arange, array, copy, empty, empty_like, eye, fromfile, fromfunction, identity, linspace, logspace, mgrid, ogrid, ones, ones_like, r , zeros, zeros_like 

转化

astype, atleast 1d, atleast 2d, atleast 3d, mat 

操作

array split, column stack, concatenate, diagonal, dsplit, dstack, hsplit, hstack, item, newaxis, ravel, repeat, reshape, resize, squeeze, swapaxes, take, transpose, vsplit, vstack 

询问

all, any, nonzero, where 

排序

argmax, argmin, argsort, max, min, ptp, searchsorted, sort 

运算

choose, compress, cumprod, cumsum, inner, fill, imag, prod, put, putmask, real, sum 

基本统计

cov, mean, std, var 

基本线性代数

cross, dot, outer, svd, vdot

ufunc函数对象的方法

ufunc函数对象本身还有一些方法，这些方法只对两个输入、一个输出的ufunc函数有效，其它的ufunc对象调用这些方法时会抛出ValueError异常。

reduce()方法

和Python的reduce()函数类似，它沿着axis参数指定的轴对数组进行操作，相当于将<op>运算符插入到沿axis轴的所有元素之间。

<op>.reduce (array, axis=0, dtype=None)

例如：

>>> np.add.reduce([1,2,3]) # 1 + 2 + 36>>> np.add.reduce([[1,2,3],[4,5,6]], axis=1) # (1+2+3),(4+5+6)
array([ 6, 15])
计算numpy数组array中所有元素乘积
np.multiply.reduce(array)
如：print(np.multiply.reduce([5,2,3]))
30

accumulate()

和reduce()类似，只是它返回的数组和输入数组的形状相同，保存所有的中间计算结果：

>>> np.add.accumulate([1,2,3])array([1, 3, 6])>>> np.add.accumulate([[1,2,3],[4,5,6]], axis=1)array([[ 1,  3,  6],       [ 4,  9, 15]])

reduceat()

计算多组reduce()的结果，通过indices参数指定一系列的起始和终了位置。它的计算有些特别，让我们通过例子详细解释一下：

>>> a = np.array([1,2,3,4])>>> result = np.add.reduceat(a,indices=[0,1,0,2,0,3,0])>>> resultarray([ 1,  2,  3,  3,  6,  4, 10])

对于indices参数中的每个元素都会计算出一个值，因此最终的计算结果和indices参数的长度相同。结果数组result中除最后一个元素之外，都按照如下计算得出：

if indices[i] < indices[i+1]:    result[i] = <op>.reduce(a[indices[i]:indices[i+1]])else:    result[i] = a[indices[i]]

而最后一个元素如下计算:

<op>.reduce(a[indices[-1]:])

因此上面例子中，数组result的每个元素按照如下计算得出：

1 : a[0] -> 12 : a[1] -> 23 : a[0] + a[1] -> 1 + 23 : a[2] -> 36 : a[0] + a[1] + a[2] ->  1 + 2 + 3 = 64 : a[3] -> 410: a[0] + a[1] + a[2] + a[4] -> 1 + 2 + 3 + 4 = 10

可以看出result[::2]和a相等，而result[1::2]和np.add.accumulate(a)相等。使用reduceat()可以对数组中的多个片段同时进行reduce运算。

outer()方法

对其两个参数数组的每两对元素的组合进行运算。若数组a的维数为M，数组b的维数为N，则ufunc函数op的outer()方法对a、b数组计算所生成的数组c的维数为M+N。c的形状是a、b的形状的结合。例如a的形状为(2,3)，b的形状为(4,5)，则c的形状为(2,3,4,5)。让我们看一个例子：

>>> np.multiply.outer([1,2,3,4,5],[2,3,4])array([[ 2,  3,  4],       [ 4,  6,  8],       [ 6,  9, 12],       [ 8, 12, 16],       [10, 15, 20]])

可以看出通过outer()计算的结果是如下的乘法表：

*| 2  3  4------------1| 2  3  42| 4  6  83| 6  9 124| 8 12 165|10 15 20

如果将这两个数组按照等同程序一步一步地进行计算，就会发现乘法表最终是通过广播的方式计算出来的。

皮皮blog

Vectorize函数

对numpy数组中的每一个元素应用一个函数

a = np.array([[[1, 2], [1]],              [[2, 3, 3], [3, 4]]              ])print(a.shape)count_fun = np.vectorize(lambda x: len(x))print(count_fun(a))

def t(x):
  return x + 3
a1 = scipy.zeros((2,4))
a1
          [[0 0 0 0]
          [0 0 0 0]]
s = scipy.vectorize(t)
a2 = s(a1)
a2
         [[3 3 3 3]
          [3 3 3 3]]

numpy.array_equal(a1,a2)函数

True if two arrays have the same shape and elements, False otherwise.

[numpy.array_equal]

皮皮blog

多项式函数

多项式函数是变量的整数次幂与系数的乘积之和，可以用下面的数学公式表示：
     f(x)= anxn+an-1xn-1 +…+a2x2+a1x +a0

表示和转换

f(x) = x3 -2x + 1可以用下面 的数组表示，其中a[0]是最高次的系数，a[-1]是常数项，注意x2的系数为0。
>>>a= np.array([1.0, 0, -2, 1])
用poly1d()将系数转换为poly1d(一元多项式)对象，此对象可以像函数一样调用，它 返回多项式函数的值：
>>> p = np.poly1d(a)
>>>type(p)
< numpy.lib.polynomial.poly1d>
>>> p(np.linspace(0,1, 5))
array([ 1., 8.515625, 0.125, -0.078125, 0. ])

多项式计算

对poly1d对象进行加减乘除运算相当于对相应的多项式函数进行计算。例如：
>>> p + [-2, 1] # 和 p + np.polyld([-2, 1])相同 poly1d([ 1., 0., -4., 2.])
>>> p*p #两个3次多项式相乘得到一个6次多项式
 polyld([ 1., 0., -4., 2., 4., -4.,1.])
>>> p / [1, 1] #除法返回两个多項式，分别为商式和余式 (poly1d([ 1., -1., -1.]), poly1d([ 2.]))
>>> p==np.poly1d([ 1., -1., -1.]) * [1,1] + 2 
>>> True

多项式微分和积分

多项式对象的deriv()和integ()方法分别计算多项式函数的微分和积分：
>>> p.deriv()
poly1d([ 3., 0., -2.])
>>> p.integ()
poly1d([ 0.25, 0., -1., 1. , 0.])
>>> p.integ().deriv() == p 
True

多项式函数的根

使用roots()函数计算
>>> r = np.roots(p)
>>> r
array([-1.61803399, 1., 0.61803399])
>>> p(r)  #将根带入多项式计算，得到的值近似为0
array([ -4.21884749e-15, -4.44089210e-16,-2.22044605e-16])
poly()函数可以将根转换冋多项式的系数
>>> np.poly(r)
array([ 1. 00000000e+00, 9.99200722e-16, -2. 000000000e+00 , 1.00000000e+00])

NumPy多项式函数

除了使用多项式对象之外，还可以直接使用NumPy提供的多项式函数对表示多项式系数的数组进行运算。
 >>> np.polymul([1,1],[1,1])
array( [1,2,1])

polyfit()函数

对一组数据使用多项式函数进行拟合，找到和这组数据最接近的 多项式的系数。
计算-pi/2~ pi/2区间与sin(x)函数最接近的多项式的系数：(numpy_polyfit.py)
x = np.linspace(-np.pi/2, np.pi/2, 1000) 
y = np.sin(x) 
for deg in [3,5,7]:
      a = np.polyfit(x, y, deg)
      error = np.abs(np.polyval(a, x)-y)
      print “poly %d:” %deg, a
      print “max error of order %d:” % deg , np.max(error)

皮皮blog

广播(broadcasting)运算及数组四则运算

当使用ufunc函数对两个数组进行计算时，ufunc函数会对这两个数组的对应元素进行计算，因此它要求这两个数组的形状相同。

广播规则允许你在形状不同但却兼容的数组上进行计算。换句话说，你并不总是需要重塑或铺平数组，使它们的形状匹配。

广播规则描述了具有不同维度和/或形状的数组仍可以用于计算。一般的规则是：当两个维度相等，或其中一个为1时，它们是兼容的。NumPy使用这个规则，从后边的维数开始，向前推导，来比较两个元素级数组的形状。最小的维度在内部被自动延伸，从而匹配其他维度，但此操作并不涉及任何内存复制。

如果形状不同，会进行如下的广播处理：

1. 让所有输入数组都向其中维数最多的数组看齐，shape属性中不足的部分都通过在前面加1补齐。
2. 输出数组的shape属性是输入数组的shape属性的各个轴上的最大值。
3. 如果输入数组的某个轴的长度为1或与输出数组的对应轴的长度相同时，这个数组能够用来计算，否则出错。
4. 当输入数组的某个轴的长度为1时，沿着此轴运算时都用此轴上的第一组值。

例子

为了更好的了解广播运算可以先看看前面的tile函数的计算方式。

例1：2*1数组和1*2数组相乘

a = np.array([1, 2]).reshape([-1, 1])print('a = \n', a)b = np.array([[4, 5]])print('b = \n', b)print('a*b = \n', a * b)

a =  [[1] [2]]b =  [[4 5]]a*b =  [[ 4  5] [ 8 10]]

例2：

先创建一个二维数组a，其形状为(6,1)：

>>> a = np.arange(0, 60, 10).reshape(-1, 1)>>> aarray([[ 0], [10], [20], [30], [40], [50]])>>> a.shape(6, 1)

再创建一维数组b，其形状为(5,)：

>>> b = np.arange(0, 5)>>> barray([0, 1, 2, 3, 4])>>> b.shape(5,)

例1：计算a和b的和

得到一个加法表，它相当于计算两个数组中所有元素组的和，得到一个形状为(6,5)的数组：

>>> c = a + b>>> carray([[ 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]])>>> c.shape(6, 5)

由于a和b的维数不同，根据规则1，需要让b的shape属性向a对齐，于是将b的shape属性前面加1，补齐为(1,5)。相当于做了如下计算：

>>> b.shape=1,5>>> barray([[0, 1, 2, 3, 4]])

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

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

>>> b = b.repeat(6,axis=0)>>> barray([[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的第1轴的长度为1，而b的第1轴长度为5，为了让它们在第1轴上能够相加，需要将a的第1轴的长度扩展为5，这相当于：

>>> a = a.repeat(5, axis=1)>>> aarray([[ 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就可以按对应元素进行相加运算了。

例2：行减行均值

A = np.array([[1, 2, 3, 4, 5], [2, 3, 2, 5, 3], [5, 5, 5, 3, 2]])print(A)row_mean = np.mean(A, 1).reshape([len(A),1])print(row_mean)print(A - row_mean)

当然，在执行“a+b”运算时，NumPy内部并不会真正将长度为1的轴用repeat()进行扩展，这样太浪费空间了。

快速产生广播运算数组的ogrid对象

[numpy教程：数组创建]

numpy教程：排序、搜索和计数函数

from:http://blog.csdn.net/pipisorry/article/details/39235753

ref: NumPy Reference

用Python做科学计算-ufunc运算

http://www.cnblogs.com/begtostudy/archive/2010/08/03/1790935.html