Pandas: groupby.agg의 relabeling dicts 사용 중단은 많은 문제를 야기합니다.

@zertrin : 함께해주셔서 감사합니다. 나는 이것에 대해 #15931에서 많은 토론이 있었던 것을 보았다. 제가 이 글을 다 읽지 못해서 지금은 댓글을 달 수 없습니다. 그럼에도 불구하고 핑을 보겠습니다.

@jjjjjjjjjjjjjjjjjjj 넘 넘넘 아저씨ㅠㅠ ㅠㅠㅠ ㅠㅠㅠ ㅠㅠㅠ ㅠㅠㅠ ㅠㅠㅠ ㅠㅠㅠ ㅠㅠㅠ ㅠㅠㅠ ㅠㅠㅠ ㅠㅠㅠ ㅠㅠㅠ

이 예에서 현재 agg 구현으로 이름을 바꾸는 것이 매우 투박하고 깨져 있다는 점에 동의합니다. 중첩된 딕셔너리는 다소 복잡하지만 여러분이 했던 것처럼 작성하면 무슨 일이 일어나고 있는지 매우 명확해집니다.

나는이있을 수도있을 것 같군요 names 추가 매개 변수 agg 새로운 이름으로 사전 매핑에게 집계 열을 걸릴 것이다. 상위 인덱스 수준을 유지할지 여부를 결정하기 위해 다른 매개변수 drop_index 를 부울로 추가할 수도 있습니다.

따라서 구문은 다음과 같이 바뀝니다.

agg_dict = {'energy': ['sum',
                       lambda x: np.percentile(x, 98), # lambda
                       lambda x: np.percentile(x, 17), # lambda
                      ],
            'distance': ['sum',
                         'mean',
                         smrb.mad, # original function
                         mad_c1,   # partial function wrapping the original function
                        ]
           }

name_dict = {'energy':['energy_sum', 'energy_p98', 'energy_p17'],
             'distance':['distance_sum', 'distance_mean', 'distance_mad', 'distance_mad_c1']}


mydf.groupby('cat').agg(agg_dict, names=name_dict, drop_index=True)

또는 DataFrame.assign 와 유사하게 작동하는 완전히 새로운 agg_assign 메서드를 만들 수 있습니다.

mydf.groupby('cat').agg_assign(energy_sum=lambda x: x.energy.sum(),
                               energy_p98=lambda x: np.percentile(x.energy, 98),
                               energy_p17=lambda x: np.percentile(x.energy, 17),
                               distance_sum=lambda x: x.distance.sum(),
                               distance_mean=lambda x: x.distance.mean(),
                               distance_mad=lambda x: smrb.mad(x.distance),
                               distance_mad_c1=lambda x: mad_c1(x.distance))

저는 사실 이 옵션이 훨씬 좋습니다.

그만한 가치가 있기 때문에 나는 또한 기능을 평가절하하지 않는 것에 강력하게 찬성합니다.

나에게 큰 이유는 파이썬의 함수 이름 공간(특정 구현과 관련된 것)을 열 이름과 데이터(구현에 대해 확실히 알아야 하는 것)와 혼합하는 데 매우 이상한 점이 있기 때문입니다. '<lambda>' 라는 열(여러 열)이 표시된다는 사실은 심각한 인지 부조화를 유발합니다.

불필요한(노출된) 열 이름이 사용되는 중간 단계가 있기 때문에 이름 바꾸기 접근 방식이 문제가 됩니다. 또한 구현에 잠재적으로 종속성이 있기 때문에 안정적이고 체계적으로 이름을 바꾸기가 어렵습니다.

그 외에도 중첩된 dict 기능은 확실히 복잡하지만 수행 중인 복잡한 작업입니다.

TL;DR 평가절하하지 마십시오. :)

나의 기여는 두 가지에 의해 동기가 부여된다.

1. 나는 Pandas의 부풀려진 API를 줄이려는 동기를 알고 있으며 이에 동의합니다. "부풀려진" API 요소를 줄이려는 인식된 동기와 관련하여 잘못 안내되어 있더라도 Pandas의 API가 간소화될 수 있다는 것이 여전히 제 생각입니다.
2. 모든 사람의 욕구와 욕구를 만족시키는 API를 제공하는 것보다 좋은 요리책과 좋은 레시피가 있는 것이 낫다고 생각합니다. 나는 중첩된 사전을 통한 이름 변경이 이미 존재하는 만족스러운 변덕에 해당한다고 주장하는 것이 아니며 우리는 사용 중단에 대해 논의하고 있습니다. 그러나 그것은 간소화된 API와 다른 것 사이의 스펙트럼에 있습니다.

또한 Pandas Series 및 DataFrame 개체에는 파이프라이닝을 용이하게 하는 pipe 메서드가 있습니다. 이 문서 부분 에서는 pipe 를 사용하여 서브클래싱 대신 메서드를 대리할 수 있다고 설명합니다. 같은 정신으로 새로운 GroupBy.pipe 를 사용하여 유사한 역할을 수행하고 groupby 개체에 대한 프록시 메서드를 빌드할 수 있습니다.

@zertrin 의 예를 사용

import numpy as np
import statsmodels.robust as smrb
from functools import partial

# The DataFrame offered up above
mydf = pd.DataFrame(
    {
        'cat': ['A', 'A', 'A', 'B', 'B', 'C'],
        'energy': [1.8, 1.95, 2.04, 1.25, 1.6, 1.01],
        'distance': [1.2, 1.5, 1.74, 0.82, 1.01, 0.6]
    },
    index=range(6)
)

# Identical dictionary passed to `agg`
funcs = {
    'energy': {
        'total_energy': 'sum',
        'energy_p98': lambda x: np.percentile(x, 98),  # lambda
        'energy_p17': lambda x: np.percentile(x, 17),  # lambda
    },
    'distance': {
        'total_distance': 'sum',
        'average_distance': 'mean',
        'distance_mad': smrb.mad,   # original function
        'distance_mad_c1': mad_c1,  # partial function wrapping the original function
    },
}

