Pandas統計分析中（數據計算、數據格式化、數據分組統計、數據移位、數據轉換、數據合並、數據導出）

• 本篇博文來自《Python數據分析從入門到精通》_明日科技編著
• 相信經過第3章的學習，您已經了解Pandas了，那麼本章開始進行Pandas進階，對Pandas相關技術進一步加深講解，主要包括數據計算、數據格式化，以及應用非常廣泛的數據分組統計、數據位移、數據轉換、數據合並、數據導出和日期數據的處理，時間序列等。
• 對於本章的學習，可能存在一定難度，建議讀者彈性學習，內容有一定的選擇性，對於短時間無法理解的內容可以先放一放，重要的是多練習、多時間，重復學習是快速提升編程技能的階梯。

4.1 數據計算

• Pandas提供了大量的數據計算函數，可以實現求和、求均值、求最大值、求最小值、求中位數、求眾數、求方差、標准差等，從而使得數據統計變得簡單高效。

4.1.1 求和（sum()函數）

• 在Python中通過調用DataFrame對象的sum()函數實現行/列數據的求和運算，語法如下：

DataFrame.sum(axis=None,skipna=None,level=None,numeric_only=None,min_count=0,**kwargs)

• 參數說明：
  – axis:axis=1表示行，axis=0表示列，默認值為None（無）。
  – skipna:布爾型，表示計算結果是否排除NaN/Null值，默認值為None。

NaN表示非數值。在進行數據處理、數據計算時，Pandas會為缺少的值自動分配NaN值。

• level：表示索引層級，默認值為None
• numeric_only:僅數字，布爾型，默認值為None
• min_count:表示執行操作所需的數目，整型，默認值為0
• **kwargs:要傳遞給函數的附加關鍵字參數
• 返回值：返回Series對象或DataFrame對象。行或列求和數據。
• 首先，創建一組DataFrame類型的數據。包括語文、數學和英語三科的成績：

import pandas as pd
data = [[110,105,99],[105,88,115],[109,120,130]]
index = [1,2,3]
columns = ['語文','數學','英語']
df = pd.DataFrame(data=data, index=index, columns=columns)
df

• 下面使用sum()函數計算三科的總成績，代碼如下：

df['總成績']=df.sum(axis=1)
df

4.1.2 求均值（mean()函數)

• 在Python中通過調用DataFrame對象的mean（）函數實現行/列數據平均值運算，語法如下：

DataFrame.mean(axis=None,skipna=None,level=None,numeric_only=None,**kwargs)

• 參數說明：
  – axis:axis=1表示行，axis=0表示列，默認值為None（無）。
  – skipna:布爾型，表示計算結果是否排除NaN/Null值，默認值為None。
  – level：表示索引層級，默認值為None
  – numeric_only:僅數字，布爾型，默認值為None
  – **kwargs:要傳遞給函數的附加關鍵字參數
  – 返回值：返回Series對象或DataFrame對象。
• 計算語文、數學和英語三科的平均值：

import pandas as pd
data = [[110,105,99],[105,88,115],[109,120,130],[112,115]]
index = [1,2,3,4]
columns = ['語文','數學','英語']
df = pd.DataFrame(data=data, index=index, columns=columns)
df

new=df.mean()
#增加一行數據（語文、數學和英語的平均值,忽略索引）
df=df.append(new,ignore_index=True)
df

• 從運行結果看，語文平均分109，數學平均分107，英語平均分114.667

4.1.3 求最大值（max()函數）

• 在Python中通過調用DataFrame對象的max()函數實現行/列數據最大值運算，語法如下：

DataFrame.max(axis=None,skipna=None,level=None,numeric_only=None,**kwargs)

• 參數說明：
  – axis:axis=1表示行，axis=0表示列，默認值為None（無）。
  – skipna:布爾型，表示計算結果是否排除NaN/Null值，默認值為None。
  – level：表示索引層級，默認值為None
  – numeric_only:僅數字，布爾型，默認值為None
  – **kwargs:要傳遞給函數的附加關鍵字參數
  – 返回值：返回Series對象或DataFrame對象
• 計算語文、數學和英語三科的最大值：

new=df.max()
#增加一行數據（語文、數學和英語的最大值,忽略索引）
df=df.append(new,ignore_index=True)
df

4.1.4 求最小值（min()函數）

• 在Python中通過調用DataFrame對象的min()函數實現行/列數據最小值運算，語法如下：

DataFrame.min(axis=None,skipna=None,level=None,numeric_only=None,**kwargs)

• 參數說明：
  – axis:axis=1表示行，axis=0表示列，默認值為None（無）。
  – skipna:布爾型，表示計算結果是否排除NaN/Null值，默認值為None。
  – level：表示索引層級，默認值為None
  – numeric_only:僅數字，布爾型，默認值為None
  – **kwargs:要傳遞給函數的附加關鍵字參數
  – 返回值：返回Series對象或DataFrame對象。
• 計算語文、數學和英語三科的最小值：

new=df.min()
#增加一行數據（語文、數學和英語的最小值,忽略索引）
df=df.append(new,ignore_index=True)
df

4.1.5 求中位數（median()函數）

• 在Python中通過調用DataFrame對象的median()函數實現中位數的計算，語法如下：

DataFrame.median(axis=None,skipna=None,level=None,numeric_only=None,**kwargs)

• 參數說明：
  – axis:axis=1表示行，axis=0表示列，默認值為None（無）。
  – skipna:布爾型，表示計算結果是否排除NaN/Null值，默認值為None。
  – level：表示索引層級，默認值為None
  – numeric_only:僅數字，布爾型，默認值為None
  – **kwargs:要傳遞給函數的附加關鍵字參數
  – 返回值：返回Series對象或DataFrame對象。
• 計算語文、數學和英語三科的中位數：

import pandas as pd
data = [[110,120,110],[130,130,130],[130,120,130]]
columns = ['語文','數學','英語']
df = pd.DataFrame(data=data,columns=columns)
new=df.median()
#增加一行數據（語文、數學和英語的中位數,忽略索引）
df=df.append(new,ignore_index=True)
df

4.1.6 求眾數（model()函數）

• 眾數就是一組數據中出現最多的數稱為眾數，它代表了數據的一般水平。
• 在Python中通過調用DataFrame對象的mode()函數求眾數，語法如下：

DataFrame.mode(axis=0,numeric_only=False,dropna=True)

• 參數說明：
  – axis:axis=1表示行，axis=0表示列，默認值為None（無）。
  – numeric_only:僅數字，布爾型，默認值為None
  – dropna:是否刪除缺失值，布爾型，默認值為True。
  – 返回值：返回Series對象或DataFrame對象。
• 計算語文、數學和英語三科的眾數：

import pandas as pd
data = [[110,120,110],[130,130,130],[130,120,130]]
columns = ['語文','數學','英語']
df = pd.DataFrame(data=data,columns=columns)
df

