[Pandas] 데이터의 그룹 연산

데이터의 그룹 연산

• 데이터의 그룹 연산은 원본 데이터 세트 객체를 그룹별로 분할(Split)하고 분할된 각 그룹에 함수를 적용(Apply)하고 결과를 통합(Combine)하는 연산을 수행한다.
  • 이를 하나의 용어로 Split-Apply-Combine 이라 한다.
• 대다수의 경우 데이터를 여러 집합(Sets)으로 분할하고, 분할된 각 부분 집합에 함수와 같은 기능을 적용한다.
• 또는 분할하지 않더라도 여러 데이터 세트의 값들을 원하는 조건에 따라 어떤 인덱스나 라벨에 하나의 값으로 변환하는 형태로써 데이터를 합치는데, 이를 그룹 연산이라고 한다.
• groupby() 는 원본 데이터를 개별 그룹으로 나누어 이 그룹들에 특정 연산을 수행하고 수행 결과를 나타내는 각 그룹들을 합치기 위한 메소드이다.
  • 예를 들어, 초등학생들을 남녀 그룹으로 구분하고, 다시 학년별로 구분하고 그룹들의 평균을 구하는 함수를 적용해 이 그룹들을 다시 통합하는데 적용할 수 있다.

 

• 그룹 연산은 분할된 각 그룹에 통계 요약이나 통계 계산을 수행하기 위해 집계(Aggregation)하거나 그룹 내에서 데이터를 표준화하거나 손실 값들을 각 그룹에서 도출된 값으로 채우는 등 그룹에 특정 연산을 수행하는 것이다.
• 또는 인덱스 처리된 객체를 반환하는 변환(Transformation)을 실행한다.
• 혹은 몇몇 요소만 가지는 그룹에 속하는 데이터를 삭제하거나 그룹 총합 또는 평균에 따라 데이터를 필터링(Filtering)하는 작업 등을 실행한다는 의미이다.

 

데이터 객체를 그룹 연산

• 판다스는 DataFrame.groupby()와 Series.groupby() 메소드를 호출하여 GroupBy 객체를 반환하는 데이터 그룹 연산 기능을 제공한다.

 

GroupBy 객체 속성

• GroupBy 객체를 생성한다는 것은 groupby() 메소드에 어떤 기준에 따라 인수들을 적용해 데이터 개체를 더 작은 그룹들로 분할한다는 의미이다.

df = pd.DataFrame({'A': ['ha', 'hi', 'ho', 'ha', 'ho'],
                   'B': ['one', 'two', 'one', 'one', 'two'],
                   'Data1': np.random.randn(5),
                   'Data2': np.random.randn(5)})
df

 

• 다음은 groupby 메소드를 이용해 df 객체를 열 A를 기준으로 A의 요소 ha, hi, ho 3개 그룹으로 분할한 grouped1 을 반환하는 예제이다.
• grouped1
  • DataFrameGroupBy 객체
  • 그룹들의 속성은 키가 반영된 단일 그룹
  • 각 그룹에 속하는 축 라벨에 해당하는 값이 있는 딕셔너리

>>> grouped1 = df.groupby('A')
>>> grouped1
<pandas.core.groupby.generic.DataFrameGroupBy object at 0x000001561778C730>

>>> gr_dict = dict(list(grouped1))
>>> gr_dict
{'ha':     A    B     Data1     Data2
 0  ha  one  1.116526 -1.905494
 3  ha  one -0.601640 -1.722962,
 'hi':     A    B     Data1     Data2
 1  hi  two -0.900592  1.144933,
 'ho':     A    B     Data1     Data2
 2  ho  one -0.291602 -0.488843
 4  ho  two  0.618950 -1.594516}
 
 >>> grouped1.groups
 {'ha': [0, 3], 'hi': [1], 'ho': [2, 4]}

 

