이것이 데이터 분석이다 with 파이썬 ch1-1(chipotle 주문 데이터 분석하기)

 

 

 

 

ch01. 데이터에서 인사이트 발견하기¶

 

1.1 탐색적 데이터 분석의 과정¶

탐색적 데이터 분석은 데이터의 정보를 파악하며 문제 해결에 필요한 힌트를 분석하는 과정이다.

 

- 데이터와의 첫 만남¶

우리가 실제로 접하는 대부분의 데이터는 아직 분석에 활용된 적 없는 혹은 정제되지 않은 데이터이다. 이러한 데이터를 raw data라고 부른다. 탐색적 데이터 분석은 데이터를 열어보는 상황에서부터 시작되며 이때 부터 다음과 같은 과정을 수행한다.

1. 데이터의 출처와 주제에 대해 이해한다.¶

우선 데이터가 어디에서 생성된 것이고, 어떻게 수집된 것인지를 이해하는 것이 먼저이다. 데이터의 이름, 구성 요소, 그리고 데이터의 출처와 주제 등에 대해 가장 먼저 조사한다.

2. 데이터의 크기를 알아본다.¶

데이터의 대략적인 양이나 개수를 알아보는 단계이다. 데이터의 크기에 따라서 특별한 종류의 샘플링이 필요하기도 하고, 어떤 방식으로 데이터를 처리할지도 달라질 수 있기 때문이다.

• 샘플링(sampling) : 샘플링이란 어떤 자료로부터 일부의 값을 추출하는 행위를 말한다. 분석하고자 하는 데이터가 너무 크거나 전체 데이터를 사용할 수 없는 경우에는 샘플링된 데이터를 분석하는 것이 좋은 대안이 될 수 있다.

3. 데이터의 구성 요소(피처)를 살펴본다.¶

마지막으로 데이터의 피처를 살펴본다. 피처란 데이터를 구성하는 요소를 말한다. 만약 어떤 학급의 신체검사 결과를 기록한 데이터가 있다고 할 때, 키와 몸무게 그리고 시력같은 측정 요소를 피처라고 부른다. 데이터를 탐색하는 단계에서 피처를 살펴보는 것은 아주 중요한 과정이다.

 

- 데이터의 속성 탐색하기¶

데이터를 탐색하는 단계에서 데이터의 외형적인 힌트를 얻었다면 이번 단계에서는 데이터의 실제적인 내용을 탐색한다. 실제적인 내용 탐색의 과정에서는 크게 피처의 속성 탐색, 그리고 피처 간의 상관 관계 탐색 이렇게 두 가지를 시행한다.

- 피처의 속성 탐색¶

데이터에서는 어떤 속성을 탐색할 수 있을까? 우선 가장 쉽게 떠올릴 수 있는 것은 평균값을 계산하는 것이다. 평균을 구하는 것뿐만 아니라, 표준편차, 중앙값, 데이터의 사분위 수 등의 통계값을 구할 수도 있다. 피처이 속성 탐색 과정에서 가장 중요한 것은 데이터에 질문을 던지는 것이다.

- 피처 간의 상관 관계 탐색¶

피처 간의 상관 관계 탐색이란 여러 개의 피처가 서로에게 미치는 영향력을 알아보는 것이다. 만약 학급의 신체검사 데이터를 살펴본 뒤, '우리 학급은 비만이 아닐까?' 라는 질문을 했다고 가정해보자. 그렇다면 우리는 '몸무게'라는 피처를 살펴볼 것이다. 그리고 이를 통해 가정을 확인할 것이다. 하지만 우리가 한 가지 더 고려해야 할 점은 몸무게는 키와도 관계가 있다는 것이다. 이런 상황에서 필요한 것이 피처 간의 상관 관계 탐색이다. 데이터 분석에서는 이를 통계적인 방법으로 알아볼 수 있으며, 이는 피처 간의 공분산, 혹은 상관 계수와 같은 개념을 포함한다.