new=df.mode() #計算三科成績的眾數
#df.mode(axis=1) #每一行的眾數
#df['數學'].mode() #“數學”的眾數
#增加一行數據（語文、數學和英語的中位數,忽略索引）
df=df.append(new,ignore_index=True)
df

4.1.7 求方差（var()函數）

• 方差用於衡量一組數據的離散程度，即各組數據與它們的平均數的差的平方，那麼我們用這個結果衡量這組數據的波動大小，並把它叫做這組數據的方差，方差越小越穩定。通過方差可以了解以下這個問題的波動性。
• 在Python中通過調用DataFrame對象的var()函數求方差，語法如下：

DataFrame.var(axis=None,skipna=None,level=None,ddof=1,numeric_only=None,**kwargs)

• 參數說明：
  – axis:axis=1表示行，axis=0表示列，默認值為None（無）。
  – skipna:布爾型，表示計算結果是否排除NaN/Null值，默認值為None。
  – level：表示索引層級，默認值為None
  – ddof：整型，默認值值為1。自由度，計算中使用的除數是N-ddof，其中N表示元素的數量。
  – numeric_only:僅數字，布爾型，默認值為None
  – **kwargs:要傳遞給函數的附加關鍵字參數
  – 返回值：返回Series對象或DataFrame對象。
• 計算“小黑”和“小白”物理成績的方差，程序代碼如下：

import pandas as pd
import numpy as np
data = [[110,113,102,105,108],[118,98,119,85,118]]
index=['小黑','小白']
columns = ['物理1','物理2','物理3','物理4','物理5']
df = pd.DataFrame(data=data,index=index,columns=columns)
df.var(axis=1)

• 從運行結果得知：小黑的物理成績波動較小，發揮更穩定。這裡需要注意的是，Pandas中計算的方差為無偏樣本方差（即方差和/樣本數-1），NumPy中計算的方差就是樣本方差本身（即方差和/樣本數）。

4.1.8 標准差（數據標准化std()函數）

• 在Python中通過調用DataFrame對象的std()函數求標准差，語法如下：

DataFrame.std(axis=None,skipna=None,level=None,ddof=1,numeric_only=None,**kwargs)

• 參數說明：
  – axis:axis=1表示行，axis=0表示列，默認值為None（無）。
  – skipna:布爾型，表示計算結果是否排除NaN/Null值，默認值為None。
  – level：表示索引層級，默認值為None
  – ddof：整型，默認值值為1。自由度，計算中使用的除數是N-ddof，其中N表示元素的數量。
  – numeric_only:僅數字，布爾型，默認值為None
  – **kwargs:要傳遞給函數的附加關鍵字參數
  – 返回值：返回Series對象或DataFrame對象。
• 使用std()函數計算標准差，程序代碼如下：

import pandas as pd
import numpy as np
data = [[110,120,110],[130,130,130],[130,120,130]]
columns = ['語文','數學','英語']
df = pd.DataFrame(data=data,columns=columns)
new = df.std()
#增加一行數據（語文、數學和英語的標准差,忽略索引）
df=df.append(new,ignore_index=True)
df

4.1.9 求分位數（quantile()函數）

• 分位數也稱分位點，它以概率依據將數據分割成幾個等份，常用的有中位數（即二分位數）、四分位數、百分位數等。分位數是數據分析中常用的一個統計量，經過抽樣得到的一個樣本值。例如，經常會聽到老師說：“這次考試竟然有20%的同學不及格！”，那麼這句話就體現了分位數的作用。在Python中通過DataFrame對象的quantile（）函數求分位數，語法如下：

DataFrame.quantile(q=0.5,axis=0,numeric_only=True,interpolation='linear')

• 參數說明：
  – q:浮點型或數組，默認為0.5（50%分位數），其值為0~1
  – axis:axis=1表示行，axis=0表示列，默認值為None（無）。
  – numeric_only:僅數字，布爾型，默認值為True
  – interpolation:內插值，可選參數，用於指定要使用的插值方法，當期望的分位數為數據點i~j時，線性：i + (j-i)x分數，其中分數是指被i和j包圍的小數部分。較低：i。較高：j。最近：i或j二者最近者為准。中點：（i+j)/2
  – 返回值：返回Series對象或DataFrame對象。
• 通過分位數淘汰35%的學生，首先使用quantile()函數計算35%的分位數，然後將學生成績與分位數比較，篩選小於等於分位數的學生，程序代碼如下：

import pandas as pd
#創建DataFrame數據（數學成績）
data = [120,89,98,78,65,102,112,56,79,45]
columns = ['數學']
df = pd.DataFrame(data=data,columns=columns)
#計算35%的分位數
x=df['數學'].quantile(0.35)
#輸出淘汰學生
df[df['數學']<=x]

• 從運行結果可知：即將被淘汰的學生有四名，分數分別是78、65、56和45。
• 如果參數numeric_only=False，將計算日期、時間和時間增量數據的分位數，程序代碼如下：

import pandas as pd
df = pd.DataFrame({
'A': [1, 2],
'B': [pd.Timestamp('2019'),
pd.Timestamp('2020')],
'C': [pd.Timedelta('1 days'),
pd.Timedelta('2 days')]})
print(df.quantile(0.5, numeric_only=False))

4.2 數據格式化

• 在進行數據處理時，尤其是在計算中應用求均值（mean()函數）後，發現結果中的小數位數增加了許多。此時就需要對數據進行格式化，以增加數據的可讀性。例如，保留小數點位數、百分號、千位分隔符等。

4.2.1 設置小數位數

• 設置小數位數主要使用DataFrame對象的round()函數，該函數可以實現四捨五入，而它的decimals參數則用於設置保留小數的位數，設置後數據類型不會發生變化，依然是浮點型。語法如下：

DataFrame.round(decimals=0,*args,**kwargs)

• decimals：每一列四捨五入的小數位數，整型、字典或Series對象。如果是整數，則將每一列四捨五入到相同的位置。否則，將字典和Series捨入到可變數目的位置；如果小數是類似於字典的，那麼列名應該在鍵中；如果小數是級數，列名應該在索引中。沒有包含在小數中的任何列都將保持原樣。非輸入列的小數元素將被忽略。
• *args：附加的關鍵字參數
• **kwargs：附加的關鍵字參數
• 返回值：返回DataFrame對象
• 使用round()函數四捨五入保留小數位數，程序代碼如下：

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.random([5, 5]),
columns=['A1', 'A2', 'A3','A4','A5'])
df

df.loc[:,'A1':'A3']=df.round(2)#將A1至A3列保留小數點後兩位
df

df.round({
'A1': 1, 'A3': 2}) #A1列保留小數點後一位、A3列保留小數點後兩位

s1 = pd.Series([1, 0, 2], index=['A1', 'A2', 'A3']) #A1保留1位小數，A2列保留0位小數，A3列保留2位小數。
df.round(s1) #設置Series對象小數位數

