操作DataFrame对象
DataFrame对象可以实现访问、修改、合并等操作，接下来详细讲解。
访问DataFrame对象。
可访问行或列的内容，也可访问具体的某个值，列可通过字典索引和属性方式两种方式访问。具体示例如下所示：
In [1]: from pandas import DataFrame
In [2]: dct = {'北京':{2016:3000,2018:8000,2017:5000},'上海':
...: {2016:2500,2018:7500,2017:4800},
...: '深圳':{2016:2600,2018:7800,2017:5000}}
In [3]: f3 = DataFrame(dct,[2016,2017,2018])
In [4]: fc1 = f3['北京']
In [5]: fc2 = f3.上海
上述代码是对DataFrame对象的列进行访问，其中In [4]是通过字典索引方式来访问DataFrame对象的列，并将返回结果赋值给变量fc1；In [5]是通过属性的方式来访问DataFrame对象的列，并将返回结果赋值给变量fc2。各变量的运行结果如下所示：
In [9]: dct
Out[9]:
{'上海': {2016: 2500, 2017: 4800, 2018: 7500},
'北京': {2016: 3000, 2017: 5000, 2018: 8000},
'深圳': {2016: 2600, 2017: 5000, 2018: 7800}}
In [10]: f3
Out[10]:
上海 北京 深圳
2016 2500 3000 2600
2017 4800 5000 5000
2018 7500 8000 7800
In [11]: fc1
Out[11]:
2016 3000
2017 5000
2018 8000
Name: 北京, dtype: int64
In [12]: fc2
Out[12]:
2016 2500
2017 4800
2018 7500
Name: 上海, dtype: int64
从上述运行结果可看出，不管是通过字典索引还是属性的方式都完整访问到了“北京”和“上海”这两列的内容，获取的数据都是一个Series对象。
对于行的访问可通过loc（通过索引行名来访问）或iloc（通过索引行位置来访问）来访问某一行或多行数据，具体示例如下所示：
In [41]: from pandas import DataFrame
In [42]: dct = {'北京':{'a':3000,'c':8000,'b':5000}
...: ,'上海':{'a':2500,'c':7500,'b':4800},
...: '深圳':{'a':2600,'c':7800,'b':5000}}
In [43]: f3 = DataFrame(dct,['a','b','c'])
In [44]: fr1 = f3.loc["a"]
In [45]: fr2 = f3.iloc[0]
In [46]: fr3 = f3.loc[['a','b','c']]
In [47]: fr4 = f3.iloc[range(2)]
上述代码是对DataFrame对象的行进行访问，其中In [44]是通过loc来访问DataFrame对象行索引名为“a”的行，并将返回结果赋值给变量fr1；In [45]是通过iloc来访问DataFrame对象的首行，并将返回结果赋值给变量fr2；In [46]是通过loc来访问DataFrame对象的多行，并将返回结果赋值给变量fr3；In [47]是通过iloc来访问DataFrame对象的多行，并将返回结果赋值给变量fr4。各变量的运行结果如下所示：
In [48]: dct
Out[48]:
{'上海': {'a': 2500, 'b': 4800, 'c': 7500},
'北京': {'a': 3000, 'b': 5000, 'c': 8000},
'深圳': {'a': 2600, 'b': 5000, 'c': 7800}}
In [49]: f3
Out[49]:
上海 北京 深圳
a 2500 3000 2600
b 4800 5000 5000
c 7500 8000 7800
In [50]: fr1
Out[50]:
上海 2500
北京 3000
深圳 2600
Name: a, dtype: int64
In [51]: fr2
Out[51]:
上海 2500
北京 3000
深圳 2600
Name: a, dtype: int64
In [52]: fr3
Out[52]:
上海 北京 深圳
a 2500 3000 2600
b 4800 5000 5000
c 7500 8000 7800
In [53]: fr4
Out[53]:
上海 北京 深圳
a 2500 3000 2600
b 4800 5000 5000
从上述运行结果可看出，可以通过loc和iloc来访问DataFrame对象的一行或多行。
还可通过行列的结合来访问DataFrame对象中的某一个值，具体示例如所示：
In [54]: from pandas import DataFrame
In [55]: dct = {'北京':{'a':3000,'c':8000,'b':5000}
...: ,'上海':{'a':2500,'c':7500,'b':4800},'深圳
...: ':{'a':2600,'c':7800,'b':5000}}
In [56]: f3 = DataFrame(dct,['a','b','c'])
In [57]: fn = f3['北京'][0]
In [58]: fn1 = f3['北京']['a']
In [59]: fn2 = f3.loc['a']['北京']
In [60]: fn3 = f3.iloc[0]['北京']
In [61]: fn4 = f3.loc['a'][1]
In [62]: fn5 = f3.iloc[0][1]
上述代码是对DataFrame对象的某一个值进行访问，其中In [57]和In [58]是以先指定DataFrame对象的列，再指定行的方式确定访问的值，共有上述示例中的两种方式来指定，并将访问结果赋值给变量fn和fn1；In [59]~ In [62]是以先指定DataFrame对象的行，再指定列的方式确定访问的值，共有上述示例中的四种方式来指定，并将访问结果赋值给变量fn2、fn3、fn4和fn5。各变量的运行结果如下所示：
In [74]: f3
Out[74]:
上海 北京 深圳
a 2500 3000 2600
b 4800 5000 5000
c 7500 8000 7800
In [75]: fn
Out[75]: 3000
In [76]: fn1
Out[76]: 3000
In [77]: fn2
Out[77]: 3000
In [78]: fn3
Out[78]: 3000
In [79]: fn4
Out[79]: 3000
In [80]: fn5
Out[80]: 3000
从上述运行结果可看出，不管是通过先指定列再指定行，还是先指定行再指定列的方式访问DataFrame对象的某一值都可以实现。
上述示例是访问DataFrame对象中的具体内容，若想访问DataFrame对象中的行列索引可以通过index和columns属性来进行访问，此处不再举例讲述。
DataFrame对象的修改，可以添加或修改行或列
具体示例如下所示：
In [89]: from pandas import DataFrame
In [90]: dct = {'北京':{'a':3000,'c':8000,'b':5000
...: },'上海':{'a':2500,'c':7500,'b':4800},'深
...: 圳':{'a':2600,'c':7800,'b':5000}}
In [91]: f3 = DataFrame(dct,index=['a','b','c'])
上述代码是创建DataFrame对象f3，f3的运行结果如下所示：
In [92]: f3
Out[92]:
上海 北京 深圳
a 2500 3000 2600
b 4800 5000 5000
c 7500 8000 7800
接下来为f3对象添加值都为6000的列，具体示例如下所示：
In [93]: f3['广州'] = 6000
添加列之后的f3运行结果如下所示：
In [94]: f3
Out[94]:
上海 北京 深圳 广州
a 2500 3000 2600 6000
b 4800 5000 5000 6000
c 7500 8000 7800 6000
接下来修改“广州”的列数据，具体示例如下所示：
In [97]: f3['广州'] = [2400,4600,6000]
修改“广州”列之后的f3运行结果如下所示：
In [98]: f3
Out[98]:
上海 北京 深圳 广州
a 2500 3000 2600 2400
b 4800 5000 5000 4600
c 7500 8000 7800 6000
接下来为f3添加索引为“d”的一行，具体示例如下所示：
In [99]: f3.append(DataFrame({'上海':8000,'北京':10000,
...: '深圳':8000,'广州':7000},index = ['d']))
编写完上述代码只要回车即显示结果，显示结果如下所示：
Out[99]:
上海 北京 广州 深圳
a 2500 3000 2400 2600
b 4800 5000 4600 5000
c 7500 8000 6000 7800
d 8000 10000 7000 8000
上述结果虽然能看出添加了行索引为“d”的一行，但实际上的f3对象并没有改变，因此需要下列操作才能实现真正的添加行数据，具体示例如下所示：
In [101]: f3 = f3.append(DataFrame({'上海':8000,'北京':10000,
...: '深圳':8000,'广州':7000},index = ['d']))
再次运行f3才能实现添加行索引为“d”的一行，运行结果如下所示：
In [102]: f3
Out[102]:
上海 北京 广州 深圳
a 2500 3000 2400 2600
b 4800 5000 4600 5000
c 7500 8000 6000 7800
d 8000 10000 7000 8000
DataFrame对象的合并
具体示例如下所示：
In [14]: from pandas import DataFrame
In [15]: dct1 = {'BJ':{'a':10,'b':20,'c':30,'d':40,'e':50}}
In [16]: f1 = DataFrame(dct1)
In [17]: dct2 = {'SZ':{'a':10,'c':30,'d':40,'e':50,'f':60}}
In [18]: f2 = DataFrame(dct2)
In [19]: f3 = f2.join(f1)
In [20]: f4 = f2.join(f1,how = 'inner')
In [21]: f5 = f2.join(f1,how = 'outer')
上述代码是DataFrame对象合并，In [19]是将f1和f2以默认方式进行合并，即只保留f2中的索引，并将合并之后的结果赋值给变量f3；In [20]是将f1和f2合并交集部分，其他部分删除，并将合并之后的结果赋值给变量f4；In [19]是将f1和f2合并并集部分，即每部分内容都进行合并，并将合并之后的结果赋值给变量f5。各变量的运行结果如下所示：
In [22]: f1
Out[22]:
BJ
a 10
b 20
c 30
d 40
e 50
In [23]: f2
Out[23]:
SZ
a 10
c 30
d 40
e 50
f 60
In [24]: f3
Out[24]:
SZ BJ
a 10 10.0
c 30 30.0
d 40 40.0
e 50 50.0
f 60 NaN
In [25]: f4
Out[25]:
SZ BJ
a 10 10
c 30 30
d 40 40
e 50 50
In [26]: f5
Out[26]:
SZ BJ
a 10.0 10.0
b NaN 20.0
c 30.0 30.0
d 40.0 40.0
e 50.0 50.0
f 60.0 NaN
从上述运行结果可看出，通过默认方式合并的f3中只含有f2中的索引， f1中索引“b”没有保留，并将f1中没有的索引“f”对应的值合并为NaN；而通过交集合并的f4则只保留了f1和f2共有的索引值“a、c、d、e”，其他内容全部删除；通过并集合并的f5保留了f1和f2中所有的索引，其中只存在于一个对象中的索引所对应的值均合并为NaN。
网友评论