python dataframe 修改单元值 dataframe修改元素值

转载

mob64ca1416b5a8 2023-12-25 13:44:39

实验目的

熟练掌握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   D0
  1    A1   B1   C1   D1
  2    A2   B2   C2   D2
  3    A3   B3   C3   D3
y 4    A4   B4   C4   D4
  5    A5   B5   C5   D5
  6    A6   B6   C6   D6
  7    A7   B7   C7   D7
z 8    A8   B8   C8   D8
  9    A9   B9   C9   D9
  10  A10  B10  C10  D10
  11  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 = True
    318         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   D
 0  A0  B0  C0  D0
 1  A1  B1  C1  D1
 2  A2  B2  C2  D2
 3  A3  B3  C3  D3,
 'y':     A   B   C   D
 4  A4  B4  C4  D4
 5  A5  B5  C5  D5
 6  A6  B6  C6  D6
 7  A7  B7  C7  D7,
 'z':       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

		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

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：hadoop 认证文件 hadoop集群认证

下一篇：flask echarts 天气数据分析 python天气数据分析论文背景

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯

	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

		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

	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

	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

	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

	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

	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

		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

	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

	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

	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

	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