第5章合併

import numpy as np
import pandas as pd
df = pd.read_csv('data/table.csv')
df.head()

# import numpy as np
# import pandas as pd 
# 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
# df_append=df.loc[:3,['Gender','Height']].copy()
# df_append

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


s = pd.Series({'Gender':'F','Height':188},name='new_row')
s=pd.Series(['F',188],index=['Gender','Height'],name ='new_row')
s
df_append.append(s)

# s=pd.Series({'Gender':'F','Height':188},name='new_row')
# 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)

# 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)


# 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)
df_append.assign(col1=lambda x:x['Gender']+'test',
                col2=s)

	Gender	Height	col1	col2
0	M	173	Mtest	NaN
1	F	192	Ftest	NaN
2	M	186	Mtest	NaN
3	F	167	Ftest	NaN

二、combine與update

1. comine方法

comine和update都是用於表的填充函數，可以根據某種規則填充

（a）填充對象

可以看出combine方法是按照表的順序輪流進行逐列循環的，而且自動索引對齊，缺失值爲NaN，理解這一點很重要

首先腦子裏先生成一張新表df3，它的行列爲df1和df2的並集，然後將原來的df1和df2的大小擴充到df3，缺失值爲NaN，然後對df1和df2同時逐列進行func參數的規則操作（就是寫的lambda那個地方），然後按照返回值進行每一列的更新。

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

	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	M	173.0
1	F	192.0
10	NaN	NaN
11	NaN	NaN

（b）一些例子

例①：根據列均值的大小填充

# 例子1
df1 = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
df2 = pd.DataFrame({'A': [8, 7], 'B': [6, 5]})
df1.combine(df2,lambda x,y:x if x.mean()>y.mean() else y)


# df1=pd.DataFrame({'A':[1,2],'B':[3,4]})
# df2=pd.DataFrame({'A':[8,7],'B':[6,5]})
# df1.combine(df2,lambda x,y:x if x.mean()>y.mean() else y)

	A	B
0	8	6
1	7	5

例②：索引對齊特性（默認狀態下，後面的表沒有的行列都會設置爲NaN）

df1

	A	B
0	1	3
1	2	4

df2 = pd.DataFrame({'B': [8, 7], 'C': [6, 5]},index=[1,2])
df2

	B	C
1	8	6
2	7	5

# df2 = pd.DataFrame({'B': [8, 7], 'C': [6, 5]},index=[1,2])
df1.combine(df2,lambda x,y:x if x.mean()>y.mean() else y)

	A	B	C
0	NaN	3.0	NaN
1	NaN	4.0	6.0
2	NaN	NaN	5.0

例③：使得df1原來符合條件的值不會被覆蓋

overwrite設置的是False，所以如果df1表有，df2沒有，那麼就是根據有值的那個表填充值，如果兩個都沒有填充NaN，如果overwrite=True那麼就是除了df2相應位置有，其他都是NaN，此時‘A’列都是NaN（體會一下overwrite的含義就是是否df2說了算）

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,fill_value=-1)
df1.combine(df2,lambda x,y:x if x.mean()>y.mean() else y,fill_value=-1)

	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.combine_first(df2)

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

	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.combine_first(df2)

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

	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）例子

例①：索引完全對齊情況下的操作

df1 = pd.DataFrame({'A': [1, 2, 3],
                    'B': [400, 500, 600]})
df2 = pd.DataFrame({'B': [4, 5, 6],
                    'C': [7, 8, 9]})
df1.update(df2)
df1

	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])

默認狀態拼接：

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，因此列取交集）：

pd.concat([df3,df1],join='inner')

	A
1	A1
3	A3
0	A0
1	A1

join設置爲外鏈接：

pd.concat([df3,df1],sort=True)

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

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

四、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’)：

display(left)
display(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

左連接：

pd.merge(left, right, how='left', 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

右連接：

pd.merge(left, right, how='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
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]})
pd.merge(left, right, on='B', how='outer')

	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]})