• 특정 그룹인 ho를 선택해 해당 데이터를 구하는 방법에는 2가지가 있다.
  • gr_dict에서 ho에 해당하는 데이터를 구하는 방법
  • GroupBy 객체인 group1에 get_group() 메소드를 사용하는 방법

gr_dict['ho']

 

grouped1.get_group('ho')

 

• 다음 예제에서는 반환되는 객체 grouped1 에서 ha, hi, ho 3개 그룹을 기준으로 Data1과 Data2의 평균값을 구한다.

grouped1.mean()

 

• 다른 조건은 동일하게 하고, Data2의 평균값만 구하려면 다음과 같이 실행한다.
• 여기에서 grouped2는 SeriesGroupBy 객체라는 점에 주목한다.
• 따라서 이 객체의 평균값을 구한 결과는 시리즈 객체이다.

>>> grouped2 = df['Data2'].groupby(df['A'])
>>> grouped2
<pandas.core.groupby.generic.SeriesGroupBy object at 0x000001561778F7F0>

>>> grouped2.mean()
A
ha   -1.814228
hi    1.144933
ho   -1.041680
Name: Data2, dtype: float64

 

• 다음은 df의 A열과 B열을 기준으로 한 인수를 groupby()에 전달하고, Data1의 평균값만 구하는 예제이다.
• grouped3은 df 객체를 4개 그룹으로 분할한 SeriesGroupBy 객체임을 확인할 수 있다.

>>> grouped3 = df['Data1'].groupby([df['A'], df['B']])
>>> grouped3.groups
{('ha', 'one'): [0, 3], ('hi', 'two'): [1], ('ho', 'one'): [2], ('ho', 'two'): [4]}

>>> grouped3
<pandas.core.groupby.generic.SeriesGroupBy object at 0x0000015617797400>

>>> grouped3.mean()
grouped3.mean()
grouped3.mean()
A   B  
ha  one    0.257443
hi  two   -0.900592
ho  one   -0.291602
    two    0.618950
Name: Data1, dtype: float64

 

• df와 길이가 같은 배열로 이루어진 시리즈 객체와 리스트를 groupby()에 전달하여 연산을 실행할 수도 있다.
• 다음 예제는 이러한 조건에서 인덱스를 변경한다.

>>> material = np.array(['water', 'oil', 'oil' ,'water', 'oil'])
>>> time = ['1hr', '1hr', '2hr', '2hr', '1hr']
>>> df['Data1'].groupby([material, time]).mean()
oil    1hr   -0.140821
       2hr   -0.291602
water  1hr    1.116526
       2hr   -0.601640
Name: Data1, dtype: float64

 

GroupBy 순서 정렬

• groupby() 연산을 수행할 때 그룹 키의 순서는 기본으로 정렬된다.

df2 = pd.DataFrame({'A': ['ho', 'hi', 'ha'],
'B': ['two', 'one', 'two'],
'Data1': np.random.randn(3)})
df2.groupby(['A']).sum()

 

df2.groupby('A', sort=False).sum()

 

멀티 인덱스가 있는 객체를 그룹 연산

• 멀티 인덱싱된 데이터의 계층 레벨 중 한 레벨로 groupby() 연산을 실행할 수 있다.
• 이를 확인하기 위해 2개 레벨을 가진 멀티 인덱스가 있는 시리즈를 생성한다.

>>> arr = [['ha', 'ha', 'hi', 'hi', 'ho', 'ho'], ['one', 'two', 'one', 'one', 'two', 'two']]
>>> ind = pd.MultiIndex.from_arrays(arr, names=['1st', '2nd'])
>>> ser = pd.Series(np.random.randn(6), index=ind)
>>> ser
1st  2nd
ha   one   -0.034185
     two   -0.795684
hi   one   -0.102656
     one   -2.227725
ho   two    1.025775
     two   -0.251597
dtype: float64

 

• ser의 레벨 중 하나로 groupby() 연산을 수행한다.
• level=0은 1st 열의 인덱스인 ha, ho, ho를 의미하며, level=1은 2nd 열의 one, two를 의미한다. 

