一、Python數據分析之Numpy

0.數組的引入

• 假設我們想將列表中的每個元素增加1，但列表不支持這樣的操作：

  a = [1,2,3,4]
  a+1 #報錯
  #但可以這樣操作
  [x+1 for x in a]
  

• 數組與另一個數組相加，得到對應元素相加的結果：

  a = [1,2,3,4]
  b = [2,3,4,5]
  a+b #[1, 2, 3, 4, 2, 3, 4, 5]并不是我們想要的結果
  
  [x+y for(x,y) in zip(a,b)]  #都需要利用到列表生成式
  

• 這樣的操作比較麻煩，而且在數據量特別大的時候會非常耗時間。如果我們使用Numpy，就會變得特別簡單

1.創建數組

0. 先導入numpy包，有三種導入方式

   #import numpy
   import numpy as np#導入numpy包并起別名為np
   #from numpy import *
   

1. 使用np.array()創建:從其他python結構（如列表，元組）轉換

   l = [0,1,2,3]
   print(l)#[0, 1, 2, 3]
   a = np.array([0,1,2,3])
   print(a,type(a))#[0 1 2 3] <class 'numpy.ndarray'>
   a = np.array([[0,1,2,3],[10,11,12,13]])#創建二維數組
   

2. NumPy 原生數組的創建（如 arange、ones、zeros等）

   • np.arange(start, end, step):返回一個ndarray對象, 起始值為start，終止值為end，但不含終止值，步長為step

     a = np.arange(1,10,0.5) #左閉右開區間，和range的使用方式同理
     print(a,type(a))#[1.  1.5 2.  2.5 3.  3.5 4.  4.5 5.  5.5 6.  6.5 7.  7.5 8.  8.5 9.  9.5] <class 'numpy.ndarray'>
     

   • np.ones(shape, dtype=None):函數返回給定形狀和數據類型的新數組，其中元素的值設置為1

     one=np.ones(5,dtype="bool")
     print(one,type(one))#[ True  True  True  True  True] <class 'numpy.ndarray'>
     array_2d = np.ones((2, 3))
     print(array_2d,array_2d.dtype)#
     [[1. 1. 1.]
      [1. 1. 1.]] float64
     

   • np.zeros(shape,dtype=None):函數返回給定形狀和數據類型的新數組，其中元素的值設置為0

     • 用法同ones()

   • np.linspace(start，stop，num):指定間隔起始點、終止端，以及指定分隔值總數（包括起始點和終止點），最終函數返回間隔類均勻分布的數值數組

     該函數共有7個參數，主要介紹前面3個

     • start：數據的起始點，即區間的最小值

     • stop：數據的結束點，即區間的最大值

     • num：數據量，可以理解成分割了多少份，不寫默認為50

       a = np.linspace(1,50) #右邊是包括在里面的，從a-->b一共c個數的等差數列
       print(a)#
       [ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10. 11. 12. 13. 14. 15. 16. 17. 18.
        19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36.
        37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50.]
       a = np.linspace(1,50,10)
       print(a)#
       [ 1.          6.44444444 11.88888889 17.33333333 22.77777778 28.22222222
        33.66666667 39.11111111 44.55555556 50.        ]
       

   • Numpy中的random.rand(d0,d1,…,dn)主要用于返回一個或一組0到1之間的隨機數或隨機數組

     • dn表示每個維度

     • 示例：

       np.random.rand(2,3)
       #array([[0.34510296, 0.26100149, 0.55205447],
              [0.1093094 , 0.43907452, 0.29931807]])
       

   • numpy.random.randn(d0,d1,…,dn):返回一個或一組樣本，具有標準正態分布

     • 用法同rand()

     • 示例：

       np.random.randn(10) #標準正態分布
       array([-1.4237624 ,  1.63058904, -1.9223658 ,  0.17736421,  0.54337908,
              -1.46049834,  0.2146448 , -0.32785131, -1.08990638, -0.75152502])
       

   • numpy.random.randint(low, high=None, size=None, dtype=’l’):返回隨機整數，范圍區間為[low,high），包含low，不包含high

     • 參數：low為最小值，high為最大值，size為數組大小(沒寫默認為1)，dtype為數據類型，默認的數據類型是np.int

     • high沒有填寫時，默認生成隨機數的范圍是[0，low)

       np.random.randint(1,20,10) #生成隨機整數，從1-20中隨機10個
       

3. 注意：

   • numpy默認ndarray的所有元素的類型是相同的

   • 如果傳進來的列表中包含不同的類型，則統一為同一類型，優先級：str>float>int

   • 示例：

     c = np.array([4,23.4,12.4])
     print(c,c.dtype)#[ 4.  23.4 12.4] float64
     # 如果既有字符串，又有數字，按照優先級，統一為字符串
     b = np.array(["你好帥",2,3,4])
     print(b,b.dtype)#['你好帥' '2' '3' '4'] <U3
     

2.數組的屬性

1. 查看數組中元素類型dtype

   a=np.random.rand(2,3)
   a.dtype#dtype('float64')
   

   • 類型轉換

     • 利用dtype屬性

       a = np.array([1.5,-3],dtype = int)
       a#array([ 1, -3])
       

     • astype方法：返回一個新數組

       a = np.array([1,2,3])
       a.astype(float)#array([1., 2., 3.])
       

2. 查看數組的形狀shape

   a.shape#(2, 3)
   np.shape(a)#另一種寫法
   

3. 查看數組元素的個數size

   a.size#6
   

4. 查看數組的維度ndim

   a.ndim#2
   

3.數組的基本操作

3.1 索引

1. 一維數組與列表基本一致

   a = np.array([0,1,2,3])
   a[0]#0
   a[0] = 10
   a#array([10,  1,  2,  3])
   

2. 二維數組

   a = np.array([[0,1,2,3],[10,11,12,13]])
   a[1,3]#13
   a[1][3]#另一種寫法
   #其中，1是行索引，3是列索引，中間用逗號隔開。事實上，Python會將它們看成一個元組（1,3），然后按照順序進行對應。
   #事實上，我們還可以使用單個索引來索引一整行內容：
   a[1]#array([10, 11, 12, -1])
   

3.2 切片

1. 數組中的切片與列表中基本相同

2. 示例：

   a = np.array([11,12,13,14,15])
   a[1:3] #左閉右開，從0開始算array([12, 13])
   a[1:-2] #等價于a[1:3]
   
   a = np.array([[0,1,2,3,4,5],[10,11,12,13,14,15],[20,21,22,23,24,25],[30,31,32,33,34,35],[40,41,42,43,44,45],[50,51,52,53,54,55]])
   a#
   array([[ 0,  1,  2,  3,  4,  5],
          [10, 11, 12, 13, 14, 15],
          [20, 21, 22, 23, 24, 25],
          [30, 31, 32, 33, 34, 35],
          [40, 41, 42, 43, 44, 45],
          [50, 51, 52, 53, 54, 55]])
   #想得到第一行的第4和第5兩個元素
   a[0,3:5]#array([3, 4])
   #得到第三列
   a[:,2]#array([ 2, 12, 22, 32, 42, 52])
   

3. 注意：在數組中切片在內存中使用的是引用機制

   a = np.array([0,1,2,3,4])
   b = a[2:4]
   print(b)#[2 3]
   b[0] = 10
   a#array([ 0,  1, 10,  3,  4])
   #引用機制意味著，Python并沒有為b分配新的空間來存儲它的值，而是讓b指向了a所分配的內存空間，因此，改變b會改變a的值
   
   #而這種現象在列表中并不會出現
   a = [1,2,3,4,5]
   b = a[2:4]
   b[0] = 10
   print(a)#[1, 2, 3, 4, 5]
   

3.3花式索引

• 切片只能支持連續或者等間隔的切片操作，要想實現任意位置的操作。需要使用花式索引 fancy slicing。

  1. 一維花式索引

     • 指定索引位置

     a = np.arange(0,100,10)
     #array([ 0, 10, 20, 30, 40, 50, 60, 70, 80, 90])
     index = [1,2,-3]
     y = a[index]
     print(y,type(y))#[10 20 70] <class 'numpy.ndarray'>
     

     • 使用布爾數組

     #mask必須是布爾數組，長度必須和數組長度相等
     mask = np.array([0,2,2,0,0,1,0,0,1,0],dtype = bool)
     mask#
     array([False,  True,  True, False, False,  True, False, False,  True,
            False])
     a[mask]#array([10, 20, 50, 80])
     

  2. 二維花式索引

     • 對于二維花式索引，我們需要給定行和列的值

     a = np.array([[0,1,2,3,4,5],[10,11,12,13,14,15],[20,21,22,23,24,25],[30,31,32,33,34,35],[40,41,42,43,44,45],[50,51,52,53,54,55]])
     
     a[(0,1,2,3,4),[1,2,3,4,5]]#元組或者列表都可以
     array([ 1, 12, 23, 34, 45])#array([ 1, 12, 23, 34, 45])
     
     #返回的是最后三行的1,3,5列
     a[3:,[0,2,4]]
     #array([[30, 32, 34],
            [40, 42, 44],
            [50, 52, 54]])
     

     • 使用mask（bool數組）進行索引

     mask = np.array([1,0,1,0,0,1],dtype = bool)
     a[mask,2]#array([ 2, 22, 52])
     

  3. 注意：與切片不同，花式索引返回的是原對象的一個復制而不是引用

