task_6连接

一、作业

# 作业1

import pandas as pd         
import os               
import sys          
import glob

# 调用os读取目录下的所有文件
path = r'data/us_report' 
all_files = glob.glob(os.path.join(path, "*.csv")) 
df_from_each_file = (pd.read_csv(f) for f in all_files)
# 设置多层index,将时间设置为文件名
# PS： 我写完代码才发现题目里给了规定的代码，然而我已经搞完了，就偷懒不动了，看起来差不多，只不过不是datetime对象
date = [ i.split('\\')[-1].split('.csv')[0] for i in all_files]

# 纵向连接所有的数据
df_all =  pd.concat(df_from_each_file, keys = date )
df = df_all.copy() #复制一份

# 重置索引
df = df.reset_index()
df.head()

# 选择纽约的行数据
df_NY = df.loc[df['Province_State'] == 'New York',['level_0','Confirmed', 'Deaths', 'Recovered', 'Active' ]]
df_NY.head()

# 修改列名
df_NY = df_NY.rename(columns={'level_0':'date'})
'''
修改列名时出现了一点问题。一开始写的代码是df_ny.rename_axis(columns={'level_0':'date'}).head()
结果死活不行。经群里大佬指点，才想起来df的Index是一个对象，这个对象有一个属性叫name，列名实际上是Index的值。
因此要用rename来修改。
'''
# 设置索引
df_NY = df_NY.set_index('date')
df_NY.head()

'''
Ex2：实现join函数¶
请实现带有 how 参数的 join 函数

假设连接的两表无公共列

调用方式为 join(df1, df2, how="left")

给出测试样例
'''

def myjoin(df1, df2, how="left"):
    import pandas as pd
    import numpy as np

    if how=="left":
        df_base = df1
        df_extra = df2
        
    elif how=='right':
        df_base = df2
        df_extra = df1        
    else:
        error('The value of how should be left or right')
        
    shape1 = df_base.shape[0]
    shape2 = df_extra.shape[0]
    
    if shape2 >= shape1:
        return pd.concat([df_base, df_extra.iloc[:shape1,:]], axis=1)
    else:
        data = np.full([shape1-shape2, df_extra.shape[1]], np.nan)
        df_nan = pd.DataFrame(columns = df_extra.columns, data = data)
        df_extra = df_extra.append(df_nan, ignore_index=True)
        return pd.concat([df_base, df_extra], axis=1)
    

# 函数用法示例
df1 = pd.DataFrame({'Name':['San Zhang','Si Li'],
                    'Age':[20,30]})


df2 = pd.DataFrame({'name':['Wu Wang'], 'weight':[40]})

myjoin(df1, df2)

二、关系型连接

2.1 连接的基本概念

连接是指把两张相关的表按照某一个或某一组键连接起来。例如学生期末考试各个科目的成绩表按照 姓名 和 班级 连接成总的成绩表，又例如对企业员工的各类信息表按照 员工ID号 进行连接汇总。
在关系型连接中， 键是十分重要的，往往用 on 参数表示。
另一个重要的要素是连接的形式。在 pandas 中的关系型连接函数 merge 和 join 中提供了 how 参数来代表连接形式，分为左连接 left 、右连接 right 、内连接 inner 、外连接 outer。
对于两个DataFrame的，如图，假设连接的键为‘Name’,四中连接具体形式如图所示。

所谓左连接即以左表的键为准，如果右表中的键于左表存在，那么就添加到左表，否则则处理为缺失值，右连接类似处理。内连接只负责合并两边同时出现的键，而外连接则会在内连接的基础上包含只在左边出现以及只在右边出现的值，因此外连接又叫全连接。

键即指用于连接的列元素，连接法则这里可以用一个表表示：

2.2 值连接

pandas 中merge函数: 按一列或者多列的值的组合来连接

df1 = pd.DataFrame({'Name':['San Zhang','Si Li'],
                    'Age':[20,30]})
df2 = pd.DataFrame({'Name':['Si Li','Wu Wang'],
                    'Gender':['F','M']})
