numpy - juedaiyuer/researchNote GitHub Wiki

#Numpy笔记#

##安装##u

pip install --user numpy scipy matplotlib ipython jupyter pandas sympy nose

# Consider adding this at the end of your ~/.bashrc file
export PATH="$PATH:/home/your_user/.local/bin"

##函数库的导入##

测试环境

python2
Python 2.7.6 (default, Jun 22 2015, 17:58:13) 

import numpy as np

##创建##

多维数组对象ndarray

ndarray是一个通用的同构数据多维容器

array对象和list对象的区别是array对象的每一个元素都是数值，而list保存的是每个元素对象的指针

>>> a=np.array([1,2,3,4])
>>> b=np.array([5,6,7,8])
>>> c=np.array([1,2,3,4],[4,5,6,7],[7,8,9,10](/juedaiyuer/researchNote/wiki/1,2,3,4],[4,5,6,7],[7,8,9,10))

>>> b
array([5, 6, 7, 8])

>>> c
array([[ 1,  2,  3,  4],
	   [ 4,  5,  6,  7],
	   [ 7,  8,  9, 10]])

数组的大小可以通过其shape属性获得

>>> a.shape
(4,)

>>> c.shape
(3, 4)

修改数组的shape属性,只是改变每个轴的大小，数组元素在内存中的位置并没有改变

c.shape=4,3

某个轴元素为-1时，将根据数组元素的个数自动计算此轴的长度

>>> c.shape=2,-1
>>> c
array([[ 1,  2,  3,  4,  4,  5],
	   [ 6,  7,  7,  8,  9, 10]])

使用数组的reshape方法，可以创建一个改变了尺寸的新数组，原数组的shape保持不变

>>> d=a.reshape((2,2))
>>> d
array([[1, 2],
	   [3, 4]])
>>> a
array([1, 2, 3, 4])

数组a和d其实共享数据存储内存区域，修改其中任意一个数组的元素，另一个也会改变

array([1, 2, 3, 4])
>>> a[1]=100
>>> d
array([[  1, 100],
	   [  3,   4]])

数组的元素类型可以通过dtype属性获得，可以通过dtype参数在创建时指定元素类型

>>> np.array([1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10](/juedaiyuer/researchNote/wiki/1,-2,-3,-4],[4,-5,-6,-7],-[7,-8,-9,-10), dtype=np.float)
array([[  1.,   2.,   3.,   4.],
	   [  4.,   5.,   6.,   7.],
	   [  7.,   8.,   9.,  10.]])

>>> np.array([1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10](/juedaiyuer/researchNote/wiki/1,-2,-3,-4],[4,-5,-6,-7],-[7,-8,-9,-10), dtype=np.complex)
array([[  1.+0.j,   2.+0.j,   3.+0.j,   4.+0.j],
	   [  4.+0.j,   5.+0.j,   6.+0.j,   7.+0.j],
	   [  7.+0.j,   8.+0.j,   9.+0.j,  10.+0.j]])

上面的代码先创建一个Python序列，然后通过array函数将其转为数组

类似于python的range函数，通过指定开始值，终值和步长来创建一维数组

>>> np.arange(0,1,0.1)
array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9])

linspace函数通过指定开始值、终值和元素个数来创建一维数组

>>> np.linspace(0, 1, 12)
array([ 0.        ,  0.09090909,  0.18181818,  0.27272727,  0.36363636,
	    0.45454545,  0.54545455,  0.63636364,  0.72727273,  0.81818182,
	    0.90909091,  1.        ])

logspace函数和linspace类似，不过它创建等比数列，下面的例子产生1(10^0)到100(10^2)、有20个元素的等比数列:

>>> np.logspace(0, 2, 20)
array([   1.        ,    1.27427499,    1.62377674,    2.06913808,
	      2.6366509 ,    3.35981829,    4.2813324 ,    5.45559478,
	      6.95192796,    8.8586679 ,   11.28837892,   14.38449888,
	     18.32980711,   23.35721469,   29.76351442,   37.92690191,
	     48.32930239,   61.58482111,   78.47599704,  100.        ])

Python的字符串实际上是字节序列，每个字符占一个字节

s="abcdefgh"

创建一个8bit的整数数组，得到的数组正好就是字符串中每个字符的ASCII编码

>>> np.fromstring(s,dtype=np.int8)
array([ 97,  98,  99, 100, 101, 102, 103, 104], dtype=int8)

