前言：

先感受一下資料科學的魅力，上圖是在Smart Dubai 2017 GITEX科技周展臺上推出Smart Decision-Making Platform（智能決策平臺），于10月8日至12日在迪拜世界貿易中心舉行，游客可以通過一個“沉浸式的空間”將資料可視化，讓他們了解迪拜的未來，讓參觀者可以在現場查閱觀看全市資料，這意味著迪拜將成為了世界上第一個與公眾分享實時實時資料的城市，同時還可以預測未來十年的發展，

最近，很多小伙伴在后臺私信我，咨詢有沒有資料處理及可視化的相關系統教程？我的回復是，這些庫只是工具，無需花費很長的時間牢記這些命令的使用，學習一遍之后整理好筆記即可，遺忘之時再查找這些筆記使用即可，

本文是博主本人結合自己的使用經驗以及各大博主的分享精煉匯總而成，耗時進半個月的時候，翻閱博客和參考資料無數，最后精選了最實用、常用、好用的“Pandas、Numpy、Matplotlib”三大神兵利器的方法使用攻略，

Pandas精煉總結

1.屬性值中存在缺失，將變數轉換成Pandas可操作型別資料的方法

當某個屬性資料中存在空值(NaN)，則該屬性資料型別為object，使用convert_dtypes()將Series轉換為支持的dtypes，

1.convert_dtypes()處理DataFrame型別資料，示例如下：

# dataframe 變數型別自動轉換
df = pd.DataFrame(
    {
        "a": pd.Series([1, 2, 3], dtype=np.dtype("int32")),
        "b": pd.Series(["x", "y", "z"], dtype=np.dtype("O")),
        "c": pd.Series([True, False, np.nan], dtype=np.dtype("O")),
        "d": pd.Series(["h", "i", np.nan], dtype=np.dtype("O")),
        "e": pd.Series([10, np.nan, 20], dtype=np.dtype("float")),
        "f": pd.Series([np.nan, 100.5, 200], dtype=np.dtype("float")),
    }
)
print(df.dtypes)

dfn = df.convert_dtypes()
print(dfn.dtypes)

2.convert_dtypes()處理Series變數型別資料，示例如下：

# Series 變數型別自動轉換
s = pd.Series(["a", "b", np.nan])
print(s.dtypes)
sn = s.convert_dtypes()
print(sn.dtypes)

2.為資料表格添加顏色特性，實作更好可視化的方法

pandas可通過添加顏色條件，讓表格資料凸顯出統計特性，

import pandas as pd
df = pd.read_csv("test.csv")

1.Fare變數值呈現條形圖，以清楚看出各個值得大小比較，可直接使用bar，示例如下:

df.style.bar("Fare",vmin=0)

2.讓Age變數呈現背景顏色的梯度變化，以體驗映射的數值大小，那么可直接使用background_gradient，深顏色代表數值大，淺顏色代表數值小，示例如下：

df.style.background_gradient("Greens",subset="Age")

3.讓所有缺失值都高亮出來，可使用highlight_null，示例如下：

df.style.highlight_null()

4.pandas的style條件格式，組合用法非常簡單，示例如下：

df.style.bar("Fare",vmin=0).background_gradient("Greens",subset="Age").highlight_null()

3.Pandas中數值實作函式映射轉換的方法

使用pd.transform(func,axis)函式：

• func是指定用于處理資料的函式，它可以是普通函式、字串函式名稱、函式串列或軸標簽映射函式的字典，
• axis是指要應用到哪個軸，0代表列，1代表行，

1.func=“普通函式”，示例如下：

df = pd.DataFrame({'A': [1,2,3], 'B': [10,20,30] })
def plus_10(x):
    return x+10
df.transform(plus_10)
# df.transform(lambda x: x+10)  等價寫法

2.func=“內置的字串函式”，示例如下：

df = pd.DataFrame({'A': [1,2,3], 'B': [10,20,30] })
df.transform('sqrt')

3.func=“多個映射函式”，示例如下：

df = pd.DataFrame({'A': [1,2,3], 'B': [10,20,30] })
df.transform([np.sqrt, np.exp])

4.func=“指定軸位置的映射函式”，示例如下：

df = pd.DataFrame({'A': [1,2,3], 'B': [10,20,30] })
df.transform({
    'A': np.sqrt,
    'B': np.exp,
})

4.屬性值中出現長串列或字串形式的資料，實作分割處理的方法

作業中，比如用戶畫像的資料中也會遇到，客戶使用的app型別就會以這種長串列的形式或者以逗號隔開的字串形式展現出來，

1.使用explode()這個方法即可，一般我們會在后面跟一個去重的方法，explode()支持串列、元組、Series和numpy的ndarray型別資料，示例如下：

df.explode('愛好').drop_duplicates()

2.當長資料不是explode能夠處理的資料型別時，使用Series.str.split()分割字串的方法將其轉換為串列格式后處理，然后再進行explode即可，示例如下：

df["愛好"] = df["愛好"].str.split()

df.explode('愛好').drop_duplicates()

5.DataFrame資料之間拼接的方法

源資料如下：

df1 = pd.DataFrame（{ 
    'name'：['A'，'B'，'C'，'D']，
    'math'：[60,89,82,70]，
    'physics'：[66， 95,83,66]，
    'chemistry'：[61,91,77,70] 
}）
df2 = pd.DataFrame（{ 
    'name'：['E'，'F'，'G'，'H']，
    'math'：[66,95,83,66]，
    'physics'：[60， 89,82,70]，
    'chemistry'：[90,81,78,90] 
}）

1.默認情況下，它是沿axis=0垂直連接的，并且默認情況下會保留df1和df2原來的索引，

pd.concat（[df1，df2]）

2.可以通過設定引數ignore_index=True，這樣索引就可以從0到n-1自動排序了，

pd.concat（[df1，df2]，ignore_index = True）

3.如果想要沿水平軸連接兩個DataFrame，可以設定引數axis=1，

pd.concat（[df1，df2]，axis = 1）

4.可以通過設定引數verify_integrity=True，將此設定True為時，如果存在重復的索引，將會報錯，

 pd.concat([df1,df2], verify_integrity=True)

