简介

Pandas提供了很多合并Series和Dataframe的强大的功能，通过这些功能可以方便的进行数据分析。本文将会详细讲解如何使用Pandas来合并Series和Dataframe。

使用concat

concat是最常用的合并DF的方法，先看下concat的定义：

pd.concat(objs, axis=0, join='outer', ignore_index=False, keys=None,

          levels=None, names=None, verify_integrity=False, copy=True)

看一下我们经常会用到的几个参数：

objs是Series或者Series的序列或者映射。

axis指定连接的轴。

join : {‘inner’, ‘outer’}, 连接方式，怎么处理其他轴的index，outer表示合并，inner表示交集。

ignore_index：忽略原本的index值，使用0,1,… n-1来代替。

copy：是否进行拷贝。

keys：指定最外层的多层次结构的index。

我们先定义几个DF，然后看一下怎么使用concat把这几个DF连接起来：

In [1]: df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],

   ...:                     'B': ['B0', 'B1', 'B2', 'B3'],

   ...:                     'C': ['C0', 'C1', 'C2', 'C3'],

   ...:                     'D': ['D0', 'D1', 'D2', 'D3']},

   ...:                    index=[0, 1, 2, 3])

   ...: 

In [2]: df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],

   ...:                     'B': ['B4', 'B5', 'B6', 'B7'],

   ...:                     'C': ['C4', 'C5', 'C6', 'C7'],

   ...:                     'D': ['D4', 'D5', 'D6', 'D7']},

   ...:                    index=[4, 5, 6, 7])

   ...: 

In [3]: df3 = pd.DataFrame({'A': ['A8', 'A9', 'A10', 'A11'],

   ...:                     'B': ['B8', 'B9', 'B10', 'B11'],

   ...:                     'C': ['C8', 'C9', 'C10', 'C11'],

   ...:                     'D': ['D8', 'D9', 'D10', 'D11']},

   ...:                    index=[8, 9, 10, 11])

   ...: 

In [4]: frames = [df1, df2, df3]

In [5]: result = pd.concat(frames)

df1,df2,df3定义了同样的列名和不同的index，然后将他们放在frames中构成了一个DF的list，将其作为参数传入concat就可以进行DF的合并。

举个多层级的例子：

In [6]: result = pd.concat(frames, keys=['x', 'y', 'z'])

使用keys可以指定frames中不同frames的key。

使用的时候，我们可以通过选择外部的key来返回特定的frame：

In [7]: result.loc['y']

Out[7]:

    A   B   C   D

4  A4  B4  C4  D4

5  A5  B5  C5  D5

6  A6  B6  C6  D6

7  A7  B7  C7  D7

上面的例子连接的轴默认是0，也就是按行来进行连接，下面我们来看一个例子按列来进行连接，如果要按列来连接，可以指定axis=1：

In [8]: df4 = pd.DataFrame({'B': ['B2', 'B3', 'B6', 'B7'],

   ...:                     'D': ['D2', 'D3', 'D6', 'D7'],

   ...:                     'F': ['F2', 'F3', 'F6', 'F7']},

   ...:                    index=[2, 3, 6, 7])

   ...: 

In [9]: result = pd.concat([df1, df4], axis=1, sort=False)

默认的 join='outer'，合并之后index不存在的地方会补全为NaN。

下面看一个join='inner'的情况：

In [10]: result = pd.concat([df1, df4], axis=1, join='inner')

join='inner' 只会选择index相同的进行展示。

如果合并之后，我们只想保存原来frame的index相关的数据，那么可以使用reindex：

In [11]: result = pd.concat([df1, df4], axis=1).reindex(df1.index)

或者这样：

In [12]: pd.concat([df1, df4.reindex(df1.index)], axis=1)

Out[12]:

    A   B   C   D    B    D    F

0  A0  B0  C0  D0  NaN  NaN  NaN

1  A1  B1  C1  D1  NaN  NaN  NaN

2  A2  B2  C2  D2   B2   D2   F2

3  A3  B3  C3  D3   B3   D3   F3

看下结果：

可以合并DF和Series：

In [18]: s1 = pd.Series(['X0', 'X1', 'X2', 'X3'], name='X')

In [19]: result = pd.concat([df1, s1], axis=1)

如果是多个Series，使用concat可以指定列名：

In [23]: s3 = pd.Series([0, 1, 2, 3], name='foo')

In [24]: s4 = pd.Series([0, 1, 2, 3])

In [25]: s5 = pd.Series([0, 1, 4, 5])