# Write a proxy method to be passed to `pipe`
def agg_assign(gb, fdict):
    data = {
        (cl, nm): gb[cl].agg(fn)
        for cl, d in fdict.items()
        for nm, fn in d.items()
    }
    return pd.DataFrame(data)

# All the API we need already exists with `pipe`
mydf.groupby('cat').pipe(agg_assign, fdict=funcs)

결과는

            distance                                                 energy                        
    average_distance distance_mad distance_mad_c1 total_distance energy_p17 energy_p98 total_energy
cat                                                                                                
A              1.480     0.355825           0.240           4.44     1.8510     2.0364         5.79
B              0.915     0.140847           0.095           1.83     1.3095     1.5930         2.85
C              0.600     0.000000           0.000           0.60     1.0100     1.0100         1.01

pipe 메서드를 사용하면 많은 경우에 새 API를 추가할 필요가 없습니다. 또한 우리가 논의하고 있는 더 이상 사용되지 않는 기능을 대체할 수 있는 수단을 제공합니다. 따라서 지원 중단을 진행하는 경향이 있습니다.

나는 tdpetrou의 아이디어를 정말 좋아합니다 - names=name_dict .

이것은 모두를 행복하게 할 수 있습니다. 그것은 우리가 원하는 대로 쉽게 열의 이름을 바꿀

실제로는 초기 게시물에서 언급했듯이 집계 작업이 결과 열의 이름에서 정의된 위치를 분리하는 문제를 해결하지 못하므로 둘 다 "동기화"되었는지 확인하기 위해 추가 노력이 필요합니다.

나는 그것이 나쁜 해결책이라고 말하지는 않지만(결국 다른 문제를 해결함) dict of dict 접근 방식만큼 쉽고 명확하지 않을 것입니다. 여기서 내 말은 글을 쓸 때 목록의 두 사전을 동기화된 상태로 유지해야 하고 소스를 읽을 때 독자는 목록의 두 번째 사전에 있는 이름을 목록의 첫 번째 사전에 있는 집계 정의와 일치시키려고 노력해야 한다는 것을 의미합니다. 그것은 각각의 경우에 두 배의 노력입니다.

중첩된 딕셔너리는 다소 복잡하지만 여러분이 했던 것처럼 작성하면 무슨 일이 일어나고 있는지 매우 명확해집니다.

나는 아직도 왜 모든 사람들이 dict of dict가 복잡하다고 말하는지 이해하지 못합니다. 나에게 그것은 그것을 하는 가장 명확한 방법이다.

즉, names 키워드가 pandas 팀이 편안한 유일한 솔루션이라면 현재 상황에 비해 여전히 개선된 것입니다.

@pirsquared 는 현재 API를 사용하는 흥미로운 솔루션입니다. 내 의견으로는 이해하기 쉽지 않지만 (나는 그것이 어떻게 작동하는지 정말로 이해하지 못합니다 : 혼란 스럽습니다 : )

데이터 과학 하위 레딧에서 스레드를 시작했습니다. 팬더에 대해 무엇을 싫어합니까? . 누군가 groupby 뒤에 반환된 MultiIndex 에 대한 경멸을 제기하고 plydata 에 구현된 dplyr do 동사를 가리켰습니다 . 그것은 agg_assign 로 정확히 작동하므로 꽤 흥미로웠습니다.

@zertrin agg_assign dict of dict 접근 방식보다 우수하고 SQL 집계와 동일할 뿐만 아니라 집계 내에서 여러 열이 서로 상호 작용할 수 있습니다. DataFrame.assign 동일하게 작동합니다.

@jreback @TomAugspurger에 대한 생각이 있습니까?

...
mydf.groupby('cat').agg(agg_dict, 이름=name_dict, drop_index=True)

이렇게 하면 문제가 해결되지만 키와 값을 두 위치에 정렬해야 합니다. 이러한 부기 코드가 필요하지 않은 API( .agg_assign 안됨)는 오류가 덜 발생한다고 생각합니다.

API 사용 후 정리 코드 문제도 있습니다. groupby 작업이 MultiIndex 데이터 프레임을 반환하면 대부분의 경우 사용자가 MultiIndex 실행 취소합니다. .agg_assign 를 사용하는 직접적인 선언적 방법은 계층 구조, MultiIndex 출력, 나중에 정리하지 않음을 제안합니다.

사용 패턴에 따라 다중 인덱스 출력은 옵트아웃이 아닌 옵트인이어야 한다고 생각합니다.

나는 처음에 agg_assign 제안에 대해 회의적이었지만 마지막 두 가지 의견을 보고 이것이 좋은 해결책이 될 수 있다는 확신을 갖게 되었습니다.

특히 agg_assign(**relabeling_dict) 형식으로 사용할 가능성에 대해 생각하여 다음과 같이 내 relabeling_dict 를 정의할 수 있습니다.

relabeling_dict = {
    'energy_sum': lambda x: x.energy.sum(),
    'energy_p98': lambda x: np.percentile(x.energy, 98),
    'energy_p17': lambda x: np.percentile(x.energy, 17),
    'distance_sum': lambda x: x.distance.sum(),
    'distance_mean': lambda x: x.distance.mean(),
    'distance_mad': lambda x: smrb.mad(x.distance),
    'distance_mad_c1': lambda x: mad_c1(x.distance)
}

그것은 매우 유연하고 내 OP에서 언급 한 모든 문제를 해결할 것입니다.

@zertrin @has2k1

나는 이것에 대해 조금 더 생각하고 있었고 이 기능은 이미 apply 합니다. 인덱스를 새 열 이름으로, 값을 집계로 사용하여 Series를 반환하기만 하면 됩니다. 이것은 이름에 공백을 허용하고 원하는 대로 정확히 열을 정렬할 수 있는 기능을 제공합니다.

def my_agg(x):
    data = {'energy_sum': x.energy.sum(),
            'energy_p98': np.percentile(x.energy, 98),
            'energy_p17': np.percentile(x.energy, 17),
            'distance sum' : x.distance.sum(),
            'distance mean': x.distance.mean(),
            'distance MAD': smrb.mad(x.distance),
            'distance MAD C1': mad_c1(x.distance)}
    return pd.Series(data, index=list_of_column_order)