3.4 "不完全"索引

• 對于二維數組只給定一個索引時，為行索引

  y = a[:3]
  y#
  array([[ 0,  1,  2,  3,  4,  5],
         [ 1,  1,  1,  1,  1,  1],
         [20, 21, 22, 23, 24, 25]])
  

3.5 數組變形

1. 利用shape屬性

   a = np.arange(6)#array([0, 1, 2, 3, 4, 5])
   a.shape=(2,3)
   a
   #array([[0, 1, 2],
          [3, 4, 5]])
   a.shape#(2, 3)
   

2. 使用reshape()函數：它不會修改原來數組的值，而是返回一個新的數組

   a = np.arange(6)
   arr=a.reshape(2,3)
   print(arr)#
   array([[0, 1, 2],
          [3, 4, 5]])
   a#沒變
   

3. 數組轉置 T（轉置）

   a=np.array([[0, 1, 2],
          [3, 4, 5]])
   print(a.T)
   [[0 3]
    [1 4]
    [2 5]]
   print(a)
   [[0 1 2]
    [3 4 5]]
   #轉置不會改變原值
   a.transpose()#另一種寫法
   

4.數組聚合操作

• 聚合操作：指的是在數據查找基礎上對數據的進一步整理篩選行為

1. 求和np.sum(a,axis=None)

   • axis參數:

     • 當axis=0時，對列進行聚合操作
     • 當axis=1時，對行進行聚合操作

   • 示例：

     ##評分人數
     mv_num = np.array([692795,42995,327855,580897,478523,157074,306904,662552,284652,159302])
     np.sum(mv_num)#3693549
     mv_num.sum()#另一種寫法
     
     a = np.array([[0,1,2,3],[10,11,12,13]])
     a.sum(axis=0)#array([10, 12, 14, 16])
     a.sum(axis=1)#array([ 6, 46])
     

2. 最大最小值np.max()/np.min()

   • 用法同sum()

3. 平均值np.mean()

   • 用法同sum()

4. 標準差np.std()

   • 用法同sum()

5. 相關系數矩陣numpy.cov()

   ##評分
   mv_score = np.array([9.6,9.5,9.5,9.4,9.4,9.4,9.4,9.3,9.3,9.3])
   ##電影時長（分鐘）
   mv_length = np.array([142,116,116,142,171,194,195,133,109,92])
   np.cov(mv_score,mv_length)
   #array([[9.88888889e-03, 4.55555556e-01],
          [4.55555556e-01, 1.26288889e+03]])
   

6. 數組排序

   1. np.sort(a, axis=1, kind='quicksort', order=None)

   • a：所需排序的數組

   • axis：數組排序時的基準,axis = 0,按列排列;axis = 1 ,按行排列(默認axis=1)

   • kind：數組排序時使用的方法，其中：kind = ′quicksort′為快排；kind = ′mergesort′為混排；kind = ′heapsort′為堆排

   • 示例：

     arr = np.array([[3, 2, 4], [5, 0, 1]])
     
     print(np.sort(arr))
     [[2 3 4]
      [0 1 5]]
     print(np.sort(arr,axis=0))
     [[3 0 1]
      [5 2 4]]
     

   2. np.argsort(a, axis=1, kind='quicksort', order=None)

   • 返回從小到大的排列在數組中的索引位置

   • 用法與sort基本一致

   • 示例：

     ##評分人數
     mv_num = np.array([692795,42995,327855,580897,478523,157074,306904,662552,284652,159302])
     order = np.argsort(mv_num)
     order#array([1, 5, 9, 8, 6, 2, 4, 3, 7, 0], dtype=int64)
     
     arr = np.array([[3, 2, 4], [5, 0, 1]])
     order=np.argsort(arr)
     order#
     array([[1, 0, 2],
            [1, 2, 0]], dtype=int64)
     

5.數組連接

1. 有時候我們需要將不同的數組按照一定的順序連接起來，此時便可以用到concatenate((a0,a1,...,aN),axis = 0)

   • aN表示數組

   • axis表示按什么方向進行連接，默認為0，即按列連接

   • 數組為一維數組（向量）直接在其后面進行連接

     arr1 = np.array([1, 2, 3])
     
     arr2 = np.array([4, 5, 6])
     
     arr = np.concatenate((arr1, arr2))
     print(arr1.shape,arr2.shape)#(3,) (3,)
     print(arr)#[1 2 3 4 5 6]
     

   • 數組為二維數組

     arr1 = np.array([[1, 2, 3]])
     
     arr2 = np.array([[4, 5, 6]])
     
     arr = np.concatenate((arr1, arr2))
     print(arr1.shape,arr2.shape)#(1, 3) (1, 3)
     print(arr)
     #[[1 2 3]
     #[4 5 6]]
     arr = np.concatenate((arr1, arr2),axis=1)
     print(arr)#[[1 2 3 4 5 6]]
     

2. hstack() 沿行堆疊

   arr1 = np.array([1, 2, 3])
   
   arr2 = np.array([4, 5, 6])
   
   arr = np.hstack((arr1, arr2))
   
   print(arr)#[1 2 3 4 5 6]
   

3. vstack() 沿列堆疊

   arr1 = np.array([1, 2, 3])
   
   arr2 = np.array([4, 5, 6])
   
   arr = np.vstack((arr1, arr2))
   
   print(arr)
   #[[1 2 3]
    [4 5 6]]
   

4. dstack() 沿高度堆疊，該高度與深度相同

   arr1 = np.array([1, 2, 3])
   
   arr2 = np.array([4, 5, 6])
   
   arr = np.dstack((arr1, arr2))
   
   print(arr)#
   [[[1 4]
     [2 5]
     [3 6]]]
   

6.numpy內置函數

1. np.abs(a):絕對值函數，其中a為數組

2. np.exp(a):指數函數即 \(e^x\)

   示例：

   a = np.array([-1,1,0,-2])
   np.exp(a) #array([0.36787944, 2.71828183, 1.        , 0.13533528])
   

3. np.median(a):中值函數

   np.median(a) #中值-0.5
   

4. np.cumsum(a):累積和函數

   np.cumsum(a) #累積和
   #array([-1,  0,  0, -2], dtype=int32)
   

5. numpy.where(condition):輸出滿足條件元素的坐標

   a = np.array([0,12,5,20])
   b=np.where(a>10)
   print(b,type(b))#(array([1, 3], dtype=int64),) <class 'tuple'>
   

6. numpy的內置函數非常多，不需要死記，懂得查資料

   https://blog.csdn.net/nihaoxiaocui/article/details/51992860?locationNum=5&fps=1

