利用Python进行数据分析-Pandas(第五部分-数据规整:聚合、合并和重塑)

  在许多应用中,数据可能分散在许多文件或数据库中,存储的形式也不利于分析。本部分关注可以聚合、合并、重塑数据的方法。

1、层次化索引

  层次化索引(hierarchical indexing)是pandas的一项重要功能,它使你能在一个轴上拥有多个(两个以上)索引级别。抽象点说,它使你能以低纬度形式处理高纬度数据。我们来看一个简单的栗子:创建一个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]])
print(data)
a  1   -1.624220
2 -1.061747
3 0.895593
b 1 -2.702315
3 -1.690189
c 1 2.608471
2 1.167507
d 2 0.139161
3 1.298629
dtype: float64

看到的结果是经过美化的带有MultiIndex索引的Series的格式。索引之间的“间隔”表示“直接使用上面的标签”:

print(data.index)
MultiIndex([('a', 1),
('a', 2),
('a', 3),
('b', 1),
('b', 3),
('c', 1),
('c', 2),
('d', 2),
('d', 3)],
)

对于一个层次化索引的对象,可以使用所谓的部分索引,使用它选取数据子集的操作更简单:

print(data['b'])
1    0.543979
3 -0.454024
dtype: float64
print(data['b':'c'])
b  1    0.543979
3 -0.454024
c 1 -0.764155
2 -1.453191
dtype: float64
print(data.loc[['b', 'd']])
b  1    0.543979
3 -0.454024
d 2 0.954414
3 -0.683874
dtype: float64

有时甚至还可以在“内层”中进行选取:

print(data.loc[:, 2])
a    0.359590
c 0.508768
d 1.482796
dtype: float64

层次化索引在数据重塑和基于分组的操作(如透视表生成)中扮演着重要的角色。例如,可以通过unstack方法将这段数据重新安排到一个DataFrame中:

print(data.unstack())
          1         2         3
a 2.218684 -0.383126 0.020178
b -1.468355 NaN -1.042682
c -0.291976 0.658995 NaN
d NaN 0.402100 1.726501

unstack的逆运算是stack:

print(data.unstack().stack())
a  1   -0.606073
2 -0.597230
3 0.117367
b 1 0.438933
3 0.577631
c 1 -0.300920
2 -0.308119
d 2 -0.005924
3 -1.015638
dtype: float64

对于一个DataFrame,每条轴都可以有分层索引:

frame = pd.DataFrame(np.arange(12).reshape((4, 3)), index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]], columns=[['Ohio', 'Ohio', 'Colorado'], ['Green', 'Red', 'Green']])
print(frame)
     Ohio     Colorado
Green Red Green
a 1 0 1 2
2 3 4 5
b 1 6 7 8
2 9 10 11

各层都可以有名字(可以是字符串,也可以是别的Python对象)。如果指定了名称,它们就会显示在控制台输出:

frame.index.names = ['key1', 'key2']
frame.columns.names = ['state', 'color']
print(frame)
state      Ohio     Colorado
color Green Red Green
key1 key2
a 1 0 1 2
2 3 4 5
b 1 6 7 8
2 9 10 11

注意:小心区分索引名state、color与行标签。

有了部分列索引,因此可以轻松选取列分组:

print(frame['Ohio'])
color      Green  Red
key1 key2
a 1 0 1
2 3 4
b 1 6 7
2 9 10

2、重排与分级排序

  有时,你需要重新调整某条轴上各级别的顺序,或根据指定级别上的值对数据进行排序。swaplevel接受两个级别编号或名称,并返回一个互换了级别的新对象(但数据不会发生变化):

print(frame.swaplevel('key1', 'key2'))
state      Ohio     Colorado
color Green Red Green
key2 key1
1 a 0 1 2
2 a 3 4 5
1 b 6 7 8
2 b 9 10 11

而sort_index则根据单个级别中的值对数据进行排序。交换级别时,常常也会用到sort_index,这样最终结果就是按照指定顺序进行字母排序了:

print(frame.sort_index(level=1))
state      Ohio     Colorado
color Green Red Green
key1 key2
a 1 0 1 2
b 1 6 7 8
a 2 3 4 5
b 2 9 10 11
print(frame.swaplevel(0, 1).sort_index(level=0))
state      Ohio     Colorado
color Green Red Green
key2 key1
1 a 0 1 2
b 6 7 8
2 a 3 4 5
b 9 10 11

3、根据级别汇总统计

  许多对DataFrame和Series的描述和汇总统计都有一个level选项,它用于指定在某条轴上求和的级别。再以上面那个DataFrame为例,我们可以根据行或列上的级别来进行求和:

print(frame.sum(level='key2'))
state  Ohio     Colorado
color Green Red Green
key2
1 6 8 10
2 12 14 16
print(frame.sum(level='color', axis=1))
color      Green  Red
key1 key2
a 1 2 1
2 8 4
b 1 14 7
2 20 10

这其实是利用了pandas的groupy功能。

4、使用DataFrame的列进行索引

  人们经常想要将DataFrame的一个或多个列当做行索引来用,或者可能希望将行索引变成DataFrame的列。以下面这个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]})
print(frame)
   a  b    c  d
0 0 7 one 0
1 1 6 one 1
2 2 5 one 2
3 3 4 two 0
4 4 3 two 1
5 5 2 two 2
6 6 1 two 3

DataFrame的set_index函数会将其一个或多个列转换为行索引,并创建一个新的DataFrame:

frame2 = frame.set_index(['c', 'd'])
print(frame2)
       a  b
c d
one 0 0 7
1 1 6
2 2 5
two 0 3 4
1 4 3
2 5 2
3 6 1

默认情况下,那些列会从DataFrame中移除,但也可以将其保留下来:

print(frame.set_index(['c', 'd'], drop=False))
       a  b    c  d
c d
one 0 0 7 one 0
1 1 6 one 1
2 2 5 one 2
two 0 3 4 two 0
1 4 3 two 1
2 5 2 two 2
3 6 1 two 3

reset_index的功能跟set_index刚好相反,层次化索引的级别会被转移到列里面:

print(frame2.reset_index())
     c  d  a  b
0 one 0 0 7
1 one 1 1 6
2 one 2 2 5
3 two 0 3 4
4 two 1 4 3
5 two 2 5 2
6 two 3 6 1

5、合并数据集-数据库风格的DataFrame合并

  pandas对象中的数据可以通过一些方式进行合并:

  • pandas.merge可根据一个或多个键将不同DataFrame中的行连接起来。SQL或其他关系型数据库的用户对此应该回比较熟悉,因为它实现的就是数据库的join操作。
  • pandas.concat可以沿着一条轴将多个对象叠到一起。
  • 实例方法combine_first可以将重复数据编接在一起,用一个对象中的值填充另一个对象中的缺失值。

  数据集的合并(merge)或连接(join)运算是通过一个或多个键将行衔接起来的。这些运算是关系型数据库的核心。pandas的merge函数是对数据应用这些算法的主要切入点:

df1 = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'], 'data1': range(7)})
df2 = pd.DataFrame({'key': ['a', 'b', 'd'], 'data2': range(3)})
print(df1)
print(df2)
  key  data1
0 b 0
1 b 1
2 a 2
3 c 3
4 a 4
5 a 5
6 b 6
key data2
0 a 0
1 b 1
2 d 2

这是一种多对一的合并。df1中的数据有多个被标记为a和b的行,而df2中key列的每个值仅对应一行。对这些对象调用merge即可得到:

print(pd.merge(df1, df2))
  key  data1  data2
0 b 0 1
1 b 1 1
2 b 6 1
3 a 2 0
4 a 4 0
5 a 5 0

注意,我并没有指明要用哪个列进行连接。如果没有指定,merge就会将重叠列的列名当做键。不过,最好明确指定一下:

print(pd.merge(df1, df2, on='key'))
  key  data1  data2
0 b 0 1
1 b 1 1
2 b 6 1
3 a 2 0
4 a 4 0
5 a 5 0