6.DataFrame資料轉置的方法

dataframe都有的一個簡單屬性，實作轉置功能，它在顯示describe時可以很好的搭配，

boston.describe().T.head(10)

7.統計屬性的數值分布頻率的方法

在資料探索的時候，value_counts是使用很頻繁的函式，它默認是不統計空值的，但空值往往也是我們很關心的，如果想統計空值，可以將引數dropna設定為False，

ames_housing = pd.read_csv("data/train.csv")

print(ames_housing["FireplaceQu"].value_counts(dropna=False, normalize=True))

8.Pandas替換例外值的方法

例外值檢測是資料分析中常見的操作，使用clip函式可以很容易地找到變數范圍之外的例外值，并替換它們，

 age.clip(50, 60)

9.Pandas篩選資料的方法

源資料如下：

1.直接在dataframe的[]中寫篩選的條件或者組合條件，示例如下：

# 篩選出大于NOX這變數平均值的所有資料，然后按NOX降序排序，
df[df['NOX']>df['NOX'].mean()].sort_values(by='NOX',ascending=False).head()

#篩選出大于NOX這變數平均值且CHAS屬性值=1的所有資料，然后按NOX降序排序，
df[(df['NOX']>df['NOX'].mean())& (df['CHAS'] ==1)].sort_values(by='NOX',ascending=False).head()

2.loc按標簽值（列名和行索引取值）訪問，iloc按數字索引訪問，均支持單值訪問或切片查詢，loc還可以指定回傳的列變數，示例如下：

# 按df['NOX']>df['NOX'].mean()條件篩選出資料，并篩選出指定CHAS變數，然后賦值=2
df.loc[(df['NOX']>df['NOX'].mean()),['CHAS']] = 2

3.需要鎖定某些具體的值的，這時候就需要isin了，比如我們要限定NOX取值只能為0.538,0.713,0.437中時，示例如下：

df.loc[df['NOX'].isin([0.538,0.713,0.437]),:].sample(5)

# 也可以做取反操作，在篩選條件前加`~`符號
df.loc[~df['NOX'].isin([0.538,0.713,0.437]),:].sample(5)

4.pandas里實作字串的模糊篩選，可以用.str.contains()來實作，示例如下：

train.loc[train['Name'].str.contains('Mrs|Lily'),:].head()

10.DataFrame資料之間合并的方法

merge()：對于擁有相同的鍵的兩個DataFrame物件，需要將其進行有效的拼接，整合到一個物件，

def merge(left, right, how='inner', on=None, left_on=None, right_on=None,
         left_index=False, right_index=False, sort=True,
         suffixes=('_x', '_y'), copy=True, indicator=False,
         validate=None)

主要引數介紹：

• left：DataFrame物件；
• right：DataFrame物件；
• how：連接方式，inner或outer，默認是outer；
• on：指定用于連接的鍵，必須存在于左右兩個DataFrame中；
• left_on：左側DataFrame中用于連接鍵的列名，當左右物件列名不同但含義相同時使用；
• right_on：右側DataFrame中用于連接鍵的列名；
• left_index：使用左側DataFrame的行索引作為連接鍵（配合right_on）；
• right_index：使用右側DataFrame的行索引作為連接鍵（配合left_on）；
• sort：對其按照連接鍵進行排序；

源資料為：

df1 = pd.DataFrame(np.random.randint(10, size=(3, 3)), columns=['A', 'B', 'C'])
df2 = pd.DataFrame(np.random.randint(10, size=(2, 2)), columns=['A', 'B'])

pd.merge(df1, df2, how='outer', on='B')

pd.merge(df1, df2, how='outer', left_on='B', right_on='A')

11.Pandas洗掉重復項的方法

1.drop_duplicates():洗掉物件dataframe中重復的行，重復通過引數subset指定，

def drop_duplicates(subset=None, keep='first', inplace=False, ignore_index=False)

主要引數介紹：

• subset：指定的鍵（列），默認為所有的列（即每行全部相同）；
• keep：洗掉重復項，除了第1個（first）或者最后一個（last）；
• inplace：是否直接對原來的物件進行修改，默認為False，生成一個拷貝`；
• ignore_index：是否重建索引；

df1 = pd.DataFrame(np.random.randint(10, size=(3, 3)), columns=['A', 'B', 'C'])
df1.drop_duplicates('A')

2.unique()：相比于drop_duplicates方法，unique()只針對于Series物件，類似于Set， 通常是對dataframe中提取某一鍵，變成Series，再去重，統計個數，

print(len(df1['A'].unique().tolist()))

12.Pandas資料排序的方法

sort_values()：按照某個鍵進行排序， 查看相同鍵時行的某些變化，如例子中在A相同時B、C的變化，

def sort_values(by, axis=0, ascending=True, kind='quicksort', na_position='last', ignore_index=False)

主要引數介紹：

• by：字串或字串串列，指定按照哪個鍵/索引進行排序；
• axis：指定排序的軸；
• ascending：升序或降序，默認為升序；
• kind：指定排序方法，‘quicksort’, ‘mergesort’, ‘heapsort；
• ignore_index：是否重建索引；

df1.sort_values(by='A')

13.Pandas資料采樣的方法

sample()：對物件進行采樣， 當dataframe物件資料量太大，導致做實驗過滿時，可以抽取一部分進行實驗，提高效率，

def sample(n=None, frac=None, replace=False, weights=None, random_state=None, axis=None)

主要引數介紹：

• n：指定采樣的數量；
• frac：指定采樣的比例，與n只能選擇其中一個；
• replace：允許或不允許對同一行進行多次采樣；
• weights：采樣的權重，默認為“None”將導致相同的概率權重；
• random_state：類似于seed作用；
• axis：指定采樣的軸，默認為行；

df1.sample(n=3)

df1.sample(frac=0.1)

14.Pandas判斷和洗掉缺失值的方法

1.isna()：isna方法回傳一個布爾物件，每個元素是否為NaN，

df1.isna()

2.isnull()：當資料量很大時，上述很難觀察到某列是否存在缺失，此時可以用isnull()方法 ，

 df1.isnull().all()  # 某列是否全部為NaN
 df1.isnull().any() # 某列是否出現NaN

3.dropna()：dropna方法洗掉含缺失值的行或列，

def dropna(axis=0, how='any', thresh=None, subset=None, inplace=False)

主要引數介紹：

• axis：指定軸；
• how：引數為any時，行或列（axis決定）出現NaN時，就進行洗掉；為all時，行或列全為NaN時才進行洗掉；
• thresh：閾值，要求不為NAN的個數；
• subset：指定鍵（列）進行判斷NAN洗掉；
• inplace：是否更改原物件；

 df1.dropna(how='any', subset=['B'])

15.Pandas指定條件下值替換的方法

where()：通過布爾序列選擇一個回傳的子集，對物件進行篩選，并且對于不滿足的值，where方法可以對其進行替換，

例如若列為性別，元素為字串，可將其進行替換為數值，

# 寫法一
df1.where(df1 > 3, -1)
# 寫法二
df1[df1.A <= 3] = -1

Numpy精煉總結

1.Numpy統計頻數的方法

bincount()方法：計算非負整數陣列中每個值出現的次數，回傳一個輸入陣列的桶裝（binning）結果，

numpy.bincount(x, weights=None, minlength=0)

引數介紹：

• x：1維的非負整數陣列；
• weights：與x相同維度的權重陣列；
• minlength：輸出陣列的最小桶數(bins)；當行并未出現最大的值時，就可以指定該引數；

# 統計從0~max值的整數出現的頻數
np.bincount([1,2,3,4,5,1,1,1,5,4])
# 設定每個值的權重，最終的頻數由資料對應的權重相加得到
np.bincount([1,2,3,4,5,1,1,1,5,4], weights=[0.1,0.2,0.3,0.4,0.5,0.1,0.2,0.3,0.4,0.5])
# 指定輸出陣列的最小長度
np.bincount([1], minlength=4)

2.Numpy陣列之間連接合并的方法

1.np.r_[]/np.c_[]分別為沿行/列進行連接，指定r /``c`可指定連接后資料的輸出格式，資料挖掘中，最常用的就是為某個多維陣列添加一行樣本，或一列特征，

