P5

知知知…

1. append方法

① 利用 Series 添加表

s = pd.Series({'Gender':'F','Height':188},name='new_row')
df.append(s)

②利用 DataFrame 添加表

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

2. assign方法

① 主要用于在表中添加列，列名可直接由参数指定（利用 Series 添加）

s = pd.Series(list('abcd'),index=range(4))
df.assign(Name=s)  # Name 可指定

②可添加多个列

s = pd.Series(list('abcd'))
s1 = pd.Series(list('efgh'))
df_append.assign(col1=s,col2=s1) # 一次性添加两个列，列名分别为 col1 与 col2

3. comine 方法

先来看看 comine 函数的参数

combine(other, func, fill_value=None, overwrite=True) 其中

① other ： DataFrame，要按列合并的DataFrame。

②func ： 功能，将两个系列作为输入并返回一个Series或一个标量的函数。用于逐列合并两个数据帧。（使用 func 将 DataFrame 与其他 DataFrame 组合到按元素组合的列。生成的 DataFrame 的行索引和列索引将是两者的并集。）注意：func 是一定要传入的，且可以匿名函数

③fill_value ： 标量值，默认None，在将任何列传递给合并函数之前填充NaN的值。

④overwrite ： boolean，默认为True，如果为true，列自我不存在在其他将与NaN的覆盖。

相比较而言comine 方法 有点复制，更多的时候，常用 combine_first方法

4. combine_first 方法

这个方法作用是用df2填补df1的缺失值

df1 = pd.DataFrame({'A': [NaN, 0], 'B': [NaN, 4]})
df2 = pd.DataFrame({'A': [1, 1], 'B': [3, 3]})
print(df1.combine_first(df2))
'''
     A    B
0  1.0  3.0
1  0.0  4.0
'''

5. update方法

①该方法会直接在df上操作，而且用于更新的框 中的 缺失值 元素不会起作用，默认该位不更新。即保存原来的元素

df1 = pd.DataFrame({'A': [1, 2, 3],
                    'B': [400, 500, 600]})
df2 = pd.DataFrame({'B': [4, 5, 6]})
df1.update(df2)
print(df1)  # 在 df1 上直接操作
'''
   A  B
0  1  4
1  2  5
2  3  6
'''

② 不在被更新框中的列 不会被更新

df1 = pd.DataFrame({'A': [1, 2, 3],
                    'B': [4, 5, 6]})
df2 = pd.DataFrame({'C': [7, 8, 9]})
df1.update(df2)
print(df1)  #  df2 中的 C 列在 df1 中不存在
'''
   A  B
0  1  4
1  2  5
2  3  6
'''

③ 更新框中的列 可以通过控制索引值或 NaN 来实现部分填充

df1 = pd.DataFrame({'A': [1, 2, 3],
                    'B': [400, 500, 600]})
df2 = pd.DataFrame({'B': [4, 5, 6]}, index=range(1,4)) # 控制索引为 1 2 3 而不是从 0 开始
df1.update(df2)
print(df1)
'''
   A      B
0  1  400.0
1  2    4.0
2  3    5.0
'''

df1 = pd.DataFrame({'A': [1, 2, 3],
                    'B': [400, 500, 600]})
df2 = pd.DataFrame({'B': [4, NaN, 6]})  # 利用NaN实现部分填充
df1.update(df2)
print(df1)
'''
   A      B
0  1    4.0
1  2  500.0
2  3    6.0
'''

6. concat 方法

① concat方法可以在两个维度上拼接，默认 axis=0，实现的是纵向的行拼接
设置 axis=1 时，可实现横向的列拼接

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

print(pd.concat([df1, df2])) # 默认 axis=0 纵向行拼接
'''
    A   B
0  A0  B0
1  A1  B1
2  A2  B2
3  A3  B3
'''
 
print(pd.concat([df1, df2], axis=1)) # 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=‘outer’）外连接, 而设置 join=‘inner’ 时 取拼接方向的交集

print(pd.concat([df1, df2], join='inner')) 
'''
    A   B
0  A0  B0
1  A1  B1
2  A2  B2
3  A3  B3
'''

7. merge 方法

① merge是pandas中用来合并数据的函数，不像concat是按照某行或某列来合并，而是按照数据中具体的某一字段（或者说是某个series，或多个series）来连接数据。

on表示按照那个特征来找相同的字段，且要左表和右表用来对齐的那一列都有相同的列名

例子一：

df1 = pd.DataFrame({'姓名': ["小明","小红","小刚"],
                   '年纪': [10, 9, 12],
                   '城市': ['上海', '北京', '深圳']})
print(df1)
'''
   姓名  年纪  城市
0  小明  10  上海
1  小红   9  北京
2  小刚  12  深圳
'''

df2 = pd.DataFrame({'零花钱': [50, 200, 600, 400, 80],
                   '城市': ['苏州', '北京', '上海', '广州', '重庆']})

print(df2)
'''
   零花钱  城市
0   50  苏州
1  200  北京
2  600  上海
3  400  广州
4   80  重庆
'''

print(pd.merge(df1, df2, on='城市'))  # 以城市 这列找相同的字段 组成新的 表
'''
   姓名  年纪  城市  零花钱
0  小明  10  上海  600
1  小红   9  北京  200
'''
# 其中 城市 的左边可称为左表，右边称为右表

例子二：

df1 = pd.DataFrame({'姓名': ["小明","小红","小刚"],
                   '年纪': [10, 9, 12],
                   '城市': ['上海', '北京', '深圳']})

df2 = pd.DataFrame({'姓名': ["小杨", "小欢", "小明", "小红", "小刚"],
                   '零花钱': [50, 200, 600, 400, 80],
                   '城市': ['苏州', '北京', '上海', '广州', '重庆']})
print(pd.merge(df1, df2, on=['姓名', '城市'])) # 以两个列为要求 寻找相同字段
'''
   姓名  年纪  城市  零花钱
0  小明  10  上海  600
'''

② 其他参数

• how = ‘outer’:外置，相当于两个DateFrame求并集
• how = ‘right’:右置，合并后，按照最右边不为空的样本显示
• how = ‘left’：左置，合并后，按照最左边不为空的样本显示
• how = ‘inner’：只显示匹配到的字段的样本

8. join 函数

① join函数作用是将多个pandas对象横向拼接，遇到重复的索引项时会使用笛卡尔积，默认左连接，以左边的框为主

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'])
print(left.join(right))  # 以 left 的 index 为基准，在 right 中的 index 进行寻找匹配，然后重组数据
'''
     A   B    C    D
K0  A0  B0   C0   D0
K1  A1  B1  NaN  NaN
K2  A2  B2   C2   D2
'''

② 同样地 用 on 参数指定key，也支持多层 key

本文地址：https://blog.csdn.net/weixin_51503843/article/details/110490785