利用python进行数据分析之数据聚合和分组运算

最新推荐文章于 2024-05-31 14:54:28 发布
最新推荐文章于 2024-05-31 14:54:28 发布
阅读量210 收藏
点赞数
文章标签： 大数据 数据结构与算法 python

对数据集进行分组并对各分组应用函数是数据分析中的重要环节。

group by技术

pandas对象中的数据会根据你所提供的一个或多个键被拆分为多组，拆分操作是在对象的特定轴上执行的，然后将一个函数应用到各个分组并产生一个新值，最后所有这些函数的执行结果会被合并到最终的结果对象中。

复制代码 
>>> from pandas import *
>>> df=DataFrame({'key1':['a','a','b','b','a'],'key2':['one','two','one','two','one'],'data1':np.random.randn(5),'data2':np.random.randn(5)}) >>> df data1 data2 key1 key2 0 -1.413818 -0.865514 a one 1 -1.001804 0.309597 a two 2 0.357458 -0.387695 b one 3 0.674294 -0.977009 b two 4 -0.090150 2.444888 a one >>> grouped=df['data1'].groupby(df['key1']) >>> grouped <pandas.core.groupby.SeriesGroupBy object at 0x04005770>
#生成一个groupby对象，实际上还未进行任何计算，可对其调用方法进行计算 >>> grouped.mean() key1 a -0.835257 b 0.515876 Name: data1, dtype: float64
#此外，可将列名直接当作分组对象，分组中，数值列会被聚合，非数值列会从结果中排除 >>> df.groupby('key1').mean() data1 data2 key1 a -0.835257 0.629657 b 0.515876 -0.682352 >>> df.groupby(['key1','key2']).mean() data1 data2 key1 key2 a one -0.751984 0.789687 two -1.001804 0.309597 b one 0.357458 -0.387695 two 0.674294 -0.977009
复制代码

 无论你准准备拿groupby做什么，都可能会使用groupby的size方法，可以返回一个含有分组大小的series；

复制代码 
>>> df.groupby(['key1','key2']).size() key1 key2 a one 2 two 1 b one 1 two 1 dtype: int64
复制代码

 1、对分组进行迭代

groupby对象支持迭代，可以产生一组二元数组（由分组名称和数据块构成）

复制代码 
>>> for name,group in df.groupby('key1'): print name print group a data1 data2 key1 key2 0 -1.413818 -0.865514 a one 1 -1.001804 0.309597 a two 4 -0.090150 2.444888 a one b data1 data2 key1 key2 2 0.357458 -0.387695 b one 3 0.674294 -0.977009 b two
复制代码

 对于多重键的情况，元祖的第一个元素将会是由键值组成的元组

复制代码 
>>> for (k1,k2),group in df.groupby(['key1','key2']): print k1,k2 print group a one data1 data2 key1 key2 0 -1.413818 -0.865514 a one 4 -0.090150 2.444888 a one a two data1 data2 key1 key2 1 -1.001804 0.309597 a two b one data1 data2 key1 key2 2 0.357458 -0.387695 b one b two data1 data2 key1 key2 3 0.674294 -0.977009 b two
复制代码

 groupby分组默认是在axis=0上进行分组的，通过设置也可以在其他轴上进行分组

复制代码 
>>> df.dtypes
data1    float64
data2    float64
key1      object
key2      object
dtype: object
>>> grouped=df.groupby(df.dtypes,axis=1)
>>> dict(list(grouped))
{dtype('O'): key1 key2 0 a one 1 a two 2 b one 3 b two 4 a one, dtype('float64'): data1 data2 0 -1.413818 -0.865514 1 -1.001804 0.309597 2 0.357458 -0.387695 3 0.674294 -0.977009 4 -0.090150 2.444888}
复制代码

 2、选取一个或一组列

对于DataFrame产生的groupby对象，如果用一个或一组列名对其进行索引，就能实现选取部分列进行聚合的目的

复制代码 
>>> df
      data1     data2 key1 key2
0 -1.413818 -0.865514    a  one
1 -1.001804  0.309597    a  two
2  0.357458 -0.387695    b  one
3  0.674294 -0.977009    b  two
4 -0.090150  2.444888 a one >>> df.groupby('key1')['data1'] <pandas.core.groupby.SeriesGroupBy object at 0x04005FB0>

　　>>> df.groupby('key1')['data1'].mean()
　　key1
　　a -0.835257
　　b 0.515876

