Python pandas用法

介紹
在Python中，pandas是基於NumPy陣列構建的，使資料預處理、清洗、分析工作變得更快更簡單。pandas是專門為處理表格和混雜資料設計的，而NumPy更適合處理統一的數值陣列資料。
使用下面格式約定，引入pandas包：

import pandas as pd

pandas有兩個主要資料結構：Series和DataFrame。

Series

Series是一種類似於一維陣列的物件，它由一組資料（各種NumPy資料型別）以及一組與之相關的數**據標籤（即索引）**組成，即index和values兩部分，可以通過索引的方式選取Series中的單個或一組值。

Series的建立

pd.Series(list,index=[ ])，第二個引數是Series中資料的索引，可以省略。

第一個引數可以是列表\ndarray

import numpy as np, pandas as pd
arr1 = np.arange(10)
s1 = pd.Series(arr1)
print(s1)   #由於我們沒有為資料指定索引，於是會自動建立一個0到N-1（N為資料的長度）的整數型索引
0    0
1    1
2    2
3    3
4    4
5    5
6    6
7    7
8    8
9    9

第一個引數可以是字典，字典的鍵將作為Series的索引
第一個引數可以是DataFrame中的某一行或某一列

Series型別的操作

Series型別索引、切片、運算的操作類似於ndarray，同樣的類似Python字典型別的操作，包括保留字in操作、使用.get()方法。
Series和ndarray之間的主要區別在於Series之間的操作會根據索引自動對齊資料。

DataFrame
DataFrame是一個表格型的資料型別，每列值型別可以不同，是最常用的pandas物件。DataFrame既有行索引也有列索引，它可以被看做由Series組成的字典（共用同一個索引）。DataFrame中的資料是以一個或多個二維塊存放的（而不是列表、字典或別的一維資料結構）。

DataFrame的建立

pd.DataFrame(data,columns = [ ],index = [ ])：columns和index為指定的列、行索引，並按照順序排列。

建立DataFrame最常用的是直接傳入一個由等長列表或NumPy陣列組成的字典，會自動加上行索引，字典的鍵會被當做列索引：

import pandas as pd
data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'],
        'year': [2000, 2001, 2002, 2001, 2002, 2003],
        'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}
df= pd.DataFrame(data)
In [45]: df
Out[45]: 
   pop   state  year
0  1.5    Ohio  2000
1  1.7    Ohio  2001
2  3.6    Ohio  2002
3  2.4  Nevada  2001
4  2.9  Nevada  2002
5  3.2  Nevada  2003

如果建立時指定了columns和index索引，則按照索引順序排列，並且如果傳入的列在資料中找不到，就會在結果中產生缺失值：

In [48]: df2 = pd.DataFrame(data, columns=['year', 'state', 'pop', 'debt'],
   ....:                       index=['one', 'two', 'three', 'four', 'five', 'six'])
In [49]: df2
Out[49]: 
       year   state  pop debt
one    2000    Ohio  1.5  NaN
two    2001    Ohio  1.7  NaN
three  2002    Ohio  3.6  NaN
four   2001  Nevada  2.4  NaN
five   2002  Nevada  2.9  NaN
six    2003  Nevada  3.2  NaN

另一種常見的建立DataFrame方式是使用巢狀字典，如果巢狀字典傳給DataFrame，pandas就會被解釋為外層字典的鍵作為列，內層字典鍵則作為行索引：