mydf.groupby('cat').apply(my_agg)

따라서 새로운 방법이 필요하지 않을 수 있으며 대신 문서에서 더 나은 예를 볼 수 있습니다.

@tdpetrou , 당신이 맞습니다. 내 자신의 버전을 사용하는 동안 빠른 느린 경로 선택 프로세스의 이중 실행으로 인해 apply 작동하는 방식을 잊었습니다.

흠, 문서를 읽는 것만으로도 집계 컨텍스트에서 사용하는 것에 대해 생각할 기회는 없었지만...
게다가, 나는 여전히 apply 의 솔루션이 너무 복잡하다고 생각합니다. agg_assign 접근 방식이 더 간단하고 이해하기 쉬워 보였습니다.

그것에 대해 실제로 진술한 적이 없었기 때문에 dict-of-dict 접근 방식(현재 사용되지는 않지만 이미 구현되었으며 이러한 모든 문제도 해결함)이 정말 확실하게 문제가 되지 않습니까?

agg_assign 접근 방식을 제외하고는 dict-of-dict 여전히 가장 간단한 것으로 보이며 코딩이 필요하지 않으며 단지 비추천입니다.

agg_assign 접근 방식의 장점과 단점은 열 선택 을 집계 방법으로 푸시한다는 것입니다. 모든 예제에서, x 에 전달 lambda 처럼 뭔가 self.get_group(group) 각 그룹에 대해 self 하는 DataFrameGroupBy 객체입니다. 이것은 **kwargs 있는 네이밍을 함수에 있는 선택 과 명확하게 분리하기 때문에 좋습니다.

단점은 멋지고 일반적인 집계 함수가 이제 열 선택과 관련되어야 한다는 것입니다. 공짜 점심은 없다! 즉, lambda x: x[col].min 와 같은 많은 도우미가 생깁니다. 당신은 또한 같은 것들에주의해야합니다 np.min 대, 모든 차원에 걸쳐 감소하는 pd.DataFrame.min 이상 감소하는 axis=0 . 이것이 agg_assign 와 같은 것이 apply 와 같지 않은 이유입니다. apply 여전히 특정 메서드에 대해 열 단위로 작동합니다.

이러한 절충점과 dict-of-dicts 방법에 대해서는 잘 모르겠지만 다른 사람들의 생각이 궁금합니다. 다음은 agg_assign 의 대략적인 스케치입니다. 이것을 agg_table 라고 불렀습니다. 함수가 열이 아니라 테이블로 전달된다는 점을 강조하기 위해 호출한 것입니다.

from collections import defaultdict

import pandas as pd
import numpy as np
from pandas.core.groupby import DataFrameGroupBy

mydf = pd.DataFrame(
    {
        'cat': ['A', 'A', 'A', 'B', 'B', 'C'],
        'energy': [1.8, 1.95, 2.04, 1.25, 1.6, 1.01],
        'distance': [1.2, 1.5, 1.74, 0.82, 1.01, 0.6]
    },
    index=range(6)
)


def agg_table(self, **kwargs):
    output = defaultdict(dict)
    for group in self.groups:
        for k, v in kwargs.items():
            output[k][group] = v(self.get_group(group))

    return pd.concat([pd.Series(output[k]) for k in output],
                     keys=list(output),
                     axis=1)

DataFrameGroupBy.agg_table = agg_table

용법

>>> gr = mydf.groupby("cat")
>>> gr.agg_table(n=len,
                 foo=lambda x: x.energy.min(),
                 bar=lambda y: y.distance.min())

   n   foo   bar
A  3  1.80  1.20
B  2  1.25  0.82
C  1  1.01  0.60

이 성능을 덜 끔찍하게 만들기 위해 우리가 약간 할 수 있다고 생각하지만 .agg 만큼은 아닙니다...

Pandas Core Team의 누군가가 groupby.agg 에서 dicts의 레이블을 다시 지정하지 않는 주된 이유가 무엇인지 설명해 주시겠습니까?

코드를 유지 관리하는 데 너무 많은 문제가 발생하는지 쉽게 이해할 수 있지만 최종 사용자의 복잡성에 관한 것이라면 필요한 해결 방법에 비해 매우 명확하기 때문에 다시 가져오는 것도 선택합니다...

감사합니다!

Pandas Core Team의 누군가가 groupby.agg에서 dicts의 레이블을 다시 지정하지 않는 주된 이유가 무엇인지 설명해 주시겠습니까?

https://github.com/pandas-dev/pandas/pull/15931/files#diff -52364fb643114f3349390ad6bcf24d8fR461 보셨나요?

주된 이유는 dict-key가 두 가지 작업을 수행하기 위해 오버로드되었기 때문입니다. Series / SeriesGroupBy의 경우 이름 지정용입니다. DataFrame/DataFrameGroupBy의 경우 열을 선택하기 위한 것입니다.

In [32]: mydf.aggregate({"distance": "min"})
Out[32]:
distance    0.6
dtype: float64

In [33]: mydf.aggregate({"distance": {"foo": "min"}})
/Users/taugspurger/Envs/pandas-dev/bin/ipython:1: FutureWarning: using a dict with renaming is deprecated and will be removed in a future version
  #!/Users/taugspurger/Envs/pandas-dev/bin/python3.6
Out[33]:
     distance
foo       0.6

In [34]: mydf.distance.agg({"foo": "min"})
Out[34]:
foo    0.6
Name: distance, dtype: float64

In [35]: mydf.groupby("cat").agg({"distance": {"foo": "min"}})
/Users/taugspurger/Envs/pandas-dev/lib/python3.6/site-packages/pandas/pandas/core/groupby.py:4201: FutureWarning: using a dict with renaming is deprecated and will be removed in a future version
  return super(DataFrameGroupBy, self).aggregate(arg, *args, **kwargs)
Out[35]:
    distance
         foo
cat
A       1.20
B       0.82
C       0.60

