数据预处理—Pandas

1. 介绍

Pandas是Python第三方库，提供高性能易用数据类型和分析工具。

In [192]: import pandas as pd
In [193]: pd.__version__

核心：

​ 两个数据类型Series,DataFrame

• 基于上述数据类型的各类操作
• 基本操作、运算操作、特征类操作、关联类操作

对比：

NumPy	Pandas
基础数据类型	扩展数据类型
关注数据的结构表达	关注数据的应用表达
维度和数据间关系	数据与索引间关系

2. Series类型

series类型由一组数据及与之相关的数据索引组成

2.1 索引

添加参数index=[ , , , ]自定义索引，不添加自动生成从0开始的索引。

index=[ , , , ]可直接简写为[ , , , ]

# 自动索引
In [195]: pd.Series([9,8,7,6])
Out[195]: 
0    9 # 索引 数据
1    8
2    7
3    6
dtype: int64 # NumPy中的数据类型

# 自定义索引（“index=”可省略）
In [197]: pd.Series([9,8,7,6], index=['a','b','c','d'])
Out[197]: 
a    9
b    8
c    7
d    6
dtype: int64

2.2 创建

可以由如下类型创建：

• python列表（见2.1）
• 标量值
• python字典
• ndarray
• 其他函数（range等）

标量值：

# 不指定索引相当于一个值的列表
In [201]: pd.Series(25, ['a','b','c','d'])
Out[201]: 
a    25
b    25
c    25
d    25
dtype: int64

字典：

In [203]: pd.Series({'a':9, 'b':8, 'c':7, 'd':6})
Out[203]: 
a    9
b    8
c    7
d    6
dtype: int64

# 通过index参数，从字典中挑选
In [204]: pd.Series({'a':9, 'b':8, 'c':7, 'd':6}, ['a', 'c', 'e'])
Out[204]: 
a    9.0
c    7.0
e    NaN
dtype: float64

ndarray：

#内容01234，索引98765，index = 可省略
In [205]: pd.Series(np.arange(5), index = np.arange(9,4,-1))
Out[205]: 
9    0
8    1
7    2
6    3
5    4
dtype: int32

2.3 基本操作

• series类型包括index和values两部分
• series类型的操作类似ndarray类型
• Series类型的操作类似Python字典类型

获得索引或内容

In [219]: a
Out[219]: 
a    9.0
c    7.0
e    NaN
dtype: float64

In [220]: a.index
Out[220]: Index(['a', 'c', 'e'], dtype='object')

In [221]: a.values
Out[221]: array([ 9.,  7., nan])

通过索引取值

​ 自定义索引与自动索引并存，但不能混合使用

In [222]: a['c'] # 自定义索引
Out[222]: 7.0

In [223]: a[1] # 自动索引
Out[223]: 7.0

In [224]: a[['a', 'c']] # 自定义索引取多值
Out[224]: 
a    9.0
c    7.0
dtype: float64

In [225]: a[[0, 1]] # 自动索引取多值
Out[225]: 
a    9.0
c    7.0
dtype: float64

In [226]: a[['a', 1]] # 混合使用 错误❌

类似ndarray的操作

• 索引方法相同，采用[]
• NumPy中运算和操作可用于series类型
• 可以通过自定义索引的列表进行切片
• 可以通过自动索引进行切片，如果存在自定义索引，则一同被切片

In [236]: a
Out[236]: 
a    9
b    8
c    7
d    6
e    5
dtype: int64

In [238]: a[1] # 索引
Out[238]: 8

In [239]: a[1:4:2] # 切片-[1,4)中步长为1
Out[239]: 
b    8
d    6
dtype: int64
    
In [247]: a[a > a.median()] # 切片-大于中位数的部分
Out[247]: 
a    9
b    8
dtype: int64

In [249]: np.exp(a) # numpy中的操作
Out[249]: 
a    8103.083928
b    2980.957987
c    1096.633158
d     403.428793
e     148.413159
dtype: float64

类似字典的操作

• 通过自定义索引访问
• 保留字in操作
• 使用.get()方法

