利用Python进行数据分析之数据规整

在很多应用中，数据可能分布在多个文件或数据库中，亦或以某种不易于分析的格式进行排列，需要对数据进行联合、连接以及重新排列等操作。

分层索引

分层索引允许你在一个轴向上拥有多个索引层级。笼统地说，分层索引提供了一种在更低维度的形式中处理更高维度数据的方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import numpy as np
import pandas as pd

def prints(a):
    print(a)
    print('='*30)

# 创建测试数据--Series
data = pd.Series(np.random.randn(9),
                 index=[['a','a','a','b','b','c','c','d','d'],[1,2,3,1,3,1,2,2,3]])

# 以MultiIndex作为索引的美化视图，索引中的间隙表示“直接使用上面的标签”，也叫“外层索引”
prints(data)
prints(data.index)

# 通过外层索引，可以简洁地选择数据子集
prints(data['a'])
prints(data['b':'c'])
prints(data.loc[['b','d']])

# 在内部索引中选择子集
prints(data.loc[:,2])

分层索引可以使用stack函数和unstack函数实现数据重塑，即完成具有层次索引的Series和DataFrame之间的转换，具体可参考后面数据重塑部分的介绍。

在DataFrame中，每个轴也都可以拥有分层索引

1
2
3
4
5
6
7
8
9
10
11
12
13
import numpy as np
import pandas as pd

# 创建行和列都有分层索引的DataFrame
frame = pd.DataFrame(np.arange(12).reshape((4,3)),
                     index=[['a','a','b','b'],[1,2,1,2]],
                     columns=[['apple','apple','banana'],['green','red','green']])
print(frame)

# 为层级索引命名
frame.index.names = ['key1','key2']
frame.columns.names = ['fruit','color']
print(frame)

重排序和层级排序

有时需要重新排列轴上的层级顺序，或者按照特定层级的值对数据进行排序，可以使用swaplevel接收两个层级序号或层级名称，返回一个进行了层级变更的对象；而sort_index只能在单一层级上对数据进行排序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import numpy as np
import pandas as pd

frame = pd.DataFrame(np.arange(12).reshape((4,3)),
                     index=[['a','a','b','b'],[1,2,1,2]],
                     columns=[['apple','apple','banana'],['green','red','green']])
# 为层级索引命名
frame.index.names = ['key1','key2']
frame.columns.names = ['fruit','color']
print(frame)

# 将'key1'和'key2'掉换位置，使'key2'成为外层索引，'key1'成为内层索引，但是数据顺序不变
print(frame.swaplevel('key1','key2'))

# 对单层索引数据进行排序，level=1表示按照内层索引排序
print(frame.sort_index(level=1))

# 层级变换 + 层级排序，level=0表示按照外层索引排序
print(frame.swaplevel(0,1).sort_index(level=0))

索引按照字典顺序从最外层开始排序是，数据选择性能和数据可读性会更好。

按层级进行汇总统计

DataFrame和Series中很多描述型和统计型函数有一个level选项可以指定想要在某个特定的轴上进行聚合。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import numpy as np
import pandas as pd

frame = pd.DataFrame(np.arange(12).reshape((4,3)),
                     index=[['a','a','b','b'],[1,2,1,2]],
                     columns=[['apple','apple','banana'],['green','red','green']])

# 为层级索引命名
frame.index.names = ['key1','key2']
frame.columns.names = ['fruit','color']

# 按照'key2'进行汇总，默认按照行汇总
print(frame.sum(level='key2'))

# 按照'color'列进行汇总，指定按列进行汇总
print(frame.sum(level='color',axis=1))

使用DataFrame的列进行索引

有时候需要将某些列作为索引可以通过set_index函数实现。reset_index是它的反函数，可以将分层索引的索引移动到列中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import numpy as np
import pandas as pd

def prints(a):
    print(a)
    print('='*30)
    
# 创建一个基础数据--DataFrame
frame = pd.DataFrame({'a':range(7),
                      'b':range(7,0,-1),
                      'c':['one','one','one','two','two','two','two'],
                      'd':[0,1,2,0,1,2,3]})
prints(frame)

# 将'c''d'列设为层次索引，其中'c'列是外层索引，'d'列是内层索引
frame2 = frame.set_index(['c','d'],drop=True)
prints(frame2)

# 将层次索引还原回矩阵，形成DataFrame的数据
frame3 = frame2.reset_index()
prints(frame3)

联合与合并数据集

包含pandas对象的数据可以通过多种方式联合在一起：

  • pd.merge根据一个或多个键进行连接
  • pd.concat使对象在轴向上进行黏合或堆叠
  • combine_first实例方法允许将重叠的数据拼接在一起，以使用一个对象中的值填充另一个对象中的缺失值

