标签：lin   需要   ret   逗号   缺省   --   字符串   保存   csdn   

一、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]])

[python]-数据科学库Numpy学习

标签：lin   需要   ret   逗号   缺省   --   字符串   保存   csdn   

原文地址：http://www.cnblogs.com/NextNight/p/6929937.html