In [250]: a
Out[250]: 
a    9
b    8
c    7
d    6
e    5
dtype: int64

In [251]: a['b'] # 索引
Out[251]: 8

In [252]: 'b' in a # 索引是否存在
Out[252]: True

In [253]: 8 in a
Out[253]: False

In [254]: a.get('b', 100) # 索引方式2
Out[254]: 8

In [255]: a.get('t', 100)
Out[255]: 100
    
In [256]: a['f'] = 4 # 添加   

对齐操作

a和b操作结果：

• 索引维a和b并集
• 内容为a和b操作结果
• 与nan操作，结果为nan

In [257]: a
Out[257]: 
a    9
b    8
c    7
d    6
e    5
dtype: int64

In [258]: b
Out[258]: 
d    6
e    5
f    4
dtype: int64

In [259]: a + b
Out[259]: 
a     NaN
b     NaN
c     NaN
d    12.0
e    10.0
f     NaN
dtype: float64

name属性

• a.name
• a.index.name

In [266]: a.name = 'Series对象a'

In [267]: a.index.name = '索引'
    
In [269]: a
Out[269]: 
索引
a    9
b    8
c    7
d    6
e    5
Name: Series对象a, dtype: int64

修改

series对象可以随时修改并即刻生效

In [272]: a
Out[272]: 
索引
a    9
b    8
c    7
d    6
e    5
Name: Series对象a, dtype: int64

In [273]: a.name = 'myname' # 对象名

In [274]: a.index.name = 'ind' # 索引列名
    
In [277]: a['a', 'b'] = 10 # 通过自定义索引修改

In [278]: a[2] = 30 # 通过自动索引修改

In [280]: a['f'] = 20 # 添加一条

In [282]: a
Out[282]: 
ind
a    10
b    10
c    30
d     6
e     5
f    20
Name: myname, dtype: int64

3. DataFrame

3.1 简洁

• DataFrame是一个表格型的数据类型，每列值类型可以不同
• DataFrame既有行索引、也有列索引
• DataFrame常用于表达二维数据，但可以表达多维数据

DataFrame类型由共用相同索引的一组列组成

​ index_0 → data_a data_1 data_w

​ index_1 → data_b data_2 …… data_x

​ index_2 → data_c data_3 data_y

​ index_3 → data_d data_4 data_z

​ index_0 index_1 … 方向：index，axis=0

​ index_0 data_a … 方向：column，axis=1

3.2 创建

DataFrame类型可以由如下类型创建：

• 二维ndarray对象
• 由一维ndarray、列表、字典、元组或series构成的字典
• series类型
• 其他的DataFrame类型

# 二维ndarray对象
# 自动索引
In [284]: pd.DataFrame(np.arange(12).reshape(3,4))
Out[284]: 
   0  1   2   3
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11
# 自定义索引
In [312]: pd.DataFrame(np.arange(4).reshape(2,2),
                       index=['a','b'],
                       columns=['c','d'])
Out[312]: 
   c  d
a  0  1
b  2  3


# series字典，自定义索引
# 字典关键字为列索引，series字典索引为行索引
In [287]: dt = {
    'one':pd.Series([1,2,3],index=['a','b','c']),
	'two':pd.Series([9,8,7,6],index['a','b','c','d'])
}
# 有相同行号，后面的覆盖前面的
In [288]: pd.DataFrame(dt)
Out[288]: 
   one  two
a  1.0    9
b  2.0    8
c  3.0    7
d  NaN    6


# 列表字典
In [289]: d = {'one':[1,2,3], 'two':[9,8,7]}
# 自动行索引
In [290]: pd.DataFrame(d)
Out[290]: 
   one  two
0    1    9
1    2    8
2    3    7
# 自定义行索引
In [292]: pd.DataFrame(d,index=['a','b','c'])
Out[292]: 
   one  two
a    1    9
b    2    8
c    3    7

练习：

城市	环比	同比	定基
北京	101.5	120.7	121.4
上海	101.2	127.3	127.8
广州	101.3	119.4	120.0
深圳	102.0	140.9	145.5
沈阳	100.1	101.4	101.6