pd.merge(left, right, on='B', how='outer',validate='one_to_one')

	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]})
pd.merge(df1, df2, on='col1', how='outer', indicator=True) #indicator='indicator_column'也是可以的

	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'])
display(left)
display(right)
display(left.join(right))
left=left.rename_axis(index={None:'indx'})
right=right.rename_axis(index={None:'indx'})
# display(left)
# display(right)
pd.merge(left,right,how='left',on='indx')

	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

	A	B	C	D
indx
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.join(right, on='key')

	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)
display(left)
display(right)
display(left.join(right, on=['key1','key2']))
pd.merge(left,right,on=['key1','key2'],how='left')

	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

	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各自最適合使用的場景，並舉出相應的例子。

append像序列中添加行
assign 更像是左連接，一列一列的像序列中添加列
combine 求兩個表的並集
update 把一個表裏面的元素參照另一個表進行更新
concat 可以將兩個表在兩個維度進行拼接
merge 通過指定一個key來將兩個表進行連接
join 也可以指定key，默認的話就是按照index來進行連接

【問題二】 merge_ordered和merge_asof的作用是什麼？和merge是什麼關係？

merge_ordered:使用可選的填充或者插值進行合併。
函數允許組合時間序列和其他有序數據。特別是它有一個可選的fill_method關鍵字來填充/插入缺失的數據。
merge_asof:執行合併。類似於左連接，只是我們匹配最近的鍵而不是相等的鍵，可以說是一種去除NaN的連接方法。
除了我們匹配最近的鍵而不是相等的鍵之外，其他的都類似於有序的left-join 。對於左側DataFrame中的每一行，我們選擇右側DataFrame中on鍵對應的值小於left的鍵對應的值的最後一行。兩個DataFrame必須按鍵排序。

【問題三】請構造一個多級索引與多級索引合併的例子，嘗試使用不同的合併函數。

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)
display(left.join(right, on=['key1','key2']))
pd.merge(left,right,on=['key1','key2'],how='left')

	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

	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

【問題四】上文提到了連接的笛卡爾積，那麼當連接方式變化時（inner/outer/left/right），這種笛卡爾積規則會相應變化嗎？請構造相應例子。

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

	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

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

	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

2. 練習

【練習一】有2張公司的員工信息表，每個公司共有16名員工，共有五個公司，請解決如下問題：

pd.read_csv('data/Employee1.csv').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

pd.read_csv('data/Employee2.csv').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) 每個公司有多少員工滿足如下條件：既出現第一張表，又出現在第二張表。

(b) 將所有不符合(a)中條件的行篩選出來，合併爲一張新表，列名與原表一致。

© 現在需要編制所有80位員工的信息表，對於(b)中的員工要求不變，對於滿足(a)條件員工，它們在某個指標的數值，取偏離它所屬公司中滿足(b)員工的均值數較小的哪一個，例如：P公司在兩張表的交集爲{p1}，並集扣除交集爲{p2,p3,p4}，那麼如果後者集合的工資均值爲1萬元，且p1在表1的工資爲13000元，在表2的工資爲9000元，那麼應該最後取9000元作爲p1的工資，最後對於沒有信息的員工，利用缺失值填充。

(a) 每個公司有多少員工滿足如下條件：既出現第一張表，又出現在第二張表。

df1=pd.read_csv('data/Employee1.csv')
df2=pd.read_csv('data/Employee2.csv')
L=pd.merge(table1,table2,on=['Name'],how='inner')['Name']
L=list(L)
# L.count()
len(L)

(b) 將所有不符合(a)中條件的行篩選出來，合併爲一張新表，列名與原表一致。

# L.values
df1[~df1['Name'].isin(L)]

	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