数据库风格连接

其中pd.merge实现的是数据库的连接操作，用于将各种join操作算法运用到你的数据上

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import numpy as np
import pandas as pd

def prints(a):
    print(a)
    print('='*30)

left = pd.DataFrame({'key':['K10','K1','K2','K3'],
                     'A':['A0','A1','A2','A3'],
                     'B':['B0','B1','B2','B3']})
right = pd.DataFrame({'key':['K0','K1','K2','K3'],
                      'C':['C0','C1','C2','C3'],
                      'D':['D0','D1','D2','D3']})
prints(left)
prints(right)

# 没有指定连接键时，自动将重叠列名作为连接键，默认做内连接，取的是两张表的交集
prints(pd.merge(left,right))

prints(pd.merge(left,right,on='key',how='left'))
prints(pd.merge(left,right,on='key',how='outer'))

merge函数参数如下：

参数 描述
left 合并时，左边的DataFrame数据
right 合并时，右边的DataFrame数据
how 连接方式：’inner’，’outer’，’left’，’right’之一，默认是’inner’
on 连接键，必须是两边DataFrame都有的列名
left_on left DataFrame中用作连接键的列
right_on right DataFrame中用作连接键的列
left_index 使用left的行索引作为它的连接键
right_index 使用right的行索引作为它的连接键
sort 通过连接键按字母顺序合并的数据进行排序，默认为True
suffixes 添加到列名后到字符串元组，默认是’_x’ ， ‘_y’
copy 如果是False，在某些特殊情况下避免将数据复制到结果数据结构中，默认情况是复制的
indicator 添加一个特殊的列_merge，指示每一行的来源，值将根据每行中连接数据的来源分为’left_only’，’right_only’，’both’

根据索引合并

有时需要根据DataFrame的索引进行合并，可以传递left_index=True或者right_index=True，或者都传，来表示索引需要用来作为合并的键

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import numpy as np
import pandas as pd

def prints(a):
    print(a)
    print('='*30)

left = pd.DataFrame([[1,2],[3,4],[5,6]],
                    index=['a','c','e'],
                    columns=['语文','数学'])
right = pd.DataFrame([[7,8],[9,10],[11,12],[13,14]],
                     index=['b','c','d','e'],
                     columns=['英语','综合'])
prints(left)
prints(right)

prints(pd.merge(left,right,how='outer',left_index=True,right_index=True))

DataFrame有一个方便的join实例方法，用于按照索引合并，也可以用于合并多个索引相同或相似但没有重叠列的DataFrame对象，上面的数据合并也可以这样写：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import numpy as np
import pandas as pd

def prints(a):
    print(a)
    print('='*30)

left = pd.DataFrame([[1,2],[3,4],[5,6]],
                    index=['a','c','e'],
                    columns=['语文','数学'])
right = pd.DataFrame([[7,8],[9,10],[11,12],[13,14]],
                     index=['b','c','d','e'],
                     columns=['英语','综合'])
prints(left)
prints(right)

# join方法按照索引进行合并，要求两个表格没有重叠的列名
prints(left.join(right,how='outer'))

对于一些简单的索引-索引合并，也可以向join方法中转入一个DataFrame列表，进行多对象合并。

沿轴向连接

另一种数据组合操作可称为拼接、绑定或堆叠。np.concatenate函数可以在Numpy数组上实现该功能：

1
2
3
4
import numpy as np

arr = np.arange(12).reshape((3,4))
print(np.concatenate([arr,arr],axis=1))

pandas的concat函数提供了实现将值和索引粘在一起的功能，先来看看concat在Series中的表现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import numpy as np
import pandas as pd

s1 = pd.Series([0,1],index=['a','b'])
s2 = pd.Series([2,3,4],index=['c','d','e'])
s3 = pd.Series([5,6],index=['f','g'])

# 默认情况按照axis=0的轴拼接，生成一个新的Series
print(pd.concat([s1,s2,s3]))

# 指定axis=1的轴拼接，会生成一个新的DataFrame，默认是join='outer'外连接
print(pd.concat([s1,s2,s3],axis=1))

s4 = pd.concat([s1,s3])

# 指定内连接，可以发现'f'和'g'标签消失了
print(pd.concat([s1,s4],axis=1,join='inner'))

# 使用join_axes来指定用于连接其他轴向的轴
print(pd.concat([s1,s4],axis=1,join_axes=[['a','c','b','e']]))

# 使用keys参数在连接轴向上创建一个多层索引，keys的值就是外层索引
result = pd.concat([s1,s2,s3],keys=['one','two','three'])