In [293]: d = {
    '城市':['北京','上海','广州','深圳','沈阳'], 
    '环比':[101.5,101.2,101.3,102.0,100.1],
    '同比':[120.7,127.3,119.4,140.9,101.4],
    '定基':[121.4,127.8,120.0,145.5,101.6]
}

In [294]: data = pd.DataFrame(d,index=['c1','c2','c3','c4','c5'])

In [295]: data
Out[295]: 
    城市     环比     同比     定基
c1  北京  101.5  120.7  121.4
c2  上海  101.2  127.3  127.8
c3  广州  101.3  119.4  120.0
c4  深圳  102.0  140.9  145.5
c5  沈阳  100.1  101.4  101.6

3.3 查询

以上面城市表为例

查询行名、列名、数据

In [296]: data.index
Out[296]: Index(['c1', 'c2', 'c3', 'c4', 'c5'], dtype='object')

In [297]: data.columns
Out[297]: Index(['城市', '环比', '同比', '定基'], dtype='object')
    
In [299]: data.values
Out[299]: 
array([['北京', 101.5, 120.7, 121.4],
       ['上海', 101.2, 127.3, 127.8],
       ['广州', 101.3, 119.4, 120.0],
       ['深圳', 102.0, 140.9, 145.5],
       ['沈阳', 100.1, 101.4, 101.6]], dtype=object)

查询某列

# []不带列号
In [305]: data['城市']
Out[305]: 
c1    北京
c2    上海
c3    广州
c4    深圳
c5    沈阳
Name: 城市, dtype: object

# [[]]带列号
In [306]: data[['城市']]
Out[306]: 
    城市
c1  北京
c2  上海
c3  广州
c4  深圳
c5  沈阳

In [307]: data[['同比', '城市']]
Out[307]: 
       同比  城市
c1  120.7  北京
c2  127.3  上海
c3  119.4  广州
c4  140.9  深圳
c5  101.4  沈阳

查询某行

# []不带行号，竖放
In [315]: data.loc['c1']
Out[315]: 
城市       北京
环比    101.5
同比    120.7
定基    121.4
Name: c1, dtype: object

# [[]]带行号
In [317]: data.loc[['c1']]
Out[317]: 
    城市     环比     同比     定基
c1  北京  101.5  120.7  121.4

In [316]: data.loc[['c1','c2']]
Out[316]: 
    城市     环比     同比     定基
c1  北京  101.5  120.7  121.4
c2  上海  101.2  127.3  127.8

查询某点

In [324]: data.at['c2', '环比']
Out[324]: 101.2

3.4 索引操作

如何改变series和DataFrame对象?

• 增加或重排：reindex 重新索引 + 索引类型操作
• 删除：drop 删除

Index类型操作

In [338]: data.index
Out[338]: Index(['c1', 'c2', 'c3', 'c4', 'c5'], dtype='object')

In [339]: data.columns
Out[339]: Index(['城市', '环比', '同比', '定基'], dtype='object')

index和columns都是Index类型。

常用方法：

方法	介绍
.append(idx)	连接另一个Index对象，产生新的Index对象
.diff(idx)	计算差集，产生新的Index对象
.intersection(idx)	计算交集
.union(idx)	计算并集
.delete(loc)	删除loc位置处的元素
.insert( loc,e)	在loc位置增加一个元素e

调用上述方法后生成新的索引，然后使用reindex方法修改DataFrame

重新索引

.reindex()能够改变或重排series和DataFrame索引

.reindex(index=None, columns=None, ...)的参数：

参数	说明
index,columns	新的行列自定义索引
fill_value	重新索引中，用于填充缺失位置的值
method	填充方法，ffill当前值向前填充，bfill向后填充
limit	最大填充量
copy	默认True ，生成新的对象，False时，新旧相等不复制

#原始数据
In [327]: data
Out[327]: 
    城市     环比     同比     定基
c1  北京  101.5  120.7  121.4
c2  上海  101.2  127.3  127.8
c3  广州  101.3  119.4  120.0
c4  深圳  102.0  140.9  145.5
c5  沈阳  100.1  101.4  101.6

