笨办法学分析[05]pandas常用操作(一)

1.Series获取值: s.values

DataFrame也存在values，返回的是二维ndarray数据

In [3]: s=pd.Series([4, 7, -5, 3])
   ...: s.values
Out[3]: array([ 4,  7, -5,  3], dtype=int64)

2.Series转换为列表： list(s)

In [4]: list(s)
Out[4]: [4, 7, -5, 3]

3.Series索引： s[:]

In [5]: s=pd.Series([4, 7, -5, 3],index=list('adbs'))
   ...: s[1:]
Out[5]: 
d    7
b   -5
s    3
dtype: int64

In [6]: s[['a','s']]
Out[6]: 
a    4
s    3
dtype: int64

4.Series数据筛选： s[s>i]

#筛选大于3的值
In [7]: s[s>3]
Out[7]: 
a    4
d    7
dtype: int64

5.判断Series是否存在某个索引或某个值： x in s

#是否存在索引值
In [8]: 'a' in s
Out[8]: True
#是否存在某个值
In [9]: 7 in s.values
Out[9]: True
In [10]: 10 in s.values
Out[10]: False

6.DataFrame更改列顺序pd.DataFrame(data,columns=[])

data可以是用于创建DataFrame的合适的数据，也可以是 DataFrame。
如果原数据存在列名，则根据新的columns顺序调整列顺序，如果不存在，则会引入NaN值。
还可以添加index对行索引进行更改。如果data不是DataFrame，则一般而言index的长度需和数据的行数相同，否则会创建失败。

In [11]: data = {'省市': ['重庆', '重庆', '重庆', '成都', '成都', '成都'],
    ...:         '年份': [2014, 2015, 2016, 2014, 2015, 2016],
    ...:         '常住人口': [2991.0, 3107.0, 3048.0, 1465.8, 1591.8, 1604.5]}
    ...: df=pd.DataFrame(data)

In [12]: df
Out[12]: 
   省市    年份    常住人口
0  重庆  2014  2991.0
1  重庆  2015  3107.0
2  重庆  2016  3048.0
3  成都  2014  1465.8
4  成都  2015  1591.8
5  成都  2016  1604.5
#更改列顺序
In [13]: pd.DataFrame(data,columns=['年份','常住人口','省市'])
Out[13]: 
     年份    常住人口  省市
0  2014  2991.0  重庆
1  2015  3107.0  重庆
2  2016  3048.0  重庆
3  2014  1465.8  成都
4  2015  1591.8  成都
5  2016  1604.5  成都
#当添加了未知列时，会引入NaN值。注意index添加的数量必须和原有行数一致，否则会报错
In [14]: pd.DataFrame(data,columns=['年份','常住人口','省市','GDP'],
    ...:              index=list('abcdef'))
Out[14]: 
     年份    常住人口  省市  GDP
a  2014  2991.0  重庆  NaN
b  2015  3107.0  重庆  NaN
c  2016  3048.0  重庆  NaN
d  2014  1465.8  成都  NaN
e  2015  1591.8  成都  NaN
f  2016  1604.5  成都  NaN

7.DataFrame的添加列： df['label']=data

即可通过此种方式添加任何列，如果data是列表，需注意其长度和df的长度一致。如果添加的是Series，则会通过索引（index）对齐数据，缺失数据将会被添加NaN值。

In [17]: df['GDP']=2000

In [18]: df
Out[18]: 
   省市    年份    常住人口   GDP
0  重庆  2014  2991.0  2000
1  重庆  2015  3107.0  2000
2  重庆  2016  3048.0  2000
3  成都  2014  1465.8  2000
4  成都  2015  1591.8  2000
5  成都  2016  1604.5  2000

8.DataFrame行列转置（行列切换）： df.T

In [19]: df.T
Out[19]: 
         0     1     2       3       4       5