>>> ser.index
MultiIndex([('ha', 'one'),
            ('ha', 'two'),
            ('hi', 'one'),
            ('hi', 'one'),
            ('ho', 'two'),
            ('ho', 'two')],
           names=['1st', '2nd'])
           
>>> grouped = ser.groupby(level=0)
>>> grouped.sum()
1st
ha   -0.829869
hi   -2.330381
ho    0.774179
dtype: float64

 

• 다음과 같이 멀티 인덱스의 names에 명시한 2nd를 level의 값으로 전달해 그룹 연산을 실행할 수 있다.

>>> ser.groupby(level='2nd').sum()
2nd
one   -2.364566
two   -0.021506
dtype: float64

 

그룹 객체의 반복 처리

• GroupBy 객체를 이용해 반복 연산을 수행할 수 있다.
• 다음은 생성된 GroupBy 객체 grouped1을 이용해 반복 연산을 수행하는 예제이다.

>>> grouped1 = df.groupby('A')
>>> for name, group in grouped1:
>>>    print(name)
ha
hi
ho

 

• 사용자 정의 변수 name과 group을 출력한 결과는 다음과 같다.

>>> for name, group in grouped1:
>>>    print(name)
>>>    print(group)
ha
    A    B     Data1     Data2
0  ha  one  1.116526 -1.905494
3  ha  one -0.601640 -1.722962
hi
    A    B     Data1     Data2
1  hi  two -0.900592  1.144933
ho
    A    B     Data1     Data2
2  ho  one -0.291602 -0.488843
4  ho  two  0.618950 -1.594516

 

• 다음은 A와 B를 df의 인수로 설정해 그룹 연산을 실행하고 반복 연산을 이용해 변수인 튜플 (n1, n2)와 group을 구하는 예제이다.

>>> for (n1, n2), group in df.groupby(['A', 'B']):
>>>    print((n1, n2))
>>>    print(group)
('ha', 'one')
    A    B     Data1     Data2
0  ha  one  1.116526 -1.905494
3  ha  one -0.601640 -1.722962
('hi', 'two')
    A    B     Data1     Data2
1  hi  two -0.900592  1.144933
('ho', 'one')
    A    B     Data1     Data2
2  ho  one -0.291602 -0.488843
('ho', 'two')
    A    B    Data1     Data2
4  ho  two  0.61895 -1.594516

 

 

GroupBy 객체를 그룹별 연산 및 변환

• 1개 이상의 열로 이루어진 GroupBy 연산 결과에 aggregate() 또는 agg() 메소드를 사용하면 1개 이상의 집계 연산을 수행할 수 있다.
• 각 그룹에 count(), max(), min(), sum(), avg() 등과 같은 함수를 용도에 따라 적용하고 집계된 결과들을 하나의 데이터프레임으로 나타낼 수 있다.
• 또한, 각 그룹을 표준화하는 등의 변환을 수행할 수 있다.

 

데이터 집계하기

• 데이터를 집계하는 연산을 실행하기 위해 먼저 다음과 같이 df 객체를 생성한다.

df = pd.DataFrame({'A': ['ha', 'hi', 'ho', 'ha', 'ho'],
                   'B': ['one', 'two', 'one', 'one', 'two'],
                   'Data1': np.random.randn(5),
                   'Data2': np.random.randn(5)})
df

 

• GroupBy 객체가 생성되면 그 데이터에 계산을 실행하는 몇몇 메소드를 적용할 수 있다.
• 다음 예제에서는 데이터를 집계하는 agg() 메소드를 적용한다.

grouped1 = df.groupby('A')
grouped1.agg(np.sum)

 

grouped2 = df.groupby(['A', 'B'])
grouped2.agg('sum')

 

• 키가 여러 개인 경우 groupby()에 as_index=True 인수를 사용하면 열들을 멀티 인덱스로 변경할 수 있다.
• 다음 예제는 as_index가 False로써 열 A, B가 멀티 인덱스가 아닌 요솟값을 가진다.
• 인수 as_index의 기본값은 True이다.