如果两个对象的列名不同,也可以分别进行指定:

print(pd.merge(df3, df4, left_on='lkey', right_on='rkey'))
 lkey  data1 rkey  data2
0 b 0 b 1
1 b 1 b 1
2 b 6 b 1
3 a 2 a 0
4 a 4 a 0
5 a 5 a 0

可能你已经注意到了,结果里面c和d以及与之相关的数据消失了。默认情况下,merge做的是“内连接”;结果中的键是交集。其他方式还有“left”、“right”以及“outer”。外连接求取的是键的并集,组合了左连接和右连接的效果:

print(pd.merge(df1, df2, how='outer'))
  key  data1  data2
0 b 0.0 1.0
1 b 1.0 1.0
2 b 6.0 1.0
3 a 2.0 0.0
4 a 4.0 0.0
5 a 5.0 0.0
6 c 3.0 NaN
7 d NaN 2.0

如下表对这些选项进行了总结:

选项 说明
inner 使用两个表都有的键
left 使用左表中所有的键
right 使用右表中所有的键
outer 使用两个表中所有的键

多对多的合并有些不直观。看下面的栗子:

df1 = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'b'], 'data1': range(6)})
print(df1)
  key  data1
0 b 0
1 b 1
2 a 2
3 c 3
4 a 4
5 b 5
df2 = pd.DataFrame({'key': ['a', 'b', 'a', 'b', 'd'], 'data2': range(5)})
print(df2)
  key  data2
0 a 0
1 b 1
2 a 2
3 b 3
4 d 4
print(pd.merge(df1, df2, on='key', how='left'))
   key  data1  data2
0 b 0 1.0
1 b 0 3.0
2 b 1 1.0
3 b 1 3.0
4 a 2 0.0
5 a 2 2.0
6 c 3 NaN
7 a 4 0.0
8 a 4 2.0
9 b 5 1.0
10 b 5 3.0

多对多连接产生的是行的笛卡尔积。由于左边的DataFrame有3个“b”行,右边的有2个,所以最终结果中就有6个“b”行。连接方式只影响出现在结果中的不同的键的值:

print(pd.merge(df1, df2, how='inner'))
  key  data1  data2
0 b 0 1
1 b 0 3
2 b 1 1
3 b 1 3
4 b 5 1
5 b 5 3
6 a 2 0
7 a 2 2
8 a 4 0
9 a 4 2

要根据多个键进行合并,传入一个由列名组成的列表即可:

print(pd.merge(left, right, on=['key1', 'key2'], how='outer'))
  key1 key2  lval  rval
0 foo one 1.0 4.0
1 foo one 1.0 5.0
2 foo two 2.0 NaN
3 bar one 3.0 6.0
4 bar two NaN 7.0

结果中会出现哪些键组合取决于所选的合并方式,你可以这样来理解:多个键形成一系列元组,并将其当做单个连接键。

注意:在进行列-列连接时,DataFrame对象中的索引会被丢弃。

对于合并运算需要考虑的最后一个问题是对重复列名的处理。虽然你可以手工处理列名重叠的问题,但merge有一个更实用的suffixes选项,用于指定附加到左右两个DataFrame对象的重叠列名上的字符串:

print(pd.merge(left, right, on='key1', suffixes=('_left', '_right')))
  key1 key2_left  lval key2_right  rval
0 foo one 1 one 4
1 foo one 1 one 5
2 foo two 2 one 4
3 foo two 2 one 5
4 bar one 3 one 6
5 bar one 3 two 7

如下表是merge函数的参数:

参数  说明
          left         参与合并的左侧DataFrame
right 参与合并的右侧DataFrame
how "inner"、"outer"、"left"、"right"其中之一。默认为"inner"
              on                用于连接的列名。必须存在于左右两个DataFrame对象中。如果未指定,且其他连接键也未指定,则以left和right列名的交集作为连接集
