前言
本文的文字及图片来源于网络,仅供学习、交流使用,不具有任何商业用途,版权归原作者所有,如有问题请及时联系我们以作处理。
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需小心. 可能会删除原数据.