一、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 npd = 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.545454555.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.63665093.35981829    4.2813324     5.45559478    6.95192796    8.858667911.28837892   14.38449888   18.32980711   23.35721469   29.7635144237.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]])