精华内容
下载资源
问答
  • 使用GROUP BY 时候需要注意的地方

    千次阅读 2017-08-04 14:21:53
    使用EXPLAIN 可以看到执行计划,看到Extra列中有Using filesort,这是对性能有一定影响的,特别是使用group by时,就算你没有显示的指定order by,mysql会默认按照分组字段进行排序。某些情况下是没有必要使用排序...

    在开发过程中常常会遇到sql 进行分组的业务,笔者在编码过程中就犯了这样一个低级错误,还好项目经理及时指出来了,避免了以后的问题,给大家分享一下。

    使用EXPLAIN 可以看到执行计划,看到Extra列中有Using filesort,这是对性能有一定影响的,特别是使用了group by时,就算你没有显示的指定order by,mysql会默认按照分组字段进行排序。某些情况下是没有必要使用排序的,这个 filesort 并不是说通过磁盘文件进行排序,而只是告诉我们进行了一个排序操作而已。

    这里写图片描述

    则完全可以可以使用order by null来取消排序

    这里写图片描述

    展开全文
  • pandas之分组groupby()的使用整理与总结

    万次阅读 多人点赞 2019-07-27 18:41:53
    使用pandas的时候,有些场景需要对数据内部进行分组处理,如一组全校学生成绩的数据,我们想通过班级进行分组,或者再对班级分组后的性别进行分组来进行分析,这时通过pandas下的groupby()函数就可以解决。在使用...

    前言

    在使用pandas的时候,有些场景需要对数据内部进行分组处理,如一组全校学生成绩的数据,我们想通过班级进行分组,或者再对班级分组后的性别进行分组来进行分析,这时通过pandas下的groupby()函数就可以解决。在使用pandas进行数据分析时,groupby()函数将会是一个数据分析辅助的利器。
    groupby的作用可以参考 超好用的 pandas 之 groupby 中作者的插图进行直观的理解:
    在这里插入图片描述

    准备

    读入的数据是一段学生信息的数据,下面将以这个数据为例进行整理grouby()函数的使用:

    import pandas as pd
    import numpy as np
    import matplotlib.pyplot as plt
    
    df = pd.read_csv('./data.csv')
    print(df)
    
          Name  Gender  Age  Score
    0     Alen    Male   18     80
    1      Bob    Male   19     90
    2     Cidy  Female   18     93
    3   Daniel    Male   20     87
    4    Ellen  Female   17     96
    5  Frankie    Male   21    100
    6     Gate    Male   20     88
    7     Hebe  Female   22     98
    

    基本操作

    在进行对groupby函数进行学习之前,首先需要明确的是,通过对DataFrame对象调用groupby()函数返回的结果是一个DataFrameGroupBy对象,而不是一个DataFrame或者Series对象,所以,它们中的一些方法或者函数是无法直接调用的,需要按照GroupBy对象中具有的函数和方法进行调用。

    grouped = df.groupby('Gender')
    print(type(grouped))
    print(grouped)
    
    <class 'pandas.core.groupby.groupby.DataFrameGroupBy'>
    
    

    分组时,不仅仅可以指定一个列名,也可以指定多个列名:

    grouped = df.groupby('Gender')
    grouped_muti = df.groupby(['Gender', 'Age'])
    
    print(grouped.size())
    print(grouped_muti.size())
    
    Gender
    Female    3
    Male      5
    dtype: int64
    
    Gender  Age
    Female  17     1
            18     1
            22     1
    Male    18     1
            19     1
            20     2
            21     1
    dtype: int64
    

    指定多个列名个单个列名后的区别在于,分组的主键或者索引(indice)将一个是单个主键,另一个则是一个元组的形式:

    print(grouped.get_group('Female'))
    print(grouped_muti.get_group(('Female', 17)))
    
        Name  Gender  Age  Score
    2   Cidy  Female   18     93
    4  Ellen  Female   17     96
    7   Hebe  Female   22     98
        Name  Gender  Age  Score
    4  Ellen  Female   17     96
    

    通过调用get_group()函数可以返回一个按照分组得到的DataFrame对象,所以接下来的使用就可以按照·DataFrame·对象来使用。如果想让这个DataFrame对象的索引重新定义可以通过:

    df = grouped.get_group('Female').reset_index()
    print(df)
    
       index   Name  Gender  Age  Score
    0      2   Cidy  Female   18     93
    1      4  Ellen  Female   17     96
    2      7   Hebe  Female   22     98
    

    这里可以总结一下,由于通过groupby()函数分组得到的是一个DataFrameGroupBy对象,而通过对这个对象调用get_group(),返回的则是一个·DataFrame·对象,所以可以将DataFrameGroupBy对象理解为是多个DataFrame组成的。
    而没有调用get_group()函数之前,此时的数据结构任然是DataFrameGroupBy,此时进行对DataFrameGroupBy按照列名进行索引,同理就可以得到SeriesGroupBy对象,取多个列名,则得到的任然是DataFrameGroupBy对象,这里可以类比DataFrameSeries的关系。

    按照上面的思路理解后,再调用get_group()函数后得到的DataFrame对象按照列名进行索引实际上就是得到了Series的对象,下面的操作就可以按照Series对象中的函数行了。

    在没有进行调用get_group(),也就是没有取出特定某一组数据之前,此时的数据结构任然是DataFrameGroupBy,其中也有很多函数和方法可以调用,如max()count()std()等,返回的结果是一个DataFrame对象。

    print(grouped.count())
    print(grouped.max()[['Age', 'Score']])
    print(grouped.mean()[['Age', 'Score']])
    
            Name  Age  Score
    Gender                  
    Female     3    3      3
    Male       5    5      5
            Age  Score
    Gender            
    Female   22     98
    Male     21    100
             Age      Score
    Gender                 
    Female  19.0  95.666667
    Male    19.6  89.000000
    

    如果其中的函数无法满足你的需求,你也可以选择使用聚合函数aggregate,传递numpy或者自定义的函数,前提是返回一个聚合值。

    def getSum(data):
        total = 0
        for d in data:
            total+=d
        return total
    
    
    print(grouped.aggregate(np.median))
    print(grouped.aggregate({'Age':np.median, 'Score':np.sum}))
    print(grouped.aggregate({'Age':getSum}))
    

    aggregate函数不同于apply,前者是对所有的数值进行一个聚合的操作,而后者则是对每个数值进行单独的一个操作:

    def addOne(data):
        return data + 1
    
    df['Age'] = df['Age'].apply(addOne)
    df['Age'] = df['Age'].apply(int)
    

    可视化操作

    对组内的数据绘制概率密度分布:

    grouped['Age'].plot(kind='kde', legend=True)
    plt.show()
    

    由于grouped['Age']是一个SeriesGroupby对象, 顾名思义, 就是每一个组都有一个Series. 所以直接plot相当于遍历了每一个组内的Age数据。

    REF

    groupby官方文档
    超好用的 pandas 之 groupby

    展开全文
  • 什么时候GROUP BY ---sql

    千次阅读 多人点赞 2018-09-14 01:56:15
    说的多怕你混,你就记住当SELECT 后 既有 表结构本身的字段,又有需要使用聚合函数(COUNT(),SUM(),MAX(),MIN(),AVG()等)的字段,就要用到group by分组,查询的限定条件里有需要用聚合函数计算的字段时也需要用分组...

    说的多怕你混,你就记住当SELECT 后 既有 表结构本身的字段,又有需要使用聚合函数(COUNT(),SUM(),MAX(),MIN(),AVG()等)的字段,就要用到group by分组,查询的限定条件里有需要用聚合函数计算的字段时也需要用分组,比如:
    select avg(grade) from cs
    查询选课表(cs)中学生的总成绩(grade);这里就不用分组;
    又如:
    select sno,sum(grade) from cs group by sno
    查询选课表里每个学生的总成绩,这里就要用分组,分组的依照字段必须是select 后没有被计算过的原始字段;
    以上是分组用法。

    本来我也弄不清,书上说的太模糊,后来自己代码写多了就懂了。
    分组的概念:就是让经过计算的查询结果根据某一个或者多个字段分成一组一组(一行一行)的排列显示。

    另外顺便介绍下,WHERE和HAVING的区别,WHERE作用于全表,而HAVING只作用于分组的组内。

    到现在我怎么用都不会混淆了,希望能帮助你

    展开全文
  • groupby函数详解

    万次阅读 多人点赞 2019-06-06 13:40:19
    pandas中groupby函数用法详解1 groupby()核心用法2 groupby()语法格式3 groupby()参数说明4 groupby()典型范例 1 groupby()核心用法 (1)根据DataFrame本身的某一列或多列内容进行分组聚合,(a)若按某一列聚合...

    计算各列数据总和并作为新列添加到末尾

    df['Col_sum'] = df.apply(lambda x: x.sum(), axis=1)
    

    计算指定列下每行数据的总和并作为新列添加到末尾

     df_sf['item_sum'] = df_sf.loc[:,['item_1','item_2','item_3']].apply(lambda x:x.sum(),axis=1)   #'item_sum'列计算'item_1','item_2','item_3'三列的总和
    

    计算各行数据总和并作为新行添加到末尾

    df.loc['Row_sum'] = df.apply(lambda x: x.sum())
    

    计算指定列下各行数据总和并作为新行添加到末尾

    MT_fs.loc['总计']=MT_fs.loc[:,['发货量','签收量','激活量','首充']].apply(lambda x: x.sum())  #“总计”表示新增行的“index”
    

    Table1 groupby()的常见用法

    函数适用场景备注
    df.groupby(‘key1’)一列聚合分组键为列名(可以是字符串、数字或其他Python对象)
    df.groupby([‘key1’,‘key2’])多列聚合分组键为列名引入列表list[]
    df[‘data1’].groupby(df[‘key1’]).mean()按某一列进行一重聚合求均值分组键为Series
    A=df[‘订单编号’].groupby([ df[‘运营商’], df[‘分类’], df[‘百度圣卡’] ]).count()按某一列进行多重聚合计数分组键为Series引入列表list[]
    df[‘data1’].groupby([states,years]).mean()分组键与原df无关,而是另外指定的任何长度适当的数组分组键是数组,state和year均为数组

    备注:

    grouped=df['data1'].groupby(df['key1'])    #聚合后不适用配合函数的输出为:<pandas.core.groupby.generic.SeriesGroupBy object at 0x000001FE3D1FE5C0>
    

    这是由于变量grouped是一个GroupBy对象,它实际上还没有进行任何计算,只是含有一些有关分组键df[‘key1’]的中间数据而已,然后我们可以调用配合函数(如:.mean()方法)来计算分组平均值等。
      因此,一般为方便起见可直接在聚合之后+“配合函数”,默认情况下,所有数值列都将会被聚合,虽然有时可能会被过滤为一个子集
      一般,如果对df直接聚合时,
    df.groupby([df['key1'],df['key2']]).mean()分组键为:Series)与df.groupby(['key1','key2']).mean()分组键为:列名)是等价的,输出结果相同。
      但是,如果对df的指定列进行聚合时,
    df['data1'].groupby(df['key1']).mean()分组键为:Series),唯一方式。
    此时,直接使用“列名”作分组键,提示“Error Key”。
       注意:分组键中的任何缺失值都会被排除在结果之外。

    1 groupby()核心用法

    (1)根据DataFrame本身的某一列或多列内容进行分组聚合,(a)若按某一列聚合,则新DataFrame将根据某一列的内容分为不同的维度进行拆解,同时将同一维度的再进行聚合,(b)若按某多列聚合,则新DataFrame将是多列之间维度的笛卡尔积,即:新DataFrame具有一个层次化索引(由唯一的键对组成),例如:“key1”列,有a和b两个维度,而“key2”有one和two两个维度,则按“key1”列和“key2”聚合之后,新DataFrame将有四个group;
    注意:groupby默认是在axis=0上进行分组的,通过设置axis=1,也可以在其他任何轴上进行分组。

    (2)groupby(),根据分组键的不同,有以下4种聚合方法:

    • 分组键为Series
      (a)使用原df的子列作为Series
      df.groupby([ df[‘key1’], df[‘key2’] ]).mean()
      (b)使用自定义的Series
      mapping={‘a’:‘red’,‘b’:‘red’,‘c’:‘blue’,‘d’:‘blue’,‘e’:‘red’,‘f’:‘orange’}
      map_series=pd.Series(mapping)
      people.groupby(map_series,axis=1).count()
    • 分组键为列名
      df.groupby([ ‘key1’,‘key2’ ]).mean()
    • 分组键为数组
      states=np.array([‘Ohio’, ‘California’, ‘California’, ‘Ohio’, ‘Ohio’])
      years=np.array([2004,2005,2006,2005,2006]) #自定义数组
      df[‘data1’].groupby( [ states,years ] ).mean()
    • 分组键为字典
      mapping={‘a’:‘red’,‘b’:‘red’,‘c’:‘blue’,‘d’:‘blue’,‘e’:‘red’,‘f’:‘orange’} #自定义字典
      by_column=people.groupby(mapping,axis=1).sum() #指定axis=1,表示对列数据进行聚合分组
    • 分组键为函数
      例如:传入len函数(可以求取一个字符串长度数组),实现根据字符串的长度进行分组
      people.groupby(len).sum() #将字符串长度相同的行进行求和
    • 分组键为函数和数组、列表、字典、Series的组合
      引入列表list[ ] 将函数跟数组、列表、字典、Series混合使用作为分组键进行聚合,因为任何东西最终都会被转换为数组
      key_list=[‘one’,‘one’,‘one’,‘two’,‘two’] #自定义列表,默认列表顺序和df的列顺序一致
      people.groupby([ len,key_list ]).min()
    • 分组键为具有多重列索引df 的列索引层次
      hier_df.groupby(level=‘cty’,axis=1).count() #利用参数level,指明聚合的层级
      (3)常用配合函数/方法
    1. 打印出按某一指定列进行聚合的DataFrame:
    for i in df.groupby('key1'):
        print(i)
    
    1. 按某一指定列进行聚合的DataFrame:

    Table1 groupby()的配合函数

    函数适用场景备注
    .mean()均值
    .count()计数
    .min()最小值
    .mean().unstack()求均值,聚合表的层次索引不堆叠
    .size()计算分组大小GroupBy的size方法,将返回一个含有分组大小的Series
    .apply()
    .agg()

    (4)对聚合后的数据片段,进行字典、列表等格式转化

    • 将数据片段转为字典
    pieces=pieces=dict(list(df.groupby('key1')))
    
    • 将数据片段转为列表
    pieces=list(df.groupby('key1'))
    

    (5)利用groupby,根据dtypes对列进行分组,此时需指定axis=1,否则,groupby默认根据axis=0进行分组,而行数据由于类型不统一,故无法根据dtypes对列进行分组,结果为空。
    (6)可使用一个/组列名,或者一个/组字符串数组对由DataFrame产生的GroupBy对象,进行索引,从而实现选取部分列进行聚合的目的即:

    1)根据key1键对data1列数据聚合
    df.groupby('key1')['data1'].mean()
    #或者
    df['data1'].groupby(df['key1']).mean()    #或者df['data1'].groupby([df['key1']]).mean() ,当按多个层次聚合时引入列表,故单层次用列表也无妨
    >>>
    key1
    a    -0.048502
    b     0.053162
    Name: data1, dtype: float64
    (2)根据key1键对data2列数据聚合
    df.groupby('key1')['data2'].mean()
    #或者
    df['data2'].groupby(df['key1']).mean()
    >>>
    key1
    a     -0.533444
    b     -0.948798
    Name: data2, dtype: float64
    (3)根据key1键对data2列数据聚合,当对多列数据如data1和data2根据某个键入key1聚合分组时,组引入列表['data1','data2'],此处对data2外加中括号是一个意思,只是影响输出格式。
    df.groupby('key1')[['data2']].mean()
    #或者df[['data2']].groupby(df['key1']).mean()
    >>>
    	 data2
    key1	
    a	-0.533444
    b	-0.9487984)根据key1键对data1和data2列数据聚合
    df.groupby('key1')[['data1','data2']].mean()
    #或者
    df[['data1','data2']].groupby(df['key1']).mean()
    >>>
    	   data1	data2
    key1		
    a	 -0.048502	-0.533444
    b	  0.053162	-0.9487985)根据多个键key1、key2对data2列数据聚合
    df.groupby(['key1','key2'])['data2'].mean()
    #或者
    df['data2'].groupby([df['key1'],df['key2']]).mean()
    >>>
    key1  key2
    a     one    -1.391653
          two     1.182974
    b     one    -1.707349
          two    -0.190247
    Name: data2, dtype: float64
    

    2 groupby()语法格式

    DataFrame.groupby(by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, observed=False, **kwargs)
    

    3 groupby()参数说明

    by : mapping, function, label, or list of labels
    Used to determine the groups for the groupby. If by is a function, it’s called on each value of the object’s index. If a dict or Series is passed, the Series or dict VALUES will be used to determine the groups (the Series’ values are first aligned; see .align() method). If an ndarray is passed, the values are used as-is determine the groups. A label or list of labels may be passed to group by the columns in self. Notice that a tuple is interpreted a (single) key.

    axis : {0 or ‘index’, 1 or ‘columns’}, default 0
    Split along rows (0) or columns (1).

    level : int, level name, or sequence of such, default None
    If the axis is a MultiIndex (hierarchical), group by a particular level or levels.

    as_index : bool, default True
    For aggregated output, return object with group labels as the index. Only relevant for DataFrame input. as_index=False is effectively “SQL-style” grouped output.

    sort : bool, default True
    Sort group keys. Get better performance by turning this off. Note this does not influence the order of observations within each group. Groupby preserves the order of rows within each group.

    group_keys : bool, default True
    When calling apply, add group keys to index to identify pieces.

    squeeze : bool, default False
    Reduce the dimensionality of the return type if possible, otherwise return a consistent type.

    observed : bool, default False
    This only applies if any of the groupers are Categoricals. If True: only show observed values for categorical groupers. If False: show all values for categorical groupers.

    New in version 0.23.0.

    **kwargs
    Optional, only accepts keyword argument ‘mutated’ and is passed to groupby.

    4 groupby()典型范例

    范例一:根据DataFrame本身的某一列或多列内容进行分组聚合

    #创建原始数据集
    import pandas as pd
    import numpy as np
    
    df=pd.DataFrame({'key1':['a','a','b','b','a'],
                     'key2':['one','two','one','two','one'],
                      'data1':np.random.randn(5),
                      'data2':np.random.randn(5)})
    #'key1':['a','a','b','b','a']亦可写作'key1':list('aabba'),完成列表的创建
    >>> df
       key1	 key2	    data1	  data2
    0	a	 one	  -0.484689	  -3.105627
    1	a	 two	  0.033929	  1.182974
    2	b	 one	  1.067201	  -1.707349
    3	b	 two	  -0.960876	  -0.190247
    4	a	 one	  0.305254	  0.322322
    #(1)按指定的某一列进行聚合
    for i in df.groupby('key1'):
        print(i)
    >>>
    ('a',   key1   key2     data1      data2
    0        a     one     -0.484689   -3.105627
    1        a     two     0.033929    1.182974
    4        a     one     0.305254    0.322322)
    ('b',   key1   key2     data1      data2
    2        b     one     1.067201    -1.707349
    3        b     two     -0.960876   -0.190247)
    #(2)按多列进行聚合,新的DataFrame是多列之间维度的笛卡尔积
    for i in df.groupby(['key1','key2']):
        print(i)
    >>>
    (('a', 'one'),   key1    key2     data1      data2
          0          a       one      -0.484689  -3.105627
          4          a       one      0.305254   0.322322)
    (('a', 'two'),   key1    key2     data1     data2
          1          a       two      0.033929   1.182974)
    (('b', 'one'),   key1    key2     data1     data2
          2          b       one      1.067201 -1.707349)
    (('b', 'two'),   key1   key2     data1     data2
          3          b       two      -0.960876 -0.190247)
    #(3) 按key1进行分组,并计算data1列的平均值
    df1=df['data1'].groupby(df['key1']).mean()
    >>>
    key1
    a       -0.048502
    b       0.053162
    #(4) 按key1、key2进行分组,并计算data1列的平均值,聚合表不堆叠
    #将数据从“花括号”格式转为“表格”格式,unstack即“不要堆叠”
    df2=df['data1'].groupby([df['key1'],df['key2']]).mean().unstack()
    >>>df2
    key2	one	        two
    key1		
    a	    -0.089718	 0.033929
    b	    1.067201	 -0.960876
    #(5)分组键可以是与原df无关的,另外指定的任何长度适当的数组,新数组按列表顺序分别与df[col_1]的数据一一对应。
    states=np.array(['Ohio', 'California', 'California', 'Ohio', 'Ohio'])
    years=np.array([2004,2005,2006,2005,2006])
    df['data1'].groupby([states,years]).mean()
    >>>
    California  2005    0.033929
                2006    1.067201
    Ohio        2004   -0.484689
                2005   -0.960876
                2006    0.305254
    #用到GroupBy的size方法,它可以返回一个含有分组大小的Series
    df.groupby(['key1','key2']).size()
    >>>
          key1  key2
    a     one     2
          two     1
    b     one     1
          two     1
    

    范例二:利用for循环,对分组进行迭代

    #原始数据集与范例一相同
    #对一列聚合,使用for循环进行分组迭代
    for name,group in df.groupby('key1'):
        print(name)
        print(group)
    >>>
    a
      key1 key2     data1     data2
    0    a  one -0.484689 -3.105627
    1    a  two  0.033929  1.182974
    4    a  one  0.305254  0.322322
    b
      key1 key2     data1     data2
    2    b  one  1.067201 -1.707349
    3    b  two -0.960876 -0.190247
    #若仅使用一个变量name,会影响输出结果的索引层次表达方式,且结果为元组
    for name in df.groupby('key1'):
        print(name)
    >>>
    ('a',   key1 key2     data1     data2
    0    a  one -0.484689 -3.105627
    1    a  two  0.033929  1.182974
    4    a  one  0.305254  0.322322)
    ('b',   key1 key2     data1     data2
    2    b  one  1.067201 -1.707349
    3    b  two -0.960876 -0.190247)
    #对于多重键的情况,元组的第一个元素将会是由键值组成的元组,所以for循环的第一个变量用元组(k1,k2):
    for (k1,k2),group in df.groupby(['key1','key2']):
        print(k1,k2)
        print(group)
    >>>
    a one
      key1 key2     data1     data2
    0    a  one -0.484689 -3.105627
    4    a  one  0.305254  0.322322
    a two
      key1 key2     data1     data2
    1    a  two  0.033929  1.182974
    b one
      key1 key2     data1     data2
    2    b  one  1.067201 -1.707349
    b two
      key1 key2     data1     data2
    3    b  two -0.960876 -0.190247
    #对于多重键的情况,若for循环的第一个变量不用元组(k1,k2),而是普通变量name,则输出结果的层次索引将为元组格式
    for name,group in df.groupby(['key1','key2']):
        print(name)
        print(group)
    >>>
    ('a', 'one')
      key1 key2     data1     data2
    0    a  one -0.484689 -3.105627
    4    a  one  0.305254  0.322322
    ('a', 'two')
      key1 key2     data1     data2
    1    a  two  0.033929  1.182974
    ('b', 'one')
      key1 key2     data1     data2
    2    b  one  1.067201 -1.707349
    ('b', 'two')
      key1 key2     data1     data2
    3    b  two -0.960876 -0.190247
    

    范例三:对聚合后的数据片段,进行格式类型转化

    #将数据片段转为字典
    pieces=dict(list(df.groupby('key1')))
    >>>
    pieces
    {'a':   key1  key2     data1     data2
     0       a   one     -0.484689 -3.105627
     1       a   two      0.033929  1.182974
     4       a   one      0.305254  0.322322, 'b':   key1 key2     data1     data2
     2       b   one      1.067201 -1.707349
     3       b   two     -0.960876 -0.190247}
     >>>
     pieces['b']    #选取片段
        key1	key2	data1	    data2
    2	b	    one	    1.067201	-1.707349
    3	b	    two	    -0.960876	-0.190247
    #将数据片段转为列表
    pieces=list(df.groupby('key1'))
    >>>
    pieces
    [('a',   key1 key2     data1     data2
      0       a   one     -0.484689 -3.105627
      1       a   two      0.033929  1.182974
      4       a   one      0.305254  0.322322), ('b',   key1 key2     data1     data2
      2       b   one      1.067201 -1.707349
      3       b   two     -0.960876 -0.190247)]
    

    范例四:利用groupby,根据dtypes对列进行分组,此时,需指定axis=1,否则,groupby默认根据axis=0进行分组,而行数据由于类型不统一,故无法根据dtypes对列进行分组

    #df.dtypes用于确定df的数据类型
    df.dtypes
    >>>
    key1      object
    key2      object
    data1    float64
    data2    float64
    dtype: object
    #将聚合后df转化为字典格式,后根据df的数据类型对列进行分组
    grouped=df.groupby(df.dtypes,axis=1)
    dict(list(grouped))
    >>>
    {dtype('float64'):       data1     data2
                          0 -0.484689 -3.105627
                          1  0.033929  1.182974
                          2  1.067201 -1.707349
                          3 -0.960876 -0.190247
                          4  0.305254  0.322322, dtype('O'):   key1  key2
                                                           0    a   one
                                                           1    a   two
                                                           2    b   one
                                                           3    b   two
                                                           4    a   one}
    #若不指定axis=1,则默认groupby根据行数据按dtypes进行分组
    grouped1=df.groupby(df.dtypes)
    dict(list(grouped1))
    >>>
    {}    #由于行数据不统一,故按dtypes分组时,为空
    #将聚合数据片段转化为list类型
    list(grouped)
    >>>
    [(dtype('float64'),       data1     data2
                           0  -0.484689 -3.105627
                           1   0.033929  1.182974
                           2   1.067201 -1.707349
                           3  -0.960876 -0.190247
                           4   0.305254  0.322322), (dtype('O'),    key1  key2
                                                                 0    a  one
                                                                 1    a  two
                                                                 2    b  one
                                                                 3    b  two
                                                                 4    a  one)]
                                                                 
    

    范例五:根据自定义字典、自定义列表、自定义Series、函数或者函数与自定义数组、列表、字典、Series的组合,作为分组键进行聚合

    #创建原始数据集
    people=pd.DataFrame(np.random.randn(5,5),columns=list('abcde'),index=['Joe','Steve','Wes','Jim','Travis'])
    people
    >>>
                a	        b	        c	       d	       e
    Joe 	-0.350379	-2.216265	-1.922898	0.655574	0.512573
    Steve	-1.212107	-1.040184	-0.659978	-0.277454	0.613489
    Wes	    -1.624845	-0.432863	-0.211577	0.310541	2.138030
    Jim	     2.038365	-0.237121	-0.392664	-0.480918	1.566855
    Travis	-0.345361	-0.653787	-0.299217	1.019871	0.511216
    #利用people.ix[2:3,['b','c']]=np.nan,将第2,3行,第b,c列的数据置为空
    people.ix[2:3,['b','c']]=np.nan
    >>>
    people
                a	        b	        c	       d	      e
    Joe	    -0.350379	-2.216265	-1.922898	 0.655574	0.512573
    Steve	-1.212107	-1.040184	-0.659978	-0.277454	0.613489
    Wes	    -1.624845	   NaN	       NaN	     0.310541	2.138030
    Jim	     2.038365	-0.237121	-0.392664	-0.480918	1.566855
    Travis	-0.345361	-0.653787	-0.299217	 1.019871	0.511216
    # 假设已知列的分组关系,并希望根据分组计算列的总计:
    #创建分组的映射字典
    mapping={'a':'red','b':'red','c':'blue','d':'blue','e':'red','f':'orange'}
    mapping
    >>>
    {'a': 'red', 'b': 'red', 'c': 'blue', 'd': 'blue', 'e': 'red', 'f': 'orange'}
    type(mapping)
    >>>
    dict
    #将这个字典传给groupby即可,由于是按列进行分组,指定axis=1
    by_column=people.groupby(mapping,axis=1).sum()
    by_column
    >>>
    	        blue	red
    Joe	       -1.267323	-2.054071
    Steve	   -0.937431	-1.638802
    Wes	        0.310541	 0.513184
    Jim	       -0.873581	 3.368099
    Travis	    0.720653	-0.487932
    #用自定义Series作为分组键进行聚合,则pandas会检查Series以确保其索引跟分组轴是对齐的
    #自定义Series作为分组键
    map_series=pd.Series(mapping)
    >>>
    map_series
    a       red
    b       red
    c      blue
    d      blue
    e       red
    f    orange
    dtype: object
    #用自定义Series作为分组键聚合
    people.groupby(map_series,axis=1).count()
    >>>
           blue	red
    Joe	    2	3
    Steve	2	3
    Wes	    1	2
    Jim	    2	3
    Travis	2	3
    #用函数作分组键,进行分组,需传入len函数(可以求取一个字符串长度数组),实现根据人名的长度进行分组
    people.groupby(len).sum()   #将名字长度相同的行求和
    >>>
            a	        b	         c	        d	       e
    3	0.063140	-2.453386	-2.315561	0.485198	4.217458
    5	-1.212107	-1.040184	-0.659978	-0.277454	0.613489
    6	-0.345361	-0.653787	-0.299217	1.019871	0.511216
    #将函数和数组、列表、字典、Series组合作为分组键,进行聚合
    key_list=['one','one','one','two','two']   #自定义列表,默认列表的字符串顺序和df的列顺序一致
    people.groupby([len,key_list]).min()
    >>>
                 a	        b	        c	        d	       e
    3	one	 -1.624845	-2.216265	-1.922898	0.310541	0.512573
        two	  2.038365	-0.237121	-0.392664	-0.480918	1.566855
    5	one	 -1.212107	-1.040184	-0.659978	-0.277454	0.613489
    6	two	 -0.345361	-0.653787	-0.299217	1.019871	0.511216
    

    范例六:df含有多重列索引的聚合分组

    #根据df的多重列索引的层次级别分组聚合
    #自定义列层次索引
    columns=pd.MultiIndex.from_arrays([['US','US','US','JP','JP'],[1,3,5,1,3]],names=['cty','tenor'])
    >>>
    columns
    MultiIndex(levels=[['JP', 'US'], [1, 3, 5]],
               codes=[[1, 1, 1, 0, 0], [0, 1, 2, 0, 1]],
               names=['cty', 'tenor'])
    #创建包含多重列索引的原始数据集
    hier_df=pd.DataFrame(np.random.randn(4,5),columns=columns)
    >>>
    hier_df
    cty	    US	        JP
    tenor	  1	          3	         5	         1	        3
    0	  0.023254	 -0.271758	-0.129695	-1.003850	0.600698
    1	  -0.076856	 0.696218	-1.054670	-0.232982	0.641908
    2	  0.211017	 0.481233	-0.289600	0.794614	-0.910464
    3	  1.069144	 0.358034	0.169202	-1.910069	0.769219
    #按列索引层次进行分组聚合
    hier_df.groupby(level='cty',axis=1).count()    #利用参数level,指明聚合的层级
    >>>
    cty	JP	US
    0	2	3
    1	2	3
    2	2	3
    3	2	3
    
    #"盲投"DataFrame按照“号码归属省”对指定4列“'发货量','签收量','激活量','首充'”进行聚合
    functions=['count']
    MT_fs_grouped=MT_data.groupby(['号码归属省'])
    MT_fs=MT_fs_grouped['发货量','签收量','激活量','首充'].agg(functions)
    MT_fs=pd.DataFrame(MT_fs)
    MT_fs.reset_index(inplace=True)   #将聚合表的index转为普通列
    #对聚合表增加“各列统计求和”的行,同时指定参与求和的列,即“号码归属省”列需排除;
    MT_fs.loc['总计']=MT_fs.loc[:,['发货量','签收量','激活量','首充']].apply(lambda x: x.sum())
    MT_fs.loc['总计',['号码归属省']]='总计'  #补全“省份”最后一行的“总计”名称
    

    参考链接:https://www.cnblogs.com/huiyang865/p/5577772.html

    5 groupby常见的调用函数

    • 描述组内数据的基本统计量:A.groupby("性别").describe().unstack()
    • 组内均值计算:A.groupby("性别").mean()
    • 我们还可以一次运用多个函数计算:A.groupby( ["班级","性别"]).agg([np.sum, np.mean, np.std]) # 一次计算了三个
    • 按照【生日】的【年份】进行分组,看看有多少人是同龄?
      A[“生日”] = pd.to_datetime(A[“生日”],format ="%Y/%m/%d") # 转化为时间格式
      A.groupby(A["生日"].apply(lambda x:x.year)).count() # 按照【生日】的【年份】分组
      在这里插入图片描述

    参考链接:python中groupby函数主要的作用是进行数据的分组以及分组后地组内运算!

    展开全文
  • Group by使用

    千次阅读 2019-06-09 14:49:16
    Group by使用group by 的初步认识还是不很熟悉,在学习的项目中用了几次group by,今天早上一觉醒来看了一下,突然感觉group by好陌生,总有个筋转不过来,不过想了一会总有一点头绪,简单总结一下吧,group ...
  • group by详解

    万次阅读 多人点赞 2018-09-16 22:06:51
    group_by的意思是根据by对数据按照哪个字段进行分组,或者是哪几个字段进行分组。 二. 语法 select 字段 from 表名 where 条件 group by 字段 或者 select 字段 from 表名 group by 字段 having 过滤条件 ...
  • 什么group by后面不能使用列的别名

    万次阅读 多人点赞 2018-06-30 15:33:14
    同事工作中遇到一个问题: select count(billingdate),to_char(billingdate,'YYYYmm') month from tu_trade where to_char(billingdate,'YYYY') ='2017'...group by month;  -----执行报错,can't resolve mo...
  • SQL中group by使用

    千次阅读 2018-12-27 11:42:55
    SQL中Group By使用 1、概述 “Group By”从字面意义上理解就是根据“By”指定的规则对数据进行分组,所谓的分组就是将一个“数据集”划分成若干个“小区域”,然后针对若干个“小区域”进行数据处理。   2、...
  • DB2中group by使用

    千次阅读 2018-12-27 11:41:34
    GROUP BY是按照什么分组,聚合函数,就是求取按照GROUP BY分组之后的聚合函数得到的值。 那么GROUP BY后边,可想而知,一定是语法中除了聚合函数之外,所有的字段了。 group by 有一个原则,就是 select 后面的所有...
  • Mysql5.7使用group by查询时order by无效问题 第一种写法: SELECT * FROM user_paper_relation WHERE paper_id = &quot;&quot; GROUP BY examer_id ORDER BY total_score DESC 问题:发现先执行的...
  • 比如在使用group by进行分组查询报错 1 查看自己的sql_mode配置: 在sql命令行中输入select @@sql_mode;这时我们能够看到自己的sql_mode配置,其中如果有ONLY_FULL_GROUP_BY,那它就是group by查询报错的罪魁祸...
  • having是分组(group by)后的筛选条件,分组后的数据组内再筛选;where则是在分组前筛选。正确写法:select student_id, avg(score) as avgscore from student_score group by student_id having avgscore&gt;...
  • order bygroup by一起使用

    千次阅读 2018-09-17 13:29:11
    GROUP BY 是按什么条件... 单独使用时候,都是在sql语句的结尾,但是如果两个条件一起使用的话,则是: GROUP BY order_id ORDER BY order_id DESC ,这句的意思是按照order_id 分组,然后按照order_id降序排序。...
  • MySQL GROUP BY 语句使用总结

    万次阅读 多人点赞 2018-02-02 15:38:12
    MySQL GROUP BY 语句使用总结 大家好,我是Yangrl. 总结一下MySQL中查询记录操作中的GROUP BY语句,查遗补漏。 表名:testusers,字段记录如图,以前create的直接拿来用,将就一下。(懒即生产力) 命令行工具...
  • 文章目录 order by放在最后,order by里要有和group by里一样的字段
  • order bygroup by 一起使用

    千次阅读 2019-05-15 23:55:14
    整理一下 order bygroup by 一起使用的笔记 order by 的执行顺序是从左到右。 如果使用select 列表项对应的位置序号来指定排序项,那么这个数字序号不能大于select 列表里的项目个数。 一般可以使用一个没有被...
  • mysql group by 与order by 一起使用

    万次阅读 2017-09-04 12:12:38
    今天在做mysql分组查询的时候遇到一个问题:... 于是上午搜了下才发现group by 与order by 一起使用是要遵守一定原则的:  1.order by 的列,必须是出现在group by 子句里的列  例如:SELECT dep.department_name,
  • hive> select * from app_data_stats_historical where os='1' group by dt limit 100; 出现结果如下: 2014-01-01 2014-01-06 2014-01-13 2014-01-20 2014-01-27 2014-02-01 2014-02-03 2014-02-04 20
  • 在mysql中使用group by进行分组后取某一列的最大值,我们可以直接使用MAX()函数来实现,但是如果我们要取最大值对应的ID,那么我们需要取得整行的数据。最开始的实现方法如下SELECT t.event_id,MAX(t.create_time) ...
  • group by使用

    千次阅读 2008-04-03 16:16:00
    可按照在 GROUP BY 子句中定义的组对行进行分组。以其最简单的形式,组由称为分组列的列组成。 SELECT 子句中的列名必须为分组列或列函数。列函数对于 GROUP BY 子句定义的每个组各返回一个结果。下列示例产生一个...
  • 理解group by

    万次阅读 多人点赞 2017-04-07 15:09:34
    先来看下表1,表名为test:   表1  执行如下SQL语句: 1 ... GROUP BY name ... 可是为了能够更好的理解“group by”多个列“和”聚合函数“的应用,我建议在思考的过程中,由表1到表2的过程中...
  • group by 和 order by 一起使用问题处理

    千次阅读 2020-04-30 16:12:30
    group by 和 order by 一起使用时,会先使用group by 分组,并取出分组后的第一条数据,所以后面的order by 排序时根据取出来的第一条数据来排序的,但是第一条数据不一定是分组里面的最大数据。 解决方案: 可以...
  • 使用GROUP BY子句进行分组操作

    千次阅读 2014-09-28 16:50:56
    本文通过实例介绍GROUP BY子句的使用方法。 1 准备测试数据 新建数据表tb_Student并插入下图所示的测试数据。   图1 数据表tb_Student的数据 2 使用GROUP BY子句进行分组 问题1  要求 按照班级ID对学生进行...
  • group by和select的使用

    万次阅读 多人点赞 2018-07-05 18:34:53
    GROUP BY的用法1、group by概述:简单来说:将数据库的数据用'by'后面接的规则进行分组,即将一个大数据库分成一个个相同类型数据在一起的小区域。2、group by的语法:SELECT column_name, function(column_name) //...
  • Linq使用Group By经验总结

    千次阅读 2014-10-27 14:32:44
    学习Linq时,经常会遇到Linq使用Group By问题,这里将介绍Linq使用Group By问题的解决方法。 1.计数 var q = from p in db.Products group p by p.CategoryID into g select new { g.Key, NumProducts...
  • sql GROUP BY子句使用实例

    千次阅读 2015-01-02 16:51:10
    GROUP BY子句 GROUP BY子句可以将表的行划分为不同的组。分别总结每个组,这样就可以控制想要看见的详细信息的级别。 语法: [ GROUP BY [ ALL ] group_by_expression[ ,...n ] [ WITH { CUBE | ROLLUP } ] ] ...
  • 使用group by时 select count(*) from partner.gs_user_info u group by u.username,u.game; 查询结果如下: count计算的数量是每个group by的结果的数量,并不是我要的查询记录数的数量。 正确的写法是这样的...
  • DB2 多种GROUP BY使用

    千次阅读 2018-12-04 12:34:52
    平常经常使用GROUP BY对数据进行分组运算,但是还有其他的分组运行情况。 GROUP BY CUBE()、GROUP BY ROLLUP()、GROUP BY GROUPING SETS() 以原始数据表数据为例: 【1】GROUP BY CUBE()的分组情况 结果集...
  • SQL中Group by使用

    千次阅读 2017-09-05 20:13:19
    1、Group by使用select XS.学号,XS.姓名,XS.所在系,XX.课程号,KC.课程名 from XS join XX on XS.学号=XX.学号 join KC on KC.课程号=XX.课程号 group by XS.学号,XS.姓名,XS.所在系,XX.课程号,KC.课程名 order by ...
  • SparkSQL groupBy使用

    千次阅读 2019-01-08 11:12:52
    数据格式(消费者ID 消费时间 消费金额) 1 12:01 100 1 12:02 200 1 12:50 100 2 12:50 100 3 13:01 200 ...2、使用sparkSQl里面的 groupby.agg()方法 groupby(“id”,“time”).agg(sum(“cous...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 847,374
精华内容 338,949
关键字:

by什么时候使用group