复制代码

尤其对于大数据集，可能只需要对部分列进行聚合

复制代码 
>>> df.groupby(['key1','key2'])[['data2']].mean() #注意data2的形式，如果传入的是标量名称则不同  data2 key1 key2 a one 0.789687 two 0.309597 b one -0.387695 two -0.977009 >>> df.groupby(['key1','key2'])['data2'].mean() key1 key2 a one 0.789687 two 0.309597 b one -0.387695 two -0.977009 Name: data2, dtype: float64
复制代码

 3、通过字典或Series进行分组

除数组以外，分组信息还可以以其他形式存在

复制代码 
>>> people=DataFrame(np.random.randn(5,5),columns=['a','b','c','d','e'],index=['joe','steve','wes','jim','travis']) >>> people a b c d e joe -1.136829 -0.549897 1.382399 -1.457968 -1.975316 steve 0.633057 0.905028 0.615449 -1.307026 -0.150066 wes 0.715308 -1.546033 1.090450 -0.699447 0.308514 jim 0.127834 0.134140 0.218690 0.298301 0.722678 travis 1.561881 0.283804 0.017650 1.231204 -1.732033 >>> people.ix[2:3,['b','c']]=np.nan >>> people a b c d e joe -1.136829 -0.549897 1.382399 -1.457968 -1.975316 steve 0.633057 0.905028 0.615449 -1.307026 -0.150066 wes 0.715308 NaN NaN -0.699447 0.308514 jim 0.127834 0.134140 0.218690 0.298301 0.722678 travis 1.561881 0.283804 0.017650 1.231204 -1.732033 >>> mapping={'a':'red','b':'red','c':'blue','d':'blue','e':'red'} >>> by_column=people.groupby(mapping,axis=1) >>> by_column.sum() blue red joe -0.075569 -3.662042 steve -0.691577 1.388018 wes -0.699447 1.023822 jim 0.516991 0.984652 travis 1.248854 0.113652
复制代码

Series也有这样的功能，它可以被看作一个固定大小的映射

复制代码 
>>> map_series=Series(mapping)
>>> map_series
a     red
b     red
c    blue
d    blue
e     red
dtype: object
>>> people.groupby(map_series,axis=1).sum()
            blue       red
joe    -0.075569 -3.662042
steve  -0.691577  1.388018
wes    -0.699447  1.023822 jim 0.516991 0.984652 travis 1.248854 0.113652
复制代码

4、通过函数进行分组

相较于字典或者Series，python函数在定义分组映射关系时可以更具创意和抽象，任何被当作分组键的函数都会在索引值上被调用一次，其返回值被当作分组名称

复制代码 
#根据人名长度进行分组
>>> people.groupby(len).sum()
          a         b         c         d         e
3 -0.293687 -0.415757  1.601089 -1.859114 -0.944124
5  0.633057  0.905028  0.615449 -1.307026 -0.150066
6  1.561881  0.283804  0.017650  1.231204 -1.732033
复制代码

将函数，列表，字典混用也没问题，因为任何东西最终会被转换为数组

复制代码 
>>> keyliat=['one','one','one','two','two'] >>> people.groupby([len,keyliat]).min() a b c d e 3 one -1.136829 -0.549897 1.382399 -1.457968 -1.975316 two 0.127834 0.134140 0.218690 0.298301 0.722678 5 one 0.633057 0.905028 0.615449 -1.307026 -0.150066 6 two 1.561881 0.283804 0.017650 1.231204 -1.732033
复制代码

5、根据索引级别分组

层次化索引的数据集最方便的地方在于它能够根据索引级别进行聚合，实现该目的，通过level关键字传入级别编号或名称即可。

复制代码 
>>> import numpy as np
>>> hief_df=DataFrame(np.random.randn(4,5),columns=columns)
>>> hief_df
cty           us                            jp          
tennor         1         3         5         1         3
0      -0.185892 -0.517436 -0.040285  1.274849  0.015439
1      -1.757972 -0.650451  0.863938  0.467745 -0.288524
2       1.512232 -0.494746 -0.119517  1.047349 -0.627444
3      -0.656453  0.858041  1.218276  1.138983  0.997657
>>> hief_df.groupby(level='cty',axis=1).count() cty jp us 0 2 3 1 2 3 2 2 3 3 2 3
复制代码

数据聚合

 对于聚合,一般指的是能够从数组产生的标量值的数据转换过程,常见的聚合运算都有相关的统计函数快速实现,当然也可以自定义聚合运算

