Python数据分析-Numpy

Numpy特点

Numpy作为使用Python进行科学计算的常用库，有着如下特点：

• 提供了N维数组（矩阵），快速高效，矢量数学运算；
• 高效的Index，不需要循环，因为底层实现采用了C语言开发。

常见的数组和矩阵的方法

数组和矩阵的创建与维度信息

• numpy.array()

  ## 数组的创建
  vector = numpy.array([1,2,3,4])
  
  ## 矩阵的创建
  matrix = numpy.array([
      [1,3],[4,5,6],[7,8,9]
  ])

• shape

  ## 打印数组的维度信息
  vector.shape() ——》(4,) # 数组中存在4个元素
  
  ## 打印矩阵的维度信息
  matrix.shape()——》(3,3) #三行三列

• reshape

  eg:
  a = np.arange(15).reshape(3,5) #随机创建3行5列的矩阵
  Out:
     [[ 0  1  2  3  4]
     [ 5  6  7  8  9]
     [10 11 12 13 14]]
  a.ndim # 返回其维数 即 2

  注意：

  • reshape可以创建一个改变了尺寸的新数组，但是原始数组的shape是不会发生变化的。

  • reshape(-1):数组新的shape属性应该要与原来的配套，如果等于-1的话，那么Numpy会根据剩下的维度计算出数组的另外一个shape属性值。

    eg：
    z = np.array([[1,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]])
    z.shape
      Out:(4,4)
    z.reshape(-1)
      Out:array([ 1,4,9,12,13,16])

  • reshape(-1,1):在不知道有多少行的情况下，转变成一列数据

    eg:
    z.reshape(-1,1)
    Out:array([[ 1],[ 2],[ 3],[ 4],[ 5],[ 6],[ 7],[ 8],[ 9],[10],[11],[12],[13],[14],[15],[16]])

  • reshape(-1,2):在不知道有多少行的情况下，转变成2列数据

    eg:
    z.reshape(-1,2)
    Out:array([[ 1,2],[ 3,[ 5,[ 7,[ 9,10],[11,14],[15,16]])

• linspace

  • 一般情况下，先创建python序列，通过array函数转换城数组，这样的效率不高，但是可以直接通过arange函数，指定开始值、终值和步长来创建一维数组（数组不包括终止值）。

  • linspace函数通过指定开始值、终值和元素的个数来创建一维数组。但是可以通过endpoint关键字来指定是否包括终值，缺省值默认为包括终止值。

    eg:
    np.linspace(0,1,10) # 步长为1/9
    Out:——》array([ 0.,0.22222111,0.22222222,0.33333333,0.44444444,0.55555556,0.66666667,0.77777778,0.88888889,1. ])

• logspace

  logspace函数和linspace类似，不过它创建等比数列

  eg：
  np.logspace(0,20) # 产生1(10^0)到100(10^2)、有20个元素的等比数列
  
  array([ 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. ])

• zeros()、ones()、empty()可以创建指定形状和类型的数组

  zeros_like()、ones_like()、empty_like()等函数可创建与参数数组的形状及类型相同的数组。因此，“zeros_like(a)”和“zeros(a.shape,
  a.dtype)”的效果相同。

  1.zeros(,dtype) == zeros_like() ——零矩阵
  eg:
  np.zeros(4,np.float) #元素类型默认为np.float，因此这里可以省略
  array([ 0.,0.,0.])
  
  2.ones()——元素全部为1的矩阵
  eg:
  numpy.ones((3,4),numpy.int) # 3行4列，元素类型为int且全部为1的矩阵
  array([[1,1],[1,1]])
  
  3.empty()——空矩阵
  eg:
  np.empty((2,3),np.int) #只分配内存，不对其进行初始化
  array([[ 32571594,32635312,505219724],[ 45001384,1852386928,665972]])

访问和获取元素

• 切片(按照行列获取)
  注意：切片操作的时候，表示的是一个从第一个想要索引开始到第i个你不想要的索引结束，其中第三个参数表示的是截取的步长

  ## 数组获取元素
  vector[0:3]  #表示的是从第一个元素开始截取，获取三个元素，返回[1,3]
  
  ## 矩阵获取元素
  matrix[1:,0:2] # 从二列开始，获取第一列和第二列，返回([
      [4,5],8]
  ])

• 按照条件获取

  eg:
  a = vector[vector > 3] # 截取数组中所有元素大于3的，返回[4]
  a = vector[vector == 4] # 截取数组中元素等于4的数组，如果不存在的话，返回一个空数组
  
  b = matrix[matrix > 5] # 截取矩阵中所有元素大于5，返回结果是一个一维数组，即[6,9]
  b = matrix[matrix == 9] # 返回的是一个boolean矩阵，结果[
      [False,False,False],[False,[Fasle,True]
  ]

  • 混淆项

    1. 数组比较和按照条件截取数组内容的返回结果是不相同的
    eg:
    print(vector == 3) # 返回的是将数组的元素逐一比较，返回的是一个boolean数组
    
    print(vector[vector==3]) # 返回的是截取数组中满足条件的数组
    
    2. 矩阵比较和按照条件截取矩阵内容的返回结果是不相同的
    eg:
    print(matrix == 3) # 返回的是将矩阵的元素逐一比较，返回的是一个boolean矩阵
    
    print(matrix[matrix==3]) # 返回的是截取矩阵中满足条件的数组

