介紹

在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

7178691-106835b28c0cea5a.png

DataFrame對象操作

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

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作為參數，可以就地修改對象，不會返回新的對象。

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的索引選項

算術運算

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()是用得最多的。

讀寫文本格式的數據

用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() 基于分位數的離散化函數?；谥然蚧跇颖痉治粩祵⒆兞侩x散化為等大小桶。
pandas.date_range() 返回一個時間索引
df.apply() 沿相應軸應用函數
Series.value_counts() 返回不同數據的計數值
df.aggregate()
df.reset_index() 重新設置index，參數drop = True時會丟棄原來的索引，設置新的從0開始的索引。常與groupby()一起用
numpy.zeros()