visualization
데이터 집계와 재구조화
hayleyhell
2022. 11. 18. 18:46
In [1]:
import pandas as pd
In [2]:
netflix_titles = pd.read_csv('https://raw.githubusercontent.com/minaahayley/Python/main/data/netflix_titles.csv')
In [3]:
netflix_titles.sample()
Out[3]:
| show_id | type | title | director | cast | country | date_added | release_year | rating | duration | listed_in | description | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 847 | s848 | TV Show | Mad for Each Other | NaN | Jung Woo, Oh Yeon-seo, Baik Ji-won, Lee Hye-eu... | NaN | May 24, 2021 | 2021 | TV-MA | 1 Season | International TV Shows, Romantic TV Shows, TV ... | Bothered to realize they are next-door neighbo... |
value_counts()¶
- value_counts()에서 normalize=True 옵션 사용하기
In [4]:
#value_counts를 사용하면 그룹화 된 데이터의 카운트 값을 보여준다.
type_count = pd.DataFrame(netflix_titles['type'].value_counts())
type_count
Out[4]:
| type | |
|---|---|
| Movie | 6131 |
| TV Show | 2676 |
In [5]:
#normalize=True 옵션을 사용하면, 해당 데이터가 전체 데이터에서 어느 정도의 비율을 차지하는 지 알 수 있다.
type_percent = pd.DataFrame(netflix_titles['type'].value_counts(normalize=True))
type_percent
Out[5]:
| type | |
|---|---|
| Movie | 0.696151 |
| TV Show | 0.303849 |
In [6]:
df = type_count.merge(type_percent, how='left', left_index=True, right_index=True)
df.columns = ['콘텐츠 수', '비율']
df.head()
Out[6]:
| 콘텐츠 수 | 비율 | |
|---|---|---|
| Movie | 6131 | 0.696151 |
| TV Show | 2676 | 0.303849 |
groupby().agg()¶
*groupby().agg() 함수를 이용하여 멀티 컬럼 집계하기
groupby() 함수로 집계해서 나온 Series를 데이터프레임으로 만들고 싶은 경우, reset_index()를 해주면 된다.
In [7]:
netflix_titles.groupby('release_year')['title'].count()
Out[7]:
release_year
1925 1
1942 2
1943 3
1944 3
1945 4
...
2017 1032
2018 1147
2019 1030
2020 953
2021 592
Name: title, Length: 74, dtype: int64
In [8]:
netflix_titles.groupby('release_year')['title'].count().reset_index()
Out[8]:
| release_year | title | |
|---|---|---|
| 0 | 1925 | 1 |
| 1 | 1942 | 2 |
| 2 | 1943 | 3 |
| 3 | 1944 | 3 |
| 4 | 1945 | 4 |
| ... | ... | ... |
| 69 | 2017 | 1032 |
| 70 | 2018 | 1147 |
| 71 | 2019 | 1030 |
| 72 | 2020 | 953 |
| 73 | 2021 | 592 |
74 rows × 2 columns
한 번의 groupby 집계를 통해 여러 통계 함수를 적용하고 싶을 때 agg() 함수를 이용하면 된다.
이 경우 컬럼 이름을 지정해 줄 수 있어, rename() 함수를 이용하지 않아도 된다.
In [9]:
group = netflix_titles.groupby('release_year').agg(title_cnt = ('title', 'count'), country_cnt = ('country', 'count'))
group
Out[9]:
| title_cnt | country_cnt | |
|---|---|---|
| release_year | ||
| 1925 | 1 | 0 |
| 1942 | 2 | 2 |
| 1943 | 3 | 3 |
| 1944 | 3 | 3 |
| 1945 | 4 | 4 |
| ... | ... | ... |
| 2017 | 1032 | 966 |
| 2018 | 1147 | 1038 |
| 2019 | 1030 | 913 |
| 2020 | 953 | 852 |
| 2021 | 592 | 383 |
74 rows × 2 columns
drop()¶
- drop() 함수를 이용하여 행과 열 삭제하기
- 특정 조건을 만족하는 인덱스(행) 삭제
- df.drop(조건이 포함된 인덱스, inplace=True)
In [10]:
#release_yeaer가 2000년 이하인 인덱스
group[group.index < 2000].index
Out[10]:
Int64Index([1925, 1942, 1943, 1944, 1945, 1946, 1947, 1954, 1955, 1956, 1958,
1959, 1960, 1961, 1962, 1963, 1964, 1965, 1966, 1967, 1968, 1969,
1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, 1980,
1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991,
1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999],
dtype='int64', name='release_year')
In [11]:
group.drop(group[group.index < 2000].index, inplace=True)
group
Out[11]:
| title_cnt | country_cnt | |
|---|---|---|
| release_year | ||
| 2000 | 37 | 36 |
| 2001 | 45 | 44 |
| 2002 | 51 | 50 |
| 2003 | 61 | 59 |
| 2004 | 64 | 62 |
| 2005 | 80 | 79 |
| 2006 | 96 | 95 |
| 2007 | 88 | 87 |
| 2008 | 136 | 132 |
| 2009 | 152 | 142 |
| 2010 | 194 | 178 |
| 2011 | 185 | 179 |
| 2012 | 237 | 222 |
| 2013 | 288 | 270 |
| 2014 | 352 | 333 |
| 2015 | 560 | 516 |
| 2016 | 902 | 838 |
| 2017 | 1032 | 966 |
| 2018 | 1147 | 1038 |
| 2019 | 1030 | 913 |
| 2020 | 953 | 852 |
| 2021 | 592 | 383 |
특정 조건을 만족하는 컬럼(열) 삭제
df.drop(컬럼, axis=1, inplace=True)
In [12]:
group.drop(['country_cnt'], axis=1, inplace=True)
group
Out[12]:
| title_cnt | |
|---|---|
| release_year | |
| 2000 | 37 |
| 2001 | 45 |
| 2002 | 51 |
| 2003 | 61 |
| 2004 | 64 |
| 2005 | 80 |
| 2006 | 96 |
| 2007 | 88 |
| 2008 | 136 |
| 2009 | 152 |
| 2010 | 194 |
| 2011 | 185 |
| 2012 | 237 |
| 2013 | 288 |
| 2014 | 352 |
| 2015 | 560 |
| 2016 | 902 |
| 2017 | 1032 |
| 2018 | 1147 |
| 2019 | 1030 |
| 2020 | 953 |
| 2021 | 592 |
xs()¶
- xs() 함수를 이용하여 멀티 인덱스 다루기
In [13]:
#멀티 인덱스 생성
multi_index = netflix_titles.groupby(['release_year', 'type'])['title'].count().reset_index().set_index(['release_year', 'type'])
multi_index
Out[13]:
| title | ||
|---|---|---|
| release_year | type | |
| 1925 | TV Show | 1 |
| 1942 | Movie | 2 |
| 1943 | Movie | 3 |
| 1944 | Movie | 3 |
| 1945 | Movie | 3 |
| ... | ... | ... |
| 2019 | TV Show | 397 |
| 2020 | Movie | 517 |
| TV Show | 436 | |
| 2021 | Movie | 277 |
| TV Show | 315 |
119 rows × 1 columns
xs() 함수는 멀티 인덱스에 가장 적합하며, level에 따라서 인덱스 지정을 해줄 수 있다.
In [14]:
#멀티 인덱스로 2000년 release 된 title을 선택하고 싶은 경우
multi_index.xs(2000, level='release_year')
Out[14]:
| title | |
|---|---|
| type | |
| Movie | 33 |
| TV Show | 4 |
In [15]:
#멀티 인덱스로 type이 Movie인 title을 선택하고 싶은 경우
multi_index.xs('Movie', level='type')
Out[15]:
| title | |
|---|---|
| release_year | |
| 1942 | 2 |
| 1943 | 3 |
| 1944 | 3 |
| 1945 | 3 |
| 1946 | 1 |
| ... | ... |
| 2017 | 767 |
| 2018 | 767 |
| 2019 | 633 |
| 2020 | 517 |
| 2021 | 277 |
73 rows × 1 columns
stack()¶
- stack() 함수를 이용하여 멀티 컬럼을 stacking 하기
먼저 netfilix 데이터를 country와 type별로 그룹화하여 각 그룹의 평균 duration과 release year를 구한다.
In [16]:
#duration 전처리
netflix_titles['duration'] = pd.to_numeric(netflix_titles['duration'].str.split('Season|min', expand=True)[0].replace({'NaN':None}))
netflix_titles['duration']
Out[16]:
0 90.0
1 2.0
2 1.0
3 1.0
4 2.0
...
8802 158.0
8803 2.0
8804 88.0
8805 88.0
8806 111.0
Name: duration, Length: 8807, dtype: float64
멀티 컬럼을 생성하기 위해 여러 개의 함수를 한번에 집계하기
In [17]:
group = netflix_titles.groupby(['type','rating'])[['release_year', 'duration']].agg(['min', 'mean'])
group.head()
Out[17]:
| release_year | duration | ||||
|---|---|---|---|---|---|
| min | mean | min | mean | ||
| type | rating | ||||
| Movie | 66 min | 2015 | 2015.000000 | NaN | NaN |
| 74 min | 2017 | 2017.000000 | NaN | NaN | |
| 84 min | 2010 | 2010.000000 | NaN | NaN | |
| G | 1956 | 1997.804878 | 9.0 | 90.268293 | |
| NC-17 | 2013 | 2015.000000 | 83.0 | 125.000000 | |
level을 0로 지정한 경우 상위 column(type, rating)의 데이터들이 각각의 index를 기준으로 stack된 것을 확인 할 수 있다.
In [18]:
group.stack(level=0).head()
Out[18]:
| mean | min | |||
|---|---|---|---|---|
| type | rating | |||
| Movie | 66 min | release_year | 2015.000000 | 2015.0 |
| 74 min | release_year | 2017.000000 | 2017.0 | |
| 84 min | release_year | 2010.000000 | 2010.0 | |
| G | duration | 90.268293 | 9.0 | |
| release_year | 1997.804878 | 1956.0 |
level을 1로 지정한 경우 하위 column의 데이터(mean, min)들이 각각의 index를 기준으로 stack된 것을 확인 할 수 있다.
In [19]:
group.stack(level=1).head()
Out[19]:
| release_year | duration | |||
|---|---|---|---|---|
| type | rating | |||
| Movie | 66 min | min | 2015.0 | NaN |
| mean | 2015.0 | NaN | ||
| 74 min | min | 2017.0 | NaN | |
| mean | 2017.0 | NaN | ||
| 84 min | min | 2010.0 | NaN |
level을 지정하지 않을 경우 level을 -1로 지정했을 때와 동일한 결과를 반환한다.
In [20]:
stacked = group.stack()
stacked.head()
Out[20]:
| release_year | duration | |||
|---|---|---|---|---|
| type | rating | |||
| Movie | 66 min | min | 2015.0 | NaN |
| mean | 2015.0 | NaN | ||
| 74 min | min | 2017.0 | NaN | |
| mean | 2017.0 | NaN | ||
| 84 min | min | 2010.0 | NaN |
df['col']을 stack하는 경우 해당 column의 데이터에 대해서만 각각의 index를 기준으로 stacking 한다.
In [21]:
group['release_year'].stack().head()
Out[21]:
type rating
Movie 66 min min 2015.0
mean 2015.0
74 min min 2017.0
mean 2017.0
84 min min 2010.0
dtype: float64
unstack()¶
- unstack() 함수를 이용하여 멀티 인덱스를 stacking 하기
level을 0으로 지정한 경우 index의 type이 column 방향으로 stack된 것을 확인 할 수 있다.
In [22]:
stacked.unstack(0).head()
Out[22]:
| release_year | duration | ||||
|---|---|---|---|---|---|
| type | Movie | TV Show | Movie | TV Show | |
| rating | |||||
| 66 min | min | 2015.0 | NaN | NaN | NaN |
| mean | 2015.0 | NaN | NaN | NaN | |
| 74 min | min | 2017.0 | NaN | NaN | NaN |
| mean | 2017.0 | NaN | NaN | NaN | |
| 84 min | min | 2010.0 | NaN | NaN | NaN |
level을 1로 지정한 경우 index의 rating이 column 방향으로 stack된 것을 확인 할 수 있다.
In [23]:
stacked.unstack(1).head()
Out[23]:
| release_year | ... | duration | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| rating | 66 min | 74 min | 84 min | G | NC-17 | NR | PG | PG-13 | R | TV-14 | ... | PG-13 | R | TV-14 | TV-G | TV-MA | TV-PG | TV-Y | TV-Y7 | TV-Y7-FV | UR | |
| type | ||||||||||||||||||||||
| Movie | min | 2015.0 | 2017.0 | 2010.0 | 1956.000000 | 2013.0 | 1958.000000 | 1973.000000 | 1955.000000 | 1962.000000 | 1942.000000 | ... | 8.000000 | 62.000000 | 5.000000 | 10.000000 | 12.000000 | 12.000000 | 3.000000 | 14.000000 | 43.0 | 103.000000 |
| mean | 2015.0 | 2017.0 | 2010.0 | 1997.804878 | 2015.0 | 2010.866667 | 2008.428571 | 2009.314286 | 2010.459222 | 2012.606167 | ... | 108.330612 | 106.720201 | 110.290820 | 79.666667 | 95.889913 | 94.851852 | 48.114504 | 66.287770 | 68.4 | 106.333333 | |
| TV Show | min | NaN | NaN | NaN | NaN | NaN | 2004.000000 | NaN | NaN | 2015.000000 | 1925.000000 | ... | NaN | 1.000000 | 1.000000 | 1.000000 | 1.000000 | 1.000000 | 1.000000 | 1.000000 | 2.0 | NaN |
| mean | NaN | NaN | NaN | NaN | NaN | 2011.600000 | NaN | NaN | 2015.500000 | 2015.698499 | ... | NaN | 1.000000 | 1.821282 | 1.851064 | 1.685590 | 1.668731 | 1.852273 | 2.020513 | 2.0 | NaN | |
4 rows × 34 columns
level을 지정하지 않을 경우 level을 -1로 지정했을 때와 동일한 결과를 반환한다.
In [24]:
stacked.unstack().head()
Out[24]:
| release_year | duration | ||||
|---|---|---|---|---|---|
| min | mean | min | mean | ||
| type | rating | ||||
| Movie | 66 min | 2015.0 | 2015.000000 | NaN | NaN |
| 74 min | 2017.0 | 2017.000000 | NaN | NaN | |
| 84 min | 2010.0 | 2010.000000 | NaN | NaN | |
| G | 1956.0 | 1997.804878 | 9.0 | 90.268293 | |
| NC-17 | 2013.0 | 2015.000000 | 83.0 | 125.000000 | |
df['col']을 unstack하는 경우 해당 column의 데이터에 대해서만 컬럼 방향으로 stacking 한다.
In [25]:
stacked['duration'].unstack().head()
Out[25]:
| min | mean | ||
|---|---|---|---|
| type | rating | ||
| Movie | 66 min | NaN | NaN |
| 74 min | NaN | NaN | |
| 84 min | NaN | NaN | |
| G | 9.0 | 90.268293 | |
| NC-17 | 83.0 | 125.000000 |
pd.melt()¶
- pd.melt() 함수를 이용하여 id 변수를 기준으로 stacking하기
In [26]:
melted = netflix_titles.groupby(['type','rating'])[['release_year','duration']].mean().reset_index()
melted.head()
Out[26]:
| type | rating | release_year | duration | |
|---|---|---|---|---|
| 0 | Movie | 66 min | 2015.000000 | NaN |
| 1 | Movie | 74 min | 2017.000000 | NaN |
| 2 | Movie | 84 min | 2010.000000 | NaN |
| 3 | Movie | G | 1997.804878 | 90.268293 |
| 4 | Movie | NC-17 | 2015.000000 | 125.000000 |
id_vars에 해당되지 않은 column은 variable 값으로 들어가고, value 컬럼에 id 변수와 variable에 해당하는 값이 들어간다.
In [27]:
pd.melt(melted, id_vars=['type','rating']).head()
Out[27]:
| type | rating | variable | value | |
|---|---|---|---|---|
| 0 | Movie | 66 min | release_year | 2015.000000 |
| 1 | Movie | 74 min | release_year | 2017.000000 |
| 2 | Movie | 84 min | release_year | 2010.000000 |
| 3 | Movie | G | release_year | 1997.804878 |
| 4 | Movie | NC-17 | release_year | 2015.000000 |