- 탐색한 데이터의 시각화¶

마지막 단계는 탐색한 데이터의 시각화 단계이다. 지금까지의 과정을 통해 어느 정도 데이터를 파악했다면 이를 효과적으로 시각화할 차례이다. 데이터의 시각화는 수치적 자료만 가지고는 파악하기 힘든 패턴이나 인사이트를 발견하는 데 유용하다. 단순 데이터 탐색으로는 상관 관계를 쉽게 발견하기 어렵지만 이를 그래프로 시각화하면 직관적으로 파악할 수 있다.

 

1.2 멕시코풍 프랜차이즈 chiptle의 주문 데이터 분석하기¶

데이터 출처 : https://github.com/yoonkt200/python-data-analysis

우리가 첫 번째로 분석해볼 데이터는 멕시코풍 프랜차이즈 'chipotle'라는 음석점의 주문 데이터이다.

step.1 탐색: 데이터의 기초 정보 살펴보기¶

• chipotle 데이터셋의 기초 정보 출력하기

아래와 같이 코드를 입력하여 코드 셀을 생성한다. 이 코드는 데이터를 불러온 뒤, 불러온 데이터의 구성 정보를 출력하는 코드이다. 데이터를 불러오기 위해선 read_csv() 함수를 사용해야 하는데 여기에 데이터 파일의 경로를 입력한다. 데이터 파일의 경로를 의미하는 변수는 file_path이다.

In [2]:

import pandas as pd

file_path = '/home/jaeyoon89/python-data-analysis/data/chipotle.tsv'
# read_csv() 함수로 데이터를 데이터 프레임 형태로 불러온다.
chipo = pd.read_csv(file_path, sep='\t')

print(chipo.shape)
print("-----------------------------------")
print(chipo.info())

 

(4622, 5)
-----------------------------------
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4622 entries, 0 to 4621
Data columns (total 5 columns):
 #   Column              Non-Null Count  Dtype 
---  ------              --------------  ----- 
 0   order_id            4622 non-null   int64 
 1   quantity            4622 non-null   int64 
 2   item_name           4622 non-null   object
 3   choice_description  3376 non-null   object
 4   item_price          4622 non-null   object
dtypes: int64(2), object(3)
memory usage: 180.7+ KB
None

 

그리고 shape()와 info() 함수를 호출하면 위와 같은 실행 결과를 볼 수 있다. shape는 데이터의 행과 열의 크기를 반환하고, info()는 행의 구성정보와 열의 구성 정보를 나타낸다. 실행결과를 보면 데이터가 4,622개의 행과 5개의 피처로 구성되어 있음을 알 수 있다. 또한 order_id와 quantity는 int64(숫자), 나머지 3개는 object라는 타입으로 이루어져 있다. 그런데 한 가지 특이한 정보는 choice_description 피처가 3,376개의 non_null object로 구성되어 있다. 이 정보는 무엇일까? 데이터 프레임에서 object 타입은 일반적으로 문자열을 의미한다. 그리고 null이라는 용어는 데이터가 비어 있는 것을 의미한다. 이를 결측값이라고 한다. 즉, '3376 non-null object'라는 것은 3,376개의 비어 있지 않은 문자열 데이터가 있다는 정보이다. 하지만 데이터의 개수는 4,622개이므로 choice_description 피처는 1,246개의 결측값이 존재한다. 다음 코드를 살펴보자. head(10) 함수는 첫 10개의 데이터를 테이블 형태로 출력한다. 또한 columns와 index를 호출하면 데이터의 행과 열에 대한 정보를 함께 출력할 수 있다.

 

• chipotle 데이터셋의 행과 열, 데이터 확인하기

In [3]:

chipo.head(10)

Out[3]:

	order_id	quantity	item_name	choice_description	item_price