grouped3 = df.groupby(['A', 'B'], as_index=False)
grouped3.aggregate(np.sum)

 

df.groupby('A', as_index=False).sum()

 

• 다음과 같이 GroupBy 객체에 size() 메소드를 사용해 각 그룹의 크기를 구할 수 있다.

>>> grouped2.size()
A   B  
ha  one    2
hi  two    1
ho  one    1
    two    1
dtype: int64

 

대표적인 aggregation() 함수들

함수	기능
mean()	그룹들의 평균 계산
sum()	그룹 값들의 합계 계산
size()	손실값을 포함한 그룹 수 계산
count()	손실값을 제외한 그룹 수 계산
std()	그룹들의 표준 편차 계산
var()	그룹들의 분산 계산
sem()	그룹 평균의 표준 편차 계산
describe()	요약된 통계 반환
first()	그룹 값들 중에서 첫 번째 행 반환
last()	그룹 값들 중에서 미자막 행 반환
nth()	n 번째 행을 반환하거나 n 이 리스트이면 서브세트 반환
min()	그룹 값들의 최솟값 계산
max()	그룹 값들의 최댓값 계산

 

• aggregation() 함수들은 반환된 객체의 차원을 축소시킬 수 있다.

grouped = df.groupby('A')
grouped['Data1'].agg([np.sum, np.mean, np.std])

 

• 각 열에 적용할 함수들의 리스트를 DataFrameGroupBy 객체인 grouped에 전달할 수 있으며, 집계 연산으로 처리된 결과는 멀티 인덱스를 가진다.

grouped.agg([np.sum, np.mean])

 

• 처리 결과를 살펴보면 함수 자체가 열의 이름이 되는데 이름을 변경하고 싶다면 다음과 같이 rename() 메소드를 실행한다.

grouped['Data1'].agg([np.sum, np.mean]).rename(columns={'sum': '합계', 'mean': '평균'})

 

• DataFrameGroupBy 객체의 이름도 rename() 메소드로 변경할 수 있다.

grouped.agg([np.sum, np.mean]).rename(columns={'sum': '합계','mean': '평균'})

 

데이터프레임 열들에 각각 다른 함수 적용하기

• 데이터를 집계 연산하기 위해 여러 함수로 이루어진 딕셔너리를 전달하면 데이터프레임의 각 열에 서로 다른 연산을 수행할 수 있다.

grouped.agg({'Data2': np.sum, 'Data1': lambda x: np.sum(x)})

 

• aggregate() 함수에 딕셔너리를 전달하면 열의 순서를 임의로 출력한다.
• 특정 순서로 열을 정렬해 출력하고 싶다면 OrderedDict() 메소드를 사용한다.

from collections import OrderedDict
grouped.agg({'Data2': 'sum', 'Data1': np.mean})

 

df_grd = grouped.agg(OrderedDict([('Data2', 'sum'), ('Data1', 'mean')]))
df_grd

 

• 다음 예제에서는 df_grd에서 인덱스 ha를 gold로, hi를 silver로, ho를 gold로 변경한 후 gold와 silver 각각의 합계를 구한다.

ind = ['gold', 'silver', 'gold']
df_grd.groupby(ind).sum()

 

자동차 판매 대리점별 영업 현황 데이터 연산과 변환

• transform() 메소드는 groupby와 연계해 데이터를 효율적으로 요약하기 위해 사용한다.
• aggregate() 메소드는 차원이 감소된 데이터를 반환하지만, transform() 메소드는 shape가 같은 재결합된 온전한 데이터를 반환한다.

 

예제 : H자동차 3개 대리점의 그랜저, 소나타, 아벤떼 차종 영업 현황 데이터를 이용한 데이터 연산과 변환 작업

