pandas笔记二（数据连接、合并、分组和聚合函数）

数据连接和合并

总结差别：

• 1、当没有索引时：merge、join为按照一定条件合并
• 2、当有索引、并按照索引合并时，得到结果为两者混合到一起了，重新按照一定规则排序了。
• 3、当没有索引时、concat不管列名，直接加到一起，可以加到后面、也可以加到右边，axis=0为加到后面，axis=1为加到右边，左边的数据结构没有变，变的是右边数据结构。
• 4、当有索引、并按照索引合并时，得到结果两者混合到一起了。

数据连接 merge

def merge(left, right, how='inner', on=None, left_on=None, right_on=None,
          left_index=False, right_index=False, sort=False,
          suffixes=('_x', '_y'), copy=True, indicator=False,
          validate=None)

参数	说明
left与right	两个不同的DataFrame
how	指的是合并(连接)的方式有inner(内连接),left(左外连接),right(右外连接),outer(全外连接);默认为inner，连接时没有就以NaN填充
on	指的是用于连接的列索引名称。必须存在左右两个DataFrame对象中，如果没有指定且其他参数也未指定则以两个DataFrame的列名交集做为连接键
left_on	左则DataFrame中用作连接键的列名;这个参数中左右列名不相同，但代表的含义相同时非常有用。
right_on	右则DataFrame中用作 连接键的列名
left_index	使用左则DataFrame中的行索引做为连接键
right_index	使用右则DataFrame中的行索引做为连接键
sort	默认为True，将合并的数据进行排序。在大多数情况下设置为False可以提高性能
suffixes	字符串值组成的元组，用于指定当左右DataFrame存在相同列名时在列名后面附加的后缀名称，默认为(’_x’,’_y’)
copy	默认为True,总是将数据复制到数据结构中；大多数情况下设置为False可以提高性能
indicator	在 0.17.0中还增加了一个显示合并数据中来源情况；如只来自己于左边(left_only)、两者(both)

df1 = pd.DataFrame(
    {'key1':list('abcdefgh'),
     'data1':np.random.randint(-5,10,8)}
)

df2 = pd.DataFrame(
    {'key2':list('abcde'),
     'data2':np.random.randint(-5,10,5)}
)
# 两表合并 根据on参数相同的值合并，如果不指定默认根据相同的列合并
# print(pd.merge(df1,df2, on='key', suffixes=['左表', '右表']))  # suffixes指定后缀
# 如果两张表没有相同的列的时候，可以通过left_on和right_on来指定连接条件（列）
print(pd.merge(df1,df2, left_on='key1', right_on='key2'))
# 参数how默认是inner也就是内联,如果outer就是并集，没有就以NaN填充
print(pd.merge(df1,df2, left_on='key1', right_on='key2', how='outer'))
# 左连接和右连接，意思是以左为准或者是以右为准
print('#####################')
print(pd.merge(df1,df2, left_on='key1', right_on='key2', how='left'))
print(pd.merge(df1,df2, left_on='key1', right_on='key2', how='right'))

# 行索引
print(pd.merge(df1,df2, left_on='data1', right_index=True))

数据连接 join

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=’’ 区分相同列名的列

数据合并 numpy.concatenate()

这个比较简单:

def concatenate(arrays, axis=None, out=None):

• arrays参数是指可迭代对象，可以是元组或列表
• axis=0默认按照列合并，axis=1按照行合并，None是直接合并成一行

数据合并 pd.concat() (这个是重点)

def concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,
           keys=None, levels=None, names=None, verify_integrity=False,
           sort=None, copy=True):

参数	说明
objs	要合并的对象，可迭代对象元组或列表都可
axis	默认为0按照列索引合并，为1时按照行索引合并
join	默认为outer也就是并集，inner为交集
sort	默认为True，设为False减少消耗，pandas0.24版本会提示
join_axes=[]	指定自定义索引。
keys=[]	创建层次化索引
ignore_index=True	重建索引。

df1 = pd.DataFrame(
    {'key1':list('abcdefgh'),
     'data1':np.random.randint(-5,10,8)}
)

df2 = pd.DataFrame(
    {'key2':list('abcde'),
     'data1':np.random.randint(-5,10,5)}
)
print(pd.concat([df1,df2], sort=False))

