一：pandas簡介
Pandas 是一個開源的第三方 Python 庫，從 Numpy 和 Matplotlib 的基礎上構建而來，享有數據分析“三劍客之一”的盛名（NumPy、Matplotlib、Pandas）。Pandas 已經成為 Python 數據分析的必備高級工具，它的目標是成為強大、靈活、可以支持任何編程語言的數據分析工具，本文主要是對pandas進行入門，通過本文你將系統性了解pandas的基本使用方法。
二：pandas安裝以及庫的導入
2.1 Pandas安裝
Python自帶的包管理工具pip來安裝：
pip install pandas
若未安裝Anaconda，可以通過Anaconda安裝，在終端或命令符輸入如下命令安裝：
conda install pandas
2.2 pandas模塊的導入
import numpy as np # pandas和numpy常常結合在一起使用，導入numpy庫 import pandas as pd # 導入pandas庫
三：pandas數據結構
我們知道，構建和處理二維、多維數組是一項繁瑣的任務。Pandas 為解決這一問題， 在 ndarray 數組（NumPy 中的數組）的基礎上構建出了兩種不同的數據結構，分別是 Series（一維數據結構）和 DataFrame（二維數據結構）：
- Series 是帶標簽的一維數組，這里的標簽可以理解為索引，但這個索引並不局限於整數，它也可以是字符類型，比如 a、b、c 等；
- DataFrame 是一種表格型數據結構，它既有行標簽，又有列標簽。
| 數據結構 | 維度 | 說明 |
| Series | 1 | 該結構能夠存儲各種數據類型，比如字符數、整數、浮點數、Python 對象等，Series 用 name 和 index 屬性來描述 數據值。Series 是一維數據結構，因此其維數不可以改變。 |
| DataFrame | 2 | DataFrame 是一種二維表格型數據的結構，既有行索引，也有列索引。行索引是 index，列索引是 columns。 在創建該結構時，可以指定相應的索引值。 |
3.1 pandas Series結構
Series 結構，也稱 Series 序列，是 Pandas 常用的數據結構之一，它是一種類似於一維數組的結構，由一組數據值（value）和一組標簽組成，其中標簽與數據值之間是一一對應的關系。
Series 可以保存任何數據類型，比如整數、字符串、浮點數、Python 對象等，它的標簽默認為整數，從 0 開始依次遞增。Series 的結構圖，如下所示：
通過標簽我們可以更加直觀地查看數據所在的索引位置。
3.1.1創建Series對象
import pandas as pd s=pd.Series( data, index, dtype, copy) #參數說明： #data 輸入的數據，可以是列表、常量、ndarray 數組等。 #index 索引值必須是惟一的，如果沒有傳遞索引，則默認為 #np.arrange(n)。 #dtype dtype表示數據類型，如果沒有提供，則會自動判斷得出。 #copy 表示對 data 進行拷貝，默認為 False。
可以用數組、字典、標量值或者 Python 對象來創建 Series 對象
1）ndarray（數組）創建Series對象
ndarray 是 NumPy 中的數組類型，當 data 是 ndarry 時，傳遞的索引必須具有與數組相同的長度。假如沒有給 index 參數傳參，在默認情況下，索引值將使用是 range(n) 生成，其中 n 代表數組長度：
import pandas as pd import numpy as np data = np.array(['a','b','c','d']) #使用默認索引，創建 Series 序列對象 s1 = pd.Series(data) print(f'默認索引\n{s1}') ''' 默認索引 0 a 1 b 2 c 3 d dtype: object ''' #使用“顯式索引”的方法自定義索引標簽 s2 = pd.Series(data,index=[100,101,102,103]) print(f'自定義索引\n{s2}') ''' 自定義索引 100 a 101 b 102 c 103 d dtype: object '''
上述示例中沒有傳遞任何索引，所以索引默認從 0 開始分配 ，其索引范圍為 0 到len(data)-1。
2）dict創建Series對象：
把 dict 作為輸入數據。如果沒有傳入索引時會按照字典的鍵來構造索引；反之，當傳遞了索引時需要將索引標簽與字典中的值一一對應。
import pandas as pd import numpy as np data = {'a' : 0, 'b' : 1, 'c' : 2} #沒有傳遞索引時 會按照字典的鍵來構造索引 s1_dict = pd.Series(data) print(f'沒有傳遞索引\n{s1_dict}') ''' 沒有傳遞索引 a 0 b 1 c 2 dtype: int64 ''' #字典類型傳遞索引時 索引時需要將索引標簽與字典中的值一一對應 當傳遞的索引值無法找到與其對應的值時，使用 NaN（非數字）填充 s2_dict = pd.Series(data, index=['a','b','c','d']) print(f'傳遞索引\n{s2_dict}') ''' 傳遞索引 a 0 b 1 c 2
d NaN dtype: int64 '''
3)標量創建Series對象
#如果 data 是標量值，則必須提供索引: 標量值按照 index 的數量進行重復，並與其一一對應 s3 = pd.Series(6,index=[0,1,2,3]) print(f'標量值，則必須提供索引\n{s3}') ''' 標量值，則必須提供索引 0 6 1 6 2 6 3 6 dtype: int64 '''
3.1.2 訪問Series數據
Series 訪問數據分為兩種方式，一種是位置索引訪問；另一種是標簽索引訪問。
1）位置索引
s = pd.Series([1,2,3,4,5],index=['a','b','c','d','e']) print(f'Series數據\n{s}') ''' Series數據 a 1 b 2 c 3 d 4 e 5 dtype: int64 ''' #位置索引 第一個位置索引：0 print(f'位置索引={s[0]}') ''' 位置索引=1 ''' #標簽索引 第一個標簽索引：a print(f'標簽索引={s["a"]}')# ''' 標簽索引=1 ''' #通過切片的方式訪問 Series 序列中的數據 print(f'前兩個元素\n{s[:2]}') ''' 前兩個元素 a 1 b 2 dtype: int64 ''' print(f'最后三個元素\n{s[-3:]}') ''' 最后三個元素 c 3 d 4 e 5 dtype: int64 '''
2）標簽索引
Series 類似於固定大小的 dict，把 index 中的索引標簽當做 key，而把 Series 序列中的元素值當做 value，然后通過 index 索引標簽來訪問或者修改元素值。
s = pd.Series([1,2,3,4,5],index=['a','b','c','d','e']) print(f'Series數據\n{s}') ''' Series數據 a 1 b 2 c 3 d 4 e 5 dtype: int64 ''' #標簽索引訪問單個元素 print(f'標簽索引訪問單個元素={s["a"]}') ''' 標簽索引訪問單個元素=1 ''' #標簽索引訪問多個元素 print(f'標簽索引訪問多個元素\n{s[["a","b","c"]]}') ''' 標簽索引訪問多個元素 a 1 b 2 c 3 dtype: int64 ''' #訪問不包括的標簽 會包報異常 print(f'訪問不包括的標簽g,會包報異常={s["g"]}') ''' Traceback (most recent call last): File "E:/PycharmScripts/pandas_Scripts/testCases/test_series.py", line 126, in <module> print(f'訪問不包括的標簽g,會包報常={s["g"]}') File "E:\PycharmScripts\pandas_Scripts\venv\lib\site-packages\pandas\core\series.py", line 942, in __getitem__ return self._get_value(key) File "E:\PycharmScripts\pandas_Scripts\venv\lib\site-packages\pandas\core\series.py", line 1051, in _get_value loc = self.index.get_loc(label) File "E:\PycharmScripts\pandas_Scripts\venv\lib\site-packages\pandas\core\indexes\base.py", line 3363, in get_loc raise KeyError(key) from err KeyError: 'g' '''
3.1.3 Series常用屬性
Series 的常用屬性和方法。在下表列出了 Series 對象的常用屬性
| 名稱 | 屬性 |
| axes | 以列表的形式返回所有行索引標簽 |
| dtype | 返回對象的數據類型 |
| empty | 判斷Series對象是否為空 |
| ndim | 返回輸入數據的維數 |
| size | 返回輸入數據的元素數量 |
| values | 以ndarray的形式返回Series對象 |
| index | 返回一個RangeIndex對象，用來描述索引的取值范圍。 |
1）axes
s = pd.Series(np.random.randn(5)) print(f'默認索引\n{s}') ''' 0 -0.858591 1 -1.124626 2 -0.722887 3 1.081652 4 1.483287 dtype: float64 ''' s1 = pd.Series(np.random.randn(5),index=['a','b','c','d','e']) print(f'自定義索引\n{s1}') ''' a 1.077336 b 1.501572 c 2.616032 d 0.487748 e 0.339723 dtype: float64 ''' #axes 以列表的形式返回所有行索引標簽 #默認索引 print(s.axes) #[RangeIndex(start=0, stop=5, step=1)] # 自定義索引 print(s1.axes) #[Index(['a', 'b', 'c', 'd', 'e'], dtype='object')]
2) index
返回一個RangeIndex對象，用來描述索引的取值范圍。
s = pd.Series(np.random.randn(5)) print(f'默認索引\n{s}') ''' 0 -0.858591 1 -1.124626 2 -0.722887 3 1.081652 4 1.483287 dtype: float64 ''' s1 = pd.Series(np.random.randn(5),index=['a','b','c','d','e']) print(f'自定義索引\n{s1}') ''' a 1.077336 b 1.501572 c 2.616032 d 0.487748 e 0.339723 dtype: float64 ''' #index返回一個RangeIndex對象，用來描述索引的取值范圍 #默認索引 print(s.index) #RangeIndex(start=0, stop=5, step=1) #自定義索引 print(s1.index) #Index(['a', 'b', 'c', 'd', 'e'], dtype='object') #通過.index.values 獲取索引列表 print(s.index.values) #[0 1 2 3 4] print(s1.index.values) #['a' 'b' 'c' 'd' 'e']
3）values
以數組的形式返回 Series 對象中的數據。
s = pd.Series(np.random.randn(5)) print(f'默認索引\n{s}') ''' 0 -0.858591 1 -1.124626 2 -0.722887 3 1.081652 4 1.483287 dtype: float64 ''' #values 以數組的形式返回 Series 對象中的數據。 print(s.values) #[ 0.40307219 0.04711446 0.7655564 0.58309962 -1.38002949]
3.2 pandas DataFrame結構
DataFrame 一個表格型的數據結構，既有行標簽（index），又有列標簽（columns），它也被稱異構數據表，所謂異構，指的是表格中每列的數據類型可以不同，比如可以是字符串、整型或者浮點型等。其結構圖示意圖，如下所示：
3.2.1創建DataFrame對象
import pandas as pd pd.DataFrame( data, index, columns, dtype, copy) #參數說明： data 輸入的數據，可以是 ndarray，series，list，dict，標量以及一個 DataFrame。 index 行標簽，如果沒有傳遞 index 值，則默認行標簽是 np.arange(n)，n 代表 data 的元素個數。 columns 列標簽，如果沒有傳遞 columns 值，則默認列標簽是 np.arange(n)。 dtype dtype表示每一列的數據類型。 copy 默認為 False，表示復制數據 data。
1）列表創建DataFame對象
import pandas as pd #單一列表創建 DataFrame data = [1,2,3] df1 = pd.DataFrame(data) print(f'單一列表\n{df1}') ''' 單一列表 0 0 1 1 2 2 3 ''' # 使用嵌套列表創建 DataFrame 對象 data = [['java',10],['python','20'],['C++','30']] df2 = pd.DataFrame(data) print(f'嵌套列表創建\n{df2}') ''' 嵌套列表創建 0 1 0 java 10 1 python 20 2 C++ 30 ''' #指定數值元素的數據類型為 float： 並指定columns df3 = pd.DataFrame(data,columns=['name','age'],dtype=float) print(f'指定數據類型和colums\n{df3}') ''' 指定數據類型和colums name age 0 java 10.0 1 python 20.0 2 C++ 30.0 '''
2）字典嵌套列表創建DataFrame對象
data字典中，鍵對應值的元素長度必須相等（也就是列表的長度相等），如果傳遞索引那么索引的長度必須等於列表的長度；如果沒有傳遞索引，默認情況下 索引應為range（n).n代表的列表的長度
data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
#沒有傳遞所以
df1 = pd.DataFrame(data)
print(f'默認索引\n{df1}')
'''
默認索引
Name Age
0 Tom 28
1 Jack 34
2 Steve 29
3 Ricky 42
'''
#自定義索引
df2 = pd.DataFrame(data,index=['a','b','c','d'])
print(f'自定義索引\n{df2}')
'''
自定義索引
Name Age
a Tom 28
b Jack 34
c Steve 29
d Ricky 42
'''
3)列表嵌套字典創建DataFrame對象
列表嵌套字典作為傳入的值時，默認情況下 字典的鍵作為名（coloumns）
注意：如果某個元素的值缺失，也就是字典的key無法找到對應的Value，獎使用NaN代替
# 字典的鍵被用作列名 如果其中某個元素值缺失，也就是字典的 key 無法找到對應的 value，將使用 NaN 代替。 data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}] df1 = pd.DataFrame(data) print(df1) ''' a b c 0 1 2 NaN 1 5 10 20.0 ''' #自定義行標簽索引 df2 = pd.DataFrame(data,index=['first','second']) print(df2) ''' a b c first 1 2 NaN second 5 10 20.0 ''' #如果列名 在字典鍵中不存在，所以對應值為 NaN。 df3 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b']) df4 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b1']) print(f'df3的列名在字典鍵中存在\n{df3}') print(f'df4的列名b1在字典鍵不中存在\n{df4}') ''' df3的列名在字典鍵中存在 a b first 1 2 second 5 10 df4的列名b1在字典鍵不中存在 a b1 first 1 NaN second 5 NaN '''
4) Series創建DataFrame對象
傳遞一個字典形式的 Series，從而創建一個 DataFrame 對象，其輸出結果的行索引是所有 index 的合集
#Series創建DataFrame對象 其輸出結果的行索引是所有 index 的合集 data = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']), 'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])} df = pd.DataFrame(data) print(df) ''' one two a 1.0 1 b 2.0 2 c 3.0 3 d NaN 4 '''
3.2.2 列索引操作DataFrame
DataFrame 可以使用列索引（columns index）來完成數據的選取、添加和刪除操作
1）列索引選取數據列
#列索引操作DataFrame data = [['java',10,9,],['python',20,100],['C++',30,50]] df1 = pd.DataFrame(data,columns=['name','age','number']) print(f'數據df1\n{df1}') ''' 數據df1 name age number 0 java 10 9 1 python 20 100 2 C++ 30 50 ''' #獲取數據方式一：使用列索引，實現數據獲取某一行數據 df[列名]等於df.列名 print(f'通過df1.name方式獲取\n{df1.name}') ''' 通過df1.name方式獲取 0 java 1 python 2 C++ Name: name, dtype: object ''' print(f'通過df1["name"]方式獲取\n{df1["name"]}') ''' 通過df1["name"]方式獲取 0 java 1 python 2 C++ Name: name, dtype: object ''' #獲取數據方式二：使用列索引，實現數據獲取某多行數據 df[list] print(f'通過df[list]方式獲取多列數據\n{df1[["name","number"]]}') ''' 通過df[list]方式獲取多列數據 name number 0 java 9 1 python 100 2 C++ 50 ''' #獲取數據方式三：使用布爾值篩選 獲取某行數據 # 不同的條件用()包裹起來,並或非分別使用&,|,~而非and,or,not print(f'獲取name=python的數據\n{df1[df1["name"]=="python"]}') ''' 獲取name=python的數據 name age number 1 python 20 100 ''' print(f'獲取age大於等於20的數據\n{df1[df1["age"]>=20]}') ''' 獲取age大於等於20的數據 name age number 1 python 20 100 2 C++ 30 50 ''' print(f'獲取name=python的數據或者是age等於30\n{df1[(df1["name"]=="python") | (df1["age"]==30)]}') ''' 獲取name=python的數據或者是age等於30 name age number 1 python 20 100 2 C++ 30 50 '''
2）列索引添加數據列
使用 columns 列索引表標簽可以實現添加新的數據列
#列索引添加數據列 data = {'one':[1,2,3],'two':[2,3,4]} df1 = pd.DataFrame(data,index=['a','b','c']) print(f'原數據\n{df1}') ''' 原數據 one two a 1 2 b 2 3 c 3 4 ''' #方式一：使用df['列']=值，插入新的數據列 df1['three'] = pd.Series([10,20,30],index=list('abc')) print(f'使用df["列"]=值，插入新的數據\n{df1}') ''' 使用df["列"]=值，插入新的數據 one two three a 1 2 10 b 2 3 20 c 3 4 30 ''' #方式二：#將已經存在的數據列做相加運算 df1['four'] = df1['one']+df1['three'] print(f'將已經存在的數據列做相加運算\n{df1}') ''' 將已經存在的數據列做相加運算 one two three four a 1 2 10 11 b 2 3 20 22 c 3 4 30 33 ''' #方式三：使用 insert() 方法插入新的列 # #注意是column參數 #數值4代表插入到columns列表的索引位置 df1.insert(4,column='score',value=[50,60,70]) print(f'使用insert()方法插入\n{df1}') ''' 使用insert()方法插入 one two three four score a 1 2 10 11 50 b 2 3 20 22 60 c 3 4 30 33 70 '''
3）列索引刪除數據列
通過del和pop()都能夠刪除 DataFrame 中的數據列
data = {'one':[1,2,3],'two':[20,30,40],'three':[20,30,40]}
df1 = pd.DataFrame(data,index=['a','b','c'])
print(f'原數據\n{df1}')
#方式一 del 刪除某一列
del df1["one"]
print(f'通過del df["列名"]刪除\n{df1}')
#方式er pop() 刪除某一列
df1.pop("two")
print(f'通過pop("列名")刪除\n{df1}')
執行結果;
原數據 one two three a 1 20 20 b 2 30 30 c 3 40 40 通過del df["列名"]刪除 two three a 20 20 b 30 30 c 40 40 通過pop("列名")刪除 three a 20 b 30 c 40
3.2.3行索引操作DataFrame
理解了上述的列索引操作后，行索引操作就變的簡單。下面看一下，如何使用行索引來選取 DataFrame 中的數據。
1) 標簽索引選取 loc[]
可以將行標簽傳遞給 loc 函數，來選取數據
注意：loc 允許接兩個參數分別是行和列，參數之間需要使用“逗號”隔開，但該函數只能接收標簽索引。
data = {'one':[1,2,3,4],'two':[20,30,40,50],'three':[60,70,80,90]}
df1 = pd.DataFrame(data,index=['a','b','c','d'])
print(f'原數據\n{df1}')
#取某一行數據
print(f'取某一行數據\n{df1.loc["a"]}')
#loc 允許接兩個參數分別是行和列，參數之間需要使用“逗號”隔開，但該函數只能接收標簽索引
#去某一個單元格的數據
print(f"取某一個單元格的數據\n{df1.loc['a','two']}")
#更改某一個單元格的數據
df1.loc['a','two']='abc'
print(f"更改后的數據\n{df1}")
執行結果：
#原數據 one two three a 1 20 60 b 2 30 70 c 3 40 80 d 4 50 90
#取某一行數據 one 1 two 20 three 60 Name: a, dtype: int64
#取某一個單元格的數據 20
#更改后的數據 one two three a 1 abc 60 b 2 30 70 c 3 40 80 d 4 50 90
2）整數索引選取 iloc[]
通過將數據行所在的索引位置傳遞給 iloc 函數，也可以實現數據行選取.
注意：iloc 允許接受兩個參數分別是行和列，參數之間使用“逗號”隔開，但該函數只能接收整數索引。
data = {'one':[1,2,3,4],'two':[20,30,40,50],'three':[60,70,80,90]}
df1 = pd.DataFrame(data,index=['a','b','c','d'])
print(f'原數據\n{df1}')
#取某一行的數據 索引是從0開始
print(f'取某一行的數據\n{df1.iloc[0]}')
執行結果：
原數據 one two three a 1 20 60 b 2 30 70 c 3 40 80 d 4 50 90
取某一行的數據 one 1 two 20 three 60 Name: a, dtype: int64
3) 切片操作多行選取
loc 允許接兩個參數分別是行和列，參數之間需要使用“逗號”隔開，但該函數只能接收標簽索引。
iloc 允許接受兩個參數分別是行和列，參數之間使用“逗號”隔開，但該函數只能接收整數索引。
data = {'one':[1,2,3,4],'two':[20,30,40,50],'three':[60,70,80,90]}
df1 = pd.DataFrame(data,index=['a','b','c','d'])
print(f'原數據\n{df1}')
#loc[] 允許接兩個參數分別是行和列，參數之間需要使用“逗號”隔開，但該函數只能接收標簽索引
print(f"#loc[]方式獲取第三行最后兩列數據\n{df1.loc['c','two':'three']}")
#iloc[] 允許接受兩個參數分別是行和列，參數之間使用“逗號”隔開，但該函數只能接收整數索引。
print(f"#iloc[]方式獲取第三行最后兩列數據\n{df1.iloc[2,1:3]}")
執行結果：
原數據 one two three a 1 20 60 b 2 30 70 c 3 40 80 d 4 50 90 #loc[]方式獲取第三行最后兩列數據 two 40 three 80 Name: c, dtype: int64 #iloc[]方式獲取第三行最后兩列數據 two 40 three 80 Name: c, dtype: int64
4) 添加數據行
使用 append() 函數，可以將新的數據行添加到 DataFrame 中，該函數會在行末追加數據行
data = {'one':[1,2,3,4],'two':[20,30,40,50],'three':[60,70,80,90]}
df1 = pd.DataFrame(data,index=['a','b','c','d'])
print(f'#原數據\n{df1}')
df2 = pd.DataFrame({'one':'Q','two':'W'},index=['e'])
#使用append()返回一個新的是DataFrame的對象
df = df1.append(df2)
print(f'#在行末追加新數據行\n{df}')
執行結果：
#原數據 one two three a 1 20 60 b 2 30 70 c 3 40 80 d 4 50 90 #在行末追加新數據行 one two three a 1 20 60.0 b 2 30 70.0 c 3 40 80.0 d 4 50 90.0 e Q W NaN
5) 刪除數據行
您可以使用行索引標簽，從 DataFrame 中刪除某一行數據。如果索引標簽存在重復，那么它們將被一起刪除
pop(行索引) 刪除某一行
pop(列名) 刪除某一列
注意：如果有重復的行索引 並通過 drop()會 同時刪除
data = {'one':[1,2,3,4],'two':[20,30,40,50],'three':[60,70,80,90]}
df1 = pd.DataFrame(data,index=['a','b','c','d'])
print(f'原數據\n{df1}')
#pop(行索引) 刪除某一行
df = df1.drop('a')
print(f'pop(行索引) 刪除某一行\n{df}')
#pop(列名) 刪除某一列
df1.pop("one")
print(f'#pop(列名) 刪除某一列\n{df1}')
執行結果：
原數據 one two three a 1 20 60 b 2 30 70 c 3 40 80 d 4 50 90 pop(行索引) 刪除某一行 one two three b 2 30 70 c 3 40 80 d 4 50 90 #pop(列名) 刪除某一列 two three a 20 60 b 30 70 c 40 80 d 50 90
3.3 常用屬性和方法匯總
DataFrame 的屬性和方法，與 Series 相差無幾，如下所示：
| 名稱 | 屬性&方法描述 |
| index | 返回行索引 |
| coloumns | 返回列索引 |
| values | 使用numpy數組表示Dataframe中的元素值 |
| head() | 返回前 n 行數據。 |
| tail() | 返回后 n 行數據。 |
| axes | 返回一個僅以行軸標簽和列軸標簽為成員的列表。 |
| dtypes | 返回每列數據的數據類型。 |
| empty | DataFrame中沒有數據或者任意坐標軸的長度為0，則返回True。 |
| ndim | 軸的數量，也指數組的維數。 |
| shape | DataFrame中的元素數量。 |
| shift() | 將行或列移動指定的步幅長度 |
| T | 行和列轉置。 |
| info() | 返回相關的信息:行數 列數，列索引 列非空值個數， 列類型 |
1） info()，index，coloumns，values ，axes
info():返回DataFrame對象的相關信息
index：返回行索引
coloumns：返回列索引
values：使用numpy數組表示Dataframe中的元素值
axes: 返回一個行標簽、列標簽組成的列表
data = { 'name:': pd.Series(['c語言中文網','編程幫',"百度",'360搜索','谷歌','微學苑','Bing搜索']), 'year': pd.Series([5,6,15,28,3,19,23]), 'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])} df = pd.DataFrame(data) print(f'#原數據\n{df}') #info() 獲取相關信息 print(f'#df.info()獲取DataFrame相關信息\n{df.info()}') #index 獲取行索引 print(f'#df.index 獲取行索引\n{df.index}') #coloumns 獲取行索引 print(f'#df.columns 獲取列索引\n{df.columns}') #axes 獲取行標簽、列標簽組成的列表 print(f'#df.axes 獲取行標簽、列標簽組成的列表\n{df.axes}') #values 使用numpy數組表示Dataframe中的元素值 print(f'#df.values獲取Dataframe中的元素值\n{df.values}')
執行結果：
#原數據 name: year Rating 0 c語言中文網 5 4.23 1 編程幫 6 3.24 2 百度 15 3.98 3 360搜索 28 2.56 4 谷歌 3 3.20 5 微學苑 19 4.60 6 Bing搜索 23 3.80 #df.info()獲取DataFrame相關信息 <class 'pandas.core.frame.DataFrame'> RangeIndex: 7 entries, 0 to 6 Data columns (total 3 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 name: 7 non-null object 1 year 7 non-null int64 2 Rating 7 non-null float64 dtypes: float64(1), int64(1), object(1) memory usage: 296.0+ bytes None #df.index 獲取行索引 RangeIndex(start=0, stop=7, step=1) #df.columns 獲取列索引 Index(['name:', 'year', 'Rating'], dtype='object') #df.axes 獲取行標簽、列標簽組成的列表 [RangeIndex(start=0, stop=7, step=1), Index(['name:', 'year', 'Rating'], dtype='object')] #df.values獲取Dataframe中的元素值 [['c語言中文網' 5 4.23] ['編程幫' 6 3.24] ['百度' 15 3.98] ['360搜索' 28 2.56] ['谷歌' 3 3.2] ['微學苑' 19 4.6] ['Bing搜索' 23 3.8]]
2）head()&tail()查看數據
如果想要查看 DataFrame 的一部分數據，可以使用 head() 或者 tail() 方法。其中 head() 返回前 n 行數據，默認顯示前 5 行數據
data = { 'name:': pd.Series(['c語言中文網','編程幫',"百度",'360搜索','谷歌','微學苑','Bing搜索']), 'year': pd.Series([5,6,15,28,3,19,23]), 'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])} df = pd.DataFrame(data) print(f'#原數據\n{df}') #head(n) 返回前n行數據 默認是前5行 print(f'#df.head(n) 返回前n行數據\n{df.head(2)}') #tail(n) 返回后n行數據 print(f'#df.tail(n) 返回后n行數據\n{df.tail(2)}')
執行結果：
#原數據 name: year Rating 0 c語言中文網 5 4.23 1 編程幫 6 3.24 2 百度 15 3.98 3 360搜索 28 2.56 4 谷歌 3 3.20 5 微學苑 19 4.60 6 Bing搜索 23 3.80
#df.head(2) 返回前2行數據 name: year Rating 0 c語言中文網 5 4.23 1 編程幫 6 3.24
#df.tail(2) 返回后2行數據 name: year Rating 5 微學苑 19 4.6 6 Bing搜索 23 3.8
3） dtypes
返回每一列數據的類型
data = { 'name:': pd.Series(['c語言中文網','編程幫',"百度",'360搜索','谷歌','微學苑','Bing搜索']), 'year': pd.Series([5,6,15,28,3,19,23]), 'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])} df = pd.DataFrame(data) print(f'#原數據\n{df}') #dtpes 獲取每一列數據的數據類型 print(f'#df.dtpes返回每一列的數據類型\n{df.dtypes}')
執行結果：
#原數據 name: year Rating 0 c語言中文網 5 4.23 1 編程幫 6 3.24 2 百度 15 3.98 3 360搜索 28 2.56 4 谷歌 3 3.20 5 微學苑 19 4.60 6 Bing搜索 23 3.80 #df.dtpes返回每一列的數據類型 name: object year int64 Rating float64 dtype: object
4) empty
返回一個布爾值，判斷輸出的數據對象是否為空，若為 True 表示對象為空。
data = { 'name:': pd.Series(['c語言中文網','編程幫',"百度",'360搜索','谷歌','微學苑','Bing搜索']), 'year': pd.Series([5,6,15,28,3,19,23]), 'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])} df = pd.DataFrame(data) print(f'#原數據\n{df}') #empty 判斷輸出的數據對象是否為空，若為 True 表示對象為空 print(f'#df.empty 對象是否為空，若為 True 表示對象為空\n{df.empty}')
執行結果：
#原數據 name: year Rating 0 c語言中文網 5 4.23 1 編程幫 6 3.24 2 百度 15 3.98 3 360搜索 28 2.56 4 谷歌 3 3.20 5 微學苑 19 4.60 6 Bing搜索 23 3.80 #df.empty 對象是否為空，若為 True 表示對象為空 False
5) ndim&shape 查看維數和維度
ndimf：返回數據對象的維數
shape：返回一個代表 DataFrame 維度的元組。返回值元組 (a,b)，其中 a 表示行數，b 表示列數
data = { 'name:': pd.Series(['c語言中文網','編程幫',"百度",'360搜索','谷歌','微學苑','Bing搜索']), 'year': pd.Series([5,6,15,28,3,19,23]), 'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])} df = pd.DataFrame(data) print(f'#原數據\n{df}') #ndim 查看DataFrame的維數 同時也適合Series print(f"#df.ndim 查看DataFrame的維數\n{df.ndim}") #shape 維度的元組。返回值元組 (a,b)，其中 a 表示行數，b 表示列數 同時也適合Series print(f"#df.shape 維度的元組。返回值元組 (a,b)，其中 a 表示行數，b 表示列數\n{df.shape}")
執行結果：
#原數據 name: year Rating 0 c語言中文網 5 4.23 1 編程幫 6 3.24 2 百度 15 3.98 3 360搜索 28 2.56 4 谷歌 3 3.20 5 微學苑 19 4.60 6 Bing搜索 23 3.80 #df.ndim 查看DataFrame的維數 2 #df.shape 維度的元組。返回值元組 (a,b)，其中 a 表示行數，b 表示列數 (7, 3)
6）size
返回DataFrame對象的元素數量
data = { 'name:': pd.Series(['c語言中文網','編程幫',"百度",'360搜索','谷歌','微學苑','Bing搜索']), 'year': pd.Series([5,6,15,28,3,19,23]), 'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])} df = pd.DataFrame(data) print(f'#原數據\n{df}') #size 查看DataFrame對象元素的數量 print(f'#df.size 查看DataFrame對象元素的數量\n{df.size}')
執行結果;
#原數據 name: year Rating 0 c語言中文網 5 4.23 1 編程幫 6 3.24 2 百度 15 3.98 3 360搜索 28 2.56 4 谷歌 3 3.20 5 微學苑 19 4.60 6 Bing搜索 23 3.80 #df.size 查看DataFrame對象元素的數量 21
7) T（Transpose）轉置
返回 DataFrame 的轉置，也就是把行和列進行交換。
data = { 'name:': pd.Series(['c語言中文網','編程幫',"百度",'360搜索','谷歌','微學苑','Bing搜索']), 'year': pd.Series([5,6,15,28,3,19,23]), 'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])} df = pd.DataFrame(data) print(f'#原數據\n{df}') # T（Transpose）轉置 把行和列進行交換 print(f'#df.T把行和列進行交換\n{df.T}')
執行結果：
#原數據 name: year Rating 0 c語言中文網 5 4.23 1 編程幫 6 3.24 2 百度 15 3.98 3 360搜索 28 2.56 4 谷歌 3 3.20 5 微學苑 19 4.60 6 Bing搜索 23 3.80 #df.T把行和列進行交換 0 1 2 3 4 5 6 name: c語言中文網 編程幫 百度 360搜索 谷歌 微學苑 Bing搜索 year 5 6 15 28 3 19 23 Rating 4.23 3.24 3.98 2.56 3.2 4.6 3.8
四：pandas描述性統計
描述統計學（descriptive statistics）是一門統計學領域的學科，主要研究如何取得反映客觀現象的數據，並以圖表形式對所搜集的數據進行處理和顯示，最終對數據的規律、特征做出綜合性的描述分析。Pandas 庫正是對描述統計學知識完美應用的體現，可以說如果沒有“描述統計學”作為理論基奠，那么 Pandas 是否存在猶未可知。下列表格對 Pandas 常用的統計學函數做了簡單的總結：
| 函數名稱 | 描述說明 |
|---|---|
| count() | 統計某個非空值的數量。 |
| sum() | 求和 |
| mean() | 求均值 |
| median() | 求中位數 |
| mode() | 求眾數 |
| std() | 求標准差 |
| min() | 求最小值 |
| max() | 求最大值 |
| abs() | 求絕對值 |
| prod() | 求所有數值的乘積。 |
| cumsum() | 計算累計和，axis=0，按照行累加；axis=1，按照列累加。 |
| cumprod() | 計算累計積，axis=0，按照行累積；axis=1，按照列累積。 |
| corr() | 計算數列或變量之間的相關系數，取值-1到1，值越大表示關聯性越強。 |
在 DataFrame 中，使用聚合類方法時需要指定軸(axis)參數。下面介紹兩種傳參方式：
- 對行操作，默認使用 axis=0 或者使用 "index"；
- 對列操作，默認使用 axis=1 或者使用 "columns"。
從圖 上 可以看出，axis=0 表示按垂直方向進行計算，而 axis=1 則表示按水平方向。
4.1 sum()求和
4.1.1 axis=0 垂直方向 的所有值的和
data = { 'name:': pd.Series(['c語言中文網','編程幫',"百度",'360搜索','谷歌','微學苑','Bing搜索']), 'year': pd.Series([5,6,15,28,3,19,23]), 'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])} df = pd.DataFrame(data) print(f'#原數據\n{df}') #sum() 默認返回axis=0 （垂直方向）的所有值的和 print(f'#df.sum() 默認返回axis=0 （垂直方向）的所有值的和\n{df.sum()}')
執行結果：
#原數據 name: year Rating 0 c語言中文網 5 4.23 1 編程幫 6 3.24 2 百度 15 3.98 3 360搜索 28 2.56 4 谷歌 3 3.20 5 微學苑 19 4.60 6 Bing搜索 23 3.80 #df.sum() 默認返回axis=0 （垂直方向）的所有值的和 name: c語言中文網編程幫百度360搜索谷歌微學苑Bing搜索 year 99 Rating 25.61 dtype: object
注意：sum() 和 cumsum() 函數可以同時處理數字和字符串數據。雖然字符聚合通常不被使用，但使用這兩個函數並不會拋出異常；而對於 abs()、cumprod() 函數則會拋出異常，因為它們無法操作字符串數據。
4.1.2 axis=1時 水平方向
data = { 'name:': pd.Series(['c語言中文網','編程幫',"百度",'360搜索','谷歌','微學苑','Bing搜索']), 'year': pd.Series([5,6,15,28,3,19,23]), 'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])} df = pd.DataFrame(data) print(f'#原數據\n{df}') #sum() 當axis=1 （水平方向）的所有值的和 print(f'#df.sum(axis=1) 默認返回axis=1 （水平方向）的所有值的和\n{df.sum(axis=1)}')
執行結果：
#原數據 name: year Rating 0 c語言中文網 5 4.23 1 編程幫 6 3.24 2 百度 15 3.98 3 360搜索 28 2.56 4 谷歌 3 3.20 5 微學苑 19 4.60 6 Bing搜索 23 3.80 #df.sum(axis=1) 默認返回axis=1 （垂直方向）的所有值的和 0 9.23 1 9.24 2 18.98 3 30.56 4 6.20 5 23.60 6 26.80 dtype: float64
4.2 mean()求均值
data = { 'name:': pd.Series(['c語言中文網','編程幫',"百度",'360搜索','谷歌','微學苑','Bing搜索']), 'year': pd.Series([5,6,15,28,3,19,23]), 'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])} df = pd.DataFrame(data) print(f'#原數據\n{df}') #mean() 求平均值 print(f'#mean() 平均值\n{df.mean()}')
執行結果：
#原數據 name: year Rating 0 c語言中文網 5 4.23 1 編程幫 6 3.24 2 百度 15 3.98 3 360搜索 28 2.56 4 谷歌 3 3.20 5 微學苑 19 4.60 6 Bing搜索 23 3.80 #mean() 平均值 year 14.142857 Rating 3.658571 dtype: float64
4.3 std()求標准差
返回數值列的標准差，
標准差是方差的算術平方根，它能反映一個數據集的離散程度。注意，平均數相同的兩組數據，標准差未必相同。
data = { 'name:': pd.Series(['c語言中文網','編程幫',"百度",'360搜索','谷歌','微學苑','Bing搜索']), 'year': pd.Series([5,6,15,28,3,19,23]), 'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])} df = pd.DataFrame(data) print(f'#原數據\n{df}') print(f'#df.std()求標准差\n{df.std()}')
執行結果：
#原數據 name: year Rating 0 c語言中文網 5 4.23 1 編程幫 6 3.24 2 百度 15 3.98 3 360搜索 28 2.56 4 谷歌 3 3.20 5 微學苑 19 4.60 6 Bing搜索 23 3.80 #df.std()求標准差 year 9.737018 Rating 0.698628 dtype: float64
五：pandas自定義函數pipe()&apply()&applymap()
如果想要應用自定義的函數，或者把其他庫中的函數應用到 Pandas 對象中，有以下三種方法：
- 操作整個 DataFrame 的函數：pipe()
- 操作行或者列的函數：apply()
- 操作單一元素的函數：applymap()
5.1操作整個數據表 pipe()
通過給 pipe() 函數傳遞一個自定義函數和適當數量的參數值，從而操作 DataFrme 中的所有元素。下面示例，實現了數據表中的元素值依次加 3
pip()傳入函數對應的第一個位置上的參數必須是目標Series或DataFrame，其他相關的參數使用常規的鍵值對方式傳入即可
#自定義函數 def adder(ele1,ele2): return ele1+ele2 #操作DataFrame df = pd.DataFrame(np.random.randn(4,3),columns=['c1','c2','c3']) #相加前 print(f'#原數據\n{df}') #相加后 print(f'#df.pipe()相加后的數據\n{df.pipe(adder,3)}')
執行結果：
#原數據 c1 c2 c3 0 1.983983 -0.129944 -0.127036 1 -0.946266 -0.870207 -1.144708 2 -1.748058 -0.612437 -0.628766 3 -0.011004 -0.989770 0.971783 #df.pipe()相加后的數據 c1 c2 c3 0 4.983983 2.870056 2.872964 1 2.053734 2.129793 1.855292 2 1.251942 2.387563 2.371234 3 2.988996 2.010230 3.971783
5.2 操作行或者列的函數：apply()
如果要操作 DataFrame 的某一行或者某一列，可以使用 apply() 方法，該方法與描述性統計方法類似，都有可選參數 axis。
5.2.1 axis=0 垂直方向
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3']) print(f'#原始數據\n{df}') #axis=0默認按列操作，計算每一列均值 print(f'#df.apply(函數)計算每一列均值\n{df.apply(np.mean)}')
執行結果：
#原始數據 col1 col2 col3 0 1.256708 -0.790664 -0.627037 1 0.056723 -1.246128 -0.315323 2 -1.209148 -0.126714 1.801013 3 0.572156 -0.986480 1.382834 4 -0.322420 0.018977 -1.100964 #df.apply(函數)計算每一列均值 col1 0.070804 col2 -0.626202 col3 0.228105 dtype: float64
5.2.2 axis=1 水平方向
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3']) print(f'#原始數據\n{df}') #自定義函數 def adder(df, data): data_list =[] columns = df.index.values for i in columns: value = df[i] data_list.append(value+data) return np.sum(data_list,axis=0) df['col4'] = df.apply(adder,args=(3,),axis=1) print(f'#調用自定義函數\n{df}')
執行結果：
#原始數據 col1 col2 col3 0 1.256708 -0.790664 -0.627037 1 0.056723 -1.246128 -0.315323 2 -1.209148 -0.126714 1.801013 3 0.572156 -0.986480 1.382834 4 -0.322420 0.018977 -1.100964 #調用自定義函數 col1 col2 col3 col4 0 1.256708 -0.790664 -0.627037 8.839007 1 0.056723 -1.246128 -0.315323 7.495272 2 -1.209148 -0.126714 1.801013 9.465152 3 0.572156 -0.986480 1.382834 9.968511 4 -0.322420 0.018977 -1.100964 7.595593
5.3 操作單一元素的函數：applymap()
DataFrame的 applymap() 函數可以對DataFrame里的每個值進行處理,然后返回一個新的DataFrame
df = pd.DataFrame({ 'a': [1, 2, 3], 'b': [10, 20, 30], 'c': [5, 10, 15] }) print(f'#原始數據\n{df}') def add_one(x,data): print(f'x的值 = {x}') print(f'data的值={data}') return x + 1 df1 = df.applymap(add_one,data=3) print(f'#applymap（）對每個元素操作后\n{df1}')
執行結果：
#原始數據 a b c 0 1 10 5 1 2 20 10 2 3 30 15 #自定義函數傳入的參數值 x的值 = 1 data的值=3 x的值 = 2 data的值=3 x的值 = 3 data的值=3 x的值 = 10 data的值=3 x的值 = 20 data的值=3 x的值 = 30 data的值=3 x的值 = 5 data的值=3 x的值 = 10 data的值=3 x的值 = 15 data的值=3 #applymap（）對每個元素操作后 a b c 0 2 11 6 1 3 21 11 2 4 31 16
六：pandas iteration遍歷
如果想要遍歷 DataFrame 的每一行，我們下列函數：
- iteritems()：以鍵值對 (key,value) 的形式遍歷列；
- iterrows()：以 (row_index,row) 的形式遍歷行;
- itertuples()：使用已命名元組的方式遍歷行。
6.1 iteritems()：以鍵值對 (key,value) 的形式遍歷列
以鍵值對的形式遍歷 DataFrame 對象，以列標簽為鍵，以對應列的元素為值。
df = pd.DataFrame(np.random.randn(4,3),columns=['col1','col2','col3']) print(f'#原始數據\n{df}') #iteritems()：以鍵值對 (key,value) 的形式遍歷 以列標簽為鍵，以對應列的元素為值 for key,value in df.iteritems(): print (f'#key以列標簽為鍵：{key}') print(f'#value以對應列的元素為值\n{value}')
執行結果：
#原始數據 col1 col2 col3 0 0.284440 -0.741417 0.232854 1 1.425886 -0.725062 -0.231505 2 -0.959947 -0.253215 0.972865 3 -1.675378 1.439948 -1.232833 #key以列標簽為鍵：col1 #value以對應列的元素為值 0 0.284440 1 1.425886 2 -0.959947 3 -1.675378 Name: col1, dtype: float64 #key以列標簽為鍵：col2 #value以對應列的元素為值 0 -0.741417 1 -0.725062 2 -0.253215 3 1.439948 Name: col2, dtype: float64 #key以列標簽為鍵：col3 #value以對應列的元素為值 0 0.232854 1 -0.231505 2 0.972865 3 -1.232833 Name: col3, dtype: float64
6.2 iterrows()：以 (row_index,row) 的形式遍歷行
該方法按行遍歷，返回一個迭代器，以行索引標簽為鍵，以每一行數據為值。
df = pd.DataFrame(np.random.randn(4,3),columns=['col1','col2','col3']) print(f'#原始數據\n{df}') #該方法按行遍歷，返回一個迭代器，以行索引標簽為鍵，以每一行數據為值 for row_index, row in df.iterrows(): print(f'#行索引標簽為鍵row_index:{row_index}') print(f'#每一行數據為值row:\n{row}') print(f'#每一行轉成字典（列表簽：value）:\n{row.to_dict()}')
執行結果：
#原始數據 col1 col2 col3 0 0.691124 -0.726609 -1.163696 1 -1.143281 0.008123 -0.496127 2 -0.677804 -1.307235 -0.926160 3 0.280503 -0.777648 0.970424 #行索引標簽為鍵row_index:0 #每一行數據為值row: col1 0.691124 col2 -0.726609 col3 -1.163696 Name: 0, dtype: float64 #每一行轉成字典（列標簽：value）: {'col1': 0.6911237932116442, 'col2': -0.7266085751270223, 'col3': -1.1636955887400091} #行索引標簽為鍵row_index:1 #每一行數據為值row: col1 -1.143281 col2 0.008123 col3 -0.496127 Name: 1, dtype: float64 #每一行轉成字典（列標簽：value）: {'col1': -1.143281153387153, 'col2': 0.008123105611642303, 'col3': -0.4961267413779065} #行索引標簽為鍵row_index:2 #每一行數據為值row: col1 -0.677804 col2 -1.307235 col3 -0.926160 Name: 2, dtype: float64 #每一行轉成字典（列標簽：value）: {'col1': -0.6778043873693782, 'col2': -1.3072345379948949, 'col3': -0.926160102004644} #行索引標簽為鍵row_index:3 #每一行數據為值row: col1 0.280503 col2 -0.777648 col3 0.970424 Name: 3, dtype: float64 #每一行轉成字典（列標簽：value）: {'col1': 0.2805031017555484, 'col2': -0.7776480571277457, 'col3': 0.9704240438056065}
6.3 itertuples()：使用已命名元組的方式遍歷行
tertuples() 同樣將返回一個迭代器，該方法會把 DataFrame 的每一行生成一個元組
df = pd.DataFrame(np.random.randn(4,3),columns=['col1','col2','col3']) print(f'#原始數據\n{df}') for row in df.itertuples(): print(f'#每一行生成一個元組\n{row}')
執行結果：
#原始數據 col1 col2 col3 0 -0.059090 -0.159421 -0.474316 1 -0.736043 0.747226 0.171213 2 -0.380318 1.080828 -1.653805 3 -0.457426 0.737069 -1.045649 #每一行生成一個元組 Pandas(Index=0, col1=-0.05909003053453285, col2=-0.15942088983693178, col3=-0.4743159410530973) #每一行生成一個元組 Pandas(Index=1, col1=-0.736042848878659, col2=0.7472261708453659, col3=0.17121325299305076) #每一行生成一個元組 Pandas(Index=2, col1=-0.3803178814594451, col2=1.0808276756692548, col3=-1.6538049580807752) #每一行生成一個元組 Pandas(Index=3, col1=-0.4574258113524991, col2=0.737068849037987, col3=-1.0456494326191845)
七：pandas sorting排序
7.1 sort_index()
作用：默認根據行標簽對所有行排序，或根據列標簽對所有列排序，或根據指定某列或某幾列對行排序。
sort_index(axis=0, level=None, ascending=True, inplace=False, kind='quicksort', na_position='last', sort_remaining=True, by=None) #參數說明： axis： 0按照行名排序；1按照列名排序 level： 默認None，否則按照給定的level順序排列---貌似並不是，文檔 ascending： 默認True升序排列；False降序排列 inplace： 默認False，否則排序之后的數據直接替換原來的數據框 kind： 排序方法，{‘quicksort’, ‘mergesort’, ‘heapsort’}, default ‘quicksort’。似乎不用太關心。 na_position：缺失值默認排在最后{"first","last"} by： 按照某一列或幾列數據進行排序，但是by參數貌似不建議使用
1）axis=0, ascending=True 默認按“行標簽”升序排列
df = pd.DataFrame({'b':[1,2,2,3],'a':[4,3,2,1],'c':[1,3,8,2]},index=[2,0,1,3])
print(f'#原始數據\n{df}')
print(f'#默認按“行標簽”升序排序，或df.sort_index(axis=0, ascending=True)\n{df.sort_index()}')
執行結果：
#原始數據 b a c 2 1 4 1 0 2 3 3 1 2 2 8 3 3 1 2 #默認按“行標簽”升序排序，或df.sort_index(axis=0, ascending=True) b a c 0 2 3 3 1 2 2 8 2 1 4 1 3 3 1 2
2）axis=1 按“列標簽”升序排列
df = pd.DataFrame({'b':[1,2,2,3],'a':[4,3,2,1],'c':[1,3,8,2]},index=[2,0,1,3])
print(f'#原始數據\n{df}')
print(f'#按“列標簽”升序排序，或df.sort_index(axis=1, ascending=True)\n{df.sort_index(axis=1)}')
執行結果：
#原始數據 b a c 2 1 4 1 0 2 3 3 1 2 2 8 3 3 1 2 #按“列標簽”升序排序，或df.sort_index(axis=1, ascending=True) a b c 2 4 1 1 0 3 2 3 1 2 2 8 3 1 3 2
八：pandas去重函數：drop_duplicates()
8.1 函數格式
df.drop_duplicates(subset=['A','B','C'],keep='first',inplace=True) #參數說明如下： subset：表示要進去重的列名，默認為 None。 keep：有三個可選參數，分別是 first、last、False，默認為 first，表示只保留第一次出現的重復項，刪除其余重復項，last 表示只保留最后一次出現的重復項，False 則表示刪除所有重復項。 inplace：布爾值參數，默認為 False 表示刪除重復項后返回一個副本，若為 Ture 則表示直接在原數據上刪除重復項。
1) 保留第一次出現的行重復項
import pandas as pd data = { 'A':[1,0,1,1], 'B':[0,2,5,0], 'C':[4,0,4,4], 'D':[1,0,1,1] } df = pd.DataFrame(data) print(f'#原始數據\n{df}') #默認是keep=first 保留第一次出現的重復項 inplace=False 刪除后返回一個副本 df_drop = df.drop_duplicates() #或者寫出 df_drop = df.drop_duplicates(keep='first', inplace=False) print(f'#去重后的數據\n{df_drop}')
執行結果：
#原始數據 A B C D 0 1 0 4 1 1 0 2 0 0 2 1 5 4 1 3 1 0 4 1 #去重后的數據 A B C D 0 1 0 4 1 1 0 2 0 0 2 1 5 4 1
2) keep=False刪除所有行重復項
import pandas as pd data = { 'A':[1,0,1,1], 'B':[0,2,5,0], 'C':[4,0,4,4], 'D':[1,0,1,1] } df = pd.DataFrame(data) print(f'#原始數據\n{df}') #keep=False 刪除所有重復項(行) inplace=True 在原始的數據進行刪除重復項（行） df.drop_duplicates(keep=False,inplace=True) print(f'#去重后的數據\n{df}')
執行結果：
#原始數據 A B C D 0 1 0 4 1 1 0 2 0 0 2 1 5 4 1 3 1 0 4 1 #去重后的數據 keep=False 刪除所有重復項 A B C D 1 0 2 0 0 2 1 5 4 1
3）subset刪除指定的單列去重
import pandas as pd data = { 'A':[1,0,1,1], 'B':[0,2,5,0], 'C':[4,0,4,4], 'D':[1,0,1,1] } df = pd.DataFrame(data) print(f'#原始數據\n{df}') #subset：表示要進去重的列名，默認為 None。 ##去除所有重復項，對於B列來說兩個0是重復項 df_drop = df.drop_duplicates(subset=['B'],inplace=False, keep=False) #簡寫，省去subset參數 #df.drop_duplicates(['B'],keep=False) print(f'#刪除指定的列\n{df_drop}')
執行結果：
#原始數據 A B C D 0 1 0 4 1 1 0 2 0 0 2 1 5 4 1 3 1 0 4 1 #刪除指定的列 A B C D 1 0 2 0 0 2 1 5 4 1
從上述示例可以看出，刪除重復項后，行標簽使用的數字是原來的，並沒有從 0 重新開始，那么我們應該怎么從 0 重置索引呢？Pandas 提供的 reset_index() 函數會直接使用重置后的索引。
data = { 'A':[1,0,1,1], 'B':[0,2,5,0], 'C':[4,0,4,4], 'D':[1,0,1,1] } df = pd.DataFrame(data) print(f'#原始數據\n{df}') #去除所有重復項，對於B來說兩個0是重復項 df_drop = df.drop_duplicates(subset=['B'],inplace=False, keep=False) print(f'#刪除指定的列\n{df_drop}') #reset_index() 函數會直接使用重置后的索引,索引從0開始 df_reset = df_drop.reset_index(drop=True) print(f'重新設置行索引后的數據\n{df_reset}')
執行結果：
#原始數據 A B C D 0 1 0 4 1 1 0 2 0 0 2 1 5 4 1 3 1 0 4 1 #刪除指定的列 A B C D 1 0 2 0 0 2 1 5 4 1 #重新設置行索引后的數據 A B C D 0 0 2 0 0 1 1 5 4 1
4) subset指定多列同時去重
import pandas as pd df = pd.DataFrame({'C_ID':[1,1,2,12,34,23,45,34,23,12,2,3,4,1], 'Age':[12,12,15,18, 12, 25, 21, 25, 25, 18, 25,12,32,18], 'G_ID':['a','a','c','a','b','s','d','a','b','s','a','d','a','a']}) print(f'#原始數據\n{df}') #last只保留最后一個重復項 去除重復項后並不更改行索引 df_drop = df.drop_duplicates(['Age', 'G_ID'], keep='last') print(f'#去除指定多列的數據\n{df_drop}')
執行結果：
#原始數據 C_ID Age G_ID 0 1 12 a 1 1 12 a 2 2 15 c 3 12 18 a 4 34 12 b 5 23 25 s 6 45 21 d 7 34 25 a 8 23 25 b 9 12 18 s 10 2 25 a 11 3 12 d 12 4 32 a 13 1 18 a #去除指定多列的數據 C_ID Age G_ID 1 1 12 a 2 2 15 c 4 34 12 b 5 23 25 s 6 45 21 d 8 23 25 b 9 12 18 s 10 2 25 a 11 3 12 d 12 4 32 a 13 1 18 a
九：python Pandas缺失值處理
9.1檢查缺失值
為了使檢測缺失值變得更容易，Pandas 提供了 isnull() 和 notnull() 兩個函數，它們同時適用於 Series 和 DataFrame 對象
1）isnull() 判斷是缺失值 若是則返回True ，反之返回False
df = pd.DataFrame(np.random.randn(3, 3), index=list("ace"), columns=['one', 'two', 'three']) print(f'原始數據\n{df}') #通過使用 reindex（重構索引），創建了一個存在缺少值的 DataFrame對象 df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f']) print(f'#使用 reindex（重構索引)后的數據\n{df}') #isnull() 檢查是否是缺失值，若是則返回True 反之返回False print(f'#isnull()判斷第one列的每個元素是否是缺失值\n{df["one"].isnull()}')
執行結果：
#原始數據 one two three a -0.792201 0.659663 1.412614 c -1.204695 0.566436 -2.052258 e 0.829130 1.896560 -0.321445 #使用 reindex（重構索引)后的數據 one two three a -0.792201 0.659663 1.412614 b NaN NaN NaN c -1.204695 0.566436 -2.052258 d NaN NaN NaN e 0.829130 1.896560 -0.321445 f NaN NaN NaN #isnull()判斷第one列的每個元素是否是缺失值 a False b True c False d True e False f True Name: one, dtype: bool
2）notnull()判斷不是缺失值 若不是缺失值則返回True，反之返回False
df = pd.DataFrame(np.random.randn(3, 3), index=list("ace"), columns=['one', 'two', 'three']) print(f'原始數據\n{df}') #通過使用 reindex（重構索引），創建了一個存在缺少值的 DataFrame對象 df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f']) print(f'#使用 reindex（重構索引)后的數據\n{df}') #notnull() 檢查是否不是缺失值，若不是則返回True 反之返回False print(f'判斷是第one列的每個元素是否不是缺失值\n{df["one"].notnull()}')
執行結果：
#原始數據 one two three a -1.211702 0.977706 0.684588 c -0.042288 1.814968 -0.755887 e 1.144412 0.206859 -1.498902 #使用 reindex（重構索引)后的數據 one two three a -1.211702 0.977706 0.684588 b NaN NaN NaN c -0.042288 1.814968 -0.755887 d NaN NaN NaN e 1.144412 0.206859 -1.498902 f NaN NaN NaN #判斷是第one列的每個元素是否不是缺失值 a True b False c True d False e True f False Name: one, dtype: bool
9.2缺失數據計算
計算缺失數據時，需要注意兩點：首先數據求和時，將 NA 值視為 0 ，其次，如果要計算的數據為 NA，那么結果就是 NA
df = pd.DataFrame(np.random.randn(3, 3), index=list("ace"), columns=['one', 'two', 'three']) print(f'#原始數據\n{df}') #通過使用 reindex（重構索引），創建了一個存在缺少值的 DataFrame對象 df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f']) print(f'#使用 reindex（重構索引)后的數據\n{df}') #計算缺失數據時，需要注意兩點：首先數據求和時，將 NA 值視為 0 ，其次，如果要計算的數據為 NA，那么結果就是 NA print(df['one'].sum())
執行結果：
#原始數據 one two three a 2.570816 0.489973 -1.334633 c -0.277604 0.691039 -3.298916 e 0.651539 0.145426 0.197667 #使用 reindex（重構索引)后的數據 one two three a 2.570816 0.489973 -1.334633 b NaN NaN NaN c -0.277604 0.691039 -3.298916 d NaN NaN NaN e 0.651539 0.145426 0.197667 f NaN NaN NaN #第one列求和結果： 2.944751293477092
9.3清理並填充缺失值
1）fillna()標量替換NaN
df = pd.DataFrame(np.random.randn(3, 3), index=list("ace"), columns=['one', 'two', 'three']) print(f'#原始數據\n{df}') #通過使用 reindex（重構索引），創建了一個存在缺少值的 DataFrame對象 df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f']) print(f'#使用 reindex（重構索引)后的數據\n{df}') #用fillna(6)標量替換NaN print(f'用fillna(6)標量替換NaN后的數據\n{df.fillna(6)}')
執行結果：
#原始數據 one two three a 0.252345 0.429046 -2.552799 c -2.404367 -1.042196 0.655366 e -0.254975 0.224454 -0.493185 #使用 reindex（重構索引)后的數據 one two three a 0.252345 0.429046 -2.552799 b NaN NaN NaN c -2.404367 -1.042196 0.655366 d NaN NaN NaN e -0.254975 0.224454 -0.493185 f NaN NaN NaN #用fillna(6)標量替換NaN后的數據 one two three a 0.252345 0.429046 -2.552799 b 6.000000 6.000000 6.000000 c -2.404367 -1.042196 0.655366 d 6.000000 6.000000 6.000000 e -0.254975 0.224454 -0.493185 f 6.000000 6.000000 6.000000
2) ffill() 向前填充和 bfill() 向后填充填充NA
df = pd.DataFrame(np.random.randn(3, 3), index=list("ace"), columns=['one', 'two', 'three']) print(f'#原始數據\n{df}') #通過使用 reindex（重構索引），創建了一個存在缺少值的 DataFrame對象 df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f']) print(f'#使用 reindex（重構索引)后的數據\n{df}') print(f"#.fillna(method='ffill')向前填充后的數據\n{df.fillna(method='ffill')}") #或者解寫為df.ffill() # print(df.ffill()) print(f"#.bfillna()向后填充后的數據\n{df.bfill()}")
執行結果：
#原始數據 one two three a -0.657623 0.003340 0.866407 c 0.668809 -0.155485 -0.065128 e -0.303612 -0.119558 1.671199 #使用 reindex（重構索引)后的數據 one two three a -0.657623 0.003340 0.866407 b NaN NaN NaN c 0.668809 -0.155485 -0.065128 d NaN NaN NaN e -0.303612 -0.119558 1.671199 f NaN NaN NaN #.fillna(method='ffill'等價於df.ffill()向前填充后的數據 one two three a -0.657623 0.003340 0.866407 b -0.657623 0.003340 0.866407 c 0.668809 -0.155485 -0.065128 d 0.668809 -0.155485 -0.065128 e -0.303612 -0.119558 1.671199 f -0.303612 -0.119558 1.671199 #.bfill()向后填充后的數據 如果最后面沒有數據就不會填充 one two three a -0.657623 0.003340 0.866407 b 0.668809 -0.155485 -0.065128 c 0.668809 -0.155485 -0.065128 d -0.303612 -0.119558 1.671199 e -0.303612 -0.119558 1.671199 f NaN NaN NaN
3) 使用replace替換通用值
在某些情況下，您需要使用 replace() 將 DataFrame 中的通用值替換成特定值，這和使用 fillna() 函數替換 NaN 值是類似的
df = pd.DataFrame({'one':[10,20,30,40,50,10], 'two':[99,0,30,40,50,60]})
print(f'#原始數據\n{df}')
df = df.replace({10:100,30:333,99:9})
print(f'#replace替換后的數據\n{df}')
執行結果：
#原始數據 one two 0 10 99 1 20 0 2 30 30 3 40 40 4 50 50 5 10 60 #replace替換后的數據 one two 0 100 9 1 20 0 2 333 333 3 40 40 4 50 50 5 100 60
9.4刪除缺失值
如果想刪除缺失值，那么使用 dropna() 函數與參數 axis 可以實現。在默認情況下，按照 axis=0 來按行處理，這意味着如果某一行中存在 NaN 值將會刪除整行數據
df = pd.DataFrame(np.random.randn(3, 3), index=list("ace"), columns=['one', 'two', 'three']) print(f'#原始數據\n{df}') #通過使用 reindex（重構索引），創建了一個存在缺少值的 DataFrame對象 df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f']) print(f'#使用 reindex（重構索引)后的數據\n{df}') #dropna() axis=0如果某一行中存在 NaN 值將會刪除整行數據 print(f'#dropna()刪除后的數據\n{df.dropna()}')
執行的結果：
#原始數據 one two three a -1.706917 0.169167 -1.149683 c -0.132433 -0.003184 -0.562634 e -0.865398 -0.877156 1.870602 #使用 reindex（重構索引)后的數據 one two three a -1.706917 0.169167 -1.149683 b NaN NaN NaN c -0.132433 -0.003184 -0.562634 d NaN NaN NaN e -0.865398 -0.877156 1.870602 f NaN NaN NaN #dropna()刪除后的數據 one two three a -1.706917 0.169167 -1.149683 c -0.132433 -0.003184 -0.562634 e -0.865398 -0.877156 1.870602
十：pandas csv讀寫文件
使用pandas做數據處理的第一步就是讀取數據，數據源可以來自於各種地方，csv文件便是其中之一。而讀取csv文件，pandas也提供了非常強力的支持，參數有四五十個。這些參數中，有的很容易被忽略，但是在實際工作中卻用處很大 。
10.1 read_csv()
pandas.read_csv(filepath_or_buffer, sep=',', delimiter=None, header='infer',names=None, index_col=None, usecols=None)
1) index_col()自定義索引
在 CSV 文件中指定了一個列，然后使用index_col可以實現自定義索引
#讀取csv文件數據 sep :指定分隔符。如果不指定參數，則會嘗試使用逗號分隔 df = pd.read_csv('/Users/testin/PycharmProjects/untitled4/person.csv', sep=',') print(f'#讀取csv文件數據\n{df}') #使用index_col可以實現自定義索引 df = pd.read_csv('/Users/testin/PycharmProjects/untitled4/person.csv', index_col=['ID']) print(f'使用index_col可以實現自定義索引\n{df}') print(f'獲取自定義的索引={df.index}')
執行結果：
#讀取csv文件數據 ID Name Age City Salary 0 1 Jack 28 Beijing 22000 1 2 Lida 32 Shanghai 19000 2 3 John 43 Shenzhen 12000 3 4 Helen 38 Hengshui 3500 #使用index_col可以實現自定義索引 Name Age City Salary ID 1 Jack 28 Beijing 22000 2 Lida 32 Shanghai 19000 3 John 43 Shenzhen 12000 4 Helen 38 Hengshui 3500 #獲取自定義的索引=Int64Index([1, 2, 3, 4], dtype='int64', name='ID')
2) names更改文件標頭名
使用 names 參數可以指定頭文件的名稱
- 當names沒被賦值時，header會變成0，即選取數據文件的第一行作為列名。
- 當 names 被賦值，header 沒被賦值時，那么header會變成None。如果都賦值，就會實現兩個參數的組合功能。
df = pd.read_csv('/Users/testin/PycharmProjects/untitled4/person.csv', sep=',') print(f'#讀取csv文件數據\n{df}') #names更改文件標頭名 header 沒有賦值 df = pd.read_csv('/Users/testin/PycharmProjects/untitled4/person.csv', names=['a', 'b', 'c', 'd', 'e']) print(f'#names 更改表頭名\n{df}')
執行結果：
#讀取csv文件數據 ID Name Age City Salary 0 1 Jack 28 Beijing 22000 1 2 Lida 32 Shanghai 19000 2 3 John 43 Shenzhen 12000 3 4 Helen 38 Hengshui 3500 #names 更改表頭名 a b c d e 0 ID Name Age City Salary 1 1 Jack 28 Beijing 22000 2 2 Lida 32 Shanghai 19000 3 3 John 43 Shenzhen 12000 4 4 Helen 38 Hengshui 3500
注意：文件標頭名是附加的自定義名稱，但是您會發現，原來的標頭名（列標簽名）並沒有被刪除，此時您可以使用header參數來刪除它
#names更改文件標頭名 header為變成0，即選取文件的第一行作為表頭 df = pd.read_csv("/Users/testin/PycharmProjects/untitled4/person.csv", names=['a', 'b', 'c', 'd', 'e'],header=0) print(f'#names 更改表頭名且header=0\n{df}') df = pd.read_csv('/Users/testin/PycharmProjects/untitled4/person.csv',header=1) #不指定names，指定header為1，則選取第二行當做表頭，第二行下面的是數據
print(f'#不指定names，指定header=1則選取第二行當做表頭\n{df}')
執行結果：
#names 更改表頭名且header=0 a b c d e 0 1 Jack 28 Beijing 22000 1 2 Lida 32 Shanghai 19000 2 3 John 43 Shenzhen 12000 3 4 Helen 38 Hengshui 3500 #不指定names，指定header=1則選取第二行當做表頭 1 Jack 28 Beijing 22000 0 2 Lida 32 Shanghai 19000 1 3 John 43 Shenzhen 12000 2 4 Helen 38 Hengshui 3500
3) skiprows跳過指定的行數
skiprows參數表示跳過指定的行數
df = pd.read_csv('/Users/testin/PycharmProjects/untitled4/person.csv', names=['a', 'b', 'c', 'd', 'e'],header=0)
print(f'#names 更改表頭名且header=0\n{df}')
#skiprows指定跳過行數
df = pd.read_csv('/Users/testin/PycharmProjects/untitled4/person.csv',skiprows=2)
print(f'#skiprows指定跳過行數\n{df}')
執行結果：
#names 更改表頭名且header=0 a b c d e 0 1 Jack 28 Beijing 22000 1 2 Lida 32 Shanghai 19000 2 3 John 43 Shenzhen 12000 3 4 Helen 38 Hengshui 3500 #skiprows指定跳過行數 2 Lida 32 Shanghai 19000 0 3 John 43 Shenzhen 12000 1 4 Helen 38 Hengshui 3500
注意：包含標頭所在行
10.2 to_csv()
Pandas 提供的 to_csv() 函數用於將 DataFrame 轉換為 CSV 數據。如果想要把 CSV 數據寫入文件，只需向函數傳遞一個文件對象即可。否則，CSV 數據將以字符串格式返回。
data = {'Name': ['Smith', 'Parker'], 'ID': [101, 102], 'Language': ['Python', 'JavaScript']}
df_data = pd.DataFrame(data)
print(f'#DataFrame原始數據\n{df_data}')
#通過to_csv()轉成csv文件數據
df_csv = df_data.to_csv()
print(f'#通過to_csv()轉成csv文件數據后的數據\n{df_csv}')
#指定 CSV 文件輸出時的分隔符，並將其保存在 pandas.csv 文件中index=False 表示不寫入索引
df_data.to_csv("/Users/testin/PycharmProjects/untitled4/person.csv",sep='|',index=False)
執行結果：
#DataFrame原始數據 Name ID Language 0 Smith 101 Python 1 Parker 102 JavaScript #通過to_csv()轉成csv文件數據后的數據 ,Name,ID,Language 0,Smith,101,Python 1,Parker,102,JavaScript
10.3 to_dict()
請參考：https://blog.csdn.net/qq_45083975/article/details/104502983
to_dict()可以對DataFrame類型的數據進行轉換
可以選擇六種的轉換類型，分別對應於參數 ‘dict’, ‘list’, ‘series’, ‘split’, ‘records’, ‘index’，下面逐一介紹每種的用法
data = pd.DataFrame([['3rd', 31.194181, 'UNKNOWN', 'UNKNOWN', 'male'], ['1rd', 31.194181, 'Cherbourg', 'Paris, France', 'female'], ['3rd', 31.194181, 'UNKNOWN', 'UNKNOWN', 'male']], index=['1086', '12', '1036'], columns=['pclass', 'age', 'embarked', 'home.dest', 'sex']) print(data)
輸出結果：
1、選擇參數orient=’dict’ ，可以看成是一種雙重字典結構（columns是外層鍵，index是內層鍵）形成結構{column -> {index -> value}}
data_dict = data.to_dict(orient='dict') print(data_dict)
輸出結果：
{ 'pclass': {'1086': '3rd', '12': '1rd', '1036': '3rd'},
'age': {'1086': 31.194181, '12': 31.194181, '1036': 31.194181},
'embarked': {'1086': 'UNKNOWN', '12': 'Cherbourg', '1036': 'UNKNOWN'},
'home.dest': {'1086': 'UNKNOWN', '12': 'Paris, France', '1036': 'UNKNOWN'},
'sex': {'1086': 'male', '12': 'female', '1036': 'male'} }
2、選擇參數orient=’list’ ，也可以看成是一種雙重字典結構，只不過內層變成了一個列表（columns是外層鍵，不顯示index）形成結構 {column -> [values]}
data_dict = data.to_dict(orient='list') print(data_dict)
輸出結果：
{'pclass': ['3rd', '1rd', '3rd'],
'age': [31.194181, 31.194181, 31.194181],
'embarked': ['UNKNOWN', 'Cherbourg', 'UNKNOWN'],
'home.dest': ['UNKNOWN', 'Paris, France', 'UNKNOWN'],
'sex': ['male', 'female', 'male']
}
data_dict = data.to_dict(orient='series') print(data_dict)
輸出結果：
{'pclass': 1086 3rd
12 1rd
1036 3rd
Name: pclass, dtype: object, 'age': 1086 31.194181
12 31.194181
1036 31.194181
Name: age, dtype: float64, 'embarked': 1086 UNKNOWN
12 Cherbourg
1036 UNKNOWN
Name: embarked, dtype: object, 'home.dest': 1086 UNKNOWN
12 Paris, France
1036 UNKNOWN
Name: home.dest, dtype: object, 'sex': 1086 male
12 female
1036 male
Name: sex, dtype: object}
4、選擇參數orient=’split’形成結構{index -> [index], columns -> [columns], data -> [[values]，[values]，[values]……]}。總體分為三部分：index、columns、data
data_dict = data.to_dict(orient='split') print(data_dict)
輸出結果：
{ 'index': ['1086', '12', '1036'], 'columns': ['pclass', 'age', 'embarked', 'home.dest', 'sex'], 'data': [ ['3rd', 31.194181, 'UNKNOWN', 'UNKNOWN', 'male'], ['1rd', 31.194181, 'Cherbourg', 'Paris, France', 'female'], ['3rd', 31.194181, 'UNKNOWN', 'UNKNOWN', 'male'] ] }
5、選擇參數orient=’records’ （不顯示index）形成結構[{column -> value}, … , {column -> value}]，可以看作是一條數據一條數據組成的集合，不顯示index
data_dict = data.to_dict(orient='records') print(data_dict)
輸出結果：
[ {'pclass': '3rd', 'age': 31.194181, 'embarked': 'UNKNOWN', 'home.dest': 'UNKNOWN', 'sex': 'male'}, {'pclass': '1rd', 'age': 31.194181, 'embarked': 'Cherbourg', 'home.dest': 'Paris, France', 'sex': 'female'}, {'pclass': '3rd', 'age': 31.194181, 'embarked': 'UNKNOWN', 'home.dest': 'UNKNOWN', 'sex': 'male'} ]
6、選擇參數orient=’index’形成結構{index -> {column -> value}}，可以看作是一條數據一條數據組成的集合，但是每條數據之前顯示index
data_dict = data.to_dict(orient='index') print(data_dict)
輸出結果：
{ '1086': {'pclass': '3rd', 'age': 31.194181, 'embarked': 'UNKNOWN', 'home.dest': 'UNKNOWN', 'sex': 'male'}, '12': {'pclass': '1rd', 'age': 31.194181, 'embarked': 'Cherbourg', 'home.dest': 'Paris, France', 'sex': 'female'}, '1036': {'pclass': '3rd', 'age': 31.194181, 'embarked': 'UNKNOWN', 'home.dest': 'UNKNOWN', 'sex': 'male'} }
10.4 to_records()
DataFrame.to_records()函數將數據幀轉換為數字記錄數組。如果需要，索引將作為記錄數組的第一個字段,
語法:data frame . to _ records(index = True，convert _ datetime64 =無，column _ dtypes =無，index _ dtypes =無)
參數: 索引: bool，默認 True convert _ datetime 64:如果是 DatetimeIndex，是否將索引轉換為 datetime.datetime。 column _ dttypes:如果是字符串或類型，則數據類型存儲所有列 index _ dttypes:如果是字符串或類型，則數據類型存儲所有索引級別
返回: numpy.recarray
to_records()可以把每一行的數據轉成一個元組
df = pd.DataFrame({'Weight': [45, 88, 56, 15, 71],
'Name': ['Sam', 'Andrea', 'Alex', 'Robin', 'Kia'],
'Age': [14, 25, 55, 8, 21]})
print(df)
records = df.to_records()
print(records)
print(type(records))
records1 = df.to_records(index=False)
print("==============")
print(records1)
十一：pandas Excel讀寫操作詳解
11.1 to_excel()
通過 to_excel() 函數可以將 Dataframe 中的數據寫入到 Excel 文件。
如果想要把單個對象寫入 Excel 文件，那么必須指定目標文件名；如果想要寫入到多張工作表中，則需要創建一個帶有目標文件名的ExcelWriter對象，並通過sheet_name參數依次指定工作表的名稱。
1）創建名表格並寫入數據
# to_ecxel() 語法格式如下: 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_wirter | 文件路徑或者 ExcelWrite 對象。 |
| sheet_name | 指定要寫入數據的工作表名稱。 |
| na_rep | 缺失值的表示形式。 |
| float_format | 它是一個可選參數，用於格式化浮點數字符串。 |
| columns | 指要寫入的列。 |
| header | 寫出每一列的名稱，如果給出的是字符串列表，則表示列的別名。 |
| index | 表示要寫入的索引。 |
| index_label | 引用索引列的列標簽。如果未指定，並且 hearder 和 index 均為為 True，則使用索引名稱。如果 DataFrame 使用 MultiIndex，則需要給出一個序列。 |
| startrow | 初始寫入的行位置，默認值0。表示引用左上角的行單元格來儲存 DataFrame。 |
| startcol | 初始寫入的列位置，默認值0。表示引用左上角的列單元格來儲存 DataFrame。 |
| engine | 它是一個可選參數，用於指定要使用的引擎，可以是 openpyxl 或 xlsxwriter。 |
創建表格並寫入數據：
#創建DataFrame數據 info_website = pd.DataFrame({'name': ['編程幫', 'c語言中文網', '微學苑', '92python'], 'rank': [1, 2, 3, 4], 'language': ['PHP', 'C', 'PHP','Python' ], 'url': ['www.bianchneg.com', 'c.bianchneg.net', 'www.weixueyuan.com','www.92python.com' ]}) print(f'#DataFrame數據\n{info_website}') #創建ExcelWrite對象 writer = pd.ExcelWriter(to_excle_file_path) info_website.to_excel(writer) writer.save() writer.close()
注意：
使用pd.ExcelWriter生成writer，然后就可將數據寫入該excel文件了，但是寫完之后必須要writer.save()和writer.close()，否則數據仍然只在數據流中，並沒保存到excel文件中。
執行結果：
2）一次性插入多個sheet數據
注意：此操作會將原文件內容覆蓋掉
to_excle_file_path = os.path.abspath(os.path.join(os.path.dirname(__file__),os.pardir,'Data/to_excle.xlsx'))
#創建DataFrame數據 字典嵌套數組類型 info_website = pd.DataFrame({'name': ['編程幫', 'c語言中文網', '微學苑', '92python'], 'rank': [1, 2, 3, 4], 'language': ['PHP', 'C', 'PHP','Python' ], 'url': ['www.bianchneg.com', 'c.bianchneg.net', 'www.weixueyuan.com','www.92python.com' ]}) print(f'#DataFrame數據\n{info_website}')
#數組嵌套字典類型
data = [{'a': 1, 'b': 2,'c':3},{'a': 5, 'b': 10, 'c': 20},{'a': "王者", 'b': '黃金', 'c': '白銀'}]
df = pd.DataFrame(data)
print(f'#DataFrame數據\n{df}')
df.to_excel(writer)
info_website.to_excel(writer, sheet_name="這是第一個sheet", index=False)
info_website.to_excel(writer, sheet_name="這是第二個sheet", index=False)
writer.save()
writer.close()
執行結果是：
3) 追加sheet表內容
按照官網的示例使用writer = pd.ExcelWriter("excel 樣例.xlsx", mode='a')就能插入sheet，而不是覆蓋原文件，然而我進行該操作之后就報錯了如：
writer = pd.ExcelWriter("excel 樣例.xlsx", mode='a') Traceback (most recent call last): File "<ipython-input-75-8f1e772ce767>", line 1, in <module> writer = pd.ExcelWriter("excel 樣例.xlsx", mode='a') File "D:\anaconda\lib\site-packages\pandas\io\excel\_xlsxwriter.py", line 177, in __init__ raise ValueError("Append mode is not supported with xlsxwriter!") ValueError: Append mode is not supported with xlsxwriter!
原因是現在常用的寫入excel模塊是openpyxl和xlsxwriter，pd.ExcelWriter方法默認是xlsxwriter，但是xlsxwriter不支持append操作，具體解釋可以參考。因此我們只需要更改模塊就行：
writer = pd.ExcelWriter(to_excle_file_path,mode='a',engine='openpyxl') info_website.to_excel(writer, sheet_name="追加第一個sheet", index=False) info_website.to_excel(writer, sheet_name="追加第二個sheet", index=False) writer.save() writer.close()
執行結果：
11.2 read_excel()
如果您想讀取 Excel 表格中的數據，可以使用 read_excel() 方法，其語法格式如下：
pd.read_excel(io, sheet_name=0, header=0, names=None, index_col=None, usecols=None, squeeze=False,dtype=None, engine=None, converters=None, true_values=None, false_values=None, skiprows=None, nrows=None, na_values=None, parse_dates=False, date_parser=None, thousands=None, comment=None, skipfooter=0, convert_float=True, **kwds)
下表對常用參數做了說明：
1）處理未命名的列 以及重新定義索引
#讀取excel數據 file_path = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'Data/website.xlsx')) df = pd.read_excel(file_path, engine='openpyxl') print(f'#原始數據\n{df}') #選擇name列做為索引，並跳過前兩行 df = pd.read_excel(file_path, index_col='name', skiprows=[2], engine='openpyxl') print(f'#選擇name列做為索引，並跳過前兩行\n{df}') #處理未命名列 df.columns = df.columns.str.replace('Unnamed.*', 'col_label') print(f'#修改為未命名的列\n{df}')
執行結果；
#原始數據 name rank language URL Unnamed: 4 0 編程幫 1 C語言 www.bianchneg.com biancheng 1 微學苑 2 Java www.weixueyuan.com QWER 2 Python 3 Python www.92python.com ASDF #選擇name列做為索引，並跳過前兩行 rank language URL Unnamed: 4 name 編程幫 1 C語言 www.bianchneg.com biancheng Python 3 Python www.92python.com ASDF #修改為未命名的列 rank language URL col_label name 編程幫 1 C語言 www.bianchneg.com biancheng Python 3 Python www.92python.com ASDF
2）index_col前多列作為索引列，usecols設置讀取的數據列
file_path = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'Data/website.xlsx')) df = pd.read_excel(file_path, engine='openpyxl') print(f'#原始數據\n{df}') #index_col選擇前兩列作為索引列 選擇前三列數據，name列作為行索引 df = pd.read_excel(file_path, index_col=[0,1], usecols=[0,1,2],engine='openpyxl') print(f'#ndex_col選擇前兩列作為索引列 選擇前三列數據，name列作為行索引\n{df}')
執行結果：
#原始數據 name rank language URL Unnamed: 4 0 編程幫 1 C語言 www.bianchneg.com biancheng 1 微學苑 2 Java www.weixueyuan.com QWER 2 Python 3 Python www.92python.com ASDF #ndex_col選擇前兩列作為索引列 選擇前三列數據，name列作為行索引 language name rank 編程幫 1 C語言 微學苑 2 Java Python 3 Python
十二：pandas和numpy的比較
我們知道 Pandas 是在 NumPy 的基礎構建而來，因此，熟悉 NumPy 可以更加有效的幫助我們使用 Pandas。
NumPy 主要用 C語言編寫，因此，在計算還和處理一維或多維數組方面，它要比 Python 數組快得多。關於 NumPy 的學習http://c.biancheng.net/numpy/
12.1創建數組
數組的主要作用是在一個變量中存儲多個值。NumPy 可以輕松地處理多維數組。
import numpy as np np_arr = np.array([12,21,31,41,51]) print(f'#數據類型\n{type(np_arr)}') print(f"#打印新建數組:{np_arr}", end="") #for循環獲取數據 for i in range(5): print(f'for循環獲取數據:{np_arr[i]}')
執行結果：
#數據類型 <class 'numpy.ndarray'> #打印新建數組:[12 21 31 41 51]for循環獲取數據:12 for循環獲取數據:21 for循環獲取數據:31 for循環獲取數據:41 for循環獲取數據:51
12.2布爾索引
布爾索引是 NumPy 的重要特性之一，通常與 Pandas 一起使用。它的主要作用是過濾 DataFrame 中的數據，比如布爾值的掩碼操作。
下面示例展示了如何使用布爾索引訪問 DataFrame 中的數據。
data = {'name':["Smith", "William", "Phill", "Parker"],
'age': ["28", "39", "34", "36"]}
df = pd.DataFrame(data, index=[True, True, False, True])
print(f'#原始數據\n{df}')
#.loc訪問索引為 True 的數據
print(f'#.loc訪問索引為 True 的數據\n{df.loc[True]}')
執行結果：
#原始數據 name age True Smith 28 True William 39 False Phill 34 True Parker 36 #.loc訪問索引為 True 的數據 name age True Smith 28 True William 39 True Parker 36
12.3重塑數組形狀
在不改變數組數據的情況下，對數組進行變形操作，即改變數組的維度，比如 23（兩行三列）的二維數組變維 32（三行兩列）的二維數組。變形操作可以通過 reshape() 函數實現
arr = np.arange(16) print("#原數組: \n", arr) arr1 = arr.reshape(2,8) print(f'#變形后數組\n{arr1}')
執行結果：
#原數組: [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15] #變形后數組 [[ 0 1 2 3 4 5 6 7] [ 8 9 10 11 12 13 14 15]]
12.4Pdans與NumPy區別
Pandas 和 NumPy 被認為是科學計算與機器學習中必不可少的庫，因為它們具有直觀的語法和高性能的矩陣計算能力。下面對 Pandas 與 NumPy 進行簡單的總結，如下表所示：
1）轉換ndarray數組
在某些情況下，需要執行一些 NumPy 數值計算的高級函數，這個時候您可以使用 to_numpy() 函數，將 DataFrame 對象轉換為 NumPy ndarray 數組，並將其返回。
DataFrame.to_numpy(dtype=None, copy=False) #參數說明： dtype：可選參數，表示數據類型； copy：布爾值參數，默認值為 Fales，表示返回值不是其他數組的視圖。
df = pd.DataFrame({"P": [2, 3], "Q": [4.0, 5.8]})
#給df添加R列
df['R'] = pd.date_range('2020-12-23', periods=2)
print(f'#創建的df數據\n{df}')
#將其轉化為numpy數組
print(f'#將其轉化為numpy數組\n{df.to_numpy()}')
執行結果：
#創建的df數據 P Q R 0 2 4.0 2020-12-23 1 3 5.8 2020-12-24 #將其轉化為numpy數組 [[2 4.0 Timestamp('2020-12-23 00:00:00')] [3 5.8 Timestamp('2020-12-24 00:00:00')]]
參考：
https://blog.csdn.net/qq_41854911/article/details/122696986
http://c.biancheng.net/pandas/fillna.html
https://blog.csdn.net/qq_35318838/article/details/104692846