要使用自己的定义的聚合函数,需将其传入aggregate或agg方法即可

复制代码 
>>> df=DataFrame({'key1':['a','a','b','b','a'],'key2':['one','two','one','two','one'],'data1':np.random.randn(5),'data2':np.random.randn(5)}) >>> df data1 data2 key1 key2 0 -1.299938 -1.269616 a one 1 -0.279184 -0.037004 a two 2 -0.851559 -0.527337 b one 3 1.140124 0.882907 b two 4 0.406030 -0.365484 a one >>> grouped=df.groupby('key1') >>> def peak_to_peak(arr): return arr.max()-arr.min() >>> grouped.agg(peak_to_peak) data1 data2 key1 a 1.705968 1.232612 b 1.991683 1.410243
复制代码

 describe方法也可使用,但严格来说这些并非聚合运算

复制代码 
>>> grouped.describe()
               data1     data2
key1                          
a    count  3.000000  3.000000
     mean  -0.391031 -0.557368
     std    0.858466  0.638316
     min   -1.299938 -1.269616
     25%   -0.789561 -0.817550
     50%   -0.279184 -0.365484
     75%    0.063423 -0.201244
     max    0.406030 -0.037004 b count 2.000000 2.000000 mean 0.144282 0.177785 std 1.408332 0.997193 min -0.851559 -0.527337 25% -0.353638 -0.174776 50% 0.144282 0.177785 75% 0.642203 0.530346 max 1.140124 0.882907
复制代码

 1、面向列的多函数应用

前面已经看到对Series或DataFrame列的聚合运算其实就是使用aggregate调用自定义函数或者直接调用诸如mean，std之类的方法；

但是当你希望对不同列使用不同的聚合函数时看如下事例：

复制代码 
>>> tips['tip_pct']=tips['tip']/tips['total_bill'] >>> tips[:6] total_bill tip sex smoker day time size tip_pct 0 16.99 1.01 Female No Sun Dinner 2 0.059447 1 10.34 1.66 Male No Sun Dinner 3 0.160542 2 21.01 3.50 Male No Sun Dinner 3 0.166587 3 23.68 3.31 Male No Sun Dinner 2 0.139780 4 24.59 3.61 Female No Sun Dinner 4 0.146808 5 25.29 4.71 Male No Sun Dinner 4 0.186240 >>> grouped=tips.groupby(['sex','smoker']) >>> grouped_pct=grouped['tip_pct'] #可以将函数名以字符串的形式传入 >>> grouped_pct.agg('mean') sex smoker Female No 0.156921 Yes 0.182150 Male No 0.160669 Yes 0.152771 Name: tip_pct, dtype: float64
复制代码

 如果传入一组函数或者函数名，则得到的DataFrame列就会以相应的函数命名，实际操作中并不一定需要接受默认的函数名，可以传入一个由（name,function）元组组成的列表当作一个有序映射。

复制代码 
>>> grouped_pct.agg(['mean','std']) mean std sex smoker Female No 0.156921 0.036421 Yes 0.182150 0.071595 Male No 0.160669 0.041849 Yes 0.152771 0.090588
复制代码
复制代码 
>>> grouped_pct.agg([('foo','mean'),('bar',np.std)]) foo bar sex smoker Female No 0.156921 0.036421 Yes 0.182150 0.071595 Male No 0.160669 0.041849 Yes 0.152771 0.090588
复制代码

对于DataFrame，还可以定义一组应用于全部列的函数，或不同的列应用不同的函数，这样会产生层次化索引的DataFrame

复制代码 
>>> functions=['count','mean','max'] >>> result=grouped['tip_pct','total_bill'].agg(functions) >>> result tip_pct total_bill count mean max count mean max sex smoker Female No 54 0.156921 0.252672 54 18.105185 35.83 Yes 33 0.182150 0.416667 33 17.977879 44.30 Male No 97 0.160669 0.291990 97 19.791237 48.33 Yes 60 0.152771 0.710345 60 22.284500 50.81
复制代码

 现在假设想要对不同的列应用不同的函数，具体的办法就是向agg传入一个从列名映射到函数的字典

