pandas中DataFrame的修改元素值、缺失值处理、合并操作的方法
2024-05-05 15:51:08
实验目的
熟练掌握pandas中DataFrame的修改元素值、缺失值处理、合并操作的方法
实验原理
concat合并：
pd.concat(objs, axis=0, join=‘outer’, join_axes=None, ignore_index=False,
keys=None, levels=None, names=None, verify_integrity=False)
参数：
objs: series，dataframe或者是panel构成的序列lsit。
axis： 需要合并链接的轴，0是行，1是列，默认为axis=0。
join：连接的方式 inner，或者outer，默认为join=‘outer’
keys：合并的同时增加分区。
ignore_index：忽略索引，默认为False，当为True时，合并的两表就按列字段对齐。
merge合并：
pandas的merge方法提供了一种类似于SQL的内存链接操作，官网文档提到它的性能会比其他开源语言的数据操作（例如R）要高效。
pd.merge(left, right, how=‘inner’, on=None, left_on=None, right_on=None,
left_index=False, right_index=False, sort=True,
suffixes=(’_x’, ‘_y’), copy=True, indicator=False,validate=None)
merge的参数：
left/right：两个不同的DataFrame
on：指的是用于连接的列索引名称。必须存在右右两个DataFrame对象中，如果没有指定且其他参数也未指定则以两个DataFrame的列名交集做为连接键
left_on：左则DataFrame中用作连接键的列名;这个参数中左右列名不相同，但代表的含义相同时非常有用。right_on：右则DataFrame中用作 连接键的列名。
left_index：使用左则DataFrame中的行索引做为连接键。
right_index：使用右则DataFrame中的行索引做为连接键。
how：指的是合并(连接)的方式有inner(内连接),left(左外连接),right(右外连接),outer(全外连接);默认为inner。
sort：根据DataFrame合并的keys按字典顺序排序，默认是True，如果置false可以提高表现。
suffixes：字符串值组成的元组，用于指定当左右DataFrame存在相同列名时在列名后面附加的后缀名称，默认为(’_x’,’_y’)
copy：默认为True,总是将数据复制到数据结构中；大多数情况下设置为False可以提高性能
indicator：在 0.17.0中还增加了一个显示合并数据中来源情况；如只来自于左边(left_only)、两者(both)。
merge的默认合并方法：merge用于表内部基于 index-on-index 和 index-on-column(s) 的合并，但默认是基于index来合并。
join连接：主要用于索引上的合并
join(self, other, on=None, how=‘left’, lsuffix=’’, rsuffix=’’,sort=False)
其中参数的意义与merge方法基本相同,只是join方法默认为左外连接how=left
1.默认按索引合并，可以合并相同或相似的索引，不管他们有没有重叠列。
2.可以连接多个DataFrame
3.可以连接除索引外的其他列
4.连接方式用参数how控制
5.通过lsuffix=’’, rsuffix=’’ 区分相同列名的列
实验环境
Python 3.6.1
Jupyter
实验内容
练习pandas中DataFrame的修改元素值、缺失值处理、合并操作。
代码部分：
import numpy as np
import pandas as pd
1.修改数据
1) 通过字典对象创建一个DataFrame。
dates = pd.date_range('20130101', periods=6)
dates
DatetimeIndex(['2013-01-01', '2013-01-02', '2013-01-03', '2013-01-04','2013-01-05', '2013-01-06'],dtype='datetime64[ns]', freq='D')
df = pd.DataFrame(np.random.randn(6,4), index=dates, columns=list('ABCD'))
df
| A | B | C | D | |
|---|---|---|---|---|
| 2013-01-01 | 0.896387 | -0.983990 | -0.633715 | 0.224435 |
| 2013-01-02 | 0.173375 | -0.220575 | -1.010174 | 0.494923 |
| 2013-01-03 | 0.579714 | 0.303940 | 2.790600 | 0.302989 |
| 2013-01-04 | -1.684962 | -0.788070 | -0.265911 | -0.907506 |
| 2013-01-05 | -0.108375 | -0.799685 | 2.212832 | 1.557938 |
| 2013-01-06 | 0.396521 | -0.087139 | 0.056659 | 1.267565 |
2) .新建一个值为[1,2,3,4,5,6]，索引index为2013-01-02到2013-01-07的Series，并将series赋值给df作为df新增的F列
s1=pd.Series([1,2,3,4,5,6],index=pd.date_range('20130102',periods=6))
s1
2013-01-02 1
2013-01-03 2
2013-01-04 3
2013-01-05 4
2013-01-06 5
2013-01-07 6
Freq: D, dtype: int64
df['F']=s1
df
| A | B | C | D | F | |
|---|---|---|---|---|---|
| 2013-01-01 | 0.896387 | -0.983990 | -0.633715 | 0.224435 | NaN |
| 2013-01-02 | 0.173375 | -0.220575 | -1.010174 | 0.494923 | 1.0 |
| 2013-01-03 | 0.579714 | 0.303940 | 2.790600 | 0.302989 | 2.0 |
| 2013-01-04 | -1.684962 | -0.788070 | -0.265911 | -0.907506 | 3.0 |
| 2013-01-05 | -0.108375 | -0.799685 | 2.212832 | 1.557938 | 4.0 |
| 2013-01-06 | 0.396521 | -0.087139 | 0.056659 | 1.267565 | 5.0 |
3) 通过at方法把满足df中dates[0],列A的值修改为0
df.at[dates[0],'A']=0
df
| A | B | C | D | F | |
|---|---|---|---|---|---|
| 2013-01-01 | 0.000000 | -0.983990 | -0.633715 | 0.224435 | NaN |
| 2013-01-02 | 0.173375 | -0.220575 | -1.010174 | 0.494923 | 1.0 |
| 2013-01-03 | 0.579714 | 0.303940 | 2.790600 | 0.302989 | 2.0 |
| 2013-01-04 | -1.684962 | -0.788070 | -0.265911 | -0.907506 | 3.0 |
| 2013-01-05 | -0.108375 | -0.799685 | 2.212832 | 1.557938 | 4.0 |
| 2013-01-06 | 0.396521 | -0.087139 | 0.056659 | 1.267565 | 5.0 |
4) 使用iat方法修改df中行下标为0，列下标为1的值等于0
df.iat[0,1]=0
df
| A | B | C | D | F | |
|---|---|---|---|---|---|
| 2013-01-01 | 0.000000 | 0.000000 | -0.633715 | 0.224435 | NaN |
| 2013-01-02 | 0.173375 | -0.220575 | -1.010174 | 0.494923 | 1.0 |
| 2013-01-03 | 0.579714 | 0.303940 | 2.790600 | 0.302989 | 2.0 |
| 2013-01-04 | -1.684962 | -0.788070 | -0.265911 | -0.907506 | 3.0 |
| 2013-01-05 | -0.108375 | -0.799685 | 2.212832 | 1.557938 | 4.0 |
| 2013-01-06 | 0.396521 | -0.087139 | 0.056659 | 1.267565 | 5.0 |
5) 使用loc方法把df的D列值修改为5*len(df)
df.loc[:,'D']=np.array([5]*len(df))
df
| A | B | C | D | F | |
|---|---|---|---|---|---|
| 2013-01-01 | 0.000000 | 0.000000 | -0.633715 | 5 | NaN |
| 2013-01-02 | 0.173375 | -0.220575 | -1.010174 | 5 | 1.0 |
| 2013-01-03 | 0.579714 | 0.303940 | 2.790600 | 5 | 2.0 |
| 2013-01-04 | -1.684962 | -0.788070 | -0.265911 | 5 | 3.0 |
| 2013-01-05 | -0.108375 | -0.799685 | 2.212832 | 5 | 4.0 |
| 2013-01-06 | 0.396521 | -0.087139 | 0.056659 | 5 | 5.0 |
6) 使用copy方法将df赋值给df2,使用where语句将df2中满足df2>0条件的值修改为-df2。
df2=df.copy()
df2
| A | B | C | D | F | |
|---|---|---|---|---|---|
| 2013-01-01 | 0.000000 | 0.000000 | -0.633715 | 5 | NaN |
| 2013-01-02 | 0.173375 | -0.220575 | -1.010174 | 5 | 1.0 |
| 2013-01-03 | 0.579714 | 0.303940 | 2.790600 | 5 | 2.0 |
| 2013-01-04 | -1.684962 | -0.788070 | -0.265911 | 5 | 3.0 |
| 2013-01-05 | -0.108375 | -0.799685 | 2.212832 | 5 | 4.0 |
| 2013-01-06 | 0.396521 | -0.087139 | 0.056659 | 5 | 5.0 |
df2[df2>0]=-df2
df2
| A | B | C | D | F | |
|---|---|---|---|---|---|
| 2013-01-01 | 0.000000 | 0.000000 | -0.633715 | -5 | NaN |
| 2013-01-02 | -0.173375 | -0.220575 | -1.010174 | -5 | -1.0 |
| 2013-01-03 | -0.579714 | -0.303940 | -2.790600 | -5 | -2.0 |
| 2013-01-04 | -1.684962 | -0.788070 | -0.265911 | -5 | -3.0 |
| 2013-01-05 | -0.108375 | -0.799685 | -2.212832 | -5 | -4.0 |
| 2013-01-06 | -0.396521 | -0.087139 | -0.056659 | -5 | -5.0 |
2.缺失值
1）使用reindex方法将df的行列索引同时重新索引，使行index=date[0:4]，列索引culumns=list(df.columns+[‘E’])，并返回一个新的数据帧df1，然后使用loc方法将df1中行索引为dates[0]和dates[1]，列为“E"的值修改为1。
df1=df.reindex(index=dates[0:4],columns=list(df.columns)+['E'])
df1
| A | B | C | D | F | E | |
|---|---|---|---|---|---|---|
| 2013-01-01 | 0.000000 | 0.000000 | -0.633715 | 5 | NaN | NaN |
| 2013-01-02 | 0.173375 | -0.220575 | -1.010174 | 5 | 1.0 | NaN |
| 2013-01-03 | 0.579714 | 0.303940 | 2.790600 | 5 | 2.0 | NaN |
| 2013-01-04 | -1.684962 | -0.788070 | -0.265911 | 5 | 3.0 | NaN |
df1.loc[dates[0]:dates[1],'E']=1
df1
| A | B | C | D | F | E | |
|---|---|---|---|---|---|---|
| 2013-01-01 | 0.000000 | 0.000000 | -0.633715 | 5 | NaN | 1.0 |
| 2013-01-02 | 0.173375 | -0.220575 | -1.010174 | 5 | 1.0 | 1.0 |
| 2013-01-03 | 0.579714 | 0.303940 | 2.790600 | 5 | 2.0 | NaN |
| 2013-01-04 | -1.684962 | -0.788070 | -0.265911 | 5 | 3.0 | NaN |
2) 使用dropna方法删除df1中任何包含缺失值的行。
df1.dropna(how='any')
| A | B | C | D | F | E | |
|---|---|---|---|---|---|---|
| 2013-01-02 | 0.173375 | -0.220575 | -1.010174 | 5 | 1.0 | 1.0 |
3) 使用fillna方法，将df1中所有的缺失值用5填充
df1
| A | B | C | D | F | E | |
|---|---|---|---|---|---|---|
| 2013-01-01 | 0.000000 | 0.000000 | -0.633715 | 5 | NaN | 1.0 |
| 2013-01-02 | 0.173375 | -0.220575 | -1.010174 | 5 | 1.0 | 1.0 |
| 2013-01-03 | 0.579714 | 0.303940 | 2.790600 | 5 | 2.0 | NaN |
| 2013-01-04 | -1.684962 | -0.788070 | -0.265911 | 5 | 3.0 | NaN |
df1.fillna(value=5)
| A | B | C | D | F | E | |
|---|---|---|---|---|---|---|
| 2013-01-01 | 0.000000 | 0.000000 | -0.633715 | 5 | 5.0 | 1.0 |
| 2013-01-02 | 0.173375 | -0.220575 | -1.010174 | 5 | 1.0 | 1.0 |
| 2013-01-03 | 0.579714 | 0.303940 | 2.790600 | 5 | 2.0 | 5.0 |
| 2013-01-04 | -1.684962 | -0.788070 | -0.265911 | 5 | 3.0 | 5.0 |
4) 使用isnull方法判断df1中的值是否为缺失值，是缺失值返回True，否则返回False，返回一个由布尔值组成的数据帧
pd.isnull(df1)
| A | B | C | D | F | E | |
|---|---|---|---|---|---|---|
| 2013-01-01 | False | False | False | False | True | False |
| 2013-01-02 | False | False | False | False | False | False |
| 2013-01-03 | False | False | False | False | False | True |
| 2013-01-04 | False | False | False | False | False | True |
5) 使用notnull判断df1中的值是否为缺失值，返回一个由布尔值组成的数据帧
pd.notnull(df1)
| A | B | C | D | F | E | |
|---|---|---|---|---|---|---|
| 2013-01-01 | True | True | True | True | False | True |
| 2013-01-02 | True | True | True | True | True | True |
| 2013-01-03 | True | True | True | True | True | False |
| 2013-01-04 | True | True | True | True | True | False |
3.合并
1）使用concat进行合并
（1）创建数据帧df1、df2、df3，使用concat函数将df1\df2\df3进行合并
df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'], 'B': ['B0', 'B1', 'B2', 'B3'],'C': ['C0', 'C1', 'C2', 'C3'],'D': ['D0', 'D1', 'D2', 'D3']},index=[0, 1, 2, 3])
df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],'B': ['B4', 'B5', 'B6', 'B7'],'C': ['C4', 'C5', 'C6', 'C7'],'D': ['D4', 'D5', 'D6', 'D7']},index=[4, 5, 6, 7])
df3 = pd.DataFrame({'A': ['A8', 'A9', 'A10', 'A11'],'B': ['B8', 'B9', 'B10', 'B11'],'C': ['C8', 'C9', 'C10', 'C11'],'D': ['D8', 'D9', 'D10', 'D11']},index=[8, 9, 10, 11])
df1
| A | B | C | D | |
|---|---|---|---|---|
| 0 | A0 | B0 | C0 | D0 |
| 1 | A1 | B1 | C1 | D1 |
| 2 | A2 | B2 | C2 | D2 |
| 3 | A3 | B3 | C3 | D3 |
df2
| A | B | C | D | |
|---|---|---|---|---|
| 4 | A4 | B4 | C4 | D4 |
| 5 | A5 | B5 | C5 | D5 |
| 6 | A6 | B6 | C6 | D6 |
| 7 | A7 | B7 | C7 | D7 |
df3
| A | B | C | D | |
|---|---|---|---|---|
| 8 | A8 | B8 | C8 | D8 |
| 9 | A9 | B9 | C9 | D9 |
| 10 | A10 | B10 | C10 | D10 |
| 11 | A11 | B11 | C11 | D11 |
result = pd.concat([df1,df2,df3])
result
| A | B | C | D | |
|---|---|---|---|---|
| 0 | A0 | B0 | C0 | D0 |
| 1 | A1 | B1 | C1 | D1 |
| 2 | A2 | B2 | C2 | D2 |
| 3 | A3 | B3 | C3 | D3 |
| 4 | A4 | B4 | C4 | D4 |
| 5 | A5 | B5 | C5 | D5 |
| 6 | A6 | B6 | C6 | D6 |
| 7 | A7 | B7 | C7 | D7 |
| 8 | A8 | B8 | C8 | D8 |
| 9 | A9 | B9 | C9 | D9 |
| 10 | A10 | B10 | C10 | D10 |
| 11 | A11 | B11 | C11 | D11 |
print('df1:\n',df1,'\ndf2:\n',df2,'\ndf3:\n','\nresult:\n',result)
df1:A B C D
0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3 A3 B3 C3 D3
df2:A B C D
4 A4 B4 C4 D4
5 A5 B5 C5 D5
6 A6 B6 C6 D6
7 A7 B7 C7 D7
df3:result:A B C D
0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3 A3 B3 C3 D3
4 A4 B4 C4 D4
5 A5 B5 C5 D5
6 A6 B6 C6 D6
7 A7 B7 C7 D7
8 A8 B8 C8 D8
9 A9 B9 C9 D9
10 A10 B10 C10 D10
11 A11 B11 C11 D11
(2)将df1,df2,df3进行合并，并将合并后的数据帧进行分区为keys=[‘x’,‘y’,‘z’]
result1 = pd.concat([df1,df2,df3], keys=['x', 'y', 'z'])
print(result1)
A B C D
x 0 A0 B0 C0 D01 A1 B1 C1 D12 A2 B2 C2 D23 A3 B3 C3 D3
y 4 A4 B4 C4 D45 A5 B5 C5 D56 A6 B6 C6 D67 A7 B7 C7 D7
z 8 A8 B8 C8 D89 A9 B9 C9 D910 A10 B10 C10 D1011 A11 B11 C11 D11
(3)新建一个数据帧df4，将df1与df4进行列项合并，axis=1。
df4 = pd.DataFrame({'B': ['B2', 'B3', 'B6', 'B7'],'D': ['D2', 'D3', 'D6', 'D7'],'F': ['F2', 'F3', 'F6', 'F7']},index=[2, 3, 6, 7])
df4
| B | D | F | |
|---|---|---|---|
| 2 | B2 | D2 | F2 |
| 3 | B3 | D3 | F3 |
| 6 | B6 | D6 | F6 |
| 7 | B7 | D7 | F7 |
result2=pd.concat([df1,df4],axis=1)
print(result2)
A B C D B D F
0 A0 B0 C0 D0 NaN NaN NaN
1 A1 B1 C1 D1 NaN NaN NaN
2 A2 B2 C2 D2 B2 D2 F2
3 A3 B3 C3 D3 B3 D3 F3
6 NaN NaN NaN NaN B6 D6 F6
7 NaN NaN NaN NaN B7 D7 F7
(4)df1与df4进行列项合并axis=1，合并方式为内部合并join=‘inner’
result3=pd.concat([df1,df4],axis=1,join='inner')
print(result3)
A B C D B D F
2 A2 B2 C2 D2 B2 D2 F2
3 A3 B3 C3 D3 B3 D3 F3
(5)将df1与df4进行列项合并axis=1，结果只保留合并后df1索引的行join_axes=[df1.index]。
df1.index
Int64Index([0, 1, 2, 3], dtype='int64')
result4 = pd.concat([df1,df4],axis=1)
print(result4)
---------------------------------------------------------------------------ValueError Traceback (most recent call last)<ipython-input-41-b69245b6f21a> in <module>
----> 1 result4 = pd.concat([df1,df4],axis=1,join=[df1.index])2 print(result4)C:\ProgramData\Anaconda3\lib\site-packages\pandas\core\reshape\concat.py in concat(objs, axis, join, ignore_index, keys, levels, names, verify_integrity, sort, copy)272 ValueError: Indexes have overlapping values: ['a']273 """
--> 274 op = _Concatenator(275 objs,276 axis=axis,C:\ProgramData\Anaconda3\lib\site-packages\pandas\core\reshape\concat.py in __init__(self, objs, axis, join, keys, levels, names, ignore_index, verify_integrity, copy, sort)317 self.intersect = True318 else: # pragma: no cover
--> 319 raise ValueError(320 "Only can inner (intersect) or outer (union) join the other axis"321 )ValueError: Only can inner (intersect) or outer (union) join the other axis
(6)将df1与df4合并，忽略行索引ignore_index=True
result5=pd.concat([df1,df4],ignore_index=True)
print(result5)
A B C D F
0 A0 B0 C0 D0 NaN
1 A1 B1 C1 D1 NaN
2 A2 B2 C2 D2 NaN
3 A3 B3 C3 D3 NaN
4 NaN B2 NaN D2 F2
5 NaN B3 NaN D3 F3
6 NaN B6 NaN D6 F6
7 NaN B7 NaN D7 F7
(7)创建一个名为s1的Series值为[‘X0’, ‘X1’, ‘X2’, ‘X3’]，name=‘X’，将df1与s1进行列项合并。
s1=pd.Series(['X0', 'X1', 'X2', 'X3'],name='X')
result6=pd.concat([df1,s1],axis=1)
print(result6)
A B C D X
0 A0 B0 C0 D0 X0
1 A1 B1 C1 D1 X1
2 A2 B2 C2 D2 X2
3 A3 B3 C3 D3 X3
(8)将df1与s1进行列项合并，忽略索引 ignore_index=True。
result=pd.concat([df1,s1],axis=1,ignore_index=True)
print(df1,s1,result)
A B C D
0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3 A3 B3 C3 D3 0 X0
1 X1
2 X2
3 X3
Name: X, dtype: object 0 1 2 3 4
0 A0 B0 C0 D0 X0
1 A1 B1 C1 D1 X1
2 A2 B2 C2 D2 X2
3 A3 B3 C3 D3 X3
(9)创建三个Series分别为s2,s3,s4，将三个Series进行合并，使用keys=[‘red’,‘blue’,‘yellow’]对合并后数据帧的列改名。
s2 = pd.Series([0, 1, 2, 3], name='foo')
s3 = pd.Series([0, 1, 2, 3])
s4 = pd.Series([0, 1, 4, 5])
pd.concat([s2,s3,s4],axis=1,keys=['red','blue','yellow'])
| red | blue | yellow | |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 1 | 1 | 1 | 1 |
| 2 | 2 | 2 | 4 |
| 3 | 3 | 3 | 5 |
(10)将df1,df2,df3,作为值，x,y,z作为键构建名为pieces的字典，然后对pieces使用concat进行合并，并令参数keys=[‘z’,‘y’]
pieces={'x':df1,'y':df2,'z':df3}
result = pd.concat(pieces, keys=['z', 'y'])
pieces
{'x': A B C D0 A0 B0 C0 D01 A1 B1 C1 D12 A2 B2 C2 D23 A3 B3 C3 D3,'y': A B C D4 A4 B4 C4 D45 A5 B5 C5 D56 A6 B6 C6 D67 A7 B7 C7 D7,'z': A B C D8 A8 B8 C8 D89 A9 B9 C9 D910 A10 B10 C10 D1011 A11 B11 C11 D11}
result
| A | B | C | D | ||
|---|---|---|---|---|---|
| z | 8 | A8 | B8 | C8 | D8 |
| 9 | A9 | B9 | C9 | D9 | |
| 10 | A10 | B10 | C10 | D10 | |
| 11 | A11 | B11 | C11 | D11 | |
| y | 4 | A4 | B4 | C4 | D4 |
| 5 | A5 | B5 | C5 | D5 | |
| 6 | A6 | B6 | C6 | D6 | |
| 7 | A7 | B7 | C7 | D7 |
2)使用append进行合并
(1)使用append方法将df1与df2合并。
df1.append(df2)
| A | B | C | D | |
|---|---|---|---|---|
| 0 | A0 | B0 | C0 | D0 |
| 1 | A1 | B1 | C1 | D1 |
| 2 | A2 | B2 | C2 | D2 |
| 3 | A3 | B3 | C3 | D3 |
| 4 | A4 | B4 | C4 | D4 |
| 5 | A5 | B5 | C5 | D5 |
| 6 | A6 | B6 | C6 | D6 |
| 7 | A7 | B7 | C7 | D7 |
(2)使用append方法将df1与df4合并
df1.append(df4)
| A | B | C | D | F | |
|---|---|---|---|---|---|
| 0 | A0 | B0 | C0 | D0 | NaN |
| 1 | A1 | B1 | C1 | D1 | NaN |
| 2 | A2 | B2 | C2 | D2 | NaN |
| 3 | A3 | B3 | C3 | D3 | NaN |
| 2 | NaN | B2 | NaN | D2 | F2 |
| 3 | NaN | B3 | NaN | D3 | F3 |
| 6 | NaN | B6 | NaN | D6 | F6 |
| 7 | NaN | B7 | NaN | D7 | F7 |
(3)使用append方法将df1与df2、df3合并。
df1.append([df2,df3])
| A | B | C | D | |
|---|---|---|---|---|
| 0 | A0 | B0 | C0 | D0 |
| 1 | A1 | B1 | C1 | D1 |
| 2 | A2 | B2 | C2 | D2 |
| 3 | A3 | B3 | C3 | D3 |
| 4 | A4 | B4 | C4 | D4 |
| 5 | A5 | B5 | C5 | D5 |
| 6 | A6 | B6 | C6 | D6 |
| 7 | A7 | B7 | C7 | D7 |
| 8 | A8 | B8 | C8 | D8 |
| 9 | A9 | B9 | C9 | D9 |
| 10 | A10 | B10 | C10 | D10 |
| 11 | A11 | B11 | C11 | D11 |
(4)将df1与df4进行合并，忽略索引ignore_index=True
result=df1.append(df4,ignore_index=True)
result
| A | B | C | D | F | |
|---|---|---|---|---|---|
| 0 | A0 | B0 | C0 | D0 | NaN |
| 1 | A1 | B1 | C1 | D1 | NaN |
| 2 | A2 | B2 | C2 | D2 | NaN |
| 3 | A3 | B3 | C3 | D3 | NaN |
| 4 | NaN | B2 | NaN | D2 | F2 |
| 5 | NaN | B3 | NaN | D3 | F3 |
| 6 | NaN | B6 | NaN | D6 | F6 |
| 7 | NaN | B7 | NaN | D7 | F7 |
3) 使用merge进行合并
(1)创建两个数据帧left、right，使用merge函数按key列将left与right进行连接。
left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],'A': ['A0', 'A1', 'A2', 'A3'], 'B': ['B0', 'B1', 'B2', 'B3']})
right = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],'C': ['C0', 'C1', 'C2', 'C3'], 'D': ['D0', 'D1', 'D2', 'D3']})
result = pd.merge(left, right, on='key')
print( left,right,result)
key A B
0 K0 A0 B0
1 K1 A1 B1
2 K2 A2 B2
3 K3 A3 B3 key C D
0 K0 C0 D0
1 K1 C1 D1
2 K2 C2 D2
3 K3 C3 D3 key A B C D
0 K0 A0 B0 C0 D0
1 K1 A1 B1 C1 D1
2 K2 A2 B2 C2 D2
3 K3 A3 B3 C3 D3
复合key的合并方法，使用merge的时候可以选择多个key作为复合可以来对齐合并。
(2)创建两个数据帧left、right，使用merge函数按[key1，key2]列将left与right进行连接。
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']})
result = pd.merge(left, right, on=['key1', 'key2'])
print( left,right,result)
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)使用merge函数按[key1，key2]列将left与right进行左表连接
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']})
result = pd.merge(left, right, how='left', on=['key1', 'key2'])
print( left,right,result)
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
(4)使用merge函数按[key1，key2]列将left与right进行右表连接
result = pd.merge(left, right, how='right', on=['key1', 'key2'])
print(result)
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
(5)使用merge函数按[key1，key2]列将left与right进行外表连接
result = pd.merge(left, right, how='outer', on=['key1', 'key2'])
print(result)
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
(6)使用merge函数按key1，key2列将left与right进行内表连接。
result = pd.merge(left, right, how='inner', on=['key1', 'key2'])
print(result)
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
(7)创建两个都只有A、B两列的数据帧left,right，使用merge函数按B列将left与right进行外表连接，可以看到除连接列B以外的列名相同时，会在列名后加上区分的后缀。
left = pd.DataFrame({'A' : [1,2], 'B' : [2, 2]})
right = pd.DataFrame({'A' : [4,5,6], 'B': [2,2,2]})
result = pd.merge(left, right, on='B', how='outer')
print(result)
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
(8)创建两个数据帧df1、df2，使用merge函数按col1列将df1与df2进行外表连接，并使用参数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)
| 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 |
4) 使用join进行连接
(1)创建两个数据帧left、right，使用join方法将left与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'])
result = left.join(right)
print(left,'\n',right,'\n',result)
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
(2)使用join方法将left与right进行外表连接
result = left.join(right, how='outer')
print(left,'\n',right,'\n',result)
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
K3 NaN NaN C3 D3
(3)使用join方法将left与right进行内表连接。
result = left.join(right, how='inner')
print(left,'\n',right,'\n',result)
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
K2 A2 B2 C2 D2
(4)使用merge函数按左右表索引将left与right进行外表连接
result = pd.merge(left, right, left_index=True, right_index=True, how='outer')
print(left,'\n',right,'\n',result)
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
K3 NaN NaN C3 D3
(5)创建两个数据帧left、right，使用join方法按key列将left与right连接
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'])
result = left.join(right, on='key')
print(left,'\n',right,'\n',result)
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
result = pd.merge(left, right, left_on='key', right_index=True,how='left', sort=False)
print(left,'\n',right,'\n',result)
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
pandas中DataFrame的修改元素值、缺失值处理、合并操作的方法相关推荐
- Python之pandas：对pandas中dataframe数据中的索引输出、修改、重命名等详细攻略
Python之pandas:对pandas中dataframe数据中的索引输出.修改.重命名等详细攻略 目录 对pandas中dataframe数据中的索引输出.修改.重命名等详细攻略 知识点学习 输 ...
- pandas计算dataframe两列数据值相等的行号、取出DataFrame中两列值相等的行号
pandas计算dataframe两列数据值相等的行号.取出DataFrame中两列值相等的行号 目录 pandas计算dataframe两列数据值相等的行号.取出DataFrame中两列值相等的行号
- python查看dataframe数据类型_python pandas中DataFrame类型数据操作函数的方法
python数据分析工具pandas中DataFrame和Series作为主要的数据结构. 本文主要是介绍如何对DataFrame数据进行操作并结合一个实例测试操作函数. 1)查看DataFrame数 ...
- python column stack_Python基础 | pandas中dataframe的整合与形变(merge reshape)
[toc] 本文示例数据下载,密码:vwy3 import pandas as pd # 数据是之前在cnblog上抓取的部分文章信息 df = pd.read_csv('./data/SQL测试用数 ...
- python科学计算笔记（九）pandas中DataFrame数据操作函数
Python数据分析工具pandas中DataFrame和Series作为主要的数据结构. 本文主要是介绍如何对DataFrame数据进行操作并结合一个实例测试操作函数. 1)查看DataFrame数 ...
- python dataframe函数_python pandas中DataFrame类型数据操作函数的方法
这篇文章主要介绍了关于python pandas中DataFrame类型数据操作函数的方法,有着一定的参考价值,现在分享给大家,有需要的朋友可以参考一下 python数据分析工具pandas中Data ...
- Pandas中DataFrame基本函数整理（全）
[python]Pandas中DataFrame基本函数整理(全) 构造函数 DataFrame([data, index, columns, dtype, copy]) #构造数据框 属性和数据 D ...
- Python—pandas中DataFrame类型数据操作函数
python数据分析工具pandas中DataFrame和Series作为主要的数据结构. 本文主要是介绍如何对DataFrame数据进行操作并结合一个实例测试操作函数. 1)查看DataFram ...
- python字符串替换空格_python - 用pandas中的NaN替换空白值（空格）
python - 用pandas中的NaN替换空白值(空格) 我想在Pandas数据帧中找到包含空格(任意数量)的所有值,并用NaN替换这些值. 有什么想法可以改进吗? 基本上我想转此: A B C ...
- pandas中DataFrame的ix，loc，iloc索引方式的异同
pandas中DataFrame的ix,loc,iloc索引方式的异同 1.loc: 按照标签索引,范围包括start和end 2.iloc: 在位置上进行索引,不包括end 3.ix: 先在inde ...
最新文章
- jupyter分割代码块_科研分享—Python根据关键词自动抓取Pubmed文献标题（附全部代码）文末有福利...
- Linux的关机命令和重启命令
- Leetcode 141.环形链表
- ArcObjects中的几何对象简介(一)
- git添加user及repository
- 万用表怎么测量电池容量_如何使用万用表，使用万用表测量常用的六个方面
- java调c++代码_Java中调用C++代码的实现 | 学步园
- php class使用方法,php的类使用方法问题
- c语言中的*和运算符*,C语言中的运算和运算符
- 理解T-SQL: 触发器
- java 获取物理路径_JSP---jsp页面获取物理路径
- 【行业专题报告】 汽车、二手车-专题资料
- 小巧的KML文件生成工具KML Generator
- 乖离率背离公式_掌握这“八大底部买入形态+主力抄底逃顶选股公式”，把握底部起涨点...
- 【Python爬虫实战】使用Selenium爬取QQ音乐歌曲及评论信息
- python中θ符号怎么打出来_怎么打特殊符号
- 滴滴云服务器快速配置搭建滴滴云GPU云服务器搭建深度学习环境
- SpringBoot使用分布式锁
- IT管理类培训，你想了解的全都在这里
- 彻底搞懂java程序的初始化顺序
热门文章
- DOS命令行使用pscp实现远程文件和文件夹传输(转)
- 大叔手记（2）：为每个应用程序池单独设置aspnet.config配置文件
- Silverlight开发中的疑难杂症-控件设计篇-如何实现一个NumericBox（下）
- [转帖]成功者的十四项心理定律
- 20200815每日一句
- 20191205每日一句
- 传智播客Java 关键字，标识符，注释
- unity 0 Asset Store ，package如何快速导入，快捷键
- Atitit 数据类型体系图 目录 1. 系统常用的数据类型 1 2. H5 form表单新数据类型 2 2.1. TML5 新的 Input 类型 2 2.2. HTML5 的新的表单元素： 2
- Atitit 互联网技术公司防爆指南技术规范标准流程 30个危险物品