• 當然，保留小數位數也可以用自定義函數，例如，為DataFrame對象中的各個浮點值保留兩位小數，主要代碼如下：

df.applymap(lambda x: '%.2f'%x) #通過自定義函數設置小數位數，返回類型為object

經過自定義函數處理過的數據將不再是浮點型而是對象型，如果後續計算需要數據，則應先進行數據類型轉換。

4.2.2 設置百分比

• 在數據分析過程中，有時需要百分比數據。那麼，利用自定義函數將數據進行格式化處理，處理後的數據就可以從浮點型轉換成指定小數位數的百分比數據，主要使用apply()函數與format()函數。
• 將A列的數據格式轉化為百分比數據，程序代碼如下：

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.random([5, 5]),
columns=['A1', 'A2', 'A3','A4','A5'])
df['百分比']=df['A1'].apply(lambda x: format(x,'.0%')) #整列保留0位小數
print(df)
df['百分比']=df['A1'].apply(lambda x: format(x,'.2%')) #整列保留兩位小數
print(df)
df['百分比']=df['A1'].map(lambda x:'{:.0%}'.format(x)) #整列保留0位小數，也可以使用map函數
print(df)

4.2.3 設置千位分隔符

• 由於業務需要，有時需要將數據格式化為帶千位分隔符的數據。那麼，處理後的數據將不再是浮點型而是對象型。
• 將圖書館碼洋格式化為帶千位分隔符的數據，程序代碼如下：

import pandas as pd
data = [['零基礎學Python','1月',49768889],['零基礎學Python','2月',11777775],['零基礎學Python','3月',13799990]]
columns = ['圖書','月份','碼洋']
df = pd.DataFrame(data=data, columns=columns)
df['碼洋']=df['碼洋'].apply(lambda x:format(int(x),','))
print(df)

設置千位分隔符後，對於程序來說，這些數據將不再是數值型，而是數字和逗號組成的字符串，如果由於程序需要再變成數值型就會很麻煩，因此設置千位分隔符要慎重。

4.3 數據分組統計

• 本節主要介紹分組統計函數groupby()的各種應用。

4.3.1 分組統計groupby()函數

• 對數據進行分組統計，主要使用DataFrame對象的groupyby()函數，其功能如下：
• （1）根據給定的條件將數據拆分成組
• （2）每個組都可以獨立應用函數（如求和函數sum（）、求平均值函數mean()等）
• （3）將結果合並到一個數據結構中
• groupby()函數用於將數據按照一列或多列進行分組，一般與計算函數結合使用，實現數據的分組統計，語法如下：

DataFrame.group(by=None,axis=0,level=None,as_index=True,sort=True,group_keys=True,squeeze=False,observed=False)

• 參數說明：
  – by:映射、字典或Series對象、數組、標簽或標簽列表。如果by是一個函數，則對象索引的每個值都調用它；如果傳遞了一個字典或Series對象，則使用該字典或Series對象值來確定組；如果傳遞了數組ndarray，則按原樣使用這些值來確定組。
  – axis：axis=1表示行，axis=0表示列。默認值為0
  – level：表示索引層級，默認值為None（無）
  – as_index:布爾型，默認值為True，返回以組標簽為索引的對象
  – sort：對組進行排序，布爾型，默認值為True
  – group_keys:布爾型，默認值為True，調用apply()函數時，將分組的鍵添加到索引以標識片段
  – squeeze：布爾型，默認值為False。如果可能，減少返回類型的維度；否則返回一致類型
  – observed:當以石斑魚分類時，才會使用該參數。如果參數值為True，則僅顯示分類石斑魚的觀測值；如果參數值為False，則顯示石斑魚的所有值
  – 返回值：返回DataFrameGroupBy，返回包含有關組的信息的groupby對象。

1.按照一列分組統計

• 按照圖書"一級分類"對訂單數據進行分組統計求和，程序代碼如下：

import pandas as pd #導入pandas模塊
df=pd.read_csv('JD.csv',encoding='gbk')
df

#抽取數據
df1=df[['一級分類','7天點擊量','訂單預定']]
df1

df1=df1.groupby('一級分類').sum() #分組統計求和
df1

2.按照多列分組統計

• 多列分組統計，以列表形式指定列。
• 按照圖書"一級分類"和"二級分類"對訂單數據進行分組統計求和，主要代碼如下：

#抽取數據
df1=df[['一級分類','二級分類','7天點擊量','訂單預定']]
df1

df2=df1.groupby(['一級分類','二級分類']).sum() #分組統計求和
df2

3.分組並按指定列進行數據計算

• 前面介紹的分組統計是按照所有列進行匯總計算的，那麼如何按照指定類匯總計算呢？
• 統計各編程語言的7天點擊量，首先按"二級分類"分組，然後抽取"7天點擊量"列並對該列進行求和運算，主要代碼如下：

#抽取數據
df1=df[['二級分類','7天點擊量']]
df1

df1=df1.groupby('二級分類')['7天點擊量'].sum()
df1

4.3.2 對分組數據進行迭代

迭代一級分類的訂單數據

• 通過for循環對分組統計數據進行迭代（遍歷分組數據）。
• 按照"一級分類"分組，並輸出每一分類中的訂單數據，主要代碼如下：

import pandas as pd #導入pandas模塊
df=pd.read_csv('JD.csv',encoding='gbk')
#抽取數據
df1=df[['一級分類','7天點擊量','訂單預定']]
df1

for name, group in df1.groupby('一級分類'):
print(name)
print(group)

數據庫
一級分類 7天點擊量 訂單預定
25 數據庫 58 2
27 數據庫 128 13
移動開發
一級分類 7天點擊量 訂單預定
10 移動開發 85 4
19 移動開發 32 1
24 移動開發 85 2
28 移動開發 59 0
編程語言與程序設計
一級分類 7天點擊量 訂單預定
0 編程語言與程序設計 35 1
1 編程語言與程序設計 49 0
2 編程語言與程序設計 51 2
3 編程語言與程序設計 64 1
4 編程語言與程序設計 26 0
5 編程語言與程序設計 60 1
6 編程語言與程序設計 227 11
8 編程語言與程序設計 122 3
9 編程語言與程序設計 111 5
11 編程語言與程序設計 165 5
12 編程語言與程序設計 131 1
13 編程語言與程序設計 149 10
15 編程語言與程序設計 1139 79
16 編程語言與程序設計 125 1
18 編程語言與程序設計 149 4
20 編程語言與程序設計 52 1
21 編程語言與程序設計 597 25
22 編程語言與程序設計 474 15
23 編程語言與程序設計 83 3
26 編程語言與程序設計 132 8
29 編程語言與程序設計 27 2
30 編程語言與程序設計 239 13
31 編程語言與程序設計 45 1
32 編程語言與程序設計 28 0
網頁制作/Web技術
一級分類 7天點擊量 訂單預定
7 網頁制作/Web技術 100 7
14 網頁制作/Web技術 188 8
17 網頁制作/Web技術 57 0