7.numpy mat的使用

雖然array也可以進行運算，但mat更符合矩陣

• numpy.mat(data, dtype=None)：將數據轉化成矩陣類型

  • Parameters 參數介紹

    • data：array_like 數組、列表之類
    • dtype：data-type Data-type of the output matrix

  • Returns 返回值：matrix

• 索引

  m= np.mat([1,2,3])  #創建矩陣
  m[0]                #取一行
  m[0,1]              #第一行，第2個數據
  m[0][1]             #注意不能像數組那樣取值了,這樣寫會報錯
  

• 示例：

  A=np.array([[1,2,3],[4,5,6]])
  A1=np.mat(A)
  print(A1,type(A1))
  #結果
  [[1 2 3]
   [4 5 6]] <class 'numpy.matrix'>
  
  #也可以直接傳參數
  B=np.mat('1 2 3;4 5 6')#單引號，雙引號均可
  print(B,type(B))
  #結果
  [[1 2 3]
   [4 5 6]] <class 'numpy.matrix'>
  

  注:如果輸入本身就是一個矩陣，則np.mat不會對該矩陣make a copy.僅僅是創建了一個新的引用。np.matrix(data, copy = True)創建了一個新的相同的矩陣。當修改新矩陣時，原來的矩陣不會改變。

  #導入模塊
  import numpy as np
  
  #創建ndarray二維數組
  x = np.array([[1, 2], [3, 4]])
  
  #生成 <class 'numpy.matrix'> 矩陣
  m = np.mat(x)
  
  #打印 m 矩陣
  print(m)
  [[1 2]
   [3 4]]
  #如果此時修改 x 數組，m矩陣也會隨之發生變化
  x[0,0] = 5
  print(m)
  [[5 2]
   [3 4]]
  

8.矩陣的相關運算

1. 矩陣乘法

   • 數據結構為numpy.ndarray（數組） 或者numpy.matrix（矩陣）可以使用numpy.dot(a, b, out=None)

     • a : ndarray 數組
     • b : ndarray 數組
     • out : ndarray, 可選，用來保存dot()的計算結果

   • 數據結構為numpy.matrix（矩陣）時也可以使用星號（*）

   • 示例：

     #矩陣
     A=np.mat("1;2;3")
     B=np.mat('1 2 3;4 5 6')
     np.dot(B,A)
     #B*A 矩陣乘法要注意先后順序
     #B.dot(A)另一種寫法
     #結果
     matrix([[14],
             [32]])
     #數組
     A=np.array([[1],[2],[3]])
     print(A.shape)#(3, 1)
     B=np.array([[1,2,3],[4,5,6]])
     print(B.shape)#(2, 3)
     B.dot(A)
     #輸出結果
     array([[14],
            [32]])
     B*A#會報錯，對于數組*計算的時對應位置的乘法，需要兩個數組的形狀相同
     #operands could not be broadcast together with shapes (2,3) (3,1) 
     

2. 矩陣對應元素相乘

   • np.multiply():數組和矩陣對應位置相乘，輸出與相乘數組/矩陣的大小一致

   • 數據結構為numpy.ndarray（數組）時也可以使用星號（*）

   • 示例

     #數組
     A=np.array([[1,1,1],[2,2,2]])
     B=np.array([[1,2,3],[4,5,6]])
     B*A
     np.multiply(A,B)
     #輸出結果
     array([[ 1,  2,  3],
            [ 8, 10, 12]])
     #矩陣
     A=np.mat(A)
     B=np.mat(B)
     np.multiply(A,B)
     #輸出結果
     matrix([[ 1,  2,  3],
             [ 8, 10, 12]])
     

3. 計算矩陣的行列式值

   • numpy.linalg.det() 函數計算輸入矩陣的行列式

   • 示例

     import numpy as np
     a = np.array([[1,2], [3,4]]) 
      
     print (np.linalg.det(a))#-2.0
     

4. 逆矩陣

   • numpy.linalg.inv()：函數計算矩陣的乘法逆矩陣

   • 示例

     x = np.array([[1,2],[3,4]]) 
     y = np.linalg.inv(x) 
     print (x)
     print (y)
     print (np.dot(x,y))
     #輸出結果
     [[1 2]
      [3 4]]
     
     [[-2.   1. ]
      [ 1.5 -0.5]]
     #近似于E
     [[1.00000000e+00 1.11022302e-16]
      [0.00000000e+00 1.00000000e+00]]
     

5. 解線性方程組

   • linalg.solve(a,b)形如：AX = B

     • a:Coefficient matrix（系數矩陣）
     • b:列向量

   • 示例：Solve the system of equations

     x₀ + 2 * x₁ = 1 and

     3 * x₀ + 5 * x₁ = 2

     a = np.array([[1, 2], [3, 5]])
     b = np.array([1, 2])
     x = np.linalg.solve(a, b)
     x
     array([-1.,  1.])
     

二、Pandas

1.Pandas基本介紹

Python Data Analysis Library 或 Pandas是基于Numpy的一種工具，該工具是為了解決數據分析任務而創建的。Pandas納入了大量庫和一些標準的數據模型，提供了高效地操作大型數據集所需的工具。pandas提供了大量能使我們快速便捷地處理數據的函數和方法。

2.Pandas 基本數據結構

• pandas有兩種常用的基本結構：
  • Series：
    • 帶標簽的一維數組，與Numpy中的一維array類似。二者與Python基本的數據結構List也很接近。Series可存儲整數、浮點數、字符串、Python 對象等類型的數據
  • DataFrame：
    • 二維的表格型數據結構，可以將DataFrame理解為Series的容器。

3.Series 的創建

1. series由兩部分組成

   • values:一組數據(ndarray類型)

   • index:相關的數據索引標簽

   • 形式如下：

     

2. Pandas 使用 Series() 函數來創建 Series 對象

   • pandas.Series( data, index, dtype, name, copy)

     • data：一組數據(ndarray 類型)
     • index：數據索引標簽，如果不指定，默認從 0 開始
     • dtype：數據類型，默認會自己判斷
     • name：設置名稱
     • copy：拷貝數據，默認為 False

   • 創建一個空series對象

     #輸出數據為空
     s = pd.Series()
     print(s,type(s))#Series([], dtype: float64) <class 'pandas.core.series.Series'>
     

   • 用列表list構建Series

     my_list=[7,'Beijing','19大',3.1415,-10000,'Happy']
     s=pd.Series(my_list)
     print(type(s))
     print(s)
     #輸出結果
     <class 'pandas.core.series.Series'>
     0           7
     1     Beijing
     2        19大
     3      3.1415
     4      -10000
     5       Happy
     dtype: object
     

     • pandas會默認用0到n來做Series的index,但也可以自己指定index

       s=pd.Series([7,'Beijing','19大',3.1415,-10000,'Happy'],
       index=['A','B','C','D','E','F'])
       print(s)
       #輸出結果
       A           7
       B     Beijing
       C        19大
       D      3.1415
       E      -10000
       F       Happy
       dtype: object
       

   • ndarray創建Series對象

     d=pd.Series(np.random.randn(5),index=['a','b','c','d','e'])
     print(d)
     #輸出結果
     a   -0.329401
     b   -0.435921
     c   -0.232267
     d   -0.846713
     e   -0.406585
     dtype: float64
     

   • 用字典dict來構建Series，因為Series本身其實就是key-value的結構

     cities={'Beijing':55000,'Shanghai':60000,'shenzhen':50000,'Hangzhou':20000,'Guangzhou':45000,'Suzhou':None}
     apts=pd.Series(cities,name='income')
     print(apts)
     #輸出結果
     Beijing      55000.0
     Guangzhou    45000.0
     Hangzhou     20000.0
     Shanghai     60000.0
     Suzhou           NaN
     shenzhen     50000.0
     Name: income, dtype: float64
     

4.訪問Series數據

4.1 索引—index

