基于 Python 和 Pandas 的数据分析(6) --- Joining and Merging

这一节我们将看一下如何通过 join 和 merge 来合并 dataframe.

import pandas as pd

df1 = pd.DataFrame({'HPI':[80,85,88,85],
                    'Int_rate':[2, 3, 2, 2],
                    'US_GDP_Thousands':[50, 55, 65, 55]},
                   index = [2001, 2002, 2003, 2004])

df2 = pd.DataFrame({'HPI':[80,85,88,85],
                    'Int_rate':[2, 3, 2, 2],
                    'US_GDP_Thousands':[50, 55, 65, 55]},
                   index = [2005, 2006, 2007, 2008])

df3 = pd.DataFrame({'HPI':[80,85,88,85],
                    'Unemployment':[7, 8, 9, 6],
                    'Low_tier_HPI':[50, 52, 50, 53]},
                   index = [2001, 2002, 2003, 2004])

还是用上一节的例子, 但是我在 df3 的列上做了一点改动, 先来看下 merge 的用法:

print(pd.merge(df1,df3, on='HPI'))

输出:

    HPI  Int_rate  US_GDP_Thousands  Unemployment  Low_tier_HPI
0   80         2                50             7            50
1   85         3                55             8            52
2   85         3                55             6            53
3   85         2                55             8            52
4   85         2                55             6            53
5   88         2                65             9            50

这个例子中, 是以列 "HPI" 为基准做的合并, merge 的时候, 会自动忽略索引列. 当然, 我们也可以使用多个列做基准如下:

print(pd.merge(df1,df2, on=['HPI','Int_rate']))

输出:

   HPI  Int_rate  US_GDP_Thousands_x  US_GDP_Thousands_y
0   80         2                  50                  50
1   85         3                  55                  55
2   88         2                  65                  65
3   85         2                  55                  55

大家可能也注意到了这里有两个版本的 "US_GDP_Thousands", 并用 "x" 和 "y" 加以区分. 这是因为我们没有共享这个列, 所以两个列都要保留. 这也是为什么我之前说 Pandas 可以与 mysql 很好地合作.

通常情况下, 我们应该尽可能保持数据库的轻量化, 这样执行查询的速度才能更快.

加入你要建一个网站, 你需要保存用户的相关信息, 比如用户名, 密码, 邮箱, 注册时间等基本信息. 另外, 你可能还需要保存用户设置, 用户发的帖子等其他的信息. 随着网站功能的完善, 可能需要保存的信息也会越来越多, 你当然可以建一个很大的信息涵盖所有信息的表, 但是那会导致你查询任意某个信息都会很慢, 所以更好的做法是分成几个小表, 分块保存信息. 然后你还可以像下面这样通过 merge 把两个表连起来, 然后再重新定义索引:

df4 = pd.merge(df1,df3, on='HPI')
df4.set_index('HPI', inplace=True)
print(df4)

输出:

      Int_rate  US_GDP_Thousands  Unemployment  Low_tier_HPI
HPI
80          2                50             7            50
85          3                55             8            52
85          3                55             6            53
85          2                55             8            52
85          2                55             6            53
88          2                65             9            50

那么, 如果在合并之前, HPI 就是索引, 在这种情况下, 我们就可以用 join:

df1.set_index('HPI', inplace=True)
df3.set_index('HPI', inplace=True)

joined = df1.join(df3)
print(joined)

输出:

     Int_rate  US_GDP_Thousands  Unemployment  Low_tier_HPI
HPI
80          2                50             7            50
85          3                55             8            52
85          3                55             6            53
85          2                55             8            52
85          2                55             6            53
88          2                65             9            50

从上面两个例子可以看出, join 和 merge 就是在设置索引上有些许不同. 我们现在改下初始数据结构, 进一步分析:

df1 = pd.DataFrame({
                    'Int_rate':[2, 3, 2, 2],
                    'US_GDP_Thousands':[50, 55, 65, 55],
                    'Year':[2001, 2002, 2003, 2004]
                    })

