文章目录
一、关系型连接
1. 连接的基本概念
对DataFrame或命名的Series对象，按照键连接，和数据库的连接基本一致一样，同样也有左连和右连。重复数据按照笛卡尔积进行连接。
2. 值连接 merge
上面说的按照键连接也是一种值连接，除了按照一列值进行连接外还能按照多列值的组合进行连接。使用merge实现。
看下pandas文档里怎么说的
DataFrame.merge(right, how=‘inner’, on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=(’_x’, ‘_y’), copy=True, indicator=False, validate=None)
- 其中DataFrame和right分别对应上述的表一和表二，连接的必须是dataframe或命名Series.
- how表示连接方式，有{‘left’, ‘right’, ‘outer’, ‘inner’, ‘cross’}这几种, 默认‘inner’即内联。
left左连，right右连上面已经说明，即以哪个表为主。
inner内连表示取两个表对应属性的交集，outer取并集。
cross代表取两个表对应键的笛卡尔积，保留左表的顺序。 - on：要加入的列或列构成的list。必须在两个DataFrame中都可以找到它们。如果on为None且未在索引上合并，则默认为两个DataFrame中列的交集。
df1 = pd.DataFrame({'Name':['San Zhang','Si Li'],
'Age':[20,30]})
df2 = pd.DataFrame({'Name':['Si Li','Wu Wang'],
'Gender':['F','M']})
print(df1.merge(df2, on='Name', how='left').to_markdown())
表一
| Name | Age | |
|---|---|---|
| 0 | San Zhang | 20 |
| 1 | Si Li | 30 |
表二
| Name | Gender | |
|---|---|---|
| 0 | Si Li | F |
| 1 | Wu Wang | M |
表一和表二按照姓名进行左连之后
| Name | Age | Gender | |
|---|---|---|---|
| 0 | San Zhang | 20 | nan |
| 1 | Si Li | 30 | F |
所谓左连右连，即连接的时候键按照哪个表为主，例子中表一表二进行左连即表一为主，按表一的所有姓名去对应表二中的姓名进行连接，并把表二中对应的其他属性（gender性别）附上。右连同理。
4. left_on和right_on 指明左右连接的列或索引，适用于两个表中想要连接的列不具备相同的列名的时候。可以为列名或者list。
- left_index和right_index和上面一样是为了连接不同的索引相同但是索引名称不同的时候指定左右索引名字。
- sort是否对结果进行排序，默认不排序，即按照how中的结果顺序。这里试了下如果sort=True是对连接的那列(或多列)按照字母表顺序进行排序
- suffixes 后缀，当合并后其他属性值一样，用于区分，如果不指定则默认加上_x 和 _y。
注意使用后缀的前提当前合并的列/索引的名称一样
比如下面合并张三的语文和数学成绩，这俩成绩在两个老师的记分册中都叫得分，统计张三的所有成绩时，为了区别我们给他们分别加上对应的学科名称后缀，语文第一次挂科了进行了补考所以有两次成绩，也加上后缀区别。
df1 = pd.DataFrame({'Name':['San Zhang'],'Grade':[50]})
df2 = pd.DataFrame({'Name':['San Zhang'],'Grade':[80]})
df3 = pd.DataFrame({'Name':['San Zhang'],'Grade_Chinese':[90]})
res1=df1.merge(df2, on='Name', how='left', suffixes=['_Chinese','_Math'])
res1.merge(df3, on='Name', how='left', suffixes=['_1','_2'])
| Name | Grade_Chinese_1 | Grade_Math | Grade_Chinese_2 | |
|---|---|---|---|---|
| 0 | San Zhang | 50 | 80 | 90 |
- validate（可选）检查对应模式，检查的是当前列属性是否是A表和B表一对一（“one_to_one” or “1:1”）、一对多（“one_to_many” or “1:m”）、多对一（“many_to_one” or “m:1”）或者多对多 （“many_to_many”）的关系。
测试：
这部份测试没有生效，不返回True或False，开始以为是pandas版本低没有升级的原因，后面升级成最1.1.0版本依旧如此。经过和群里小伙伴讨论后明白了，当检查不报错时表示通过，不通过会报错。之前我比较的是多列作为连接条件，情况很多，下面单独说明。
检查单列情况时，可以正确检查出。
检查多列是都都满足时，结果不对，比如下面Name很明显时多对多关系，但是这里1：m没有报错。所以validate不适用于多列的检查。
还有一点需要说明
事实上validate的’‘1:m’'中的’1’是强约束 , 'm’是弱约束
'1’限制on选中的列必须是unique的值
'm’则不限制 , 既可以unique也可以非unique
因此 , validate=‘m:m’ 就可以全员通过和没设置一样 , 只有’1’有限制效果
练一练
上面以多列为键的例子中，错误写法显然是一种多对多连接，而正确写法是一对一连接，请修改原表，使得以多列为键的正确写法能够通过 validate=‘1:m’ 的检验，但不能通过 validate=‘m:1’ 的检验。
df1 = pd.DataFrame({'Name':['San Zhang', 'Si Li'],
'Age':[20, 21],
'Class':['one', 'two']})
df2 = pd.DataFrame({'Name':['San Zhang', 'San Zhang'],
'Gender':['F', 'M'],
'Class':['two', 'one']})
df1.merge(df2, on='Name', how='left',validate='m:1')
将表1中重复的名字张三改为李四，这样表一姓名都为唯一，表二有两个张三，满足姓名1：m，不满足m:1，符合条件。
3. 索引连接
所谓索引连接，就是把索引当作键，因此这和值连接本质上没有区别， pandas 中利用 join 函数来处理索引连接，它的参数选择要少于 merge ，除了必须的 on 和 how 之外，可以对重复的列指定左右后缀 lsuffix 和 rsuffix 。其中， on 参数指索引名，单层索引时省略参数表示按照当前索引连接。
疑惑：Merge也可以通过索引进行连接，那么Merge和Join两个连接的有区别吗，下面实践了一下。
分别通过Merge和Join得到结果：
可以看到，结果完全一致，通过和群里小伙伴交流，我知道了merge包含了join操作，支持两个df间行方向或列方向的拼接操作，默认列拼接，取交集，而join只是简化了merge的行拼接的操作。
二、方向连接
1. concat
前面的是细致的连接，但有时候用户只需要两个表或者多个表按照纵向或者横向拼接，为这种需求， pandas 中提供了 concat 函数来实现。
在 concat 中，最常用的有三个参数，它们是 axis, join, keys ，分别表示拼接方向，连接形式，以及在新表中指示来自于哪一张旧表的名字。这里需要特别注意， join 和 keys 与之前提到的 join 函数和键的概念没有任何关系。
在默认状态下的 axis=0 ，表示纵向拼接多个表，常常用于多个样本的拼接；而 axis=1 表示横向拼接多个表，常用于多个字段或特征的拼接。
纵向拼接：
df1 = pd.DataFrame({'Name':['San Zhang','Si Li'],
'Age':[20,30]})
df2 = pd.DataFrame({'Name':['Wu Wang'], 'Age':[40]})
pd.concat([df1, df2],0)
| Name | Age | |
|---|---|---|
| 0 | San Zhang | 20 |
| 1 | Si Li | 30 |
| 0 | Wu Wang | 40 |
横向拼接：
pd.concat([df1, df2],1)
| Name | Age | Name | Age | |
|---|---|---|---|---|
| 0 | San Zhang | 20 | Wu Wang | 40 |
| 1 | Si Li | 30 | nan | nan |
虽然说 concat 不是处理关系型合并的函数，但是它仍然是关于索引进行连接的。纵向拼接会根据列索引对其，默认状态下 join=outer ，表示保留所有的列，并将不存在的值设为缺失； join=inner ，表示保留两个表都出现过的列。横向拼接则根据行索引对齐， join 参数可以类似设置。
因此，当确认要使用多表直接的方向合并时，尤其是横向的合并，可以先用 reset_index 方法恢复默认整数索引再进行合并，防止出现由索引的误对齐和重复索引的笛卡尔积带来的错误结果。
最后， keys 参数的使用场景在于多个表合并后，用户仍然想要知道新表中的数据来自于哪个原表，这时可以通过 keys 参数产生多级索引进行标记。例如，第一个表中都是一班的同学，而第二个表中都是二班的同学，可以使用如下方式合并：
df1 = pd.DataFrame({'Name':['San Zhang','Si Li'],
'Age':[20,30]})
df2 = pd.DataFrame({'Name':['Wu Wang'], 'Gender':['M']})
pd.concat([df1, df2],axis=1,join='outer',keys=['1','2'])
2. 序列Series与表DataFrame的合并
append 和 assign(分配)操作
在 append 中，如果原表是默认整数序列的索引，那么可以使用 ignore_index=True 对新序列对应的索引自动标号，否则必须对 Series 指定 name 属性。
df1 = pd.DataFrame({'Name':['San Zhang','Si Li'],
'Age':[20,30]})
s = pd.Series(['Wu Wang', 21], index = df1.columns)
df1.append(s, ignore_index=True)
| Name | Age | |
|---|---|---|
| 0 | San Zhang | 20 |
| 1 | Si Li | 30 |
| 2 | Wu Wang | 21 |
对于 assign分配 而言，虽然可以利用其添加新的列，但一般通过 df[‘new_col’] = … 的形式就可以等价地添加新列。同时，使用 [] 修改的缺点是它会直接在原表上进行改动，而 assign 返回的是一个临时副本:
append和assign的区别
append是不改变原有表格结构，增加一条数据。
assign是增加一个新的列。
三、类连接操作
除了上述介绍的若干连接函数之外， pandas 中还设计了一些函数能够对两个表进行某些操作，这里把它们统称为类连接操作。
1. 比较
它能够比较两个表或者序列的不同处并将其汇总展示
df1 = pd.DataFrame({'Name':['San Zhang', 'Si Li', 'Wu Wang'],
'Age':[20, 21 ,21],
'Class':['one', 'two', 'three']})
df2 = pd.DataFrame({'Name':['San Zhang', 'Li Si', 'Wu Wang'],
'Age':[20, 21 ,21],
'Class':['one', 'two', 'Three']})
df1.compare(df2)
| (‘Name’, ‘self’) | (‘Name’, ‘other’) | (‘Class’, ‘self’) | (‘Class’, ‘other’) | |
|---|---|---|---|---|
| 1 | Si Li | Li Si | nan | nan |
| 2 | nan | nan | three | Three |
结果中返回了不同值所在的行列，如果相同则会被填充为缺失值 NaN ，其中 other 和 self 分别指代传入的参数表和被调用的表自身。
如果想要完整显示表中所有元素的比较情况，可以设置 keep_shape=True ,结果如下：
2. 组合
combine 函数能够让两张表按照一定的规则进行组合，在进行规则比较时会自动进行列索引的对齐。对于传入的函数而言，每一次操作中输入的参数是来自两个表的同名 Series ，依次传入的列是两个表列名的并集，例如下面这个例子会依次传入 A,B,C,D 四组序列，每组为左右表的两个序列。同时，进行 A 列比较的时候， s2 指代的就是一个全空的序列，因为它在被调用的表中并不存在，并且来自第一个表的序列索引会被 reindex 成两个索引的并集。具体的过程可以通过在传入的函数中插入适当的 print 方法查看。
def choose_min(s1, s2):
s2 = s2.reindex_like(s1)
# 当不满足s1<s2时， series替换成s2
res = s1.where(s1<s2, s2)
res = res.mask(s1.isna()) # isna表示是否为缺失值，返回布尔序列
return res
df1 = pd.DataFrame({'A':[1,2], 'B':[3,4], 'C':[5,6]})
df2 = pd.DataFrame({'B':[5,6], 'C':[7,8], 'D':[9,10]}, index=[1,2])
df1.combine(df2, choose_min)
| A | B | C | D | |
|---|---|---|---|---|
| 0 | nan | nan | nan | nan |
| 1 | nan | 4 | 6 | nan |
| 2 | nan | nan | nan | nan |
等价于
df1.combine(df2,np.minimum)
四、练习
Ex1：美国疫情数据集
太难了 看了答案懂点，还能将Series转成DataFrame然后都加到一个空集合，再将整个list通过concat将其中所有DataFrame连接。
L = []
for d in date:
df = pd.read_csv('data/us_report/' + d + '.csv', index_col='Province_State')
data = df.loc['New York', ['Confirmed','Deaths',
'Recovered','Active']]
L.append(data.to_frame().T)
res = pd.concat(L)
res.index = date
res.head()
Ex2：实现join函数
请实现带有 how 参数的 join 函数
- 假设连接的两表无公共列
- 调用方式为 join(df1, df2, how=“left”)
- 给出测试样例
啥也不说了，贴答案吧。
In [117]: def join(df1, df2, how='left'):
.....: res_col = df1.columns.tolist() + df2.columns.tolist()
.....: dup = df1.index.unique().intersection(df2.index.unique())
.....: res_df = pd.DataFrame(columns = res_col)
.....: for label in dup:
.....: cartesian = [list(i)+list(j) for i in df1.loc[label
.....: ].values for j in df2.loc[label].values]
.....: dup_df = pd.DataFrame(cartesian, index = [label]*len(
.....: cartesian), columns = res_col)
.....: res_df = pd.concat([res_df,dup_df])
.....: if how in ['left', 'outer']:
.....: for label in df1.index.unique().difference(dup):
.....: if isinstance(df1.loc[label], pd.DataFrame):
.....: cat = [list(i)+[np.nan]*df2.shape[1
.....: ] for i in df1.loc[label].values]
.....: else: cat = [list(i)+[np.nan]*df2.shape[1
.....: ] for i in df1.loc[label].to_frame().values]
.....: dup_df = pd.DataFrame(cat, index = [label
.....: ]*len(cat), columns = res_col)
.....: res_df = pd.concat([res_df,dup_df])
.....: if how in ['right', 'outer']:
.....: for label in df2.index.unique().difference(dup):
.....: if isinstance(df2.loc[label], pd.DataFrame):
.....: cat = [[np.nan]+list(i)*df1.shape[1
.....: ] for i in df2.loc[label].values]
.....: else: cat = [[np.nan]+list(i)*df1.shape[1
.....: ] for i in df2.loc[label].to_frame().values]
.....: dup_df = pd.DataFrame(cat, index = [label
.....: ]*len(cat), columns = res_col)
.....: res_df = pd.concat([res_df,dup_df])
.....: return res_df
.....:
In [118]: df1 = pd.DataFrame({'col1':list('01234')}, index=list('AABCD'))
In [119]: df1
Out[119]:
col1
A 0
A 1
B 2
C 3
D 4
In [120]: df2 = pd.DataFrame({'col2':list('opqrst')}, index=list('ABBCEE'))
In [121]: df2
Out[121]:
col2
A o
B p
B q
C r
E s
E t
In [122]: join(df1, df2, how='outer')
Out[122]:
col1 col2
A 0 o
A 1 o
B 2 p
B 2 q
C 3 r
D 4 NaN
E NaN s
E NaN t
801
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