s = pd.Series([1,3,5,np.nan,6,8])
print(s.index,type(s.index))
#結果
#默認情況下，Series的下標都是數字（可以使用額外參數指定），類型是統一的。
RangeIndex(start=0, stop=6, step=1) <class 'pandas.core.indexes.range.RangeIndex'>

s.index.name = '索引'
s
#
索引
0    1.0
1    3.0
2    5.0
3    NaN
4    6.0
5    8.0
dtype: float64

4.2 值—values

new_s=s.values
print(new_s,type(new_s),new_s.dtype)
#結果
[ 1.  3.  5. nan  6.  8.] <class 'numpy.ndarray'> float64

4.3 切片

s[2:5] #左閉右開
#結果
2    5.0
3    NaN
4    6.0
dtype: float64

s[::2]
#結果
0    1.0
2    5.0
4    6.0
dtype: float64

s.index = list('abcdef')
s['a':'c':2] #依據自己定義的數據類型進行切片，不是左閉右開了
#結果
a    1.0
c    5.0
dtype: float64

5.DataFrame

5.1 DataFrame簡介

1. DataFrame是一個表格型的數據結構,DataFrame由按一定順序排列的多列數據組成.設計初衷是將Series的使用場景從一維拓展到多維。其實DataFrame就是由多個Series組成的，因此可以說DataFrame是Series的容器。

2. DataFrame由3部分組成

   • 行索引:index

   • 列索引:columns

   • 值:values

   • 如下圖：

     

5.2 DataFrame的創建

1. 使用ndarry創建

   • pd.DataFrame(data=None, index=None, columns=None, dtype=None, copy=False)

     • index指定行索引，columns指定列索引，若不寫，則默認從0開始，size指定行數和列數

     • 示例：

       df = pd.DataFrame(data=np.random.randint(1,10,size=(2,4)),index=["a","b"],columns=["A","B","C","D"])
       #結果
       	A	B	C	D
       a	2	9	8	1
       b	6	1	2	1
       
       #默認情況下，如果不指定index參數和columns，那么它們的值將從用0開始的數字替代
       df = pd.DataFrame(np.random.randn(6,4))
       print(df)
       #結果
                 0         1         2         3
       0 -0.261175 -0.250175 -0.315719  1.294368
       1  0.824193 -1.930705 -0.744268  0.343531
       2 -0.350171  1.270669  0.783120 -0.795121
       3  0.626404 -2.341512 -0.057654 -0.883903
       4 -0.648448  0.253251  0.447128  1.492709
       5 -0.315956  0.121005 -0.804142 -1.134788
       

2. 使用字典創建

   • 字典的每個key代表一列，其value可以是各種能夠轉化為Series的對象

     dic = {"name":["張三","李四","王五"],"age":[1,2,3]}
     # key為列的索引，行索引則默認從0開始
     df=pd.DataFrame(dic)
     print(df)
     #結果
        name	 age
     0	張三	18
     1	李四	19
     2	王五	22
     
     df2 = pd.DataFrame({'A':1.,'B':pd.Timestamp("20181001"),'C':pd.Series(1,index = list(range(4)),dtype = float),'D':np.array([3]*4, dtype = int),'E':pd.Categorical(["test","train","test","train"]),'F':"abc"}) #B:時間戳,E分類類型
     print(df2)
     #輸出結果
          A          B    C  D      E    F
     0  1.0 2018-10-01  1.0  3   test  abc
     1  1.0 2018-10-01  1.0  3  train  abc
     2  1.0 2018-10-01  1.0  3   test  abc
     3  1.0 2018-10-01  1.0  3  train  abc
     

5.3 DataFrame 的屬性

1. index 行索引屬性

   print(df2.index,type(df2.index))
   #Int64Index([0, 1, 2, 3], dtype='int64') <class 'pandas.core.indexes.numeric.Int64Index'>
   

2. columns 列索引屬性

   print(df.columns,type(df.columns))
   #Index(['A', 'B', 'C', 'D', 'E', 'F'], dtype='object') <class 'pandas.core.indexes.base.Index'>
   

3. values 數據值屬性

   df2.values
   #結果
   array([[1.0, Timestamp('2018-10-01 00:00:00'), 1.0, 3, 'test', 'abc'],
          [1.0, Timestamp('2018-10-01 00:00:00'), 1.0, 3, 'train', 'abc'],
          [1.0, Timestamp('2018-10-01 00:00:00'), 1.0, 3, 'test', 'abc'],
          [1.0, Timestamp('2018-10-01 00:00:00'), 1.0, 3, 'train', 'abc']],
         dtype=object)
   

4. shape、size、dtypes

   df2.shape
   (4, 6)
   df2.size
   24
   df2.dtypes
   #輸出結果
   A           float64
   B    datetime64[ns]
   C           float64
   D             int32
   E          category
   F            object
   dtype: object
   

5.4 DataFrame的索引和切片

1. 隱式索引的操作：即不規定行、列索引使用默認索引

   • df[0][0] df[列][行]，獲取隱式索引單個元素

   • df[1] ,df[i] 獲取第i+1列元素 df[1,3,5]這種寫法會報錯

   • df[0:2] 對行的切片操作，獲取的是0和1行，顧頭不顧尾

   • df[[0,1]] 對列的操作，獲取第一列和第二列

   • df.iloc[0:2,0:2] iloc對于隱式索引的操作，獲取前兩行和前兩列組成的區域，逗號前式行，逗號后是列

   • df.iloc[[0,1],[0,1]] iloc對于隱式索引的操作，獲取前兩行和前兩列組成的區域

   • 示例：

     df = pd.DataFrame(np.random.randn(6,4))
     print(df)
     #輸出結果
               0         1         2         3
     0 -1.724670 -0.305197 -1.235365 -0.052571
     1  1.401085  1.621906 -0.526358 -1.507972
     2 -0.786382  0.741458  0.306289 -1.099758
     3  2.419920 -0.647299  1.194271  0.692936
     4  0.347969  0.607995 -1.757885 -0.021412
     5 -0.964155  0.936637  0.975647  0.731744
     df[[0,2]]
               0         2
     0 -1.724670 -1.235365
     1  1.401085 -0.526358
     2 -0.786382  0.306289
     3  2.419920  1.194271
     4  0.347969 -1.757885
     5 -0.964155  0.975647
     
     df[0]
     0   -1.724670
     1    1.401085
     2   -0.786382
     3    2.419920
     4    0.347969
     5   -0.964155
     Name: 0, dtype: float64
     
     df[0:2]
               0         1         2         3
     0 -1.724670 -0.305197 -1.235365 -0.052571
     1  1.401085  1.621906 -0.526358 -1.507972
     
     df.iloc[0:2,0:2]
               0         1
     0 -1.724670 -0.305197
     1  1.401085  1.621906
     

2. 顯式索引的操作:顯式索引使用切片表達式時是閉區間

   • df["A"] 或 df.A 獲取單列，類似于字典的操作

   • df['A']['a'] 獲取單個元素，先列后行 df[列][行]

   • df["a":"b"] 獲取是a到b行,包含b行

   • df[["A","B"]] 獲取A列和B列

   • df.loc["a":"b","A":"B"] loc對于顯式索引的操作，df[行區域，列區域]

   • df.loc[["a","b"],["A","B"]] loc對于顯式索引的操作，結果同上

   • 示例：

     df1 = pd.DataFrame(data=np.random.randint(1,10,size=(3,4)),index=["a","b","c"],columns=["A","B","C","D"])
     df1
        A  B  C  D
     a  2  6  2  6
     b  6  8  6  6
     c  1  8  5  4
     
     df1.loc["a":"b","A":"B"]
        A  B
     a  2  6
     b  6  8
     

3. head和tail方法可以分別查看最前面幾行和最后面幾行的數據（默認為5）

   df.head()
             0         1         2         3
   0 -1.724670 -0.305197 -1.235365 -0.052571
   1  1.401085  1.621906 -0.526358 -1.507972
   2 -0.786382  0.741458  0.306289 -1.099758
   3  2.419920 -0.647299  1.194271  0.692936
   4  0.347969  0.607995 -1.757885 -0.021412
   
   df.tail(3)
             0         1         2         3
   3  2.419920 -0.647299  1.194271  0.692936
   4  0.347969  0.607995 -1.757885 -0.021412
   5 -0.964155  0.936637  0.975647  0.731744
   