• 上述代碼中，name是groupby()函數中"一級分類"的值，group是分組後的數據。如果groupby()函數對多列進行分組，那麼需要在for循環中指定多列。

迭代兩級分類的訂單數據

• 迭代"一級分類"和"二級分類"的訂單數據，主要代碼如下：

import pandas as pd #導入pandas模塊
df=pd.read_csv('JD.csv',encoding='gbk')
#抽取數據
df2=df[['一級分類','二級分類','7天點擊量','訂單預定']]
df2

for (key1,key2), group in df2.groupby(['一級分類','二級分類']):
print(key1,key2)
print(group)

數據庫 Oracle
一級分類 二級分類 7天點擊量 訂單預定
25 數據庫 Oracle 58 2
數據庫 SQL
一級分類 二級分類 7天點擊量 訂單預定
27 數據庫 SQL 128 13
移動開發 Android
一級分類 二級分類 7天點擊量 訂單預定
10 移動開發 Android 85 4
19 移動開發 Android 32 1
24 移動開發 Android 85 2
28 移動開發 Android 59 0
編程語言與程序設計 ASP.NET
一級分類 二級分類 7天點擊量 訂單預定
0 編程語言與程序設計 ASP.NET 35 1
20 編程語言與程序設計 ASP.NET 52 1
編程語言與程序設計 C#
一級分類 二級分類 7天點擊量 訂單預定
5 編程語言與程序設計 C# 60 1
8 編程語言與程序設計 C# 122 3
26 編程語言與程序設計 C# 132 8
編程語言與程序設計 C++/C語言
一級分類 二級分類 7天點擊量 訂單預定
6 編程語言與程序設計 C++/C語言 227 11
9 編程語言與程序設計 C++/C語言 111 5
11 編程語言與程序設計 C++/C語言 165 5
18 編程語言與程序設計 C++/C語言 149 4
29 編程語言與程序設計 C++/C語言 27 2
31 編程語言與程序設計 C++/C語言 45 1
編程語言與程序設計 JSP/JavaWeb
一級分類 二級分類 7天點擊量 訂單預定
4 編程語言與程序設計 JSP/JavaWeb 26 0
12 編程語言與程序設計 JSP/JavaWeb 131 1
編程語言與程序設計 Java
一級分類 二級分類 7天點擊量 訂單預定
2 編程語言與程序設計 Java 51 2
13 編程語言與程序設計 Java 149 10
16 編程語言與程序設計 Java 125 1
23 編程語言與程序設計 Java 83 3
編程語言與程序設計 PHP
一級分類 二級分類 7天點擊量 訂單預定
1 編程語言與程序設計 PHP 49 0
3 編程語言與程序設計 PHP 64 1
編程語言與程序設計 Python
一級分類 二級分類 7天點擊量 訂單預定
15 編程語言與程序設計 Python 1139 79
21 編程語言與程序設計 Python 597 25
22 編程語言與程序設計 Python 474 15
30 編程語言與程序設計 Python 239 13
編程語言與程序設計 Visual Basic
一級分類 二級分類 7天點擊量 訂單預定
32 編程語言與程序設計 Visual Basic 28 0
網頁制作/Web技術 HTML
一級分類 二級分類 7天點擊量 訂單預定
14 網頁制作/Web技術 HTML 188 8
網頁制作/Web技術 JavaScript
一級分類 二級分類 7天點擊量 訂單預定
7 網頁制作/Web技術 JavaScript 100 7
網頁制作/Web技術 WEB前端
一級分類 二級分類 7天點擊量 訂單預定
17 網頁制作/Web技術 WEB前端 57 0

4.3.3 對分組的某列或多列使用聚合函數（agg()函數）

• Python也可以實現像SQL中的分組聚合運算操作，主要通過groupby()函數和agg()函數實現。

對分組統計結果使用聚合函數

• 按"一級分類"分組統計"7天點擊量""訂單預定"的平均值和總和，主要代碼如下：

import pandas as pd #導入pandas模塊
df=pd.read_csv('JD.csv',encoding='gbk')
#抽取數據
df1=df[['一級分類','7天點擊量','訂單預定']]
df1

df1.groupby('一級分類').agg(['mean','sum'])

針對不同的列使用不同的聚合函數

• 在上述示例中，還可以針對不同的列使用不同的聚合函數。例如，按“一級分類”分組統計“7天點擊量”的平均值和總和、“訂單預定”的總和，主要代碼如下：

df1.groupby('一級分類').agg({
'7天點擊量':['mean','sum'],'訂單預定':['sum']})

通過自定義函數實現分組統計

• 通過自定義函數實現數據分組統計。例如，統計1月份銷售數據中，購買次數最多的產品，主要代碼如下：

import pandas as pd #導入pandas模塊
df=pd.read_excel('1月.xlsx') #導入Excel文件
df

#x是“寶貝標題”對應的列
#value_counts()函數用於Series對象中的每個值進行計數並且排序
max1 = lambda x: x.value_counts(dropna=False).index[0]
max1.__name__ = "購買次數最多"
df1=df.agg({
'寶貝標題': [max1],
'數量': ['sum', 'mean'],
'買家實際支付金額': ['sum', 'mean']})
df1

4.3.4 通過字典和Series對象進行分組統計

1.通過字典進行分組統計

• 首先創建字典建立對應關系，然後將字典傳遞給groupby()函數從而實現數據分組統計。
• 統計各地區銷量，業務要求將“北京”“上海”“廣州”3個一線城市放在一起統計。那麼首先創建一個字典將“北京出庫銷量”“上海出庫銷量”“廣州出庫銷量”都對應“北上廣”；然後使用groupy()函數進行分組統計。主要代碼如下：

import pandas as pd #導入pandas模塊
#解決數據輸出時列名不對齊的問題
pd.set_option('display.unicode.east_asian_width', True)
df=pd.read_csv('JD.csv',encoding='gbk') #導入csv文件
df=df.set_index(['商品名稱'])
df

#創建字典
mapping={
'北京出庫銷量':'北上廣','上海出庫銷量':'北上廣',
'廣州出庫銷量':'北上廣','成都出庫銷量':'成都',
'武漢出庫銷量':'武漢','西安出庫銷量':'西安'}
df1=df.groupby(mapping,axis=1).sum()
df1

2.通過Series對象進行分組統計

• 通過Series對象進行分組統計與字典的方法類似。
• 首先，創建一個Series對象，主要代碼如下：

import pandas as pd #導入pandas模塊
df=pd.read_csv('JD.csv',encoding='gbk') #導入csv文件
df=df.set_index(['商品名稱'])
data={
'北京出庫銷量':'北上廣','上海出庫銷量':'北上廣',
'廣州出庫銷量':'北上廣','成都出庫銷量':'成都',
'武漢出庫銷量':'武漢','西安出庫銷量':'西安',}
s1=pd.Series(data)
s1

