8 examples of 'group by sum pandas' in Python

54
def sum(self):
55
    def sum(scol):
56
        return F.when(
57
            F.row_number().over(self._unbounded_window) >= self._min_periods,
58
            F.sum(scol).over(self._window)
59
        ).otherwise(F.lit(None))
60
61
    return self._apply_as_series_or_frame(sum)

236
def mean(self):
237
    # TODO, there is a lot of copy-paste with the code above
238
    # TODO, we should probably define groupby.aggregate
239
    func = _accumulate_groupby_mean
240
    start = (0, 0)
241
    if isinstance(self.grouper, Streaming):
242
        func = partial(func, index=self.index)
243
        example = self.root.example.groupby(self.grouper.example)
244
        if self.index is not None:
245
            example = example[self.index]
246
        example = example.mean()
247
        stream = self.root.stream.zip(self.grouper.stream)
248
        stream = stream.accumulate(func, start=start, returns_state=True)
249
    else:
250
        func = partial(func, grouper=self.grouper, index=self.index)
251
        example = self.root.example.groupby(self.grouper)
252
        if self.index is not None:
253
            example = example[self.index]
254
        example = example.mean()
255
        stream = self.root.stream.accumulate(func, start=start,
256
                                             returns_state=True)
257
    if isinstance(example, pd.DataFrame):
258
        return StreamingDataFrame(stream, example)
259
    else:
260
        return StreamingSeries(stream, example)

103
def SUM(df, n, price='Close'):
104
    """
105
    Summation
106
    """
107
    sum_list = []
108
    i = 0
109
    while i < len(df[price]):
110
        if i + 1 < n:
111
            SUM = float('NaN')
112
        else:
113
            start = i + 1 - n
114
            end = i + 1
115
            SUM = sum(df[price][start:end])
116
        sum_list.append(SUM)
117
        i += 1
118
    return sum_list

31
def groupby(xs, keys):
32
    result = defaultdict(list)
33
    for (x, key) in zip(xs, keys):
34
        result[key].append(x)
35
    return result

89
def SUM(Series, N):
90
    return pd.Series.rolling(Series, N).sum()

230
def get_column_sum(self, column):
231
    return self.spark_df.select(column).groupBy().sum().collect()[0][0]

38
def add_group_id(df, *groupby_cols, gid_colname='gid'):
39
    groupby_cols = list(groupby_cols)
40
    df_group = df.groupby(groupby_cols).apply(lambda g: pd.Series({
41
        'group_length': g.shape[0]
42
    })).reset_index()
43
    df_group[gid_colname] = df_group.index
44
    df_merge = pd.merge(df, df_group, how='outer', on=groupby_cols)
45
    df_merge['group_length'] = df_merge['group_length'].fillna(-1)
46
    df_merge[gid_colname] = df_merge[gid_colname].fillna(-1)
47
    df_merge['group_length'] = df_merge['group_length'].astype(int)
48
    df_merge[gid_colname] = df_merge[gid_colname].astype(int)
49
    return df_merge

2757
@typecheck(f=func_spec(1, expr_any),
2758
           collection=expr_oneof(expr_set(), expr_array()))
2759
def group_by(f: Callable, collection) -> DictExpression:
2760
    """Group collection elements into a dict according to a lambda function.
2761
2762
    Examples
2763
    --------
2764
2765
    >>> a = ['The', 'quick', 'brown', 'fox']
2766
2767
    >>> hl.eval(hl.group_by(lambda x: hl.len(x), a))
2768
    {5: ['quick', 'brown'], 3: ['The', 'fox']}
2769
2770
    Parameters
2771
    ----------
2772
    f : function ( (arg) -> :class:`.Expression`)
2773
        Function to evaluate for each element of the collection to produce a key for the
2774
        resulting dictionary.
2775
    collection : :class:`.ArrayExpression` or :class:`.SetExpression`
2776
        Collection expression.
2777
2778
    Returns
2779
    -------
2780
    :class:`.DictExpression`.
2781
        Dictionary keyed by results of `f`.
2782
    """
2783
    return collection.group_by(f)