4. 總結

• loc是對于顯式索引的相關操作(對于標簽的處理)，iloc是針對隱式索引的相關操作(對于整數的處理)
• df[0:2]切片操作是針對行而言，對于df["A"]索引操作是對于列而言；獲取單個元素先列后行，df[列][行]；loc和iloc操作，逗號前是行區域或行列表，逗號后是列區域或列列表

5.5 DataFrame讀取數據及數據操作

1. 讀取Excel文件數據

   • 函數原型pd.read_excel(io, sheetname=0,header=0,skiprows=None,index_col=None,names=None,
     arse_cols=None,date_parser=None,na_values=None,thousands=None,
     convert_float=True,has_index_names=None,converters=None,dtype=None,
     true_values=None,false_values=None,engine=None,squeeze=False,**kwds)
   • 參數介紹
     • io ：excel 路徑
     • sheetname：默認是sheetname為0，返回多表使用sheetname=[0,1]，若sheetname=None是返回全表 。注意：int/string返回的是dataframe，而none和list返回的是dict of dataframe
     • header ：指定作為列名的行，默認0，即取第一行，數據為列名行以下的數據；若數據不含列名，則設定 header = None
     • skiprows：省略指定行數的數據
     • skip_footer：省略從尾部數的行數據
     • index_col ：指定列為索引列，也可以使用 u’string’
     • names：指定列的名字，傳入一個list數據
     • usecols:默認為None，解析所有列；如果為str，則表示Excel列字母和列范圍的逗號分隔列表（例如“ A：E”或“ A，C，E：F”）。范圍全閉；如果為int，則表示解析到第幾列；如果為int列表，則表示解析那幾列

   df = pd.read_excel(r"D:\BaiduNetdiskDownload\python\python\作業3\豆瓣電影數據.xlsx",index_col = 0)
   

2. 文本文件的讀取

   • 函數原型 pandas.read_csv(filepath_or_buffer, sep=, delimiter=None, header=‘infer’, names=None, index_col=None, usecols=None, squeeze=False, prefix=None, mangle_dupe_cols=True, dtype=None, engine=None, converters=None, true_values=None, false_values=None, skipinitialspace=False, skiprows=None, skipfooter=0, nrows=None, na_values=None, keep_default_na=True, na_filter=True, verbose=False, skip_blank_lines=True, parse_dates=False, infer_datetime_format=False, keep_date_col=False, date_parser=None, dayfirst=False, cache_dates=True, iterator=False, chunksize=None, compression=‘infer’, thousands=None, decimal=’.’, lineterminator=None, quotechar=’"’, quoting=0, doublequote=True, escapechar=None, comment=None, encoding=None, dialect=None, error_bad_lines=True, warn_bad_lines=True, delim_whitespace=False, low_memory=True, memory_map=False, float_precision=None, storage_options=None)
   • 幾個重要參數
     • filepath_or_buffer：字符串。任何有效的字符串路徑都可以，網址也行。
     • sep:字符串，表示分隔符，默認為逗號
     • delimiter：字符串，sep的別名，默認None（如果定義該參數，則sep參數失效）
     • header: int或者int列表，默認由推斷出來。這是用于規定列名的行號
     • index_col: 整數或者字符串或者整數/字符串列表。指定用作的行標簽的列
     • nrows: 整數，選擇性使用。要讀取的文件行數。對于讀取大文件很有用
     • skiprows:列表或者整數，選擇性使用。在文件開始處要跳過的行號（索引為0）或要跳過的行數（整數）
   • 返回值為DateFrame

3. 數據操作

   • 添加數據df.append(other, ignore_index=False, verify_integrity=False, sort=None)

     • other：DataFrame、series、dict、list等數據結構

     • ignore_index:默認值為False，為True則不使用index標簽

     • verify_integrity：默認值為False，如果為True當創建相同的index時會拋出ValueError的異常

     • sort:boolean,默認是None

     • 示例：

       #append添加字典
       data = pd.DataFrame()
       a = {"x":1,"y":2}
       data = data.append(a,ignore_index=True)
       print(data)#
            x    y
       0  1.0  2.0
       
       #append添加series
       #如果不添加ignore_index=True,會報錯TypeError: Can only append a Series if ignore_index=True or if the Series has a name
       #如果不添加ignore_index=True，則需要添加name屬性
       series = pd.Series({"x":1,"y":2},name="a")
       data = data.append(series)
       print(data)#輸出結果
            x    y
       0  1.0  2.0
       a  1.0  2.0
       #設置的name會作為index的name
       
       #append添加list
       #如果list是一維的，則是以列的形式添加，如果list是二維的則是以行的形式來添加
       data = pd.DataFrame()
       a = [1,2,3]
       data = data.append(a)
       print(data)#
          0
       0  1
       1  2
       2  3
       
       data = pd.DataFrame()
       a = [[1,2,3],[4,5,6]]
       data = data.append(a)
       print(data)#
          0  1  2
       0  1  2  3
       1  4  5  6
       

   • drop(labels=None, axis=0, index=None, columns=None, level=None, inplace=False, errors='raise')

     • labels：一個字符或者數值，加上axis ，表示帶label標識的行或者列；如 (labels='A', axis=1) 表示A列

     • axis：axis=0表示行，axis=1表示列

     • columns：列名

     • index：表示dataframe的index, 如index=1, index=a

     • inplace：True表示刪除某行后原dataframe變化，False不改變原始dataframe

     • 示例：

       df2 = pd.DataFrame({'A':1.,'B':pd.Timestamp("20181001"),'C':pd.Series(1,index = list(range(4)),dtype = float),'D':np.array([3]*4, dtype = int),'E':pd.Categorical(["test","train","test","train"]),'F':"abc"}) #B:時間戳,E分類類型
       print(df2)#
            A          B    C  D      E    F
       0  1.0 2018-10-01  1.0  3   test  abc
       1  1.0 2018-10-01  1.0  3  train  abc
       2  1.0 2018-10-01  1.0  3   test  abc
       3  1.0 2018-10-01  1.0  3  train  abc
       #刪除A列，axis=1不能省略
       df2=df2.drop('A',axis=1)
       #df2=df2.drop(columns='A')另一種寫法
       

5.6 缺失值處理

1. 缺失值
   • 在np中，None是python自帶的,其類型為object,因此,None不能參與到人任何計算中(NoneType)
   • np.nan(NaN) 是浮點類型(float),能參與到計算中.但計算的結果總是NaN
   • 在pandas中把None和np.nan都視作np.nan
2. 缺失值處理方法
   • isnull() 有缺失值則返回True
   • notnull() 沒有缺失值則返回True
   • isnull().any(axis=1) axis=1是代表行，0代表列，一行中只要有一個空值則返回True
   • notnull().all(axis=1) 一行中所有不為空則返回True
   • df.dropna(axis=0, how='any', thresh=None, subset=None, inplace=False) 刪除有缺失值的整行或整列
     • axis=0 這里的0代表行
     • how='any' how是刪除方式，any只要一行或一列中有一個缺失值就刪除，還有一個all代表的意思是，一行或一列中所有的都為缺失值才刪除，常用的是any
     • inplace=False inplace代表操作是否對原數據進行覆蓋，False代表不在原數據上修改，而是復制出一份，True代表在原數據上修改
   • df.fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None, **kwargs) 對缺失值進行填充
     • value 填充的值,也可以是字典
     • axis 1 代表行，0代表列
     • inplace inplace代表操作是否對原數據進行覆蓋，False代表不在原數據上修改，而是復制出一份，True代表在原數據上修改
     • method 分為四種填充方式：'backfill', 'bfill', 'pad', 'ffill' 其中pad / ffill表示用前面行/列的值，填充當前行/列的空值； backfill / bfill表示用后面行/列的值，填充當前行/列的空值