In [65]: pop = {'Nevada': {2001: 2.4, 2002: 2.9},
....:        'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}
In [66]: df3 = pd.DataFrame(pop)
In [67]: df3
Out[67]: 
      Nevada  Ohio
2000     NaN   1.5
2001     2.4   1.7
2002     2.9   3.6

DataFrame物件操作

• df.values：將DataFrame轉換為ndarray二維陣列，注意後面不加()。
• 通過類似字典標記的方式或屬性的方式，可以將DataFrame的列獲取為一個Series。
• 列可以通過賦值的方式進行修改。例如，我們可以給那個空的"debt"列賦上一個標量值或一組值。
• 將列表或陣列賦值給某個列時，其長度必須跟DataFrame的長度相匹配。如果賦值的是一個Series，就會精確匹配DataFrame的索引，所有的空位都將被填上缺失值。
• 為不存在的列賦值會建立出一個新列。關鍵字del用於刪除列。

```bash
import pandas as pd
data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'],
        'year': [2000, 2001, 2002, 2001, 2002, 2003],
        'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}
In [48]: df2 = pd.DataFrame(data, columns=['year', 'state', 'pop', 'debt'],
   ....:                       index=['one', 'two', 'three', 'four', 'five', 'six'])

In [50]: df2.columns
Out[50]: Index(['year', 'state', 'pop', 'debt'], dtype='object')
#通過類似字典標記的方式或屬性的方式，可以將DataFrame的列獲取為一個Series。
In [51]: df2['state']  #或者df2.state
Out[51]: 
one        Ohio
two        Ohio
three      Ohio
four     Nevada
five     Nevada
six      Nevada
Name: state, dtype: object
#列可以通過賦值的方式進行修改。例如，我們可以給那個空的"debt"列賦上一個標量值或一組值
In [54]: frame2['debt'] = 16.5
In [55]: frame2
Out[55]: 
       year   state  pop  debt
one    2000    Ohio  1.5  16.5
two    2001    Ohio  1.7  16.5
three  2002    Ohio  3.6  16.5
four   2001  Nevada  2.4  16.5
five   2002  Nevada  2.9  16.5
six    2003  Nevada  3.2  16.5
#將列表或陣列賦值給某個列時，其長度必須跟DataFrame的長度相匹配。如果賦值的是一個Series，就會精確匹配DataFrame的索引，所有的空位都將被填上缺失值
In [58]: val = pd.Series([-1.2, -1.5, -1.7], index=['two', 'four', 'five'])
In [59]: df2['debt'] = val
In [60]: df2
Out[60]: 
       year   state  pop  debt
one    2000    Ohio  1.5   16.5
two    2001    Ohio  1.7  -1.2
three  2002    Ohio  3.6   16.5
four   2001  Nevada  2.4  -1.5
five   2002  Nevada  2.9  -1.7
six    2003  Nevada  3.2   16.5
#為不存在的列賦值，會建立出一個新列
In [61]: df2['eastern'] = df2.state == 'Ohio'
In [62]: df2
Out[62]: 
       year   state  pop  debt  eastern
one    2000    Ohio  1.5   NaN     True
two    2001    Ohio  1.7  -1.2     True
three  2002    Ohio  3.6   NaN     True
four   2001  Nevada  2.4  -1.5    False
five   2002  Nevada  2.9  -1.7    False
six    2003  Nevada  3.2   NaN    False
#關鍵字del用於刪除列
In [63]: del df2['eastern']
In [64]: df2.columns
Out[64]: Index(['year', 'state', 'pop', 'debt'], dtype='object')

pandas的基本功能

資料索引：Series和DataFrame的索引是Index型別，Index物件是不可修改，可通過索引值或索引標籤獲取目標資料，也可通過索引使序列或資料框的計算、操作實現自動化對齊。索引型別index的常用方法：

• .append(idx)：連線另一個Index物件，產生新的Index物件
• .diff(idx)：計算差集，產生新的Index物件
• .intersection(idx)：計算交集
• .union(idx)：計算並集
• .delete(loc)：刪除loc位置處的元素
• .insert(loc,e)：在loc位置增加一個元素
  

重新索引：能夠改變、重排Series和DataFrame索引，會建立一個新物件，如果某個索引值當前不存在，就引入缺失值。
df.reindex(index, columns ,fill_value, method, limit, copy )：index/columns為新的行列自定義索引；fill_value為用於填充缺失位置的值；method為填充方法，ffill當前值向前填充，bfill向後填充；limit為最大填充量；copy 預設True，生成新的物件，False時，新舊相等不復制。

In [98]: frame = pd.DataFrame(np.arange(9).reshape((3, 3)),
   ....:                      index=['a', 'c', 'd'],columns=['Ohio', 'Texas', 'California'])
In [99]: frame
Out[99]: 
   Ohio  Texas  California
a     0      1           2
c     3      4           5
d     6      7           8

In [100]: frame2 = frame.reindex(['a', 'b', 'c', 'd'])
In [101]: frame2
Out[101]: 
   Ohio  Texas  California
a   0.0    1.0         2.0
b   NaN    NaN         NaN
c   3.0    4.0         5.0
d   6.0    7.0         8.0

刪除指定索引：預設返回的是一個新物件。
.drop()：能夠刪除Series和DataFrame指定行或列索引。
刪除一行或者一列時，用單引號指定索引，刪除多行時用列表指定索引。
如果刪除的是列索引，需要增加axis=1或axis='columns’作為引數。
增加inplace=True作為引數，可以就地修改物件，不會返回新的物件。

索引、選取和過濾
df.loc[行標籤，列標籤]：通過標籤查詢指定的資料，第一個值為行標籤，第二值為列標籤。當第二個引數為空時，查詢的是單個或多個行的所有列。如果查詢多個行、列的話，則兩個引數用列表表示。
df.iloc[行位置，列位置]：通過預設生成的數字索引查詢指定的資料。

In [128]: data = pd.DataFrame(np.arange(16).reshape((4, 4)),
   .....:                     index=['Ohio', 'Colorado', 'Utah', 'New York'],
   .....:                     columns=['one', 'two', 'three', 'four'])
​
In [129]: data
Out[129]: 
          one  two  three  four
Ohio        0    1      2     3
Colorado    4    5      6     7
Utah        8    9     10    11
New York   12   13     14    15
#df.loc選取第二行、第二三列
In [137]: data.loc['Colorado', ['two', 'three']]   
Out[137]: 
two      5
three    6
Name: Colorado, dtype: int64
#df.iloc選取第二行、第二三列
In [138]: data.iloc[1, [1, 2]]
Out[138]: 
two      5
three    6
Name: Colorado, dtype: int64

在pandas中，有多個方法可以選取和重新組合資料。對於DataFrame，表5-4進行了總結
表5-4 DataFrame的索引選項
算術運算：算術運算根據行列索引，對齊後運算，運算預設產生浮點數，對齊時缺項填充NaN (空值)。除了用±*/外，還可以用Series和DataFrame的算術方法，這些方法傳入fill_value引數時，可以填充預設值。比如df1.add(df2, fill_value = 1)：

比較運算只能比較相同索引的元素，不進行補齊。採用>< >= <= == !=等符號進行的比較運算，產生布林值。
排序 ：在排序時，任何缺失值預設都會被放到末尾
.sort_index(axis=0, ascending=True)：根據指定軸索引的值進行排序。預設軸axis=0, ascending=True，即預設根據0軸的索引值做升序排序。軸axis=1為根據1軸的索引值排序， ascending=False為降序。
在指定軸上根據數值進行排序，預設升序。
Series.sort_values(axis=0, ascending=True)：只能根據0軸的值排序。
DataFrame.sort_values(by, axis=0, ascending=True)，引數by為axis軸上的某個索引或索引列表。

pandas資料分析

統計分析、相關分析

適用於Series和DataFrame的基本統計分析函式：傳入axis='columns’或axis=1將會按行進行運算。
.describe()：針對各列的多個統計彙總，用統計學指標快速描述資料的概要。
.sum()：計算各列資料的和
.count()：非NaN值的數量
.mean( )/.median()：計算資料的算術平均值、算術中位數
.var()/.std()：計算資料的方差、標準差
.corr()/.cov()：計算相關係數矩陣、協方差矩陣，是通過引數對計算出來的。Series的corr方法用於計算兩個Series中重疊的、非NA的、按索引對齊的值的相關係數。DataFrame的corr和cov方法將以DataFrame的形式分別返回完整的相關係數或協方差矩陣。
.corrwith()：利用DataFrame的corrwith方法，可以計算其列或行跟另一個Series或DataFrame之間的相關係數。傳入一個Series將會返回一個相關係數值Series（針對各列進行計算），傳入一個DataFrame則會計算按列名配對的相關係數。
.min()/.max()：計算資料的最小值、最大值
.diff()：計算一階差分，對時間序列很有效
.mode()：計算眾數，返回頻數最高的那（幾）個
.mean()：計算均值
.quantile()：計算分位數（0到1）
.isin()：用於判斷向量化集合的成員資格，可用於過濾Series中或DataFrame列中資料的子集
適用於Series的基本統計分析函式，DataFrame[列名]返回的是一個Series型別。
.unique()：返回一個Series中的唯一值組成的陣列。
.value_counts()：計算一個Series中各值出現的頻率。
.argmin()/.argmax()：計算資料最大值、最小值所在位置的索引位置（自動索引）
.idxmin()/.idxmax()：計算資料最大值、最小值所在位置的索引（自定義索引）

分組

• DataFrame.groupby()：分組函式，使用方法參考https://blog.csdn.net/cymy001/article/details/78300900
• pandas.cut()：根據資料分析物件的特徵，按照一定的數值指標，把資料分析物件劃分為不同的區間部分來進行研究，以揭示其內在的聯絡和規律性。類似給成績設定優良中差，比如：0-59分為差，60-70分為中，71-80分為優秀等等。使用方法參考
  https://blog.csdn.net/weixin_39541558/article/details/80578529
  https://blog.csdn.net/missyougoon/article/details/83986511
  pandas讀寫文字格式的資料
  pandas提供了一些用於將表格型資料讀取為DataFrame物件的函式。下表對它們進行了總結，其中read_csv()、read_table()、to_csv()是用得最多的。
  
  工作中實際碰到的資料可能十分混亂，一些資料載入函式（尤其是read_csv）的引數非常多（read_csv有超過50個引數）。具體使用參考https://seancheney.gitbook.io/python-for-data-analysis-2nd/di-06-zhang-shu-ju-jia-zai-cun-chu-yu-wen-jian-ge-shi

用pandas來進行資料清洗和準備

在資料分析和建模的過程中，相當多的時間要用在資料準備上：載入、清理、轉換以及重塑。

處理缺失資料

在許多資料分析工作中，缺失資料是經常發生的。對於數值資料，pandas使用浮點值NaN（np.nan）表示缺失資料，也可將缺失值表示為NA（Python內建的None值）。

• .info()：檢視資料的資訊，包括每個欄位的名稱、非空數量、欄位的資料型別。
• .isnull()：返回一個同樣長度的值為布林型的物件（Series或DataFrame），表示哪些值是缺失的，.notnull()為其否定形式。

import pandas as pd
import numpy as np
In [10]: string_data = pd.Series(['aardvark', 'artichoke', np.nan, None])
In [11]: string_data
Out[11]:
0     aardvark
1    artichoke
2          NaN
3         None
dtype: object

In [14]: string_data.isnull()
Out[14]: 
0    False
1    False
2     True
3     True
dtype: bool

• .dropna()：刪除缺失資料。對於Series物件，dropna返回一個僅含非空資料和索引值的Series。對於DataFrame物件，dropna預設刪除含有缺失值的行；如果想刪除含有缺失值的列，需傳入axis = 1作為引數；如果想刪除全部為缺失值的行或者列，需傳入how='all’作為引數；如果想留下一部分缺失資料，需傳入thresh = n作為引數，表示每行至少n個非NA值。

import pandas as pd
import numpy as np
In [19]: data = pd.DataFrame([[1., 6.5, 3.], [1., NA, NA], [NA, NA, NA], [NA, 6.5, 3.]])
In [20]: data.dropna()
Out[22]: 
     0    1    2
0  1.0  6.5  3.0
#傳入how='all'將只丟棄全為NA的那些行：
In [23]: data.dropna(how='all')
Out[23]: 
     0    1    2
0  1.0  6.5  3.0
1  1.0  NaN  NaN
3  NaN  6.5  3.0

In [24]: data[4] = NA
In [25]: data
Out[25]: 
     0    1    2   4
0  1.0  6.5  3.0 NaN
1  1.0  NaN  NaN NaN
2  NaN  NaN  NaN NaN
3  NaN  6.5  3.0 NaN
#用這種方式丟棄列，只需傳入axis=1即可：
In [26]: data.dropna(axis=1, how='all')
Out[26]: 
     0    1    2
0  1.0  6.5  3.0
1  1.0  NaN  NaN
2  NaN  NaN  NaN
3  NaN  6.5  3.0
#假設你只想留下一部分觀測資料，可以用thresh引數實現此目的：
In [27]: df = pd.DataFrame(np.random.randn(7, 3))
In [28]: df.iloc[:4, 1] = NA
In [29]: df.iloc[:2, 2] = NA
In [30]: df
Out[30]: 
          0         1         2
0 -0.204708       NaN       NaN
1 -0.555730       NaN       NaN
2  0.092908       NaN  0.769023
3  1.246435       NaN -1.296221
4  0.274992  0.228913  1.352917
5  0.886429 -2.001637 -0.371843
6  1.669025 -0.438570 -0.539741

In [32]: df.dropna(thresh=2)
Out[32]: 
          0         1         2
2  0.092908       NaN  0.769023
3  1.246435       NaN -1.296221
4  0.274992  0.228913  1.352917
5  0.886429 -2.001637 -0.371843
6  1.669025 -0.438570 -0.539741

• .fillna(value,method,limit,inplace)：填充缺失值。value為用於填充的值（比如0、'a’等）或者是字典（比如{‘列’:1,‘列’:8,……}為指定列的缺失資料填充值）；method預設值為ffill，向前填充，bfill為向後填充；limit為向前或者向後填充的最大填充量。inplace預設會返回新物件，修改為inplace=True可以對現有物件進行就地修改。

資料轉換

替換值

• .replace(old, new)：用新的資料替換老的資料，如果希望一次性替換多個值，old和new可以是列表。預設會返回一個新的物件，傳入inplace=True可以對現有物件進行就地修改。

刪除重複資料

• .duplicated()：判斷各行是否是重複行（前面出現過的行），返回一個布林型Series。
• .drop_duplicates()：刪除重複行，返回刪除後的DataFrame物件。預設保留的是第一個出現的行，傳入keep='last’作為引數後，則保留最後一個出現的行。
  兩者都預設會對全部列做判斷，在傳入列索引組成的列表[ ‘列1’ , ‘列2’ , ……]作為引數後，可以只對這些列進行重複項判斷。

利用函式或字典進行資料轉換

• Series.map()：接受一個函式或字典作為引數。使用map方法是一種實現元素級轉換以及其他資料清理工作的便捷方式。

import pandas as pd
In [52]: data = pd.DataFrame({'food': ['bacon', 'pulled pork', 'bacon','pastrami', 'corned beef', 'bacon','pastrami', 'honey ham', 'nova lox'],
   ....                       'ounces': [4, 3, 12, 6, 7.5, 8, 3, 5, 6]})
meat_to_animal = {
  'bacon': 'pig',  'pulled pork': 'pig',  'pastrami': 'cow',  'corned beef': 'cow',
  'honey ham': 'pig',  'nova lox': 'salmon'
}
#增加一列animal
In [57]: data['animal'] = data['food'].map(meat_to_animal)
In [58]: data
Out[58]: 
          food  ounces  animal
0        bacon     4.0     pig
1  pulled pork     3.0     pig
2        bacon    12.0     pig
3     Pastrami     6.0     cow
4  corned beef     7.5     cow
5        Bacon     8.0     pig
6     pastrami     3.0     cow
7    honey ham     5.0     pig
8     nova lox     6.0  salmon

DataFrame常見函式

df.head()：查詢資料的前五行
df.tail()：查詢資料的末尾5行
pandas.cut()
pandas.qcut() 基於分位數的離散化函式。基於秩或基於樣本分位數將變數離散化為等大小桶。
pandas.date_range() 返回一個時間索引
df.apply() 沿相應軸應用函式
Series.value_counts() 返回不同資料的計數值
df.aggregate()
df.reset_index() 重新設定index，引數drop = True時會丟棄原來的索引，設定新的從0開始的索引。常與groupby()一起用
numpy.zeros()

https://www.jianshu.com/p/840ba135df30