Numpy补充（转）

原文链接：NumPy入门详解
http://blog.topspeedsnail.com/archives/599

概述

NumPy和SciPy是开源的 Python 的科学计算模块，这俩货提供了预编译的快速的数学函数，基于C语言开发。这两个库已经发展的很成熟了，NumPy 包提供了大数组和矩阵函数。SciPy 扩展了NumPy包，它集成了很多有用的算法，像最小值，傅立叶变换，线性回归等等。

安装

pip install numpy
pip install scipy

引入 NumPy 模块

有几种方法引入Numpy模块，标准做法是用 import 语句。

>>> import numpy

但是如果你调用了大量的NumPy函数，一遍一遍的写 numpy.X 就比较烦了，下面用给numpy 起一个短一点的名字。

>>> import numpy as np

这个语句可以用 np.x 代替 numpy.x。如果连简称都不想要，就像调用内建函数一样，一般不建议这个引入方法。

>>> from numpy import *

数组

NumPy 的中心就是 array 类。这里的数组和python的list很像，除了数组里的每个元素必须是同一个类型，典型的是数字类型，像 float 和 int。Array可以操作大量的数据而且比list要高效的多。

数组可以用list创建：

>>> a = np.array([1, 4, 5, 8], float)
>>> a
array([ 1.,  4.,  5.,  8.])
>>> type(a)

在这里函数 array 使用两个参数：list 和 数据的类型。数组元素可以被访问，分割，操作，就像list一样：

>>> a[:2]
array([ 1.,  4.])
>>> a[3]
8.0
>>> a[0] = 5.
>>> a
array([ 5.,  4.,  5.,  8.])

不像list，数组可以是多维的，下面是两维数组的例子：

>>> a = np.array([[1, 2, 3], [4, 5, 6]], float)
>>> a
array([[ 1.,  2.,  3.],
       [ 4.,  5.,  6.]])
>>> a[0,0]
1.0
>>> a[0,1]
2.0

数组的分割在多维数组里是一样的，每个分割应用到相应的维度：

>>> a = np.array([[1, 2, 3], [4, 5, 6]], float)
>>> a[1,:]
array([ 4.,  5.,  6.])
>>> a[:,2]
array([ 3.,  6.])
>>> a[-1:,-2:]
array([[ 5.,  6.]])

数组的形状（shape）属性是每个维度的个数：

>>> a.shape
(2, 3)

数组的 dtype 属性告诉你数组元素的类型：

>>> a.dtype
dtype('float64')

len 函数返回第一轴长度：

>>> a = np.array([[1, 2, 3], [4, 5, 6]], float)
>>> len(a)
2

in 测试值是否在数组中：

>>> a = np.array([[1, 2, 3], [4, 5, 6]], float)
>>> 2 in a
True
>>> 0 in a
False

数组可以被重新排列，下面把一个一维数组转化为二维数组：

>>> a = np.array(range(10), float)
>>> a
array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.])
>>> a = a.reshape((5, 2))
>>> a
array([[ 0.,  1.],
       [ 2.,  3.],
       [ 4.,  5.],
       [ 6., 7.],
       [ 8.,  9.]])
>>> a.shape
(5, 2)

注意 reshape 函数创建了一个新的数组，并不是在修改原来的数组。

copy 函数创建一个新的，分离的内存拷贝：

>>> a = np.array([1, 2, 3], float)
>>> b = a
>>> c = a.copy()
>>> a[0] = 0
>>> a
array([0., 2., 3.])
>>> b
array([0., 2., 3.])
>>> c
array([1., 2., 3.])

list 也可以用数组创建：

>>> a = np.array([1, 2, 3], float)
>>> a.tolist()
[1.0, 2.0, 3.0]
>>> list(a)
[1.0, 2.0, 3.0]

我们可以把数组的原始数据转化为二进制字符串（tostring 函数），fromstring 是 tostring 的反过程。tostring 函数可以很方便的把数组数据存储到文件中，以后需要时再用 fromstring 函数进行读取：

>>> a = array([1, 2, 3], float)
>>> s = a.tostring()
>>> s 'x00x00x00x00x00x00xf0?x00x00x00x00x00x00x00@x00x00x00x00 x00x00x08@'
>>> np.fromstring(s)
array([ 1.,  2.,  3.])

fill 可以用一个值填充数组：

>>> a = array([1, 2, 3], float)
>>> a
array([ 1.,  2.,  3.])
>>> a.fill(0)
>>> a
array([ 0.,  0.,  0.])

