欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

Pandas联合与合并数据集

程序员文章站 2022-06-05 19:32:04
...

包含在pandas对象的数据可以通过多种方式联合在一起:

  • pandas.merge根据一个或多个键将行进行连接。对于SQL或其他关系型数据库的用户来说,这种方式比较熟悉,它实现的是数据库的连接操作。
  • pandas.concat使对象在轴向上进行黏合或“堆叠”。
  • combine_first实例方法允许将重叠的数据拼接在一起,以使用一个对象中的值填充另一个对象中的缺失值。我会介绍上面几种方法,并给出一些例子。这些例子将会用在本书的后续内容中。

数据库风格的DataFrame连接

合并或连接操作通过一个或多个键连接行来联合数据集。这些操作是关系型数据库的核心内容(例如基于SQL的数据库)。pandas中的merge函数主要用于将各种join操作算法运用在你的数据上:

import pandas as pd
df1 = pd.DataFrame({'key':['b','b','a','c','a','a','b'],'data1': range(7)})
  key  data1
0   b      0
1   b      1
2   a      2
3   c      3
4   a      4
5   a      5
6   b      6
df2 = pd. DataFrame({'key': ['a','b','d'],'data2': range(3)})
  key  data2
0   a      0
1   b      1
2   d      2

这是一个多对一连接的例子;df1的数据有多个行的标签为a和b,而df2在key列中每个值仅有一行。调用merge处理我们获得的对象:

pd.merge(df1,df2)
  key  data1  data2
0   b      0      1
1   b      1      1
2   b      6      1
3   a      2      0
4   a      4      0
5   a      5      0

请注意,我并没有指定在哪一列上进行连接。如果连接的键信息没有指定,merge会自动将重叠列名作为连接的键。但是,显式地指定连接键才是好的实现:

pd.merge(df1,df2,on='key')
  key  data1  data2
0   b      0      1
1   b      1      1
2   b      6      1
3   a      2      0
4   a      4      0
5   a      5      0

如果每个对象的列名是不同的,你可以分别为它们指定列名:

df1 = pd.DataFrame({'lkey':['b','b','a','c','a','a','b'],'data1': range(7)})
df2 = pd. DataFrame({'rkey': ['a','b','d'],'data2': range(3)})
  lkey  data1
0    b      0
1    b      1
2    a      2
3    c      3
4    a      4
5    a      5
6    b      6

  rkey  data2
0    a      0
1    b      1
2    d      2
pd.merge(df1,df2,left_on='lkey',right_on='rkey')
  lkey  data1 rkey  data2
0    b      0    b      1
1    b      1    b      1
2    b      6    b      1
3    a      2    a      0
4    a      4    a      0
5    a      5    a      0

你可能注意到结果中缺少’c’和’d’的值以及相关的数据。默认情况下,merge做的是内连接(‘inner’join),结果中的键是两张表的交集。其他可选的选项有’left’、‘right’和’outer’。外连接(outerjoin)是键的并集,联合了左连接和右连接的效果:
内连接(inner)

pd.merge(df1,df2,left_on='lkey',right_on='rkey',how='inner')
与
pd.merge(df1,df2,left_on='lkey',right_on='rkey')
是一样的
  lkey  data1 rkey  data2
0    b      0    b      1
1    b      1    b      1
2    b      6    b      1
3    a      2    a      0
4    a      4    a      0
5    a      5    a      0

左连接(left)

pd.merge(df1,df2,left_on='lkey',right_on='rkey',how='left')
  lkey  data1 rkey  data2
0    b      0    b    1.0
1    b      1    b    1.0
2    a      2    a    0.0
3    c      3  NaN    NaN
4    a      4    a    0.0
5    a      5    a    0.0
6    b      6    b    1.0

右连接(right)

pd.merge(df1,df2,left_on='lkey',right_on='rkey',how='right')
  lkey  data1 rkey  data2
0    b    0.0    b      1
1    b    1.0    b      1
2    b    6.0    b      1
3    a    2.0    a      0
4    a    4.0    a      0
5    a    5.0    a      0
6  NaN    NaN    d      2

