在这里插入图片描述
Task05：合并（2天）

Pandas基础

Pandas 合并

一、append与assign

1. append方法
2. assign方法

二、combine与update

1. comine方法
2. update方法

三、concat方法
四、merge与join

1. merge函数
2. join函数

五、问题与练习

1. 问题
2. 练习

参考内容

Pandas 合并

import numpy as np
import pandas as pd

# 加上这两行可以一次性输出多个变量而不用print
from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.ast_node_interactivity = "all"

df = pd.read_csv('data/table.csv')
df.head()

	School	Class	ID	Gender	Address	Height	Weight	Math	Physics
0	S_1	C_1	1101	M	street_1	173	63	34.0	A+
1	S_1	C_1	1102	F	street_2	192	73	32.5	B+
2	S_1	C_1	1103	M	street_2	186	82	87.2	B+
3	S_1	C_1	1104	F	street_2	167	81	80.4	B-
4	S_1	C_1	1105	F	street_4	159	64	84.8	B+

一、append与assign

1. append方法

（a）利用序列添加行（必须指定name）

df_append = df.loc[:3,['Gender','Height']].copy()
df_append

	Gender	Height
0	M	173
1	F	192
2	M	186
3	F	167

# 用Series添加
s = pd.Series({'Gender':'F','Height':188},name='new_row') # 这里必须指定name
df_append.append(s) # 新增的是行

	Gender	Height
0	M	173
1	F	192
2	M	186
3	F	167
new_row	F	188

（b）用DataFrame添加表

df_temp = pd.DataFrame({
    'Gender': ['F', 'M'],
    'Height': [188, 176]
},
                       index=['new_1', 'new_2'])
df_append.append(df_temp)

	Gender	Height
0	M	173
1	F	192
2	M	186
3	F	167
new_1	F	188
new_2	M	176

2. assign方法

该方法主要用于添加列，列名直接由参数指定：

s = pd.Series(list('abcd'),index=range(4))
df_append.assign(Letter=s)

	Gender	Height	Letter
0	M	173	a
1	F	192	b
2	M	186	c
3	F	167	d

可以一次添加多个列：

df_append.assign(col1=lambda x:x['Gender']*2,
                 col2=s)

	Gender	Height	col1	col2
0	M	173	MM	a
1	F	192	FF	b
2	M	186	MM	c
3	F	167	FF	d

二、combine与update

1. comine方法

comine和update都是用于表的填充函数，可以根据某种规则填充
（a）填充对象
可以看出combine方法是按照表的顺序轮流进行逐列循环的，而且自动索引对齐，缺失值为NaN，理解这一点很重要

df_combine_1 = df.loc[:1,['Gender','Height']].copy()
df_combine_2 = df.loc[10:11,['Gender','Height']].copy()
df_combine_1
df_combine_2
df_combine_1.combine(df_combine_2,lambda x,y:print(x,y))

	Gender	Height
0	M	173
1	F	192

	Gender	Height
10	M	161
11	F	175

0       M
1       F
10    NaN
11    NaN
Name: Gender, dtype: object 0     NaN
1     NaN
10      M
11      F
Name: Gender, dtype: object
0     173.0
1     192.0
10      NaN
11      NaN
Name: Height, dtype: float64 0       NaN
1       NaN
10    161.0
11    175.0
Name: Height, dtype: float64

	Gender	Height
0	NaN	NaN
1	NaN	NaN
10	NaN	NaN
11	NaN	NaN

（b）一些例子
例①：根据列均值的大小填充

# 例子1
df1 = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
df2 = pd.DataFrame({'A': [1, 0], 'B': [5, 8]})
df1
df2
# 这里均值比较是在列间进行
df1.combine(df2,lambda x,y:x if x.mean()>y.mean() else y)

	A	B
0	1	3
1	2	4

	A	B
0	1	5
1	0	8

	A	B
0	1	5
1	2	8

例②：索引对齐特性（默认状态下，后面的表没有的行列都会设置为NaN）

df2 = pd.DataFrame({'B': [8, 7], 'C': [6, 5]},index=[1,2])
df1
df2
df1.combine(df2,lambda x,y:x if x.mean()>y.mean() else y)
# 没有的行或列都显示'NaN'

	A	B