transpose 对数组进行转置，生成一个新的数组：

>>> a = np.array(range(6), float).reshape((2, 3))
>>> a
array([[ 0.,  1.,  2.],
       [ 3.,  4.,  5.]])
>>> a.transpose()
array([[ 0.,  3.],
       [ 1.,  4.],
       [ 2., 5.]])

flatten 把多维数组转为一位数组：

>>> a = np.array([[1, 2, 3], [4, 5, 6]], float)
>>> a
array([[ 1.,  2.,  3.],
       [ 4.,  5.,  6.]])
>>> a.flatten()
array([ 1.,  2.,  3.,  4.,  5.,  6.])

concatenate 把多个数组串联起来：

>>> a = np.array([1,2], float)
>>> b = np.array([3,4,5,6], float)
>>> c = np.array([7,8,9], float)
>>> np.concatenate((a, b, c))
array([1., 2., 3., 4., 5., 6., 7., 8., 9.])

如果数组有多个维度，可以指定维度进行串联，默认情况下 concatenate 串联第一个维度：

>>> a = np.array([[1, 2], [3, 4]], float)
>>> b = np.array([[5, 6], [7,8]], float)
>>> np.concatenate((a,b))
array([[ 1.,  2.],
       [ 3.,  4.],
       [ 5.,  6.],
       [ 7.,  8.]])
>>> np.concatenate((a,b), axis=0)
array([[ 1.,  2.],
       [ 3.,  4.],
       [ 5.,  6.],
       [ 7.,  8.]])
>>> np.concatenate((a,b), axis=1)
array([[ 1.,  2.,  5.,  6.],
       [ 3.,  4.,  7.,  8.]])

newaxis 常量增加维度：

>>> a = np.array([1, 2, 3], float)
>>> a
array([1., 2., 3.])
>>> a[:,np.newaxis]
array([[ 1.],
       [ 2.],
       [ 3.]])
>>> a[:,np.newaxis].shape
(3,1)
>>> b[np.newaxis,:]
array([[ 1.,  2.,  3.]])
>>> b[np.newaxis,:].shape
(1,3)

newaxis 为向量和矩阵运算生成适当的维度。

创建数组的其它方法

arange 函数和 range 类似，不同的是 arange 返回数组

>>> np.arange(5, dtype=float)
array([ 0.,  1.,  2.,  3.,  4.])
>>> np.arange(1, 6, 2, dtype=int)
array([1, 3, 5])

zeros 和 ones 函数创建一个指定维度的数组，并且分别填充0，1。这两个也许是最常用的创建数组的方法：

>>> np.ones((2,3), dtype=float)
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.]])
>>> np.zeros(7, dtype=int)
array([0, 0, 0, 0, 0, 0, 0])

zeros_like 和 ones_like 用已存在数组的维度创建新数组，并分别填充0，1：

>>> a = np.array([[1, 2, 3], [4, 5, 6]], float)
>>> np.zeros_like(a)
array([[ 0.,  0.,  0.],
       [ 0.,  0.,  0.]])
>>> np.ones_like(a)
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.]])

创建一个给定大小的2维单位矩阵：

>>> np.identity(4, dtype=float)
array([[ 1.,  0.,  0.,  0.],
       [ 0.,  1.,  0.,  0.],
       [ 0.,  0.,  1.,  0.],
       [ 0.,  0.,  0.,  1.]])

eye 函数生成一个”对角”矩阵：

>>> np.eye(4, k=0, dtype=float)
array([[ 1.,  0.,  0.,  0.],
       [ 0.,  1.,  0.,  0.],
       [ 0.,  0.,  1.,  0.],
       [ 0.,  0.,  0.,  1.]])
>>> np.eye(4, k=1, dtype=float)
array([[ 0.,  1.,  0.,  0.],
       [ 0.,  0.,  1.,  0.],
       [ 0.,  0.,  0.,  1.],
       [ 0.,  0.,  0.,  0.]])

数组之间的数学计算

数组之间进行计算的时候注意数组的维数，相同大小的数组可以加，减…：

>>> a = np.array([1,2,3], float)
>>> b = np.array([5,2,6], float)
>>> a + b
array([6., 4., 9.])
>>> a – b
array([-4., 0., -3.])
>>> a * b
array([5., 4., 18.])
>>> b / a
array([5., 1., 2.])
>>> a % b
array([1., 0., 3.])
>>> b**a
array([5., 4., 216.])

