在组对象上应用vs变换

小开

由于我同样对.transform操作和.apply感到困惑，我找到了一些答案，对这个问题有了一些了解。例如这个答案是非常有用的。

到目前为止，我的结论是.transform将工作(或处理)Series(列)彼此隔离。这意味着在你的前两次通话中

df.groupby('A').transform(lambda x: (x['C'] - x['D']))
df.groupby('A').transform(lambda x: (x['C'] - x['D']).mean())

你要求.transform从两列中取值，“它”实际上不会同时“看到”它们(可以这么说)。transform将逐个查看dataframe列并返回一个系列(或一组系列)'made'由重复len(input_column)次的标量组成。

因此，.transform应该使用这个标量来生成Series，它是应用于输入Series上的一些约简函数的结果(并且一次仅适用于一个系列/列)。

考虑这个例子(在你的数据框架上):

zscore = lambda x: (x - x.mean()) / x.std() # Note that it does not reference anything outside of 'x' and for transform 'x' is one column.
df.groupby('A').transform(zscore)

将收益率:

       C      D
0  0.989  0.128
1 -0.478  0.489
2  0.889 -0.589
3 -0.671 -1.150
4  0.034 -0.285
5  1.149  0.662
6 -1.404 -0.907
7 -0.509  1.653

这与你一次只在一列上使用它是完全相同的:

df.groupby('A')['C'].transform(zscore)

收益率:

注意，上一个例子(df.groupby('A')['C'].apply(zscore))中的.apply将以完全相同的方式工作，但如果你试图在数据框架上使用它，它会失败:

df.groupby('A').apply(zscore)

给错误:

ValueError: operands could not be broadcast together with shapes (6,) (2,)

那么还有什么地方是.transform有用的?最简单的情况是尝试将约简函数的结果分配回原始数据框架。

df['sum_C'] = df.groupby('A')['C'].transform(sum)
df.sort('A') # to clearly see the scalar ('sum') applies to the whole column of the group

收益率:

     A      B      C      D  sum_C
1  bar    one  1.998  0.593  3.973
3  bar  three  1.287 -0.639  3.973
5  bar    two  0.687 -1.027  3.973
4  foo    two  0.205  1.274  4.373
2  foo    two  0.128  0.924  4.373
6  foo    one  2.113 -0.516  4.373
7  foo  three  0.657 -1.179  4.373
0  foo    one  1.270  0.201  4.373

对.apply进行同样的尝试将在sum_C中得到NaNs。因为.apply将返回一个缩减后的Series，它不知道如何广播回:

df.groupby('A')['C'].apply(sum)

给:

A
bar    3.973
foo    4.373

也有使用.transform来过滤数据的情况:

df[df.groupby(['B'])['D'].transform(sum) < -1]


A      B      C      D
3  bar  three  1.287 -0.639
7  foo  three  0.657 -1.179

我希望这能让你更清楚一点。

小开

最佳答案

`apply`和`transform`之间的两个主要区别

transform和apply组by方法之间有两个主要区别。

输入

apply隐式地将每个组的所有列作为DataFrame传递给自定义函数。
而transform将每个组的每一列单独作为系列传递给自定义函数。

输出

传递给apply可以返回标量、序列或数据帧(或numpy数组甚至列表)的自定义函数。
传递给transform必须返回一个序列(一维序列、数组或列表)的自定义函数与组的长度相同。

因此，transform一次只作用于一个Series，而apply一次作用于整个DataFrame。

检查自定义函数

检查传递给apply或transform的自定义函数的输入会有很大帮助。

例子

让我们创建一些样本数据并检查这些组，这样你就可以看到我在说什么:

import pandas as pd
import numpy as np
df = pd.DataFrame({'State':['Texas', 'Texas', 'Florida', 'Florida'],
'a':[4,5,1,3], 'b':[6,10,3,11]})


State  a   b
0    Texas  4   6
1    Texas  5  10
2  Florida  1   3
3  Florida  3  11

让我们创建一个简单的自定义函数，该函数输出隐式传递的对象的类型，然后引发一个异常，以便可以停止执行。

def inspect(x):
print(type(x))
raise

现在，让我们把这个函数传递给groupby apply和transform方法，看看传递给它的对象是什么:

df.groupby('State').apply(inspect)


<class 'pandas.core.frame.DataFrame'>
<class 'pandas.core.frame.DataFrame'>
RuntimeError

正如你所看到的，一个DataFrame被传递给inspect函数。您可能想知道为什么DataFrame类型被打印了两次。熊猫跑第一组两次。它这样做是为了确定是否有一个快速的方法来完成计算。这是一个你不应该担心的小细节。

现在，让我们对transform做同样的事情

df.groupby('State').transform(inspect)
<class 'pandas.core.series.Series'>
<class 'pandas.core.series.Series'>
RuntimeError

它被传递一个Series -一个完全不同的Pandas对象。

因此，transform一次只允许处理一个Series。它不可能同时作用于两列。因此，如果我们尝试从自定义函数中的b中减去列a，则会得到transform错误。见下文:

def subtract_two(x):
return x['a'] - x['b']


df.groupby('State').transform(subtract_two)
KeyError: ('a', 'occurred at index a')

当pandas试图查找不存在的系列索引a时，我们得到一个KeyError。你可以用apply完成这个操作，因为它有整个DataFrame:

df.groupby('State').apply(subtract_two)


State
Florida  2   -2
3   -8
Texas    0   -2
1   -5
dtype: int64

输出是一个Series，由于保留了原始索引，因此有点令人困惑，但我们可以访问所有列。

显示传递的pandas对象