• 데이터에는 연남, 성산, 연희 3개 H자동차 대리점에서 판매된 차종별 매출액 비율을 1가지 방법으로 구한다.
  • agg() 메소드
  • transform() 메소드
    • 인덱스를 리셋할 필요가 없어 효율적으로 연산할 수 있다.

 

agg()를 이용해 매출액 비율 구하기

df = pd.read_excel('car_sales.xlsx')
df

 

• 데이터를 지점을 의미하는 Branch로 그룹화하고, Ext Price 열을 기준으로 그룹별로 더한다.

>>> df.groupby('Branch')['Ext Price'].agg('sum')
Branch
Sungsan    667
Yeonhi     782
Yeonnam    510
Name: Ext Price, dtype: int64

 

• 시리즈의 인덱스 라벨 또는 이름을 변경하는 rename() 메소드를 적용해 Ext Price의 이름을 Br_Total로 변경한다.

>>> df.groupby('Branch')['Ext Price'].agg('sum').rename('Br_Total')
Branch
Sungsan    667
Yeonhi     782
Yeonnam    510
Name: Br_Total, dtype: int64

 

• 인덱스를 초기화하여 새로운 데이터프레임을 생성하기 위해 reset_index() 메소드를 적용한다.

br_total = df.groupby('Branch')['Ext Price'].agg('sum').rename('Br_Total').reset_index()
br_total

 

• 원본 데이터 df에 대리점별 매출액을 나타내는 Br_Total 데이터를 합친다.

df_m = df.merge(br_total)
df_m

 

• 다음으로 각 대리점의 차종별 매출액 비율을 구한다.
• 이를 위해 Br_Pct 열을 생성하고 값들을 동적 할당한다.

df_m['Br_Pct'] = df_m['Ext Price'] / df_m['Br_Total']
df_m

 

transform() 메소드를 이용해 매출액 비율 구하기

• transform() 메소드를 이용해 같은 결과인 Br_Pct를 더 간단하게 연산할 수 있다.

>>> df.groupby('Branch')['Ext Price'].transform('sum')
0    510
1    510
2    510
3    667
4    667
5    667
6    782
7    782
8    782
Name: Ext Price, dtype: int64

 

• 대리점별 자동차 매출액을 구한 후 각 대리점에서 차량별 매출액 비율을 구한다.

df['Br_Total'] = df.groupby('Branch')['Ext Price'].transform('sum')
df['Br_Pct'] = df['Ext Price'] / df['Br_Total']
df

 

• 이처럼 GroupBy 객체에 transform() 메소드를 적용하면 agg() 메소드를 적용한 것보다 효율적으로 연산을 수행할 수 있다.

 

 

GroupBy 객체를 이용한 분할, 적용, 통합

학교별 수학 성적에 분할, 적용, 통합 연산 실행

• GroupBy 객체를 이용해 분할, 적용, 통합 연산을 실행하기 위해 학교 이름, 학생 이름 그리고 수학 성적 데이터로 이루어진 객체를 다음과 같이 생성한다.
• 생성된 객체로 데이터를 전처리하여 학교별 수학 성적 평균을 구하고, 학생 개인별 성적과 비교하고 학생들의 학점도 산출해본다.

df = pd.DataFrame({'School': ['Yeonhi', 'Yeonhi', 'Sungsan', 'Sungsan', 'Sungsan'], 
                   'Name': ['Haena', 'Gisu', 'Una', 'Naeun', 'Ziho'],
                   'Math_S': [92, 70, 88, 92, 70]})
df

 

• School 인수를 가지는 GroupBy 객체의 수학 성적인 Math_S 열에서 학교별 평균을 구한다.

>>> mean_s = df.groupby('School')['Math_S'].agg('mean')
>>> mean_s
School
Sungsan    83.333333
Yeonhi     81.000000
Name: Math_S, dtype: float64

 

• rename() 메소드를 이용해 mean_s 객체의 이름인 Math_S를 Avg_S로 변경한다.

>>> mean_s.rename('Avg_S')
School
Sungsan    83.333333
Yeonhi     81.000000
Name: Avg_S, dtype: float64

 