对于2维数组的乘积，执行的是数组元素依次相乘，注意，和矩阵乘法是不一样的：

>>> a = np.array([[1,2], [3,4]], float)
>>> b = np.array([[2,0], [1,3]], float)
>>> a * b
array([[2., 0.], [3., 12.]])

如果大小不同，返回如下错误：

>>> a = np.array([1,2,3], float)
>>> b = np.array([4,5], float)
>>> a + b
Traceback (most recent call last):
  File "", line 1, in 
ValueError: shape mismatch: objects cannot be broadcast to a single shape

对于多维数组来说，如果维度数不同，python 可以对数组进行扩展，然后执行数学操作。用最小维的数组填充：

>>> a = np.array([[1, 2], [3, 4], [5, 6]], float)
>>> b = np.array([-1, 3], float)
>>> a
array([[ 1.,  2.],
[ 3., 4.],
       [ 5.,  6.]])
>>> b
array([-1.,  3.])
>>> a + b
array([[ 0.,  5.],
       [ 2.,  7.],
       [ 4.,  9.]])

数组 b 在执行运算时，填充为：

 array([[-1.,  3.],
       [-1.,  3.],
[-1., 3.]])

可以指定 newaxis 指定计算方式：

>>> a = np.zeros((2,2), float)
>>> b = np.array([-1., 3.], float)
>>> a
array([[ 0.,  0.],
       [ 0.,  0.]])
>>> b
array([-1., 3.])
>>> a + b
array([[-1.,  3.],
       [-1.,  3.]])
>>> a + b[np.newaxis,:]
array([[-1.,  3.],
       [-1.,  3.]])
>>> a + b[:,np.newaxis]
array([[-1., -1.],
[ 3., 3.]])

在标准计算之上，NumPy 还提供了大量的常用数学函数，abs, sign, sqrt, log, log10, exp, sin, cos, tan, arcsin, arccos, arctan, sinh, cosh, tanh, arcsinh, arccosh,和 arctanh。

>>> a = np.array([1, 4, 9], float)
 >>> np.sqrt(a)
array([ 1.,  2.,  3.])

floor，ceil，rint：

>>> a = np.array([1.1, 1.5, 1.9], float)
>>> np.floor(a)
array([ 1.,  1.,  1.])   # 向下
>>> np.ceil(a)
array([ 2.,  2.,  2.])   # 向上
>>> np.rint(a)
array([ 1.,  2.,  2.])   # 4舍5入

NumPy 中两个重要的数学常量：

>>> np.pi
3.1415926535897931
>>> np.e
2.7182818284590451

数组的遍历

数组的遍历类似list的遍历：

>>> a = np.array([1, 4, 5], int)
>>> for x in a:
...    print x
... # 
1
4
5

二维数组：

>>> a = np.array([[1, 2], [3, 4], [5, 6]], float)
>>> for x in a:
...     print x
... # 
[1. 2.]
[3. 4.]
[5. 6.]

遍历数组时可以使用乘法：

>>> a = np.array([[1, 2], [3, 4], [5, 6]], float)
>>> for (x, y) in a:
...     print x * y
... # 
2.0
12.0
30.0

基本数组操作

很多函数都是为了得到数组的属性；数组里的元素可以相加或相乘：

>>> a = np.array([2, 4, 3], float)
>>> a.sum()
9.0
>>> a.prod()
24.0

上面使用的是成员函数，也可以用 NumPy 的标准函数：

>>> np.sum(a)  # 下面的很多函数即可以用成员函数，也可以用标准NumPy函数
9.0
>>> np.prod(a)
24.0

数组的平均值，方差，标准差：

>>> a = np.array([2, 1, 9], float)
>>> a.mean()
4.0
>>> a.var()
12.666666666666666
>>> a.std()
3.5590260840104371

数组中的最大最小元素：

>>> a = np.array([2, 1, 9], float)
>>> a.min()
1.0
>>> a.max()
9.0

argmin 和 argmax 函数返回最小最大值的索引：

>>> a = np.array([2, 1, 9], float)
>>> a.argmin()
1
>>> a.argmax()
2

对于多维数组，所有的函数都可以指定一个 axis 指定操作沿哪个轴（横竖）：

>>> a = np.array([[0, 2], [3, -1], [3, 5]], float)
>>> a.mean(axis=0)
array([ 2.,  2.])
>>> a.mean(axis=1)
array([ 1.,  1.,  4.])
>>> a.min(axis=1)
array([ 0., -1.,  3.])
>>> a.max(axis=0)
array([ 3.,  5.])