0	1	3
1	2	4

	B	C
1	8	6
2	7	5

	A	B	C
0	NaN	NaN	NaN
1	NaN	8.0	6.0
2	NaN	7.0	5.0

例③：使得df1原来符合条件的值不会被覆盖

df1.combine(df2, lambda x, y: x if x.mean() > y.mean() else y, overwrite=False)

	A	B	C
0	1.0	NaN	NaN
1	2.0	8.0	6.0
2	NaN	7.0	5.0

例④：在新增匹配df2的元素位置填充-1

# 两者对比显示
df1.combine(df2, lambda x, y: x if x.mean() > y.mean() else y)
df1.combine(df2, lambda x, y: x if x.mean() > y.mean() else y, fill_value=-1)

	A	B	C
0	NaN	NaN	NaN
1	NaN	8.0	6.0
2	NaN	7.0	5.0

	A	B	C
0	1.0	-1.0	-1.0
1	2.0	8.0	6.0
2	-1.0	7.0	5.0

（c）combine_first方法
这个方法作用是用df2填补df1的缺失值，功能比较简单，但很多时候会比combine更常用，下面举两个例子：

df1 = pd.DataFrame({'A': [None, 0], 'B': [None, 4]})
df2 = pd.DataFrame({'A': [1, 1], 'B': [3, 3]})
df1
df2
df1.combine_first(df2)

	A	B
0	NaN	NaN
1	0.0	4.0

	A	B
0	1	3
1	1	3

	A	B
0	1.0	3.0
1	0.0	4.0

# 也有所引对齐特性
df1 = pd.DataFrame({'A': [None, 0], 'B': [4, None]})
df2 = pd.DataFrame({'B': [3, 3], 'C': [1, 1]}, index=[1, 2])
df1
df2
df1.combine_first(df2)

	A	B
0	NaN	4.0
1	0.0	NaN

	B	C
1	3	1
2	3	1

	A	B	C
0	NaN	4.0	NaN
1	0.0	3.0	1.0
2	NaN	3.0	1.0

2. update方法

（a）三个特点

①返回的框索引只会与被调用框的一致（默认使用左连接，下一节会介绍）
②第二个框中的nan元素不会起作用
③没有返回值，直接在df上操作

（b）例子
例①：索引完全对齐情况下的操作

# 这个函数呢相当于用df2取替换df1，但会根据索引对齐，后者没有的，保留原先df1
# 后者多余的也不会增加
df1 = pd.DataFrame({'A': [1, 2, 3],
                    'B': [400, 500, 600]})
df2 = pd.DataFrame({'B': [4, 5, 6],
                    'C': [7, 8, 9]})
df1
df2
df1.update(df2)
df1

	A	B
0	1	400
1	2	500
2	3	600

	B	C
0	4	7
1	5	8
2	6	9

	A	B
0	1	4
1	2	5
2	3	6

例②：部分填充

df1 = pd.DataFrame({'A': ['a', 'b', 'c'],
                    'B': ['x', 'y', 'z']})
df2 = pd.DataFrame({'B': ['d', 'e']}, index=[1,2])
df1.update(df2)
df1

	A	B
0	a	x
1	b	d
2	c	e

例③：缺失值不会填充

df1 = pd.DataFrame({'A': [1, 2, 3],
                    'B': [400, 500, 600]})
df2 = pd.DataFrame({'B': [4, np.nan, 6]})
df1.update(df2)
df1

	A	B
0	1	4.0
1	2	500.0
2	3	6.0

三、concat方法

concat方法可以在两个维度上拼接，默认纵向凭借（axis=0），拼接方式默认外连接。

所谓外连接，就是取拼接方向的并集，而’inner’时取拼接方向（若使用默认的纵向拼接，则为列的交集）的交集。

下面举一些例子说明其参数：

df1 = pd.DataFrame({'A': ['A0', 'A1'],
                    'B': ['B0', 'B1']},
                    index = [0,1])
df2 = pd.DataFrame({'A': ['A2', 'A3'],
                    'B': ['B2', 'B3']},
                    index = [2,3])