省市      重庆    重庆    重庆      成都      成都      成都
年份    2014  2015  2016    2014    2015    2016
常住人口  2991  3107  3048  1465.8  1591.8  1604.5
GDP   2000  2000  2000    2000    2000    2000

9.DataFrame的删除列： del df['label']

注意是原地删除

In [3]: df
Out[3]: 
     常住人口    年份  省市
0  2991.0  2014  重庆
1  3107.0  2015  重庆
2  3048.0  2016  重庆
3  1465.8  2014  成都
4  1591.8  2015  成都
5  1604.5  2016  成都

In [4]: df['是否重庆']=df['省市']=='重庆'

In [5]: df
Out[5]: 
     常住人口    年份  省市   是否重庆
0  2991.0  2014  重庆   True
1  3107.0  2015  重庆   True
2  3048.0  2016  重庆   True
3  1465.8  2014  成都  False
4  1591.8  2015  成都  False
5  1604.5  2016  成都  False

In [6]: del df['是否重庆']

In [7]: df
Out[7]: 
     常住人口    年份  省市
0  2991.0  2014  重庆
1  3107.0  2015  重庆
2  3048.0  2016  重庆
3  1465.8  2014  成都
4  1591.8  2015  成都
5  1604.5  2016  成都

10.DataFrame的重新索引行： df.reindex([])

reindex传入的index列表是什么就会按照index列表顺序重新组织数据，如果新的index中有原df的索引没有的值，则索引对应的行将会引入NaN值，可以使用fill_value=value对NaN值进行填充。

In [10]: df2=pd.DataFrame(np.arange(9).reshape((3, 3)),
    ...:     index=['a', 'c', 'd'],
    ...:     columns=['Ohio', 'Texas', 'California'])

In [11]: df2
Out[11]: 
   Ohio  Texas  California
a     0      1           2
c     3      4           5
d     6      7           8

In [12]: df2.reindex(['a', 'b', 'c', 'd'])
Out[12]: 
   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 [13]: df2.reindex(['a','x','c'])
Out[13]: 
   Ohio  Texas  California
a   0.0    1.0         2.0
x   NaN    NaN         NaN
c   3.0    4.0         5.0

11.DataFrame的重新索引列： df.reindex(columns=[])

In [14]: states = ['Texas', 'chongqing', 'California']
    ...: df2.reindex(columns=states)
Out[14]: 
   Texas  chongqing  California
a      1        NaN           2
c      4        NaN           5
d      7        NaN           8

12.DataFrame的更改行列索引（修改/重命名行列标题）方法1：df.rename(index={},columns={})，这里不会对原数据进行修改

和重新索引行列不同的是，我们可能希望对行列的索引进行重构，例如从某些系统导出的列标题数据可能是一些英文缩写，而我们为了辨识希望将其替换为全称以便大家理解。rename的index和columns参数分别对行和列的索引进行修改，传入的数据类型为字典。如下例：

In [12]: df
Out[12]: 
     常住人口    年份  省市
0  2991.0  2014  重庆
1  3107.0  2015  重庆
2  3048.0  2016  重庆
3  1465.8  2014  成都
4  1591.8  2015  成都
5  1604.5  2016  成都

In [15]: idx=dict(zip(range(6),list('abcdef')))