df1.merge(df2, on='Name', how='left')
df1.merge(df2, on='Name', how='right')
df1.merge(df2, on='Name', how='inner')
df1.merge(df2, on='Name', how='outer')

• 多列
  在某些时候出现重复元素是麻烦的，例如两位同学来自不同的班级，但是姓名相同，这种时候就要指定 on 参数为多个列使得正确连接：

df1 = pd.DataFrame({'Name':['San Zhang', 'San Zhang'],
                  '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') # 错误的结果。由于每个表都有重复值，因此做笛卡尔积，出现四行。
df1.merge(df2, on=['Name', 'Class'], how='left') # 正确的结果。按两列数据组合来合并，就没有重复值。正常合并

如果两个表中想要连接的列不具备相同的列名，可以通过 left_on 和 right_on 指定

df1 = pd.DataFrame({'df1_name':['San Zhang','Si Li'],
                   'Age':[20,30]})
df2 = pd.DataFrame({'df2_name':['Si Li','Wu Wang'],
                    'Gender':['F','M']})

df1.merge(df2, left_on='df1_name', right_on='df2_name', how='left')

如果两个表中的列出现了重复的列名，那么可以通过 suffixes 参数指定。例如合并考试成绩的时候，第一个表记录了语文成绩，第二个是数学成绩：

df1 = pd.DataFrame({'Name':['San Zhang'],'Grade':[70]})

df2 = pd.DataFrame({'Name':['San Zhang'],'Grade':[80]})

df1.merge(df2, on='Name', how='left')# 如果不加suffixes=['_Chinese','_Math']，结果是列名为 Grade_x Grade_y

df1.merge(df2, on='Name', how='left', suffixes=['_Chinese','_Math'])
# 加了suffixes=['_Chinese','_Math']，结果是列名为 Grade_Chinese Grade_Math。似乎相当于一个修改列名的参数

2.3 索引连接

所谓索引连接，就是把索引当作键，因此这和值连接本质上没有区别， pandas 中利用 join 函数来处理索引连接，它的参数选择要少于 merge ，除了必须的 on 和 how 之外，可以对重复的列指定左右后缀 lsuffix 和 rsuffix 。其中， on 参数指索引名，单层索引时省略参数表示按照当前索引连接。

df1 = pd.DataFrame({'Age':[20,30]},
                  index=pd.Series(
                  ['San Zhang','Si Li'],name='Name'))
df2 = pd.DataFrame({'Gender':['F','M']},
                    index=pd.Series(
                    ['Si Li','Wu Wang'],name='Name'))
df1.join(df2, how='left')

df1 = pd.DataFrame({'Grade':[70]},
                     index=pd.Series(['San Zhang'],
                     name='Name'))
 

df2 = pd.DataFrame({'Grade':[80]},
                     index=pd.Series(['San Zhang'],
                     name='Name'))
df1.join(df2, how='left', lsuffix='_Chinese', rsuffix='_Math')

df1 = pd.DataFrame({'Age':[20,21]},
                    index=pd.MultiIndex.from_arrays(
                    [['San Zhang', 'San Zhang'],['one', 'two']],
                    names=('Name','Class')))


df2 = pd.DataFrame({'Gender':['F', 'M']},
                    index=pd.MultiIndex.from_arrays(
                    [['San Zhang', 'San Zhang'],['two', 'one']],
                    names=('Name','Class')))


df1.join(df2)
# 结果相当于df1.merge(df2,on=['Name','Class'], how='left')

三、方向连接

3.1 concat函数

不依赖于轴（键）的数据拼接。作用类比于matlab中[A,B]横向拼接与[A;B]纵向拼接。

在 concat 中，最常用的有三个参数，它们是 axis, join, keys ，分别表示拼接方向，连接形式，以及在新表中指示来自于哪一张旧表的名字。这里需要特别注意， join 和 keys 与之前提到的 join 函数和键的概念没有任何关系。

在默认状态下的 axis=0 ，表示纵向拼接多个表，常常用于多个样本的拼接；而 axis=1 表示横向拼接多个表，常用于多个字段或特征的拼接。

• 纵向连接。nd的数据与md的数据拼成(m+n)*d

df1 = pd.DataFrame({'Name':['San Zhang','Si Li'],
                    'Age':[20,30]})
df2 = pd.DataFrame({'Name':['Wu Wang'], 'Age':[40]})
pd.concat([df1, df2])

• 横向连接。nd的数据与nc的数据拼成n*(d+c)

df2 = pd.DataFrame({'Grade':[80, 90]})
df3 = pd.DataFrame({'Gender':['M', 'F']})
pd.concat([df1, df2, df3], 1)

默认状态下 join=outer ，表示保留所有的列，并将不存在的值设为缺失；
join=inner ，表示保留两个表都出现过的列。横向拼接则根据行索引对齐， join 参数可以类似设置。

df2 = pd.DataFrame({'Name':['Wu Wang'], 'Gender':['M']})
pd.concat([df1, df2])
df2 = pd.DataFrame({'Grade':[80, 90]}, index=[1, 2])
pd.concat([df1, df2], 1)
pd.concat([df1, df2], axis=1, join='inner')

当确认要使用多表直接的方向合并时，尤其是横向的合并，可以先用 reset_index 方法恢复默认整数索引再进行合并，防止出现由索引的误对齐和重复索引的笛卡尔积带来的错误结果。

keys 参数的使用场景在于多个表合并后，用户仍然想要知道新表中的数据来自于哪个原表，这时可以通过 keys 参数产生多级索引进行标记。

df1 = pd.DataFrame({'Name':['San Zhang','Si Li'],
                     'Age':[20,21]})
df2 = pd.DataFrame({'Name':['Wu Wang'],'Age':[21]})
pd.concat([df1, df2], keys=['one', 'two'])

3.2 序列与表的合并

• append方法：把一个序列追加到表的行末。
  在 append 中，如果原表是默认整数序列的索引，那么可以使用 ignore_index=True 对新序列对应的索引自动标号，否则必须对 Series 指定 name 属性。

s = pd.Series(['Wu Wang', 21], index = df1.columns)
df1.append(s, ignore_index=True)

• assign 方法：把一个序列追加到表的列末。
  一般通过 df[‘new_col’] = … 的形式等价地添加新列。同时，使用 [] 修改的缺点是它会直接在原表上进行改动，而 assign 返回的是一个临时副本

s = pd.Series([80, 90])
df1.assign(Grade=s)
df1['Grade'] = s
df1

四、类连接操作

4.1 比较

compare函数能够比较两个表或者序列的不同处并将其汇总展示。

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)