• 인덱스를 초기화하면 avg_score의 인덱스는 시퀀스 형태가 된다.

avg_score = mean_s.rename('Avg_S').reset_index()
avg_score

 

• df 객체에 avg_score 객체를 합친다.

df1 = df.merge(avg_score)
df1

 

• apply() 메소드를 적용하여 수학 성적을 1 이하로 변환해본다.
• 이 변환은 다양한 응용 사례에 적용할 수 있도록 하는 예제이다.

df['Rating_S'] = df['Math_S'].apply(lambda x: x/100)
df

 

• 학생들의 점수를 A, B, C, F 학점으로 변환하기 위해 수학 성적을 나타내는 Math_S 열을 math_score 변수에 다음과 같이 할당한다.

>>> math_score = df['Math_S']
>>> grade = []
>>> for x in math_score:
>>>     if x > 90:
>>>         grade = grade + ['A']
>>>     elif x > 80:
>>>         grade = grade + ['B']
>>>     elif x > 70:
>>>         grade = grade + ['C']
>>>     else:
>>>         grade = grade + ['F']

 

• 학점을 나타내는 리스트인 grade를 df 객체에 동적 할당한다.

>>> grade
['A', 'F', 'B', 'A', 'F']

>>> df['Grade'] = grade

 

• 학점 데이터가 추가된 df 객체를 확인한다.

df

 

• 이번에는 transform() 메소드를 사용해 학점을 연산하는 방법이다.
• 먼저 transform() 메소드로 수학 성적 평균을 구하고, df 객체에 Avg_S를 추가한다.

df['Avg_S'] = df.groupby('School')['Math_S'].transform('mean')
df

 

• 평균 점수보다 큰 수학 점수를 불리언으로 나타내는 열 Above_avg를 추가하고 데이터를 완성한다.

df['Above_Avg'] = df['Avg_S'] < df['Math_S']
df

 

apply() 메소드 적용

• apply() 메소드는 함수를 그룹별로 적용하고 그 결과를 통합하는 연산을 수행한다.
• apply() 메소드에 전달하는 함수는 데이터프레임을 첫 번째 인수로 가져야 하며, 결과로 데이터프레임, 시리즈 또는 스칼라를 반환한다.

 

• apply() 메소드를 이용해 분할된 그룹에 함수들을 적용하고 통합할 수 있다.
• 다음 예제는 GroupBy 객체에 apply() 메소드를 적용한다.
  • 수학 점수인 Math_S 열의 값들을 오름차순으로 정렬한다.
    • 이를 위해 먼저 순서를 정렬하는 사용자 정의 함수 sort_math()를 입력하고 호출하는 코드를 다음과 같이 실행한다.

def sort_math(dfs, n=3, column='Math_S'):
    return dfs.sort_values(by=column)[:n]
sort_math(df, n=5)

 

• 이를 학교별로 그룹을 분할한 후 apply() 메소드를 적용하고, sort_math 함수를 인수로 전달한다.
• apply(sort_math, n=2)를 입력하면 sort_math() 함수에 n=2라는 인수를 전달해 연산한다.
• apply(sort_math, n=2, column='Rating_S')는 sort_math() 함수에 n=2, column='Rating_S'를 전달하라는 의미이다.

df.groupby('School').apply(sort_math, n=2, column='Rating_S')

 

 

기타 그룹 연산

불필요한 부분을 자동으로 제거

• 다음은 특정 열을 기준으로 표준 편차를 계산하는 예제이다.
• 이 데이터에 집계 연산을 위한 함수를 적용할 때 연산 범주에 해당하지 않는 B열을 제거해도 어떤 문제가 발생하지 않는다.

df = pd.DataFrame({'A': ['ha', 'hi', 'ho', 'ha', 'ho'],
                   'B': ['one', 'two', 'one', 'one', 'two'],
                   'Data1': np.random.randn(5),
                   'Data2': np.random.randn(5)})
df

 