In [16]: idx
Out[16]: {0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e', 5: 'f'}

In [17]: df.rename(index=idx)
Out[17]: 
     常住人口    年份  省市
a  2991.0  2014  重庆
b  3107.0  2015  重庆
c  3048.0  2016  重庆
d  1465.8  2014  成都
e  1591.8  2015  成都
f  1604.5  2016  成都

13.DataFrame的更改行列索引（修改/重命名行列标题）方法2： df.index=[],df.columns=[]，这里会对原数据进行修改

注意：这里赋值的列表必须与index和columns的长度一致，因此重命名时应注意索引列表的顺序。

In [18]: df
Out[18]: 
     常住人口    年份  省市
0  2991.0  2014  重庆
1  3107.0  2015  重庆
2  3048.0  2016  重庆
3  1465.8  2014  成都
4  1591.8  2015  成都
5  1604.5  2016  成都

In [19]: df.index=list('abcdef')

In [20]: df
Out[20]: 
     常住人口    年份  省市
a  2991.0  2014  重庆
b  3107.0  2015  重庆
c  3048.0  2016  重庆
d  1465.8  2014  成都
e  1591.8  2015  成都
f  1604.5  2016  成都

In [22]: df.columns=['a1','a2','a3']

In [23]: df
Out[23]: 
       a1    a2  a3
a  2991.0  2014  重庆
b  3107.0  2015  重庆
c  3048.0  2016  重庆
d  1465.8  2014  成都
e  1591.8  2015  成都
f  1604.5  2016  成都

14.DataFrame的索引方式-字典（标签）或属性索引： df['label'] df.label

In [15]: df.年份
Out[15]: 
0    2014
1    2015
2    2016
3    2014
4    2015
5    2016
Name: 年份, dtype: int64

In [16]: df[['年份','省市']]
Out[16]: 
     年份  省市
0  2014  重庆
1  2015  重庆
2  2016  重庆
3  2014  成都
4  2015  成都
5  2016  成都

#通过切片选取行
In [18]: df[:2]
Out[18]: 
     常住人口    年份  省市
0  2991.0  2014  重庆
1  3107.0  2015  重庆

#通过布尔型数据选取
In [22]: df[df['年份']>2015]
Out[22]: 
     常住人口    年份  省市
2  3048.0  2016  重庆
5  1604.5  2016  成都

15.DataFrame的索引方式-loc和iloc：df.loc[],df.iloc[]

In [23]: data = {'省市': ['重庆', '重庆', '重庆', '成都', '成都', '成都'],
    ...:     '年份': [2014, 2015, 2016, 2014, 2015, 2016],
    ...:     '常住人口': [2991.0, 3107.0, 3048.0, 1465.8, 1591.8, 1604.5]}
    ...: df3=pd.DataFrame(data,index=list('abcdef'))

In [24]: df3
Out[24]: 
     常住人口    年份  省市
a  2991.0  2014  重庆
b  3107.0  2015  重庆
c  3048.0  2016  重庆
d  1465.8  2014  成都
e  1591.8  2015  成都
f  1604.5  2016  成都

#通过标签选择一行和多列
In [27]: df3.loc['a',['常住人口','省市']]
Out[27]: 
常住人口    2991
省市        重庆
Name: a, dtype: object

#通过iloc和整数进行选取
In [29]: df3.iloc[2,[2,0,1]]
Out[29]: 
省市        重庆
常住人口    3048
年份      2016
Name: c, dtype: object

DataFrame的索引选项

16.DataFrame的算术运算（两个df间计算）：df1+df2

（1）两个df进行运算时，会按行列索引进行自动对齐，行列索引重叠的部分才会进行计算，其余部分会用NaN进行填充。
（2）可以使用fill_value参数对不重叠部分进行数据填充，例如在加减法中fill_value=0，在乘除法中fill_value=1

In [2]: df1=pd.DataFrame(np.arange(12).reshape((3,4)),
   ...:                  columns=list('abcd'))
   ...: df2=pd.DataFrame(np.arange(20).reshape((4,5)),
   ...:                  columns=list('abcde'))
   ...: df1.loc[1,'b']=np.nan

In [3]: df1
Out[3]: 
   a    b   c   d
0  0  1.0   2   3
1  4  NaN   6   7
2  8  9.0  10  11

In [4]: df2
Out[4]: 
    a   b   c   d   e
0   0   1   2   3   4
1   5   6   7   8   9
2  10  11  12  13  14
3  15  16  17  18  19

In [5]: df1+df2
Out[5]: 
      a     b     c     d   e
0   0.0   2.0   4.0   6.0 NaN
1   9.0   NaN  13.0  15.0 NaN
2  18.0  20.0  22.0  24.0 NaN
3   NaN   NaN   NaN   NaN NaN

#fill_value参数填充
In [6]: df1.add(df2,fill_value=0)
Out[6]: 
      a     b     c     d     e
0   0.0   2.0   4.0   6.0   4.0
1   9.0   6.0  13.0  15.0   9.0
2  18.0  20.0  22.0  24.0  14.0
3  15.0  16.0  17.0  18.0  19.0

#行广播
In [9]: s=df2.loc[1]
In [10]: s
Out[10]: 
a    5
b    6
c    7
d    8
e    9
Name: 1, dtype: int32

In [11]: df2
Out[11]: 
    a   b   c   d   e
0   0   1   2   3   4
1   5   6   7   8   9
2  10  11  12  13  14
3  15  16  17  18  19

In [12]: df2-s
Out[12]: 
    a   b   c   d   e
0  -5  -5  -5  -5  -5
1   0   0   0   0   0
2   5   5   5   5   5
3  10  10  10  10  10

#列广播必须使用算术运算方法
In [13]: s2=df2['a']

In [14]: s2
Out[14]: 
0     0
1     5
2    10
3    15
Name: a, dtype: int32

In [15]: df2.sub(s2,axis='index')
Out[15]: 
   a  b  c  d  e
0  0  1  2  3  4
1  0  1  2  3  4
2  0  1  2  3  4
3  0  1  2  3  4

df的算术运输方法

16.DataFrame的函数应用和映射：np.f(df)

(1)NumPy的ufuncs（元素级数组方法）也可用于操作pandas对象

#NumPy的ufuncs（元素级数组方法）也可用于操作pandas对象
In [17]: df3=pd.DataFrame(np.random.randn(4,3),columns=list('abc'),
    ...:     index=list('defg'))

In [18]: df3
Out[18]: 
          a         b         c
d -1.480045 -0.533040 -1.805579
e  0.570024  0.473758  0.522302
f -1.019122  2.273182 -0.013623
g  0.025102 -0.176810  0.484197

In [19]: np.abs(df3)
Out[19]: 
          a         b         c
d  1.480045  0.533040  1.805579
e  0.570024  0.473758  0.522302
f  1.019122  2.273182  0.013623
g  0.025102  0.176810  0.484197

17.DataFrame的函数应用和映射：df.apply(f)

In [8]: df=pd.DataFrame(np.random.randn(5,6),columns=list('abcdef'))

In [9]: def f(x):
   ...:     return pd.Series([x.min(),x.max()],index=['min','max'])

In [10]: df.apply(f)
Out[10]: 
            a         b         c         d         e         f
min -1.437988 -2.143342 -2.393996 -1.274434 -0.668326 -1.998081
max  0.605102  1.530396  1.128361  1.097948  2.435992  0.804016

#格式化数据，数据保留2位小数
In [11]: fmt=lambda x: '%.2f' % x
    ...: df.applymap(fmt)
Out[11]: 
       a      b      c      d      e      f
0  -0.56   1.53  -1.18  -1.27   2.44  -0.98
1  -1.44   1.09  -0.09   1.10   0.64  -0.08
2  -1.05  -2.14   0.06  -0.31   0.82  -2.00
3   0.61  -1.08   1.13  -0.07  -0.54  -0.80
4   0.06   0.19  -2.39  -0.29  -0.67   0.80

18.DataFrame的索引排序：df.sort_index()

默认对行进行排序，可以传入axis改变排序轴，传入ascending确定排序方式为降序还是升序

In [12]: df
Out[12]: 
          a         b         c         d         e         f
0 -0.558851  1.530396 -1.182550 -1.274434  2.435992 -0.976853
1 -1.437988  1.093641 -0.091220  1.097948  0.644922 -0.081432
2 -1.045230 -2.143342  0.063647 -0.311614  0.818843 -1.998081
3  0.605102 -1.078476  1.128361 -0.068826 -0.543363 -0.797792
4  0.061240  0.185573 -2.393996 -0.291933 -0.668326  0.804016

In [13]: df.sort_index(axis='columns',ascending=False)
Out[13]: 
          f         e         d         c         b         a
0 -0.976853  2.435992 -1.274434 -1.182550  1.530396 -0.558851
1 -0.081432  0.644922  1.097948 -0.091220  1.093641 -1.437988
2 -1.998081  0.818843 -0.311614  0.063647 -2.143342 -1.045230
3 -0.797792 -0.543363 -0.068826  1.128361 -1.078476  0.605102
4  0.804016 -0.668326 -0.291933 -2.393996  0.185573  0.061240

19.DataFrame对值排序：df.sort_values()

对Series按值排序，即s.sort_values()；在dataframe中按多列排序df.sort_values(by=['columns1','columns2',...])

df.sort_values(by='c')
Out[14]: 
          a         b         c         d         e         f
4  0.061240  0.185573 -2.393996 -0.291933 -0.668326  0.804016
0 -0.558851  1.530396 -1.182550 -1.274434  2.435992 -0.976853
1 -1.437988  1.093641 -0.091220  1.097948  0.644922 -0.081432
2 -1.045230 -2.143342  0.063647 -0.311614  0.818843 -1.998081
3  0.605102 -1.078476  1.128361 -0.068826 -0.543363 -0.797792

20.DataFrame的排名：df.rank()

rank排序可以通过传入method参数对排名方法进行限定。

method参数	内容
average	默认方法，在相等分组中，为各个值平均排名
min	使用整个分组的最小排名（这是我们常用的排名方式，并列第一名，第三名...）
max	使用整个分组的最大排名
first	按值在原始数据中的出现顺序分配排名
dense	类似min方法，但排名总是在组间增加1，而不是组中相同的元素数

df2=pd.DataFrame({'b': [4.3, 7, -3, 2], 'a': [0, 1, 0, 1],
                  'c': [-2, 5, 8, -2.5]})

df2
Out[23]: 
     b  a    c
0  4.3  0 -2.0
1  7.0  1  5.0
2 -3.0  0  8.0
3  2.0  1 -2.5

df2.rank()
Out[24]: 
     b    a    c
0  3.0  1.5  2.0
1  4.0  3.5  3.0
2  1.0  1.5  4.0
3  2.0  3.5  1.0

21.DataFrame的常用操作汇总表

函数或方法	用途
s.values	获取Series或DataFrame的值（去掉索引）
list(s)	将Series转换为列表
x in s	判断x是否在Series s中，返回True或False值
df['label']=data	给数据添加列，注意列长度，如果是pands数据类型则会根据索引对齐
df.T	行列转置
del df['label']	删除列，注意是对原df删除
df.reindex([])	对索引进行排序，添加columns参数可以对列进行排序，没有的索引会引入NaN值
df.rename(index={},columns={})	重命名行列（修改行列标题/索引），传入字典形式的数据，如index={"oldtext":"newtext"}
df.index=[],df.columns=[]	按顺序重命名行列（修改行列标题/索引），赋值的列表必须与index和columns的长度一致
df.loc[],df.iloc[]	通用的DataFrame索引方式，df.loc[[行label],[列label]]
df1.add/sub/div/floordiv/mul/pow(df2)	分别用于df1和df2之间到底加、减、除、底除、乘、指数的方法
df.apply(f)	对df执行函数f的运算
df.sort_index()	对行按索引进行排序，可以传入axis改变排序轴，传入ascending确定排序方式为降序还是升序
df.sort_values()	对值进行排序，对Series按值排序，即s.sort_values()；在dataframe中按多列排序df.sort_values(by=['columns1','columns2',...])
df.rank()	数据排名，通过method参数限定方法，method='min'是常用的排名方法

以上内容根据《利用Python进行数据分析·第2版》进行整理。
参考链接：https://www.jianshu.com/p/161364dd0acf