df1=df.groupby(s1,axis=1).sum()
df1

4.4 數據移位

• 什麼是數據移位？例如，分析數據時需要上一條數據怎麼辦？當然是移動至上一條，從而得到該條數據，這就是數據移位。在Pandas中，使用shift()方法可以獲取上一條數據，該方法返回向下移位後的結果，從而得到上一條結果。例如，獲取某學生上一次英語成績，如圖4.21所示。
  
• shift()方法是一個非常有用的方法，用於數據位移與其他方法結合，能實現很多難以想象的功能，語法格式如下：

DataFrame.shift(periods=1,freq=1,axis=0)

• 參數說明：
  – periods:表示移動的幅度，可以是正數，也可以是負數，默認值位1，1表示移動一次。注意這裡移動的都是數據，而索引是不移動的，移動之後是沒有對應值的，賦值為NaN.
  – freq:可選參數，默認值為None，只適用於時間序列，如果這個參數存在，那麼會按照參數值移動時間索引，而數據值沒有發生變化。
  – axis：axis=1表示行，axis=0表示列。默認值為0
• 使用shift（）統計學生每周英語測試成績的升降情況，程序代碼如下：

import pandas as pd
data = [110,105,99,120,115]
index=[1,2,3,4,5]
df = pd.DataFrame(data=data,index=index,columns=['英語'])
df['升降']=df['英語']-df['英語'].shift()
print(df)

• 這裡再擴張下，通過10次周測來看下學生整體英語成績的升降情況：

import pandas as pd
import matplotlib.pylab as plt
data = [110,105,99,120,115,112,118,120,109,113]
index=[1,2,3,4,5,6,7,8,9,10]
df = pd.DataFrame(data=data,index=index,columns=['英語'])
df['升降']=df['英語']-df['英語'].shift()
print(df)
df['升降'].plot(style='b')
plt.show()

• shift()方法還有很多方面的應用。例如這樣一個常見一個情景：分析股票數據，獲取的股票數據中有股票的實時價格，也有每日的收盤價“close”，此時需要將實時價格和上一個工作日的收盤價進行對比，那麼通過shift()方法就可以輕松解決。shift()方法還可以應用於時間序列，剛興趣的讀者可以再學習完後續章節進行嘗試和探索。

4.5 數據轉換

• 數據轉換一般包括一列數據轉換為多列數據、行列數據、DataFrame轉換為字典、DataFrame轉換為列表和DataFrame轉換為元組等。

4.5.1 一列數據轉換為多列數據

• 一列數據轉換為多列數據的情況在日常工作中經常會用到，從各種系統中導出的訂單號、名稱、地址很多都是復合組成的（即由多項內容組成），那麼，這些列在查找、統計、合並時就沒辦法使用，需要將它們拆分開。例如，地址信息由省市區街道門牌號等信息組成，如果按省、市或區統計數據，就需要將地址信息中的“省”“市”“區”拆分開，此時就應用到了一列數據轉多列數據，通常使用以下方法。

1.split()方法

• Pandas的DataFrame對象中是split()內置方法可以實現分隔字符串，語法如下：

Series.str.split(pat=None,n=1,expand=False)

• 參數說明：
  – pat:字符串、符號或正則表達式，字符串分割的依據，默認以空格分割字符串。
  – n：整型，分割次數，默認值為-1，0 或-1都將返回所有拆分。
  – expand：布爾型，分割後的結果是否轉換為DataFrame，默認值是False。
  – 返回值：系列、索引、DataFrame或多重索引
• 首先，我們來看一組淘寶銷售訂單數據(部分數據)，如圖4.25所示。
  
• 從圖4.25中數據得知：不僅“收貨地址”是復合的，“寶貝標題”也是復合的，即由多種產品組成。
• 使用split()方法先對“收貨地址”進行分割，程序代碼如下：

import pandas as pd
#導入Excel文件指定列數據（“買家會員名”和“收貨地址”）
df = pd.read_excel('mrbooks.xls',usecols=['買家會員名','收貨地址'])
df

#使用split方法分割“收貨地址”
series=df['收貨地址'].str.split(' ',expand=True)
df['省']=series[0]
df['市']=series[1]
df['區']=series[2]
df1=df.head()
df1

2.join()方法與split()方法結合

以逗號分隔多種產品數據。

• 通過join()方法與split()方法結合，以逗號“，”分隔“寶貝標題”，主要代碼如下：

import pandas as pd
#導入Excel文件部分列數據（“買家會員名”和“寶貝標題”）
df = pd.read_excel('mrbooks.xls',usecols=['買家會員名','寶貝標題'])
df

#使用join方法和split方法分割“寶貝標題”
df = df.join(df['寶貝標題'].str.split('，', expand=True))
df1=df.head()
df1

• 從運行結果得知：“寶貝標題”中含有多種產品的數據被拆分開，這樣操作便於日後對每種產品的銷量進行統計。
• 將DataFrame中的tuple(元組)類型數據分隔成多列。

對元組數據進行分隔

• 首先，創建一組包含元組的數據，程序代碼如下：

import pandas as pd
df = pd.DataFrame({
'a':[1,2,3,4,5], 'b':[(1,2), (3,4),(5,6),(7,8),(9,10)]})
df

# apply函數分割元組
df[['b1', 'b2']] = df['b'].apply(pd.Series)
df

#或者join方法結合apply函數分割元組
df= df.join(df['b'].apply(pd.Series))
df

4.5.2 行列轉換

• 在Pandas處理數據過程中，有時需要對數據進行行列轉換或重排，主要使用stack()方法、unstack()方法和pivot()方法，下面介紹這3種方法的應用。

1.stack()方法

• stack（）方法用於將原來的列索引轉換成最內層的行索引，轉換效果對比示意圖如圖4.31所示。
  
• stack()方法的語法如下：

DataFrame.stack(level=-1,dropna=True)

• 參數說明：
  – level：索引層級，定義為一個索引或標簽，或索引或標簽列表，默認值是-1
  – dropna：布爾型，默認值是True
  – 返回值：DataFrame對象或Series對象
• 將學生英語成績進行行列轉換，程序代碼如下：

import pandas as pd
df=pd.read_excel('grade.xls') #導入Excel文件
df

df = df.set_index(['班級','序號']) #設置2級索引“班級”和“序號”
df

df = df.stack()
df

2.unstack()方法

• unstack()方法與stack()方法相反，它是stack()方法的逆操作，即將最內層的行索引轉換成列索引，轉換效果對比如圖4.32所示。

• unstack()方法的語法如下：
  

DataFrame.unstack(level=-1,fill_value=None)

• 參數說明：
  – level：索引層級，定義為一個索引或標簽，或索引或標簽列表，默認值為-1
  – fill_value：整型、字符串或字典，如果unstack()方法產生丟失值，則用這個值替換NaN
  – 返回值：DataFrame對象或Series對象。