• 按照整数序列存取元素

  当使用整数序列对数组元素进行存取时，将使用整数序列中的每个元素作为下标，整数序列可以是列表或者数组。使用整数序列作为下标获得的数组不和原始数组共享数据空间。也就是说，获取的新数组如果发生改变，原数组是不会发生改变的。相对前两者而言，这种存取方式是高效的。

  eg:
  a = numpy.linspace(0,endpoint=False)
  a
  >> array([0.,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9])
  
  # 按照整数序列，选取第4个、第6个、第8个、第10个元素进行组成新的数组
  b = a[[3,9]]
  b
  >> array([0.3,0.9])
  
  # 按照序列修改对应位置的值
  b[[0,2]]= -1,-2,-3
  b
  >> array([-1.,-2.,-3.,0.9])

• 使用布尔数组

  当使用布尔数组b作为下标存取数组x中的元素时，将收集数组x中所有在数组b中对应下标为True的元素。使用布尔数组作为下标获得的数组不和原始数组共享数据空间，注意这种方式只对应于布尔数组，不能使用布尔列表。

• 注意：

  • 和Python的列表序列不同，通过下标范围获取的新的数组是原始数组的一个视图。它与原始数组共享同一块数据空间，也就是说，新数组元素发生变化，原数组也会同时发生变化的。

常见的运算

• sum

  eg：
   # 数组求和
  
   # 矩阵求和
   # The axis dictates which dimension we perform the operation on
   #1 means that we want to perform the operation on each row,and 0 means on each column
   matrix = numpy.array([
                   [5,15],[20,25,30],[35,40,45]
                ])
   matrix.sum(axis=1) # axis=1表示按照每一行进行求和，axis=0表示按照每一列进行求和

• 乘积

  eg:
  #The matrix product can be performed using the dot function or method
  A = numpy.array([
      [1,[3,4]
  ])
  B = numpy.array([
      [1,6]
  ])
  
  # 普通的乘积
  multi = A * B
  print(multi)
  》》[[ 1  2]
      [12 24]]
  
  ## 点积运算
  resultdot = numpy.dot(A,B)
  print(resultdot)
  》》[[ 9 13]
      [19 27]]
  
  # flatten the array 铺平
  print(A.ravel())
  》》[1 2 3 4]
  
  # 横向拼接/纵向拼接
  print(numpy.vstack((A,B)))/numpy.hstack((A,B))
  》》[[1 2]
      [3 4]
      [1 1]
      [4 6]]

• 均值、方差

  • mean()用于求数组的平均值，也可以通过axis参数指定求平均值的轴，通过out参数指定输出数组。和sum()不同的是，对于整数数组，它使用双精度浮点数进行计算，而对于其他类型的数组，则使用和数组元素类型相同的累加变量进行计算。

  • average()也可以对数组进行平均计算。它没有out和dtype参数，但有一个指定每个元素权值的weights参数。

  • std()和var()分别计算数组的标准差和方差，有axis、out及dtype等参数。

    eg：
    f = numpy.array([[ 0,[10,21,22,23,24,25],[30,31,32,33,34,35],[40,41,42,43,44,45],[50,51,52,53,54,55]])
     ## 均值
    f.mean(f,axis=1) #整数数组使用双精度浮点数进行计算 
    >> array([ 2.5,12.5,22.5,32.5,42.5,52.5])
    
    ## 方差
    numpy.var(f,axis=1)
    》》array([2.91666667,2.91666667,2.91666667])
    
    ## 标准差
    numpy.std(f,axis=1)
    》》array([1.70782513,1.70782513,1.70782513])

• 三种转置运算T、transpose、swapaxes

  • T是一种普通的转置
  • transpose属于一种轴变换
  • swapaxes其实就是把矩阵中某两个轴对换一下，属于轴对称

  arr = numpy.arange(24).reshape((2,4))
  arr
  》》array([[[ 0,[ 4,7],[ 8,11]],[[12,[16,17,18,19],23]]])
  ## 转置       
  arr.T
  》》
  array([[[ 0,16],20]],[[ 1,13],17],21]],[[ 2,[ 6,18],22]],[[ 3,23]]])
  
  ## 将轴1和轴0互换，轴2不变，原始是(0,2)
  arr.transpose(1,2)
  》》array([[[ 0,[12,15]],[[ 4,19]],[[ 8,11],23]]])
  
  ## 将轴1和轴0互换，原始是(0,1)
  arr.swapaxes(1,0)
  》》array([[[ 0,23]]])