数组排序：

>>> a = np.array([6, 2, 5, -1, 0], float)
>>> sorted(a)
[-1.0, 0.0, 2.0, 5.0, 6.0]
>>> a.sort()
>>> a
array([-1.,  0.,  2.,  5.,  6.])

把数组里的元素限制到指定范围，就相当于对每个元素执行 min(max(x, minval), maxval) 操作：

>>> a = np.array([6, 2, 5, -1, 0], float)
>>> a.clip(0, 5)
array([ 5.,  2.,  5.,  0.,  0.])

取出不重复元素：

>>> a = np.array([1, 1, 4, 5, 5, 5, 7], float)
>>> np.unique(a)
array([ 1.,  4.,  5.,  7.])

对于2维数组，取出对象元素：

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

比较操作

按每元素比较：

>>> a = np.array([1, 3, 0], float)
>>> b = np.array([0, 3, 2], float)
>>> a > b
array([ True, False, False], dtype=bool)
>>> a == b
array([False,  True, False], dtype=bool)
>>> a <= b
array([False,  True,  True], dtype=bool)

any 和 all 测试数组里的bool是否都为true：

>>> c = np.array([ True, False, False], bool)
>>> any(c)   # 有一真
True
>>> all(c)   # 所有都为真
False

对数组的每个元素执行 与（and），或（or），非（not）操作：

>>> a = np.array([1, 3, 0], float)
>>> np.logical_and(a > 0, a < 3)
array([ True, False, False], dtype=bool)
>>> b = np.array([True, False, True], bool)
>>> np.logical_not(b)
array([False,  True, False], dtype=bool)
>>> c = np.array([False, True, False], bool)
>>> np.logical_or(b, c)
array([ True,  True,  False], dtype=bool)

where 函数，where(<判断>真假，真，假)，类似 a > b ? a : b ：

>>> a = np.array([1, 3, 0], float)
>>> np.where(a != 0, 1 / a, a)
array([ 1.        ,  0.33333333,  0.        ])
 >>> np.where(a > 0, 3, 2)
array([3, 3, 2])

nonzero 返回非0的元组的索引：

>>> a = np.array([[0, 1], [3, 0]], float)
>>> a.nonzero()
(array([0, 1]), array([1, 0]))

判断 NaN 和 Inf：

>>> a = np.array([1, np.NaN, np.Inf], float)
>>> a
array([  1.,  NaN,  Inf])
>>> np.isnan(a)
array([False,  True, False], dtype=bool)
>>> np.isfinite(a)
array([ True, False, False], dtype=bool)

数组元素的选择和操作

Bool数组可以用来选择元素：选出大于等于6的值

>>> a = np.array([[6, 4], [5, 9]], float)
>>> a >= 6
array([[ True, False],
       [False,  True]], dtype=bool)
>>> a[a >= 6]
array([ 6.,  9.])

又一个例子：

>>> a = np.array([[6, 4], [5, 9]], float)
>>> sel = (a >= 6)
>>> a[sel]
array([ 6.,  9.])
>>> a[np.logical_and(a > 5, a < 9)]
>>> array([ 6.])

除了用bool，还可以用整数数组当成索引，用来选择数组里的元素：

>>> a = np.array([2, 4, 6, 8], float)
>>> b = np.array([0, 0, 1, 3, 2, 1], int)
>>> a[b]
array([ 2.,  2.,  4.,  8.,  6.,  4.])

同：

 >>> a = np.array([2, 4, 6, 8], float)
>>> a[[0, 0, 1, 3, 2, 1]]
array([ 2.,  2.,  4.,  8.,  6.,  4.])

如果是多维数组，我们可以用多个一维数组，例如：

>>> a = np.array([[1, 4], [9, 16]], float)
>>> b = np.array([0, 0, 1, 1, 0], int)
>>> c = np.array([0, 1, 1, 1, 1], int)
>>> a[b,c]
array([  1.,   4.,  16.,  16.,   4.])

第一个数组指定维数，对应的第二个数组指定索引。
take 函数和［］是一样的：

>>> a = np.array([2, 4, 6, 8], float)
>>> b = np.array([0, 0, 1, 3, 2, 1], int)
>>> a.take(b)
array([ 2.,  2.,  4.,  8.,  6.,  4.])

take 还提供了axis 参数：