left_on 左侧DataFrame中用作连接键的列
right_on 右侧DataFrame中用作连接键的列
left_index 将左侧的行索引用作其连接键
right_index   类似于left_index
sort 根据连接键对合并后的数据进行排序,默认为True。有时在处理大数据集时,禁用该选项可获得更好的性能
suffixes 字符串值元组,用于追加到重叠名的末尾,默认为('_x','_y')。
copy 设置为False,可以在某些特殊情况下避免将数据复制到结果数据结构中。默认总是复制

indicator添加特殊的列_merge,它可以指明每个行的来源,它的值有left_only、right_only或both,根据每行的合并数据的来源。

6、索引上的合并

  有时候,DataFrame中的连接键位于其索引中。在这种情况下,你可以传入left_index=True或right_index= True(或两个都传)以说明索引应该被用作连接键:

left1 = pd.DataFrame({'key': ['a', 'b', 'a', 'a', 'b', 'c'], 'value': range(6)})
print(left1)
  key  value
0 a 0
1 b 1
2 a 2
3 a 3
4 b 4
5 c 5
right1 = pd.DataFrame({'group_val': [3.5, 7]}, index=['a', 'b'])
print(right1)
   group_val
a 3.5
b 7.0
print(pd.merge(left1, right1, left_on='key', right_index=True))
  key  value  group_val
0 a 0 3.5
2 a 2 3.5
3 a 3 3.5
1 b 1 7.0
4 b 4 7.0

由于默认的merge方法是求取连接键的交集,因此你可以通过外连接的方式得到它们的并集:

print(pd.merge(left1, right1, left_on='key', right_index=True, how='outer'))
  key  value  group_val
0 a 0 3.5
2 a 2 3.5
3 a 3 3.5
1 b 1 7.0
4 b 4 7.0
5 c 5 NaN

对于层次化索引的数据,事情就有点复杂了,因为索引的合并默认是多键合并:

lefth = pd.DataFrame({'key1': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'], 'key2': [2000, 2001, 2002, 2001, 2002], 'data': np.arange(5.)})
print(lefth)
     key1  key2  data
0 Ohio 2000 0.0
1 Ohio 2001 1.0
2 Ohio 2002 2.0
3 Nevada 2001 3.0
4 Nevada 2002 4.0
righth = pd.DataFrame(np.arange(12).reshape((6, 2)), index=[['Nevada', 'Nevada', 'Ohio', 'Ohio', 'Ohio', 'Ohio'], [2001, 2000, 2000, 2000, 2001, 2002]], 
columns=['event1', 'event2'])
print(righth)
             event1  event2
Nevada 2001 0 1
2000 2 3
Ohio 2000 4 5
2000 6 7
2001 8 9
2002 10 11

这种情况下,你必须以列表的形式指明用作合并键的多个列(注意用how='outer'对重复索引值的处理):

print(pd.merge(lefth, righth, left_on=['key1', 'key2'], right_index=True))
     key1  key2  data  event1  event2
0 Ohio 2000 0.0 4 5
0 Ohio 2000 0.0 6 7
1 Ohio 2001 1.0 8 9
2 Ohio 2002 2.0 10 11
3 Nevada 2001 3.0 0 1
print(pd.merge(lefth, righth, left_on=['key1', 'key2'], right_index=True, how='outer'))
     key1  key2  data  event1  event2
0 Ohio 2000 0.0 4.0 5.0
0 Ohio 2000 0.0 6.0 7.0
1 Ohio 2001 1.0 8.0 9.0
2 Ohio 2002 2.0 10.0 11.0
3 Nevada 2001 3.0 0.0 1.0
4 Nevada 2002 4.0 NaN NaN
4 Nevada 2000 NaN 2.0 3.0

同时使用合并双方的索引也没问题:

left2 = pd.DataFrame([[1., 2.], [3., 4.], [5., 6.]], index=['a', 'c', 'e'], columns=['Ohio', 'Nevada'])
right2 = pd.DataFrame([[7., 8.], [9., 10.], [11., 12.], [13., 14.]], index=['b', 'c', 'd', 'e'], columns=['Missouri', 'Alabama'])
print(left2)
print(right2)
   Ohio  Nevada
a 1.0 2.0
c 3.0 4.0
e 5.0 6.0
Missouri Alabama
b 7.0 8.0
c 9.0 10.0
d 11.0 12.0
e 13.0 14.0

DataFrame还有一个便捷的join实例方法,它能更方便地实现按索引合并。它还可用于合并多个带有相同或相似索引的DataFrame对象,但要求没有重叠的列。在上面那个例子中,我们可以编写:

print(left2.join(right2, how='outer'))
   Ohio  Nevada  Missouri  Alabama
a 1.0 2.0 NaN NaN
b NaN NaN 7.0 8.0
c 3.0 4.0 9.0 10.0
d NaN NaN 11.0 12.0
e 5.0 6.0 13.0 14.0

因为一些历史版本的遗留原因,DataFrame的join方法默认使用的是左连接,保留左边表的行索引。它还支持在调用的DataFrame的列上,连接传递的DataFrame索引:

print(left1.join(right1, on='key'))
  key  value  group_val
0 a 0 3.5
1 b 1 7.0
2 a 2 3.5
3 a 3 3.5
4 b 4 7.0
5 c 5 NaN

最后,对于简单的索引合并,你还可以向join传入一组DataFrame,下一节会介绍更为通用的concat函数,也能实现此功能:

print(left2.join([right2, another]))
   Ohio  Nevada  Missouri  Alabama  New York  Oregon
a 1.0 2.0 NaN NaN 7.0 8.0
c 3.0 4.0 9.0 10.0 9.0 10.0
e 5.0 6.0 13.0 14.0 11.0 12.0
print(left2.join([right2, another], how='outer'))
   Ohio  Nevada  Missouri  Alabama  New York  Oregon
a 1.0 2.0 NaN NaN 7.0 8.0
c 3.0 4.0 9.0 10.0 9.0 10.0
e 5.0 6.0 13.0 14.0 11.0 12.0
b NaN NaN 7.0 8.0 NaN NaN
d NaN NaN 11.0 12.0 NaN NaN
f NaN NaN NaN NaN 16.0 17.0

7、轴向连接

  另一种数据合并运算也被称作连接(concatenation)、绑定(binding)或堆叠(stacking)。Numpy的concatenation函数可以用NumPy数组来做:

arr = np.arange(12).reshape((3, 4))
print(arr)
[[ 0  1  2  3]
[ 4 5 6 7]
[ 8 9 10 11]]
print(np.concatenate([arr, arr], axis=1))
[[ 0  1  2  3  0  1  2  3]
[ 4 5 6 7 4 5 6 7]
[ 8 9 10 11 8 9 10 11]]

对于pandas对象(如Series和DataFrame),带有标签的轴使你能够进一步推广数组的连接运算。具体点说,你还需要考虑以下这些东西:

  • 如果对象在其他轴上的索引不同,我们应该合并这些轴的不同元素还是只使用交集?
  • 连接的数据集是否需要在结果对象中可识别?
  • 连接轴中保存的数据是否需要保留?许多情况下,DataFrame默认的整数标签最好在连接时删掉。

pandas的concat函数提供了一种能够解决这些问题的可靠方式。将给出一些例子来讲解其使用方式。假设有三个没有重叠索引的Series:

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'])
print(pd.concat([s1, s2, s3]))
a    0
b 1
c 2
d 3
e 4
f 5
g 6
dtype: int64

默认情况下,concat是在axis=0上工作的,最终产生一个新的Series。如果传入axis=1,则结果就会变成一个DataFrame:

print(pd.concat([s1, s2, s3], axis=1, sort=True))
     0    1    2
a 0.0 NaN NaN
b 1.0 NaN NaN
c NaN 2.0 NaN
d NaN 3.0 NaN
e NaN 4.0 NaN
f NaN NaN 5.0
g NaN NaN 6.0

这种情况下,另外的轴上没有重叠,从索引的有序并集(外连接)上就可以看出来。传入join='inner'即可得到它们的交集:

s4 = pd.concat([s1, s3])
print(s4)
a    0
b 1
f 5
g 6
dtype: int64
print(pd.concat([s1, s4], axis=1, sort=True))
     0  1
a 0.0 0
b 1.0 1
f NaN 5
g NaN 6
print(pd.concat([s1, s4], axis=1, sort=True, join='inner'))
   0  1
a 0 0
b 1 1

在这个栗子中,f和g标签消失了,是因为使用的是join='inner'选项。

也可以通过join_axes指定要在其他轴上使用的索引:

print(pd.concat([s1, s4], axis=1, join_axes=[['a', 'c', 'b', 'e']]))
    0    1
a 0.0 0.0
c NaN NaN
b 1.0 1.0
e NaN NaN

不过有个问题,参与连接的片段在结果中区分不开。假设你想要在连接轴上创建一个层次化索引。使用keys参数即可达到这个目的:

result = pd.concat([s1, s2, s3], keys=['one', 'two', 'three'])
print(result)
one    a    0
b 1
two c 2
d 3
e 4
three f 5
g 6
dtype: int64
print(result.unstack())
         a    b    c    d    e    f    g
one 0.0 1.0 NaN NaN NaN NaN NaN
two NaN NaN 2.0 3.0 4.0 NaN NaN
three NaN NaN NaN NaN NaN 5.0 6.0

如果沿着axis=1对Series进行合并,则keys就会变成DataFrame的列头:

print(pd.concat([s1, s2, s3], axis=1, keys=['one', 'two', 'three'], sort=False))
   one  two  three
a 0.0 NaN NaN
b 1.0 NaN NaN
c NaN 2.0 NaN
d NaN 3.0 NaN
e NaN 4.0 NaN
f NaN NaN 5.0
g NaN NaN 6.0

同样的逻辑也适用于DataFrame对象:

df1 = pd.DataFrame(np.arange(6).reshape(3, 2), index=['a', 'b', 'c'], columns=['one', 'two'])
df2 = pd.DataFrame(5+np.arange(4).reshape((2, 2)), index=['a', 'c'], columns=['three', 'four'])
print(df1)
print(df2)
   one  two
a 0 1
b 2 3
c 4 5
three four
a 5 6
c 7 8
print(pd.concat([df1, df2], axis=1, keys=['level1', 'level2'], sort=False))
  level1     level2
one two three four
a 0 1 5.0 6.0
b 2 3 NaN NaN
c 4 5 7.0 8.0

如果传入的不是列表而是一个字典,则字典的键就会被当做keys选项的值:

print(pd.concat({'level1': df1, 'level2': df2}, axis=1, sort=False))
  level1     level2
one two three four
a 0 1 5.0 6.0
b 2 3 NaN NaN
c 4 5 7.0 8.0

此外还有两个用于管理层次化索引创建方式的参数。举个栗子,我们可以用names参数命名创建的轴级别:

print(pd.concat([df1, df2], axis=1, keys=['level1', 'level2'], sort=False, names=['upper', 'lower']))
upper level1     level2
lower one two three four
a 0 1 5.0 6.0
b 2 3 NaN NaN
c 4 5 7.0 8.0

最后一个关于DataFrame的问题是,DataFrame的行索引不包含任何相关数据:

df1 = pd.DataFrame(np.random.randn(3, 4), columns=['a', 'b', 'c', 'd'])
df2 = pd.DataFrame(np.random.randn(2, 3), columns=['b', 'd', 'a'])
print(df1)
print(df2)
          a         b         c         d
0 -0.285165 1.850042 -0.313016 0.405468
1 0.248911 -1.143353 1.629733 0.065551
2 1.219122 -0.761709 1.458502 -0.459100
b d a
0 0.186271 -1.150992 1.228888
1 -0.827791 0.302782 -0.939113

在这种情况下,传入ignore_index=True即可:

print(pd.concat([df1, df2], ignore_index=True, sort=False))
          a         b         c         d
0 -0.285165 1.850042 -0.313016 0.405468
1 0.248911 -1.143353 1.629733 0.065551
2 1.219122 -0.761709 1.458502 -0.459100
3 1.228888 0.186271 NaN -1.150992
4 -0.939113 -0.827791 NaN 0.302782

参数对应表:

参数 说明
objs 参与连接的pandas对象的列表或字典。唯一必须的参数
axis 指明连接的轴向,默认为0
join "inner"、"outer"其中之一,默认为"outer"。指明其他轴向上的索引是按交集(inner)还是并集(outer)进行合并
join_axes 指明用于其他n-1条轴的索引,不执行并集/交集运算
keys 与连接对象有关的值,用于形成连接轴向上的层次化索引。可以是任意值的列表或数组、元组数组、数组列表
levels 指定用作层次化索引各级别上的索引,如果设置了keys的话
names 用于创建分层级别的名称,如果设置了keys和levels的话
verify_integrity 检查结果对象轴上的重复情况,如果发现则引发异常。默认(False)允许重复
ignore_index 不保留连接轴上的索引,产生一组新索引range(total_length)

8、合并重叠数据

  还有一种数据组合问题不能用简单的合并(merge)或连接(concatenation)运算来处理。比如说,你可能有索引全部或部分重叠的两个数据集。举个栗子,我们使用NumPy的where函数,它表示一种等价于面向数组的if-else:

a = pd.Series([np.nan, 2.5, np.nan, 3.5, 4.5, np.nan], index=['f', 'e', 'd', 'c', 'b', 'a'])
b = pd.Series(np.arange(len(a), dtype=np.float64), index=['f', 'e', 'd', 'c', 'b', 'a'])
b[-1] = np.nan
print(a)
print(b)
f    NaN
e 2.5
d NaN
c 3.5
b 4.5
a NaN
dtype: float64
f 0.0
e 1.0
d 2.0
c 3.0
b 4.0
a NaN
dtype: float64
print(np.where(pd.isnull(a), b, a))
[0.  2.5 2.  3.5 4.5 nan]

这里需要说明的一个函数是np.where(condition, a, b)意思是当调教成立的时候取值为a,否则取值为b!

Series有一个combine_first方法,实现的也是一样的功能,还带有pandas的数据对齐:

print(b[:-2].combine_first(a[2:]))
a    NaN
b 4.5
c 3.0
d 2.0
e 1.0
f 0.0
dtype: float64

对于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)
print(df2)
     a    b   c
0 1.0 NaN 2
1 NaN 2.0 6
2 5.0 NaN 10
3 NaN 6.0 14
a b
0 5.0 NaN
1 4.0 3.0
2 NaN 4.0
3 3.0 6.0
4 7.0 8.0
print(df1.combine_first(df2))
     a    b     c
0 1.0 NaN 2.0
1 4.0 2.0 6.0
2 5.0 4.0 10.0
3 3.0 6.0 14.0
4 7.0 8.0 NaN

9、重塑层次化索引

  有许多用于重新排列表格型数据的基础运算。这些函数也称作为重塑(reshape)或轴向旋转(pivot)运算。

  层次化索引为DataFrame数据的重排任务提供了一种具有良好一致性的方式。主要功能有二:

  • stack:将数据的列“旋转”为行;
  • unstack:将数据的行“旋转”为列。

如下将通过一系列的范例来讲解这些操作。接下来看一个简单的DataFrame,其中的行列索引均为字符串数组:

data = pd.DataFrame(np.arange(6).reshape(2, 3), index=pd.Index(['Ohio', 'Colorado'], name='state'), columns=pd.Index(['one', 'two', 'three'], name='number'))
print(data)
number    one  two  three
state
Ohio 0 1 2
Colorado 3 4 5

对该数据使用stack方法即可将列转换为行,得到一个Series:

result = data.stack()
print(result)
state     number
Ohio one 0
two 1
three 2
Colorado one 3
two 4
three 5
dtype: int32

对于一个层次化索引的Series,你可以用unstack将其重排为一个DataFrame:

print(result.unstack())
number    one  two  three
state
Ohio 0 1 2
Colorado 3 4 5

默认情况下,unstack操作的是最内层(stack也是如此)。传入分层级别的编号或名称即可对其它级别进行unstack操作:

print(result.unstack(0))
state   Ohio  Colorado
number
one 0 3
two 1 4
three 2 5
print(result.unstack('state'))
state   Ohio  Colorado
number
one 0 3
two 1 4
three 2 5

如果不是所有的级别值都能在各分组中找到的话,则unstack操作可能会引入缺失数据:

s1 = pd.Series([0, 1, 2, 3], index=['a', 'b', 'c', 'd'])
s2 = pd.Series([4, 5, 6], index=['c', 'd', 'e'])
data2 = pd.concat([s1, s2], keys=['one', 'two'])
print(data2)
one  a    0
b 1
c 2
d 3
two c 4
d 5
e 6
dtype: int64
print(data2.unstack())
       a    b    c    d    e
one 0.0 1.0 2.0 3.0 NaN
two NaN NaN 4.0 5.0 6.0

stack默认会滤除缺失数据,因此该运算是可逆的:

print(data2.unstack().stack())
one  a    0.0
b 1.0
c 2.0
d 3.0
two c 4.0
d 5.0
e 6.0
dtype: float64
print(data2.unstack().stack(dropna=False))
one  a    0.0
b 1.0
c 2.0
d 3.0
e NaN
two a NaN
b NaN
c 4.0
d 5.0
e 6.0
dtype: float64

在对DataFrame进行unstack操作时,作为旋转轴的级别将会成为结果中的最低级别:

df = pd.DataFrame({'left': result, 'right': result + 5}, columns=pd.Index(['left', 'right'], name='side'))
print(df)
side             left  right
state number
Ohio one 0 5
two 1 6
three 2 7
Colorado one 3 8
two 4 9
three 5 10
print(df.unstack())
side     left           right
number one two three one two three
state
Ohio 0 1 2 5 6 7
Colorado 3 4 5 8 9 10

当调用stack,我们可以指明轴的名字:

print(df.unstack('state').stack('side'))
state         Colorado  Ohio
number side
one left 3 0
right 8 5
two left 4 1
right 9 6
three left 5 2
right 10 7

10、将“宽格式”旋转为“长格式”

  旋转DataFrame的逆运算是pandas.melt。它不是将一列转换到多个新的DataFrame,而是合并多个列成为一个,产生一个比输入长的DataFrame。看一个栗子:

df = pd.DataFrame({'key': ['foo', 'bar', 'baz'], 'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})
print(df)
   key  A  B  C
0 foo 1 4 7
1 bar 2 5 8
2 baz 3 6 9

key列可能是分组指标,其它的列是数据值。当使用pandas.melt,我们必须指明哪些列是分组指标。下面使用key作为唯一的分组指标:

print(pd.melt(df, ['key']))
   key variable  value
0 foo A 1
1 bar A 2
2 baz A 3
3 foo B 4
4 bar B 5
5 baz B 6
6 foo C 7
7 bar C 8
8 baz C 9

使用pivot,可以重塑回原来的样子:

reshaped = melted.pivot('key', 'variable', 'value')
print(reshaped)
variable  A  B  C
key
bar 2 5 8
baz 3 6 9
foo 1 4 7

因为pivot的结果从列创建了一个索引,用作行的标签,我们可以使用reset_index将数据移回列:

print(reshaped.reset_index())
variable  key  A  B  C
0 bar 2 5 8
1 baz 3 6 9
2 foo 1 4 7

你还可以指定列的子集,作为值的列:

print(pd.melt(df, id_vars=['key'], value_vars=['A', 'B']))
   key variable  value
0 foo A 1
1 bar A 2
2 baz A 3
3 foo B 4
4 bar B 5
5 baz B 6

pandas.melt也可以不用分组指标:

print(pd.melt(df, value_vars=['A', 'B', 'C']))
  variable  value
0 A 1
1 A 2
2 A 3
3 B 4
4 B 5
5 B 6
6 C 7
7 C 8
8 C 9
上一篇:(转)Linux下Oracle启动、建立表空间、用户、授权、数据库导入导出


下一篇:C# 网上收集的一些所谓的开源项目