如果从字符串s创建16bit的整数数组，那么两个相邻的字节就表示一个整数，把字节98和字节97当作一个16位的整数，它的值就是98*256+97 = 25185。可以看出内存中是以little endian(低位字节在前)方式保存数据的。

>>> np.fromstring(s, dtype=np.int16)
array([25185, 25699, 26213, 26727], dtype=int16)

创建九九乘法表

>>> def func(i,j):
...     return (i+1)*(j+1) 
... 
>>> a=np.fromfunction(func,(9,9))
>>> a
array([[  1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.],
	   [  2.,   4.,   6.,   8.,  10.,  12.,  14.,  16.,  18.],
	   [  3.,   6.,   9.,  12.,  15.,  18.,  21.,  24.,  27.],
	   [  4.,   8.,  12.,  16.,  20.,  24.,  28.,  32.,  36.],
	   [  5.,  10.,  15.,  20.,  25.,  30.,  35.,  40.,  45.],
	   [  6.,  12.,  18.,  24.,  30.,  36.,  42.,  48.,  54.],
	   [  7.,  14.,  21.,  28.,  35.,  42.,  49.,  56.,  63.],
	   [  8.,  16.,  24.,  32.,  40.,  48.,  56.,  64.,  72.],
	   [  9.,  18.,  27.,  36.,  45.,  54.,  63.,  72.,  81.]])

zeors创建数组

>>> np.zeros(10)
array([ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.])

>>> np.zeros((3,6))
array([[ 0.,  0.,  0.,  0.,  0.,  0.],
	   [ 0.,  0.,  0.,  0.,  0.,  0.],
	   [ 0.,  0.,  0.,  0.,  0.,  0.]])

empty

• numpy.empty

产生随机数，创建新数组，只分配内存空间但不填充任何值

>>> np.empty((2,3))
array([[  0.00000000e+000,   6.88677313e-317,   4.71627160e-317],
	   [  6.93397412e-310,   0.00000000e+000,   0.00000000e+000]])

##数据类型##

dtype	

直接映射到相应的机器表示

双精度浮点型float,8字节，64位

显示转换其dtype---astype

>>> arr=np.array([1,2,3,4,5])
>>> arr.dtype
dtype('int64')
>>> float_arr=arr.astype(np.float)
>>> float_arr.dtype
dtype('float64')

##数组和标量之间的运算##

矢量化

大小相等的数组之间的任何算数运算都会将运算应用到元素级

>>> arr=np.array([1.,2.,3.],[4.,5.,6.](/juedaiyuer/researchNote/wiki/1.,2.,3.],[4.,5.,6.))
>>> arr
array([[ 1.,  2.,  3.],
	   [ 4.,  5.,  6.]])
>>> arr*arr
array([[  1.,   4.,   9.],
	   [ 16.,  25.,  36.]])

数组与标量的算数运算也会将标量值传播到各个元素

>>> 1/arr
array([[ 1.        ,  0.5       ,  0.33333333],
	   [ 0.25      ,  0.2       ,  0.16666667]])

不同大小的数组之间的运算叫做广播（broadcasting）

---

##存取元素##

>>> a=np.arange(10)
>>> a[5]  #下标获取
5

###元素索引###

>>> arr=np.array([1,2,3],[4,5,6],[7,8,9](/juedaiyuer/researchNote/wiki/1,2,3],[4,5,6],[7,8,9))
>>> arr[2]
array([7, 8, 9])

>>> arr[2,0]
7
>>> arr[2][0]
7

2×2×3数组arr3d

>>> arr3d=np.array([[1,2,3],[4,5,6](/juedaiyuer/researchNote/wiki/[1,2,3],[4,5,6),[7,8,9],[10,11,12](/juedaiyuer/researchNote/wiki/7,8,9],[10,11,12)])
>>> arr3d
array([[[ 1,  2,  3],
	    [ 4,  5,  6]],

	   [[ 7,  8,  9],
	    [10, 11, 12]]])



>>> arr3d[0]
array([[1, 2, 3],
	   [4, 5, 6]])

###切片索引###

>>> a[3:5] #范围值获取大于等于3,小于5
array([3, 4])

>>> a[:5]  #大于等于0
array([0, 1, 2, 3, 4])

>>> a[0:-1] #从数组后往前数
array([0, 1, 2, 3, 4, 5, 6, 7, 8])

将一个标量值赋值给一个切片，该值会自动传播到整个选区，数组切片是原始数组的视图

>>> a[2:4] = 100,101 #修改元素的值

>>> a[1:-1:2] #第三个参数表示步长
array([1, 3, 5, 7])


>>> a[::-1]  #整个数组头尾颠倒
array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])