>>> a = np.array([[0, 1], [2, 3]], float)
>>> b = np.array([0, 0, 1], int)
>>> a.take(b, axis=0)    # 横 ［0，0，1］取 a[0]
array([[ 0.,  1.],       #                a[0]
       [ 0., 1.],        #                a[1]
       [ 2.,  3.]])
>>> a.take(b, axis=1)    # 竖
array([[ 0.,  0.,  1.],
       [ 2.,  2.,  3.]])

和 take 相对的函数是 put：

>>> a = np.array([0, 1, 2, 3, 4, 5], float)
>>> b = np.array([9, 8, 7], float)
>>> a.put([0, 3], b)
>>> a
array([ 9.,  1.,  2.,  8.,  4.,  5.])

上面的7没有用到，下面的5背重复使用

>>> a = np.array([0, 1, 2, 3, 4, 5], float)
>>> a.put([0, 3], 5)
>>> a
array([ 5.,  1.,  2.,  5.,  4.,  5.])

向量和矩阵数学

点乘：

>>> a = np.array([1, 2, 3], float)
>>> b = np.array([0, 1, 1], float)
>>> np.dot(a, b)
5.0

点乘可应用于矩阵相乘：

>>> a = np.array([[0, 1], [2, 3]], float)
>>> b = np.array([2, 3], float)
>>> c = np.array([[1, 1], [4, 0]], float)
>>> a
array([[ 0.,  1.],
       [ 2.,  3.]])
>>> np.dot(b, a)
array([  6.,  11.])
>>> np.dot(a, b)
array([  3.,  13.])
>>> np.dot(a, c)
array([[  4.,   0.],
[ 14.,
>>> np.dot(c, a)
2.]])
array([[ 2.,  4.],
       [ 0.,  4.]])

矩阵和向量的内积，外积，和十字相乘。对于向量，内积和点乘是等价的：

>>> a = np.array([1, 4, 0], float)
>>> b = np.array([2, 2, 1], float)
>>> np.outer(a, b)
array([[ 2.,  2.,  1.],
       [ 8.,  8.,  4.],
       [ 0.,  0.,  0.]])
>>> np.inner(a, b)
10.0
>>> np.cross(a, b)
array([ 4., -1., -6.])

NumPy 内建线性代数计算，在 linalg 的子模块中可以找到。求矩阵的行列式：

>>> a = np.array([[4, 2, 0], [9, 3, 7], [1, 2, 1]], float)
>>> a
array([[ 4.,  2.,  0.],
         [ 9., 3., 7.],
         [ 1.,  2.,  1.]])
>>> np.linalg.det(a)
-53.999999999999993

本征值和特征向量：

>>> vals, vecs = np.linalg.eig(a)
>>> vals
array([ 9.        ,  2.44948974, -2.44948974])
>>> vecs
array([[-0.3538921 , -0.56786837,  0.27843404],
       [-0.88473024,  0.44024287, -0.89787873],
       [-0.30333608,  0.69549388,  0.34101066]])

矩阵的逆：

>>> b = np.linalg.inv(a)
>>> b
array([[ 0.14814815,  0.07407407, -0.25925926],
       [ 0.2037037 , -0.14814815,  0.51851852],
       [-0.27777778,  0.11111111,  0.11111111]])
>>> np.dot(a, b)
array([[  1.00000000e+00, 5.55111512e-17, 2.22044605e-16]
       [  0.00000000e+00, 0.00000000e+00,  5.55111512e-16],
       [  1.11022302e-16, , 1.00000000e+00, 1.00000000e+00]])

奇异值分解：

>>> a = np.array([[1, 3, 4], [5, 2, 3]], float)
>>> U, s, Vh = np.linalg.svd(a)
>>> U
array([[-0.6113829 , -0.79133492],
       [-0.79133492,  0.6113829 ]])
>>> s
array([ 7.46791327,  2.86884495])
>>> Vh
array([[-0.61169129, -0.45753324, -0.64536587],
       [ 0.78971838, -0.40129005, -0.46401635],
       [-0.046676  , -0.79349205,  0.60678804]])

多项式

NumPy 提供了处理多项式的方法。给一组根，找多项式系数：

>>> np.poly([-1, 1, 1, 10])
array([  1, -11,   9,  11, -10])

多项式

给一组系数，求根，和上面相反的操作：

>>> np.roots([1, 4, -2, 3])
array([-4.57974010+0.j        ,  0.28987005+0.75566815j,
        0.28987005-0.75566815j])