# 使用unstack函数将Series重塑成DataFrame,keys作为外层索引，会变为DataFrame的行索引
print(result.unstack())

# concat沿着轴向axis=1连接Series时，也会形成一个DataFrame，keys称为列标签
print(pd.concat([s1,s2,s3],axis=1,keys=['one','two','three']))

相同的逻辑应用到DataFrame的连接中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import numpy as np
import pandas as pd

df1 = pd.DataFrame(np.arange(6).reshape(3,2),
                   index=list('abc'),
                   columns=['one','two'])
df2 = pd.DataFrame(np.arange(4).reshape(2,2)+5,
                   index=list('ac'),
                   columns=['three','four'])

# 沿着axis=1轴向拼接时，keys称为列的外层索引
print(pd.concat([df1,df2],axis=1,keys=['level1','level2']))

# 上面的效果不用列表而用字典表示，keys的值需要放在字典的键上
print(pd.concat({'level1':df1,'level2':df2},axis=1))

# names参数命名生成的轴层级
print(pd.concat([df1,df2],axis=1,keys=['level1','level2'],
                names=['upper','lower']))

# 不沿着连接轴保留索引
df3 = pd.DataFrame(np.random.randn(3,4),columns=['a','b','c','d'])
df4 = pd.DataFrame(np.random.randn(2,3),columns=['b','d','a'])
print([df1,df2],ignore_index=True)

concat函数的参数

参数 描述
objs 需要连接的pandas对象列表或字典
axis 连接的轴向，默认是0，即行方向
join 默认是’outer’，用于指定连接方式
join_axes 用于指定其他轴的特定索引
keys 与要连接的对象关联的值，形成层级索引
levels 在键值传递时，指定多层索引的层级
names 用于指定多层索引的层级名称
verify_integrity 检查连接对象中新的轴是否重复，默认是False，允许重复
ignore_index 不沿着连接轴保留索引，生成新的索引

联合重叠数据

当你有两个数据集，它们的索引全部或部分重叠，你需要用根据轴向索引，用其中一个数据集的值填充或替换另一个数据集的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import numpy as np
import pandas as pd

a = pd.Series([np.nan,2.5,0.0,3.5,4.5,np.nan],
             index=['f','e','d','c','b','a'])
b = pd.Series([0.,np.nan,2.,np.nan,np.nan,5.],
             index=['a','b','c','d','e','f'])

# 使用np.where函数实现，如果a是空，则取b的值，否则取a的值
print(np.where(pd.isnull(a),b,a))

# 使用pd.combine_first函数实现
print(b.combine_first(a))

# 在DataFrame中，combine_first逐列做相同的操作，可以认为它根据传入的对象来修复调用对象的缺失值
df1 = pd.DataFrame({'a':[1.,np.nan,5.,np.nan],
                    'b':[np.nan,2.,np.nan,6.]
                    'c':range(2,18,4)})
df2 = pd.DataFrame({'a':[5.,4.,np.nan,3.,7.],
                    'b':[np.nan,3.,4.,6.,8.]})

print(df1.combine_first(df2))

重塑和透视

重排列表格型数据有多种基础操作，比如重塑或透视。

使用多层索引进行重塑

多层索引在DataFrame中提供了一种一致性方式用于重排列数据：

  • stack（堆叠）：将列中的数据透视到行，即DataFrame变为多重索引的Series，行标签即外层索引
  • unstack（拆堆）：将行中的数据透视到列，即多重索引的Series变为DataFrame，内层索引变为列标签
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import numpy as np
import pandas as pd

def prints(a):
    print(a)
    print('='*30)

data = pd.DataFrame(np.arange(6).reshape(2,3),
                    index=pd.Index(['Jerry','Tom'],name='Name'),
                    columns=pd.Index(['Chinese','Math','English'],name='Course'))
prints(data)

# stack函数 将dataframe对象转换为Series对象
# stack函数 将列索引旋转为行索引，完成层级索引
r = data.stack()
prints(r)

# unstack函数 将Series对象转换成DataFrame，内层索引为列标签，外层索引为行标签
prints(r.unstack())
# 通过指定level=0，使内层索引称为列标签，外层索引称为列标签，
prints(r.unstack(level=0))
# 指定标签名的方式，也可以指定列标签
print(r.unstack('Course'))

# 如果层级中的所有值并未包含于每个子分组时，拆分可能会引入缺失值
a1 = pd.Series(np.arange(4),index=list('abcd'))
a2 = pd.Series(np.arange(3)+4,index=list('cde'))

# 创建层级索引Series
s1 = pd.concat([a1,a2],keys=['data1','data2'])
prints(s1)
# 旋转为DataFrame时出现缺失值
prints(s1.unstack())
# stack 默认过滤nan
prints(s1.unstack().stack())
prints(s1.unstack().stack(dropna=False))