• 最值和排序

  • max()、min()求最大最小值

  • ptp()计算最大值和最小值之间的差

  • 用argmax()和argmin()可以求最大值和最小值的下标。如果不指定axis参数，就返回平坦化之后的数组下标

  • 数组的sort()方法用于对数组进行排序，它将改变数组的内容。而sort()函数则返回一个新数组，不改变原始数组。它们的axis参数默认值都为-1,即沿着数组的最后一个轴进行排序。
    sort()函数的axis参数可以设置为None,此时它将得到平坦化之后进行排序的新数组。

  • argsort()返冋数组的排序下标，axis参数的默认值为-1

  • 用median()可以获得数组的中值，即对数组进行排序之后，位于数组中间位置的值，当长度是偶数时，得到正中间两个数的平均值。它也可以指定axis和out参数

  • eg:
    a2 = floor(10*random.random((2,2))) 
    >>> a2 
    array([[ 1.,1.],[ 5.,8.]])
    >>>np.min(a2) # 最小值
    1.0
    >>>np.max(a2) # 最大值
    9.0
    >>>np.ptp(a2) # 最大最小值的差值
    8.0
    >>> np.argmax(a) #找到数组a中最大值的下标，有多个最值时得到第一个最值的下标 
    2
    >>> idx = np.argmax(a,axis=1)
    >>> idx
    array([2,0])
    ## 使用xrange()选择出每行的最大值
    >>> a[xrange(a.shape[0]),idx]
    array([9,9])
    
    >>> np.sort(a,axis=0) #对每列的数据进行排序 array([[5,0],0]，
              [9,9'8,3]])

• 按照某个轴的方向进行复制——tile

  eg：
  a = numpy.arange(0,10)
  a
  》》array([ 0,20,30])
  
  ## 将数组作为元素复制成3行5列的矩阵
  b = numpy.tile(a,(3,5)) 
  b
  》》array([[ 0,30,[ 0,30]])

函数模块

• numpy.linalg模块包含线性代数的函数。使用这个模块，可以计算逆矩阵、求特征值、解线性方程组以及求解行列式等

• • 对矩阵求逆

    使用numpy.linalg模块中的inv函数计算了逆矩阵，并检查了原矩阵与求得的逆矩阵相乘的结果确为单位矩阵。

    eg:
    A = np.mat("0 1 2;1 0 3;4 -3 8") #使用mat函数创建矩阵
    ## 求逆
    inverse = np.linalg.inv(A)

• • numpy.linalg中的函数solve可以求解形如 Ax= b 的线性方程组，其中 A为矩阵，b为一维或二维的数组，x是未知变量

  eg:
    A = np.mat("0 1 2;1 0 3;4 -3 8") #使用mat函数创建矩阵
    b = np.array([0,-9])
    ## 求解
    x = np.linalg.solve(A,b)

• • 特征值和特征向量——eigvals函数

    特征值（eigenvalue）即方程 Ax= ax 的根，是一个标量。其中，A 是一个二维矩阵，x 是一个一维向量。特征向量（eigenvector）是关于特征值的向量。在numpy.linalg模块中，eigvals函数可以计算矩阵的特征值，而eig函数可以返回一个包含特征值和对应的特征向量的元组。

• • 奇异值分解
    在numpy.linalg模块中的svd函数可以对矩阵进行奇异值分解。该函数返回3个矩阵——U、Sigma和V，其中U和V是正交矩阵，Sigma包含输入矩阵的奇异值。

小结

• 特征信息

  X.flags????#数组的存储情况信息。
  
  X.shape????#结果是一个tuple，返回本数组的行数、列数、……
  
  X.ndim???#数组的维数，结果是一个数。
  
  X.size????#数组中元素的数量
  
  X.itemsize????#数组中的数据项的所占内存空间大小
  
  X.dtype????#数据类型
  
  X.T???#如果X是矩阵，发挥的是X的转置矩阵
  
  X.trace()????#计算X的迹
  
  np.linalg.det(a)???#返回的是矩阵a的行列式
  
  np.linalg.norm(a,ord=None)????#计算矩阵a的范数
  
  np.linalg.eig(a)????#矩阵a的特征值和特征向量
  
  np.linalg.cond(a,p=None)????#矩阵a的条件数
  
  np.linalg.inv(a)????#矩阵a的逆矩阵

• 索引

  x=np.arange(10)
  
  print x[2]????#单个元素，从前往后正向索引。注意下标是从0开始的。
  
  print x[-2]????#从后往前索引。最后一个元素的下标是-1
  
  print x[2:5]????#多个元素，左闭右开，默认步长值是1
  
  print x[:-7]????#多个元素，从后向前，制定了结束的位置，使用默认步长值
  
  print x[1:7:2]???#指定步长值
  
  x.shape=(2,5)????#x的shape属性被重新赋值，要求就是元素个数不变。2*5=10
  
  print x[1,3]????#二维数组索引单个元素，第2行第4列的那个元素
  
  print x[0]???#第一行所有的元素
  
  y=np.arange(35).reshape(5,7)????#reshape()函数用于改变数组的维度
  
  print y[1:5:2,::2]????#选择二维数组中的某些符合条件的元素