分组 groupby

0.24版本之后pandas.groupby()方法已经删除了，所以直接使用对象的groupby方法即可

def groupby(self, by=None, axis=0, level=None, as_index=True, sort=True,
                group_keys=True, squeeze=False, observed=False, **kwargs):

• df.groupby()分组之后返回分组对象

df1 = pd.DataFrame(
    {'key1':list('11223344'),
     'data1':np.random.randint(-5,10,8),
     'data2':np.random.randint(0,10,8),}
)

# print(pd.DataFrame.groupby())
print(df1.groupby('key1'))  # 分组之后返回分组对象
gr_obj = df1.groupby('key1')
# 可以用函数进一步处理，计算过程中非数字的数据不参与计算
print(gr_obj.sum())

分组之后的数据展示

• 当迭代分组对象时，每一个元素由分组名和数据组成，数据是dataframe对象

for name,data in group_obj:
    print('#############')
    print(name)
    print(data)

• 可以转成列表或字典查看

print(list(group_obj))
print(dict(list(group_obj)))

展示：

[('1',   key1  data1  data2
0    1     -2      7
1    1     -5      8), ('2',   key1  data1  data2
2    2      0      5
3    2     -2      2), ('3',   key1  data1  data2
4    3      3      5
5    3     -2      7), ('4',   key1  data1  data2
6    4      3      1
7    4     -5      4)]
{'1':   key1  data1  data2
0    1     -2      7
1    1     -5      8, '2':   key1  data1  data2
2    2      0      5
3    2     -2      2, '3':   key1  data1  data2
4    3      3      5
5    3     -2      7, '4':   key1  data1  data2
6    4      3      1
7    4     -5      4}

分组之后的聚合函数

• 内置的聚合函数：就是对分组之后的对象进行处理，计算过程中非数字的数据不参与计算
• sum()求和，mean()求均值，size()是每组的大小，count()是列索引下计数的多少
• describe()描述，结果如下

     data1                                 ...     data2                         
     count mean       std  min   25%  50%  ...       std  min  25%  50%  75%  max
key1                                       ...                                   
1      2.0  2.5  4.949747 -1.0  0.75  2.5  ...  4.242641  1.0  2.5  4.0  5.5  7.0
2      2.0  4.5  0.707107  4.0  4.25  4.5  ...  2.828427  5.0  6.0  7.0  8.0  9.0
3      2.0  2.0  7.071068 -3.0 -0.50  2.0  ...  4.242641  0.0  1.5  3.0  4.5  6.0
4      2.0 -0.5  6.363961 -5.0 -2.75 -0.5  ...  2.828427  3.0  4.0  5.0  6.0  7.0

[4 rows x 16 columns]

transform()函数

• transform函数执行后还是按原始的索引结构返回

# 按key2索引
print(group_ky2.sum())
# 是按原始的行索引结构运算
print(group_ky2.transform('sum').add_prefix('key2_sum_'))

agg()自定义函数做聚合运算

• 这个也可以使用内置函数，用字符串(多个用列表)填充就行了比如group_obj.agg([‘max’, ‘min’])求最大值，最小值
• 给函数取别名需要一个元组，别名放在前group_obj.agg([(‘最大值’, ‘max’), ‘min’])

# 使用内置函数并取别名
print(group_obj.agg([('最大值', 'max'), 'min']))

输出：

     data1     data2    
       最大值 最小值   最大值 最小值
key1                    
1        6  -3     8   6
2        8   3     5   3
3        2   1     4   2
4       -2  -3     7   7

• 使用自定义的函数,取别名也是一样

def max_min(df_obj):
	# 参数是dataframe对象
    return df_obj.max()-df_obj.min()

def mean_func(df_obj):
    return df_obj.mean()
# 简单的自定义函数
print(group_obj.agg([('最大差值', max_min),('均值', mean_func)]))

• 使用匿名函数：group_obj.agg(lambda x:x.max()-x.min())
• 对指定列进行聚合函数运算，取别名也一样

print(group_obj.agg(lambda x:x.max()-x.min()))
# 对指定列进行聚合函数运算，取别名也一样
print(group_obj.agg({'data1': [('最大值', 'max')], 'data2': 'min'}))