8	A	a15	35	162	97.2	4706
9	A	a16	35	157	77.6	16130
12	B	b5	36	171	68.4	22547
13	B	b6	46	184	98.9	19493
15	B	b9	52	187	80.5	21171
16	B	b10	37	177	95.6	14376
17	B	b14	52	181	51.9	11474
20	C	c4	41	190	61.8	19258
21	C	c5	36	165	84.3	6563
22	C	c7	32	189	58.1	24791
23	C	c9	32	176	92.5	11797
27	D	d2	52	190	84.7	9382
29	D	d6	45	178	92.5	19393
30	D	d9	52	160	71.8	13531
32	D	d11	55	183	93.9	12547
33	E	e4	37	167	91.3	19171
34	E	e7	44	164	51.9	13035
38	E	e13	57	180	54.8	26837
39	E	e14	39	163	83.0	20554

d1=df1[~df1['Name'].isin(L)]
d2=df2[~df2['Name'].isin(L)]
df_b=pd.concat([d1,d2]).set_index('Name')
df_b.head()

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

© 現在需要編制所有80位員工的信息表，對於(b)中的員工要求不變，對於滿足(a)條件員工，它們在某個指標的數值，取偏離它所屬公司中滿足(b)員工的均值數較小的哪一個，例如：P公司在兩張表的交集爲{p1}，並集扣除交集爲{p2,p3,p4}，那麼如果後者集合的工資均值爲1萬元，且p1在表1的工資爲13000元，在表2的工資爲9000元，那麼應該最後取9000元作爲p1的工資，最後對於沒有信息的員工，利用缺失值填充。

df1 = pd.read_csv('data/Employee1.csv')
df2 = pd.read_csv('data/Employee2.csv')
df1['重複'] = ['Y_1' if df1.loc[i,'Name'] in L else 'N' for i in range(df1.shape[0])]
df2['重複'] = ['Y_2' if df2.loc[i,'Name'] in L else 'N' for i in range(df2.shape[0])]
df1 = df1.set_index(['Name','重複'])
df2 = df2.set_index(['Name','重複'])
df_c = pd.concat([df1,df2])
result = pd.DataFrame({'Company':[],'Name':[],'Age':[],'Height':[],'Weight':[],'Salary':[]})
group = df_c.groupby(['Company','重複'])
for i in L:
    first = group.get_group((i[0].upper(),'Y_1')).reset_index(level=1).loc[i,:][-4:]
    second = group.get_group((i[0].upper(),'Y_2')).reset_index(level=1).loc[i,:][-4:]
    mean = group.get_group((i[0].upper(),'N')).reset_index(level=1).mean()
    final = [i[0].upper(),i]
    for j in range(4):
        final.append(first[j] if abs(first[j]-mean[j])<abs(second[j]-mean[j]) else second[j])
    result = pd.concat([result,pd.DataFrame({result.columns.tolist()[k]:[final[k]] for k in range(6)})])
result = pd.concat([result.set_index('Name'),df_b])
for i in list('abcde'):
    for j in range(1,17):
        item = i+str(j)
        if item not in result.index:
            result = pd.concat([result,pd.DataFrame({'Company':[i.upper()],'Name':[item]
                 ,'Age':[np.nan],'Height':[np.nan],'Weight':[np.nan],'Salary':[np.nan]}).set_index('Name')])
result['Number'] = [int(i[1:]) for i in result.index]
result.reset_index().drop(columns='Name').set_index(['Company','Number']).sort_index()

		Age	Height	Weight	Salary
Company	Number
A	1	47.0	188.0	91.2	25819.0
	2	50.0	190.0	83.4	6673.0
	3	39.0	172.0	96.6	16503.0
	4	43.0	158.0	62.5	21755.0
	5	51.0	176.0	97.2	23294.0
...	...	...	...	...	...
E	12	54.0	157.0	79.4	18490.0
	13	57.0	180.0	54.8	26837.0
	14	39.0	163.0	83.0	20554.0
	15	NaN	NaN	NaN	NaN
	16	NaN	NaN	NaN	NaN

80 rows × 4 columns

【練習二】有2張課程的分數表（分數隨機生成），但專業課（學科基礎課、專業必修課、專業選修課）與其他課程混在一起，請解決如下問題：

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

	課程名字	課程類別	學分	分數