结果中返回了不同值所在的行列，如果相同则会被填充为缺失值 NaN ，其中 other 和 self 分别指代传入的参数表和被调用的表自身。
如果想要完整显示表中所有元素的比较情况，可以设置 keep_shape=True

df1.compare(df2, keep_shape=True)
#	Name	Age	Class
#self	other	self	other	self	other
#0	NaN	NaN	NaN	NaN	NaN	NaN
#1	Si Li	Li Si	NaN	NaN	NaN	NaN
#2	NaN	NaN	NaN	NaN	three	Three

4.2 组合

combine 函数能够让两张表按照一定的规则进行组合，在进行规则比较时会自动进行列索引的对齐。对于传入的函数而言，每一次操作中输入的参数是来自两个表的同名 Series ，依次传入的列是两个表列名的并集。
下面的例子表示选出对应索引位置较小的元素

def choose_min(s1, s2):
        s2 = s2.reindex_like(s1)
        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.0	6.0	NaN
#2	NaN	NaN	NaN	NaN

设置 overtwrite 参数为 False 可以保留 被调用表 中未出现在传入的参数表中的列，而不会设置未缺失值：

df1.combine(df2, choose_min, overwrite=False)
#	A	B	C	D
#0	1.0	NaN	NaN	NaN
#1	2.0	4.0	6.0	NaN
#2	NaN	NaN	NaN	NaN