df.groupby('A').std()

 

• 그룹 키에 NaN이나 NaT가 있다면 이 키들은 자동으로 배제된다.
  • NA 그룹이나 NaT 그룹은 존재하지 않는다.

 

순서가 정렬된 요소를 그룹화

• 판다스 Categorical 클래스의 인스턴스인 범주형 변수들을 그룹 키로써 사용할 수 있다.
  • 이때 레벨 순서가 유지된다.
• 다음은 data에 동일한 개수로 범주를 적용한 결과를 그룹화하여 평균을 구하는 예제이다.

>>> data = pd.Series(np.random.randn(16))
>>> data
0     0.667868
1    -0.375939
2    -0.299466
3    -0.526974
4     0.740261
5    -1.197674
6    -1.859779
7    -0.875317
8     0.874298
9    -1.200401
10    1.101841
11    0.593454
12    0.851743
13    0.402624
14   -0.126425
15    0.888500
dtype: float64

>>> factor = pd.qcut(data, [0, .25, .5, .75, 1.])
>>> factor
0       (0.138, 0.768]
1      (-0.614, 0.138]
2      (-0.614, 0.138]
3      (-0.614, 0.138]
4       (0.138, 0.768]
5     (-1.861, -0.614]
6     (-1.861, -0.614]
7     (-1.861, -0.614]
8       (0.768, 1.102]
9     (-1.861, -0.614]
10      (0.768, 1.102]
11      (0.138, 0.768]
12      (0.768, 1.102]
13      (0.138, 0.768]
14     (-0.614, 0.138]
15      (0.768, 1.102]
dtype: category
Categories (4, interval[float64]): [(-1.861, -0.614] < (-0.614, 0.138] < (0.138, 0.768] < (0.768, 1.102]]

>>> data.groupby(factor).mean()
(-1.861, -0.614]   -1.283293
(-0.614, 0.138]    -0.332201
(0.138, 0.768]      0.601052
(0.768, 1.102]      0.929096
dtype: float64

 

각 그룹의 행 확인하기

• 데이터프레임이나 시리즈와 같이 GroupBy 객체에서도 head와 tail을 호출할 수 있다.
• 다음 예제에서 head(1)은 A 열 값의 2개 그룹인 1과 5에서 첫 번째 행을 출력한다.
  • tail(1)은 각 그룹의 마지막 행을 출력한다.

df = pd.DataFrame([[1, 2], [1, 4], [5, 6], [5, 8]], columns=['A', 'B'])
df

 

gr = df.groupby('A')
gr.head(1)

 

gr.tail(1)

 

• 다음은 각 그룹에서 n 번째 행을 선택하는 예제이다.
• 데이터프레임이나 시리즈에서 n 번째 행을 선택하려면 nth() 메소드를 사용한다.
  • 이것은 감소(Reduction) 메소드이며, n에 정수를 전달하면 그룹당 1개 또는 0개의 행을 반환한다.
    • 감소 메소드는 데이터프레임의 연산 결과가 시리즈로 변환되어 차원이 낮아지는 것을 의미한다.
• 예제의 nth(0)은 gr.first()와 같다.

gr.nth(0)

 

gr.nth(1)

 

gr.nth(-1)

 

• null이 아닌 n 번째 요소를 선택하고 싶다면 dropna kwarg를 사용한다.
  • kwarg는 키워드 인수의 총칭을 나타낸다.
• 데이터프레임에 dropna() 메소드를 전달하는 것 같이 any 나 all 값을 선택한다.

df = pd.DataFrame([[1, np.nan], [1, 4], [5, 6], [5, 8]], columns=['A', 'B'])
df

 

gr = df.groupby('A')
gr.nth(0)

 

gr.nth(0, dropna='any')

 

gr.first()

 

gr.last()

 

• groupby() 함수에 as_index=False 인수를 전달하면 그룹화된 행을 반환한다.

gr1 = df.groupby('A', as_index=False)
gr1.nth(0)