一、Numpy简介：
Python中用列表(list)保存一组值，可以用来当作数组使用，不过由于列表的元素可以是任何对象，因此列表中所保存的是对象的指针。这样为了保存一个简单的[1,2,3]，需要有3个指针和三个整数对象。对于数值运算来说这种结构显然比较浪费内存和CPU计算时间。此外Python还提供了一个array模块，array对象和列表不同，它直接保存数值，和C语言的一维数组比较类似。但是由于它不支持多维，也没有各种运算函数，因此也不适合做数值运算。
NumPy提供了两种基本的对象：ndarray（N-dimensional array object）和 ufunc（universal function object）。ndarray(下文统一称之为数组)是存储单一数据类型的多维数组，而ufunc则是能够对数组进行处理的函数。
二、nadrray对象：
1、创建一个数组对象:
- 函数生成：ones(),zeros(),eye(),diag()......
- zeros:（4）,zeros(（5,2）)生成全0的数组
>>> import numpy as np
>>> np.zeros(5) //一维
array([ 0., 0., 0., 0., 0.])
>>> np.zeros((5,2))//二维
array([[ 0., 0.],
[ 0., 0.],
[ 0., 0.],
[ 0., 0.],
[ 0., 0.]])>>> np.zeros((5,2,2))//三维
array([[[ 0., 0.],
[ 0., 0.]],[[ 0., 0.],
[ 0., 0.]],[[ 0., 0.],
[ 0., 0.]],[[ 0., 0.],
[ 0., 0.]],[[ 0., 0.],
[ 0., 0.]]])- ones():生成全1的数组
>>> import numpy as np
>>> np.ones(10) //一维
array([ 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])
>>> np.ones(10,dtype="int32")//一维
array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1])>>> np.ones((4,1)) //二维
array([[ 1.],
[ 1.],
[ 1.],
[ 1.]])- arange函数：类似于list的range函数，通过指定初始值，终值，和步长来生成一维数组。（不包括终值）
import numpy as np
d = np.arange(0,10,1)
e = np.arange(0,10,2)
print (d)
#----------------------------------
[0 1 2 3 4 5 6 7 8 9]
[0 2 4 6 8]- linspace函数：通过指定初始值，终值和 元素个数来创建一维数组。（默认包含终值，可用endpoint关键字指定包含终值）
f = np.linspace(0,10,11,endpoint=False)
print (f)
#----------------------------------------
[ 0. 0.90909091 1.81818182 2.72727273 3.63636364 4.54545455
5.45454545 6.36363636 7.27272727 8.18181818 9.09090909]- logspace函数：类似linspace创建等比数列,下面的例子产生1(10^0)到100(10^2)、有20个元素的等比数列:
g = np.logspace(0,2,20)
print (g)
[ 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. ]- frombuffer,fromstring,fromfile等函数可以从字节序列创建数组。python自负产是字符序列，每个字符占一个字节，因此如果从字符串s创建一个8bit的整数数组的话得到的每个元书就是字符的ascii码值。
s= "abcdefgh"
sa = np.fromstring(s,dtype = np.int8)
print (sa)
#--------------------------------------
[ 97 98 99 100 101 102 103 104]- fromfuction函数：传入一个函数来创建数组
def fun(i,j):
return (i+1)*(j+1)
fa = np.fromfunction(fun,(9,9)) #(9,9)表示数组的shape，传给fun的书是每个元素的定位，有81个位置，可以得到81个元素
print (fa)
#---------------------------------------------------
[[ 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.]]
- 序列传入：
import numpy as np
a = np.array([1,2,3,4,5])
b = np.array([[1,2,3,4],[4,5,6,7],[7,8,9,10]])
print (a)
print (b)
#-------------------------------------------
[1 2 3 4 5]
[[ 1 2 3 4]
[ 4 5 6 7]
[ 7 8 9 10]]
2、数组的属性：
- ndim属性：数组的维数
>>> np.ones((3,2))
array([[ 1., 1.],
[ 1., 1.],
[ 1., 1.]])
>>> np.ones((3,2)).ndim
2 #二维- size：数组元素的总个数，等于shape属性中元组元素的乘积。
>>> np.ones((3,2)).size
6 #6个元素- dtype属性：查看或指定数组类型
print(a.dtype) # 数组的元素类型 int32，32bit整型数据
print(b.dtype) # 数组的元素类型 int32
aa = np.array([2,3,4,5,6],dtype = np.float)
print (aa)
#----------------------------------------------
[ 2. 3. 4. 5. 6.]- shape属性：查看或改变数组的大小
print(a.shape) #数组的大小 （5）
print(b.shape) #数组的大小 shape （3，4） #修改shape来修改数组轴的大小：
b.shape = (4,3)
print (b)
#--------------------------------------
[[ 1 2 3]
[ 4 4 5]
[ 6 7 7]
[ 8 9 10]]
#如果某个轴的值为-1，则会根据数组的总数计算此轴的长度。如b一共12个元素，修改shape
b.shape = (2,-1) #那么就会得到一个2*6的数组
print (b)
#--------------------------------------
[[ 1 2 3 4 4 5]
[ 6 7 7 8 9 10]]
b.shape = (6,-1) #那么就会得到一个6*2的数组
print (b)
#--------------------------------------
[[ 1 2]
[ 3 4]
[ 4 5]
[ 6 7]
[ 7 8]
[ 9 10]]
- reshape属性：修改一个数组的尺寸得到一个新数组，原数组不变，但是这两个数组共享内存，如果修改值的话这两个数组都会变。
c = a.reshape((5,1)) #此方法实验证明:只能是x*y=数组的总元素才可以，这里1*5只能换成5*1
print (c) #此时a的结构并没改变,a,c共享内存。
print (a)
#--------------------------------------
[[1]
[2]
[3]
[4]
[5]]
[1 2 3 4 5]
#修改a[1][2]的值
a[2] = 100
print (c) #此时a的结构并没改变,a,c共享内存。
print (a)
#--------------------------------------
[1 2 3 4 5]
[[ 1]
[ 2]
[100]
[ 4]
[ 5]]
[ 1 2 100 4 5]
3、数组存取：
- 切片法[[[----***逗号“，”分行，列。冒号“：”分范围***---]]]
>>> import numpy as np
>>> np.array([[1,2,3,4],[4,5,6,7],[7,8,9,10]])
array([[ 1, 2, 3, 4],
[ 4, 5, 6, 7],
[ 7, 8, 9, 10]])
>>> b = np.array([[1,2,3,4],[4,5,6,7],[7,8,9,10]])
>>> b[0]
array([1, 2, 3, 4])
>>> b[1]
array([4, 5, 6, 7])
>>> b[1,2]
6
>>> b[1,3]
7
>>> b[1,-1]
7
>>> b[-1]
array([ 7, 8, 9, 10])
>>> b[-1,2]
9
>>> b[-1,-2]
9
>>> b[:-2] #0--负2列
array([[1, 2, 3, 4]])
>>> b[1:2]
array([[4, 5, 6, 7]])
>>> b[1:3]
array([[ 4, 5, 6, 7],
[ 7, 8, 9, 10]])
#*************矩阵的截取***********************>>> a=np.mat(np.random.randint(2,15,size=(3,3)))
>>> a
matrix([[ 4, 10, 14],
[11, 3, 12],
[ 4, 2, 12]])
>>> a[1:,1:,]
matrix([[ 3, 12],
[ 2, 12]])
三、矩阵对象matrix：
numpy库提供了matrix类，使用matrix类创建的是矩阵对象，它们的加减乘除运算缺省采用矩阵方式计算。但是由于NumPy中同时存在ndarray和matrix对象，因此很容易将两者弄混。
- 创建矩阵：matrix函数（也可以用简写mat） a = np.matrix([[1,2,3],[5,5,6],[7,9,9]])
#利用ones()创建一个2*4的全1矩阵
>>> np.mat(np.ones((2,4)))
matrix([[ 1., 1., 1., 1.],
[ 1., 1., 1., 1.]])-
#用numpy的随机数rand产生一个2*2的随机数组并转化成矩阵
>>> np.mat(np.random.rand(2,2))
matrix([[ 0.4340437 , 0.98055453],
[ 0.52937992, 0.81452857]])#产生一个2-8之间的整数数组大小是2*5，再转换成矩阵。
>>> np.mat(np.random.randint(2,8,size=(2,5)))
matrix([[3, 6, 4, 4, 5],
[3, 7, 7, 2, 3]])#eye()函数产生单位对角数组，转换成单位对角阵
>>> np.mat(np.eye(2,2,dtype=int))
matrix([[1, 0],
[0, 1]])
>>> np.mat(np.eye(3,2,dtype=int))
matrix([[1, 0],
[0, 1],
[0, 0]])
>>> np.mat(np.eye(3,3,dtype=int))
matrix([[1, 0, 0],
[0, 1, 0],
[0, 0, 1]])#将一维数组转换成对角阵
>>> np.mat(np.diag([1,2,3]))
matrix([[1, 0, 0],
[0, 2, 0],
[0, 0, 3]])
>>> - 矩阵运算：乘积，求逆，幂运算，转置
>>> import numpy as np
>>> a = np.matrix([[1,2,3],[5,5,6],[7,9,9]])
>>> a
matrix([[1, 2, 3],
[5, 5, 6],
[7, 9, 9]])
>>> a**-1 #求逆 a.I也是a的逆
matrix([[-0.6 , 0.6 , -0.2 ],
[-0.2 , -0.8 , 0.6 ],
[ 0.66666667, 0.33333333, -0.33333333]])
>>> a*a**-1 #a乘a的逆，矩阵内积
matrix([[ 1.00000000e+00, 1.66533454e-16, -1.11022302e-16],
[ 0.00000000e+00, 1.00000000e+00, -4.44089210e-16],
[ 4.44089210e-16, 5.55111512e-17, 1.00000000e+00]])
>>> a.T #a的转置
matrix([[1, 5, 7],
[2, 5, 9],
[3, 6, 9]])
>>>
- 矩阵函数：
- dot():做矩阵乘法，一维数组做点积，二维数组做内积，不过乘积必须满足矩阵相乘的形式（M(x,y)*M2(y,z)）,两个矩阵的行列必须对应，都是一维的话必须是一个行向量，一个列向量，可以用m.reshape(-1,1)将行向量转为列向量，或者m.reshape(1,-1)将列向量转为行向量。
- inner():
- outer():
- 矩阵中更高级的一些运算可以在NumPy的线性代数子库linalg中找到。例如inv函数计算逆矩阵，solve函数可以求解多元一次方程组。
>>> from numpy import linalg as ll
>>> ll.inv(a) #求逆
matrix([[-0.6 , 0.6 , -0.2 ],
[-0.2 , -0.8 , 0.6 ],
[ 0.66666667, 0.33333333, -0.33333333]])
>>> a
matrix([[1, 2, 3],
[5, 5, 6],
[7, 9, 9]])
参考：http://blog.csdn.net/sunny2038/article/details/9002531
参考：http://old.sebug.net/paper/books/scipydoc/numpy_intro.html#id8