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

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

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