In [36]: mydf.groupby("cat").distance.agg({"foo": "min"})
/Users/taugspurger/Envs/pandas-dev/bin/ipython:1: FutureWarning: using a dict on a Series for aggregation
is deprecated and will be removed in a future version
  #!/Users/taugspurger/Envs/pandas-dev/bin/python3.6
Out[36]:
      foo
cat
A    1.20
B    0.82
C    0.60

이것은 판다에서 아마도 가장 혼란스러운 것이 아니므로 아마도 다시 방문할 수 있을 것입니다. :) 나는 아마도 몇 가지 예외적인 경우를 놓치고 있는 것 같습니다. 그러나 dict-of-dicts 집계를 제거하더라도 이름 지정과 열 선택 간에 여전히 불일치가 있습니다.

Series / SeriesGroupBy 사전 키는 항상 출력 이름을 지정하기 위한 것입니다.

DataFrame / DataFrameGroupby의 경우 사전 키는 항상 선택용입니다. dict-of-dicts를 사용하여 열을 선택한 다음 내부 dict는 Series / SeriesGroupBy와 마찬가지로 출력 이름을 지정하기 위한 것입니다.

우리는 이전에 이것을 간략하게 논의했으며(지원 중단에 대한 긴 토론의 어딘가) 여기에서 비슷한 것을 제안했습니다: https://github.com/pandas-dev/pandas/pull/14668#issuecomment -274508089. 그러나 결국에는 사용 중단만 구현되었으며 dicts('이름 바꾸기' 기능)를 사용하는 다른 기능을 더 쉽게 만들기 위한 아이디어는 구현되지 않았습니다.

문제는 딕셔너리가 '선택'(어떤 열에 이 기능을 적용하시겠습니까)과 '이름 변경'(이 함수를 적용할 때 결과 열 이름이 되어야 함)에 모두 사용되었다는 것입니다. 여기 agg_assign 제안에서 논의된 것처럼 dicts와 별개로 대체 구문은 키워드 인수가 될 수 있습니다.
agg 자체에 있든 agg_assign 와 같은 새로운 방법에 있든 나는 여전히 이 가능성을 탐구하는 데 찬성합니다.

그때 내가 제안한 것은 agg_assign 와 비슷하지만 람다 함수 대신 키워드당 dict를 사용하는 것이었습니다. 여기 예제로 번역하면 다음과 같습니다.

mydf.groupby('cat').agg(
    energy_sum={'energy': 'sum'},
    energy_p98={'energy': lambda x: np.percentile(x, 98)},
    energy_p17={'energy': lambda x: np.percentile(x, 17)},
    distance_sum={'distance': 'sum'},
    distance_mean={'distance': 'mean'},
    distance_mad={'distance': smrb.mad},
    distance_mad_c1={'distance': mad_c1})

이것이 반드시 모든 람다가 있는 버전으로 더 읽기 쉽고 쓰기 쉬운지는 확실하지 않지만, pandas가 여전히 해당 열에서 합계, 평균 등에 대해 최적화된 구현을 사용할 수 있기 때문에 이 버전이 잠재적으로 더 성능이 좋을 수 있습니다. 람다 또는 사용자 지정 함수가 없습니다.

이 접근 방식에 대한 큰 질문은 df.groupby('cat').agg(foo='mean') 가 무엇을 의미할까요? 선택하지 않았기 때문에 논리적으로 모든 열에 '평균'이 적용됩니다(이전 {'col1' : {'foo': 'mean'}, 'col2': {'foo':'mean'}, 'col3': ...} 와 유사). 그러나 그 결과 다중 인덱싱된 열이 생성되지만 위의 예에서는 MI 열로 끝나지 않는 것이 좋을 것이라고 생각합니다.

위의 작업은 기존 agg 내부에서 이전 버전과 호환될 수 있다고 생각하지만 이것이 필요한지 여부가 문제입니다.
나는 또한 이것이 다음과 같은 series 사례로 멋지게 확장될 것이라고 생각합니다.

mydf.groupby('cat').distance.agg(
    distance_sum='sum',
    distance_mean='mean',
    distance_mad=smrb.mad,
    distance_mad_c1=mad_c1)

(그리고 '거리'에 대해 한 번, '에너지'에 대해 한 번 위의 작업을 수행하고 모든 딕셔너리/람다가 마음에 들지 않으면 결과를 연결하는 것을 고려할 수도 있습니다)

@TomAugspurger agg_table 의 간단한 구현 예에서 그룹을 반복하는 대신 적용할 다른 기능을 반복하고 결국에는 axis=1로 새 열을 연결하는 것이 더 낫지 않을까요? 새로 형성된 행을 axis=0 으로 연결하는 대신 ?

BTW, @zertrin @tdpetrou @smcateer @pirsquared 등, 이 문제를 제기하고 자세한 피드백을 제공해주셔서 감사합니다. 이러한 피드백과 커뮤니티 참여는 매우 중요합니다!

저는 실제로 @tdpetrou가 제안한 패턴을 정말 좋아합니다(시리즈를 반환하는 함수와 함께 적용 사용) - 아마도 dicts보다 더 나을 것입니다.

함수가 pd.Series(data, index=data.keys()) 반환하면 인덱스를 올바른 순서로 얻을 수 있습니까? (내 코드에서 패턴을 가장 잘 구현하는 방법에 대해 생각하는 것 - 주제에서 벗어날 위험이 있음).

편집: 죄송합니다. 인덱스 인수의 요점을 잘못 이해했습니다(여기서는 선택 사항이며 열의 순서를 지정하려는 경우에만 필요합니다. pd.Series(data) 반환하면 작업이 수행됩니다).

@tdpetrou 의 예제는 first & last 집계와 함께 작동합니까?

나는 이렇게 머리 / 꼬리에 의지해야했습니다.

def agg_funcs(x):
    data = {'start':x['DATE_TIME'].head(1).values[0],
           'finish':x['DATE_TIME'].tail(1).values[0],
           'events':len(x['DATE_TIME'])}
    return pd.Series(data, index = list(data.keys()))

results = df.groupby('col').apply(agg_funcs)

나는 여전히 이 문제를 해결하고 싶지만 0.23에서는 끝나지 않을 것이라고 생각합니다.