#重新指定index排序
In [328]: data.reindex(index=['c5','c4','c3','c2','c1'])
Out[328]: 
    城市     环比     同比     定基
c5  沈阳  100.1  101.4  101.6
c4  深圳  102.0  140.9  145.5
c3  广州  101.3  119.4  120.0
c2  上海  101.2  127.3  127.8
c1  北京  101.5  120.7  121.4

#重新指定columns排序
In [329]: data.reindex(columns=['城市','同比','环比','定基'])
Out[329]: 
    城市     同比     环比     定基
c1  北京  120.7  101.5  121.4
c2  上海  127.3  101.2  127.8
c3  广州  119.4  101.3  120.0
c4  深圳  140.9  102.0  145.5
c5  沈阳  101.4  100.1  101.6

# 生成新的columns，增加一列
In [333]: newcol = data.columns.insert(4,'新增')
# 使用新columns，新位置用200填充
In [334]: data.reindex(columns=newcol, fill_value=200)
Out[334]: 
    城市     环比     同比     定基   新增
c1  北京  101.5  120.7  121.4  200
c2  上海  101.2  127.3  127.8  200
c3  广州  101.3  119.4  120.0  200
c4  深圳  102.0  140.9  145.5  200
c5  沈阳  100.1  101.4  101.6  200
# 添加新行同上

删除某行/列

.drop()能够删除series和DataFrame指定行或列索引

In [364]: data
Out[364]: 
    城市     环比     同比     定基
c1  北京  101.5  120.7  121.4
c2  上海  101.2  127.3  127.8
c3  广州  101.3  119.4  120.0
c4  深圳  102.0  140.9  145.5
c5  沈阳  100.1  101.4  101.6

In [365]: data.drop('c3')
Out[365]: 
    城市     环比     同比     定基
c1  北京  101.5  120.7  121.4
c2  上海  101.2  127.3  127.8
c4  深圳  102.0  140.9  145.5
c5  沈阳  100.1  101.4  101.6

In [368]: data.drop('定基',axis=1)
Out[368]: 
    城市     环比     同比
c1  北京  101.5  120.7
c2  上海  101.2  127.3
c3  广州  101.3  119.4
c4  深圳  102.0  140.9
c5  沈阳  100.1  101.4

4. 运算

4.1 算数运算

• 算术运算根据行列索引，补齐后运算
• 运算默认产生浮点数
• 补齐时缺项默认填充NaN(空值)
• 二维和一维、一维和零维间为广播运算
• 采用+- */符号进行的二元运算产生新的对象

# 测试数据

In [374]: a
Out[374]: 
   0  1   2   3
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11

In [375]: b
Out[375]: 
    0   1   2   3   4
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 [395]: c
Out[395]: 
   0  1  2  3
0  3  3  3  3
1  3  3  3  3
2  3  3  3  3

直接运算

In [376]: a + b
Out[376]: 
      0     1     2     3   4
0   0.0   2.0   4.0   6.0 NaN
1   9.0  11.0  13.0  15.0 NaN
2  18.0  20.0  22.0  24.0 NaN
3   NaN   NaN   NaN   NaN NaN

In [377]: a * b
Out[377]: 
      0     1      2      3   4
0   0.0   1.0    4.0    9.0 NaN
1  20.0  30.0   42.0   56.0 NaN
2  80.0  99.0  120.0  143.0 NaN
3   NaN   NaN    NaN    NaN NaN

使用方法运算

• .add(d, **argws)
• .sub( d, **argws)
• .mul(d，**argws)
• .div(d，**argws)

In [384]: b.add(a)
Out[384]: 
      0     1     2     3   4
0   0.0   2.0   4.0   6.0 NaN
1   9.0  11.0  13.0  15.0 NaN
2  18.0  20.0  22.0  24.0 NaN
3   NaN   NaN   NaN   NaN NaN

# 使用 fill_value 替换 NAN 参加运算
In [385]: b.add(a, fill_value=100)
Out[385]: 
       0      1      2      3      4