• 同樣轉換學生成績表，主要代碼如下：

import pandas as pd
#設置數據顯示的列數和寬度
pd.set_option('display.max_columns',500)
pd.set_option('display.width',1000)
#解決數據輸出時列名不對齊的問題
pd.set_option('display.unicode.east_asian_width', True)
df=pd.read_excel('grade.xls',sheet_name='英語2') #導入Excel文件
df

df = df.set_index(['班級','序號','Unnamed: 2']) #設置多級索引
df

df.unstack()

• unstack()方法中有一個參數可以指定轉換第幾層索引，例如，unstack(0)就是把第一層索引轉換為列索引，默認是將最內側索引轉換為列索引。

3.pivot()方法

• pivot()方法針對列的值，即指定某列的值作為行索引，指定某列的值作為列索引，然後再指定哪些列作為索引對應的值。unstack()方法針對索引進行操作，pivot()方法針對值進行操作。但實際上，二者的功能往往可以互相實現。
• pivot()方法的語法如下：

DataFrame.pivot(index=None,columns=None,values=None)

• 參數說明：
  – index：字符串或對象，可選參數。列用於創建新DataFrame數據的索引。如果沒有，則使用現有索引
  – columns:字符串或對象，列用於創建新的DataFrame的列
  – values:列用於填充新DataFrame的值，如果未指定，則將使用所有剩余的列，結果將具有分層索引
  – 返回值：DataFrame對象或Series對象
• 使用pivot()方法轉換學生成績表，主要代碼如下：

import pandas as pd
df=pd.read_excel('grade.xls',sheet_name='英語3') #導入Excel文件
df

df1=df.pivot(index='序號',columns='班級',values='得分')
df1

4.5.3 DataFrame轉換為字典

• DataFrame轉換為字典主要使用DataFrame對象的to_dict()方法，以索引作為字典的鍵（key），以列作為字典的值（value）。例如，有一個DataFrame對象（索引為“類別”、列為“數量”），通過to_dict()方法就會生成一個字典，示意圖如圖4.34所示。如果DataFrame對象包含兩列，那麼to_dict()方法就會生成一個兩層的字典（dict）,第一層是列名作為字典的鍵（key），第二層以索引列的值作為字典的鍵（key），以列值作為字典的值（value）。
  
• 使用to_dict()方法將按“寶貝標題”分組統計後的部分數據轉換為字典，程序代碼如下：

import pandas as pd
df = pd.read_excel('mrbooks.xls')
df

mydict=df1.to_dict()
for i,j in mydict.items():
print(i,':\t', j)

4.5.4 DataFrame轉換為列表

• DataFrame轉換為列表主要使用DataFrame對象的tolist()方法。
• 將淘寶銷售數據中的“買家會員名”轉換為列表，程序代碼如下：

import pandas as pd
df =pd.read_excel('mrbooks.xls')
df

df1=df[['買家會員名']].head()
df1

list1=df1['買家會員名'].values.tolist()
for s in list1:
print(s)

4.5.5 DataFrame轉換為元組

• DataFrame轉換為元組，首先通過循環語句按行讀取DataFrame數據，然後使用元組函數tuple()將其轉換為元組。
• 將Excel表中的人物關系部分數據轉換為元組，程序代碼如下：

import pandas as pd
df = pd.read_excel('fl4.xls')
df

df1=df[['label1','label2']].head()
df1

tuples = [tuple(x) for x in df1.values]
for t in tuples:
print(t)

4.5.6 Excel轉換為HTML網頁格式

• 日常工作中，有時會涉及財務數據的處理，而Excel應用最為廣泛，但是對於展示數據來說，Excel並不友好，如果你想用其他格式的文件來向用戶展示，那麼，HTML網頁格式是不錯的選擇。首先使用read_excel()方法導入Excel文件，然後使用to_html()方法將DataFrame數據導出為HTML格式，這樣便實現了Excel轉換為HTML格式。
• 將淘寶部分訂單數據轉換為HTML網頁格式，效果如圖4.38所示。

import pandas as pd
df=pd.read_excel('mrbooks.xls',usecols=['買家會員名','寶貝標題']).head()
df.to_html('mrbooks.html',header = True,index = False,encoding='gbk') #編碼要也可能是utf8

4.6 數據合並

• DataFrame數據合並主要使用merge()方法和concat()方法。

4.6.1 數據合並（merge()方法）

• Pandas模塊的merge()方法是按照兩個DataFrame對象列名相同的列進行連接合並，兩個DataFrame對象必須具有同名的列。merge()方法的語法如下：

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

• 參數說明：
  – right:合並對象，DataFrame對象或Series對象
  – how：合並類型，參數值可以是left（左合並）、right(右合並)、outer（外部合並）或inner（內部合並），默認值為inner。各個值的說明如下： left：只使用來自左數據集的鍵，類似於SQL左外部鏈接，保留鍵的順序。right：只使用來自右數據集的鍵，類似於SQL左外部鏈接，保留鍵的順序。outer：只使用來自兩個數據集的鍵，類似於SQL左外部鏈接，按字典順序對鍵進行排序。inner：只使用來自兩個數據集的鍵的交集，類似於SQL左外部鏈接，保留左鍵的順序。
  – on:標簽、列表或數組，默認值為None。DataFrame對象連接的列或索引級別名稱。也可以是DataFrame對象長度的數組或數組列表。
  – left_on：標簽、列表或數組，默認值為None。要連接的左數據集的列或索引級名稱，也可以是左數據集長度的數組或數組列表。
  – right_on：標簽、列表或數組，默認值為None。要連接的右數據集的列或索引級名稱，也可以是左數據集長度的數組或數組列表。
  – left_index:布爾型，默認值為False。使用左數據集的索引作為連接鍵。如果是多重索引，則其他數據中的鍵數（索引或列數）必須匹配索引級別數。
  – right_index:布爾型，默認值為False。使用右數據集的索引作為連接鍵。
  – sort：布爾型，默認值為False，在合並結果中按字典順序對連接鍵進行排序。如果值為False，則連接鍵的順序取決於連接類型how參數。
  – suffixes：元組類型，默認值為(‘_x’,‘_y’)。當左側數據集和右側數據集的列名相同時，數據合並後將帶上’_x’和’_y’後綴。
  – copy：是否復制數據，默認值為True。如果值為False，則不復制數據。
  – indicator:布爾型或字符串，默認值為False。如果值為True，則添加一個列輸出名為_Merge的DataFrame對象，其中包含每一行的信息。如果是字符串，將向輸出的DataFrame對象中添加包含每一行信息的列，並將列命名為字符型的值。
  – validate:字符串，檢查合並數據是否為指定類型。可選參數，其值說明如下：one_to_one或“1:1”:檢查合並鍵在左、右數據集中是否都是唯一的。one_to_many或“1：m”：檢查合並鍵在左、右數據集中是否唯一。many_to_one或“m:1”:檢查合並鍵在右數據集中是否唯一。many_to_many或“m:m”:允許，但不檢查。
  – 返回值：DataFrame對象，兩個合並對象的數據集。