注意：

的两个根是虚数。

求积分。

的积分是

，C是常数，默认为0：

>>> np.polyint([1, 1, 1, 1])
array([ 0.25      ,  0.33333333,  0.5       ,  1.        ,  0.        ])

同样的，求导数：

>>> np.polyder([1./4., 1./3., 1./2., 1., 0.])
array([ 1.,  1.,  1.,  1.])

polyadd, polysub, polymul, 和 polydiv 函数处理多项式系统的加，减，乘除。

polyval 求某一点的值，如求

在

时的值：

>>> np.polyval([1, -2, 0, 2], 4)
34

polyfit 函数使用最小二乘法，做曲线拟合：

>>> x = [1, 2, 3, 4, 5, 6, 7, 8]
>>> y = [0, 2, 1, 3, 7, 10, 11, 19]
>>> np.polyfit(x, y, 2)
array([ 0.375     , -0.88690476,  1.05357143])

返回了多项式系数。插值法可以在 SciPy 里找到。

统计

除了求数组的平均值，方差和标准差。NumPy 还提供一些其它函数。
求中值：

>>> a = np.array([1, 4, 3, 8, 9, 2, 3], float)
>>> np.median(a)
3.0

相关系数：

>>> a = np.array([[1, 2, 1, 3], [5, 3, 1, 8]], float)
>>> c = np.corrcoef(a)
>>> c
array([[ 1.        ,  0.72870505],
       [ 0.72870505,  1.        ]])

协方差：

 >>> np.cov(a)
array([[ 0.91666667,  2.08333333],
       [ 2.08333333,  8.91666667]])

随机数

设置随机种子：

>>> np.random.seed(293423)

种子为整数。
生成的随机数的范围 [0.0, 1.0)：

>>> np.random.rand(5)
array([ 0.40783762,  0.7550402 ,  0.00919317,  0.01713451,  0.95299583])

指定维数，下面两种方法等价：

>>> np.random.rand(2,3)
array([[ 0.50431753,  0.48272463,  0.45811345],
       [ 0.18209476,  0.48631022,  0.49590404]])
>>> np.random.rand(6).reshape((2,3))
array([[ 0.72915152,  0.59423848,  0.25644881],
       [ 0.75965311,  0.52151819,  0.60084796]])

生成一个随机数：

>>> np.random.random()
0.70110427435769551

生成指定范围的整数随机数：

 >>> np.random.randint(5, 10)
9

离散泊松分布：

>>> np.random.poisson(6.0)  # 拉姆大 ＝ 6.0
5

高斯分布：

>>> np.random.normal(1.5, 4.0)
0.83636555041094318

正态分布：

>>> np.random.normal()
0.27548716940682932

指定个数：

>>> np.random.normal(size=5)
array([-1.67215088,  0.65813053, -0.70150614,  0.91452499,  0.71440557])

随机洗牌；随机排列一个list：

>>> l = range(10)
>>> l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> np.random.shuffle(l)
>>> l
[4, 9, 5, 0, 2, 7, 6, 8, 1, 3]

其它

还有很多函数没有列出，像离散傅立叶变换，复杂的线性代数… 读官方文档获取更多信息 http://docs.scipy.org/doc。

SciPy 中的模块

导入：

>>> import scipy

列出帮助信息：

>>>help(scipy)
Help on package scipy:
 
NAME
    scipy
 
FILE
    /usr/local/lib/python2.7/site-packages/scipy/__init__.py
 
DESCRIPTION
    SciPy: A scientific computing package for Python
    ================================================
 
    Documentation is available in the docstrings and
    online at http://docs.scipy.org.
 
    Contents
    --------
    SciPy imports all the functions from the NumPy namespace, and in
    addition provides:
 
    Subpackages
    -----------
    Using any of these subpackages requires an explicit import.  For exa

SciPy 提供了很多数学算法，不在详细列出了，文档http://docs.scipy.org/doc
我们在下面列出了主要模块：

• scipy.constants：数学和物理常量
• scipy.special：数学物理
• scipy.integrate：积分
• scipy.optimize
• scipy.linalg
• scipy.sparse
• scipy.interpolate
• scipy.fftpack
• scipy.signal
• scipy.stats
  社区里的一大群开发者在不断的往SciPy中加入新功能。如果你要在代码里实现什么数学算法，最好是先看一下Scipy文档，看看有没有什么现成的玩意。