# 沿著行連接
np.r_[np.array([1,2,3]),  np.array([4,5,6])]
# 沿著列連接
np.c_[np.array([[1,2], [3,7], [8, 9]]),  np.array([4,5,6])]
# 沿著行連接，按行輸出
np.r_['r', np.array([1,2,3]),  np.array([4,5,6])]
# 沿著列連接，按列輸出
np.r_['c', np.array([1,2,3]),  np.array([4,5,6])]

2.np.concatenate()，它沿現有軸連接陣列序列，它一次能實作多個陣列拼接，

numpy.concatenate((a1, a2, ...), axis=0, out=None)

引數介紹：

• (a1, a2, …)：陣列序列，陣列必須具有相同的形狀，除了與axis對應的維度(默認情況下是第一個維度)，
• axis：整數，指定拼接的軸；若為None，則是將其展平為向量，

a = np.array([[1, 2],[3, 4]])
b = np.array([[5, 6]])

# 按陣列的第一層資料拼接
np.concatenate((a, b), axis=0)

# 按陣列的第二層資料拼接
np.concatenate((a, b.T), axis=1)

# 按陣列最內層的資料元素依次拼接并回傳一維陣列
np.concatenate((a, b), axis=None) 

3.Numpy生成亂數的方法

生成亂數的方法在資料挖掘中是必不可少的，在Numpy中，最常使用的有四種方法：np.random.rand()【回傳一個0～1的均勻樣本】、np.random.randint()【回傳隨機整數的均勻樣本】、np.random.randn()【回傳一個標準正態分布的樣本】和np.random.normal()【回傳一個標準正態分布的樣本】，

1.np.random.rand()：回傳一個給定形狀的使用[0, 1)的均勻分布的陣列，

numpy.random.rand(d0, d1, ..., dn)

引數介紹：

• d0, d1, …, dn：回傳陣列的維度，必須非負，若沒有該引數，則回傳單一隨機值；

np.random.rand(2,2)

2.np.random.randint()：回傳從低(含)到高(不含)的隨機整數，在半開區間從指定的dtype的離散均勻分布中回傳隨機整數,如果high為None(預設值)，則結果來自[0,low)，

numpy.random.randint(low, high=None, size=None, dtype=int)

引數介紹：

• low：整數或整數陣列，指定下界，若high=None，則為上界，即范圍為[0, low)；
• high：整數或整數陣列，指定上界（不取）；
• size：整數或為一個整數元組（tuple），即定義的輸出形狀，若為None，則回傳一個單一隨機值；
• dtype：定義結果型別；

np.random.randint(5, size=(2, 2))

np.random.randint(2, 3, size=5)

3.np.random.randn()：從標準正態分布中回傳一個(或多個)樣本，

numpy.random.randn(d0, d1, ..., dn)

引數介紹：

• d0, d1, …, dn：回傳陣列的維度，必須非負，若沒有該引數，則回傳單一隨機值；

np.random.randn(2, 2)

4.numpy.random.normal()：從正態(高斯)分布中隨機抽取樣本，默認為標準正態分布，

numpy.random.normal(loc=0.0, scale=1.0, size=None)

引數介紹：

• loc：float，分布的平均值；
• scale：float，分布的標準差，必須是非負數；
• size：整數或元組，輸出形狀，為None回傳單一隨機值；

mu, sigma = 0, 0.1 # mean and standard deviation
s = np.random.normal(mu, sigma, 1000)

4.Numpy資料排序的方法

Numpy中排序函式分為兩種，一種是回傳排序后的陣列np.sort()，另一種為回傳排序后的索引陣列np.argsort()，

1.np.sort()：Numpy中排序操作，通用函式為np.sort()，它回傳一個被排序的陣列，

numpy.sort(a, axis=-1, kind=None, order=None)

引數介紹：

• a：被排序的陣列；
• axis：指定排序的軸，默認值為-1，則按照最后一個軸；
• kind：排序演算法，默認為quicksort，另外還有：mergesort、heapsort、stable；
• order：字串或字串串列，a是一個定義了欄位的陣列時，這個引數指定首先比較哪個欄位，然后比較哪個欄位，