0	1	1	Chips and Fresh Tomato Salsa	NaN	$2.39
1	1	1	Izze	[Clementine]	$3.39
2	1	1	Nantucket Nectar	[Apple]	$3.39
3	1	1	Chips and Tomatillo-Green Chili Salsa	NaN	$2.39
4	2	2	Chicken Bowl	[Tomatillo-Red Chili Salsa (Hot), [Black Beans...	$16.98
5	3	1	Chicken Bowl	[Fresh Tomato Salsa (Mild), [Rice, Cheese, Sou...	$10.98
6	3	1	Side of Chips	NaN	$1.69
7	4	1	Steak Burrito	[Tomatillo Red Chili Salsa, [Fajita Vegetables...	$11.75
8	4	1	Steak Soft Tacos	[Tomatillo Green Chili Salsa, [Pinto Beans, Ch...	$9.25
9	5	1	Steak Burrito	[Fresh Tomato Salsa, [Rice, Black Beans, Pinto...	$9.25

In [4]:

print(chipo.columns)
print("------------------------------------")
print(chipo.index)

 

Index(['order_id', 'quantity', 'item_name', 'choice_description',
       'item_price'],
      dtype='object')
------------------------------------
RangeIndex(start=0, stop=4622, step=1)

 

이떄, chipotle 데이터셋 피처의 의미는 각각 다음과 같다.

• order_id : 주문번호
• quantity : 아이템의 주문 수량
• item_name : 주문한 아이템의 이름
• choice_description : 주문한 아이템의 상세 선택 옵션
• item_prince : 주문 아이템의 가격 정보

 

- quantity와 item_price의 수치적 특징¶

우선 quantity와 item_price의 수치적 특징을 살펴보자. 이 두 피처는 연속형 피처이다. 연속형 피처는 키와 몸무게처럼 어떠한 값도 가질 수 있는 연속적인 숫자 형태를 의미한다.

다음 코드의 출력 결과는 describe() 함수가 나타낸 피처의 기초 통계량이다. 하지만 현재 유일하게 존재하는 수치형 피처는 quantity뿐이기 때문에, 오직 quantity에 대한 정보만을 출력할 수 있다.

 

• describe() 함수로 기초 통게량 출력하기

In [5]:

# order_id는 숫자의 의미를 가지지 않기 때문에 str으로 변환한다.
chipo['order_id'] = chipo['order_id'].astype(str)
print(chipo.describe())

 

          quantity
count  4622.000000
mean      1.075725
std       0.410186
min       1.000000
25%       1.000000
50%       1.000000
75%       1.000000
max      15.000000

 

출력 내용을 분석해보면 아이템의 평균 주문 수량(mean)은 약 1.07이라는 것을 알 수 있다. 이는 대부분 한 아이템에 대해서 1개 정도만 주문했다는 것이고, '한 사람이 같은 메뉴를 여러개 구매하는 경우는 많지 않다' 는 인사이트를 얻을 수 있다. 그렇다면 item_price의 수치적 특징은 어떻게 알아볼 수 있을까? 현재 item_price 피처는 object 타입이기 때문에 describe() 함수로 기초 통계량을 확인할 수 없다. 이를 위해서는 추가적인 데이터 전처리 작업이 필요한데, 이는 step3 에서 배워보자.

 

- order_id와 item_name 개수¶

다음으로 order_id와 item_name의 개수를 탐색한다. 이 두 피처는 범주형 피처이기 때문에 unique() 함수를 사용한다. 이를 통해 피처 내에 몇 개의 범주가 있는지를 확인할 수 있다.

 

• unique() 함수로 범주형 피처의 개수 출력하기

In [6]:

print(len(chipo['order_id'].unique()))
print(len(chipo['item_name'].unique()))

 

1834
50

 

step.2 인사이트의 발견: 탐색과 시각화하기¶

- 가장 많이 주문한 아이템 Top10¶

먼저, 가장 많이 주문한 아이템 Top10을 분석하기 위해 다음과 같이 DataFrame['columns']의 형태에 value_counts() 함수를 적용하는 방식을 사용하자. DataFrame['columns']은 시리즈라는 객체를 반환하는데, value_counts() 함수는 이러한 시리즈 객체에만 적용되기 때문이다.

 

• 가장 많이 주문한 아이템 Top10 출력하기

In [7]:

item_count = chipo['item_name'].value_counts()[:10]
for idx, (val,cnt) in enumerate(item_count.iteritems(), 1):
    print("Top", idx, ":", val, cnt)

 

Top 1 : Chicken Bowl 726
Top 2 : Chicken Burrito 553
Top 3 : Chips and Guacamole 479
Top 4 : Steak Burrito 368
Top 5 : Canned Soft Drink 301
Top 6 : Chips 211
Top 7 : Steak Bowl 211
Top 8 : Bottled Water 162
Top 9 : Chicken Soft Tacos 115
Top 10 : Chicken Salad Bowl 110

 

- 아이템별 주문 개수와 총량¶

이번에는 groupby() 함수를 이용하여 아이템별 주문 개수와 총량을 구해보자. 판다스의 groupby() 함수는 데이터 프레임에서 특정 피처를 기준으로 그룹을 생성하며 이를 통해 그룹별 연산을 적용할 수 있다.

 

• 아이템별 주문 개수와 총량 구하기

In [8]:

# 아이템별 주문 개수를 출력한다.
order_count = chipo.groupby('item_name')['quantity'].count()
order_count[:10]

Out[8]:

item_name
6 Pack Soft Drink         54
Barbacoa Bowl             66
Barbacoa Burrito          91
Barbacoa Crispy Tacos     11
Barbacoa Salad Bowl       10
Barbacoa Soft Tacos       25
Bottled Water            162
Bowl                       2
Burrito                    6
Canned Soda              104
Name: quantity, dtype: int64

In [9]:

# 아이템별 주문 총량을 계산한다.
item_quantity = chipo.groupby('item_name')['quantity'].sum()
item_quantity[:10]

Out[9]:

item_name
6 Pack Soft Drink         55
Barbacoa Bowl             66
Barbacoa Burrito          91
Barbacoa Crispy Tacos     12
Barbacoa Salad Bowl       10
Barbacoa Soft Tacos       25
Bottled Water            211
Bowl                       4
Burrito                    6
Canned Soda              126
Name: quantity, dtype: int64

 

위의 코드 chipo.groupby('item_name')['quantity'].count() 는 chipo Dataframe 에서 item_name을 그룹으로 quantity 피처의 count()를 계산한 것이다. 이는 아이템별 주문 개수를 의미한다. 마찬가지 방법으로 chipo.groupby('item_name')['quantity'].sum() 은 아이템별 주문 총량을 나타낸다.

 

- 시각화¶

아이템별 주문의 총량을 막대 그래프로 시각화해볼 수도 있다. 코드에서는 tolist()와 넘파이의 arange() 함수를 이용해 x_pos를 선언하고 0부터 50까지의 숫자를 그래프의 x축 이름으로 사용한다. 그 이유는 50개의 아이템의 이름을 x축에 표현하기에는 그래프의 공간이 너무 협소하기 때문이다. y값(order_cnt)에는 추문 총량에 해당하는 값인 item_quantity.values.tolist()를 넣어준다.

In [10]:

%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt

item_name_list = item_quantity.index.tolist()
x_pos = np.arange(len(item_name_list))
order_cnt = item_quantity.values.tolist()

plt.bar(x_pos, order_cnt, align='center')
plt.ylabel('ordered_item_count')
plt.title('Distribution of all ordered item')

plt.show()

 

 

step.3 데이터 전처리: 전처리 함수 사용하기¶

앞선 내용의 item_price의 수치적 특징을 탐색하는 과정에서 우리는 item_price 피처의 요약 통계를 구할 수 없었다. 이는 item_price 피처가 문자열 타입이었기 때문이다. 이번 단계에서는 이러한 데이터를 전처리하는 방법에 대해 알아보자.

 

• item_price 피처 살펴보기

In [11]:

print(chipo.info())
print("------------------------------")
chipo['item_price'].head

 

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4622 entries, 0 to 4621
Data columns (total 5 columns):
 #   Column              Non-Null Count  Dtype 
---  ------              --------------  ----- 
 0   order_id            4622 non-null   object
 1   quantity            4622 non-null   int64 
 2   item_name           4622 non-null   object
 3   choice_description  3376 non-null   object
 4   item_price          4622 non-null   object
dtypes: int64(1), object(4)
memory usage: 180.7+ KB
None
------------------------------

Out[11]:

<bound method NDFrame.head of 0        $2.39 
1        $3.39 
2        $3.39 
3        $2.39 
4       $16.98 
         ...   
4617    $11.75 
4618    $11.75 
4619    $11.25 
4620     $8.75 
4621     $8.75 
Name: item_price, Length: 4622, dtype: object>

 

데이터 전처리에 앞서 item_price 피처를 살펴본 결과, 가격을 나타내는 숫자 앞에 $ 기호가 붙어있다는 것을 발견할 수 있다. 따라서 이 피처를 수치 데이터로 사용하기 위해서는 $ 기호를 제거해주는 전처리 작업이 필요하다. $ 기호를 제거하는 전처리 방법은 chipo['item_price']에 apply() 함수를 적용함으로써 가능하다. 그리고 apply() 함수에는 lambda라는 함수 명령어를 추가해준다.

 

• apply()와 lambda를 이용해 데이터 전처리하기

In [12]:

# column 단위 데이터에 apply() 함수로 전처리를 적용한다.
chipo['item_price'] = chipo['item_price'].apply(lambda x : float(x[1:]))
chipo.describe()

Out[12]:

	quantity	item_price
count	4622.000000	4622.000000
mean	1.075725	7.464336
std	0.410186	4.245557
min	1.000000	1.090000
25%	1.000000	3.390000
50%	1.000000	8.750000
75%	1.000000	9.250000
max	15.000000	44.250000

 

apply() 함수는 시리즈 단위의 연산을 처리하는 기능을 수행하며, sum()이나 mean()과 같이 연산이 정의된 함수를 파라미터로 받는다. 따라서 피처 단위의 합계나 평균을 구할 수도 있고, 우리가 정의할 새로운 함수 문자열 데이터에서 첫 번째 문자열을 제거한 뒤 나머지 문자열을 수치형으로 바꿔주는 함수를 파라미터로 입력할 수도 있다. 위의 코드 lambda x : float(x[1:]) 는 이를 수행하는 함수를 lambda로 정의하여 입력한 것이다.

 

step.4 탐색적 분석: 스무고개로 개념적 탐색 분석하기¶

이번 단계에서는 조금 더 깊이있는 질문을 통해 데이터를 탐색한다. 이 과정은 마치 데이터와 '스무고개' 놀이를 하는 과정에 비유할 수 있다. 이 단계를 거치면 여러분은 파이썬을 활용한 탐색적 데이터 분석에 익숙해질 것이다.

 

- 주문당 평균 계산금액 출력하기¶

다음 코드는 order_id로 그룹을 생성한 뒤, item_price 피처에 sum() 함수를 적용하고 mean() 함수를 추가한 것이다. 이를 통해 주문당 평균 계산금액을 구할 수 있다. 아래 결과와 같이 한 사람이 약 18달러 가량의 주문을 할 것 이라는 인사이트를 얻을 수 있다.

In [13]:

# 주문당 평균 계산금액 출력하기
chipo.groupby('order_id')['item_price'].sum().mean()

Out[13]:

18.811428571428568

 

- 한 주문에 10달러 이상 지불한 주문 번호(id) 출력하기¶

다음으로 한 주문에 10달러 이상을 지불한 주문을 찾아본다. 우선 order_id 피처(하나의 주문)를 기준으로 그룹을 만들어 quantity, item_price 피처의 합계를 계산한다. 그리고 이 결과에서 10 이상인 값을 필터링한다. 이에 대한 최종 결과인 results의 index,values를 출력하면 한 주문에 10달러 이상 지불한 id를 출력할 수 있다.

In [14]:

chipo_orderid_group = chipo.groupby('order_id').sum()
results = chipo_orderid_group[chipo_orderid_group.item_price >= 10]
print(results[:10])
print(results.index.values)

 

          quantity  item_price
order_id                      
1                4       11.56
10               2       13.20
100              2       10.08
1000             2       20.50
1001             2       10.08
1002             2       10.68
1003             2       13.00
1004             2       21.96
1005             3       12.15
1006             8       71.40
['1' '10' '100' ... '997' '998' '999']

 

- 각 아이템의 가격 구하기¶

이번에는 각 아이템의 가격을 계산한다. chipotle 데이터셋에서는 주어진 데이터만으로 각 아이템의 가격을 대략적으로 유추해야한다.

• 1. chipo[chipo.quantity == 1] 으로 동일한 아이템을 1개만 구매한 주문을 선별한다.
• 1. itme_name을 기준으로 groupby연산을 수행한 뒤, min() 함수로 각 그룹별 최저가를 계산한다.
• 1. item_price를 기준으로 정렬하는 sort_values() 함수를 적용한다. sort_values()는 series 데이터를 정렬해 주는 함수이다.

 

• 각 아이템의 가격 구하기

In [15]:

# 각 아이템의 가격을 계산합니다.
chipo_one_item = chipo[chipo.quantity == 1]
price_per_item = chipo_one_item.groupby('item_name').min()
price_per_item.sort_values(by = "item_price", ascending = False)[:10]

Out[15]:

	order_id	quantity	choice_description	item_price
item_name
Steak Salad Bowl	1032	1	[Fresh Tomato Salsa, Lettuce]	9.39
Barbacoa Salad Bowl	1283	1	[Fresh Tomato Salsa, Guacamole]	9.39
Carnitas Salad Bowl	1035	1	[Fresh Tomato Salsa, [Rice, Black Beans, Chees...	9.39
Carnitas Soft Tacos	1011	1	[Fresh Tomato Salsa (Mild), [Black Beans, Rice...	8.99
Carnitas Crispy Tacos	1774	1	[Fresh Tomato Salsa, [Fajita Vegetables, Rice,...	8.99
Steak Soft Tacos	1054	1	[Fresh Tomato Salsa (Mild), [Cheese, Sour Cream]]	8.99
Carnitas Salad	1500	1	[[Fresh Tomato Salsa (Mild), Roasted Chili Cor...	8.99
Carnitas Bowl	1007	1	[Fresh Tomato (Mild), [Guacamole, Lettuce, Ric...	8.99
Barbacoa Soft Tacos	1103	1	[Fresh Tomato Salsa, [Black Beans, Cheese, Let...	8.99
Barbacoa Crispy Tacos	110	1	[Fresh Tomato Salsa, Guacamole]	8.99

 

그리고 각 아이템의 대략적인 가격을 아래와 같이 2개의 그래프로 시각화 하여 나타낼 수 있다.

In [16]:

# 아이템 가격 분포 그래프를 출력합니다.
item_name_list = price_per_item.index.tolist()
x_pos = np.arange(len(item_name_list))
item_price = price_per_item['item_price'].tolist()
 
plt.bar(x_pos, item_price, align='center')
plt.ylabel('item price($)')
plt.title('Distribution of item price')
 
plt.show()

 

In [17]:

# 아이템 가격 히스토그램을 출력합니다.
plt.hist(item_price)
plt.ylabel('counts')
plt.title('Histogram of item price')

plt.show()

 

 

- 가장 비싼 주문에서 아이템이 총 몇 개 팔렸는지 구하기¶

여기서도 마찬가지로 order_id에 그룹별 합계 연산을 적용한다. 그리고 item_price를 기준으로 sort_values를 반환하면 가장 비싼 주문순으로 연산 결과를 얻을 수 있다.

In [18]:

# 가장 비싼 주문에서 item이 총 몇개 팔렸는지를 계산합니다.
chipo.groupby('order_id').sum().sort_values(by='item_price', ascending=False)[:5]

Out[18]:

	quantity	item_price
order_id
926	23	205.25
1443	35	160.74
1483	14	139.00
691	11	118.25
1786	20	114.30

 

- 'Veggie Salad Bowl'이 몇 번 주문되었는지 구하기¶

이번엔 특정 아이템인 'Veggie Salad Bowl'이 몇 번이나 주문되었는지 알아보자. chipo[chipo['item_name'] == "Veggie Salad Bow"] 으로 필터링한 뒤, drop_duplicates()라는 함수를 사용한다. 이는 한 주문 내에서 itme_name이 중복 집계된 경우를 제거하기 위함이다.

In [19]:

# “Veggie Salad Bowl”이 몇 번 주문되었는지를 계산합니다.
chipo_salad = chipo[chipo['item_name'] == "Veggie Salad Bowl"]
chipo_salad = chipo_salad.drop_duplicates(['item_name', 'order_id']) # 한 주문 내에서 중복 집계된 item_name을 제거합니다.

print(len(chipo_salad))
chipo_salad.head(5)

 

18

Out[19]:

	order_id	quantity	item_name	choice_description	item_price
186	83	1	Veggie Salad Bowl	[Fresh Tomato Salsa, [Fajita Vegetables, Rice,...	11.25
295	128	1	Veggie Salad Bowl	[Fresh Tomato Salsa, [Fajita Vegetables, Lettu...	11.25
455	195	1	Veggie Salad Bowl	[Fresh Tomato Salsa, [Fajita Vegetables, Rice,...	11.25
496	207	1	Veggie Salad Bowl	[Fresh Tomato Salsa, [Rice, Lettuce, Guacamole...	11.25
960	394	1	Veggie Salad Bowl	[Fresh Tomato Salsa, [Fajita Vegetables, Lettu...	8.75

 

- 'Chicken Bowl'을 2개 이상 주문한 주문 횟수 구하기¶

비슷한 방법으로 chicken Bowl을 2개 이상 주문한 횟수를 구해보자. 먼저 chicken bowl을 주문한 데이터만을 필터링한 뒤, 데이터프레임에서 quantity가 2 이상인 것을 선택하면 결과가 chicken Bowl을 2개 이상 주문한 주문 횟수를 의미한다.

In [20]:

# “Chicken Bowl”을 2개 이상 주문한 주문 횟수를 구합니다.
chipo_chicken = chipo[chipo['item_name'] == "Chicken Bowl"]
chipo_chicken_result = chipo_chicken[chipo_chicken['quantity'] >= 2]
print(chipo_chicken_result.shape[0])

 

33

In [21]:

# “Chicken Bowl”을 2개 이상 주문한 고객들의 "Chicken Bowl" 메뉴의 총 주문 수량을 구합니다.
chipo_chicken = chipo[chipo['item_name'] == "Chicken Bowl"]
chipo_chicken_ordersum = chipo_chicken.groupby('order_id').sum()['quantity']
chipo_chicken_result = chipo_chicken_ordersum[chipo_chicken_ordersum >= 2]

print(len(chipo_chicken_result))
chipo_chicken_result.head(5)

 

114

Out[21]:

order_id
1004    2
1023    2
1072    2
1078    2
1091    2
Name: quantity, dtype: int64

 

출처 : 이것이 데이터 분석이다.