前言
本文的文字及圖片來源於網絡,僅供學習、交流使用,不具有任何商業用途,版權歸原作者所有,如有問題請及時聯繫我們以作處理。
1.pandas的數據結構介紹
pandas的兩個主要數據結構: Series和DataFrame
1.1 Series
1 Series的基本概念和形式
Series是一種類似於一維數組的對象, 它由一組數據 (各種NumPy數據類型) 以及一組與之相關的數據標籤 (即索引) 組成
Series的字符串表現形式爲: 索引在左邊, 值在右邊. 由於我們沒有爲數據指定索引, 於是會自動創建一個0到 N-1 (N爲數據的長度) 的整數型索引
In [2]: import pandas as pd
In [3]: obj = pd.Series([1,2,3,4])
In [4]: obj
Out[4]:
0 1
1 2
2 3
3 4
dtype: int64
2 Series的values, index和name屬性
可以通過Series 的values和index屬性獲取其數組表示形式和索引對象
In [5]: obj.values
Out[5]: array([ 4, 7, -5, 3], dtype=int64)
In [6]: obj.index
Out[6]: RangeIndex(start=0, stop=4, step=1)
Series對象本身及其索引都有一個name屬性, 該屬性跟pandas其他的關鍵功能關係非常密切
In [32]: obj4
Out[32]:
California NaN
Ohio 35000.0
Oregon 16000.0
Texas 71000.0
dtype: float64
In [33]: obj4.name = 'population'
In [34]: obj4.index.name = 'state'
In [35]: obj4
Out[35]:
state
California NaN
Ohio 35000.0
Oregon 16000.0
Texas 71000.0
Name: population, dtype: float64
3 Series的索引
Series的字符串表現形式爲: 索引在左邊, 值在右邊. 如果沒有指定索引, 那麼就會自動創建一個0到N-1的整數型索引. (比如上面的obj)
(1) 自行創建索引
創建的Series帶有一個可以對各個數據點進行標記的索引, 即可以自己創建索引的名字.
In [7]: obj2 = pd.Series([4,7,-5,3],index=['d','b','a','c'])
In [8]: obj2
Out[8]:
d 4
b 7
a -5
c 3
dtype: int64
In [9]: obj2.index
Out[9]: Index(['d', 'b', 'a', 'c'], dtype='object')
In [10]: obj.values
Out[10]: array([ 4, 7, -5, 3], dtype=int64)
(2) Series索引的使用
可以通過索引的方式選取Series中的單個或一組值
可使用原索引名字, 也可以用數字索引 # 如obj2[‘a’]或boj2[2], 結果都是-5
索引查找單個值 # obj2[‘a’]
索引查找一組值 # obj2[[‘c’,‘a’,‘d’]]
結果以[‘c’,‘a’,‘d’]排序
利用索引重新賦值 # obj2[‘d’] = 6
In [13]: obj2['a']#索引查找單個值
Out[13]: -5
In [14]: obj2['d'] = 6#利用索引重新賦值
In [16]: obj2[['c','a','d']]#索引查找一組值
Out[16]:
c 3
a -5
d 6
dtype: int64
其中, [‘c’,‘a’,‘d’] 是索引列表. 可以是字符串形式, 也可以是數字.
(3) 索引本身的修改
Series的索引可以通過賦值的方式就地修改
In [10]: obj
Out[10]:
0 4
1 7
2 -5
3 3
dtype: int64
In [11]: obj.index = ['Bob', 'Steve', 'Jeff', 'Ryan']
In [12]: obj
Out[12]:
Bob 4
Steve 7
Jeff -5
Ryan 3
dtype: int64
(4) 運算會保留索引值的鏈接
使用NumPy函數或類似NumPy的運算 (如根據布爾型數組進行過濾、標量乘法、應用數學函數等) 都會保留索引值的鏈接.
In [17]: obj2[obj2>0]
Out[17]:
d 6
b 7
c 3
dtype: int64
In [18]: obj2 * 2
Out[18]:
d 12
b 14
a -10
c 6
dtype: int64
In [19]: np.exp(obj2)
Out[19]:
d 403.428793
b 1096.633158
a 0.006738
c 20.085537
dtype: float64
4 Series與字典
(1) 將Series看成一個定長的有序字典
還可以將Series看成是一個定長的有序字典, 因爲它是索引值到數據值的一個映射. 它可以用在許多原本需要字典參數的函數中.
In [20]: 'b' in obj2
Out[20]: True
In [21]: 'e' in obj2
Out[21]: False
(2) 通過字典創建Series
如果數據被存放在一個Python字典中, 也可以直接通過這個字典來創建Series.
如果只傳入一個字典, 則結果Series中的索引就是原字典的鍵 (有序排列)
In [22]: sdata = {'Ohio':35000, 'Texas':71000, 'Oregon': 16000,'Utah': 50000}
In [23]: 'Ohio' in sdata
Out[23]: True
In [24]: obj3 = pd.Series(sdata)
In [25]: obj3
Out[25]:
Ohio 35000
Texas 71000
Oregon 16000
Utah 50000
dtype: int64
(3) 可以傳入排好序的字典的鍵以改變順序
In [26]: states = ['California', 'Ohio', 'Oregon', 'Texas']
In [27]: obj4 = pd.Series(sdata,index=states)
In [28]: obj4
Out[28]:
California NaN
Ohio 35000.0
Oregon 16000.0
Texas 71000.0
dtype: float64
sdata中跟states索引相匹配的那3個值會被找出來並放到相應的位置上, 但由於"California"所對應的sdata值找不到, 所以其結果就爲NaN(即非數字, not a number)
‘Utah’不在states中, 它被從結果中除去
5 pandas中檢測缺失數據
pandas的isnull和notnull函數可用於檢測缺失數據. isnull和notnull既是pandas的頂級函數, 也是方法.
In [29]: pd.isnull(obj4)
Out[29]:
California True
Ohio False
Oregon False
Texas False
dtype: bool
In [30]: pd.notnull(obj4)
Out[30]:
California False
Ohio True
Oregon True
Texas True
dtype: bool
In [31]: obj4.notnull()
Out[31]:
California False
Ohio True
Oregon True
Texas True
dtype: bool
6 Series根據索引標籤自動對齊數據
Series最重要的一個功能是, 它會根據運算的索引標籤自動對齊數據
In [36]: obj3
Out[36]:
Ohio 35000
Texas 71000
Oregon 16000
Utah 50000
dtype: int64
In [37]: obj4
Out[37]:
state
California NaN
Ohio 35000.0
Oregon 16000.0
Texas 71000.0
Name: population, dtype: float64
In [38]: obj3+obj4
Out[38]:
California NaN
Ohio 70000.0
Oregon 32000.0
Texas 142000.0
Utah NaN
dtype: float64
1.2 DataFrame
1 DataFrame的基本概念
DataFrame是一個表格型的數據結構, 它含有一組有序的列, 每列可以是不同的值類型 (數值、字符串、布爾值等)
DataFrame既有行索引也有列索引, 它可以被看做由Series組成的字典 (共用同一個索引)
DataFrame中的數據是以一個或多個二維塊存放的 (而不是列表、字典或別的一維數據結構)
2 創建DataFrame
(1) 直接傳入等長列表或numpy數組組成的字典
建DataFrame的辦法有很多, 最常用的一種是直接傳入一個由等長列表或NumPy數組組成的字典.
In [3]: 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 [4]: frame = pd.DataFrame(data)
In [5]: frame
Out[5]:
state year pop
0 Ohio 2000 1.5
1 Ohio 2001 1.7
2 Ohio 2002 3.6
3 Nevada 2001 2.4
4 Nevada 2002 2.9
5 Nevada 2003 3.2
和Series一樣, 結果DataFrame會自動加上索引, 且全部列會被有序排列
選取前五行–head方法:
對於特別大的DataFrame, head方法會選取前五行顯示:
In [7]: frame.head()
Out[7]:
state year pop
0 Ohio 2000 1.5
1 Ohio 2001 1.7
2 Ohio 2002 3.6
3 Nevada 2001 2.4
4 Nevada 2002 2.9
(2) 指定index和columns
也可以指定行索引和列索引
- 指定列索引
如果指定了列索引, 則DataFrame的列就會按照指定順序進行排列
In [13]: pd.DataFrame(data,columns=['year','state','pop'])
Out[13]:
year state pop
0 2000 Ohio 1.5
1 2001 Ohio 1.7
2 2002 Ohio 3.6
3 2001 Nevada 2.4
4 2002 Nevada 2.9
5 2003 Nevada 3.2
- 指定列索引和行索引
也可以同時指定列索引和行索引
且如果傳入的列索引在數據中找不到, 就會在結果中產生缺失值:
In [17]: frame2 = pd.DataFrame(data, columns=['year', 'state', 'pop', 'debt'],index=['one', 'two', 'three', 'four',
...: 'five','six'])
In [18]: frame2
Out[18]:
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
注:
1 .從字典到DataFrame的過程中, 如果原來的數據中(即data)有列索引, 那麼可以指定列索引, 且列索引數可以不嚴格和原數據列數目對應, 如果列索引不在原來的數據中, 就會在結果中產生缺失值;
如果原來的數據中(即data)沒有列索引, 即data中沒有’stae’,‘year’, ‘pop’. 那麼可以賦索引. 且數目必須與data中列的數目對應.
2 .行索引同理. 在這個例子中, 原來數據中沒有行索引, 如果不指定行索引,就會自動產生行索引(0,1,2,3,4,5). 如果指定行索引, 那麼行索引數目必須與原數據行數目對應.
(3) 用嵌套字典創建DataFrame
另一種常見的數據形式是嵌套字典,
- 簡單的嵌套字典
如果嵌套字典傳給DataFrame, pandas就會被解釋爲: 外層字典的鍵作爲列, 內層鍵則作爲行索引, 而內層字典的鍵會被合併、排序以形成最終的索引.
In [31]: pop = pop = {'Nevada': {2001: 2.4, 2002: 2.9},
...: 'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}
In [32]: pop
Out[32]: {'Nevada': {2001: 2.4, 2002: 2.9}, 'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}
In [33]: frame3 = pd.DataFrame(pop)
In [34]: frame3
Out[34]:
Nevada Ohio
2001 2.4 1.7
2002 2.9 3.6
2000 NaN 1.5
也可以使用類似NumPy數組的方法, 對DataFrame進行轉置 (交換行和列)
In [7]: frame3.T
Out[7]:
2001 2002 2000
Nevada 2.4 2.9 NaN
Ohio 1.7 3.6 1.5
- 明確指定索引形式
如果明確指定了索引, 則情況不是如 1) 一樣
In [8]: pd.DataFrame(pop, index=[2001,2002,2003])
Out[8]:
Nevada Ohio
2001 2.4 1.7
2002 2.9 3.6
2003 NaN NaN
In [9]: pd.DataFrame(pop, index=[2001,2002,2003,2004])
Out[9]:
Nevada Ohio
2001 2.4 1.7
2002 2.9 3.6
2003 NaN NaN
2004 NaN NaN
In [10]: pd.DataFrame(pop, index=[2001,2003,2004])
Out[10]:
Nevada Ohio
2001 2.4 1.7
2003 NaN NaN
2004 NaN NaN
表5-1: 可以輸入給 Data Frame構造器的數據
3 DataFrame的屬性
(1) index-行索引屬性
frame.index
In [36]: frame.index
Out[36]: RangeIndex(start=0, stop=6, step=1)
In [37]: frame3.index
Out[37]: Int64Index([2001, 2002, 2000], dtype='int64')
In [38]: frame2.index
Out[38]: Index(['one', 'two', 'three', 'four', 'five', 'six'], dtype='object')
(2) columns-列索引屬性
frame.columns
In [39]: frame.columns
Out[39]: Index(['state', 'year', 'pop'], dtype='object')
In [40]: frame3.columns
Out[40]: Index(['Nevada', 'Ohio'], dtype='object')
In [41]: frame2.columns
Out[41]: Index(['year', 'state', 'pop', 'debt'], dtype='object')
(3) DataFrame中index和columns的name屬性
類比Series中的name屬性, (Series對象本身及其索引(index)都有一個name屬性)
對於DataFrame, 索引有兩個, 即index和columns. 所以, 有index的name屬性和columns的name屬性.
frame3.index.name = 'year'
frame3.colmuns.name = 'state'
注意: Series對象本身還有一個name屬性.而DataFrame本身也有, 不過很少提到, 也很少用到, 就當成沒有吧.
In [88]: frame3.index.name = 'year'
In [89]: frame3.columns.name = 'state'
In [90]: frame3
Out[90]:
state Nevada Ohio
year
2001 2.4 1.7
2002 2.9 3.6
2000 NaN 1.5
In [92]: frame3.index.name
Out[92]: 'year'
In [93]: frame3.columns.name
Out[93]: 'state'
(4) values- 值屬性
跟Series一樣, values屬性也會以二維ndarray的形式返回DataFrame中的數據
In [9]: frame3.values
Out[9]:
array([[2.4, 1.7],
[2.9, 3.6],
[nan, 1.5]])
4 獲取DataFrame的行或列的數據(結果都是Series)
(1) 獲取DataFrame的列
通過類似字典標記的方式或屬性的方式, 可以將DataFrame的列獲取爲一個Series
字典標記: frame2[‘state’]# 也就是索引方式
屬性訪問: frame2.state
以上返回的結果都是Series.
In [43]: frame2['state']
Out[43]:
one Ohio
two Ohio
three Ohio
four Nevada
five Nevada
six Nevada
Name: state, dtype: object
In [44]: frame2.state
Out[44]:
one Ohio
two Ohio
three Ohio
four Nevada
five Nevada
six Nevada
Name: state, dtype: object
注: 返回的Series擁有原DataFrame相同的索引, 且其name屬性也已經被相應地設置好了
延申: 類似於Series, 在使用字典標記的方式的時候, 可以傳入[‘state’, ‘year’]選取一組Series, 結果還是DataFrame類型.
In [45]: frame2[['year','state']]
Out[45]:
year state
one 2000 Ohio
two 2001 Ohio
three 2002 Ohio
four 2001 Nevada
five 2002 Nevada
six 2003 Nevada
注意: 通過索引方式返回的列只是相應數據的視圖而已, 並不是副本. 因此, 對返回的Series所做的任何就地修改全都會反映到源DataFrame上. 通過Series的copy方法即可指定複製列.
(2) 獲取DataFrame的行-loc
行也可以通過位置或名稱的方式進行獲取, 此時需要用到loc屬性
In [12]: frame2.loc['three']
Out[12]:
year 2002
state Ohio
pop 3.6
debt NaN
Name: three, dtype: object
5 DataFrame列的重新賦值和刪除
(1) DataFrame列的重新賦值
- 簡單賦值
列可以通過賦值的方式進行修改
In [24]: frame2['debt'] = 16.5
In [25]: frame2
Out[25]:
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
In [26]: frame2['debt']=np.arange(6)
In [27]: frame2
Out[27]:
year state pop debt
one 2000 Ohio 1.5 0
two 2001 Ohio 1.7 1
three 2002 Ohio 3.6 2
four 2001 Nevada 2.4 3
five 2002 Nevada 2.9 4
six 2003 Nevada 3.2 5
- 列表或數組賦值給某個列
將列表或數組賦值給某個列時, 其長度必須跟DataFrame的長度相匹配.
而如果賦值的是一個Series, 就會精確匹配DataFrame的索引, 所有的空位都將被填上缺失值.
爲不存在的列賦值會創建一個新的列
In [28]: a = [0,0,0,0,0,0] # 列表賦值
In [29]: frame2['debt']=a
In [30]: frame2
Out[30]:
year state pop debt
one 2000 Ohio 1.5 0
two 2001 Ohio 1.7 0
three 2002 Ohio 3.6 0
four 2001 Nevada 2.4 0
five 2002 Nevada 2.9 0
six 2003 Nevada 3.2 0
In [31]: b = np.array([1,1,1,1,1,1])
In [32]: frame2['debt'] = b #數組賦值
In [33]: frame2
Out[33]:
year state pop debt
one 2000 Ohio 1.5 1
two 2001 Ohio 1.7 1
three 2002 Ohio 3.6 1
four 2001 Nevada 2.4 1
five 2002 Nevada 2.9 1
six 2003 Nevada 3.2 1
In [34]: val = pd.Series([-1.2, -1.5, -1.7], index=['two','four','five'])
In [35]: frame2['debt'] = val # Series賦值
In [36]: frame2
Out[36]:
year state pop debt
one 2000 Ohio 1.5 NaN
two 2001 Ohio 1.7 -1.2
three 2002 Ohio 3.6 NaN
four 2001 Nevada 2.4 -1.5
five 2002 Nevada 2.9 -1.7
six 2003 Nevada 3.2 NaN
In [37]: frame2['hello'] = np.arange(6) # 不存在的列賦值
In [38]: frame2
Out[38]:
year state pop debt hello
one 2000 Ohio 1.5 NaN 0
two 2001 Ohio 1.7 -1.2 1
three 2002 Ohio 3.6 NaN 2
four 2001 Nevada 2.4 -1.5 3
five 2002 Nevada 2.9 -1.7 4
six 2003 Nevada 3.2 NaN 5
(2) DataFrame列的刪除 - del
In [14]: frame2['eastern'] = frame2.state == 'Ohio'
In [15]: frame2
Out[15]:
year state pop debt eastern
one 2000 Ohio 1.5 NaN True
two 2001 Ohio 1.7 NaN True
three 2002 Ohio 3.6 NaN True
four 2001 Nevada 2.4 NaN False
five 2002 Nevada 2.9 NaN False
six 2003 Nevada 3.2 NaN False
注: “字典式”可查、可新建列、可刪除列, 但“屬性式”只能用於查詢, 不能用於新建列、刪除列
In [18]: del frame2['eastern']
In [19]: frame2
Out[19]:
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
注意: 通過索引方式返回的列只是相應數據的視圖而已, 並不是副本. 因此, 對返回的Series所做的任何就地修改全都會反映到源DataFrame上. 通過Series的copy方法即可指定複製列.
1.3 索引對象
1 索引對象的基本概念
pandas的索引對象負責管理軸標籤和其他元數據 (比如軸名稱等)
構建Series或DataFrame時, 所用到的任何數組或其他序列的標籤都會被轉換成一個Index
In [3]: obj = pd.Series(range(3),index=['a','b','c'])
In [4]: index = obj.index
In [5]: index
Out[5]: Index(['a', 'b', 'c'], dtype='object')
In [6]: index[1:]
Out[6]: Index(['b', 'c'], dtype='object')
2 建立索引對象
In [11]: labels = pd.Index(np.arange(3))
In [12]: labels
Out[12]: Int64Index([0, 1, 2], dtype='int64')
In [9]: dup_labels = pd.Index(['foo','foo','bar','bar'])
In [10]: dup_labels
Out[10]: Index(['foo', 'foo', 'bar', 'bar'], dtype='object')
3 index的不可變性
(1) index對象不可變的
Index對象是不可變的, 因此用戶不能對其進行修改
In [8]: index[1]='j'
---------------------------------------------------------------------------
TypeError: Index does not support mutable operations
(2) Index對象可以共享
不可變可以使Index對象在多個數據結構之間安全共享
In [11]: labels = pd.Index(np.arange(3))
In [12]: labels
Out[12]: Int64Index([0, 1, 2], dtype='int64')
In [13]: obj2 = pd.Series([1.5,-2.5,0],index=labels)
In [14]: obj2
Out[14]:
0 1.5
1 -2.5
2 0.0
dtype: float64
In [15]: obj2.index is labels
Out[15]: True
(3)Index對象與集合
除了類似於數組, Index的功能也類似一個固定大小的集合
與python的集合不同, pandas的Index可以包含重複的標籤
In [9]: dup_labels = pd.Index(['foo','foo','bar','bar'])
In [10]: dup_labels
Out[10]: Index(['foo', 'foo', 'bar', 'bar'], dtype='object')
(4) Index的方法和屬性
每個索引都有一些方法和屬性, 它們可用於設置邏輯並回答有關該索引所包含的數據的常見問題. 表5-2列出了這些函數.
方法 說明
append 連接另一個Index對象, 產生一個新的Index
difference 計算差集, 並得到一個Index
intersection 計算交集
union 計算並集
isin 計算一個指示各值是否都包含在參數集合中的布爾型數組
delete 刪除索引i處的元素, 並得到新的Index
drop 刪除傳入的值, 並得到新的Index
insert 將元素插入到索引i處, 並得到新的Index
is_monotonic 當各元素均大於等於前一個元素時, 返回True
is_unique 當Index沒有重複值時, 返回True
unique 計算Index中唯一值的數組
2 基本功能
2.1 重新索引–reindex
1 重新索引的概念
pandas對象的一個重要方法是reindex, 其作用是創建一個新的索引對象.
2 Series的重新索引
Series的reindex將會根據新索引進行重排. 如果某個索引值當前不存在, 就引入缺失值
In [4]: obj = pd.Series([4.5,7.2,-3,3.4],index=['d','b','a','c'])
In [6]: obj2 = obj.reindex(['a','b','c','d','e'])
In [7]: obj2
Out[7]:
a -3.0
b 7.2
c 3.4
d 4.5
e NaN
dtype: float64
參數method可以進行插值處理
如使用ffill可以實現前向值填充:
In [8]: obj3 = pd.Series(['blue', 'purple', 'yellow'], index=[0, 2, 4])
In [9]: obj3.reindex(range(6),method = 'ffill')
Out[9]:
0 blue
1 blue
2 purple
3 purple
4 yellow
5 yellow
dtype: object
3 DataFrame的重新索引
在DataFrame中, reindex可以修改行索引和列索引.
當只傳遞一個序列時, 默認重新索引結果的行
列可以用columns關鍵字重新索引
In [11]: frame = pd.DataFrame(np.arange(9).reshape((3, 3)),^M
...: index=['a', 'c', 'd'],^M
...: columns=['Ohio', 'Texas', 'California'])
In [12]: frame2 = frame.reindex(['a','b','c','d'])
In [13]: frame2
Out[13]:
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
In [16]: frame.reindex(columns=states)
Out[16]:
Texas Utah California
a 1 NaN 2
c 4 NaN 5
d 7 NaN 8
4 reindex參數
表5-3列出了reindex函數的各參數及說明
2.2 丟棄指定軸上的項–drop方法
1 基本概念
丟棄某條軸上的一個或多個項, 可以使用傳入一個索引數組或列表的drop方法,
drop方法返回的是一個在指定軸上刪除了指定值的新對象, 但是原對象保持不變
2 Series中drop方法的使用
In [4]: obj = pd.Series(np.arange(5.), index=['a', 'b', 'c', 'd', 'e'])
In [6]: new_obj = obj.drop('c')# 丟棄一項
In [7]: new_obj
Out[7]:
a 0.0
b 1.0
d 3.0
e 4.0
dtype: float64
In [9]: obj.drop(['d', 'c'])# 丟棄幾項
Out[9]:
a 0.0
b 1.0
e 4.0
dtype: float64
3 DataFrame中drop方法的使用
默認刪除行標籤. 等價於參數axis=0或者axis=‘index’
刪除列標籤, 傳入參數axis=1或者axis=‘columns’
In [11]: data = pd.DataFrame(np.arange(16).reshape((4, 4)),
...: .....: index=['Ohio', 'Colorado', 'Utah', 'New York'],
...: .....: columns=['one', 'two', 'three', 'four'])
In [12]: data
Out[12]:
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
In [13]: data.drop(['Colorado','Ohio'])#默認刪除行標籤
#等價於參數axis=0或者axis='index'
Out[13]:
one two three four
Utah 8 9 10 11
New York 12 13 14 15
In [16]: data.drop('two',axis=1)
Out[16]:
one three four
Ohio 0 2 3
Colorado 4 6 7
Utah 8 10 11
New York 12 14 15
In [18]: data.drop('two',axis='columns')
Out[18]:
one three four
Ohio 0 2 3
Colorado 4 6 7
Utah 8 10 11
New York 12 14 15
4 參數inplace=True, 就地修改
許多函數或方法, 如drop, 當傳入參數inplace=True時, 可以就地修改, 不返回新對象
In [21]: data.drop('one',axis=1,inplace=True)
In [22]: data
Out[22]:
two three four
Ohio 1 2 3
Colorado 5 6 7
Utah 9 10 11
New York 13 14 15
In [23]: ctest = data.drop('Ohio',inplace=True)
In [24]: ctest#可以看到ctest是空的,說明沒有返回任何對象
In [25]: data
Out[25]:
two three four
Colorado 5 6 7
Utah 9 10 11
New York 13 14 15
使用inplace需小心. 可能會刪除原數據.