@tdpetrou 의 접근 방식은 코드에서 다시는 사용하지 않을 함수를 정의하지 않고 작동할 수 있습니까? Q/Kdb+ 세계(SQL과 유사)에서 왔기 때문에 간단한 선택 문에 대해 임시 변수/함수를 만들어야 하는 이유가 혼란스럽습니다.

여기 OP.

솔직히 말해서, 이 모든 시간과 #15931 및 여기에서 많은 토론을 했음에도 불구하고, 나는 이것이 relabeling dicts를 더 이상 사용하지 않는 것이 좋은 생각인지 여전히 확신하지 못합니다.

결국, 여기에 제안된 대안 중 어떤 것도 현재 relabeling dict 접근 방식 IMHO보다 사용자에게 더 직관적이지 않습니다. 문서에 있었을 때 한 가지 예만 들어도 이것이 어떻게 작동하는지 명확했고 매우 유연했습니다.

물론 팬더 개발자는 여전히 사용자의 관점에 따라 다른 생각을 할 수 있습니다.

relabeling dict 접근 방식조차도 매우 직관적이지 않습니다. 제 생각에는 구문이 SQL - func(column_name) as new_column_name 와 유사해야 합니다. Python에서는 3개 항목 튜플을 사용하여 이 작업을 수행할 수 있습니다. (func, column_name, new_column_name) . 이것이 dexplo가 groupby 집계를 수행하는 방법입니다.

@zertrin 위의 내 제안에 대한 피드백이 있습니까: https://github.com/pandas-dev/pandas/issues/18366/#issuecomment -349089667
결국 "{col: {name: func}}" 대신 "**{name: {col: func}}"와 같이 사전의 순서를 뒤집습니다.

@jorisvandenbossche 귀하의 접근 방식을 고려했습니다. 문제는 현재 접근 방식에 비해 어떤 추가 이점이 있는지 실제로 알지 못한다는 것입니다.

더 직설적으로 말하면 다음과 같은 선택이 주어집니다.

1. 잘 작동하는 현재 동작의 사용 중단을 취소합니다(사용 중단 코드 몇 줄을 제거하고 제거된 문서 부분을 다시 추가).
2. 제안을 구현하십시오(코드에 상당한 변경이 있을 것, 현재 접근 방식의 비추천으로 추구, 모든 사용자가 자신의 코드를 조정해야 함)

개발자와 사용자의 관점에서 의미 있고 실질적인 이점을 제공하지 않는 한 왜 2를 선택해야 하는지 모르겠습니다.

위 제안서의 몇 가지 요점을 해결하려면:

문제는 딕셔너리가 '선택'(어떤 열에 이 기능을 적용하시겠습니까)과 '이름 변경'(이 함수를 적용할 때 결과 열 이름이 되어야 함)에 모두 사용되었다는 것입니다.

이전에 잘 문서화되었기 때문에 사용자에게 문제가 되지 않았다고 생각합니다. 개인적으로 설명서의 예제를 보고 즉시 요점을 알았습니다. (편집: 그리고 나는 생각했습니다: _"예! 매우 유용한 구조, 내가 찾던 것과 정확히 일치합니다. 좋습니다."_)

dicts와 별개로 대체 구문은 키워드 인수일 수 있습니다.

dict-of-dict 접근 방식을 사용하는 매력적인 점 중 하나는 사용자가 다른 코드를 사용하여 쉽게 동적으로 생성할 수 있다는 것입니다. 이 항목 바로 위의 주석에서 지적했듯이 제안에서와 같이 키워드 인수로 이동하면 **{name: {col: func}} 구조를 통해 여전히 이를 허용합니다. 그래서 나는 당신의 제안에 반대하지 않습니다. 현재 구현된 시스템으로 이미 동일한 수준의 기능을 달성했을 때 부가 가치와 그러한 변경의 필요성을 알지 못합니다.

결국, pandas core dev가 현재 접근 방식에 대해 강한 느낌을 가지고 있다면 당신의 제안은 _괜찮습니다_. 저는 _user_로서 어떤 이점도 느끼지 못합니다. (사실 나는 모든 기존 사용자 코드를 변경하여 새로운 제안에서 다시 작동하도록 하는 단점을 봅니다.)

@zertrin 우리는 어제 일부 핵심 개발자와 이에 대해 논의했지만 여기에 요약을 작성하지 못했습니다. 그래서 이제 나는 당신의 의견에 답하기 전에 어제의 우리 생각을 반영

따라서 먼저 SQL "SELECT avg(col2) as col2_avg"와 같은 기본 기능이 작동하고 쉬워야 한다는 개념은 전적으로 동의하며 이에 대한 솔루션을 갖고 싶습니다.

이것은 당신이 실제로 싶지 않아하는 MultiIndex을 만들어으로 별도로 원래의 이유에서 우리는 dicts의 현재 (사용되지 않음) dicts도없는 그 이상적입니다 (또는 강한하지 않을 수있다)이 더 이상 사용하기로 결정했다 :

In [1]: df = pd.DataFrame({'A': ['a', 'b', 'a'], 'B': range(3), 'C': [.1, .2, .3]})

In [3]: gr = df.groupby('A')

In [4]: gr.agg({'B': {'b_sum': 'sum'}, 'C': {'c_mean': 'mean', 'c_count': 'count'}})
Out[4]: 
        C            B
  c_count c_mean b_sum
A                     
a       2    0.2     2
b       1    0.2     1

위의 경우 MultiIndex의 첫 번째 수준은 불필요합니다. 이미 구체적으로 열 이름을 변경했기 때문입니다(OP의 예에서 열의 첫 번째 수준을 삭제한 뒤에도 바로 이어짐).
그러나 MultiIndex가 필요하고 의미가 있는 gr.agg(['sum', 'mean']) 또는 (혼합) gr.agg({'B': ['sum', 'mean'], 'C': {'c_mean': 'mean', 'c_count': 'count'}}) 와 같은 작업도 수행할 수 있기 때문에 이것을 변경하는 것은 어렵습니다.