外连接(outer)

pd.merge(df1,df2,left_on='lkey',right_on='rkey',how='outer')
  lkey  data1 rkey  data2
0    b    0.0    b    1.0
1    b    1.0    b    1.0
2    b    6.0    b    1.0
3    a    2.0    a    0.0
4    a    4.0    a    0.0
5    a    5.0    a    0.0
6    c    3.0  NaN    NaN
7  NaN    NaN    d    2.0

对how参数的不同连接类型的总结:

选项 行为
inner 只对两张表都有的键的交集进行联合
left 对所有左表的键进行联合
right 对所有右表的键进行联合
outer 对两张表都有的键的并集进行联合

尽管不是很直观,但多对多的合并有明确的行为。下面这个例子更能说明上面的情况。

df1 = pd.DataFrame({'key':['b','b','a','c','a','a','b'],'data1': range(7)})
df2 = pd. DataFrame({'key': ['a','b','d'],'data2': range(3)})

out: df1

  key  data1
0   b      0
1   b      1
2   a      2
3   c      3
4   a      4
5   a      5
6   b      6

out: df2

  key  data2
0   a      0
1   b      1
2   d      2
pd.merge(df1,df2,on=['key'],how='left')
  key  data1  data2
0   b      0    1.0
1   b      1    1.0
2   a      2    0.0
3   c      3    NaN
4   a      4    0.0
5   a      5    0.0
6   b      6    1.0
pd.merge(df1,df2,on=['key'],how='right')
  key  data1  data2
0   b    0.0      1
1   b    1.0      1
2   b    6.0      1
3   a    2.0      0
4   a    4.0      0
5   a    5.0      0
6   d    NaN      2
pd.merge(df1,df2,on=['key'],how='inner')
  key  data1  data2
0   b      0      1
1   b      1      1
2   b      6      1
3   a      2      0
4   a      4      0
5   a      5      0
pd.merge(df1,df2,on=['key'],how='outer')
  key  data1  data2
0   b    0.0    1.0
1   b    1.0    1.0
2   b    6.0    1.0
3   a    2.0    0.0
4   a    4.0    0.0
5   a    5.0    0.0
6   c    3.0    NaN
7   d    NaN    2.0

Pandas联合与合并数据集

concat 从DataFrame选择某几列合并计算std

默认情况下,concat方法是沿着axis=0的轴向生效的,生成另一个Series。如果你传递axis=1,返回的结果则是一个DataFrame(axis=1时是列)

dataframe转化成array
df=df.values
array转化成dataframe
import pandas as pd , df = pd.DataFrame(df)

import pandas as pd
import numpy as np

c = np.random.random([2,9])  # 随机生成2行9列的矩阵数据
print(c)
df = pd.DataFrame(c)  # 将array转化成dataframe
print(df)
result = pd.concat([df[0],df[8]],axis=1)  # 选取某几列合并数据,计算std
print(result)
print(result.std())

out: df

          0         1         2  ...         6         7         8
0  0.849008  0.338971  0.411677  ...  0.384588  0.142539  0.324748
1  0.723320  0.643253  0.260974  ...  0.420826  0.563649  0.229707
[2 rows x 9 columns]

out: result

          0         8
0  0.849008  0.324748
1  0.723320  0.229707

out: result.std()

0    0.088875
8    0.067204

Pandas联合与合并数据集

关于numpy和pandas中std()函数的区别

要想正常计算pandas的std,需要建ddof设置为0即可;pandas的ddof默认为1;

print("计算全局标准差:\n",result.std(ddof=0)) 
print("计算全局标准差:\n",np.std(result))
print("dataframe转化成array:\n",result.values)
print("计算每一列的标准差:\n",np.std(result.values,axis=0))
print("计算每一行的标准差:\n",np.std(result.values,axis=1))

参考

https://blog.csdn.net/chixujohnny/article/details/68059992
https://blog.csdn.net/u011587322/article/details/80934096