将长透视为宽

将一列变换成DataFrame中的多列，需要掌握pivot函数的用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import numpy as np
import pandas as pd


def prints(a):
    print(a)
    print('='*30)


df = pd.DataFrame({'date': ['2018-11-22', '2018-11-22', '2018-11-23', '2018-11-23', '2018-11-24'],
                   'class': ['a', 'b', 'b', 'c', 'c'], 
                   'values': [5, 3, 2, 6, 1]}, 
                  columns=['date', 'class', 'values'])
prints(df)

# 利用pivot函数，将date指定为行标签，class指定为列标签，透视出values的值
df1 = df.pivot(index='date', columns='class', values='values')
prints(df1)

# pivot的等价写法如下，可利用set_index函数和unstack函数联合实现
prints(df.set_index(['date', 'class']).unstack(level='class'))

将宽透视为长

np.melt是pivot方法的反函数，它将多列合并成一列，产生一个新的DataFrame：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import numpy as np
import pandas as pd

df = pd.DataFrame({'key':['foo','bar','baz'],
                   'A':[1,2,3],
                   'B':[4,5,6],
                   'C':[7,8,9]})
# 将'key'列作为分组指标，其他列作为数值
melted = pd.melt(df,'key')
print(melted)

# 使用pivot函数，可以将数据重塑回原先的布局
reshaped = melted.pivot('key','variable','value')
print(reshaped)

# 使用reset_index将数据回移一列
print(reshaped.reset_index())

# 指定列的子集作为值列
melted2	= pd.melt(df,id_vars=['key'],value_vars=['A','B'])
print(melted2)

# 或者无需任何分组指标
print(pd.melt(df,value_vars=['A','B','C']))
print(pd.melt(df,value_vars=['key','A','B']))

数据分组和聚合

数据分组需要掌握groupby函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
import numpy as np
import pandas as pd


def prints(a):
    print(a)
    print('='*30)


df1 = pd.DataFrame({'fruit': ['apple', 'banana', 'orange', 'apple', 'banana'],
                    'color': ['red', 'yellow', 'yellow', 'cyan', 'cyan'],
                    'price': [8.5, 6.8, 5.6, 7.8, 6.4]})
prints(df1)

# 数据分组
g = df1.groupby(by='fruit')

# groupby返回的是数据类型
prints(g)

# 循环打印groupby中每个组的数据
for name,group in g:
    print(name)
    print('-'*30)
    print(group)
    print(type(group))
    print('='*30)

# 将groupby的数据转换成列表，并打印苹果的分组
prints(dict(list(df1.groupby(by='fruit')))['apple'])

# 数据聚合 输出为series
mean = df1.groupby(by='fruit')['price'].mean()
prints(mean)

# 语法糖的方式
mean1 = df1['price'].groupby(df1['fruit']).mean()
prints(mean1)

# as_index 输出为dataframe
mean2 = df1.groupby(by='fruit',as_index=False)['price'].mean()
prints(mean2)

# 计算每种水果的差值
# 自定义一个减法函数
def diff(arr):
    return arr.max() - arr.min()

# 用到agg aggregate函数
diff = df1.groupby(by='fruit')['price'].agg(diff)
prints(diff)

# 多个分组参数
mean3 = df1.groupby(by=['fruit','color'])['price'].mean()
prints(mean3)

# 语法糖形式
mean4 = df1['price'].groupby(by=[df1['fruit'],df1['color']]).mean()
prints(mean4)

# 修改输出DataFrame格式
mean5 = df1.groupby(by=['fruit','color'])[['price']].mean()
mean6 = df1[['price']].groupby(by=[df1['fruit'],df1['color']]).mean()
prints(mean5)
prints(mean6)


# 补充内容，先定义一个DataFrame
people = pd.DataFrame(np.random.randn(5,5),
                      columns=['a','b','c','d','e'],
                      index=['Sam','Mark','Tony','Jim','Nana'])
prints(people)

#  通过字典进行分组
m = {'a':'red','b':'red','c':'blue','d':'blue','e':'red','f':'orange'}
sum = people.groupby(by=m,axis=1).sum()
prints(sum)

# 通过Series进行分组
s1 = pd.Series(m)
count = people.groupby(by=s1,axis=1).count()
prints(count)

# 通过函数进行分组
len = people.groupby(by=len).sum() # 按照索引字符串长度进行分组
prints(len)
赏

谢谢你请我吃糖果

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

萌新伊始<br><br>把这里作为记录学习和成长的平台<br><br>如果您觉得不错<br><br>可以请我喝杯咖啡☕️<br>