numpy是Python的一个科学计算的库，提供了矩阵运算的功能，其一般与Scipy、matplotlib一起使用。它可用来存储和处理大型矩阵，比Python自身的嵌套列表（nested list structure)结构要高效的多（该结构也可以用来表示矩阵（matrix））。
https://docs.scipy.org/doc/numpy/reference/
import numpy as np
print(np.version.version)
## 1.11.1import numpy as np
# 多维数组的类型是：numpy.ndarray
# 以list或tuple变量为参数产生一维数组：
print(np.array([1,2,3,4]))
print(np.array((1.2,2,3,4)))
print(type(np.array((1.2,2,3,4))))
# 以list或tuple变量为元素产生二维数组：
print(np.array([[1,2],[3,4]]))
## [1 2 3 4]
## [ 1.2 2. 3. 4. ]
## <class 'numpy.ndarray'>
## [[1 2]
## [3 4]]import numpy as np
# 例如numpy.int32, numpy.int16, and numpy.float64等：
print(np.array((1.2,2,3,4), dtype=np.int32))
# 使用numpy.arange方法
print(np.arange(15))
print(type(np.arange(15)))
print(np.arange(15).reshape(3,5))
print(type(np.arange(15).reshape(3,5)))
## [1 2 3 4]
## [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
## <class 'numpy.ndarray'>
## [[ 0 1 2 3 4]
## [ 5 6 7 8 9]
## [10 11 12 13 14]]
## <class 'numpy.ndarray'>import numpy as np
# 例如，在从1到3中产生9个数：
print(np.linspace(1,3,9))
## [ 1. 1.25 1.5 1.75 2. 2.25 2.5 2.75 3. ] ndarray对象的主要属性有：
ndarray.ndim 纬度或者轴的数量
ndarray.shape 数组的每个纬度的尺寸
ndarray.size 数组元素的总个数
ndarray.dtype 数组元素的类型
ndarray.itemsize 数组元素二进制的大小
ndarray.data 数组元素容器（不常用）import numpy as np
a = np.zeros((2,3,2))
print(a)
print(a.ndim) # 数组的维数
print(a.shape) # 数组每一维的大小
print(a.size) # 数组的元素数
print(a.dtype) # 元素类型
print(a.itemsize) # 每个元素所占的字节数
## [[[ 0. 0.]
## [ 0. 0.]
## [ 0. 0.]]
##
## [[ 0. 0.]
## [ 0. 0.]
## [ 0. 0.]]]
## 3
## (2, 3, 2)
## 12
## float64
## 8import numpy as np
a = np.array( [[2,3,4],[5,6,7]] )
print(a)
print(a[1,2]) # index从0开始
print(a[1,:])
print(a[1,1:2])
a[1,:] = [8,9,10] # 直接赋值
print(a)
## [[2 3 4]
## [5 6 7]]
## 7
## [5 6 7]
## [6]
## [[ 2 3 4]
## [ 8 9 10]]import numpy as np
for x in np.linspace(1,3,5):
print(x)
## 1.0
## 1.5
## 2.0
## 2.5
## 3.0import numpy as np
# 先构造数组a、b：
a = np.ones((2,2))
b = np.eye(2)
print(a)
print(b)
# 数组的加减乘除
print(a > 2)
print(a+b)
print(a-b)
print(b*2)
print((a*2)*(b*2))
print(b/(a*2))
print((b*2)**4)
# 使用数组对象自带的方法
print(a.sum()) # a的元素个数
print(a.sum(axis=0)) # 计算每一列（二维数组中类似于矩阵的列）的和
print(a.min())
print(a.max())
# 使用numpy下的方法
print(np.sin(a))
print(np.max(a))
print(np.floor(a))
print(np.exp(a))
print(np.dot(a,a)) # 矩阵乘法
print(np.dot(a,b))
## [[ 1. 1.]
## [ 1. 1.]]
## [[ 1. 0.]
## [ 0. 1.]]
## [[False False]
## [False False]]
## [[ 2. 1.]
## [ 1. 2.]]
## [[ 0. 1.]
## [ 1. 0.]]
## [[ 2. 0.]
## [ 0. 2.]]
## [[ 4. 0.]
## [ 0. 4.]]
## [[ 0.5 0. ]
## [ 0. 0.5]]
## [[ 16. 0.]
## [ 0. 16.]]
## 4.0
## [ 2. 2.]
## 1.0
## 1.0
## [[ 0.84147098 0.84147098]
## [ 0.84147098 0.84147098]]
## 1.0
## [[ 1. 1.]
## [ 1. 1.]]
## [[ 2.71828183 2.71828183]
## [ 2.71828183 2.71828183]]
## [[ 2. 2.]
## [ 2. 2.]]
## [[ 1. 1.]
## [ 1. 1.]]import numpy as np
# 使用numpy下的vstack和hstack函数：
a = np.ones((2,2))
b = np.eye(2)
print(a)
print(b)
print(np.vstack((a,b))) # 顾名思义 v--vertical 垂直
print(np.hstack((a,b))) # 顾名思义 h--horizonal 水平
# 看一下这两个函数有没有涉及到浅拷贝这种问题：
c = np.hstack((a,b))
print(c)
a[1,1] = 5
b[1,1] = 5
print(c)
# 可以看到，a、b中元素的改变并未影响c。
## [[ 1. 1.]
## [ 1. 1.]]
## [[ 1. 0.]
## [ 0. 1.]]
## [[ 1. 1.]
## [ 1. 1.]
## [ 1. 0.]
## [ 0. 1.]]
## [[ 1. 1. 1. 0.]
## [ 1. 1. 0. 1.]]
## [[ 1. 1. 1. 0.]
## [ 1. 1. 0. 1.]]
## [[ 1. 1. 1. 0.]
## [ 1. 1. 0. 1.]]import numpy as np
# 数组对象自带了浅拷贝和深拷贝的方法，但是一般用深拷贝多一些：
a = np.ones((2,2))
print(a)
b = a
print(b is a)
c = a.copy() # 深拷贝
print(c is a)
## [[ 1. 1.]
## [ 1. 1.]]
## True
## False矩阵对象numpy模块中的矩阵对象为numpy.matrix，包括矩阵数据的处理，矩阵的计算，以及基本的统计功能，转置，可逆性等等，包括对复数的处理，均在matrix对象中。
class numpy.matrix(data,dtype,copy):
返回一个矩阵，其中data为ndarray对象或者字符形式；
dtype:为data的type；
copy:为bool类型。import numpy as np
# 矩阵的换行必须是用分号(;)隔开，内部数据必须为字符串形式(‘ ’)，矩阵的元素之间必须以空格隔开。
a = np.matrix('1 2 7; 3 4 8; 5 6 9')
print(a)
b = np.array([[1,5],[3,2]])
print(b)
print(type(b))
x = np.matrix(b) # 矩阵中的data可以为数组对象。
print(x)
print(type(x))
## [[1 2 7]
## [3 4 8]
## [5 6 9]]
## [[1 5]
## [3 2]]
## <class 'numpy.ndarray'>
## [[1 5]
## [3 2]]
## <class 'numpy.matrixlib.defmatrix.matrix'>import numpy as np
# 转置：
a = np.array([[1,0],[2,3]])
print(a)
print(a.transpose())
# numpy.linalg关于矩阵运算的方法
import numpy.linalg as nplg
print(nplg.eig(a)) # 特征值、特征向量
## [[1 0]
## [2 3]]
## [[1 2]
## [0 3]]
## (array([ 3., 1.]), array([[ 0. , 0.70710678],
## [ 1. , -0.70710678]]))import numpy as np
# 使用numpy.zeros，numpy.ones，numpy.eye 可以构造特定的矩阵
print(np.zeros((3,4)))
print(np.ones((4,3)))
print(np.eye(4))
# 创建一个三维数组：
print(np.ones((3,3,3)))
## [[ 0. 0. 0. 0.]
## [ 0. 0. 0. 0.]
## [ 0. 0. 0. 0.]]
## [[ 1. 1. 1.]
## [ 1. 1. 1.]
## [ 1. 1. 1.]
## [ 1. 1. 1.]]
## [[ 1. 0. 0. 0.]
## [ 0. 1. 0. 0.]
## [ 0. 0. 1. 0.]
## [ 0. 0. 0. 1.]]
## [[[ 1. 1. 1.]
## [ 1. 1. 1.]
## [ 1. 1. 1.]]
##
## [[ 1. 1. 1.]
## [ 1. 1. 1.]
## [ 1. 1. 1.]]
##
## [[ 1. 1. 1.]
## [ 1. 1. 1.]
## [ 1. 1. 1.]]]
matrix.T # transpose：返回矩阵的转置矩阵
matrix.H # hermitian (conjugate) transpose：返回复数矩阵的共轭元素矩阵
matrix.I # inverse：返回矩阵的逆矩阵
matrix.A # base array：返回矩阵基于的数组
all([axis, out]) :沿给定的轴判断矩阵所有元素是否为真(非0即为真)
any([axis, out]) :沿给定轴的方向判断矩阵元素是否为真，只要一个元素为真则为真
argmax([axis, out]) :沿给定轴的方向返回最大元素的索引（最大元素的位置）
argmin([axis, out]): 沿给定轴的方向返回最小元素的索引（最小元素的位置）
argsort([axis, kind, order]) :返回排序后的索引矩阵
astype(dtype[, order, casting, subok, copy]):将该矩阵数据复制，且数据类型为指定的数据类型
byteswap(inplace) Swap the bytes of the array elements
choose(choices[, out, mode]) :根据给定的索引得到一个新的数据矩阵（索引从choices给定）
clip(a_min, a_max[, out]) :返回新的矩阵，比给定元素大的元素为a_max，小的为a_min
compress(condition[, axis, out]) :返回满足条件的矩阵
conj() :返回复数的共轭复数
conjugate() :返回所有复数的共轭复数元素
copy([order]) :复制一个矩阵并赋给另外一个对象，b=a.copy()
cumprod([axis, dtype, out]) :返回沿指定轴的元素累积矩阵
cumsum([axis, dtype, out]) :返回沿指定轴的元素累积和矩阵
diagonal([offset, axis1, axis2]) :返回矩阵中对角线的数据
dot(b[, out]) :两个矩阵的点乘
dump(file) :将矩阵存储为指定文件,可以通过pickle.loads()或者numpy.loads()如:a.dump(‘d:\a.txt’)
dumps() :将矩阵的数据转存为字符串
fill(value) :将矩阵中的所有元素填充为指定的value
flatten([order]) :将矩阵转化为一个一维的形式，但是还是matrix对象
getA() :返回自己，但是作为ndarray返回
getA1()：返回一个扁平（一维）的数组（ndarray）
getH() :返回自身的共轭复数转置矩阵
getI() :返回本身的逆矩阵
getT() :返回本身的转置矩阵
max([axis, out]) ：返回指定轴的最大值
mean([axis, dtype, out]) :沿给定轴方向，返回其均值
min([axis, out]) ：返回指定轴的最小值
nonzero() :返回非零元素的索引矩阵
prod([axis, dtype, out]) :返回指定轴方型上，矩阵元素的乘积
ptp([axis, out]) :返回指定轴方向的最大值减去最小值
put(indices, values[, mode]) :用给定的value替换矩阵本身给定索引（indices）位置的值
ravel([order]) :返回一个数组，该数组是一维数组或平数组
repeat(repeats[, axis]) :重复矩阵中的元素，可以沿指定轴方向重复矩阵元素，repeats为重复次数
reshape(shape[, order]) :改变矩阵的大小,如：reshape([2,3])
resize(new_shape[, refcheck]) :改变该数据的尺寸大小
round([decimals, out]) :返回指定精度后的矩阵，指定的位数采用四舍五入，若为1，则保留一位小数
searchsorted(v[, side, sorter]) :搜索V在矩阵中的索引位置
sort([axis, kind, order]) :对矩阵进行排序或者按轴的方向进行排序
squeeze([axis]) :移除长度为1的轴
std([axis, dtype, out, ddof]) :沿指定轴的方向，返回元素的标准差
sum([axis, dtype, out]) ：沿指定轴的方向，返回其元素的总和
swapaxes(axis1, axis2):交换两个轴方向上的数据
take(indices[, axis, out, mode]) :提取指定索引位置的数据,并以一维数组或者矩阵返回(主要取决axis)
tofile(fid[, sep, format]) :将矩阵中的数据以二进制写入到文件
tolist() :将矩阵转化为列表形式
tostring([order]):将矩阵转化为python的字符串
trace([offset, axis1, axis2, dtype, out]):返回对角线元素之和
transpose(*axes) :返回矩阵的转置矩阵，不改变原有矩阵
var([axis, dtype, out, ddof]) ：沿指定轴方向，返回矩阵元素的方差
view([dtype, type]) :生成一个相同数据，但是类型为指定新类型的矩阵
import numpy as np
# all方法
a = np.asmatrix('0 2 7; 3 4 8; 5 0 9')
print(a)
print(a.all())
print(a.all(axis=0))
print(a.all(axis=1))
# Astype方法
print(a.astype(float))
# Argsort方法
a = np.matrix('12 3 5; 32 23 9; 10 -14 78')
print(a.argsort())
# Clip方法
print(a.clip(12,32))
# Cumprod方法
print(a.cumprod(axis=1))
# Cumsum方法
print(a.cumsum(axis=1))
# Tolist方法
print(a.tolist())
# Tofile方法
a.tofile('D:\\a.txt')
# compress()方法
from numpy import *
a = array([10, 20, 30, 40])
print(a)
condition = (a > 15) & (a < 35)
print(condition)
print(a.compress(condition))
print(a[condition]) # same effect
print(compress(a >= 30, a)) # this form a
b = array([[10,20,30],[40,50,60]])
print(b)
print(b.compress(b.ravel() >= 22))
x = array([3,1,2])
y = array([50, 101])
print(x)
print(y)
print(b.compress(x >= 2, axis=1)) # illustrates
print(b.compress(y >= 100, axis=0))
## [[0 2 7]
## [3 4 8]
## [5 0 9]]
## False
## [[False False True]]
## [[False]
## [ True]
## [False]]
## [[ 0. 2. 7.]
## [ 3. 4. 8.]
## [ 5. 0. 9.]]
## [[1 2 0]
## [2 1 0]
## [1 0 2]]
## [[12 12 12]
## [32 23 12]
## [12 12 32]]
## [[ 12 36 180]
## [ 32 736 6624]
## [ 10 -140 -10920]]
## [[12 15 20]
## [32 55 64]
## [10 -4 74]]
## [[12, 3, 5], [32, 23, 9], [10, -14, 78]]
## [10 20 30 40]
## [False True True False]
## [20 30]
## [20 30]
## [30 40]
## [[10 20 30]
## [40 50 60]]
## [30 40 50 60]
## [3 1 2]
## [ 50 101]
## [[10 30]
## [40 60]]
## [[40 50 60]]http://blog.csdn.net/claroja/article/details/70256268
NumPy一元函数
对ndarray中的数据执行元素级运算的函数
np.abs(x) np.fabs(x) 计算数组各元素的绝对值
np.sqrt(x) 计算数组各元素的平方根
np.square(x) 计算数组各元素的平方
np.log(x) np.log10(x) np.log2(x) 计算数组各元素的自然对数、10底对数和2底对数
np.ceil(x) np.floor(x) 计算数组各元素的ceiling值 或 floor值
np.rint(x) 计算数组各元素的四舍五入值
np.modf(x) 将数组各元素的小数和整数部分以两个独立数组形式返回
np.cos(x) np.cosh(x) np.sin(x) np.sinh(x) np.tan(x) np.tanh(x) 计算数组各元素的普通型和双曲型三角函数
np.exp(x) 计算数组各元素的指数值
np.sign(x) 计算数组各元素的符号值，1(+), 0, ‐1(‐)NumPy二元函数
+ ‐ * / ** 两个数组各元素进行对应运算
np.maximum(x,y) np.fmax() np.minimum(x,y) np.fmin() 元素级的最大值/最小值计
np.mod(x,y) 元素级的模运算
np.copysign(x,y) 将数组y中各元素值的符号赋值给数组x对应元素
> < >= <= == != 算术比较，产生布尔型数组import numpy as np
a = np.array( [20,30,40,50] )
b = np.arange(4)
print(b)
c = a-b
print(c)
print(b**2)
print(10*np.sin(a))
print(a)
## [0 1 2 3]
## [20 29 38 47]
## [0 1 4 9]
## [ 9.12945251 -9.88031624 7.4511316 -2.62374854]
## [20 30 40 50]import numpy as np
A = np.array( [[1,1],[0,1]] )
B = np.array( [[2,0],[3,4]] )
print(A)
print(B)
print(A*B) # elementwise product
print(np.dot(A,B)) # matrix product
## [[1 1]
## [0 1]]
## [[2 0]
## [3 4]]
## [[2 0]
## [0 4]]
## [[5 4]
## [3 4]]import numpy as np
a = np.ones(3, dtype=np.int32)
b = np.linspace(0,np.pi,3)
print(a)
print(b)
print(b.dtype.name)
c = a+b
print(c)
print(c.dtype.name)
d = np.exp(c*1j)
print(d)
print(d.dtype.name)
## [1 1 1]
## [ 0. 1.57079633 3.14159265]
## float64
## [ 1. 2.57079633 4.14159265]
## float64
## [ 0.54030231+0.84147098j -0.84147098+0.54030231j -0.54030231-0.84147098j]
## complex128import numpy as np
a = np.random.random((2,3))
print(a)
print(a.sum())
print(a.min())
print(a.max())
## [[ 0.44284149 0.01464711 0.02141201]
## [ 0.68759757 0.44162542 0.40843286]]
## 2.01655646284
## 0.0146471079917
## 0.687597573925import numpy as np
b = np.arange(12).reshape(3,4)
print(b)
print(b.sum(axis=0)) # sum of each column
print(b.min(axis=1)) # min of each row
print(b.cumsum(axis=1)) # cumulative sum along each row
## [[ 0 1 2 3]
## [ 4 5 6 7]
## [ 8 9 10 11]]
## [12 15 18 21]
## [0 4 8]
## [[ 0 1 3 6]
## [ 4 9 15 22]
## [ 8 17 27 38]]np.savetxt(frame, array, fmt=’%.18e’, delimiter=None)
frame : 文件、字符串或产生器，可以是.gz或.bz2的压缩文件
array : 存入文件的数组
fmt : 写入文件的格式，例如:%d %.2f %.18e
delimiter : 分割字符串，默认是任何空格
np.loadtxt(frame, dtype=np.float, delimiter=None， unpack=False)
frame : 文件、字符串或产生器，可以是.gz或.bz2的压缩文件
dtype : 数据类型，可选
delimiter : 分割字符串，默认是任何空格
unpack : 如果True，读入属性将分别写入不同变量
CSV只能有效存储一维和二维数组
np.savetxt() np.loadtxt()只能有效存取一维和二维数组a.tofile(frame, sep=”, format=’%s’)
frame : 文件、字符串
sep : 数据分割字符串，如果是空串，写入文件为二进制
format : 写入数据的格式
a.tofile(frame, sep=',', format='%s') # 形成了一个文本文件
a.tofile(frame, format='%s') # 不指定sep，形成的一个二进制文件
np.fromfile(frame, dtype=float, count=‐1, sep="")
frame : 文件、字符串
dtype : 读取的数据类型
count : 读入元素个数，‐1表示读入整个文件
sep : 数据分割字符串，如果是空串，写入文件为二进制
维度信息会丢失，需要通过reshape来找回维度信息
该方法需要读取时知道存入文件时数组的维度和元素类型 a.tofile()和np.fromfile()需要配合使用 可以通过元数据文件来存储额外信息np.save(fname, array) 或 np.savez(fname, array)
• fname : 文件名，以.npy为扩展名，压缩扩展名为.npz
• array : 数组变量
np.load(fname)
• fname : 文件名，以.npy为扩展名，压缩扩展名为.npzhttps://docs.scipy.org/doc/numpy/reference/routines.random.html
http://blog.csdn.net/claroja/article/details/70229758
NumPy的random子库
np.random.*
np.random.rand()
np.random.randn()
np.random.randint()
rand(d0,d1,..,dn) 根据d0‐dn创建随机数数组，浮点数，[0,1)，均匀分布
randn(d0,d1,..,dn) 根据d0‐dn创建随机数数组，标准正态分布
randint(low[,high,shape] 据shape创建随机整数或整数数组，范围是[low, high)
seed(s) 随机数种子，s是给定的种子值
shuffle(a) 根据数组a的第1轴进行随排列，改变数组x
permutation(a) 根据数组a的第1轴产生一个新的乱序数组，不改变数组x
choice(a[,size,replace,p]) 从一维数组a中以概率p抽取元素，形成size形状新数组 replace表示是否可以重用元素，默认为Falseimport numpy as np
a = np.random.randint(100,200,(3,5))
print(a)
## [[119 182 104 129 110]
## [136 107 111 198 143]
## [190 198 172 155 139]]uniform(low,high,size) 产生具有均匀分布的数组,low起始值,high结束值,size形状
normal(loc,scale,size) 产生具有正态分布的数组,loc均值,scale标准差,size形状
poisson(lam,size) 产生具有泊松分布的数组,lam随机事件发生率,size形状
sum(a, axis=None) 根据给定轴axis计算数组a相关元素之和，axis整数或元组
mean(a, axis=None) 根据给定轴axis计算数组a相关元素的期望，axis整数或元组
average(a,axis=None,weights=None) 根据给定轴axis计算数组a相关元素的加权平均值
std(a, axis=None) 根据给定轴axis计算数组a相关元素的标准差
var(a, axis=None) 根据给定轴axis计算数组a相关元素的方差
min(a) max(a) 计算数组a中元素的最小值、最大值
argmin(a) argmax(a) 计算数组a中元素最小值、最大值的降一维后下标
unravel_index(index, shape) 根据shape将一维下标index转换成多维下标
ptp(a) 计算数组a中元素最大值与最小值的差
median(a) 计算数组a中元素的中位数(中值)import numpy as np