0    0.0    2.0    4.0    6.0  104.0
1    9.0   11.0   13.0   15.0  109.0
2   18.0   20.0   22.0   24.0  114.0
3  115.0  116.0  117.0  118.0  119.0

4.2 比较运算

直接运算

同大小，索引相同，才可以

符号：==、!=、<、>、<=、>=

In [413]: a >= c
Out[413]: 
       0      1      2     3
0  False  False  False  True
1   True   True   True  True
2   True   True   True  True

使用方法运算

大小和索引可以不同，索引会对应起来，缺失位用NAN填充

方法	全称	用途
eq	equal to	==
ne	not equal to	!=
lt	less than	<
gt	greater than	>
le	less than or equal to	<=
ge	greater than or equal to	>=

In [417]: a.eq(b)
Out[417]: 
       0      1      2      3      4
0   True   True   True   True  False
1  False  False  False  False  False
2  False  False  False  False  False
3  False  False  False  False  False

4.3 不同维度的运算

# 以广播的方式进行

# 0维
In [421]: a
Out[421]: 3

# 1维
In [422]: b
Out[422]: 
a    5
b    5
c    5
d    5
dtype: int64

# 2维
In [423]: c
Out[423]: 
   a  b   c   d
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11

注：

• 方法运算时，必须 ”高维.方法(低维)“
• 直接运算，高低维位置随意

一维VS多维

一维与二维：

In [431]: a + b
Out[431]: 
a    8
b    8
c    8
d    8
dtype: int64
    
In [432]: a > b
Out[432]: 
a    False
b    False
c    False
d    False
dtype: bool

一维与三维类似

二维VS三维

# (c每一行与b比较)
In [448]: c > b
Out[448]: 
       a      b      c      d
0  False  False  False  False 
1  False  False   True   True
2   True   True   True   True

In [450]: c.gt(b)
Out[450]: 
       a      b      c      d
0  False  False  False  False
1  False  False   True   True
2   True   True   True   True

5. 排序

5.1 按轴排序

.sort_index(axis=0,ascending=True)方法在指定轴上根据索引进行排序，默认升序

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

# 0轴升序（默认）
In [455]: b = a.sort_index()

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

# 1轴降序
In [457]: b = b.sort_index(axis=1, ascending=False)

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

5.2 按值排序

.sort_values()方法在指定轴上根据数值进行排序，默认升序

• Series.sort_values(axis=0, ascending=True)
• DataFrame.sort_values(by, axis=0, ascending=True)

​ by：axis上第by行\列

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

# 0轴方向（默认）、索引为2的列、降序
In [461]: b.sort_values(2, ascending=False)
Out[461]: 
    4   3   2   1   0
b  19  18  17  16  15
d  14  13  12  11  10
a   9   8   7   6   5
c   4   3   2   1   0

# 1轴方向、索引为a的行、升序（默认）
In [465]: b.sort_values('a', axis=1)
Out[465]: 
    0   1   2   3   4
a   5   6   7   8   9
b  15  16  17  18  19
c   0   1   2   3   4
d  10  11  12  13  14

若其中有NaN，排序时统一放到末尾。

6. 统计分析

6.1 基本统计分析

方法	参数	说明
.sum()	axis=0（默认）	计算数据的总和
.count()	axis=0	非NaN值的数量
.mean( )	axis=0	算术平均值
.median()	axis=0	算术中位数
.var()	axis=0	方差
.std()	axis=0	标准差
.min()	axis=0	最小值
.max()	axis=0	最大值
.argmin()	无	最大值所在位置的索引
.argmax()	无	最小值所在位置的索引
.idxmin()	axis=0	最大值所在位置的索引
.idxmax()	axis=0	最小值所在位置的索引
.describe()	无	针对0轴（各列）的统计汇总

注：

• argmin和argmax仅用于Series，其余Series和DataFrame都行
• argmin和argmax用于Series是输出自动索引
• idxmin和idxmax用于Series是输出自动索引
• describe结果是DataFrame，可用DataFrame的性质和方法

In [507]: c
Out[507]: 
   a  b   c   d
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11