1.常規合並

• 假設一個DataFrame對象包含了學生的“語文”“數學”“英語”成績，而另一個DataFrame對象則包含了學生的“體育”成績，現將它們合並，示意圖如圖4.39所示。
  

合並學生成績表

import pandas as pd
df1 = pd.DataFrame({
'編號':['mr001','mr002','mr003'],
'語文':[110,105,109],
'數學':[105,88,120],
'英語':[99,115,130]})
df2 = pd.DataFrame({
'編號':['mr001','mr002','mr003'],
'體育':[34.5,39.7,38]})
df_merge=pd.merge(df1,df2,on='編號')
df_merge

通過索引合並數據

• 如果通過索引列合並，則需要設置right_index參數和left_index參數值為True。例如，上述舉例，通過列索引合並，主要代碼如下：

import pandas as pd
df1 = pd.DataFrame({
'編號':['mr001','mr002','mr003'],
'語文':[110,105,109],
'數學':[105,88,120],
'英語':[99,115,130]})
df2 = pd.DataFrame({
'編號':['mr001','mr002','mr003'],
'體育':[34.5,39.7,38]})
df_merge=pd.merge(df1,df2,left_index=True,right_index=True)
df_merge

圖4.41

對合並數據去重

• 從圖4.41中的運行結果得知，數據中存在重復列（如編號），如果不想要重復列，可以設置按指定列和列索引合並數據，主要代碼如下：

df_merge=pd.merge(df1,df2,on='編號',left_index=True,rith_index=True)

• 還可以通過how參數解決這一問題。例如，設置該參數值為left，就是讓df1保留所有的行列數據，df2則根據df1的行列進行補全，主要代碼如下：

df_merge=pd.merge(df1,df2,on='編號',how='left')

import pandas as pd
df1 = pd.DataFrame({
'編號':['mr001','mr002','mr003'],
'語文':[110,105,109],
'數學':[105,88,120],
'英語':[99,115,130]})
df2 = pd.DataFrame({
'編號':['mr001','mr002','mr003'],
'體育':[34.5,39.7,38]})
# df_merge=pd.merge(df1,df2,on='編號',left_index=True,right_index=True)
# df_merge
df_merge=pd.merge(df1,df2,on='編號',how='left')
df_merge

• 在jup中注釋部分代碼會報錯，運行結果如下：
  

2.多對一的數據合並

• 多對一是指兩個數據集（df1、df2）的共有列中的數據不是一對一的關系，例如，df1中的“編號”是唯一的，而df2中的“編號”由重復的編號，類似這種就是多對一的關系，示意圖如圖4.43所示。
  

根據共有列中的數據進行合並

• 根據共有列中的數據進行合並，df2根據df2的行列進行補全，程序代碼如下：

import pandas as pd
df1 = pd.DataFrame({
'編號':['mr001','mr002','mr003'],
'學生姓名':['明日同學','高猿員','錢多多']})
df2 = pd.DataFrame({
'編號':['mr001','mr001','mr003'],
'語文':[110,105,109],
'數學':[105,88,120],
'英語':[99,115,130],
'時間':['1月','2月','1月']})
df_merge=pd.merge(df1,df2,on='編號')
df_merge

3.多對多的數據合並

• 多對多是指兩個數據集（df1、df2）的共有列中的數據不全是一對一的關系，都有重復數據，例如“編號”，示意圖如圖4.45所示。
  

合並數據並相互補全

• 根據共有列中的數據進行合並，df2、df1相互補全，程序代碼如下：

import pandas as pd
df1 = pd.DataFrame({
'編號':['mr001','mr002','mr003','mr001','mr001'],
'體育':[34.5,39.7,38,33,35]})
df2 = pd.DataFrame({
'編號':['mr001','mr002','mr003','mr003','mr003'],
'語文':[110,105,109,110,108],
'數學':[105,88,120,123,119],
'英語':[99,115,130,109,128]})
df_merge=pd.merge(df1,df2)
df_merge

4.6.2 數據合並（concat()方法）

pandas.concat(objs,axis=0,join='outer',ignore_index:bool = False,keys=None,levels=None,names=None,verify_integrity:bool=False,sort:bool=False,copy:bool=True)

• 參數說明：
  – objs:Series、DataFrame或Panel對象的序列或映射。如果傳遞一個字典，則排序的鍵將用作鍵參數。
  – axis：axis=1表示行，axis=0表示列，默認值為0
  – join：值為inner（內連接）或outer（外連接），處理其他軸上的索引方式。默認值為outer
  – ignore_index：布爾值，默認值為False，保留索引，索引值為0，…，n-1。如果值為True，則忽略索引。
  – keys:序列，默認值為None。使用傳遞的鍵作為最外層構建層次索引。如果為多索引，應該使用元組。
  – levels：序列列表，默認值為None。用於構建MultiIndex的特定級別（唯一值）；否則，它們將從鍵推斷。
  – names：list列表，默認值為None。結果層次索引中的級別的名稱。
  – verify_integrity:布爾值，默認值為False。檢查新連接的軸是否包含重復項。
  – sort：布爾值，默認值為True（1.0.0以後版本默認值為False，即不排序）。如果連接為外連接（join=‘outer’），則對未對齊的非連接軸進行排序；如果連接為內連接（join=‘inner’），則該參數不起作用。
  – copy：是否復制數據，默認值為True，如果值為False，則不復制數據。
• 下面介紹concat()方法不同的合並方式，其中dfs代表合並後的DataFrame對象，df1、df2等代表單個DataFrame對象，result代表合並後的結果（DataFrame對象）。

1.相同字段的表首尾相接

• 表結構相同的數據將直接合並，表首尾相接，主要代碼如下：

dfs=[df1,df2,df3]
result=pd.concat(dfs)

• 例如，表df1、df2和df3結構相同，如圖4.47所示。合並後的效果如圖4.48所示。如果想要在合並數據時標記源數據來自哪張表，則需要在代碼中加入參數keys，例如表名分別為“1月”“二月”“三月”，合並後的效果如圖4.49所示。
  
• 主要代碼如下：

result=pd.concat(dfs,keys=['1月','2月','3月'])

2. 橫向表合並（行對齊）

• 當合並的數據列名稱不一致時，可以設置參數axis=1，concat()方法將按行對齊，然後將不同列名的兩組數據進行合並，缺失的數據用NaN填充，df1和df4合並前後效果如圖4.50和圖4.51所示。
  
• 主要代碼如下：

result=pd.concat([df1,df4],axis=1)

3.交叉合並