df3 = pd.DataFrame({'A': ['A1', 'A3'],
                    'D': ['D1', 'D3'],
                    'E': ['E1', 'E3']},
                    index = [1,3])
df1
df2
df3

	A	B
0	A0	B0
1	A1	B1

	A	B
2	A2	B2
3	A3	B3

	A	D	E
1	A1	D1	E1
3	A3	D3	E3

默认状态拼接：

pd.concat([df1,df2])

	A	B
0	A0	B0
1	A1	B1
2	A2	B2
3	A3	B3

axis=1时沿列方向拼接：

pd.concat([df1,df2],axis=1)

	A	B	A	B
0	A0	B0	NaN	NaN
1	A1	B1	NaN	NaN
2	NaN	NaN	A2	B2
3	NaN	NaN	A3	B3

join设置为内连接（由于axis=0，因此列取交集）：

df3
df1
pd.concat([df3,df1],join='inner') # BDE列没有交集

	A	D	E
1	A1	D1	E1
3	A3	D3	E3

	A	B
0	A0	B0
1	A1	B1

	A
1	A1
3	A3
0	A0
1	A1

join设置为外链接：

pd.concat([df3,df1],join='outer',sort=True) #sort设置列排序，默认为False
# 取并集

	A	B	D	E
1	A1	NaN	D1	E1
3	A3	NaN	D3	E3
0	A0	B0	NaN	NaN
1	A1	B1	NaN	NaN

verify_integrity检查列是否唯一：

#pd.concat([df3,df1],verify_integrity=True,sort=True) 报错

同样，可以添加Series：

s = pd.Series(['X0', 'X1'], name='X')
pd.concat([df1,s],axis=1)

	A	B	X
0	A0	B0	X0
1	A1	B1	X1

key参数用于对不同的数据框增加一个标号，便于索引：

pd.concat([df1,df2], keys=['x', 'y'])
pd.concat([df1,df2], keys=['x', 'y']).index

		A	B
x	0	A0	B0
x	1	A1	B1
y	2	A2	B2
y	3	A3	B3

MultiIndex([('x', 0),
            ('x', 1),
            ('y', 2),
            ('y', 3)],
           )

四、merge与join

1. merge函数

merge函数的作用是将两个pandas对象横向合并，遇到重复的索引项时会使用笛卡尔积，默认inner连接，可选left、outer、right连接

所谓左连接，就是指以第一个表索引为基准，右边的表中如果不再左边的则不加入，如果在左边的就以笛卡尔积的方式加入

merge/join与concat的不同之处在于on参数，可以指定某一个对象为key来进行连接

同样的，下面举一些例子：

left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
                     'key2': ['K0', 'K1', 'K0', 'K1'],
                      'A': ['A0', 'A1', 'A2', 'A3'],
                      'B': ['B0', 'B1', 'B2', 'B3']}) 
right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
                      'key2': ['K0', 'K0', 'K0', 'K0'],
                      'C': ['C0', 'C1', 'C2', 'C3'],
                      'D': ['D0', 'D1', 'D2', 'D3']})
right2 = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
                      'key2': ['K0', 'K0', 'K0', 'K0'],
                      'C': ['C0', 'C1', 'C2', 'C3']})

以key1为准则连接，如果具有相同的列，则默认suffixes=(’_x’,’_y’)：

left
right
pd.merge(left, right, on='key1')

	key1	key2	A	B
0	K0	K0	A0	B0
1	K0	K1	A1	B1
2	K1	K0	A2	B2
3	K2	K1	A3	B3

	key1	key2	C	D
0	K0	K0	C0	D0
1	K1	K0	C1	D1
2	K1	K0	C2	D2
3	K2	K0	C3	D3

	key1	key2_x	A	B	key2_y	C	D
0	K0	K0	A0	B0	K0	C0	D0
1	K0	K1	A1	B1	K0	C0	D0
2	K1	K0	A2	B2	K0	C1	D1
3	K1	K0	A2	B2	K0	C2	D2
4	K2	K1	A3	B3	K0	C3	D3

以多组键连接：

pd.merge(left, right, on=['key1','key2'])

	key1	key2	A	B	C	D
0	K0	K0	A0	B0	C0	D0
1	K1	K0	A2	B2	C1	D1
2	K1	K0	A2	B2	C2	D2