三、Matplotlib Pyplot

1.matplotlib pyplot簡介

• Pyplot 是 Matplotlib 的子庫，提供了和 MATLAB 類似的繪圖 API

• Pyplot 包含一系列繪圖函數的相關函數，每個函數會對當前的圖像進行一些修改，例如：給圖像加上標記，生新的圖像，在圖像中產生新的繪圖區域等等

• 導入pyplot庫

  import matplotlib.pyplot as plt
  

2.plot函數

plot() 用于畫圖它可以繪制點和線，語法格式如下

• 畫單條線

  • plot([x], y, [fmt], data=None, **kwargs)

• 畫多條線

  • plot([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs)

• 參數介紹

  • 帶有[]的參數是可選參數

  • [x] 默認參數，x為0~N-1

  • 可選參數[fmt] 是一個字符串來定義圖的基本屬性 如：顏色（color），點型（marker），線型（linestyle）具體形式 fmt = '[color][marker][line]' fmt接收的是每個屬性的單個字母縮寫 如 'bo-' 藍色圓點實線

  • 若屬性用的是全名則不能用fmt參數來組合賦值，應該用關鍵字參數對單個屬性賦值

    plot(x,y2,color='green', marker='o', linestyle='dashed', linewidth=1, markersize=6)
    

• 示例1：

  plt.plot([1,2,3,4],[1,4,9,16],"bo-") #也可以是ob，沒順序要求
  plt.show()
  print(line,type(line))#[<matplotlib.lines.Line2D object at 0x0000024C7C6362E0>] <class 'list'>
  

  

• 示例2：

  t = np.arange(0.,5.,0.2) #左閉右開從0到5間隔0.2
  plt.plot(t,t,"r--",
          t,t**2,"bs-",
          t,t**3,"g^-")
  plt.show()
  

  

• 線條屬性

  • color：折線的顏色

  • linestyle：指定折線的類型，可以是實線、虛線、點虛線、點點線等，默認文實線；

  • linewidth：指定折線的寬度

  • marker：可以為折線圖添加點，該參數是設置點的形狀；

  • markersize：設置點的大小；

  • markeredgecolor：設置點的邊框色；

  • markerfactcolor：設置點的填充色；

  • 圖示：

    

• 設置屬性

  • plt.setp(obj,*args,**kwargs)

    • obj： 要設置的對象
    • *args、**kwargs：需要設置的屬性值

  • 調用方式

    • setp(line, linewidth=2, color='r')

    • setp 還支持 MATLAB 式的鍵值對

      setp(lines, 'linewidth', 2, 'color', 'r')

    • 示例3：

      x = np.linspace(-np.pi,np.pi)
      y = np.sin(x)
      line = plt.plot(x,y)
      #plt.setp(line, color = 'g',linewidth = 4)
      plt.setp(line,"color",'r',"linewidth",4) #matlab風格
      

      

3.理解plt與ax

1. 一幅圖的結構：python是面向對象的，同樣利用matplotlib畫圖從面向對象的角度更容易理解

   • Figure對象：可看成是一個畫布。有了畫布之后，才能在上面畫各種圖

   • Axes對象：畫布上的一塊區域，這個區域肯定要包含許多信息，比如曲線，坐標軸，標題，圖例，注釋等。這些就是Axes對象包含的屬性，它們也是各種對象。比如Line2D，XAxis，YAxis

   • 如圖：

     

2. matplotlib 架構上分為三層

• 底層：backend layer

• 中層：artist layer

• 最高層：scripting layer

• 在任意一層操作都能夠實現畫圖的目的，而且畫出來還都一樣。但越底層的操作越細節話，越高層越易于人機交互。

• .plt 對應的就是最高層 scripting layer。這就是為什么它簡單上手，但要調細節就不靈了

• ax.plot 是在 artist layer 上操作。基本上可以實現任何細節的調試

3. 兩種繪圖方式的區別

   對這兩個概念有基本的了解后，就可以來看看plt.plot()和ax.plot()有何區別

   • plt

     # 第一種方式
     plt.figure()
     plt.plot([1,2,3],[4,5,6])
     plt.show()
     

   • ax

   # 第二種方式
   fig,ax = plt.subplots()
   ax.plot([1,2,3],[4,5,6])
   plt.show()
   

   • 其實就這兩種方式畫出的圖形其實是一樣的，但是

     • 第一種方式的代碼，先生成了一個Figure畫布，然后在這個畫布上隱式生成一個畫圖區域進行畫圖
     • 第二種方式同時生成了Figure和axes兩個對象，然后用ax對象在其區域內進行繪圖

4.子圖形的構成

4.1 Figure

1. figure簡介

   在繪制圖形之前，我們需要一個Figure對象，可以理解成我們需要一張畫板才能開始繪圖

2. plt.figure(num=None, figsize=None, dpi=None, facecolor=None, edgecolor=None, frameon=True, clear=False, *kwargs)：*產生一個指定編號為num的圖

   • num: 圖像編號或名稱，數字為編號 ，字符串為名稱
   • figsize: 指定figure的寬和高，單位為英寸
   • dpi: 參數指定繪圖對象的分辨率，即每英寸多少個像素，缺省值為80, 1英寸等于2.5cm,A4紙是 21*30cm的紙張
   • facecolor: 背景顏色
   • edgecolor: 邊框顏色
   • frameon: 是否顯示邊框

4.2 subplot函數

1. 使用subplots可以在一幅圖中生成多個子圖也即 axes對象

2. plt.subplot(nrows, ncols, fignum，**fig_kw)：繪圖時需要指定位置

   • nrows： subplot的行數
   • ncols： subplot的列數，行X列就是被分成多少個圖像區域
   • fignum： 目前該圖像位于第幾個位置
   • **fig_kw：創建figure時的其他關鍵字

3. subplots(nrows=1, ncols=1) 方法可以一次生成多個，在調用時只需要調用生成對象的 ax 即可

   • nrows：默認為 1，設置圖表的行數
   • ncols：默認為 1，設置圖表的列數

4. 函數調用：

   plt.subplot(ijn) i代表劃分為幾行j為幾列，n是指目前在第幾個子區域內，當numrows * numncols < 10時，中間的逗號可以省略，因此plt.subplot(211)就相當于plt.subplot(2,1,1)

5. 示例4：

   def f(t):
       return np.exp(-t)*np.cos(2*np.pi*t)
   
   t1 = np.arange(0.0,5.0,0.1)
   t2 = np.arange(0.0,4.0,0.02)
   
   plt.figure(figsize = (10,6),facecolor='g')#背景設為綠色
   ax1=plt.subplot(211)
   print(ax1,type(ax1))#AxesSubplot(0.125,0.536818;0.775x0.343182) <class 'matplotlib.axes._subplots.AxesSubplot'>
   plt.plot(t1,f(t1),"bo",t2,f(t2),'k') #子圖1上有兩條線
   
   plt.subplot(212)
   plt.plot(t2,np.cos(2*np.pi*t2),"r--")
   plt.show()
   

   

6. 另一種寫法：

   fig = plt.figure()
   ax1 = fig.add_subplot(221) # 劃分為2行2列四個區域，這是第一個區域，以下以此類推
   ax1.set(title="標題1",ylabel='y',xlabel='x') 
   ax2 = fig.add_subplot(222)
   ax2.set(title="標題2",ylabel='y',xlabel='x')
   ax3 = fig.add_subplot(223)
   ax3.set(title="標題3",ylabel='y',xlabel='x')
   ax4 = fig.add_subplot(224)
   ax4.set(title="標題4",ylabel='y',xlabel='x')
   plt.show()
   

   

5.圖形標注

5.1 坐標軸相關設置

0. 解決亂碼問題

   plt.rcParams["font.sans-serif"] = ["SimHei"] #解決中文字符亂碼的問題
   # SimHei：微軟雅黑
   # FangSong：仿宋
   plt.rcParams["axes.unicode_minus"] = False #正常顯示負號
   

1. 坐標軸標簽設置—以xlabel函數為例

   • 函數語法：

     xlabel(xlabel, fontdict=None, labelpad=None, *, loc=None, **kwargs):設置X軸的標簽

   • 函數參數：

     • xlabel：字符串格式，標簽文本內容
     • fontdict： dict, 一個字典用來控制標簽的字體樣式
     • labelpad：浮點數，默認值為None， x/y軸的標簽離x/y軸的偏移量，以點為單位
     • loc(location)：標簽位置，默認在中間，對于x軸是’left’，‘center’，‘right’，對于y軸則是’bottom’， ‘center’， ‘top’

   • 示例：

     plt.rcParams["font.sans-serif"] = ["SimHei"] #解決中文字符亂碼的問題
     plt.rcParams["axes.unicode_minus"] = False #正常顯示負號
     line=plt.plot([1,2,3,4]) #默認以列表的索引作為x，輸入的是y
     plt.ylabel('y軸',labelpad=20,loc='top',fontdict={'color':"red",'fontsize':20})
     plt.xlabel("x軸") 
     plt.show()
     #注意y軸標簽與x軸的區別
     

     

   • 另一種寫法ax.set_xlabel()用法與xlabel()相同

     plt.rcParams["font.sans-serif"] = ["SimHei"] #解決中文字符亂碼的問題
     plt.rcParams["axes.unicode_minus"] = False #正常顯示負號
     def f(t):
         return np.exp(-t)*np.cos(2*np.pi*t)
     
     t1 = np.arange(0.0,5.0,0.1)
     t2 = np.arange(0.0,4.0,0.02)
     
     plt.figure(figsize = (10,6),facecolor='g')
     ax1=plt.subplot(211)
     plt.plot(t1,f(t1),"bo",t2,f(t2),'k') #子圖1上有兩條線
     ax1.set(title="標題一")
     ax1.set_ylabel('y軸',labelpad=20,loc='top',fontdict={'color':"red",'fontsize':20})
     plt.show()
     

2. 坐標軸刻度設置

   • 函數語法

     yticks(ticks=None, labels=None, **kwargs) ax.yticks或者plt.yticks

   • 參數說明

     • ticks： 可選參數，數組，x軸刻度位置的列表。傳入空列表移除所有x軸刻度
     • labels： 可選參數，數組，放在指定刻度位置的標簽文本。只有當ticks參數有輸入值，該參數才能傳入參數

   • 示例：

     #不使用xticks函數
     x=np.linspace(1,10,100)
     y = np.sin(x)
     plt.plot(x,y)
     # plt.xticks(range(1,10))
     plt.show()
     
     #使用xticks函數
     x=np.linspace(1,10,100)
     y = np.sin(x)
     plt.plot(x,y)
     plt.xticks(range(1,10),['a','b','c','d','e','f','g','h','i'])
     plt.show()
     

     

   • plt.axis([xmin,xmax,ymin,ymax]):該方法可以讓你用一行代碼設置 x 和 y 的限值,它還可以按照圖形的內容自動收緊坐標軸，不留空白區域

     axis()函數除了支持數值列表作為輸入外，還支持字符選項。Matplotlib會根據輸入的字符選項自動地對軸進行調整

     • axis(‘off’)：關閉軸線和標簽

     • axis(‘equal’)：使x軸與y軸保持與屏幕一致的高寬比（橫縱比）

     • axis(‘tight’)：使x軸與y軸限制在有數據的區域

     • axis(‘square’)：使x軸與y軸坐標一致

       x=np.linspace(0,10,20)
       plt.plot(x,np.sin(x))
       plt.axis([-1,11,-1.5,1.5])
       plt.show()
       

       

5.2 設置標題(title)

• 函數語法

  plt.title（label, fontdict=None, loc=None, pad=None, *, y=None, **kwargs):設置坐標系標題

  ax.set_title()用法同上