它甚至可以在自定义函数中显示整个pandas对象，因此您可以确切地看到您正在操作的对象。你可以使用print语句，我喜欢使用IPython.display模块中的display函数，这样DataFrames就可以很好地以HTML形式输出到jupyter笔记本中:

from IPython.display import display
def subtract_two(x):
display(x)
return x['a'] - x['b']

截图:

Transform必须返回与组大小相同的一维序列

另一个区别是transform必须返回与组大小相同的一维序列。在这个特定的实例中，每个组有两行，所以transform必须返回一个两行的序列。如果没有，则会引发一个错误:

def return_three(x):
return np.array([1, 2, 3])


df.groupby('State').transform(return_three)
ValueError: transform must return a scalar value for each group

错误消息并不能真正描述问题。必须返回与组长度相同的序列。所以，这样的函数是可行的:

def rand_group_len(x):
return np.random.rand(len(x))


df.groupby('State').transform(rand_group_len)


a         b
0  0.962070  0.151440
1  0.440956  0.782176
2  0.642218  0.483257
3  0.056047  0.238208

返回单个标量对象也适用于`transform`

如果从自定义函数中只返回一个标量，则transform将对组中的每一行使用它:

def group_sum(x):
return x.sum()


df.groupby('State').transform(group_sum)


a   b
0  9  16
1  9  16
2  4  14
3  4  14

小开

我将使用一个非常简单的片段来说明两者的区别:

test = pd.DataFrame({'id':[1,2,3,1,2,3,1,2,3], 'price':[1,2,3,2,3,1,3,1,2]})
grouping = test.groupby('id')['price']

DataFrame是这样的:

这个表中有3个客户id，每个客户进行3次交易，每次支付1 2 3美元。

现在，我想求出每个顾客的最低付款。有两种方法:

使用apply :

grouping.min ()

返回结果如下所示:

id
1    1
2    1
3    1
Name: price, dtype: int64


pandas.core.series.Series # return type
Int64Index([1, 2, 3], dtype='int64', name='id') #The returned Series' index
# lenght is 3

使用transform :

grouping.transform (min)

返回结果如下所示:

0    1
1    1
2    1
3    1
4    1
5    1
6    1
7    1
8    1
Name: price, dtype: int64


pandas.core.series.Series # return type
RangeIndex(start=0, stop=9, step=1) # The returned Series' index
# length is 9

这两个方法都返回Series对象，但第一个方法的length为3，第二个方法的length为9。

如果你想回答What is the minimum price paid by each customer，那么apply方法是更合适的选择。

如果你想回答What is the difference between the amount paid for each transaction vs the minimum payment，那么你要使用transform，因为:

test['minimum'] = grouping.transform(min) # ceates an extra column filled with minimum payment
test.price - test.minimum # returns the difference for each row

Apply在这里不能工作，因为它返回一个大小为3的Series，但原始df的长度是9。你不能轻易地把它积分回原来的df。

小开

tmp = df.groupby(['A'])['c'].transform('mean')

就像

tmp1 = df.groupby(['A']).agg({'c':'mean'})
tmp = df['A'].map(tmp1['c'])

或

tmp1 = df.groupby(['A'])['c'].mean()
tmp = df['A'].map(tmp1)

小开

您可以使用zscore来分析C列和D列中的数据，以寻找异常值，其中zscore是系列-系列。Mean / series.std()。使用apply也创建一个用户定义的函数，用于C和D之间的差异，创建一个新的结果数据框架。Apply使用组结果集。

from scipy.stats import zscore


columns = ['A', 'B', 'C', 'D']
records = [
['foo', 'one', 0.162003, 0.087469],
['bar', 'one', -1.156319, -1.5262719999999999],
['foo', 'two', 0.833892, -1.666304],
['bar', 'three', -2.026673, -0.32205700000000004],
['foo', 'two', 0.41145200000000004, -0.9543709999999999],
['bar', 'two', 0.765878, -0.095968],
['foo', 'one', -0.65489, 0.678091],
['foo', 'three', -1.789842, -1.130922]
]
df = pd.DataFrame.from_records(records, columns=columns)
print(df)


standardize=df.groupby('A')['C','D'].transform(zscore)
print(standardize)
outliersC= (standardize['C'] <-1.1) | (standardize['C']>1.1)
outliersD= (standardize['D'] <-1.1) | (standardize['D']>1.1)


results=df[outliersC | outliersD]
print(results)


#Dataframe results
A      B         C         D
0  foo    one  0.162003  0.087469
1  bar    one -1.156319 -1.526272
2  foo    two  0.833892 -1.666304
3  bar  three -2.026673 -0.322057
4  foo    two  0.411452 -0.954371
5  bar    two  0.765878 -0.095968
6  foo    one -0.654890  0.678091
7  foo  three -1.789842 -1.130922
#C and D transformed Z score
C         D
0  0.398046  0.801292
1 -0.300518 -1.398845
2  1.121882 -1.251188
3 -1.046514  0.519353
4  0.666781 -0.417997
5  1.347032  0.879491
6 -0.482004  1.492511
7 -1.704704 -0.624618


#filtering using arbitrary ranges -1 and 1 for the z-score
A      B         C         D
1  bar    one -1.156319 -1.526272
2  foo    two  0.833892 -1.666304
5  bar    two  0.765878 -0.095968
6  foo    one -0.654890  0.678091
7  foo  three -1.789842 -1.130922




>>>>>>>>>>>>> Part 2


splitting = df.groupby('A')


#look at how the data is grouped
for group_name, group in splitting:
print(group_name)


def column_difference(gr):
return gr['C']-gr['D']


grouped=splitting.apply(column_difference)
print(grouped)


A
bar  1    0.369953
3   -1.704616
5    0.861846
foo  0    0.074534
2    2.500196
4    1.365823
6   -1.332981
7   -0.658920