默认使用inner连接，因为merge只能横向拼接，所以取行向上keys的交集，下面看如果使用how=outer参数

注意：这里的how就是concat的join

pd.merge(left, right, how='outer', on=['key1','key2'])

	key1	key2	A	B	C	D
0	K0	K0	A0	B0	C0	D0
1	K0	K1	A1	B1	NaN	NaN
2	K1	K0	A2	B2	C1	D1
3	K1	K0	A2	B2	C2	D2
4	K2	K1	A3	B3	NaN	NaN
5	K2	K0	NaN	NaN	C3	D3

左连接：

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

	key1	key2	A	B
0	K0	K0	A0	B0
1	K0	K1	A1	B1
2	K1	K0	A2	B2
3	K2	K1	A3	B3

	key1	key2	C	D
0	K0	K0	C0	D0
1	K1	K0	C1	D1
2	K1	K0	C2	D2
3	K2	K0	C3	D3

	key1	key2	A	B	C	D
0	K0	K0	A0	B0	C0	D0
1	K0	K1	A1	B1	NaN	NaN
2	K1	K0	A2	B2	C1	D1
3	K1	K0	A2	B2	C2	D2
4	K2	K1	A3	B3	NaN	NaN

右连接：

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

	key1	key2	A	B
0	K0	K0	A0	B0
1	K0	K1	A1	B1
2	K1	K0	A2	B2
3	K2	K1	A3	B3

	key1	key2	C	D
0	K0	K0	C0	D0
1	K1	K0	C1	D1
2	K1	K0	C2	D2
3	K2	K0	C3	D3

	key1	key2	A	B	C	D
0	K0	K0	A0	B0	C0	D0
1	K1	K0	A2	B2	C1	D1
2	K1	K0	A2	B2	C2	D2
3	K2	K0	NaN	NaN	C3	D3

如果还是对笛卡尔积不太了解，请务必理解下面这个例子，由于B的所有元素为2，因此需要6行：

left = pd.DataFrame({'A': [1, 2], 'B': [2, 2]})
right = pd.DataFrame({'A': [4, 5, 6], 'B': [2, 2, 2]})
left
right
pd.merge(left, right, on='B', how='outer')

	A	B
0	1	2
1	2	2

	A	B
0	4	2
1	5	2
2	6	2

	A_x	B	A_y
0	1	2	4
1	1	2	5
2	1	2	6
3	2	2	4
4	2	2	5
5	2	2	6

validate检验的是到底哪一边出现了重复索引，如果是“one_to_one”则两侧索引都是唯一，如果"one_to_many"则左侧唯一

left = pd.DataFrame({'A': [1, 2], 'B': [2, 2]})
right = pd.DataFrame({'A': [4, 5, 6], 'B': [2, 3, 4]})
#pd.merge(left, right, on='B', how='outer',validate='one_to_one') #报错

left = pd.DataFrame({'A': [1, 2], 'B': [2, 1]})
left
right
pd.merge(left, right, on='B', how='outer',validate='one_to_one')

	A	B
0	1	2
1	2	1

	A	B
0	4	2
1	5	3
2	6	4

	A_x	B	A_y
0	1.0	2	4.0
1	2.0	1	NaN
2	NaN	3	5.0
3	NaN	4	6.0

indicator参数指示了，合并后该行索引的来源

df1 = pd.DataFrame({'col1': [0, 1], 'col_left': ['a', 'b']})
df2 = pd.DataFrame({'col1': [1, 2, 2], 'col_right': [2, 2, 2]})
df1
df2
pd.merge(df1, df2, on='col1', how='outer',
         indicator=True)  #indicator='indicator_column'也是可以的

	col1	col_left
0	0	a
1	1	b

	col1	col_right
0	1	2
1	2	2
2	2	2

	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

2. join函数

join函数作用是将多个pandas对象横向拼接，遇到重复的索引项时会使用笛卡尔积，默认左连接，可选inner、outer、right连接

left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],
                     'B': ['B0', 'B1', 'B2']},
                    index=['K0', 'K1', 'K2'])
right = pd.DataFrame({'C': ['C0', 'C2', 'C3'],
                      'D': ['D0', 'D2', 'D3']},
                    index=['K0', 'K2', 'K3'])