0	思想道德修養與法律基礎	思政類	3	89.0
1	雲計算應用與開發	專業選修課	3	96.0
2	社會計算	專業選修課	3	78.0
3	深度學習	專業選修課	3	75.0
4	人工智能導論	專業必修課	3	84.0

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

	課程名字	課程類別	學分	分數
0	高等數學（一）	學科基礎課	4	99.0
1	數據科學與工程導論	學科基礎課	3	NaN
2	專業英語	學科基礎課	2	100.0
3	概率論	學科基礎課	3	99.0
4	計算機系統	專業必修課	4	80.0

(a) 將兩張表分別拆分爲專業課與非專業課（結果爲四張表）。

df1 = pd.read_csv('data/Course1.csv')
df2 = pd.read_csv('data/Course2.csv')
df_a11,df_a12,df_a21,df_a22 =0,0,0,0
df_a11= df1.query('課程類別 in ["學科基礎課","專業必修課","專業選修課"]')
df_a12= df1.query('課程類別 not in ["學科基礎課","專業必修課","專業選修課"]')
df_a21= df2.query('課程類別 in ["學科基礎課","專業必修課","專業選修課"]')
df_a22= df2.query('課程類別 not in ["學科基礎課","專業必修課","專業選修課"]')
df_a11.head()

(b) 將兩張專業課的分數表和兩張非專業課的分數表分別合併。

special = pd.concat([df_a11,df_a21])
common = pd.concat([df_a12,df_a22])
special.query('課程類別 not in ["學科基礎課","專業必修課","專業選修課"]')

common.query('課程類別 in ["學科基礎課","專業必修課","專業選修課"]')

df = pd.concat([df1,df2])
special2 = df.query('課程類別 in ["學科基礎課","專業必修課","專業選修課"]')
common2 = df.query('課程類別 not in ["學科基礎課","專業必修課","專業選修課"]')
(special.equals(special2),common.equals(common2))

(d) 專業課程中有缺失值嗎，如果有的話請在完成(3)的同時，用組內（3種類型的專業課）均值填充缺失值後拆分。

df['分數'] = df.groupby('課程類別').transform(lambda x: x.fillna(x.mean()))['分數']
df.isnull().all()

special3 = df.query('課程類別 in ["學科基礎課","專業必修課","專業選修課"]')
common3 = df.query('課程類別 not in ["學科基礎課","專業必修課","專業選修課"]')
common3.head()

	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

	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

	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

	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

	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

	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章 合併

第5章 合併

一、append與assign

1. append方法

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

（b）用DataFrame添加表

2. assign方法

該方法主要用於添加列，列名直接由參數指定：

可以一次添加多個列：

二、combine與update

1. comine方法

comine和update都是用於表的填充函數，可以根據某種規則填充

（a）填充對象

可以看出combine方法是按照表的順序輪流進行逐列循環的，而且自動索引對齊，缺失值爲NaN，理解這一點很重要

首先腦子裏先生成一張新表df3，它的行列爲df1和df2的並集，然後將原來的df1和df2的大小擴充到df3，缺失值爲NaN，然後對df1和df2同時逐列進行func參數的規則操作（就是寫的lambda那個地方），然後按照返回值進行每一列的更新。

（b）一些例子

例①：根據列均值的大小填充

例②：索引對齊特性（默認狀態下，後面的表沒有的行列都會設置爲NaN）

例③：使得df1原來符合條件的值不會被覆蓋

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

（c）combine_first方法

這個方法作用是用df2填補df1的缺失值，功能比較簡單，但很多時候會比combine更常用，下面舉兩個例子：

2. update方法

（a）三個特點

①返回的框索引只會與被調用框的一致（默認使用左連接，下一節會介紹）

②第二個框中的nan元素不會起作用

③沒有返回值，直接在df上操作

（b）例子

例①：索引完全對齊情況下的操作

例②：部分填充

例③：缺失值不會填充

三、concat方法

concat方法可以在兩個維度上拼接，默認縱向憑藉（axis=0），拼接方式默認外連接