a = np.array([[1,4],
             [3,1]])
np.sort(a)

a = np.array([[1,4],
             [3,1]])
np.sort(a, axis=0) 

a = np.array([[1,4],
             [3,1]])
np.sort(a, axis=None)

2.np.argsort()：回傳將對陣列排序的索引，通過獲得索引可以指定陣列按某行/列進行排序，

numpy.argsort(a, axis=-1, kind=None, order=None)

引數介紹：

• a：排序陣列；
• axis：默認-1，即按最后一個軸排序；如果為None，則展平為向量；
• kind：排序演算法，默認為quicksort；
• order：同np.sort()；

# axis=0,對x按列進行排序，小的在上面，大的在下面(升序)  
x = np.array([[0, 3], [2, 2], [4, -1]])
np.argsort(x, axis=0)

# axis=0,對x按行進行排序，小的在左邊，大的在右邊(升序)   
x[np.argsort(x, axis=0)[:,1]]

# 按第二列進行降序排序，添加一個負號即可(降序)  
x[np.argsort(-x, axis=0)[:,1]]

5.Numpy多維陣列展平的方法

np.flatten()：這是在資料挖掘中非常常用的方法，有時得到一個N*1矩陣，經常將其轉化為向量進行后續操作，類似方法還有ravel()，

ndarray.flatten(order='C')

引數介紹：

• order：{‘C’, ‘F’, ‘A’, ‘K’}，默認為C，以行進行展平；F以列進行展平；【最主要就是這兩個】

a = np.array([[1,2], [3,4]])

a.flatten('F')

6.Numpy改變多維素組的形狀的方法

np.reshape() ：主要用法是來改變維度（增刪），

numpy.reshape(a, newshape, order='C')

引數介紹：

• 改變形狀的陣列；
• 整數或元組，新的形狀，若元組最后一個數為-1，則表示最后一個維度是進行計算推斷得出；
• order：“C” 簡單來講就是橫著讀，橫著寫，優先讀/寫一行；“F” 豎著讀，豎著寫，優先讀/寫一列；默認是"C"，

a = np.array([[5,1,1], 
              [8,5,6],
              [3,1,3],
              [7,6,8]])
r1=a.reshape((3,4),order='C')

r2=a.reshape((3,4),order='F')

7.構造全0/1/Null陣列的方法

1.np.zeros()：回傳填充為0的陣列，

numpy.zeros(shape, dtype=float, order='C')

引數介紹：

• shape：整數或元組，新陣列的shape；
• dtype：定義陣列型別，默認為np.float64；
• order：同上，含C、F；

np.zeros(5)

np.zeros((2, 2))

2.np.zeros_like()：回傳與某陣列型別相同維度的全零陣列，