• 函數參數

  • label: 字符串，用于標題文本內容

  • fontdictdict：字體字典項：控制標題文本展現，默認設置如下

    {'fontsize': rcParams['axes.titlesize'],
     'fontweight': rcParams['axes.titleweight'],
     'color': rcParams['axes.titlecolor'],
     'verticalalignment': 'baseline',
     'horizontalalignment': loc}
    

  • loc：標題文本的位置，默認’center’，可以設置’center’, ‘left’, ‘right’，控制標題的左右移動

  • y:浮點型，標題的垂直位置（頂部是1.0）。 如果為None（默認），則自動確定，控制標題的上下移動

• 示例：

  plt.rcParams["font.sans-serif"] = ["SimHei"] #解決中文字符亂碼的問題
  plt.rcParams["axes.unicode_minus"] = False #正常顯示負號
  x = np.linspace(-2,2,1000)
  y = np.exp(x)
  
  plt.plot(x,y,ls='-',lw=2,color='g')
  
  plt.title("center",fontdict={
                      'fontsize': 20,  #字體大小
                      'fontweight':'light',  #字體粗細, ‘light’, ‘normal’, ‘medium’, ‘semibold’, ‘bold’, ‘heavy’, ‘black’
                      'color':'r',  #字體顏色
                      'verticalalignment':'top',# 垂直對齊方式，'center', 'top', 'bottom', 'baseline', 'center_baseline'
                      'horizontalalignment':'center',#對齊方式，'center', 'right', 'left'
                      'family':'Times New Roman',   #字體系列，它的值有很多，比如 “宋體”，“微軟雅黑”等等
                      'fontstyle':'italic'    #字體風格：它的值有：normal（默認值）、italic（斜體）、oblique（傾斜）
  })
  
  plt.show()
  

  

5.3 圖例設置

圖例是對圖形所展示的內容的解釋，比如在一張圖中畫了三條線，那么這三條線都代表了什么呢？這時就需要做點注釋，便引出下面的函數

• plt.legend(*args,* kwargs)或者ax.legend()*這個函數參數挺多的，主要介紹幾個常用的參數

  • handles：需要傳入你所畫線條的實例對象
  • labels：是圖例的名稱（能夠覆蓋在plt.plot( )中label參數值）
  • loc:代表了圖例在整個坐標軸平面中的位置
  • ncol： 圖例的列的數量，默認為1

• 用法：

  • 方法一：采用plt.legend( )默認參數

    • 第一步：給plt.plot( )中參數label=''傳入字符串類型的值，也就是圖例的名稱

    • 第二步：使用plt.legend( )使上述代碼產生效果

    • 示例：

      plt.rcParams['font.sans-serif'] = ['SimHei']
      plt.rcParams['axes.unicode_minus'] = False
      
      n = np.linspace(-5, 4, 30)
      m1 = 3 * n + 2
      m2 = n ** 2
      
      plt.xlabel('時間')
      plt.ylabel('心情')
      
      plt.plot(n, m1, color='r', linewidth=1.5, linestyle='-', label='女生購物欲望')
      plt.plot(n, m2, 'b', label='男生購物欲望')
      plt.legend()
      
      plt.show()
      

      

  • 方法二：向plt.legend( )中設置參數，進行個性化圖例定制

    • 示例：

      plt.rcParams['font.sans-serif'] = ['SimHei']
      plt.rcParams['axes.unicode_minus'] = False
      
      n = np.linspace(-5, 4, 30)
      m1 = 3 * n + 2
      m2 = n ** 2
      
      plt.xlabel('時間')
      plt.ylabel('心情')
      
      line1, = plt.plot(n, m1, color='r', linewidth=1.5, linestyle='-', label='女生購物欲望')#label屬性可不寫
      line2, = plt.plot(n, m2, 'b', label='男生購物欲望')
      
      plt.legend(handles=[line1, line2], labels=['girl購物欲望','boy購物欲望'], loc='best',ncol=2)
      
      plt.show()
      

      

5.4 文本注釋

• 函數語法

  text(x, y, s, fontdict=None, **kwargs):添加注釋文本；在坐標（x,y）位置添加文本