In [27]: pd.concat([s3, s4, s5], axis=1, keys=['red', 'blue', 'yellow'])

Out[27]:

   red  blue  yellow

0    0     0       0

1    1     1       1

2    2     2       4

3    3     3       5

使用append

append可以看做是concat的简化版本，它沿着axis=0 进行concat：

In [13]: result = df1.append(df2)

如果append的两个 DF的列是不一样的会自动补全NaN：

In [14]: result = df1.append(df4, sort=False)

如果设置ignore_index=True，可以忽略原来的index，并重写分配index：

In [17]: result = df1.append(df4, ignore_index=True, sort=False)

向DF append一个Series：

In [35]: s2 = pd.Series(['X0', 'X1', 'X2', 'X3'], index=['A', 'B', 'C', 'D'])

In [36]: result = df1.append(s2, ignore_index=True)

使用merge

和DF最类似的就是数据库的表格，可以使用merge来进行类似数据库操作的DF合并操作。

先看下merge的定义：

pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,

         left_index=False, right_index=False, sort=True,

         suffixes=('_x', '_y'), copy=True, indicator=False,

         validate=None)

Left, right是要合并的两个DF 或者 Series。

on代表的是join的列或者index名。

left_on:左连接

right_on：右连接

left_index: 连接之后，选择使用左边的index或者column。

right_index:连接之后，选择使用右边的index或者column。

how：连接的方式，'left', 'right', 'outer', 'inner'. 默认 inner.

sort: 是否排序。

suffixes: 处理重复的列。

copy: 是否拷贝数据

先看一个简单merge的例子：

In [39]: left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],

   ....:                      'A': ['A0', 'A1', 'A2', 'A3'],

   ....:                      'B': ['B0', 'B1', 'B2', 'B3']})

   ....: 

In [40]: right = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],

   ....:                       'C': ['C0', 'C1', 'C2', 'C3'],

   ....:                       'D': ['D0', 'D1', 'D2', 'D3']})

   ....: 

In [41]: result = pd.merge(left, right, on='key')

上面两个DF通过key来进行连接。

再看一个多个key连接的例子：

In [42]: left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],

   ....:                      'key2': ['K0', 'K1', 'K0', 'K1'],

   ....:                      'A': ['A0', 'A1', 'A2', 'A3'],

   ....:                      'B': ['B0', 'B1', 'B2', 'B3']})

   ....: 

In [43]: right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],

   ....:                       'key2': ['K0', 'K0', 'K0', 'K0'],

   ....:                       'C': ['C0', 'C1', 'C2', 'C3'],

   ....:                       'D': ['D0', 'D1', 'D2', 'D3']})

   ....: 

In [44]: result = pd.merge(left, right, on=['key1', 'key2'])

How 可以指定merge方式，和数据库一样，可以指定是内连接，外连接等：

合并方法	SQL 方法
`left`	`LEFT OUTER JOIN`
`right`	`RIGHT OUTER JOIN`
`outer`	`FULL OUTER JOIN`
`inner`	`INNER JOIN`

In [45]: result = pd.merge(left, right, how='left', on=['key1', 'key2'])

指定indicator=True ，可以表示具体行的连接方式：

In [60]: df1 = pd.DataFrame({'col1': [0, 1], 'col_left': ['a', 'b']})

In [61]: df2 = pd.DataFrame({'col1': [1, 2, 2], 'col_right': [2, 2, 2]})

In [62]: pd.merge(df1, df2, on='col1', how='outer', indicator=True)

Out[62]:

   col1 col_left  col_right      _merge

0     0        a        NaN   left_only

1     1        b        2.0        both

2     2      NaN        2.0  right_only

3     2      NaN        2.0  right_only

如果传入字符串给indicator，会重命名indicator这一列的名字：

In [63]: pd.merge(df1, df2, on='col1', how='outer', indicator='indicator_column')

Out[63]:

   col1 col_left  col_right indicator_column

0     0        a        NaN        left_only

1     1        b        2.0             both

2     2      NaN        2.0       right_only

3     2      NaN        2.0       right_only

多个index进行合并：

In [112]: leftindex = pd.MultiIndex.from_tuples([('K0', 'X0'), ('K0', 'X1'),

   .....:                                        ('K1', 'X2')],

   .....:                                       names=['key', 'X'])

   .....: 

In [113]: left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],

   .....:                      'B': ['B0', 'B1', 'B2']},

   .....:                     index=leftindex)

   .....: 

In [114]: rightindex = pd.MultiIndex.from_tuples([('K0', 'Y0'), ('K1', 'Y1'),

   .....:                                         ('K2', 'Y2'), ('K2', 'Y3')],

   .....:                                        names=['key', 'Y'])

   .....: 