left
right
left.join(right)

	A	B
K0	A0	B0
K1	A1	B1
K2	A2	B2

	C	D
K0	C0	D0
K2	C2	D2
K3	C3	D3

	A	B	C	D
K0	A0	B0	C0	D0
K1	A1	B1	NaN	NaN
K2	A2	B2	C2	D2

对于many_to_one模式下的合并，往往join更为方便

同样可以指定key：

left = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
                     'B': ['B0', 'B1', 'B2', 'B3'],
                     'key': ['K0', 'K1', 'K0', 'K1']})
right = pd.DataFrame({'C': ['C0', 'C1'],
                      'D': ['D0', 'D1']},
                     index=['K0', 'K1'])
left
right
left.join(right, on='key')

	A	B	key
0	A0	B0	K0
1	A1	B1	K1
2	A2	B2	K0
3	A3	B3	K1

	C	D
K0	C0	D0
K1	C1	D1

	A	B	key	C	D
0	A0	B0	K0	C0	D0
1	A1	B1	K1	C1	D1
2	A2	B2	K0	C0	D0
3	A3	B3	K1	C1	D1

多层key：

left = pd.DataFrame({
    'A': ['A0', 'A1', 'A2', 'A3'],
    'B': ['B0', 'B1', 'B2', 'B3'],
    'key1': ['K0', 'K0', 'K1', 'K2'],
    'key2': ['K0', 'K1', 'K0', 'K1']
})
index = pd.MultiIndex.from_tuples([('K0', 'K0'), ('K1', 'K0'), ('K2', 'K0'),
                                   ('K2', 'K1')],
                                  names=['key1', 'key2'])

right = pd.DataFrame(
    {
        'C': ['C0', 'C1', 'C2', 'C3'],
        'D': ['D0', 'D1', 'D2', 'D3']
    },
    index=index)
left
right
left.join(right, on=['key1', 'key2'])

	A	B	key1	key2
0	A0	B0	K0	K0
1	A1	B1	K0	K1
2	A2	B2	K1	K0
3	A3	B3	K2	K1

		C	D
key1	key2
K0	K0	C0	D0
K1	K0	C1	D1
K2	K0	C2	D2
K2	K1	C3	D3

	A	B	key1	key2	C	D
0	A0	B0	K0	K0	C0	D0
1	A1	B1	K0	K1	NaN	NaN
2	A2	B2	K1	K0	C1	D1
3	A3	B3	K2	K1	C3	D3

五、问题与练习

1. 问题

【问题一】请思考什么是append/assign/combine/update/concat/merge/join各自最适合使用的场景，并举出相应的例子

1. df1.append(df2) #将其他行附加到df的末尾，返回一个新对象。
    # 不在此框架中的列将添加为新列
    # append绝大部分功能可有concat实现。
2. df1.combine(df2) # 通过函数组合2个数据df1,df2
3. df1.combine_first(df2) # df1值优先，用df2中的值填充df1中Na值
4. df1.update(df2) # 用df2中的非NaN值进行就地修改df1
5. pd.concat(df1,df2) # 沿轴连接
    # 将多个对象堆叠到一起。
6. pd.merge(df1,df2) # 数据库方式数据合并（列操作）
    # 可根据一个或多个键（索引名或列名）将不同DataFrame中的行连接起来
7. df1.join(df2) # 数据连接（列操作）
    # 通过一个或多个键(df1索引名或列名，df2索引名)将行键接起来
    # join绝大部分功能可有merge实现。
8. df1.assign(col_names = col) # 主要用于添加列，列名直接由参数指定

【问题二】 merge_ordered和merge_asof的作用是什么？和merge是什么关系？

【问题三】请构造一个多级索引与多级索引合并的例子，尝试使用不同的合并函数。

【问题四】上文提到了连接的笛卡尔积，那么当连接方式变化时（inner/outer/left/right），这种笛卡尔积规则会相应变化吗？请构造相应例子。

2. 练习

【练习一】有2张公司的员工信息表，每个公司共有16名员工，共有五个公司，请解决如下问题：

df1 = pd.read_csv('data/Employee1.csv')
df1.head()

	Company	Name	Age	Height	Weight	Salary