>>> a[5:1:-1]  #小于等于5，大于1,倒序
array([5, 4, 3, 2])

只有冒号表示选取整个轴

和Python的列表序列不同，通过下标范围获取的新的数组是原始数组的一个视图，和原始数组共享一个内存

numpy设计的目的是处理大数据，将数据来回复制会产生何等的性能和内存问题，有别于复制数组数据的编程语言

如果想要得到ndarray切片的一份副本而非视图，需要显式进行复制操作，譬如arr[5:8].copy()

###布尔型索引###

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

x[True, False, True, False, False](/juedaiyuer/researchNote/wiki/True,-False,-True,-False,-False)

>>> x[np.array([True, False, True, True])] #布尔数组长度不够时，不够的为false
array([5, 3, 2])

x[np.array([True, False, True, True])] = -1, -2, -3  #也可以修改元素

---

使用numpy.random中的randn函数生成一些正态分布的随机数据

>>> names=np.array(['Bob','Joe','Will','Bob','Will','Joe','Joe'])
>>> data=np.random.randn(7,4)

>>> data
array([[-0.250048  , -0.28507158, -0.25506627,  0.18477549],
	   [-1.17996297,  0.86378588,  0.46174617, -1.65468662],
	   [-0.30221236, -1.63544174, -1.10506714,  0.27811492],
	   [-0.40620604,  0.16589463,  0.54679321,  0.34688236],
	   [-0.56446064,  1.04651302,  0.39318676,  0.29658822],
	   [-1.5066857 , -1.45537444, -0.03899201,  1.47056355],
	   [-1.62024981, -0.26599508,  0.41306453,  0.29326252]])

数组的比较运算（eg:==）也是矢量化

>>> names=='Bob'
array([ True, False, False,  True, False, False, False], dtype=bool)

产生的布尔数组可用于数组索引，布尔型数组的长度必须跟被索引的轴的长度一致

>>> data[names=='Bob']
array([[-0.250048  , -0.28507158, -0.25506627,  0.18477549],
	   [-0.40620604,  0.16589463,  0.54679321,  0.34688236]])

来一个切片

>>> data[names=='Bob',2:]
array([[-0.25506627,  0.18477549],
	   [ 0.54679321,  0.34688236]])

要选择除'Bob'以外的其他值

>>> names != 'Bob'
array([False,  True,  True, False,  True,  True,  True], dtype=bool)

>>> data[-(names == 'Bob')]
array([[-1.17996297,  0.86378588,  0.46174617, -1.65468662],
	   [-0.30221236, -1.63544174, -1.10506714,  0.27811492],
	   [-0.56446064,  1.04651302,  0.39318676,  0.29658822],
	   [-1.5066857 , -1.45537444, -0.03899201,  1.47056355],
	   [-1.62024981, -0.26599508,  0.41306453,  0.29326252]])

data中的所有负值都设置为0

>>> data[data<0]=0
>>> data
array([[ 0.        ,  0.        ,  0.        ,  0.18477549],
	   [ 0.        ,  0.86378588,  0.46174617,  0.        ],
	   [ 0.        ,  0.        ,  0.        ,  0.27811492],
	   [ 0.        ,  0.16589463,  0.54679321,  0.34688236],
	   [ 0.        ,  1.04651302,  0.39318676,  0.29658822],
	   [ 0.        ,  0.        ,  0.        ,  1.47056355],
	   [ 0.        ,  0.        ,  0.41306453,  0.29326252]])

通过一维布尔数组设置整行或列的值

>>> data[names!='Joe']=7
>>> data
array([[ 7.        ,  7.        ,  7.        ,  7.        ],
	   [ 0.        ,  0.86378588,  0.46174617,  0.        ],
	   [ 7.        ,  7.        ,  7.        ,  7.        ],
	   [ 7.        ,  7.        ,  7.        ,  7.        ],
	   [ 7.        ,  7.        ,  7.        ,  7.        ],
	   [ 0.        ,  0.        ,  0.        ,  1.47056355],
	   [ 0.        ,  0.        ,  0.41306453,  0.29326252]])

###花式索引###

Fancy indexing，利用整数数组进行索引