numpy.zeros_like(a, dtype=None, order='K', subok=True, shape=None

主要引數介紹：

• a：所參照該形狀的陣列；
• dtype：定義陣列型別；

x = np.arange(6).reshape((2, 3))
np.zeros_like(x)

3.np.empty()：用于創建空陣列，

a=np.empty(2,3)#資料全為empty,3行4列

8.構造指定型別和區間的陣列的方法

1.np.arange()：用array創建連續陣列，

a = np.arange(1,10,2)# 創建1到10的資料，步長=2

2.np.linspace()：用linspace創建線段形資料，

a = np,linspace(1,10,20) #開始端1，結束端10，分割成20個等間距的資料 

9.取最大/小值、平均值等常用引數值的方法

1.np.max()：取最大值，

a = np.array([[1,2],[3,4]])
max = np.max(a,axis=0)

2.np.min()：取最小值，

min = np.min(a,axis=1)

3.np.mean()：取矩陣的平均值，

mean = np.mean(a)

4.np.argmax()：取矩陣中最大元素的索引，

max_index = np.argmax(a)

5.np.argmin()：取矩陣中最小元素的索引，

min_index = np.ragmin(a)

10.Numpy陣列之間的運演算法則的使用方法

1.加減法的計算：陣列對應位置的元素相加減計算得到，

# 兩個陣列，維度相同
a = np.array([10, 20, 30, 401]) 
b = np.arange (4)
c = a+b
c1 = a-b

# 兩個陣列，維度不同（通過Numpy的廣播機制實作計算）
aa = np.array([[1, 2, 3, 4],[11,22,33,44]]) 
bb = np.arange (4)
c = aa+bb

2.乘除法的計算：陣列對應位置的元素乘除計算得到，

d = np.array([[1, 2],
              [3, 4]])
e = np.arange(1, 8, 2).reshape((2, 2))
f = d*e #對應元素相乘
g = d/e #對應元素相除，因為是int64型別所以類似于2/3=0

3.平方、三角函式的計算：陣列對應位置的元素進行計算得到，

a = np.array([10, 20, 30, 40])
b = np.arange(4)
c2 = b**2  # 平方
c3 = 10*np.sin(a)  #　sin函式

4.邏輯運算：陣列對應位置的元素進行邏輯運算得到，

c4 = b<3
c5 = b==3

5.矩陣相乘：采用線性代數中的矩陣乘法規則進行運算得到，

d = np.array([[1, 2],[3, 4]])
e = np.arange(1, 8, 2).reshape((2, 2))
np.dot(d, e) # 等價于d.dot(e)

11.Numpy陣列屬性方法總結

基本屬性
a.dtype	陣列元素型別 float32,uint8,…
a.shape	陣列形狀 (m,n,o,…)
a.size	陣列元素數
a.itemsize	每個元素占位元組數
a.nbytes	所有元素占的位元組
a.ndim	陣列維度

形狀相關
a.flat	所有元素的迭代器
a.flatten()	回傳一個1維陣列的復制
a.ravel()	回傳一個1維陣列，高效
a.resize(new_size)	改變形狀
a.swapaxes(axis1, axis2)	交換兩個維度的位置
a.transpose(*axex)	交換所有維度的位置
a.T	轉置，a.transpose()
a.squeeze()	去除所有長度為1的維度

填充復制
a.copy()	回傳陣列的一個復制
a.fill(value)	將陣列的元組設定為特定值

轉化
a.tolist()	將陣列轉化為串列
a.tostring()	轉換為字串
a.astype(dtype)	轉化為指定型別
a.byteswap(False)	轉換大小位元組序
a.view(type_or_dtype)	生成一個使用相同記憶體，但使用不同的表示方法的陣列

復數
a.imag	虛部
a.real	實部
a.conjugate()	復共軛
a.conj()	復共軛（縮寫）

保存
a.dump(file)	將二進制資料存在file中
a.dump()	將二進制資料表示成字串
a.tofile(fid, sep="",format="%s")	格式化ASCⅡ碼寫入檔案

查找排序
a.nonzero()	回傳所有非零元素的索引
a.sort(axis=-1)	沿某個軸排序
a.argsort(axis=-1)	沿某個軸，回傳按排序的索引
a.searchsorted(b)	回傳將b中元素插入a后能保持有序的索引值

元素數學操作
a.clip(low, high)	將數值限制在一定范圍內
a.round(decimals=0)	近似到指定精度
a.cumsum(axis=None)	累加和
a.cumprod(axis=None)	累乘積

約簡操作
a.sum(axis=None)	求和
a.prod(axis=None)	求積
a.min(axis=None)	最小值
a.max(axis=None)	最大值
a.argmin(axis=None)	最小值索引
a.argmax(axis=None)	最大值索引
a.ptp(axis=None)	最大值減最小值
a.mean(axis=None)	平均值
a.std(axis=None)	標準差
a.var(axis=None)	方差
a.any(axis=None)	只要有一個不為0，回傳真，邏輯或
a.all(axis=None)	所有都不為0，回傳真，邏輯與

Matplotlib精煉總結

【Tips】：建議使用Matplotlib的時候，采用Notebook以獲得更好的可視化互動效果，

1.Matlpoylib繪制圖形屬性的基礎方法

1.添加標題-title，matplotlib.pyplot 物件中有個 title() 可以設定表格的標題，

import numpy as np
import matplotlib.pyplot as plt
# 顯示中文
plt.rcParams['font.sans-serif'] = [u'SimHei']
plt.rcParams['axes.unicode_minus'] = False
%matplotlib inline
x=np.arange(0,10)
plt.title('這是一個示例標題')
plt.plot(x,x*x)
plt.show()

2.添加文字-text，設定坐標和文字，可以使用 matplotlib.pyplot 物件中 text() 介面，其中第一、二個引數來設定坐標，第三個引數是設定顯示文本內容，

import numpy as np
import matplotlib.pyplot as plt
# 顯示中文
plt.rcParams['font.sans-serif'] = [u'SimHei']
plt.rcParams['axes.unicode_minus'] = False
%matplotlib inline
x=np.arange(-10,11,1)
y=x*x
plt.plot(x,y)
plt.title('這是一個示例標題')
# 添加文字
plt.text(-2.5,30,'function y=x*x')
plt.show()

3.添加注釋-annotate，annotate() 介面可以在圖中增加注釋說明其中：

• xy 引數：備注的坐標點
• xytext 引數：備注文字的坐標(默認為xy的位置)
• arrowprops 引數：在 xy 和 xytext 之間繪制一個箭頭

import numpy as np
import matplotlib.pyplot as plt
# 顯示中文
plt.rcParams['font.sans-serif'] = [u'SimHei']
plt.rcParams['axes.unicode_minus'] = False
%matplotlib inline
x=np.arange(-10,11,1)
y=x*x
plt.title('這是一個示例標題')
plt.plot(x,y)
# 添加注釋
plt.annotate('這是一個示例注釋',xy=(0,1),xytext=(-2,22),arrowprops={'headwidth':10,'facecolor':'r'})
plt.show()

4.設定坐標軸名稱-xlabel/ylabel,二維坐標圖形中，需要在橫軸和豎軸注明名稱以及數量單位，設定坐標軸名稱使用的介面是 xlabel() 和 ylable()，

import numpy as np
import matplotlib.pyplot as plt
# 顯示中文
plt.rcParams['font.sans-serif'] = [u'SimHei']
plt.rcParams['axes.unicode_minus'] = False
%matplotlib inline
x=np.arange(1,20)
plt.xlabel('示例x軸')
plt.ylabel('示例y軸')
plt.plot(x,x*x)
plt.show()

5.添加圖例-legend,當線條過多時，我們設定不同顏色來區分不同線條，因此，需要對不同顏色線條做下標注，我們實用 legend() 介面來實作，

import numpy as np
import matplotlib.pyplot as plt
# 顯示中文
plt.rcParams['font.sans-serif'] = [u'SimHei']
plt.rcParams['axes.unicode_minus'] = False
%matplotlib inline
plt.plot(x,x)
plt.plot(x,x*2)
plt.plot(x,x*3)
plt.plot(x,x*4)
# 直接傳入legend
plt.legend(['生活','顏值','作業','金錢'])
plt.show()

6.調整顏色-color,傳顏色引數，使用 plot() 中的 color 屬性來設定，color 支持以下幾種方式，

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
x=np.arange(1,5)
#顏色的幾種方式
plt.plot(x,color='g')
plt.plot(x+1,color='0.5')
plt.plot(x+2,color='#FF00FF')
plt.plot(x+3,color=(0.1,0.2,0.3))
plt.show()

7.切換線條樣式-marker,如果想改變線條的樣式，我們可以使用修改 plot() 繪圖介面中 mark 引數，具體實作效果：

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
x=np.arange(1,5)
plt.plot(x,marker='o')
plt.plot(x+1,marker='>')
plt.plot(x+2,marker='s')
plt.show()

其中 marker 支持的型別：

8.顯示網格-grid,grid() 介面可以用來設定背景圖為網格，

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
x='a','b','c','d'
y=[15,30,45,10]
plt.grid()
# 也可以設定顏色、線條寬度、線條樣式
# plt.grid(color='g',linewidth='1',linestyle='-.')
plt.plot(x,y)
plt.show()

9.調整坐標軸刻度-locator_params,坐標圖的刻度我們可以使用 locator_params 介面來調整顯示顆粒，

• 同時調整 x 軸和 y 軸：plt.locator_params(nbins=20)

• 只調整 x 軸：plt.locator_params(‘'x',nbins=20)

• 只調整 y 軸：plt.locator_params(‘'y',nbins=20)

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
x=np.arange(0,30,1)
plt.plot(x,x)
# x軸和y軸分別顯示20個
plt.locator_params(nbins=20)
plt.show()

10.調整坐標軸范圍-axis/xlim/ylim,分別如下：

• axis：[0,5,0,10]，x從0到5，y從0到10

• xlim：對應引數有xmin和xmax，分別能調整最大值最小值

• ylim：同xlim用法

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
x=np.arange(0,30,1)
plt.plot(x,x*x)
#顯示坐標軸，plt.axis(),4個數字分別代表x軸和y軸的最小坐標，最大坐標
#調整x為10到25
plt.xlim(xmin=10,xmax=25)
plt.plot(x,x*x)
plt.show()

11.調整日期自適應-autofmt_xdate，有時候顯示日期會重疊在一起，非常不友好，呼叫plt.gcf().autofmt_xdate()，將自動調整角度，

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline
x=pd.date_range('2020/01/01',periods=30)
y=np.arange(0,30,1)
plt.plot(x,y)
plt.gcf().autofmt_xdate()
plt.show()

12.切換樣式-plt.style.use，matplotlib支持多種樣式，可以通過plt.style.use切換樣式，例如：plt.style.use(‘ggplot’)輸入plt.style.available 可以查看所有的樣式，

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.patches as mptaches
%matplotlib inline
plt.style.use('ggplot')
# 新建4個子圖
fig,axes=plt.subplots(2,2)
ax1,ax2,ax3,ax4=axes.ravel()
# 第一個圖
x,y=np.random.normal(size=(2,100))
ax1.plot(x,y,'o')
# 第二個圖
x=np.arange(0,10)
y=np.arange(0,10)
colors=plt.rcParams['axes.prop_cycle']
length=np.linspace(0,10,len(colors))
for s in length:
    ax2.plot(x,y+s,'-')
# 第三個圖
x=np.arange(5)
y1,y2,y3=np.random.randint(1,25,size=(3,5))
width=0.25
ax3.bar(x,y1,width)
ax3.bar(x+width,y2,width)
ax3.bar(x+2*width,y3,width)
# 第四個圖
for i,color in enumerate(colors):
    xy=np.random.normal(size=2)
ax4.add_patch(plt.Circle(xy,radius=0.3,color=color['color']))
ax4.axis('equal')
plt.show()

2.Matplotlib繪制2D、3D線形圖的方法

線形圖的意義是觀察資料的變化特征，使用之前請務必明確這一點！

1.繪制2D折線圖的方法：

首先，將需要的包載入到 notebook 中：

%matplotlib inline
import matplotlib.pyplot as plt
plt.style.use('seaborn-whitegrid')
import numpy as np

然后，需要從創建圖形和維度開始，圖形和維度可以使用下面規則進行創建：

• plt.figure()：在 Matplotlib 中，圖形（類plt.Figure的一個實體）可以被認為是一個包括所有維度、影像、文本和標簽物件的容器，
• plt.axes()：維度（類plt.Axes的一個實體）就是一個有邊界的格子包括刻度和標簽，最侄訓有我們畫在上面的圖表元素，
• plt.plot()：將資料繪制在圖表上，通過指定color關鍵字引數可以調整顏色（color=‘blue’ 、‘g’ 、’#FFDD44’、‘0.75’），通過linestyle關鍵字引數可以指定線條的風格，
• plt.xlim(xmin, xmax)：調整x坐標軸的范圍，
• plt.ylim(ymin, ymax)： 調整y坐標軸的范圍，
• plt.axis([xmin, xmax, ymin, ymax])：可以在一個函式呼叫中就完成 x 軸和 y 軸范圍的設定，
• plt.xlabel(): 設定x坐標軸的標簽，
• plt.ylabel(): 設定y坐標軸的標簽，

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-np.pi, np.pi, 100)
y = np.sin(x)
linear_y = 0.2 * x + 0.1

