首页 > 代码库 > [python]-数据科学库Numpy学习

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

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

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