复制代码 
>>> grouped.agg({'tip':np.max,'size':'sum'}) tip size sex smoker Female No 5.2 140 Yes 6.5 74 Male No 9.0 263 Yes 10.0 150 >>> grouped.agg({'tip_pct':['min','max','mean'],'size':'sum'}) tip_pct size min max mean sum sex smoker Female No 0.056797 0.252672 0.156921 140 Yes 0.056433 0.416667 0.182150 74 Male No 0.071804 0.291990 0.160669 263 Yes 0.035638 0.710345 0.152771 150
复制代码

 2、以无索引的形式返回聚合数据

一般情况下，聚合数据都需要唯一的分组键组成的索引，但也可以通过向groupby传入as_index=False以禁用该功能

复制代码 
>>> tips.groupby(['sex','smoker'],as_index=False).mean() sex smoker total_bill tip size tip_pct 0 Female No 18.105185 2.773519 2.592593 0.156921 1 Female Yes 17.977879 2.931515 2.242424 0.182150 2 Male No 19.791237 3.113402 2.711340 0.160669 3 Male Yes 22.284500 3.051167 2.500000 0.152771
复制代码

分组运算和转换

聚合仅是分组运算的一种，它是数据转换的一个特例，本节介绍transform和apply方法，他们能够执行更多其他的分组运算

以下是为一个DataFrame添加一个用于存放各索引组平均值的列，利用了先聚合再合并

 

复制代码 
>>> df
      data1     data2 key1 key2
0 -1.359405 -0.567306    a  one
1 -0.298647 -1.078614    a  two
2  0.355256  0.693866    b  one
3 -1.452335 -0.666225    b  two
4  1.036177  1.811104 a one >>> k1_means=df.groupby('key1').mean() >>> k2_means=df.groupby('key1').mean().add_prefix('mean_') >>> k1_means data1 data2 key1 a -0.207292 0.055061 b -0.548539 0.013821 >>> k2_means mean_data1 mean_data2 key1 a -0.207292 0.055061 b -0.548539 0.013821 >>> merge(df,k2_means,left_on='key1',right_index=True) data1 data2 key1 key2 mean_data1 mean_data2 0 -1.359405 -0.567306 a one -0.207292 0.055061 1 -0.298647 -1.078614 a two -0.207292 0.055061 4 1.036177 1.811104 a one -0.207292 0.055061 2 0.355256 0.693866 b one -0.548539 0.013821 3 -1.452335 -0.666225 b two -0.548539 0.013821
复制代码

 

实际上可以对DataFrame进行transform方法，对比一下下面两种的区别，transform会将一个函数应用到各个分组

复制代码 
>>> df.groupby('key2').transform(np.mean)
      data1     data2
0  0.010676  0.645888
1 -0.875491 -0.872420
2  0.010676  0.645888
3 -0.875491 -0.872420
4  0.010676  0.645888
>>> df.groupby('key2').mean() data1 data2 key2 one 0.010676 0.645888 two -0.875491 -0.872420
复制代码

1、apply，一般性的拆分-应用-合并

 最一般的groupby方法是apply，apply会将待处理的对象拆分为多个片段，然后对各个片段调用传入的函数，最后尝试将各片段组合在一起，

在groupby中，当你调用诸如describe之类的方法时，实际上是应用了快捷方式：f=lambda x:x.describe();grouped.apply(f)

 2、分位数和桶分析

pandas有一些能根据指定面元或样本分位数将数据拆分为多块的工具（比如cut和qcut），将这些数据跟groupby结合起来，就能轻松的对数据集的桶或分位数分析

复制代码 
>>>frame=DataFrame({'data1':np.random.randn(1000),'data2':np.random.randn(1000)}) >>> factor=cut(frame.data1,4) >>> factor[:10] 0 (-1.35, 0.107] 1 (0.107, 1.563] 2 (-1.35, 0.107] 3 (-2.812, -1.35] 4 (0.107, 1.563] 5 (0.107, 1.563] 6 (-1.35, 0.107] 7 (-1.35, 0.107] 8 (-1.35, 0.107] 9 (1.563, 3.02] Name: data1, dtype: category Categories (4, object): [(-2.812, -1.35] < (-1.35, 0.107] < (0.107, 1.563] < (1.563, 3.02]]
复制代码

cut返回的factor对象可直接用于groupby，分为长度相等的桶；

复制代码 
>>> def get_stats(group):
    return {'min':group.min(),'max':group.max(),'count':group.count(),'mean':group.mean()} >>> grouped=frame.data2.groupby(factor) >>> grouped.apply(get_stats).unstack() count max mean min data1 (-2.812, -1.35] 79 2.791474 0.023155 -2.577103 (-1.35, 0.107] 433 2.942033 0.066771 -2.812077 (0.107, 1.563] 437 2.391669 0.022582 -2.654376 (1.563, 3.02] 51 2.652038 0.406708 -2.387372