df3 = pd.DataFrame({
                    'Unemployment':[7, 8, 9, 6],
                    'Low_tier_HPI':[50, 52, 50, 53],
                    'Year':[2001, 2003, 2004, 2005]})

这里我们把两个 dataframe 都设置了 "Year" 列, 只是具体的年份有些不同, 那么这二者合并会怎样呢?

merged = pd.merge(df1,df3, on='Year')
print(merged)

输出:

   Year  Int_rate  US_GDP_Thousands  Unemployment  Low_tier_HPI
0  2001         2                50             7            50
1  2003         2                65             8            52
2  2004         2                55             9            50

调整一下索引, 是它看起来更清楚:

merged = pd.merge(df1,df3, on='Year')
merged.set_index('Year', inplace=True)
print(merged)

输出:

      Int_rate  US_GDP_Thousands  Unemployment  Low_tier_HPI
Year
2001         2                50             7            50
2003         2                65             8            52
2004         2                55             9            50

相信大家已经看到了, 2005和2002两行数据都没有了. merge 默认取两个数据的并集来做合并. 这就引出了另一个参数 "how", 通过对这个参数的定义, 可以选择以什么样的方式合并数据. 参数值有以下四种:

Left - 以左边的索引值为准.
Right - 以右边的索引值为准.
Outer - 取并集.
Inner - 取交集.

merged = pd.merge(df1,df3, on='Year', how='left')
merged.set_index('Year', inplace=True)
print(merged)

输出:

      Int_rate  US_GDP_Thousands  Unemployment  Low_tier_HPI
Year
2001         2                50           7.0          50.0
2002         3                55           NaN           NaN
2003         2                65           8.0          52.0
2004         2                55           9.0          50.0

以上就是左对齐的输出效果, 下面看下右对齐:

merged = pd.merge(df1,df3, on='Year', how='right')
merged.set_index('Year', inplace=True)
print(merged)

输出:

      Int_rate  US_GDP_Thousands  Unemployment  Low_tier_HPI
Year
2001       2.0              50.0             7            50
2003       2.0              65.0             8            52
2004       2.0              55.0             9            50
2005       NaN               NaN             6            53

再来看下 outer 的效果:

merged = pd.merge(df1,df3, on='Year', how='outer')
merged.set_index('Year', inplace=True)
print(merged)

输出:

      Int_rate  US_GDP_Thousands  Unemployment  Low_tier_HPI
Year
2001       2.0              50.0           7.0          50.0
2002       3.0              55.0           NaN           NaN
2003       2.0              65.0           8.0          52.0
2004       2.0              55.0           9.0          50.0
2005       NaN               NaN           6.0          53.0

再来看下 inner 的合并效果:

merged = pd.merge(df1,df3, on='Year', how='inner')
merged.set_index('Year', inplace=True)
print(merged)

输出:

      Int_rate  US_GDP_Thousands  Unemployment  Low_tier_HPI
Year
2001         2                50             7            50
2003         2                65             8            52
2004         2                55             9            50

以 inner 的方式合并, 也是 merge 默认的合并方式.

现在我们来看下 join 的合并效果, 基本上跟 merge 是一样的:

df1.set_index('Year', inplace=True)
df3.set_index('Year', inplace=True)
joined = df1.join(df3, how="outer")
print(joined)

输出:

      Int_rate  US_GDP_Thousands  Unemployment  Low_tier_HPI
Year
2001       2.0              50.0           7.0          50.0
2002       3.0              55.0           NaN           NaN
2003       2.0              65.0           8.0          52.0
2004       2.0              55.0           9.0          50.0
2005       NaN               NaN           6.0          53.0

目前为止, 我们已经对合并数据有了基本的了解, 下一节, 我们将继续在不动产投资的例子中应用这些知识.

总结一下, 当你不需要原索引的时候, 就可以用 merge 来合并, 当你需要用原索引的时候, 就可以用 join. 而 concatenation 和 append 主要用于你要增加数据行数的时候.

后面会持续更新, 有任何问题或者错误, 欢迎留言, 希望和大家交流学习.