Pandas学习笔记5——合并

在这里插入图片描述
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
1 A1 B1
y 2 A2 B2
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
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

参考内容

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

你可能感兴趣的:(Python学习笔记,python,人工智能,数据分析)