复制代码

 若要得到大小相等的桶，使用qcut即可

复制代码 
>>> grouping=qcut(frame.data1,10,labels=False)
>>> grouped=frame.data2.groupby(grouping)
>>> grouped.apply(get_stats).unstack()
   count       max      mean       min
0    100  2.791474  0.025400 -2.577103
1    100  2.536797 -0.094773 -2.046163
2    100  2.942033  0.243372 -1.671060
3    100  2.566991  0.059096 -2.252417
4    100  2.589560  0.053143 -2.812077
5    100  1.743871 -0.041336 -2.448941
6    100  2.295631  0.157645 -2.264740
7    100  2.391669 -0.012642 -2.076873
8    100  2.164782  0.026390 -2.654376
9    100  2.652038  0.197221 -2.387372
复制代码

 3、用特定分组的值填充缺失值

对于缺失数据的清理工作，有时你会用dropna将其删除，有时可能会希望用一个固定值或由数据集本事衍生出来的值去填充na值，这时应该使用fillna工具

复制代码 
>>> from pandas import *
>>> s=Series(np.random.randn(6))
>>> s[::2]=np.nan
>>> s
0         NaN
1    0.730366
2 NaN 3 1.072793 4 NaN 5 -0.720886 dtype: float64 >>> s.fillna(s.mean()) 0 0.360758 1 0.730366 2 0.360758 3 1.072793 4 0.360758 5 -0.720886 dtype: float64
复制代码

假设需要对不同的分组填充不同的值，只需将数据分组，并使用apply和一个能够对各数据块调用的fillna的函数即可

复制代码 
>>> state=['ohio','new york','vermont','florida','oregen','nevada','california','idaho'] >>> group_key=['east']*4+['west']*4 >>> group_key ['east', 'east', 'east', 'east', 'west', 'west', 'west', 'west'] >>> data=Series(np.random.randn(8),index=state) >>> data[['vermont','nevada','idaho']]=np.nan >>> data ohio -1.032728 new york -1.162002 vermont NaN florida -0.571487 oregen -0.997641 nevada NaN california 1.149481 idaho NaN dtype: float64 >>> data.groupby(group_key).mean() east -0.922072 west 0.075920 dtype: float64 #利用分组平均去填充na值 >>> fill_mean=lambda g:g.fillna(g.mean()) >>> data.groupby(group_key).apply(fill_mean) ohio -1.032728 new york -1.162002 vermont -0.922072 florida -0.571487 oregen -0.997641 nevada 0.075920 california 1.149481 idaho 0.075920 dtype: float64
复制代码

4、分组加权平均数和相关系数

根据 拆分-应用-合并 范式，DataFrame的列与列之间或两个Series之间的运算成为一种标准运算

复制代码 
>>> df=DataFrame({'category':['a','a','a','a','b','b','b','b'],'data':np.random.randn(8),'weights':np.random.rand(8)}) >>> df category data weights 0 a -1.196080 0.247188 1 a -1.695342 0.914525 2 a 1.521977 0.483654 3 a 0.814892 0.267910 4 b -0.507479 0.204920 5 b -0.696985 0.097827 6 b -0.748492 0.105464 7 b 0.837663 0.404254 >>> grouped=df.groupby('category') >>> get_wavg=lambda g:np.average(g['data'],weights=g['weights']) >>> grouped.apply(get_wavg) category a -0.466038 b 0.107713 dtype: float64
复制代码

5、面向分组的线性回归

你可以用groupby执行分组更为复杂的分组统计分析，只要函数返回的是pandas对象或者标量值即可。

透视表和交叉表

在pandas中，可以通过groupby功能以及重塑运算制作透视表，DataFrame还有一个pivot_table方法，此外还有一个顶级的pandas.pivot_table函数。

复制代码 
>>> tips.pivot_table(index=['sex','smoker']) size tip total_bill sex smoker Female No 2.592593 2.773519 18.105185 Yes 2.242424 2.931515 17.977879 Male No 2.711340 3.113402 19.791237 Yes 2.500000 3.051167 22.284500 >>> tips.pivot_table(['tip_pct','size'],index=['sex','day'],columns='smoker') size smoker No Yes sex day Female Fri 2.500000 2.000000 Sat 2.307692 2.200000 Sun 3.071429 2.500000 Thur 2.480000 2.428571 Male Fri 2.000000 2.125000 Sat 2.656250 2.629630 Sun 2.883721 2.600000 Thur 2.500000 2.300000
复制代码