In [508]: c.sum()
Out[508]: 
a    12
b    15
c    18
d    21
dtype: int64

In [509]: c.sum(axis=1)
Out[509]: 
0     6
1    22
2    38
dtype: int64

In [527]: c.describe()
Out[527]: 
         a    b     c     d
count  3.0  3.0   3.0   3.0
mean   4.0  5.0   6.0   7.0
std    4.0  4.0   4.0   4.0
min    0.0  1.0   2.0   3.0
25%    2.0  3.0   4.0   5.0
50%    4.0  5.0   6.0   7.0
75%    6.0  7.0   8.0   9.0
max    8.0  9.0  10.0  11.0

In [528]: c.describe().loc[['min']]
Out[528]: 
       a    b    c    d
min  0.0  1.0  2.0  3.0

In [529]: c.describe()[['c']]
Out[529]: 
          c
count   3.0
mean    6.0
std     4.0
min     2.0
25%     4.0
50%     6.0
75%     8.0
max    10.0

6.1 累计统计分析

方法	说明
.cumsum()	依次给出前1、2、…、n个数的和
.cumprod()	依次给出前1、2、…、n个数的积
.cummax()	依次给出前1、2、…、n个数的最大值
.cummin()	依次给出前1、2、…、n个数的最小值

注：默认0轴方向，可加参数 axis=1

In [536]: c
Out[536]: 
   a  b   c   d
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11

In [537]: c.cumprod()
Out[537]: 
   a   b    c    d
0  0   1    2    3
1  0   5   12   21
2  0  45  120  231

In [538]: c.cumprod(axis=1)
Out[538]: 
   a   b    c     d
0  0   0    0     0
1  4  20  120   840
2  8  72  720  7920

方法	说明
.rolling(w).sum( )	依次计算相邻w个元素的和
.rolling(w).mean()	依次计算相邻w个元素的算术平均值
.rolling(w).var()	依次计算相邻w个元素的方差
.rolling(w).std()	依次计算相邻w个元素的标准差
.rolling(w).min( )	依次计算相邻w个元素的最小值
.rolling(w).max()	依次计算相邻w个元素的最大值

注：

• 默认0轴方向，rolling中可加参数 axis=1
• w个元素包括当前元素和前面w-1个，不足则为NaN

In [539]: c
Out[539]: 
   a  b   c   d
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11

In [541]: c.rolling(3).sum()
Out[541]: 
      a     b     c     d
0   NaN   NaN   NaN   NaN
1   NaN   NaN   NaN   NaN
2  12.0  15.0  18.0  21.0

In [542]: c.rolling(3,axis=1).sum()
Out[542]: 
    a   b     c     d
0 NaN NaN   3.0   6.0
1 NaN NaN  15.0  18.0
2 NaN NaN  27.0  30.0

7. 相关性分析

7.1 协方差

• 协方差>0，X和Y正相关
• 协方差<0，X和Y负相关
• 协方差=0，X和Y独立无关

.cov()用于计算协方差矩阵

7.2 Pearson相关系数

r为Pearson相关系数，取值范围[-1,+1]

|r|范围：

• 0.8-1.0 极强相关
• 0.6-0.8 强相关
• 0.4-0.6 中等程度相关
• 0.2-0.4 弱相关
• 0.0-0.2 极弱相关或无相关

.corr()用于计算相关系数矩阵（Pearson、Spearman、Kendall等系数）

示例：

In [556]: a
Out[556]: 
2008     3.04
2009    22.93
2010    12.75
2011    22.60
2012    12.33
dtype: float64

In [557]: b
Out[557]: 
2008     8.18
2009    18.38
2010     9.13
2011     7.82
2012     6.96
dtype: float64

In [558]: a.cov(b)
Out[558]: 20.46345

In [559]: a.corr(b)
Out[559]: 0.5249598283887876

8. 文件读写

Pandas CSV 文件 | 菜鸟教程 (runoob.com)

Pandas JSON | 菜鸟教程 (runoob.com)

9. 数据清洗

空值、错值、重复值

Pandas 数据清洗 | 菜鸟教程 (runoob.com)