所謂外連接，就是取拼接方向的並集，而’inner’時取拼接方向（若使用默認的縱向拼接，則爲列的交集）的交集

下面舉一些例子說明其參數：

默認狀態拼接：

axis=1時沿列方向拼接：

join設置爲內連接（由於axis=0，因此列取交集）：

join設置爲外鏈接：

verify_integrity檢查列是否唯一：

同樣，可以添加Series：

key參數用於對不同的數據框增加一個標號，便於索引：

四、merge與join

1. merge函數

merge函數的作用是將兩個pandas對象橫向合併，遇到重複的索引項時會使用笛卡爾積，默認inner連接，可選left、outer、right連接

所謂左連接，就是指以第一個表索引爲基準，右邊的表中如果不再左邊的則不加入，如果在左邊的就以笛卡爾積的方式加入

merge/join與concat的不同之處在於on參數，可以指定某一個對象爲key來進行連接

同樣的，下面舉一些例子：

以key1爲準則連接，如果具有相同的列，則默認suffixes=(’_x’,’_y’)：

以多組鍵連接：

默認使用inner連接，因爲merge只能橫向拼接，所以取行向上keys的交集，下面看如果使用how=outer參數

注意：這裏的how就是concat的join

左連接：

右連接：

如果還是對笛卡爾積不太瞭解，請務必理解下面這個例子，由於B的所有元素爲2，因此需要6行：

validate檢驗的是到底哪一邊出現了重複索引，如果是“one_to_one”則兩側索引都是唯一，如果"one_to_many"則左側唯一

indicator參數指示了，合併後該行索引的來源

2. join函數

join函數作用是將多個pandas對象橫向拼接，遇到重複的索引項時會使用笛卡爾積，默認左連接，可選inner、outer、right連接

對於many_to_one模式下的合併，往往join更爲方便

同樣可以指定key：

多層key：

五、問題與練習

1. 問題

【問題一】 請思考什麼是append/assign/combine/update/concat/merge/join各自最適合使用的場景，並舉出相應的例子。

【問題二】 merge_ordered和merge_asof的作用是什麼？和merge是什麼關係？

【問題三】 請構造一個多級索引與多級索引合併的例子，嘗試使用不同的合併函數。

【問題四】 上文提到了連接的笛卡爾積，那麼當連接方式變化時（inner/outer/left/right），這種笛卡爾積規則會相應變化嗎？請構造相應例子。

2. 練習

【練習一】有2張公司的員工信息表，每個公司共有16名員工，共有五個公司，請解決如下問題：

(a) 每個公司有多少員工滿足如下條件：既出現第一張表，又出現在第二張表。

(b) 將所有不符合(a)中條件的行篩選出來，合併爲一張新表，列名與原表一致。

(a) 每個公司有多少員工滿足如下條件：既出現第一張表，又出現在第二張表。

(b) 將所有不符合(a)中條件的行篩選出來，合併爲一張新表，列名與原表一致。

【練習二】有2張課程的分數表（分數隨機生成），但專業課（學科基礎課、專業必修課、專業選修課）與其他課程混在一起，請解決如下問題：

(a) 將兩張表分別拆分爲專業課與非專業課（結果爲四張表）。

(b) 將兩張專業課的分數表和兩張非專業課的分數表分別合併。

© 不使用(a)中的步驟，請直接讀取兩張表合併後拆分。

(d) 專業課程中有缺失值嗎，如果有的話請在完成(3)的同時，用組內（3種類型的專業課）均值填充缺失值後拆分。

第5章合併

第5章合併

【問題一】請思考什麼是append/assign/combine/update/concat/merge/join各自最適合使用的場景，並舉出相應的例子。

【問題三】請構造一個多級索引與多級索引合併的例子，嘗試使用不同的合併函數。

【問題四】上文提到了連接的笛卡爾積，那麼當連接方式變化時（inner/outer/left/right），這種笛卡爾積規則會相應變化嗎？請構造相應例子。

	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

	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

	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