花式索引跟切片不一样，总是将数据复制到新数组中

一个8×4数组

>>> arr=np.empty((8,4))
>>> for i in range(8):
...     arr[i]=i
... 
>>> arr
array([[ 0.,  0.,  0.,  0.],
	   [ 1.,  1.,  1.,  1.],
	   [ 2.,  2.,  2.,  2.],
	   [ 3.,  3.,  3.,  3.],
	   [ 4.,  4.,  4.,  4.],
	   [ 5.,  5.,  5.,  5.],
	   [ 6.,  6.,  6.,  6.],
	   [ 7.,  7.,  7.,  7.]])

特定顺序选取行子集，只需要传入一个用于指定顺序的整数列表或ndarray

>>> arr[4,3,0,6](/juedaiyuer/researchNote/wiki/4,3,0,6)
array([[ 4.,  4.,  4.,  4.],
	   [ 3.,  3.,  3.,  3.],
	   [ 0.,  0.,  0.,  0.],
	   [ 6.,  6.,  6.,  6.]])

使用负数索引将会从末尾开始选取行

>>> arr[-3,-5,-7](/juedaiyuer/researchNote/wiki/-3,-5,-7)
array([[ 5.,  5.,  5.,  5.],
	   [ 3.,  3.,  3.,  3.],
	   [ 1.,  1.,  1.,  1.]])


>>> arr=np.arange(32).reshape((8,4))
>>> arr
array([[ 0,  1,  2,  3],
	   [ 4,  5,  6,  7],
	   [ 8,  9, 10, 11],
	   [12, 13, 14, 15],
	   [16, 17, 18, 19],
	   [20, 21, 22, 23],
	   [24, 25, 26, 27],
	   [28, 29, 30, 31]])

选取的元素(1,0),(5,3),(7,1),(2,1)

>>> arr[1,5,7,2],[0,3,1,2](/juedaiyuer/researchNote/wiki/1,5,7,2],[0,3,1,2)
array([ 4, 23, 29, 10])

选取矩阵的行列子集

>>> arr[1,5,7,2](/juedaiyuer/researchNote/wiki/1,5,7,2)[:,[0,3,1,2]]
array([[ 4,  7,  5,  6],
	   [20, 23, 21, 22],
	   [28, 31, 29, 30],
	   [ 8, 11,  9, 10]])

###数组转置和轴对换###

转置（transpose）是重塑的一种特殊形式，它返回的是源数据的视图

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

特殊的T属性

>>> arr.T
array([[ 0,  5, 10],
	   [ 1,  6, 11],
	   [ 2,  7, 12],
	   [ 3,  8, 13],
	   [ 4,  9, 14]])

进行矩阵计算时，经常用到T属性，eg 利用np.dot计算矩阵內积X（T）X：

>>> arr=np.random.randn(6,3)
>>> np.dot(arr.T,arr)
array([[  6.38361766,   3.40984293,   5.85232163],
	   [  3.40984293,  10.77503226,   5.68131674],
	   [  5.85232163,   5.68131674,   7.19957062]])



>>> arr=np.arange(16).reshape((2,2,4))
>>> arr
array([[[ 0,  1,  2,  3],
	    [ 4,  5,  6,  7]],

	   [[ 8,  9, 10, 11],
	    [12, 13, 14, 15]]])

>>> arr.transpose((1,0,2))
array([[[ 0,  1,  2,  3],
	    [ 8,  9, 10, 11]],

	   [[ 4,  5,  6,  7],
	    [12, 13, 14, 15]]])

swapaxes方法

>>> arr.swapaxes(1,2)
array([[[ 0,  4],
	    [ 1,  5],
	    [ 2,  6],
	    [ 3,  7]],

	   [[ 8, 12],
	    [ 9, 13],
	    [10, 14],
	    [11, 15]]])

###使用整数序列###

不和原始数组共享数据空间

##结构数组##

只要Numpy结构定义和C语言中的定义相同，Numpy可以很方便读取C语言的结构数组的二进制数据

>>> import numpy as np
>>> persontype = np.dtype({
...     'names':['name', 'age', 'weight'],
...     'formats':['S32','i', 'f']})
>>> a = np.array([("Zhang",32,75.5),("Wang",24,65.2)],
...     dtype=persontype)

S32：32个字节的字符串类型
i:32bit的整数类型
f:32bit的单精度浮点数类型

>>> a.dtype
dtype([('name', 'S32'), ('age', '<i4'), ('weight', '<f4')])