plt.figure(figsize = (8, 6)) 

plt.plot(x, y)
plt.plot(x, linear_y, color = "red", linestyle = '--') 

plt.title('y = sin(x) and y = 0.2x + 0.1')
plt.xlabel('x') 
plt.ylabel('y') 
plt.xlim(-np.pi, np.pi)
plt.ylim(-1, 1)

# plt.xticks(np.linspace(-np.pi, np.pi, 5))
x_value_range = np.linspace(-np.pi, np.pi, 5)
x_value_strs = [r'$\pi$', r'$-\frac{\pi}{2}$', r'$0$', r'$\frac{\pi}{2}$', r'$\pi$']
plt.xticks(x_value_range, x_value_strs)

ax = plt.gca() # 獲取坐標軸
ax.spines['right'].set_color('none') # 隱藏上方和右方的坐標軸
ax.spines['top'].set_color('none')

# 設定左方和下方坐標軸的位置
ax.spines['bottom'].set_position(('data', 0)) # 將下方的坐標軸設定到y = 0的位置
ax.spines['left'].set_position(('data', 0)) # 將左方的坐標軸設定到 x = 0 的位置

plt.show() # 顯示影像

2.繪制3D折線圖的方法：

import numpy as np
import matplotlib.pyplot as plt
fig = plt.figure()
ax = plt.axes(projection='3d')
theta = np.linspace(-4 * np.pi, 4 * np.pi, 100)
z = np.linspace(-2, 2, 100)
r = z ** 2 + 1
x = r * np.sin(theta)
y = r * np.cos(theta)
ax.plot(x, y, z)
mpl_toolkits.mplot3d.art3d.Line3D object at 0x095412C8>]
plt.show()

3.Matplotlib繪制2D、3D散點圖的方法

散點圖的意義是觀察不同資料的分布特征，使用之前請務必明確這一點！

1.繪制2D散點圖的方法：