• 函數參數：

  • x, y: 浮點型，放置注釋文本的數字坐標位置

  • s：字符型，文本內容

  • fontdict：字典類型，默認為空；用于覆蓋默認文本屬性的字典項，若字典項為空則默認屬性由rcParams確定。默認設置如下：

    {'fontsize': rcParams['axes.titlesize'],
     'fontweight': rcParams['axes.titleweight'],
     'color': rcParams['axes.titlecolor'],
     'verticalalignment': 'baseline',
     'horizontalalignment': loc}
    

  • **kwargs：其他參數： 設置文本屬性。如：weight：注釋文本內容的粗細風格，color：注釋文本內容的字體顏色

• 示例：

  x = np.linspace(0.05, 10, 1000)
  y = np.sin(x)
  
  plt.plot(x, y, ls="-.", lw=2, c="r", label="plot figure")
  plt.legend()
  plt.text(3.10, 0.09, "y=sin(x)", weight="bold", color="b")
  plt.show()
  

  

5.5 設置網格線

• 函數語法：

  plt.grid(b=None, which=‘major’, axis=‘both’, **kwargs)或者ax.grid()設置圖表中的網格線

• 參數說明：

  • b：可選，默認為 None，可以設置布爾值，true 為顯示網格線，false 為不顯示，如果設置 **kwargs 參數，則值為 true
  • which：可選，可選值有 'major'、'minor' 和 'both'，默認為 'major'，表示應用更改的網格線
  • axis：可選，設置顯示哪個方向的網格線，可以是取 'both'（默認），'x' 或 'y'，分別表示兩個方向，x 軸方向或 y 軸方向
  • **kwargs：可選，設置網格樣式，可以是 color='r', linestyle='-' 和 linewidth=2，分別表示網格線的顏色，樣式和寬度

• 示例：

  x = np.array([1, 2, 3, 4])
  y = np.array([1, 4, 9, 16])
  
  
  plt.title("RUNOOB grid() Test")
  plt.xlabel("x - label")
  plt.ylabel("y - label")
  
  plt.plot(x, y)
  
  plt.grid(color = 'r', linestyle = '--', linewidth = 0.5)
  
  plt.show()
  

  

6.柱狀圖

bar()函數用于繪制柱狀圖

• 函數語法

  *plt.bar(x, height, width=0.8, bottom=None, , align=‘center’, data=None, **kwargs)

• 函數參數

  • x：浮點型或類數組對象；柱形的的x軸坐標
  • height: 浮點型或類數組對象；柱形的高度
  • width：浮點型或類數組對象；柱形的寬度，默認值為0.8
  • bottom：浮點型或類數組對象； 柱形基座的y坐標，默認0
  • align：對齊方式： 中間，邊緣 ，默認為中間。柱與x軸坐標的對其方式。center:x軸坐標在中間位置,edge:x軸坐標在左邊
  • Other Parameters:
    • color：可選參數，顏色或顏色列表 。柱形顏色
    • edgecolor：可選參數：顏色或顏色列表 。柱形邊緣的顏色

• 示例：

  labels = ['G1', 'G2', 'G3', 'G4', 'G5']
  men_means = [20, 34, 30, 35, 27]
  women_means = [25, 32, 34, 20, 25]
  
  x = np.arange(len(labels))  # the label locations
  width = 0.35  # the width of the bars
  
  fig, ax = plt.subplots()
  rects1 = ax.bar(x - width/2, men_means, width, label='Men',color='g')
  rects2 = ax.bar(x + width/2, women_means, width, label='Women',color='b')
  for a,b in zip(x,men_means): #數字直接顯示在柱子上（添加文本）
      plt.text(a-width/2,b,b,ha = "center",va = "bottom",fontsize = 10) 
      
  for a,b in zip(x,women_means): #數字直接顯示在柱子上（添加文本）
      plt.text(a+width/2,b,b,ha = "center",va = "bottom",fontsize = 10) 
  # Add some text for labels, title and custom x-axis tick labels, etc.
  ax.set_ylabel('Scores')
  ax.set_title('Scores by group and gender')
  ax.set_xticks(x)
  ax.set_xticklabels(labels)
  ax.legend()
  

  

7.條形圖

函數Barh() 用于繪制條形圖

• 函數語法

  *barh(y, width, height=0.8, left=None, , align=‘center’, **kwargs)

• 用法與bar()基本一致

• 示例：

  df = pd.read_excel(r"D:\BaiduNetdiskDownload\python\python\作業5\movie_data3.xlsx", index_col = 0)
  data = df["產地"].value_counts()
  x = data.index
  y = data.values
  
  plt.figure(figsize = (10,6)) #設置圖片大小
  plt.barh(x,y,color = "g") #繪制柱狀圖，表格給的數據是怎樣就怎樣，不會自動排序
  
  plt.title("各國家或地區電影數量", fontsize = 20) #設置標題
  plt.xlabel("國家或地區",fontsize = 18) 
  plt.ylabel("電影數量") #對橫縱軸進行說明
  plt.tick_params(labelsize = 14) #設置標簽字體大小
  # plt.xticks(rotation = 90) #標簽轉90度
  
  for a,b in zip(x,y): #數字直接顯示在柱子上（添加文本）
      #a:x的位置，b:y的位置，加上10是為了展示位置高一點點不重合，
      #第二個b:顯示的文本的內容,ha,va:格式設定,center居中,top&bottom在上或者在下,fontsize:字體指定
      plt.text(b,a,a,fontsize = 10) 
  
  #plt.grid() #畫網格線，有失美觀因而注釋點
  
  plt.show()
  

  

8.餅狀圖

餅圖英文學名為Sector Graph，又名Pie Graph。常用于統計學模塊。餅圖中的數據點（數據點：在圖表中繪制的單個值，這些值由條形，柱形，折線，餅圖或圓環圖的扇面、圓點和其他被稱為數據標記的圖形表示。相同顏色的數據標記組成一個數據系列。）顯示為整個餅圖的百分比。可以使用 pyplot 中的 **pie() **方法來繪制餅圖。

• 函數語法

  *plt.pie(x, explode=None, labels=None, colors=None, autopct=None, pctdistance=0.6, shadow=False, labeldistance=1.1, startangle=0, radius=1, counterclock=True, wedgeprops=None, textprops=None, center=0, 0, frame=False, rotatelabels=False, , normalize=None, data=None)

• 參數說明

  • x：浮點型數組，表示每個扇形的面積
  • explode：數組，表示各個扇形之間的間隔，默認值為0
  • labels：列表，各個扇形的標簽，默認值為 None
  • colors：數組，表示各個扇形的顏色，默認值為 None
  • autopct：設置餅圖內各個扇形百分比顯示格式，%d%% 整數百分比，%0.1f 一位小數， %0.1f%% 一位小數百分比， %0.2f%% 兩位小數百分比
  • labeldistance：標簽標記的繪制位置，相對于半徑的比例，默認值為 1.1，如 <1則繪制在餅圖內側
  • pctdistance：：類似于 labeldistance，指定 autopct 的位置刻度，默認值為 0.6
  • shadow：：布爾值 True 或 False，設置餅圖的陰影，默認為 False，不設置陰影
  • radius：：設置餅圖的半徑，默認為 1
  • startangle：：起始繪制餅圖的角度，默認為從 x 軸正方向逆時針畫起，如設定 =90 則從 y 軸正方向畫起

• 示例：

  import matplotlib.pyplot as plt
  import numpy as np
  
  y = np.array([35, 25, 25, 15])
  
  plt.pie(y,
          labels=['A','B','C','D'], # 設置餅圖標簽
          colors=["#d5695d", "#5d8ca8", "#65a479", "#a564c9"], # 設置餅圖顏色
          explode=(0, 0.2, 0, 0), # 第二部分突出顯示，值越大，距離中心越遠
          autopct='%.2f%%', # 格式化輸出百分比
         )
  plt.title("RUNOOB Pie Test")
  plt.show()