• 交叉合並，需要在代碼中加上join()參數，如果值為inner，結果是兩張表的交集；如果值為outer，結果是兩張表的並集。例如兩張表交集，表df1和df4合並前後的效果如圖4.52和圖4.53所示。
  
• 主要代碼如下：

result=pd.concat([df1,df4],axis=1,join="inner")

4.指定表對齊數據（行對齊）

• 如果指定參數join_axes，就可以指定根據哪張表來對齊數據。例如，根據df4對齊數據，就會保留表df4的數據，然後將表1的數據與之合並，行數不變，合並前後的效果與如圖4.54和圖4.55所示。
  
• 主要代碼如下：

result=pd.concat([df1,df4],axis=1,join_axes=[df4,index]

4.7 數據導出

4.7.1 導出為.xlsx文件

• 導出數據為Excel，主要使用DataFrame對象的to_excel()方法，語法如下：

DataFrame.to_excel(excel_writer,sheet_name='Sheet1',na_rep='',float_format=None,columns=None,header=True,index=True,index_label=None,startrow=0,startcol=0,engine=None,merge_cells=True,encoding=None,inf_rep='inf',verbose=True,freeze_panes=None)

• excel_writer:字符串或ExcelWriter對象。
• sheet_name：字符串，默認值為Sheet1，包含DataFrame的表的名稱
• na_rep:字符串，默認值為’'。缺失數據的表示方式
• float_format:字符串，默認值為None，格式化浮點數的字符串
• columns:序列，可選參數，要編輯的列
• header：布爾型或字符串列表，默認值為True。列名稱，如果給定字符串列表，則表示它是列名稱的別名
• index：布爾型，默認值為True，行名（索引）
• index_label：字符串或序列，默認值為None。如果需要，可以使用索引列的列標簽；如果沒有給出，標題和索引為True，則使用索引名稱；如果數據文件使用多重索引，則需要使用序列。
• startrow:指定從哪一行開始寫入數據
• startcol:指定從哪一列寫入數據
• engine：字符串，默認值為None，指定要使用的寫引擎，如openyxl或xlsxwriter。也可以通過io.excel.xlsx.writer、io.excel.xls.writer和io.excel.xlsx.writer進行設置。
• merge_cells：布爾型，默認值為True
• encoding：指定Excel文件的編碼格式，默認值為None
• inf_rep:字符串，默認值為“正”，表示無窮大
• verbose：布爾型，默認值為True。在錯誤日志中顯示更多信息
• freeze_panes:整數的元組，長度為2，默認值為None。指定要凍結的行列

將處理後的數據導出為Excel文件

• 將數據合並後的結果導出為Excel文件，主要代碼如下：

import pandas as pd
df1 = pd.DataFrame({
'編號':['mr001','mr002','mr003','mr001','mr001'],
'體育':[34.5,39.7,38,33,35]})
df2 = pd.DataFrame({
'編號':['mr001','mr002','mr003','mr003','mr003'],
'語文':[110,105,109,110,108],
'數學':[105,88,120,123,119],
'英語':[99,115,130,109,128]})
df_merge=pd.merge(df1,df2)
df_merge.to_excel('merge.xlsx')
df1.to_excel('df1.xlsx',sheet_name='df1')

4.7.2 導出為.csv文件

• 導出數據為.csv文件，主要使用DataFrame對象的to_csv方法，語法如下：

DataFrame.to_csv(path_or_buf=None,sep=',',na_rep='',float_format=None,columns=None,header=True,index=True,index_label=None,mode='w',encoding=None,compression='infer',quoting=None,quotechar="",line_terminator=None,chunksize=None,data_format=None,doublequote=True,escapechar=None,decimal='.',errors='strict')

• path_or_buf:要保存的路徑及文件名
• sep：分隔符，默認值為","
• na_rep:指定空值的輸出方式，默認值為空字符串
• float_format:浮點數的輸出方式，要用雙引號括起來
• columns:指定要導出的列，用列名列表表示，默認值為None
• header：是否輸出列名，默認值為True
• index：布爾型，默認值為True，行名（索引）
• index_label：索引列的列名，默認值為None
• mode：Python寫入模式，默認值為w
• encoding：編碼格式，默認值為utf8
• compression:壓縮模式，默認值為infer
• quoting:導出.csv文件是否用引號，默認值為0，表示不加雙引號；如果值為1，則每個字段都會加上引號，數值也會被當作字符串看待
• quotechar:引用字符，當quoting=1時可以指定引號字符為雙引號（“”）或單引號（‘’）
• line_terminator:換行符，默認值為\n
• chunksize:一次寫入.csv文件的行數，當DataFrame對象數據特別大時需要分批寫入
• data_format：日期輸出格式
• doublequote:是否添加雙引用符，默認值為True
• escapechar：設置轉義字符
• decimal:可識別十進制分隔符的字符
• errors：指定如何處理編碼和解碼錯誤，默認值為strict（嚴格的）

將處理後的數據導出為.csv文件

import pandas as pd
data = [['a',110,105,99],['b',105,88,115],['c',109,120,130],['d',112,115]]
index = [1,2,3,4]
columns = ['name','語文','數學','英語']
df = pd.DataFrame(data=data, index=index, columns=columns)
print(df)
#相對位置，保存在程序所在路徑下
df.to_csv('Result1.csv',encoding='gb2312')
#絕對位置
df.to_csv('d:\Result.csv',encoding='gb2312')
#分隔符。使用問號（?）分隔符分隔需要保存的數據
df.to_csv('Result2.csv',sep='?',encoding='gb2312')
#替換空值，缺失值保存為NA
df.to_csv('Result3.csv',na_rep='NA',encoding='gb2312')
#格式化數據，保留兩位小數
df.to_csv('Result4.csv',float_format='%.2f',encoding='gb2312')
#保留某列數據，保存索引列和name列
df.to_csv('Result5.csv',columns=['name'],encoding='gb2312')
#是否保留列名，不保留列名
df.to_csv('Result6.csv',header=0,encoding='gb2312')
#是否保留行索引，不保留行索引
df.to_csv('Result7.csv',index=0,encoding='gb2312')

4.7.3 導出多個Sheet

• 導出多個Sheet，應該先使用pd.ExcelWriter()方法打開一個Excel文件，然後再使用to_excel()方法導出指定的Sheet。

導處Excel中多個Sheet頁的數據

• 導出指定Sheet頁中的數據，主要代碼如下：

import pandas as pd
data = [['a',110,105,99],['b',105,88,115],['c',109,120,130],['d',112,115]]
index = [1,2,3,4]
columns = ['A','語文','數學','英語']
df1 = pd.DataFrame(data=data, index=index, columns=columns)
df1.to_excel('df1.xlsx',sheet_name='df1')
work=pd.ExcelWriter('df2.xlsx') #打開一個Excel文件
df1.to_excel(work,sheet_name='df2')
df1['A'].to_excel(work,sheet_name='df3')
work.save()