精华内容
下载资源
问答
  • python笔记20:数据处理之数据分组

    千次阅读 2019-01-18 10:26:25
    #概念:数据分组,根据数据分析对象的特征,按照一定的数值指标,把数据分析对象划分为不同的区间进行研究,以揭示 #其内在的联系规律性 #cut函数:cut(series,bins,right=True,labels=NULL) #series:需要分组的...

    # -*- coding: utf-8 -*-
    #概念:数据分组,根据数据分析对象的特征,按照一定的数值指标,把数据分析对象划分为不同的区间进行研究,以揭示
    #其内在的联系和规律性

    #cut函数:cut(series,bins,right=True,labels=NULL)
    #series:需要分组的序列数据
    #bins:划分数组(如何定义划分数组是重点)
    #right:分组的时候,右边是否闭合,默认闭合
    #labels:分组的自定义标签,可以不自定义

    #返回值:分组结果的序列,列名即上述的自定义标签

    import pandas

    data = pandas.read_csv("D:/workspaces/python/pythonStudy/20.csv",sep="|")

    #分析消费金额的分布情况:
    #定义分组区间:
    bins = [
            min(data.cost)-1,20,40,60,80,100,max(data.cost)+1
    ]

    #问:分组区间中,最小值和最大值为什么要分别减一和加一?
    #答:因为分组的时候有可能会碰上边界值(即需要分组的数据和我们的最小值或最大值相等),这可能会导致找不到范围

    #开始分组(左开右闭):
    data["cut"] = pandas.cut(
    data.cost,
    bins
    )
    #查看分组结果,可以看到如果我们不自定义标签,那么python给我们生成的默认标签是数据的范围表达式

    #左闭右开:
    data["cut"] = pandas.cut(
    data.cost,
    bins,
    right=False
    )

    #自定义分组标签:
    labels = [
              '20以下','20到40','40到60','60到80','80到100','100以上'
              ]
    #开始分组
    data["cut"] = pandas.cut(
        data.cost,
        bins,
        labels = labels
    )

    展开全文
  • 下面小编就为大家分享一篇Vue中v-for的数据分组实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • //使得两组中各元素加起来的和相等, //并且,所有5的倍数必须在其中一个组中,所有3的倍数在另一个组中(不包括5的倍数), //能满足以上条件,返回true;不满足时返回false。 //知识点 字符串,循环,函数,指针,...

    //描述
    //编写一个函数,传入一个int型数组,返回该数组能否分成两组,
    //使得两组中各元素加起来的和相等,
    //并且,所有5的倍数必须在其中一个组中,所有3的倍数在另一个组中(不包括5的倍数),
    //能满足以上条件,返回true;不满足时返回false。
    //知识点 字符串,循环,函数,指针,枚举,位运算,结构体,联合体,文件操作,递归
    //运行时间限制 10M
    //内存限制 128
    //输入
    //输入输入的数据个数
    //输入一个int型数组
    //
    //输出
    //返回true或者false
    //
    //样例输入 4 1 5 -5 1
    //样例输出 true
    解析:本题需考虑完整,避免有些测试用例的漏写。
    1、可以被5整除的数的和,
    2、可以被3整除的数的和,不包括同时可以被5整除的数,
    3、将不能被3和5整除的数存放在链表中,求出和
    4、算出Sum3和Sum5的差的绝对值Abs,将Abs加入链表中
    5、然后将链表中的数分成两组,每组数的和为总和的1/2,(利用数学知识,总共有2的n次方种组合方式)
    代码如下:

    package hw07_14;
    import java.io.*;
    import java.util.Scanner;
    
    import java.util.*;
    public class Prog39_2 {
        public static void main(String[] args) {
            Scanner in = new Scanner(System.in);
            while(in.hasNextInt()) {
                int count = in.nextInt();
                List<Integer> listOthers=new ArrayList<Integer>();
                int sum3=0,sum5=0,sumTemp=0;
                for(int i=0;i<count;i++){
                    int b = in.nextInt();
                    if(b%5==0)
                        sum5+=b;
                    else if(b%3==0){
                        sum3+=b;
                    }else if(b!=0){
                        listOthers.add(b);
                        sumTemp+=b;
                    }
                }
                if(listOthers.size()==0)
                {
                    if(sum3==sum5){
                        System.out.println("true");
                    }
                    else{
                        System.out.println("false");
                    }
                }
                else
                {
                    int minus=sum3-sum5;
                    if(minus!=0){
                        listOthers.add(minus);
                        sumTemp+=minus;
                    }
                    if(sumTemp%2!=0){
                        System.out.println("false");
                    }
                    else if(foo(listOthers,listOthers.size(),sumTemp/2))
                    {
                        System.out.println("true");
    
    
                    }    else{
                        System.out.println("false");
                    }
                }
            }
        }
        static boolean  foo(List<Integer> source,int len,int defaultSum){
            int a=(int)java.lang.Math.pow(2,source.size());
            for(int i=0;i<a;i++){
                String str=Integer.toBinaryString(i);
                int sum=0;
                for(int j=0;j<str.length();j++)
                {
                    char c = str.charAt(j);
                    if(c=='1')
                    {
                        sum+=source.get(j);
                    }else
                        continue;
    
                }
                if(sum==defaultSum)return true;
    
            }
            return false;
        }// end foo
    }//end class
    
    
    展开全文
  • n个小数待分组,每个数组k个,如果n%k==0,那么组数为n/k个,如果n%k!=0,则最后一组的数量为n%k,组数为n/K+1,要求每个组的均值相等或者相近!
  • 数据集进行分组并对各组应用一个函数(无论是聚合还是转换),通常是数据分析工作中的重要环节。在将数据集加载、融合、准备好之后,通常就是计算分组统计或生成透视表。pandas提供了一个灵活高效的gruopby功能,...

    对数据集进行分组并对各组应用一个函数(无论是聚合还是转换),通常是数据分析工作中的重要环节。在将数据集加载、融合、准备好之后,通常就是计算分组统计或生成透视表。pandas提供了一个灵活高效的gruopby功能,它使你能以一种自然的方式对数据集进行切片、切块、摘要等操作。

    关系型数据库和SQL(Structured Query Language,结构化查询语言)能够如此流行的原因之一就是其能够方便地对数据进行连接、过滤、转换和聚合。但是,像SQL这样的查询语言所能执行的分组运算的种类很有限。在本章中你将会看到,由于Python和pandas强大的表达能力,我们可以执行复杂得多的分组运算(利用任何可以接受pandas对象或NumPy数组的函数)。在本章中,你将会学到:

    使用一个或多个键(形式可以是函数、数组或DataFrame列名)分割pandas对象。

    计算分组的概述统计,比如数量、平均值或标准差,或是用户定义的函数。

    应用组内转换或其他运算,如规格化、线性回归、排名或选取子集等。

    计算透视表或交叉表。

    执行分位数分析以及其它统计分组分析。

    笔记:对时间序列数据的聚合(groupby的特殊用法之一)也称作重采样(resampling),本书将在第11章中单独对其进行讲解。

    1. GroupBy机制

    Hadley Wickham(许多热门R语言包的作者)创造了一个用于表示分组运算的术语"split-apply-combine"(拆分-应用-合并)。第一个阶段,pandas对象(无论是Series、DataFrame还是其他的)中的数据会根据你所提供的一个或多个键被拆分(split)为多组。拆分操作是在对象的特定轴上执行的。例如,DataFrame可以在其行(axis=0)或列(axis=1)上进行分组。然后,将一个函数应用(apply)到各个分组并产生一个新值。最后,所有这些函数的执行结果会被合并(combine)到最终的结果对象中。结果对象的形式一般取决于数据上所执行的操作。图10-1大致说明了一个简单的分组聚合过程。

    在这里插入图片描述
    图10-1 分组聚合演示

    分组键可以有多种形式,且类型不必相同:

    • 列表或数组,其长度与待分组的轴一样。
    • 表示DataFrame某个列名的值。
    • 字典或Series,给出待分组轴上的值与分组名之间的对应关系。
    • 函数,用于处理轴索引或索引中的各个标签。

    注意,后三种都只是快捷方式而已,其最终目的仍然是产生一组用于拆分对象的值。如果觉得这些东西看起来很抽象,不用担心,我将在本章中给出大量有关于此的示例。首先来看看下面这个非常简单的表格型数据集(以DataFrame的形式):

    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)})
    
    df
    

    111
    假设你想要按key1进行分组,并计算data1列的平均值。实现该功能的方式有很多,而我们这里要用的是:访问data1,并根据key1调用groupby:

    grouped = df['data1'].groupby(df['key1'])
    grouped
    

    Out[13]: <pandas.core.groupby.SeriesGroupBy object at 0x7faa31537390>

    变量grouped是一个GroupBy对象。它实际上还没有进行任何计算,只是含有一些有关分组键df[‘key1’]的中间数据而已。换句话说,该对象已经有了接下来对各分组执行运算所需的一切信息。例如,我们可以调用GroupBy的mean方法来计算分组平均值:

    grouped.mean()
    

    在这里插入图片描述
    稍后我将详细讲解.mean()的调用过程。这里最重要的是,数据(Series)根据分组键进行了聚合,产生了一个新的Series,其索引为key1列中的唯一值。之所以结果中索引的名称为key1,是因为原始DataFrame的列df[‘key1’]就叫这个名字。

    如果我们一次传入多个数组的列表,就会得到不同的结果:

    dmean = df['data1'].groupby([df['key1'], df['key2']]).mean()
    dmean
    

    在这里插入图片描述
    这里,我通过两个键对数据进行了分组,得到的Series具有一个层次化索引(由唯一的键对组成):

    dmean.unstack()
    

    在这里插入图片描述
    在这个例子中,分组键均为Series。实际上,分组键可以是任何长度适当的数组(甚至不在同一个dataframe)

    states = np.array(['Ohio', 'California', 'California', 'Ohio', 'Ohio'])
    years = np.array([2005, 2005, 2006, 2005, 2006])
    df['data1'].groupby([states, years]).mean()
    

    在这里插入图片描述
    通常,分组信息就位于相同的要处理DataFrame中。这里,你还可以将列名(可以是字符串、数字或其他Python对象)用作分组键:

    df.groupby('key1').mean()
    df.groupby(['key1', 'key2']).mean()
    

    在这里插入图片描述在这里插入图片描述

    你可能已经注意到了,第一个例子在执行df.groupby(‘key1’).mean()时,结果中没有key2列。这是因为df[‘key2’]不是数值数据(俗称“麻烦列”),所以被从结果中排除了。默认情况下,所有数值列都会被聚合,虽然有时可能会被过滤为一个子集,稍后就会碰到。

    无论你准备拿groupby做什么,都有可能会用到GroupBy的size方法,它可以返回一个含有分组大小的Series:

    df.groupby(['key1', 'key2']).size()
    

    在这里插入图片描述
    注意,任何分组关键词中的缺失值,都会被从结果中除去。

    对分组进行迭代

    GroupBy对象支持迭代,可以产生一组二元元组(由分组名和数据块组成)。看下面的例子:

    for name, group in df.groupby('key1'):
    	print(name)
    	print(group)
    

    在这里插入图片描述
    对于多重键的情况,元组的第一个元素将会是由键值组成的元组:

    for (k1, k2), group in df.groupby(['key1', 'key2']):
    	print((k1, k2))
    	print(group)
    

    在这里插入图片描述
    当然,你可以对这些数据片段做任何操作。有一个你可能会觉得有用的运算:将这些数据片段做成一个字典:

    pieces = dict(list(df.groupby('key1')))
    pieces['b']
    

    在这里插入图片描述
    groupby默认是在axis=0上进行分组的,通过设置也可以在其他任何轴上进行分组。拿上面例子中的df来说,我们可以根据dtype对列进行分组:

    df.dtypes
    

    在这里插入图片描述

    grouped = df.groupby(df.dtypes, axis=1)
    #可以如下打印分组:
    for dtype, group in grouped:
    	print(dtype)
    	print(group)
    

    在这里插入图片描述

    选取一列或列的子集

    对于由DataFrame产生的GroupBy对象,如果用一个(单个字符串)或一组(字符串数组)列名对其进行索引,就能实现选取部分列进行聚合的目的。也就是说:

    df.groupby('key1')['data1']
    df.groupby('key1')[['data2']]
    

    <pandas.core.groupby.groupby.DataFrameGroupBy object at 0x7fbf88fe8d68>

    是以下代码的语法糖:

    df[‘data1’].groupby(df[‘key1’])
    df[[‘data2’]].groupby(df[‘key1’])
    尤其对于大数据集,很可能只需要对部分列进行聚合。例如,在前面那个数据集中,如果只需计算data2列的平均值并以DataFrame形式得到结果,可以这样写:

    df.groupby(['key1', 'key2'])[['data2']].mean()
    

    在这里插入图片描述
    这种索引操作所返回的对象是一个已分组的DataFrame(如果传入的是列表或数组)或已分组的Series(如果传入的是标量形式的单个列名):

    s_grouped = df.groupby(['key1', 'key2'])['data2']
    s_grouped
    

    Out[33]: <pandas.core.groupby.SeriesGroupBy object at 0x7faa30c78da0>

    s_grouped.mean()
    

    在这里插入图片描述

    通过字典或Series进行分组

    除数组以外,分组信息还可以其他形式存在。来看另一个示例DataFrame:

    people = pd.DataFrame(np.random.randn(5, 5),
                          columns=['a', 'b', 'c', 'd', 'e'],
                          index=['Joe', 'Steve', 'Wes', 'Jim', 'Travis'])
    
    people.iloc[2:3, [1, 2]] = np.nan # Add a few NA values
    people
    

    在这里插入图片描述
    现在,假设已知列的分组关系,并希望根据分组计算列的和:

    mapping = {'a': 'red', 'b': 'red', 'c': 'blue',
                'd': 'blue', 'e': 'red', 'f' : 'orange'}
    

    现在,你可以将这个字典传给groupby,来构造数组,但我们可以直接传递字典(我包含了键“f”来强调,存在未使用的分组键是允许的):

    by_column = people.groupby(mapping, axis=1)
    by_column.sum()
    

    在这里插入图片描述

    Series也有同样的功能,它可以被看做一个固定大小的映射:

    map_series = pd.Series(mapping)
    map_series
    

    在这里插入图片描述

    people.groupby(map_series, axis=1).count()
    

    在这里插入图片描述

    通过函数进行分组

    比起使用字典或Series,使用Python函数是一种更原生的方法定义分组映射。任何被当做分组键的函数都会在各个索引值上被调用一次,其返回值就会被用作分组名称。具体点说,以上一小节的示例DataFrame为例,其索引值为人的名字。你可以计算一个字符串长度的数组,更简单的方法是传入len函数:

    people.groupby(len).sum()
    

    在这里插入图片描述
    使用自定义匿名函数:

    people.groupby(lambda x: 'good boy' if x=='Wes' else 'bad girl').sum()
    

    在这里插入图片描述
    将函数跟数组、列表、字典、Series混合使用也不是问题,因为任何东西在内部都会被转换为数组:

    key_list = ['one', 'one', 'one', 'two', 'two']
    people.groupby([len, key_list]).min()
    

    在这里插入图片描述
    对dataframe中的列重新映射后分组:

    label = people['b'].apply(lambda x: 'yes' if x > 0.0 else 'no')
    

    在这里插入图片描述

    people.groupby(label).count()
    

    在这里插入图片描述

    根据索引级别分组

    层次化索引数据集最方便的地方就在于它能够根据轴索引的一个级别进行聚合:

    columns = pd.MultiIndex.from_arrays([['US', 'US', 'US', 'JP', 'JP'],
                                         [1, 3, 5, 1, 3]],
                                         names=['cty', 'tenor'])
    hier_df = pd.DataFrame(np.random.randn(4, 5), columns=columns)
    hier_df
    

    在这里插入图片描述
    要根据级别分组,使用level关键字传递级别序号或名字:

    hier_df.groupby(level='cty', axis=1).count()
    

    在这里插入图片描述

    2. 数据聚合

    聚合指的是任何能够从数组产生标量值的数据转换过程。之前的例子已经用过一些,比如mean、count、min以及sum等。你可能想知道在GroupBy对象上调用mean()时究竟发生了什么。许多常见的聚合运算(如表10-1所示)都有进行优化。然而,除了这些方法,你还可以使用其它的。
    在这里插入图片描述
    表10-1 经过优化的groupby方法

    你可以使用自己发明的聚合运算,还可以调用分组对象上已经定义好的任何方法。例如,quantile可以计算Series或DataFrame列的样本分位数。

    虽然quantile并没有明确地实现于GroupBy,但它是一个Series方法,所以这里是能用的。实际上,GroupBy会高效地对Series进行切片,然后对各片调用piece.quantile(0.9),最后将这些结果组装成最终结果:

    df
    

    在这里插入图片描述

    grouped = df.groupby('key1')
    grouped['data1'].quantile(0.9)
    # quantile(0.9) 表示从给定数据集确定的区间中,9/10分位所在的数值。
    

    在这里插入图片描述
    如果要使用你自己的聚合函数,只需将其传入aggregate或agg方法即可:

    def peak_to_peak(arr):
         return arr.max() - arr.min()
    grouped.agg(peak_to_peak)
    

    (注意:agg和apply的区别是,agg对分组处理之后返回的是标量,apply对分组处理后,既可以返回标量也可以返回dataframe。)
    在这里插入图片描述
    你可能注意到注意,有些方法(如describe)也是可以用在这里的,即使严格来讲,它们并非聚合运算:

    grouped.describe()
    

    在这里插入图片描述
    在后面的10.3节,我将详细说明这到底是怎么回事。

    笔记:自定义聚合函数要比表10-1中那些经过优化的函数慢得多。这是因为在构造中间分组数据块时存在非常大的开销(函数调用、数据重排等)。

    面向列的多函数应用

    回到前面小费的例子。使用read_csv导入数据之后,我们添加了一个小费百分比的列tip_pct:

    tips = pd.read_csv('examples/tips.csv')
    # Add tip percentage of total bill 
    tips['tip_pct'] = tips['tip'] / tips['total_bill']
    tips[:6]
    

    在这里插入图片描述
    你已经看到,对Series或DataFrame列的聚合运算其实就是使用aggregate(使用自定义函数)或调用诸如mean、std之类的方法。然而,你可能希望对不同的列使用不同的聚合函数,或一次应用多个函数。其实这也好办,我将通过一些示例来进行讲解。首先,我根据 day 和 smoker 对 tips 进行分组:

    grouped = tips.groupby(['day', 'smoker'])
    

    注意,对于表10-1中的那些描述统计,可以将函数名以字符串的形式传入:

    grouped_pct = grouped['tip_pct']
    grouped_pct.agg('mean')
    

    在这里插入图片描述
    如果传入一组函数或函数名,得到的DataFrame的列就会以相应的函数命名:

    grouped_pct.agg(['mean', 'std', peak_to_peak])
    

    在这里插入图片描述
    这里,我们传递了一组聚合函数进行聚合,独立对数据分组进行评估。

    可以对自动给出的列名进行重命名。
    如果传入的是一个由(name,function)元组组成的列表,则各元组的第一个元素就会被用作DataFrame的列名(可以将这种二元元组列表看做一个有序映射):

    # 将mean重命名为foo, 将 np.std 重命名为bar
    grouped_pct.agg([('foo', 'mean'), ('bar', np.std)])
    

    在这里插入图片描述
    对于DataFrame,你还有更多选择,你可以定义一组应用于全部列的一组函数,或不同的列应用不同的函数。假设我们想要对tip_pct和total_bill列计算三个统计信息:

    functions = ['count', 'mean', 'max']
    result = grouped['tip_pct', 'total_bill'].agg(functions)
    result
    

    在这里插入图片描述
    如你所见,结果DataFrame拥有层次化的列,这相当于分别对各列进行聚合,然后用concat将结果组装到一起,使用列名用作keys参数:

    result['tip_pct']
    

    在这里插入图片描述
    跟前面一样,这里也可以传入带有自定义名称的一组元组:

    ftuples = [('Durchschnitt', 'mean'),('Abweichung', np.var)]
    grouped['tip_pct', 'total_bill'].agg(ftuples)
    

    在这里插入图片描述
    现在,假设你想要对一个列或不同的列应用不同的函数。具体的办法是向agg传入一个从列名映射到函数的字典:

    grouped.agg({'tip' : np.max, 'size' : 'sum'})
    

    在这里插入图片描述

    grouped.agg({'tip_pct' : ['min', 'max', 'mean', 'std'],
                  'size' : 'sum'})
    

    在这里插入图片描述
    只有将多个函数应用到至少一列时,DataFrame才会拥有层次化的列。

    以“没有行索引”的形式返回聚合数据

    到目前为止,所有示例中的聚合数据都有由唯一的分组键组成的索引(可能还是层次化的)。由于并不总是需要如此,所以你可以向groupby传入 as_index=False 以禁用该功能:

    tips.groupby(['day', 'smoker'], as_index=False).mean()
    

    在这里插入图片描述
    当然,对结果调用 reset_index 也能得到这种形式的结果。使用as_index=False方法可以避免一些不必要的计算。

    3. apply:一般性的“拆分-应用-合并”

    最通用的GroupBy方法是apply,本节剩余部分将重点讲解它。如图10-2所示,apply会将待处理的对象拆分成多个片段,然后对各片段调用传入的函数,最后尝试将各片段组合到一起。
    在这里插入图片描述
    图10-2 分组聚合示例

    回到之前那个小费数据集,假设你想要根据分组选出最高的3个tip_pct值。首先,编写一个选取指定列具有最大值的行的函数:

    def top(df, n=3, column='tip_pct'):
         return df.sort_values(by=column)[-n:]
    top(tips, n=4)
    

    在这里插入图片描述

    现在,如果对smoker分组并用该函数调用apply,就会得到:

    tips.groupby('smoker').apply(top)
    

    (注意:agg和apply的区别是,agg对分组处理之后返回的是标量,apply对分组处理后,既可以返回标量也可以返回dataframe。)
    在这里插入图片描述
    这里发生了什么?**top函数在DataFrame的各个片段上调用,然后结果由pandas.concat组装到一起,并以分组名称进行了标记。**于是,最终结果就有了一个层次化索引,其内层索引值来自原DataFrame。

    如果传给apply的函数能够接受其他参数或关键字,则可以将这些内容放在函数名后面一并传入:

    tips.groupby(['smoker', 'day']).apply(top, n=1, column='total_bill')
    

    在这里插入图片描述

    笔记:除这些基本用法之外,能否充分发挥apply的威力很大程度上取决于你的创造力。传入的那个函数能做什么全由你说了算,它只需返回一个pandas对象或标量值即可。本章后续部分的示例主要用于讲解如何利用groupby解决各种各样的问题。

    可能你已经想起来了,之前我在GroupBy对象上调用过describe:

    result = tips.groupby('smoker')['tip_pct'].describe()
    result
    

    在这里插入图片描述

    result.unstack('smoker')
    

    在这里插入图片描述
    在GroupBy中,当你调用诸如describe之类的方法时,实际上只是应用了下面两条代码的快捷方式而已:

    f = lambda x: x.describe()
    grouped.apply(f)
    

    禁止分组键

    从上面的例子中可以看出,分组键会跟原始对象的索引共同构成结果对象中的层次化索引。将group_keys=False传入groupby即可禁止该效果:

    tips.groupby('smoker', group_keys=False).apply(top)
    # 和 as_index 参数的区别?
    

    在这里插入图片描述

    分位数和桶分析

    我曾在第8章中讲过,pandas有一些能根据指定面元或样本分位数将数据拆分成多块的工具(比如cut和qcut)。将这些函数跟groupby结合起来,就能非常轻松地实现对数据集的桶(bucket)或分位数(quantile)分析了。以下面这个简单的随机数据集为例,我们利用cut将其装入长度相等的桶中:

    frame = pd.DataFrame({'data1': np.random.randn(1000),
                          'data2': np.random.randn(1000)})
    # 将data1的全距四等分,并将每个元素归入每个区间中
    quartiles = pd.cut(frame.data1, 4)
    quartiles.head()
    

    在这里插入图片描述
    由cut返回的Categorical对象可直接传递到groupby。因此,我们可以像下面这样对data2列做一些统计计算:

    def get_stats(group):
        return {'min': group.min(), 'max': group.max(),
                'count': group.count(), 'mean': group.mean()}
    
    grouped = frame.data2.groupby(quartiles)
    grouped.apply(get_stats).unstack()
    

    在这里插入图片描述
    这些都是长度相等的桶。要根据样本分位数得到大小相等的桶,使用qcut即可。传入labels=False即可只获取分位数的编号:

    # Return quantile numbers 
    grouping = pd.qcut(frame.data1, 3, labels=False)
    # labels=False时,返回区间编号,而不是每个区间的起始标识
    grouping[:10]
    

    因为是分3桶,所以看到只有 0,1,2 这三个区间编号:
    在这里插入图片描述

    grouped = frame.data2.groupby(grouping)
    grouped.apply(get_stats).unstack()
    

    在这里插入图片描述

    我们会在第12章详细讲解pandas的Categorical类型。

    示例:用特定于分组的值填充缺失值

    对于缺失数据的清理工作,有时你会用dropna将其替换掉,而有时则可能会希望用一个固定值或由数据集本身所衍生出来的值去填充NA值。这时就得使用fillna这个工具了。在下面这个例子中,我用平均值去填充NA值:

    s = pd.Series(np.random.randn(6))
    # 这个写法表示2的倍数行
    s[::2] = np.nan
    s
    

    在这里插入图片描述

    s.fillna(s.mean())
    

    在这里插入图片描述

    假设你需要对不同的分组填充不同的值。一种方法是将数据分组,并使用apply和一个能够对各数据块调用fillna的函数即可。下面是一些有关美国几个州的示例数据,这些州又被分为东部和西部:

    states = ['Ohio', 'New York', 'Vermont', 'Florida',
    	          'Oregon', 'Nevada', 'California', 'Idaho']
    
    group_key = ['East'] * 4 + ['West'] * 4
    data = pd.Series(np.random.randn(8), index=states)
    data
    

    在这里插入图片描述
    [‘East’] * 4 产生了一个列表,包括了[‘East’]中元素的四个拷贝。将这些列表串联起来。

    将一些值设为缺失:

    data[['Vermont', 'Nevada', 'Idaho']] = np.nan
    data
    

    在这里插入图片描述

    data.groupby(group_key).mean()
    

    在这里插入图片描述
    我们可以用分组平均值去填充NA值:

    fill_mean = lambda g: g.fillna(g.mean())
    data.groupby(group_key).apply(fill_mean)
    

    返回的是各个填充后分组的合并:
    在这里插入图片描述
    此外,也可以在代码中预定义各组的填充值。
    由于分组具有一个name属性,所以我们可以拿来用一下:

    fill_values = {'East': 0.5, 'West': -1}
    fill_func = lambda g: g.fillna(fill_values[g.name])
    data.groupby(group_key).apply(fill_func)
    

    在这里插入图片描述

    示例:随机采样和排列

    假设你想要从一个大数据集中随机抽取(进行替换或不替换)样本以进行蒙特卡罗模拟(Monte Carlo simulation)或其他分析工作。“抽取”的方式有很多,这里使用的方法是对Series使用sample方法:

    # Hearts, Spades, Clubs, Diamondssuits = ['H', 'S', 'C', 'D']
    # 该游戏规则中各个颜色牌号的对应值。
    card_val = (list(range(1, 11)) + [10] * 3) * 4
    base_names = ['A'] + list(range(2, 11)) + ['J', 'K', 'Q']
    # cards 存放了所有的牌名,比如2H表示红桃2.
    cards = []
    for suit in ['H', 'S', 'C', 'D']:
        cards.extend(str(num) + suit for num in base_names)
    
    # [牌值,牌名 ] 对
    deck = pd.Series(card_val, index=cards)
    

    现在我有了一个长度为52的Series,其索引包括牌名,值则是21点或其他游戏中用于计分的点数(为了简单起见,我当A的点数为1):

    deck[:13]
    

    在这里插入图片描述
    现在,根据我上面所讲的,从整副牌中抽出5张,代码如下:

    def draw(deck, n=5):
         return deck.sample(n)
    draw(deck)
    

    在这里插入图片描述
    假设你想要从每种花色中随机抽取两张牌。由于花色是牌名的最后一个字符,所以我们可以据此进行分组,并使用apply:

    get_suit = lambda card: card[-1] # last letter is suit
    deck.groupby(get_suit).apply(draw, n=2)
    

    在这里插入图片描述
    或者,也可以这样写:

    deck.groupby(get_suit, group_keys=False).apply(draw, n=2)
    

    示例:分组加权平均数和相关系数

    根据groupby的 “拆分-应用-合并” 范式,可以进行DataFrame的列与列之间或两个Series之间的运算(比如分组加权平均)。以下面这个数据集为例,它含有分组键、值以及一些权重值:

    df = pd.DataFrame({'category': ['a', 'a', 'a', 'a',
                                     'b', 'b', 'b', 'b'],
                        'data': np.random.randn(8),
                        'weights': np.random.rand(8)})
    
    df
    

    在这里插入图片描述
    然后可以利用category计算分组加权平均数:

    grouped = df.groupby('category')
    get_wavg = lambda g: np.average(g['data'], weights=g['weights'])
    grouped.apply(get_wavg)
    

    在这里插入图片描述
    另一个例子,考虑一个来自Yahoo!Finance的数据集,其中含有几只股票和标准普尔500指数(符号SPX)的收盘价:

    # parse_dates=True 参数表示解析索引
    close_px = pd.read_csv('examples/stock_px_2.csv', parse_dates=True,
                            index_col=0)
    
    close_px.info()
    

    在这里插入图片描述

    close_px[-4:]
    

    在这里插入图片描述
    来做一个比较有趣的任务:计算一个由日收益率(通过百分数变化计算)与SPX之间的年度相关系数组成的DataFrame。下面是一个实现办法,我们先创建一个函数,用它计算每列和SPX列的成对相关系数:

    spx_corr = lambda x: x.corrwith(x['SPX'])
    

    接下来,我们使用pct_change计算close_px的百分比变化:

    rets = close_px.pct_change().dropna()
    

    最后,我们用年对百分比变化进行分组,可以用一个一行的函数,从每行的标签返回每个datetime标签的year属性:

    get_year = lambda x: x.year
    by_year = rets.groupby(get_year)
    by_year.apply(spx_corr)
    

    这个表的含义:2003年,个股AAPL的日收益率与SPX 的相关系数是0.541124
    在这里插入图片描述
    当然,你还可以计算列与列之间的相关系数。这里,我们计算Apple和Microsoft的年相关系数:

    by_year.apply(lambda g: g['AAPL'].corr(g['MSFT']))
    

    在这里插入图片描述

    示例:组级别的线性回归

    顺着上一个例子继续,你可以用groupby执行更为复杂的分组统计分析,只要函数返回的是pandas对象或标量值即可。例如,我可以定义下面这个regress函数(利用statsmodels计量经济学库)对各数据块执行普通最小二乘法(Ordinary Least Squares,OLS)回归:

    import statsmodels.api as sm
    def regress(data, yvar, xvars):
        Y = data[yvar]
        X = data[xvars]
        X['intercept'] = 1.0   #新增一列'intercept'(截距)
        result = sm.OLS(Y, X).fit()
        return result.params
    

    现在,为了按年计算AAPL对SPX收益率的线性回归,执行:

    by_year.apply(regress, 'AAPL', ['SPX'])
    

    在这里插入图片描述

    关于透视表和交叉表等高级聚合和分组方法,请见 python 数据聚合与分组运算(part 2)

    展开全文
  • 将list中某一属性相同的数据分组

    千次阅读 2020-03-12 13:57:19
    1 从数据库中取到了10条数据,放到了list中,这十条数据包含如下字段:订单号,订单明细号,发票号 2 10条数据中订单明细号都是不同的,但是订单号是可以相同的,假设订单号前三个是A,后三个是B,最后四个是C 3 那么...

    下面的举例:

    1 从数据库中取到了10条数据,放到了list中,这十条数据包含如下字段:订单号,订单明细号,发票号

    2 10条数据中订单明细号都是不同的,但是订单号是可以相同的,假设订单号前三个是A,后三个是B,最后四个是C

    3 那么问题来了,由于业务需要,现在只想取每笔订单的第一条明细订单的发票,请问该如何实现呢?

    4.订单编号中的相同的数据是连续的

    思路:首先获得所有数据list(orders),创建返回的list(targetOrders)
    然后将第一条存储进去list(targetOrders),默认订单编号orderId为第一条的数据的
    最后遍历list(order),因为订单编号中的相同的数据是连续的,所以从第二条数据起,只要跟第一条相同的就跳过,不同的就设置新的默认orderId,并将这一条新的orderId的数据存储进去list(targetOrder)

    在这里插入图片描述

    
    //数据库所有订单
    List<Order> orders = getOrders();
    //创建返回目标订单,储存每笔订单的第一条明细订单的发票
    List<Order> targetOrders = new Arraylist<Order>;
    
    //第一条就是第一个订单的明细
    Order order = list.get(0);
    //首先将第一条数据存进去需要返回的订单中
    targetOrders.add(order );
    
    //获取第一条订单编号
    Integer currentOrderId = order.getOrderId();
    
    //从第二个记录开始,找下一条订单的明细
    if(list.size()>1){
         for(int i =1;i<list.size();i++){
                  Order order2 = list.get(i);
                   //订单编号是同一条,继续找
                   if(currentOrderId == order2.getOrderId()){
                       continue;
                   }
    				//设置下一个编号
                   currentOrderId = order2.getOrderId();
                   //找到了,就存储到返回的list中
                   targetOrders.add(order2);
             }
    }
    
    展开全文
  • python中数据聚合与分组运算

    千次阅读 2017-11-24 19:12:37
    数据分析处理中,对数据进行分组并对各组应用一个函数(无论是聚合还是转换)计算分组统计或生成透视表,是数据分析工作中的重要环节。 python提供了一个灵活高效的groupby功能,它可以使你能以一种自然的方式对...
  • 1.分组级运算转换 聚合只不过是分组运算的其中一种而已。介绍transformapply方法,它们能够执行更多其他的分组运算 假设我们想要为一个DataFrame添加一个用于存放各索引分组平均值的列。一个办法是先聚合再合并 ...
  • 分组级运算转换 聚合是分组运算的其中一种。它是数据转换的一个特例,它接受能够将一维数组简化为标量值的函数。 接下来将介绍transformapply方法,它们能够执行更多其他的分组运算。 如果要为一个DataFrame...
  • 计算域是指在数据窗口的设计状态下添加到数据窗口中的Computed Field部件,它是一个数据窗口部件,具有部件的属性特征。计算字段是指在数据窗口对应的SQL语句中添加的表达式,计算字段是一个字段,它具有字段的属性...
  • Python将一个列表中的元素分成两组,使得每组数据尽可能的相等 # 分离数组 def split_array(arr): # 获取数组并排序 a = list(arr) #a.sort() # 另一个数组 b = list() # 以上a,b作为待返回的数组 # ...
  • * 比较两个list集合中map:childList 中 包含 parentList的 map 中的 key值,如果相等重新放到一个map&lt;String,List&lt;Map&lt;String,String&gt;&gt;里 * * */ public static Map&...
  • 在java8之前可以使用遍历使用map进行分组。 而在 Java 8 lambda表达式出现后,可以使用 groupingBy 收集器,一行代码实现,简单方便: Map< , > Map = list.stream().collect(groupingBy(*::get*)); (第...
  • 数据分组运算—groupby参数解读基本使用1)Series分组2)DataFrame的分组GroupBy对象size方法分组进行迭代依据每列数据类型进行分组分组后选取一个或一组列进行运算使用字典或者Series进行分组1)字典形式进行分组...
  • pandas的groupby功能,可以计算 分组统计生成透视表,可对数据集进行灵活的切片、切块、摘要等操作GroupBy技术“split-apply-comebine”(拆分-应用-合并)
  • pandas 数据聚合与分组运算

    千次阅读 2018-07-17 18:53:38
    pandas对象(无论是Series、DataFrame还是其他的)中的数据会根据你所提供的一个或多个键被拆分(split)为多组。 拆分操作是在对象的特定轴上执行的。 例如:DataFrame可以在其行(axis=0)或列(axis=1)上进行分组,然后...
  • 拔河分组

    千次阅读 2016-12-31 14:02:04
    有12个同学要分成两个组进行拔河比赛,为使比赛公平,分组时要求每组6个同学,且两组的体重之相等;已知这12个同学的体重分别为:38、39、47、35、46、58、51...说明:我们把“要求每组数据个数相等数据和也相等”的
  • MySQL对数据表进行分组查询(GROUP BY) GROUP BY关键字可以将查询结果按照某个字段或多个字段进行分组。字段中值相等的为一组。基本的语法格式如下: GROUP BY 属性名 [HAVING 条件表达式] [WITH ROLLUP] 属性...
  • 数据聚合2.1面向列的多函数应用2.2返回不含行索引的聚合数据10.3 应用(apply):通用“拆分-应用-合并”3.1禁用分组索引3.2分位数桶分析3.3示例:用特定于分组的值填充缺失值3.4 示例:随机采样排列3.5 示例:...
  • 我们在上面的内容中为大家解释了数据分析中的分组...数量指标分组分析法有单项式分组和组距式分组。现在我们给大家说一说单项式分组。单项式分组一般适用于离散型数据,而且数据值不多、变动范围较小的情况。每个...
  • LINQ分组取出第一条数据

    千次阅读 2019-07-10 10:58:30
    以上list如果直接使用distinct方法进行过滤,仍然返回3条数据,而需要的结果是2条数据。下面给出解这个问题的方法: 方法1: Distinct 方法中使用的相等比较器。这个比较器需要重写EqualsGetHashCode方...
  • MySQL分组然后取每个分组中按照某些字段排序的topN条数据 建表 CREATE TABLE `t` ( `a` int(11) DEFAULT NULL, `b` int(11) DEFAULT NULL, `c` int(11) DEFAULT NULL, `itime` timestamp NOT NULL DEFAULT ...
  • groupby,聚合,分组级运算,python 数据分析
  • mysql查询分组显示数据结果之GROUP_CONCAT使用
  • 使用Java实现对数据分组并求和,分组的依据只能是单纯的字段,不能涉及到在求和,最大值等,但是字段的数量名称可以是不定的,求和的字段的数量名称也是不定的。同时反思自己的思考问题的,解决的方法方向
  • 报文交换 报文:源(应用)发送信息整体 比如:一个文件 分组交换 分组:报文分拆出来的一系列相对较小的数据包 ...发送主机::接收应用报文(消息),拆分为较小长度为 L bits的分组(packets),在...
  • 连接查询和分组查询

    千次阅读 2017-09-28 15:59:51
    *** 分组查询: ** 使用 group by 进行分组查询 语句:《有列名:StudentID,CourseID,Scores》 select CourseID,avg(S cores) as 课程平均成绩 from Score group by CourseID 例 1:查询男女学生的人数各是多
  • 使用场景如下:对一张数据数据进行select查询操作,要求:对消息类型进行分组,然后获取每种类型最新的一条信息 实现思路获取最新数据 一般数据表插入的时候ID主键一般都是自动递增的,所以最新数据ID肯定最大。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 54,580
精华内容 21,832
关键字:

和相等数据分组