0	A	a1	47	188	63.7	25819
1	A	a3	39	172	55.9	21983
2	A	a4	43	158	62.5	21755
3	A	a6	42	182	76.9	17354
4	A	a7	49	171	94.6	6177

df2 = pd.read_csv('data/Employee2.csv')
df2.head()

	Company	Name	Age	Height	Weight	Salary
0	A	a1	30	156	91.2	28133
1	A	a2	50	190	83.4	6673
2	A	a3	34	168	96.6	16503
3	A	a5	51	176	97.2	23294
4	A	a6	37	183	93.2	19256

(a) 每个公司有多少员工满足如下条件：既出现第一张表，又出现在第二张表。

unique = []
for i in set(df2['Name']):
    if i in set(df1['Name']):
        unique.append(i)
unique
num = pd.Series(unique[i][0] for i in range(len(unique)))
num.value_counts()

['a6',
 'd10',
 'b15',
 'e11',
 'a3',
 'c10',
 'e10',
 'b1',
 'a1',
 'e8',
 'b7',
 'd5',
 'c12',
 'c3',
 'c13',
 'b3']

b    4
c    4
e    3
a    3
d    2
dtype: int64

(b) 将所有不符合(a)中条件的行筛选出来，合并为一张新表，列名与原表一致。

d1 = df1[~df1['Name'].isin(unique)]
d2 = df2[~df2['Name'].isin(unique)]
d1_d2 = pd.concat([d1, d2])
d1_d2.head()

	Company	Name	Age	Height	Weight	Salary
2	A	a4	43	158	62.5	21755
4	A	a7	49	171	94.6	6177
5	A	a8	51	168	89.5	3246
6	A	a9	36	186	62.8	3569
7	A	a13	58	190	75.9	21854

（c）现在需要编制所有80位员工的信息表，对于(b)中的员工要求不变，对于满足(a)条件员工，它们在某个指标的数值，取偏离它所属公司中满足(b)员工的均值数较小的哪一个，例如：P公司在两张表的交集为{p1}，并集扣除交集为{p2,p3,p4}，那么如果后者集合的工资均值为1万元，且p1在表1的工资为13000元，在表2的工资为9000元，那么应该最后取9000元作为p1的工资，最后对于没有信息的员工，利用缺失值填充。

【练习二】有2张课程的分数表（分数随机生成），但专业课（学科基础课、专业必修课、专业选修课）与其他课程混在一起，请解决如下问题：

s1 = pd.read_csv('data/Course1.csv')
s1.head()

	课程名字	课程类别	学分	分数
0	思想道德修养与法律基础	思政类	3	89.0
1	云计算应用与开发	专业选修课	3	96.0
2	社会计算	专业选修课	3	78.0
3	深度学习	专业选修课	3	75.0
4	人工智能导论	专业必修课	3	84.0

s2 = pd.read_csv('data/Course2.csv')
s2.head()

	课程名字	课程类别	学分	分数
0	高等数学（一）	学科基础课	4	99.0
1	数据科学与工程导论	学科基础课	3	NaN
2	专业英语	学科基础课	2	100.0
3	概率论	学科基础课	3	99.0
4	计算机系统	专业必修课	4	80.0

(a) 将两张表分别拆分为专业课与非专业课（结果为四张表）。

s1_1 = s1.query('课程类别 in ["学科基础课","专业必修课","专业选修课"]')
s1_2 = s1.query('课程类别 not in ["学科基础课","专业必修课","专业选修课"]')
s2_1 = s2.query('课程类别 in ["学科基础课","专业必修课","专业选修课"]')
s2_2 = s2.query('课程类别 not in ["学科基础课","专业必修课","专业选修课"]')
s1_1.head()
s1_2.head()
s2_1.head()
s2_2.head()

	课程名字	课程类别	学分	分数
1	云计算应用与开发	专业选修课	3	96.0
2	社会计算	专业选修课	3	78.0
3	深度学习	专业选修课	3	75.0
4	人工智能导论	专业必修课	3	84.0
6	数据结构与算法	学科基础课	5	82.0

	课程名字	课程类别	学分	分数