|:忽视字节顺序
<:低位字节在前,小端模式（little endian）

:高位字节在前,大端模式（big endian）

可以获得结构元素的某个字段

##通用函数##

ufunc是一种对ndarray中的数据执行元素级运算的函数

##利用数组进行数据处理##

用数组表达式代替循环的做法，通常被称为矢量化

生成1000个间隔相等的点

>>> points=np.arange(-5,5,0.01)

numpy的meshgrid函数接受两个一维数组，并产生两个二维矩阵

>>> xs,ys=np.meshgrid(points,points)
>>> ys
array([[-5.  , -5.  , -5.  , ..., -5.  , -5.  , -5.  ],
	   [-4.99, -4.99, -4.99, ..., -4.99, -4.99, -4.99],
	   [-4.98, -4.98, -4.98, ..., -4.98, -4.98, -4.98],
	   ..., 
	   [ 4.97,  4.97,  4.97, ...,  4.97,  4.97,  4.97],
	   [ 4.98,  4.98,  4.98, ...,  4.98,  4.98,  4.98],
	   [ 4.99,  4.99,  4.99, ...,  4.99,  4.99,  4.99]])

>>> import matplotlib.pyplot as plt
z=np.sqrt(xs**2+ys**2)
>>> z
array([[ 7.07106781,  7.06400028,  7.05693985, ...,  7.04988652,
	     7.05693985,  7.06400028],
	   [ 7.06400028,  7.05692568,  7.04985815, ...,  7.04279774,
	     7.04985815,  7.05692568],
	   [ 7.05693985,  7.04985815,  7.04278354, ...,  7.03571603,
	     7.04278354,  7.04985815],
	   ..., 
	   [ 7.04988652,  7.04279774,  7.03571603, ...,  7.0286414 ,
	     7.03571603,  7.04279774],
	   [ 7.05693985,  7.04985815,  7.04278354, ...,  7.03571603,
	     7.04278354,  7.04985815],
	   [ 7.06400028,  7.05692568,  7.04985815, ...,  7.04279774,
	     7.04985815,  7.05692568]])

>>> plt.imshow(z,cmap=plt.cm.gray);plt.colorbar()
<matplotlib.image.AxesImage object at 0x7f020fe4db90>
<matplotlib.colorbar.Colorbar object at 0x7f02256e3290>
>>> plt.title("Image plot of $\sqrt{x^2+y^2}$ for a grid of values")
<matplotlib.text.Text object at 0x7f02106c2b50>
>>> plt.show()

##将条件逻辑表述为数组运算##

numpy.where函数是三元表达式x if condition else y的矢量化版本

>>> xarr=np.array([1.1,1.2,1.3,1.4,1.5])
>>> yarr=np.array([2.1,2.2,2.3,2.4,2.5])
>>> cond=np.array([True,False,True,True,False])

根据cond中的值选取xarr和yarr的值，当cond为True时，选取xarr

列表推导式

>>> result=[(x if c else y)
...             for x,y,c in zip(xarr,yarr,cond)]
>>> result
[1.1000000000000001, 2.2000000000000002, 1.3, 1.3999999999999999, 2.5]

where函数使用

>>> arr=np.random.randn(4,4)
>>> arr
array([[ 0.00486603,  1.66132452,  0.18232715, -1.69183891],
	   [ 0.59045706, -0.3944992 ,  0.16711775, -0.47099951],
	   [ 0.04322926, -0.16509069, -0.69383947, -1.16265788],
	   [ 0.86016141,  0.05041013, -0.27975309,  0.12194332]])

矩阵所有正值替换为2,所有负值替换为-2

>>> np.where(arr>0,2,-2)
array([[ 2,  2,  2, -2],
	   [ 2, -2,  2, -2],
	   [ 2, -2, -2, -2],
	   [ 2,  2, -2,  2]])