不像折線圖，圖中的點連接起來組成連線，散點圖中的點都是獨立分布的點狀、圓圈或其他形狀，首先將需要用到的圖表工具和函式匯入到 notebook 中：

%matplotlib inline
import matplotlib.pyplot as plt
plt.style.use('seaborn-whitegrid')
import numpy as np

繪制散點圖的方法是使用plt.scatter函式，它的使用方法和plt.plot類似：

plt.scatter(x, y, marker='o')

為了更好的查看重疊的結果，還可以使用alpha關鍵字引數對點的透明度進行了調整，如果(x,y)隸屬不同的類別，那么可通設定對應的colors陣列進行不同類別顏色的配置：

import numpy as np
import matplotlib.pyplot as plt
N = 50
x = np.random.rand(N)
y = np.random.rand(N)
colors = np.random.rand(N)
area = np.pi * (15 * np.random.rand(N))**2
plt.scatter(x, y, s = area,c = colors, alpha = 0.8)
plt.show()

有的時候柱狀圖會出現在x軸的倆側，方便進行比較，代碼實作如下：

import numpy as np
import matplotlib.pyplot as plt

plt.figure(figsize = (16, 12))
n = 12
x = np.arange(n) # 按順序生成從12以內的數字
y1 = (1 - x / float(n)) * np.random.uniform(0.5, 1.0, n)
y2 = (1 - x / float(n)) * np.random.uniform(0.5, 1.0, n)

# 設定柱狀圖的顏色以及邊界顏色
#+y表示在x軸的上方 -y表示在x軸的下方
plt.bar(x, +y1, facecolor = '#9999ff', edgecolor = 'white')
plt.bar(x, -y2, facecolor = '#ff9999', edgecolor = 'white')

plt.xlim(-0.5, n) # 設定x軸的范圍，
plt.xticks(()) # 可以通過設定刻度為空，消除刻度
plt.ylim(-1.25, 1.25) # 設定y軸的范圍
plt.yticks(())

# plt.text()在影像中寫入文本，設定位置，設定文本，ha設定水平方向對其方式，va設定垂直方向對齊方式
for x1, y in zip(x, y2):
    plt.text(x1, -y - 0.05, '%.2f' % y, ha = 'center', va = 'top')
for x1, y in zip(x, y1):
    plt.text(x1, y + 0.05, '%.2f' % y, ha = 'center', va = 'bottom')
plt.show()

2.繪制3D散點圖的方法：

fig = plt.figure()
ax = plt.axes(projection='3d')
for mark,start, end in (['o', 10, 20], ['^', 5, 30]):
     xs = np.random.choice(np.arange(23, 32), 50)
     ys = np.random.choice(np.arange(0, 100), 50)
     zs = np.random.choice(np.arange(start, end), 50)
     ax.scatter(xs, ys, zs, marker=mark)
plt.show()

4.Matplotlib繪制2D、3D直方圖的方法

線形圖的意義是觀察不同屬性值的統計頻率特征，使用之前請務必明確這一點！

1.繪制2D直方圖的方法：

首先需要將需要用的包匯入 notebook：

%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt
plt.style.use('seaborn-white')

data = np.random.randn(1000)

1.1繪制單圖的情況：

plt.hist(data)

1.2繪制多圖的情況：

x1 = np.random.normal(0, 0.8, 1000)
x2 = np.random.normal(-2, 1, 1000)
x3 = np.random.normal(3, 2, 1000)

kwargs = dict(histtype='stepfilled', alpha=0.3, density=True, bins=40)

plt.hist(x1, **kwargs)
plt.hist(x2, **kwargs)
plt.hist(x3, **kwargs)

1.3如果只是需要計算直方圖的數值（即每個桶的資料點數量）而不是展示影像，np.histogram()函式可以完成這個目標：

counts, bin_edges = np.histogram(data, bins=5)
print(counts)

2.繪制3D柱狀圖的方法：

fig = plt.figure()
ax = plt.axes(projection='3d')
yticks = [3, 2, 1]
for i in yticks:
    x = np.arange(10)
    y = np.random.rand(10)
    ax.bar(x, y, zs=i, zdir='y')

plt.show()

5.Matplotlib繪制2D、3D餅圖的方法

1.繪制2D餅圖的方法：

from matplotlib import pyplot as plt 

#調節圖形大小，寬，高
plt.figure(figsize=(6,9))
#定義餅狀圖的標簽，標簽是串列
labels = [u'第一部分',u'第二部分',u'第三部分']
#每個標簽占多大，會自動去算百分比
sizes = [60,30,10]
colors = ['red','yellowgreen','lightskyblue']
#將某部分爆炸出來， 使用括號，將第一塊分割出來，數值的大小是分割出來的與其他兩塊的間隙
explode = (0.05,0,0)

patches,l_text,p_text = plt.pie(sizes,explode=explode,labels=labels,colors=colors,
                                labeldistance = 1.1,autopct = '%3.1f%%',shadow = False,
                                startangle = 90,pctdistance = 0.6)

#labeldistance，文本的位置離遠點有多遠，1.1指1.1倍半徑的位置
#autopct，圓里面的文本格式，%3.1f%%表示小數有三位，整數有一位的浮點數
#shadow，餅是否有陰影
#startangle，起始角度，0，表示從0開始逆時針轉，為第一塊，一般選擇從90度開始比較好看
#pctdistance，百分比的text離圓心的距離
#patches, l_texts, p_texts，為了得到餅圖的回傳值，p_texts餅圖內部文本的，l_texts餅圖外label的文本

#改變文本的大小
#方法是把每一個text遍歷，呼叫set_size方法設定它的屬性
for t in l_text:
    t.set_size=(30)
for t in p_text:
    t.set_size=(20)
# 設定x，y軸刻度一致，這樣餅圖才能是圓的
plt.axis('equal')
plt.legend()
plt.show()

2.繪制3D餅圖的方法：

import matplotlib.pyplot as plt

# defining labels 
genus = ['Bacteroides', 'Lachnospira', 'Roseburia', 'Blautia']

# portion covered by each label 
slices = [3, 7, 8, 6]

# color for each label 
colors = ['r', 'b', 'g', 'y']

