Pandas联合与合并数据集

包含在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

merge函数我参数

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

concat函数参数

关于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

发布了40 篇原创文章 · 获赞 0 · 访问量 1531

猜你喜欢

转载自blog.csdn.net/zhoumoon/article/details/104860289
今日推荐