In [115]: right = pd.DataFrame({'C': ['C0', 'C1', 'C2', 'C3'],

   .....:                       'D': ['D0', 'D1', 'D2', 'D3']},

   .....:                      index=rightindex)

   .....: 

In [116]: result = pd.merge(left.reset_index(), right.reset_index(),

   .....:                   on=['key'], how='inner').set_index(['key', 'X', 'Y'])

支持多个列的合并：

In [117]: left_index = pd.Index(['K0', 'K0', 'K1', 'K2'], name='key1')

In [118]: left = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],

   .....:                      'B': ['B0', 'B1', 'B2', 'B3'],

   .....:                      'key2': ['K0', 'K1', 'K0', 'K1']},

   .....:                     index=left_index)

   .....: 

In [119]: right_index = pd.Index(['K0', 'K1', 'K2', 'K2'], name='key1')

In [120]: right = pd.DataFrame({'C': ['C0', 'C1', 'C2', 'C3'],

   .....:                       'D': ['D0', 'D1', 'D2', 'D3'],

   .....:                       'key2': ['K0', 'K0', 'K0', 'K1']},

   .....:                      index=right_index)

   .....: 

In [121]: result = left.merge(right, on=['key1', 'key2'])

使用join

join将两个不同index的DF合并成一个。可以看做是merge的简写。

In [84]: left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],

   ....:                      'B': ['B0', 'B1', 'B2']},

   ....:                     index=['K0', 'K1', 'K2'])

   ....: 

In [85]: right = pd.DataFrame({'C': ['C0', 'C2', 'C3'],

   ....:                       'D': ['D0', 'D2', 'D3']},

   ....:                      index=['K0', 'K2', 'K3'])

   ....: 

In [86]: result = left.join(right)

可以指定how来指定连接方式：

In [87]: result = left.join(right, how='outer')

默认join是按index来进行连接。

还可以按照列来进行连接：

In [91]: left = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],

   ....:                      'B': ['B0', 'B1', 'B2', 'B3'],

   ....:                      'key': ['K0', 'K1', 'K0', 'K1']})

   ....: 

In [92]: right = pd.DataFrame({'C': ['C0', 'C1'],

   ....:                       'D': ['D0', 'D1']},

   ....:                      index=['K0', 'K1'])

   ....: 

In [93]: result = left.join(right, on='key')

单个index和多个index进行join：

In [100]: left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],

   .....:                      'B': ['B0', 'B1', 'B2']},

   .....:                      index=pd.Index(['K0', 'K1', 'K2'], name='key'))

   .....: 

In [101]: index = pd.MultiIndex.from_tuples([('K0', 'Y0'), ('K1', 'Y1'),

   .....:                                   ('K2', 'Y2'), ('K2', 'Y3')],

   .....:                                    names=['key', 'Y'])

   .....: 

In [102]: right = pd.DataFrame({'C': ['C0', 'C1', 'C2', 'C3'],

   .....:                       'D': ['D0', 'D1', 'D2', 'D3']},

   .....:                       index=index)

   .....: 

In [103]: result = left.join(right, how='inner')

列名重复的情况：

In [122]: left = pd.DataFrame({'k': ['K0', 'K1', 'K2'], 'v': [1, 2, 3]})

In [123]: right = pd.DataFrame({'k': ['K0', 'K0', 'K3'], 'v': [4, 5, 6]})

In [124]: result = pd.merge(left, right, on='k')

可以自定义重复列名的命名规则：

In [125]: result = pd.merge(left, right, on='k', suffixes=('_l', '_r'))

覆盖数据

有时候我们需要使用DF2的数据来填充DF1的数据，这时候可以使用combine_first：

In [131]: df1 = pd.DataFrame([[np.nan, 3., 5.], [-4.6, np.nan, np.nan],

   .....:                    [np.nan, 7., np.nan]])

   .....: 

In [132]: df2 = pd.DataFrame([[-42.6, np.nan, -8.2], [-5., 1.6, 4]],

   .....:                    index=[1, 2])

   .....:

In [133]: result = df1.combine_first(df2)

或者使用update：

In [134]: df1.update(df2)

本文已收录于 http://www.flydean.com/04-python-pandas-merge/

最通俗的解读，最深刻的干货，最简洁的教程，众多你不知道的小技巧等你来发现！

欢迎关注我的公众号:「程序那些事」,懂技术，更懂你！

Pandas高级教程之:Dataframe的合并的更多相关文章