# plotting the pie chart 
plt.pie(slices, labels=genus, colors=colors,
        startangle=110, shadow=True, explode=(0.05, 0.05, 0.1, 0.05),
        radius=1.0, autopct='%1.1f%%')

# plotting legend 
plt.legend()

# showing the plot 
plt.show() 

6.Matplolit繪制2D、3D熱圖的方法

1.繪制2D熱圖的方法：

在matplotlib中，imshow方法用于繪制熱圖，基本用法如下：

import matplotlib.pyplot as plt
import numpy as np
np.random.seed(123456789)
data = np.random.rand(25).reshape(5, 5)
plt.imshow(data)
plt.colorbar()

imshow方法常用的引數如下:

• cmap：cmap是colormap的簡稱，用于指定漸變色，默認的值為viridis, 在matplotlib中，內置了一系列的漸變色，例如："plt.imshow(data, cmap='Greens') "，
• aspect：aspect用于指定熱圖的單元格的大小，默認值為equal,此時單元格用于是一個方塊，當設定為auto時，會根據畫布的大小動態調整單元格的大小，例如："plt.imshow(data, aspect='auto')"，
• vmin和vmax：vmin和vmax引數用于限定數值的范圍，只將vmin和vmax之間的值進行映射，例如："plt.imshow(data, vmin=-0.8, vmax=0.8)"，
• extent：extent引數指定熱圖x軸和y軸的極值，取值為一個長度為4的元組或串列，其中，前兩個數值對應x軸的最小值和最大值，后兩個引數對應y軸的最小值和最大值， 例如："plt.imshow(data, extent=(-0.5, 4.5, 4.5, -0.5))"，

plt.imshow(data)
plt.xlim(-1, 5)
plt.ylim(5, -1)
plt.colorbar()

3.繪制3D熱圖的方法：

fig = plt.figure()
ax = plt.axes(projection='3d')
X = np.arange(-5, 5, 0.25)
Y = np.arange(-5, 5, 0.25)
X, Y = np.meshgrid(X, Y)
R = np.sqrt(X ** 2 + Y ** 2)
Z = np.sin(R)
ax.plot_surface(X, Y, Z, cmap = 'RdBu')
plt.show()

7.Matplotlib繪制動態圖效果的方法

在實際應用中， 希望觀察到資料的變化程序而不僅僅是最終的結果，例如股票的實時變化、各國家疫情人數動態變化等， 在Matplotlib庫中有一個子庫animation，該庫下定義了多種用于繪制動態效果圖的類，例如FuncAnimation，ArtistAnimation等，我們這里主要介紹FuncAnimation的使用，該類通過重復呼叫某個功能函式從而實作動態繪圖效果，在功能函式中會對圖進行一些修改，只要呼叫時間間隔足夠短，給人的感覺就是圖在動態變化，創建FuncAnimation物件時，需要傳遞的主要引數及其含義如下：

• fig：用于顯示動態效果的畫布，即Figure物件；
• unc：函式名，重復呼叫的功能函式；
• frames：每一幀資料，通常是可迭代物件，依次取出每一個資料傳遞給功能函式；
• init_func：初始函式，用于執行初始化操作；
• fargs：傳遞給功能函式的額外引數；
• save_count：保存計數，默認為100；
• interval：重復呼叫功能函式的間隔時間，單位為毫秒，默認為200；
• repeat_delay：影片結束后，重復執行影片的間隔時間，單位為毫秒；
• repeat：影片執行結束后，是否重復，默認為True；
• blit：是否更新所有點，即更新所有點還是僅更新變化的點，默認為False；
• cache_frame_data：是否快取資料，默認為True；

sinx()函式的動態圖顯示：

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation


fig = plt.figure(figsize=(10, 5))  # 創建圖
plt.rcParams["font.family"] = "FangSong"  # 支持中文顯示
# 為了可以觀察到整體效果，設定了X軸和Y軸的取值范圍，如果不設定取值范圍，程式會根據繪圖的資料自動調整X軸和Y軸的取值范圍
plt.ylim(-12, 12)  # Y軸取值范圍
plt.yticks([-12 + 2 * i for i in range(13)], [-12 + 2 * i for i in range(13)])  # Y軸刻度
plt.xlim(0, 2 * np.pi)  # X軸取值范圍
plt.xticks([0.5 * i for i in range(14)], [0.5 * i for i in range(14)])  # X軸刻度
plt.title("函式 y = 10 * sin(x) 在[0,2Π]區間的曲線")   # 標題
plt.xlabel("X軸")  # X軸標簽
plt.ylabel("Y軸")  # Y軸標簽
x, y = [], []  # 用于保存繪圖資料，最開始時什么都沒有，默認為空



def update(n):  # 更新函式
    x.append(n)  # 添加X軸坐標
    y.append(10 * np.sin(n))  # 添加Y軸坐標
    plt.plot(x, y, "r--")  # 繪制折線圖


ani = FuncAnimation(fig, update, frames=np.arange(0, 2 * np.pi, 0.1), interval=50, blit=False, repeat=False)  # 創建影片效果,frames引數是一個可迭代物件，程式執行時，會依次取出該物件中的元素，然后傳遞給update函式
plt.show()  # 顯示圖片

正弦曲線和余弦曲線交叉的動態圖顯示：

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation


fig, ax = plt.subplots()  # 創建畫布和繪圖區
ax.set_axis_off()  # 不顯示坐標軸
x = np.arange(0, 2 * np.pi, 0.01)  # 生成X軸坐標序列
line1, = ax.plot(x, np.sin(x))  # 獲取折線圖物件，逗號不可少，如果沒有逗號，得到的是元組
line2, = ax.plot(x, np.cos(x))  # 獲取折線圖物件，逗號不可少


def update(n):  # 動態更新函式
    line1.set_ydata(np.sin(x + n / 10.0))  # 改變線條y的坐標值
    line2.set_ydata(np.cos(x + n / 10.0))  # 改變線條y的坐標值


ani = FuncAnimation(fig, update, frames=100, interval=50, blit=False, repeat=False)  # 創建影片效果
plt.show()  # 顯示圖