>>> np.where(arr>0,2,arr)
array([[ 2.        ,  2.        ,  2.        , -1.69183891],
	   [ 2.        , -0.3944992 ,  2.        , -0.47099951],
	   [ 2.        , -0.16509069, -0.69383947, -1.16265788],
	   [ 2.        ,  2.        , -0.27975309,  2.        ]]

##数学和统计方法##

正态分布的数据，mean()平均值

>>> arr=np.random.randn(5,4)
>>> arr.mean()
-0.13462009157835167
>>> np.mean(arr)
-0.13462009157835167

mean和sum这个类的函数可以接受一个axis参数（用于计算该轴向上的统计值）

>>> arr.mean(axis=0)
array([-0.71942157, -0.36381123, -0.03802267,  0.5827751 ])

>>> arr.mean(axis=1)
array([-0.72792002, -0.79365135,  0.37792264,  0.64645212, -0.17590385])

计算元素的累计和cumsum

计算元素的累积积cumprod

sum经常被用来对布尔型数组中的True值计数

>>> arr=np.random.randn(100)
>>> (arr>0).sum()
50

any用于测试数组中是否存在一个或多个True

>>> arr.any()
True

all用于检查数组中所有值是否都是true

>>> bools=np.array([False,False,True,False])
>>> bools.all()
False

##排序##

>>> arr=np.random.randn(8)
>>> arr
array([ 1.02545756,  0.52328906, -0.76584025,  1.37353233,  1.97849979,
	   -1.04545556, -1.90650061, -0.89095452])
>>> arr.sort()
>>> arr
array([-1.90650061, -1.04545556, -0.89095452, -0.76584025,  0.52328906,
	    1.02545756,  1.37353233,  1.97849979])

多维数组可以在任何一个轴向上进行排序

>>> arr=np.random.randn(5,3)
>>> arr
array([[-0.56723114,  1.20484676,  1.16453382],
	   [-0.36093615,  0.99630792,  0.69674944],
	   [ 1.71958096, -0.28763317,  0.24006018],
	   [ 0.05070861, -1.29895495, -0.11205838],
	   [ 0.95847181,  0.62203932, -1.3358333 ]])

##唯一化以及其它的集合逻辑##

集合运算

np.unique，用于找出数组中的唯一值并返回已排序的结果

>>> names=np.array(['Bob','Joe','Will','Bob','Will','Joe','Joe'])
>>> np.unique(names)
array(['Bob', 'Joe', 'Will'], dtype='|S4')

np.in1d用于测试一个数组中的值在另一个数组中的成员资格，返回一个布尔型数组

>>> values=np.array([6,0,0,3,2,5,6])
>>> np.in1d(values,[2,3,6])
array([ True, False, False,  True,  True, False,  True], dtype=bool)

##将数组以二进制格式保存到磁盘##

>>> arr=np.arange(10)
>>> np.save('some_array',arr)
>>> np.load('some_array.npy')
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

np.savez可以将多个数组保存到一个压缩文件中，将数组以关键字参数的形式传入

>>> np.savez('array_archive.npz',a=arr,b=arr)

加载.npz文件时，会得到一个类似字典的对象，该对象会对各个数组进行延迟加载

>>> arch=np.load('array_archive.npz')
>>> arch['b']
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

##存取文本文件##

read_csv和read_table函数

np.loadtxt

np.genfromtxt

##线性代数##

Numpy提供了一个用于矩阵乘法的dot函数

>>> x=np.array([1.,2.,3.],[4.,5.,6.](/juedaiyuer/researchNote/wiki/1.,2.,3.],[4.,5.,6.))
>>> y=np.array([6.,23.],[-1,7],[8,9](/juedaiyuer/researchNote/wiki/6.,23.],[-1,7],[8,9))
>>> x
array([[ 1.,  2.,  3.],
	   [ 4.,  5.,  6.]])
>>> y
array([[  6.,  23.],
	   [ -1.,   7.],
	   [  8.,   9.]])

>>> x.dot(y)
array([[  28.,   64.],
	   [  67.,  181.]])

numpy.linalg中有一组标准的矩阵分解运算以及诸如求逆和行列式之类

同MATLAB和R等语言采用了相同的行业标准级Fortran库

##随机数生成##

一个标准正态分布的4×4样本数组

>>> samples=np.random.normal(size=(4,4))
>>> samples
array([[ 1.3587151 ,  1.1680372 ,  0.65330041, -0.59902827],
	   [ 0.25605825, -0.01815138, -0.0765063 ,  0.51642219],
	   [ 1.11683054, -0.74787998, -0.42660796, -1.08413442],
	   [ 0.95130408,  0.4035738 , -1.13045481,  0.6329906 ]])

##矩阵运算##

##范例：随机漫步##

##source##

• NumPy-快速处理数据
• SciPy.org
• Numpy User Guide Quickestart tutorial
• ndarray对象
• 利用Python进行数据分析：第四章
• NumPy v1.11 Manual