Pandas高级教程之:GroupBy用法
Pandas高级教程之:GroupBy用法目录简介分割数据多index get_group dropna groups属性 index的层级 group的遍历聚合操作通用聚合方法同时使用 ...
Pandas高级教程之:处理text数据
目录简介创建text的DF String 的方法 columns的String操作分割和替换String String的连接使用 .str来index extract extractall c ...
Pandas高级教程之:处理缺失数据
目录简介 NaN的例子整数类型的缺失值 Datetimes 类型的缺失值 None 和 np.nan 的转换缺失值的计算使用fillna填充NaN数据使用dropna删除包含NA的数据插值 ...
Pandas高级教程之:category数据类型
目录简介创建category 使用Series创建使用DF创建创建控制转换为原始类型 categories的操作获取category的属性重命名categories 使用add_cate ...
Pandas高级教程之:plot画图详解
目录简介基础画图其他图像 bar stacked bar barh Histograms box Area Scatter Hexagonal bin Pie 在画图中处理NaN数据其他作图工 ...
Pandas高级教程之:统计方法
目录简介变动百分百 Covariance协方差 Correlation相关系数 rank等级简介数据分析中经常会用到很多统计类的方法,本文将会介绍Pandas中使用到的统计方法. 变动百分百 ...
Pandas高级教程之:window操作
目录简介滚动窗口 Center window Weighted window 加权窗口扩展窗口指数加权窗口简介在数据统计中,经常需要进行一些范围操作,这些范围我们可以称之为一个window ...
Pandas高级教程之:稀疏数据结构
目录简介 Spare data的例子 SparseArray SparseDtype Sparse的属性 Sparse的计算 SparseSeries 和 SparseDataFrame 简介如果 ...
Pandas高级教程之:自定义选项
目录简介常用选项 get/set 选项经常使用的选项最大展示行数超出数据展示最大列的宽度显示精度零转换的门槛列头的对齐方向简介 pandas有一个option系统可以控制panda ...

随机推荐

LA3027简单带权并查集
题意: 有n个点,一开始大家都是独立的点,然后给出一些关系,a,b表示a是b的父亲节点,距离是abs(a-b)%1000,然后有一些询问,每次询问一个节点a到父亲节点的距离是多少? 思路: ...
Day001 Typora Markdown语法学习
# Markdown语法 ## 标题 ### 三级标题 #### 四级标题注:最多支持到六级标题 ## 字体 **hello,world!** *hello,world!* ***hello,wor ...
【报错】No converter found for return value of type: class java.util.HashMap
ssm开发碰到的错误 @ResponseBody的作用是是将java对象转为json格式的数据 @ResponseBody注解标识该方法的返回值直接写回到HTTP响应体中去(而不会被被放置到Model ...
redis 未授权访问（写公钥、写计划任务）
写公钥 ssh-keygen -t rsa # 生成key (echo -e "\n\n"; cat id_rsa.pub; echo -e "\n\n") & ...
使用BeanUtils.copyProperties踩坑经历
1. 原始转换提起对象转换,每个程序员都不陌生,比如项目中经常涉及到的DO.DTO.VO之间的转换,举个例子,假设现在有个OrderDTO,定义如下所示: public class OrderDTO ...
[Java] 静态代理动态代理
原理静态代理=代理模式动态代理=代理模式+反射代理模式可以在不修改被代理对象的基础上,通过扩展代理类,进行一些功能的附加与增强代理类和被代理类应该共同实现一个接口,或者是共同继承某个类静态代 ...
解决nohup: 忽略输入并把输出追加到"nohup.out"或者nohup: 忽略输入重定向错误到标准输出端
nohup启动脚本的时候,没有指定输出路径,默认使用当前目录的nohup.out 例如下面这句就是默认使用nohup.out作为输出文件: nohup script.sh & 改成下面的,则/ ...
KEIL中查看程序存储空间的大小
Program Size: Code=86496 RO-data=9064 RW-data=1452 ZI-data=16116 Code是代码占用的空间,RO-data是 Read Only 只读常 ...
brk 和 sbrk 区别
转自:https://www.cnblogs.com/chengxuyuancc/p/3566710.html brk和sbrk的定义,在man手册中定义了这两个函数: 1 #include < ...
Day_04_xml解析
xml解析:操作xml文档,将文档中的数据读取到内存中操作xml文档的方式有两种: 1.解析(读取):将文档中的数据读取到内存中 2.写入:将内存中的数据保存到xml文档中(后期用的并不多) 解析x ...

Pandas高级教程之:Dataframe的合并

简介