要使用其他的聚合函数，可将函数传入aggfunc参数即可

复制代码 
>>> tips.pivot_table('size',index=['sex','smoker'],columns='day',aggfunc=len) day Fri Sat Sun Thur sex smoker Female No 2 13 14 25 Yes 7 15 4 7 Male No 2 32 43 20 Yes 8 27 15 10
复制代码

 交叉表是一种用于计算分组频率的特殊透视表

复制代码 
>>> pd.crosstab([tips.time,tips.day],tips.smoker,margins=True)
#指定行与列交叉统计，margins参数用于是否进行分项小计
smoker        No  Yes  All
time   day                
Dinner Fri     3    9   12
       Sat    45   42   87 Sun 57 19 76 Thur 1 0 1 Lunch Fri 1 6 7 Thur 44 17 61 All 151 93 244
复制代码

 

weixin_33858249
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python数据分析之数据聚合与分组运算（拆分、应用、合并）
LiangPi的博客
04-24 7367
在Pandas中，分组是指使用特定的条件将原数据划分为多个组，聚合在这里指的是，对每个分组中的数据执行某些操作，最后将计算的结果进行整合。 此笔记记录在python数据分析学习过程中的数据聚合与分组运算，其中所提方法做记录，方便今后查看。
Python数据分析之数据聚合与分组运算
dawdaddad的博客
05-17 2632
1.分组与聚合的原理 在Pandas中： ​分组：指使用特定的条件将原数据划分为多个组； ​聚合：对每个分组中的数据执行某些操作，最后将计算的结果进行整合。 1.2分组与聚合的过程分为三步 1.2.1拆分 将数据集按照些标准拆分为若干个组。split拆分方法 1.2.2应用 将某个函数或方法（内置和自定义均可）应用到每个分组。apply方法应用 1.2.3合并 将产生的新值整合到结果对象中。combine方法整合 2. 通过groupby()方法将数据拆分成组 ​ 在Pandas中，可以通..
Python Pandas聚合运算
qq_41782791的博客
05-07 250
数据处理的最后一步为数据聚合，通常指的是转换数据，是每一个数组生成一个单一的数值。我们已经做过多种数据聚合操作，例如sum( )、mean( )和count( )。这些函数均是操作一组数据，得到的结果只有一个数值。然而，对数据进行分类等聚合操作更为正式，对数据的控制力更强。 对分组进行一系列的操作，内置聚合函数 df = pd.DataFrame({'key1': ['a', 'a', 'b', ...
Python数据分析13——数据聚合运算
Py.ziMing的博客
06-02 495
分组运算 transfrom方法 apply方法 数据透视表 透视表 交叉表
python：pandas的stack和unstack函数
qq_41081716的博客
11-29 1086
在用pandas进行数据重排时，经常用到stack和unstack两个函数。stack的意思是堆叠，堆积，unstack即“不要堆叠”。 常见的数据的层次化结构有两种，一种是表格，一种是“花括号”，即下面这样的l两种形式： df = pd.DataFrame({'key1' : ['a', 'a', 'b', 'b', 'a'], 'key2...
Python数据分析实战【第三章】2.19-Pandas数据分组【python】
Caption C
04-24 1083
【课程2.19】 数据分组 分组统计 - groupby功能 ① 根据某些条件将数据拆分成组 ② 对每个组独立应用函数 ③ 将结果合并到一个数据结构中 1.分组 df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar','foo', 'bar', 'foo', 'foo'], 'B' : ['one', 'on...
利用python进行数据分析之数据聚合和分组运算--小白笔记
m0_53653044的博客
09-05 981
GroupBy机制 split-apply-combine(拆分-应用-合并) 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.
利用Python进行数据分析：数据聚合与分组运算（基于DataFrame）
m0_60862600的博客
05-25 1853
利用Python进行数据分析：数据聚合与分组运算 在将数据集加载、融合、准备好之后，通常就是计算分组统计或生成透视表。pandas提供了一个灵活高效的gruopby功能，对数据集进行切片、切块、摘要等操作。 使用一个或多个键（形式可以是函数、数组或DataFrame列名）分割pandas对象。 计算分组的概述统计，比如数量、平均值或标准差，或是用户定义的函数。 应用组内转换或其他运算，如规格化、线性回归、排名或选取子集等。 计算透视表或交叉表。 执行分位数分析以及其它统计分组分析。 下图为panda
【利用Python进行数据分析】10 数据聚合与分组计算
小狐狸
02-13 1845
对数据集进行分组并对各组应用一个函数，是数据分析工作中的重要环节。在将数据集加载、融合、准备好之后，通常就是计算分组统计或生成透视表。pandas提供了一个灵活高效的gruopby功能，实现对数据集进行切片、切块、摘要等操作。 使用一个或多个键（形式可以是函数、数组或DataFrame列名）分割pandas对象。 计算分组的概述统计，比如数量、平均值或标准差，或是用户定义的函数。 应用组内转换或...
python3数据聚合与分组运算.docx
03-16
对数据集进行分组并对各组应用一个函数（无论是聚合还是转换），这是数据分析工作中的重要环节。在将数据集准备好之后，通常的任务就是计算分组统计或生成透视表。pandas提供了一个灵活高效的groupby功能，它使我们...
第9章数据聚合与分组运算.xmind
06-07
《利用python进行数据分析 》的第9章数据聚合与分组运算思维导图笔记
python数据分析 第10章 数据聚合与分组运算.ppt
02-17
python数据分析 第10章 数据聚合与分组运算.ppt 课件 第10章 数据聚合与分组运算
Python DataFrame.groupby()聚合函数,分组级运算
12-24
pandas提供了一个灵活高效的groupby功能，它使你能以一种自然的方式对数据集进行切片、切块、摘要等操作。根据一个或多个键（可以是函数、数组或DataFrame列名）拆分pandas对象。计算分组摘要统计，如计数、平均值、...
Python 在数据分析和可视化方面拥有强大的功能，它提供了许多库和工具，使得数据分析和数据可视化过程变得更加简单和高效 以下是
05-27
Python 在数据分析和可视化方面拥有强大的功能，它提供了许多库和工具，使得数据分析和数据可视化过程变得更加简单和高效。以下是 Python 在数据分析和可视化中的一些主要库及其功能： 数据分析库 NumPy： 是 ...
深入解析CRM客户关系系统：技术架构与功能实现的融合创新
最新发布
m0_65038841的博客
05-31 417
通过以上技术架构和功能实现，CRM客户关系管理系统能够帮助企业实现客户信息的集中管理、销售过程的自动化、营销活动的精准投放以及客户服务的提升，从而提高企业的市场竞争力和客户满意度。容器化与微服务：采用Docker和Kubernetes等技术，实现系统的容器化和微服务架构，提高系统可扩展性和部署灵活性。营销活动管理：创建、发布和管理各种营销活动，如优惠券、促销活动和线上线下活动等，支持活动效果分析。客户信息管理：实现对客户基本信息的录入、查询、修改和删除功能，支持多维度客户细分和标签管理。
Apache Impala 4.4.0正式发布了！
Stiga Huang的专栏
05-28 930
Apache Impala 4.4.0正式发布了！
kafka的安装
沉下心,苦磨炼
05-27 315
性能压测kafka
ELT 同步 MySQL 到 Doris
eagle89的专栏
05-29 930
同步 MySQL 到 Doris
理解接口回调及其在 RabbitMQ 中的实际运用
weixin_54574094的博客
05-30 352
通过上述示例，读者可以更好地理解接口回调的概念和原理，并了解其在 RabbitMQ 中的实际应用。接口回调是一种强大的编程模式，适用于异步编程中的各种场景，包括消息队列系统中的消息处理。本文将通过一个简单的示例介绍接口回调的概念和原理，并探讨它在 RabbitMQ 中的实际应用。通过接口回调，调用方可以将回调函数传递给某个异步操作，当操作完成或满足特定条件时，回调函数会被调用，从而实现异步处理。方法订阅了一个队列，并设置了回调函数。类负责执行一个异步操作，并在操作完成时调用传递进来的回调函数。
使用Python进行数据分析
09-18
4. 进行数据分析，可以使用Pandas提供的方法对数据进行筛选、排序、分组和聚合等操作。 5. 可选地进行数据可视化，使用Matplotlib或其他可视化工具绘制图表。 6. 进行统计分析，可以使用Pandas的描述统计方法或其他...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值