0	思想道德修养与法律基础	思政类	3	89.0
5	中国近代史纲要	思政类	3	97.0
8	网球（初）	体育类	1	81.0
10	极端性气候与陆地生态系统	公共任意选修类	2	78.0
13	游泳（初）	体育类	1	75.0

	课程名字	课程类别	学分	分数
0	高等数学（一）	学科基础课	4	99.0
1	数据科学与工程导论	学科基础课	3	NaN
2	专业英语	学科基础课	2	100.0
3	概率论	学科基础课	3	99.0
4	计算机系统	专业必修课	4	80.0

	课程名字	课程类别	学分	分数
25	学术英语听说（二）	英语类	2	92.0
26	学术英语阅读	英语类	2	72.0
27	学术英语写作	英语类	2	98.0
28	美国社会与文化	英语类	2	77.0
29	马克思主义基本原理概论	思政类	3	95.0

(b) 将两张专业课的分数表和两张非专业课的分数表分别合并。

zhuanyeke = pd.concat([s1_1, s2_1])
feizhuanye = pd.concat([s1_2, s2_2])
zhuanyeke.head()
feizhuanye.head()

	课程名字	课程类别	学分	分数
1	云计算应用与开发	专业选修课	3	96.0
2	社会计算	专业选修课	3	78.0
3	深度学习	专业选修课	3	75.0
4	人工智能导论	专业必修课	3	84.0
6	数据结构与算法	学科基础课	5	82.0

	课程名字	课程类别	学分	分数
0	思想道德修养与法律基础	思政类	3	89.0
5	中国近代史纲要	思政类	3	97.0
8	网球（初）	体育类	1	81.0
10	极端性气候与陆地生态系统	公共任意选修类	2	78.0
13	游泳（初）	体育类	1	75.0

（c）不使用(a)中的步骤，请直接读取两张表合并后拆分。

course = pd.concat([s1, s2])
zhuanyeke = course.query('课程类别 in ["学科基础课","专业必修课","专业选修课"]')
feizhuanye = course.query('课程类别 not in ["学科基础课","专业必修课","专业选修课"]')
zhuanyeke.head()
feizhuanye.head()

	课程名字	课程类别	学分	分数
1	云计算应用与开发	专业选修课	3	96.0
2	社会计算	专业选修课	3	78.0
3	深度学习	专业选修课	3	75.0
4	人工智能导论	专业必修课	3	84.0
6	数据结构与算法	学科基础课	5	82.0

	课程名字	课程类别	学分	分数
0	思想道德修养与法律基础	思政类	3	89.0
5	中国近代史纲要	思政类	3	97.0
8	网球（初）	体育类	1	81.0
10	极端性气候与陆地生态系统	公共任意选修类	2	78.0
13	游泳（初）	体育类	1	75.0

(d) 专业课程中有缺失值吗，如果有的话请在完成(3)的同时，用组内（3种类型的专业课）均值填充缺失值后拆分。

course.isnull().sum()

课程名字    0
课程类别    0
学分      0
分数      3
dtype: int64

course['分数'] = course.groupby('课程类别').transform(
    lambda x: x.fillna(x.mean()))['分数']
course.isnull().sum()

课程名字    0
课程类别    0
学分      0
分数      0
dtype: int64

zhuanyeke = course.query('课程类别 in ["学科基础课","专业必修课","专业选修课"]')
feizhuanye = course.query('课程类别 not in ["学科基础课","专业必修课","专业选修课"]')
zhuanyeke.head()
feizhuanye.head()

	课程名字	课程类别	学分	分数
1	云计算应用与开发	专业选修课	3	96.0
2	社会计算	专业选修课	3	78.0
3	深度学习	专业选修课	3	75.0
4	人工智能导论	专业必修课	3	84.0
6	数据结构与算法	学科基础课	5	82.0

	课程名字	课程类别	学分	分数
0	思想道德修养与法律基础	思政类	3	89.0
5	中国近代史纲要	思政类	3	97.0
8	网球（初）	体育类	1	81.0
10	极端性气候与陆地生态系统	公共任意选修类	2	78.0
13	游泳（初）	体育类	1	75.0

参考内容

教程仓库连接
《利用Python进行数据分析》

Pandas学习笔记5——合并