57

我有一个 pandas 数据框，其中有一列名为my_labels，其中包含字符串：'A', 'B', 'C', 'D', 'E'。我想计算每个字符串的出现次数，然后将计数除以所有计数的总和。我正在尝试在 Pandas 中这样做：

func = lambda x: x.size() / x.sum()
data = frame.groupby('my_labels').apply(func)

此代码引发错误，'DataFrame 对象没有属性'size'。如何在 Pandas 中应用函数来计算这个？

4

5 回答 5

53

apply接受一个函数来应用于每个值，而不是系列，并接受 kwargs。所以，值没有.size()方法。

也许这会起作用：

from pandas import *

d = {"my_label": Series(['A','B','A','C','D','D','E'])}
df = DataFrame(d)


def as_perc(value, total):
    return value/float(total)

def get_count(values):
    return len(values)

grouped_count = df.groupby("my_label").my_label.agg(get_count)
data = grouped_count.apply(as_perc, total=df.my_label.count())

这里的.agg()方法采用一个函数，该函数应用于groupby 对象的所有值。

于 2013-03-13T01:00:05.190 回答
25

从 Pandas 版本 0.22 开始，还存在apply:的替代方案pipe，它可以比使用快得多apply（您也可以检查这个问题以了解这两个功能之间的更多差异）。

对于您的示例：

df = pd.DataFrame({"my_label": ['A','B','A','C','D','D','E']})

  my_label
0        A
1        B
2        A
3        C
4        D
5        D
6        E

apply版本_

df.groupby('my_label').apply(lambda grp: grp.count() / df.shape[0])

给

          my_label
my_label          
A         0.285714
B         0.142857
C         0.142857
D         0.285714
E         0.142857

和pipe版本

df.groupby('my_label').pipe(lambda grp: grp.size() / grp.size().sum())

产量

my_label
A    0.285714
B    0.142857
C    0.142857
D    0.285714
E    0.142857

所以值是相同的，但是，时间差异很大（至少对于这个小数据帧）：

%timeit df.groupby('my_label').apply(lambda grp: grp.count() / df.shape[0])
100 loops, best of 3: 5.52 ms per loop

和

%timeit df.groupby('my_label').pipe(lambda grp: grp.size() / grp.size().sum())
1000 loops, best of 3: 843 µs per loop

将它包装成一个函数也很简单：

def get_perc(grp_obj):
    gr_size = grp_obj.size()
    return gr_size / gr_size.sum()

现在你可以打电话

df.groupby('my_label').pipe(get_perc)

屈服

my_label
A    0.285714
B    0.142857
C    0.142857
D    0.285714
E    0.142857

但是，对于这种特殊情况，您甚至不需要 a groupby，但您可以value_counts像这样使用：

df['my_label'].value_counts(sort=False) / df.shape[0]

屈服

A    0.285714
C    0.142857
B    0.142857
E    0.142857
D    0.285714
Name: my_label, dtype: float64

对于这个小数据框，它非常快

%timeit df['my_label'].value_counts(sort=False) / df.shape[0]
1000 loops, best of 3: 770 µs per loop

正如@anmol 所指出的，最后一条语句也可以简化为

df['my_label'].value_counts(sort=False, normalize=True)
于 2018-01-04T08:03:05.450 回答
9

尝试：

g = pd.DataFrame(['A','B','A','C','D','D','E'])

# Group by the contents of column 0 
gg = g.groupby(0)  

# Create a DataFrame with the counts of each letter
histo = gg.apply(lambda x: x.count())

# Add a new column that is the count / total number of elements    
histo[1] = histo.astype(np.float)/len(g) 

print histo

输出：

   0         1
0             
A  2  0.285714
B  1  0.142857
C  1  0.142857
D  2  0.285714
E  1  0.142857
于 2013-03-13T01:04:34.580 回答
7

关于“大小”的问题，大小不是数据帧上的函数，而是一个属性。因此，与其使用 size()，不如使用普通大小

除此之外，这样的方法应该有效

def doCalculation(df):
    groupCount = df.size
    groupSum = df['my_labels'].notnull().sum()
    
    return groupCount / groupSum

dataFrame.groupby('my_labels').apply(doCalculation)
于 2018-07-19T22:37:59.603 回答
1

我看到了一种嵌套函数技术，用于计算 SO 的加权平均值，改变该技术可以解决您的问题。

def group_weight(overall_size):
    def inner(group):
        return len(group)/float(overall_size)
    inner.__name__ = 'weight'
    return inner

d = {"my_label": pd.Series(['A','B','A','C','D','D','E'])}
df = pd.DataFrame(d)
print df.groupby('my_label').apply(group_weight(len(df)))



my_label
A    0.285714
B    0.142857
C    0.142857
D    0.285714
E    0.142857
dtype: float64

以下是如何在组内进行加权平均

def wavg(val_col_name,wt_col_name):
    def inner(group):
        return (group[val_col_name] * group[wt_col_name]).sum() / group[wt_col_name].sum()
    inner.__name__ = 'wgt_avg'
    return inner



d = {"P": pd.Series(['A','B','A','C','D','D','E'])
     ,"Q": pd.Series([1,2,3,4,5,6,7])
    ,"R": pd.Series([0.1,0.2,0.3,0.4,0.5,0.6,0.7])
     }

df = pd.DataFrame(d)
print df.groupby('P').apply(wavg('Q','R'))

P
A    2.500000
B    2.000000
C    4.000000
D    5.545455
E    7.000000
dtype: float64
于 2015-07-04T16:29:38.607 回答