그래서 위의 논의에서 언급한 제안 중 하나는 최종 열 이름을 별도로 지정하는 방법이었습니다(예: https://github.com/pandas-dev/pandas/issues/18366#issuecomment-346683449).
예를 들어 aggregate 에 추가 키워드를 추가하여 다음과 같이 열 이름을 지정합니다.

gr.agg({'B': 'sum', 'C': ['mean', 'count']}, columns=['b_sum', 'c_mean', 'c_count'])

가능할 것입니다.
그러나 열/함수 사양과 새 열 이름을 분할하면 이를 새 키워드보다 더 일반적으로 만들고 다음과 같이 할 수도 있습니다.

gr.agg({'B': 'sum', 'C': ['mean', 'count']}).rename(columns=['b_sum', 'c_mean', 'c_count'])

이 문제를 해결하려면 https://github.com/pandas-dev/pandas/issues/14829 가 필요합니다(0.24.0에서 하고 싶은 것).
(중요 사항 : 우리는이 솔루션을 지원하려는 경우 우리는 이름의 자동 중복 제거의 어떤 종류를해야하므로이를 위해 우리는 람다 함수의 이름이 중복 문제를 해결하기 위해 필요 없습니다.)

그런 다음, 우리는 여전히 이름 변경을 위한 키워드 인수의 방식을 좋아합니다. 그 이유는 다음과 같습니다.

• assign 가 팬더에서 작동하는 방식과 유사하고 groupby().aggregate() 가 ibis에서 작동하는 방식과도 일치합니다(예: R의 dplyr에서 보이는 방식과 유사함).
• 원하는 비계층적 열 이름을 직접 제공합니다(MultiIndex 없음).
• 간단한 경우(예: Series의 경우)의 경우 dict의 dict로 더 간단하다고 생각합니다.

우리는 그것이 어떻게 생겼는지에 대해 약간의 토론을 했습니다. 위에서 제안한 것은 (첫 번째 예제에서와 동일한 열/함수 선택을 사용하기 위함):

gr.agg(b_sum={'B': 'sum'}, c_mean={'C': 'mean'}, c_count={'C': 'count'})

여전히 이 사양을 dict의 dict로 구축할 수 있지만 현재(사용되지 않는) 버전과 비교하여 내부 및 외부 수준이 바뀌었습니다.

gr.agg(**{'b_sum': {'B': 'sum'}, 'c_mean': {'C': 'mean'}, 'c_count': {'C': 'count'})

(우리는 dicts의 기존 dicts를 이 버전으로 변환하는 예제 도우미 함수를 가질 수 있습니다)

그러나 dict는 항상 단일 {col: func} 이고 여러 단일 요소 dicts는 약간 이상해 보입니다. 그래서 우리가 생각한 대안은 튜플을 사용하는 것입니다.

gr.agg(b_sum=('B', 'sum'), c_mean=('C', 'mean'), c_count=('C', 'count'))

이것은 조금 더 좋아 보이지만 다른 한편으로 {'B': 'sum'} dict는 함수를 적용할 열을 지정하기 위한 다른 API와 일치합니다.

위의 두 제안(나중에 더 쉬운 이름 바꾸기 및 키워드 기반 이름 지정)은 원칙적으로 직교하지만 둘 다 있으면 좋을 수 있습니다(또는 추가 논의에 따라 다른 것).

개발자의 현재 생각을 여기에 전달해 주셔서 감사합니다 😃

나는 결과적으로 MultiIndex를 사용하여 더 이상 사용되지 않는 dict-of-dict 접근 방식의 (내 생각에는 유일한) 단점을 인정합니다. 사용자가 추가 옵션(예, YAO :-/ )을 전달하면 평면화될 수 있습니다.

언급한 바와 같이, 저는 다음과 같이 가능한 한 두 번째 버전에 반대하지 않습니다.

• 어떻게든 동적으로 생성하고 압축을 풉니다( **{} 구조 덕분에 Python!)
• 이름 바꾸기와 집계 사양을 가깝게 유지(순서가 동일하게 유지되도록 두 목록을 추적해야 하는 것은 사용자 IMHO로서 매우 성가신 일입니다)
• 함수 이름(잠재적으로 부족하거나 충돌할 수 있음)으로 인해 해결 방법 없이 람다 또는 부분 함수를 사용합니다.

따라서 마지막 제안(col>func 매핑에 대한 사전 또는 튜플 포함)은 괜찮다고 생각합니다.

이전 의견의 첫 번째 제안은 정말 원하면 구현할 수 있지만 이에 대한 제 피드백은 사용자로서 두 번째 대안보다 동기화를 유지해야 하는 고통 때문에 선택하지 않을 것이라는 것입니다. 두 개의 목록.

오늘 개발 회의에서 논의되었습니다.

짧은 요약

1. @jorisvandenbossche 는 gr.agg(b_sum=("B", "sum), ...) 구현을 시도합니다. 즉 arg 전달된 *GroupBy.agg 가 없으면 kwargs를 <output_name>=(<selection>, <aggfunc>) 로 해석합니다.
2. 직교이 문제로 우리가 구현하고자 MutliIndex.flatten을 하고 제공 flatten=True 키워드 .agg

아마도 이것이 도움이 될 것입니다. 사용 중단에 대한 제 해결 방법은 alias->aggr 맵을 올바른 이름의 함수 목록으로 대체하는 다음 도우미 함수입니다.

def aliased_aggr(aggr, name):
    if isinstance(aggr,str):
        def f(data):
            return data.agg(aggr)
    else:
        def f(data):
            return aggr(data)
    f.__name__ = name
    return f

def convert_aggr_spec(aggr_spec):
    return {
        col : [ 
            aliased_aggr(aggr,alias) for alias, aggr in aggr_map.items() 
        ]  
        for col, aggr_map in aggr_spec.items() 
    }

다음과 같이 이전 동작을 제공합니다.

mydf_agg = mydf.groupby('cat').agg(convert_aggr_spec{
    'energy': {
        'total_energy': 'sum',
        'energy_p98': lambda x: np.percentile(x, 98),  # lambda
        'energy_p17': lambda x: np.percentile(x, 17),  # lambda
    },
    'distance': {
        'total_distance': 'sum',
        'average_distance': 'mean',
        'distance_mad': smrb.mad,   # original function
        'distance_mad_c1': mad_c1,  # partial function wrapping the original function
    },
}))

와 같은 것

mydf_agg = mydf.groupby('cat').agg({
    'energy': [ 
        aliased_aggr('sum', 'total_energy'),
        aliased_aggr(lambda x: np.percentile(x, 98), 'energy_p98'),
        aliased_aggr(lambda x: np.percentile(x, 17), 'energy_p17')
    ],
    'distance': [
         aliased_aggr('sum', 'total_distance'),
         aliased_aggr('mean', 'average_distance'),
         aliased_aggr(smrb.mad, 'distance_mad'),
         aliased_aggr(mad_c1, 'distance_mad_c1'),
    ]
})

이것은 나를 위해 작동하지만 일부 코너 케이스에서는 작동하지 않을 것입니다 ...

업데이트 : 집계 사양의 튜플이 (별칭, agr)로 해석되므로 이름을 바꿀 필요가 없음을 알았습니다. 따라서 alias_aggr 함수는 필요하지 않으며 변환은 다음과 같습니다.

def convert_aggr_spec(aggr_spec):
    return {
        col : [ 
           (alias,aggr) for alias, aggr in aggr_map.items() 
        ]  
        for col, aggr_map in aggr_spec.items() 
    }

어떤 함수에서든 열을 집계하고 같은 행에서 즉시 이름을 바꾸는 기능이 정말 없는 또 다른 사용자로서 여기에 참여하고 싶습니다. 나는 pandas에서 반환된 MultiIndex를 사용하여 자신을 발견한 적이 _never_ 없습니다. 즉시 병합하거나 실제로 특정 의미를 의미하는 열 이름을 수동으로 지정하고 싶습니다.

여기에 제안된 접근 방식 중 하나에 만족할 것입니다. SQL과 유사한 구문(실제로 이미 pandas에서 .query() 를 많이 사용하고 있음), 감가상각 동작으로 되돌리기, 다른 제안. 현재의 접근 방식은 이미 R을 사용하는 동료들로부터 조롱을 받았습니다.

나는 최근에 Pandas 대신 PySpark를 사용하고 있음을 발견했습니다. 필요한 것은 아니지만 구문을 훨씬 더 좋아하기 때문입니다.

df.groupby("whatever").agg(
    F.max("col1").alias("my_max_col"),
    F.avg("age_col").alias("average_age"),
    F.sum("col2").alias("total_yearly_payments")
)

또한 PySpark는 대부분의 경우 팬더보다 쓰기에 훨씬 더 복잡합니다. 훨씬 더 깔끔해 보입니다! 그래서 나는 이것에 대한 작업이 아직 완료되었다는 점에 감사드립니다 :-)

이 기능에 대해 동의한 구문이 있다고 생각합니다. 우리는 누군가가 필요합니다
구현합니다.

2019년 3월 27일 수요일 오전 9:01 Thomas Kastl [email protected]
썼다:

나는 단지 정말로, 정말로
모든 함수에서 열을 집계하는 기능이 누락된 경우
즉시 같은 행에서 이름을 바꿉니다. 나는 나 자신을 발견한 적이 없다
팬더가 반환한 MultiIndex 사용 - 즉시 병합하거나,
또는 실제로 열 이름을 수동으로 지정하고 싶습니다.
실제로 특정한 것을 의미합니다.

여기에 제안된 접근 방식 중 하나에 만족할 것입니다. SQL과 유사한 구문
(실제로 이미 판다에서 .query()를 많이 사용하고 있습니다),
감가 상각 된 행동으로 되돌리기, 다른 제안. 그만큼
현재의 접근 방식은 이미 R을 사용하는 동료들로부터 조롱을 받았습니다.

나는 최근에 Pandas 대신 PySpark를 사용하고 있음을 발견했습니다.
구문이 훨씬 더 마음에 들기 때문에 필요하지 않았습니다.

df.groupby("무엇이든").agg( F.max("col1").alias("my_max_col"),
F.avg("age_col").alias("average_age"),
F.sum("col2").alias("total_yearly_payments") )

또한 PySpark는 대부분의 경우 팬더보다 쓰기에 훨씬 더 복잡합니다.
이것은 훨씬 더 깨끗해 보입니다! 그래서 나는 확실히 그 작업에 감사합니다
이것은 여전히 ​​수행됩니다 :-)

—
당신이 언급되었기 때문에 이것을 받는 것입니다.
이 이메일에 직접 답장하고 GitHub에서 확인하세요.
https://github.com/pandas-dev/pandas/issues/18366#issuecomment-477168767 ,
또는 스레드 음소거
https://github.com/notifications/unsubscribe-auth/ABQHIkCYYsah5siYA4_z0oop_ufIB3h8ks5va3nJgaJpZM4QjSLL
.

나는 0.25.0에 대해 이것을 얻으려고 노력할 것입니다.

https://github.com/pandas-dev/pandas/pull/26399에 PR을 올렸습니다 (selection, aggfunc) 튜플이어야 한다는 이해와 함께 **kwargs 를 사용하여 이름 바꾸기 및 열별 집계의 혼합을 허용하는 것입니다.

In [2]: df = pd.DataFrame({'kind': ['cat', 'dog', 'cat', 'dog'],
   ...:                    'height': [9.1, 6.0, 9.5, 34.0],
   ...:                    'weight': [7.9, 7.5, 9.9, 198.0]})

In [3]: df
Out[3]:
  kind  height  weight
0  cat     9.1     7.9
1  dog     6.0     7.5
2  cat     9.5     9.9
3  dog    34.0   198.0

In [4]: df.groupby('kind').agg(min_height=('height', 'min'), max_weight=('weight', 'max'))
Out[4]:
      min_height  max_weight
kind
cat          9.1         9.9
dog          6.0       198.0

이것은 몇 가지 제한 사항이 있습니다

• 다른 판다들에게는 다소 독특합니다. sytanx (output_name=(selection, aggfunc)) 는 실제로 다른 곳에서는 나타나지 않습니다( .assign 는 output_name=... 패턴을 사용하지만)
• 파이썬 식별자가 아닌 출력 이름의 철자는 추악합니다: .agg(**{'output name': (col, func)})
• Python 3.6+ 전용이거나 **kwargs 의 순서가 이전에 보존되지 않았기 때문에 3.5 및 이전 버전에 대해 추악한 해킹이 필요합니다.
• aggfunc는 단항 함수여야 합니다. 사용자 정의 aggfunc에 추가 인수가 필요한 경우 먼저 부분적으로 적용해야 합니다.

그리고 구현 세부 사항이 있습니다. 동일한 열에 대한 여러 lambda aggfuncs는 아직 지원되지 않지만 나중에 수정할 수 있습니다.

여기에 가입한 대부분의 사람들이 더 이상 사용되지 않는 동작에 대한 대안을 지지할 것이라고 생각합니다. 사람들은 이것을 구체적으로 어떻게 생각합니까?

cc @WillAyd 귀하의 우려 사항을 놓친 경우.

안녕하세요 @TomAugspurger 님 ,

진행해 주셔서 감사합니다.

이것은 몇 가지 제한 사항이 있습니다

• 다른 판다들에게는 다소 독특합니다. sytanx (output_name=(selection, aggfunc)) 는 실제로 다른 곳에는 나타나지 않습니다( .assign 는 output_name=... 패턴을 사용하지만)

이런 종류의 주장은 애초에 기존 구현을 폄하하는 동기를 부여한 주장과 상당히 유사하다는 느낌을 지울 수 없습니다.

특정 주장과 관련하여 기존 방식보다 이 새로운 방식에서 더 많은 이점을 얻는 이유를 공유할 수 있습니까?

내가 이미 생각할 수 있는 한 가지 이점은 (py3.6+의 경우) 열의 출력 순서를 개별적으로 선택할 수 있다는 것입니다.

• python 식별자가 아닌 출력 이름의 철자는 보기 흉합니다: .agg(**{'output name': (col, func)})

그런 점에서 옛날 방식이 더 좋았다. 그러나 앞서 말했듯이 **{...} 구문을 사용하여 집계를 동적으로 구축할 수만 있다면 충분히 만족할 것입니다.

• Python 3.6+ 전용이거나 **kwargs 의 순서가 이전에 보존되지 않았기 때문에 3.5 및 이전 버전에 대해 추악한 해킹이 필요합니다.

이전에는 어떻게 작동했습니까(기존 dict-of-dict 기능)? 어떤 식 으로든 주문이 보장 되었습니까?

• aggfunc는 단항 함수여야 합니다. 사용자 정의 aggfunc에 추가 인수가 필요한 경우 먼저 부분적으로 적용해야 합니다.

내 이해를 확인하기 위해: aggfunc는 유효한 값을 반환하는 모든 호출 가능 객체가 될 수 있습니까? ( 'min' , 'max' 등과 같은 "자주 사용되는" 문자열 aggfungs 외에도). 전과 비교했을 때 달라진 점이 있나요? (즉, 단항 제한이 이미 존재하지 않았습니까?)

그리고 구현 세부 사항이 있습니다. 동일한 열에 대한 여러 lambda aggfuncs는 아직 지원되지 않지만 나중에 수정할 수 있습니다.

예, 그것은 일종의 성가신 일이지만 일시적인 제한이고 이 문제를 해결하기 위해 열려 있는 한 작동할 수 있습니다.

여기에 가입한 대부분의 사람들이 더 이상 사용되지 않는 동작에 대한 대안을 지지할 것이라고 생각합니다. 사람들은 이것을 구체적으로 어떻게 생각합니까?

글쎄, 어쨌든 나는 한 단계에서 집계하고 이름을 바꾸는 것이 정말 중요하다고 생각합니다. 이전 동작이 실제로 옵션이 아닌 경우 이 대안이 가능합니다.

특정 주장과 관련하여 기존 방식보다 이 새로운 방식이 더 많은 이점을 제공하는 이유를 공유해 주시겠습니까?

내가 잘못 기억하고 있을지도 모르지만 SeriesGroupby.agg와 DataFrameGroupby.agg는 사전의 외부 키 사이에 다른 의미를 가지고 있다고 생각합니다(열 선택입니까 아니면 출력 이름 지정입니까?). 이 구문을 사용하면 키워드가 출력 이름을 의미하도록 일관되게 할 수 있습니다.

그런 점에서 옛날 방식이 더 좋았다.

차이점은 ** 까? 그렇지 않으면 동일한 제한 사항이 공유된다고 생각합니다.

이전에는 어떻게 작동했습니까(기존 dict-of-dict 기능)? 어떤 식 으로든 주문이 보장 되었습니까?

지금 PR에서 하고 있는 키 정렬입니다.

내 이해를 확인하기 위해: aggfunc는 유효한 값을 반환하는 모든 호출 가능 객체가 될 수 있습니까?

차이점은 다음과 같습니다.

In [21]: df = pd.DataFrame({"A": ['a', 'a'], 'B': [1, 2], 'C': [3, 4]})

In [22]: def aggfunc(x, myarg=None):
    ...:     print(myarg)
    ...:     return sum(x)
    ...:

In [23]: df.groupby("A").agg({'B': {'foo': aggfunc}}, myarg='bar')
/Users/taugspurger/sandbox/pandas/pandas/core/groupby/generic.py:1308: FutureWarning: using a dict with renaming is deprecated and will be removed in a future version
  return super().aggregate(arg, *args, **kwargs)
None
Out[23]:
    B
  foo
A
a   3

대안 제안으로 우리는 출력 열 이름을 위해 **kwargs 를 예약합니다. 따라서 functools.partitial(aggfunc, myarg='bar') 합니다.

네, 감사합니다. 제안된 접근 방식은 첫 번째 반복에 대해 👍라고 생각합니다(다중 람다 구현 제한이 제거되는 즉시 교체로 괜찮을 것입니다).