पंडों DataFrame कई स्तंभों का उपयोग कर कुल कार्य

Question 1

क्या एग्रीगेशन फंक्शन लिखने का एक DataFrame.aggतरीका है, जैसा कि मेथड में इस्तेमाल किया जाता है , जिसमें एग्रीगेट किए जा रहे डेटा के एक से अधिक कॉलम तक पहुंच होगी? विशिष्ट उपयोग के मामलों में भारित औसत, भारित मानक विचलन फंक होंगे।

मैं चाहूंगा कि मैं कुछ लिख सकूं

def wAvg(c, w):
    return ((c * w).sum() / w.sum())

df = DataFrame(....) # df has columns c and w, i want weighted average
                     # of c using w as weight.
df.aggregate ({"c": wAvg}) # and somehow tell it to use w column as weights ...

Question 2

हाँ; .apply(...)फ़ंक्शन का उपयोग करें , जिसे प्रत्येक उप- पर बुलाया जाएगा DataFrame। उदाहरण के लिए:

grouped = df.groupby(keys)

def wavg(group):
    d = group['data']
    w = group['weights']
    return (d * w).sum() / w.sum()

grouped.apply(wavg)

Question 3

मेरा समाधान नथानिएल के समाधान के समान है, केवल यह एक कॉलम के लिए है और मैं हर बार पूरे डेटा फ्रेम को डीप-कॉपी नहीं करता हूं, जो निषेधात्मक रूप से धीमा हो सकता है। समाधान ग्रुपबी (...) पर प्रदर्शन लाभ। लागू करें (...) लगभग 100x (!) है।

def weighted_average(df, data_col, weight_col, by_col):
    df['_data_times_weight'] = df[data_col] * df[weight_col]
    df['_weight_where_notnull'] = df[weight_col] * pd.notnull(df[data_col])
    g = df.groupby(by_col)
    result = g['_data_times_weight'].sum() / g['_weight_where_notnull'].sum()
    del df['_data_times_weight'], df['_weight_where_notnull']
    return result

Question 4

किसी भी समूह की वस्तु से किसी भी संख्या में कुल मूल्यों को वापस करना संभव है apply। बस, एक श्रृंखला लौटाएं और सूचकांक मान नए कॉलम नाम बन जाएंगे।

आइए एक त्वरित उदाहरण देखें:

df = pd.DataFrame({'group':['a','a','b','b'],
                   'd1':[5,10,100,30],
                   'd2':[7,1,3,20],
                   'weights':[.2,.8, .4, .6]},
                 columns=['group', 'd1', 'd2', 'weights'])
df

  group   d1  d2  weights
0     a    5   7      0.2
1     a   10   1      0.8
2     b  100   3      0.4
3     b   30  20      0.6

एक कस्टम फ़ंक्शन परिभाषित करें जिसे पास किया जाएगा apply। यह स्पष्ट रूप से एक DataFrame को स्वीकार करता है - मतलब dataपैरामीटर एक DataFrame है। ध्यान दें कि यह कई स्तंभों का उपयोग कैसे करता है, जो समूह aggविधि से संभव नहीं है :

def weighted_average(data):
    d = {}
    d['d1_wa'] = np.average(data['d1'], weights=data['weights'])
    d['d2_wa'] = np.average(data['d2'], weights=data['weights'])
    return pd.Series(d)

applyहमारे कस्टम फ़ंक्शन के साथ ग्रुपबी विधि को कॉल करें :

df.groupby('group').apply(weighted_average)

       d1_wa  d2_wa
group              
a        9.0    2.2
b       58.0   13.2

आप अन्य जवाबों में बताए अनुसार नए डेटाफ्रेम कॉलम में भारित योगों को पहले से निर्धारित करके बेहतर प्रदर्शन प्राप्त कर सकते applyहैं।

Question 5

निम्नलिखित (वेस मैककिनी के उत्तर पर आधारित) वास्तव में वही है जो मैं देख रहा था। मुझे यह जानकर खुशी होगी कि अगर ऐसा करने का एक सरल तरीका है pandas।

def wavg_func(datacol, weightscol):
    def wavg(group):
        dd = group[datacol]
        ww = group[weightscol] * 1.0
        return (dd * ww).sum() / ww.sum()
    return wavg


def df_wavg(df, groupbycol, weightscol):
    grouped = df.groupby(groupbycol)
    df_ret = grouped.agg({weightscol:sum})
    datacols = [cc for cc in df.columns if cc not in [groupbycol, weightscol]]
    for dcol in datacols:
        try:
            wavg_f = wavg_func(dcol, weightscol)
            df_ret[dcol] = grouped.apply(wavg_f)
        except TypeError:  # handle non-numeric columns
            df_ret[dcol] = grouped.agg({dcol:min})
    return df_ret

फ़ंक्शन df_wavg()एक डेटाफ़्रेम लौटाता है जिसे "ग्रुपबी" कॉलम द्वारा समूहीकृत किया जाता है, और जो वज़न कॉलम के लिए भार का योग देता है। अन्य कॉलम या तो भारित औसत हैं या, यदि गैर-संख्यात्मक हैं, तो min()फ़ंक्शन का उपयोग एकत्रीकरण के लिए किया जाता है।

Question 6

मैं यह बहुत कुछ करता हूं और निम्नलिखित काफी उपयोगी पाया गया है:

def weighed_average(grp):
    return grp._get_numeric_data().multiply(grp['COUNT'], axis=0).sum()/grp['COUNT'].sum()
df.groupby('SOME_COL').apply(weighed_average)

यह सभी संख्यात्मक स्तंभों के भारित औसत की गणना करेगा dfऔर गैर-संख्यात्मक लोगों को छोड़ देगा।

Question 7

इसके माध्यम से पूरा groupby(...).apply(...)करना गैर-निष्पादित है। यहाँ एक समाधान है जो मैं हर समय उपयोग करता हूं (अनिवार्य रूप से कुल्लू के तर्क का उपयोग करके)।

def grouped_weighted_average(self, values, weights, *groupby_args, **groupby_kwargs):
   """
    :param values: column(s) to take the average of
    :param weights_col: column to weight on
    :param group_args: args to pass into groupby (e.g. the level you want to group on)
    :param group_kwargs: kwargs to pass into groupby
    :return: pandas.Series or pandas.DataFrame
    """

    if isinstance(values, str):
        values = [values]

    ss = []
    for value_col in values:
        df = self.copy()
        prod_name = 'prod_{v}_{w}'.format(v=value_col, w=weights)
        weights_name = 'weights_{w}'.format(w=weights)

        df[prod_name] = df[value_col] * df[weights]
        df[weights_name] = df[weights].where(~df[prod_name].isnull())
        df = df.groupby(*groupby_args, **groupby_kwargs).sum()
        s = df[prod_name] / df[weights_name]
        s.name = value_col
        ss.append(s)
    df = pd.concat(ss, axis=1) if len(ss) > 1 else ss[0]
    return df

pandas.DataFrame.grouped_weighted_average = grouped_weighted_average