뽐뿌 특가 데이터 분석 하기

import pandas as pd
import numpy as np
import re
import matplotlib.pyplot as plt
import seaborn as sns
import pingouin as pg
import ast
from PIL import Image

from scipy.stats import shapiro, levene, mannwhitneyu, chi2_contingency, ttest_ind
from datetime import datetime
from tqdm import tqdm
from collections import Counter
from wordcloud import WordCloud
from kiwipiepy import Kiwi

# custom function
from utils import autolabel, remove_outliers, top_text

# 파라미터
sns.set(style="ticks")
plt.rcParams['font.family'] = 'NanumGothic'
custom_palette = ["skyblue", "lightgreen"]
%matplotlib inline
%config InlineBackend.figure_format='retina'
title_font_size = 14
sub_font_size = 12

# 전처리한 데이터 불러오기
data = pd.read_csv("./datas/2023-08-08 23:47:16.905195_preprocessing.csv")

data_info = data.info()

# 일반 게시물과 인기 게시물의 비율
plt.figure(figsize=(8,4))
ax = sns.countplot(data=data, x="post_type", palette=custom_palette)

# 전체 게시물 수 계산
total = len(data)

# 각 바 위에 비율 표시
for p in ax.patches:
    percentage = '{:.1f}%'.format(100 * p.get_height() / total)
    x = p.get_x() + p.get_width() / 2
    y = p.get_y() + p.get_height() * 1.02
    ax.annotate((f"{int(p.get_height())}개 ({percentage})"), (x, y), ha='center', va='center', size=sub_font_size)

ax.set_xlabel('')
ax.set_ylabel('')
ax.set_xticklabels(["일반", "인기"])

plt.title("유형 별 게시물 비율", size=title_font_size, fontweight='bold')
sns.despine()
plt.show()

# 실제로 일반 게시물과 인기 게시물이 조회수(view), 추천수(recommend), 댓글수(comment)의 평균 차이가 있는지 T-test 통계 검증을 진행한다.
# 단, 데이터 수가 약 12만개이므로 정규성, 독립성, 등분산성 확인은 생략한다.

general_data = data[data['post_type'] == 'general']
popular_hot_data = data[data['post_type'] == 'popular/hot']
metrics = ['view', 'recommend', 'comment']
for metric in metrics:
    _, p_value = ttest_ind(general_data[metric], popular_hot_data[metric])

    # 유의수준에 따라 결과 해석
    alpha = 0.05  # 유의수준 (보통 0.05)
    if p_value < alpha:
        print(f"p-value {p_value}가 유의수준 {alpha}보다 작으므로 일반 / 인기 게시물간의 {metric}의 평균 차이는 통계적으로 유의미합니다.")
    else:
        print(f"p-value가 유의수준보다 크므로 일반 / 인기 게시물간의 {metric} 통계적으로 유의미하지 않습니다.")

avg_metrics = data.groupby('post_type')[['view', 'recommend', 'comment']].mean()

fig, axes = plt.subplots(nrows=3, ncols=1, figsize=(8, 12))
metrics = ['view', 'recommend', 'comment']
titles = ['평균 조회수', '평균 추천수', '평균 댓글수']

# 그래프
for ax, metric, title in zip(axes, metrics, titles):
    avg_metrics[metric].plot(kind='bar', ax=ax, rot=0, color=custom_palette)
    ax.set_title(title, size=title_font_size, fontweight='bold')
    ax.set_xlabel("")
    ax.set_xticklabels(["일반", "인기"])

    # 숫자 추가
    for bar in ax.patches:
        yval = bar.get_height()
        ax.text(bar.get_x() + bar.get_width()/2, yval, round(yval,2), ha='center', va='bottom', fontsize=sub_font_size)
        
sns.despine()
plt.tight_layout()
plt.show()

# 데이터 프레임에서 게시물 종류 별 카테고리 갯수
category_counts = data.groupby(['post_type', 'category']).size().unstack(level=0).reset_index()
category_counts["total"] = category_counts["general"] + category_counts["popular/hot"]
category_counts["general_ratio"] = round(category_counts["general"] / category_counts["total"] * 100, 2)
category_counts["popular/hot_ratio"] = round(category_counts["popular/hot"] / category_counts["total"] * 100, 2)
category_counts["category"] = category_counts["category"].str.strip("[]")
category_counts = category_counts.sort_values(by="general_ratio", ascending=True)
category_counts

# 순서 정렬
category_counts = category_counts.sort_values(by="general_ratio", ascending=False)

# 그래프 그리기
plt.figure(figsize=(12,4))
bar_general = plt.barh(category_counts["category"], category_counts["general_ratio"], color="skyblue", label="일반 게시물")
bar_popular_hot = plt.barh(category_counts["category"], category_counts["popular/hot_ratio"], left=category_counts["general_ratio"], color="lightgreen", label="인기 게시물")

# 그래프에 퍼센트 삽입
autolabel(bar_general)
autolabel(bar_popular_hot, previous_bars=[bar_general])

plt.xlabel("")
plt.ylabel("")
plt.legend(bbox_to_anchor=(1.05, 1))
plt.title("카테고리별 일반, 인기 게시물비율", size=title_font_size, fontweight="bold")
sns.despine()
plt.show()

category_counts = category_counts.sort_values(by="general", ascending=True)

plt.figure(figsize=(12,4))
bar_general = plt.barh(category_counts["category"], category_counts["general"], color="skyblue", label="일반 게시물")
bar_popular = plt.barh(category_counts["category"], category_counts["popular/hot"], left=category_counts["general"], color="lightgreen", label="인기 게시물")

# 각 바 위에 수치 추가
for bar in bar_general:
    plt.text(bar.get_width() - 0.02 * bar.get_width(), bar.get_y() + bar.get_height()/2, 
             f'{int(bar.get_width())}', va='center', ha='right', color='black', fontsize=10)

for bar in bar_popular:
    plt.text(bar.get_x() + bar.get_width() + 0.02 * bar.get_width(), bar.get_y() + bar.get_height()/2, 
             f'{int(bar.get_width())}', va='center', ha='left', color='black', fontsize=10)

plt.xlabel("")
plt.ylabel("")
plt.legend(bbox_to_anchor=(1.05, 1))
plt.title("카테고리별 일반, 인기 게시물 갯수", size=title_font_size, fontweight="bold")
sns.despine()
plt.show()

data['keywords'] = data['keywords'].apply(ast.literal_eval)

# 일반, 인기 게시물의 키워드 추출
pop_hot_keywords = [keyword for keywords_list in data[data['post_type'] == 'popular/hot']['keywords'] for keyword in keywords_list]
general_keywords = [keyword for keywords_list in data[data['post_type'] == 'general']['keywords'] for keyword in keywords_list]

# 키워드 언급 횟수
pop_hot_keyword_freq = Counter(pop_hot_keywords)
general_keyword_freq = Counter(general_keywords)

# 상위 20개 키워드 추출
top_pop_hot_keywords = pop_hot_keyword_freq.most_common(20)
top_general_keywords = general_keyword_freq.most_common(20)

# 상위 20개 키워드만 추출
top_20_pop_hot_keywords = set([keyword for keyword, _ in top_pop_hot_keywords])
top_20_general_keywords = set([keyword for keyword, _ in top_general_keywords])

# 상위 20개 키워드 중 공통, 인기, 일반 키워드 추출
unique_pop_hot_keywords_top_20 = top_20_pop_hot_keywords - top_20_general_keywords
unique_general_keywords_top_20 = top_20_general_keywords - top_20_pop_hot_keywords

# 공통, 인기, 일반 키워드의 색상 지정
pop_hot_colors = ['lightgreen' if keyword in unique_pop_hot_keywords_top_20 else 'lightgreen' if keyword in unique_general_keywords_top_20 else 'salmon' for keyword, _ in top_pop_hot_keywords]
general_colors = ['skyblue' if keyword in unique_pop_hot_keywords_top_20 else 'skyblue' if keyword in unique_general_keywords_top_20 else 'salmon' for keyword, _ in top_general_keywords]

# 그래프 생성
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 6))

pop_hot_keywords_plot, pop_hot_frequencies_plot = zip(*top_pop_hot_keywords)
general_keywords_plot, general_frequencies_plot = zip(*top_general_keywords)

# 일반 게시물 그래프
bars1 = ax1.barh(general_keywords_plot, general_frequencies_plot, color=general_colors)
ax1.set_title('일반 게시물')
for bar, freq in zip(bars1, general_frequencies_plot):
    ax1.text(freq - 2, bar.get_y() + bar.get_height()/2, int(freq), 
             va='center', ha='right', color='black')
ax1.invert_yaxis()

# 인기 게시물 그래프
bars2 = ax2.barh(pop_hot_keywords_plot, pop_hot_frequencies_plot, color=pop_hot_colors)
ax2.set_title('인기 게시물')
for bar, freq in zip(bars2, pop_hot_frequencies_plot):
    ax2.text(freq - 2, bar.get_y() + bar.get_height()/2, int(freq), 
             va='center', ha='right', color='black')
ax2.invert_yaxis()

fig.suptitle("게시물 유형 별 상위 20개 키워드", size=title_font_size, fontweight="bold")
plt.tight_layout()
sns.despine()
plt.show()

# 키워드를 단일 list로 변경
all_keywords = [keyword for sublist in data['keywords'] for keyword in sublist]

# 리스트 to 시리즈
keywords_series = pd.Series(all_keywords)

# 마스크 이미지
uploaded_mask_image = Image.open("./images/mask_image.png").convert("L")  # Convert to grayscale
uploaded_mask = np.array(uploaded_mask_image)


# 워드 클라우드 생성
wordcloud_with_uploaded_mask = WordCloud(
    font_path='./font/NanumGothic.ttf',
    colormap="PuBu",
    background_color='white',
    mask=uploaded_mask,
    width=800, height=400,
    contour_width=0.5,
    contour_color='white',
    collocations=False
).generate_from_frequencies(keywords_series.value_counts())

# 워드 클라우드 표시
plt.figure(figsize=(12, 12))
plt.imshow(wordcloud_with_uploaded_mask, interpolation="bilinear")
plt.axis('off')
plt.savefig('./01_wordcloud.png', dpi=200)
plt.show()

# 게시물 유형별 가격 분포 시각화
plt.figure(figsize=(8, 4))
ax = sns.boxplot(x='post_type', y='product_price', data=data, palette=custom_palette, showfliers=False)

# 박스플롯의 중앙값을 숫자로 표시
medians = data.groupby(['post_type'])['product_price'].median().values
medians = [int(round(m, 2)) for m in medians]
median_labels = [str(np.round(s, 2)) for s in medians]

pos = range(len(medians))
for tick, label in zip(pos, ax.get_xticklabels()):
    ax.text(pos[tick], medians[tick] + 5000, f"{median_labels[tick]}원", 
            horizontalalignment='center', size='small', color="black", weight='semibold')

plt.title('게시물 유형별 가격 분포', size=14, fontweight="bold")
sns.despine()
plt.xlabel("")
plt.ylabel('가격')
plt.xticks([0, 1], ['일반', '인기'])
plt.show()

# 실제로 일반 게시물과 인기 게시물이 조회수(view), 추천수(recommend), 댓글수(comment)의 평균 차이가 있는지 T-test 통계 검증을 진행한다.
# 단, 데이터 수가 약 12만개이므로 정규성, 독립성, 등분산성 확인은 생략한다.

general_prices = data[data['post_type'] == 'general']['product_price'].dropna()
popular_hot_prices = data[data['post_type'] == 'popular/hot']['product_price'].dropna()
_, p_value = ttest_ind(general_prices, popular_hot_prices)

# 유의수준에 따라 결과 해석
alpha = 0.05  # 유의수준 (보통 0.05)
if p_value < alpha:
    print(f"p-value ({round(p_value, 1)})가 유의수준 {alpha}보다 작으므로 일반 / 인기 게시물간 가격의 평균 차이는 통계적으로 유의미합니다.")
else:
    print(f"p-value가 유의수준보다 크므로 일반 / 인기 게시물간 가격은 통계적으로 유의미하지 않습니다.")

# 무료 배송과 유료 배송 구분
data['free_shipping'] = data['shipping_cost'] == 0

# 게시물 유형별 무료 배송과 유료 배송의 비율 계산
shipping_distribution = data.groupby('post_type')['free_shipping'].value_counts(normalize=True).unstack().fillna(0)

colors = ['salmon', 'salmon', 'skyblue', 'lightgreen']

# 스택드 바 차트로 시각화
ax = shipping_distribution.plot(kind='bar', stacked=True, figsize=(8, 6), width=0.8)
plt.title('게시물 유형별 무료/유료 배송 비율', size=14, fontweight="bold")
plt.ylabel('비율')
plt.xlabel('게시물 유형')
plt.xticks([0, 1], ['일반', '인기'], rotation=0)
plt.yticks([])

for p, color in zip(ax.patches, colors):
    p.set_facecolor(color)

for p in ax.patches:
    width, height = p.get_width(), p.get_height()
    x, y = p.get_xy() 
    ax.text(x + width/2, 
            y + height/2, 
            '{:.1%}'.format(height), 
            horizontalalignment='center', 
            verticalalignment='center',
            color='black')
sns.despine()
plt.legend(["유료 배송"], loc='upper right', bbox_to_anchor=(0.7, 0.48, 0.4, 0.5))
plt.show()

# 게시물 유형과 배송 유형 간의 교차 테이블 생성
data['shipping_type'] = data['shipping_cost'].apply(lambda x: '무료배송' if x == 0 else '유료배송')
contingency_table = pd.crosstab(data['post_type'], data['shipping_type'])

# 카이제곱 독립성 검정 수행
chi2, p, _, _ = chi2_contingency(contingency_table)

if p > 0.05:
    print("인기 게시물과 일반 게시물의 무료 배송 비율은 차이가 없습니다.")    
else:
    print("인기 게시물의 무료 배송 비율이 일반 게시물보다 많습니다.")

# 표본의 크기가 크므로, 크래머 V를 통해 일반 게시물과 인기 게시물간 연관성 검증
n = contingency_table.sum().sum()
phi2 = chi2 / n
cramers_v = np.sqrt(phi2 / min(contingency_table.shape))

if cramers_v < 0.1:
    print("일반 게시물과 인기 게시물의 연관성은 아주 약합니다.")

elif cramers_v < 0.3:
    print("일반 게시물과 인기 게시물의 연관성은 보통입니다.")
else:
    print("일반 게시물과 인기 게시물의 연관성은 강합니다.")

# Unknown을 제외한 상위 10개 판매 채널을 먼저 추출
top_10_channels_without_unknown = data[data['sales_channel'] != 'unknown'].groupby('sales_channel').size().nlargest(10).index.tolist()

# 판매 채널명 변경: 상위 10개에 포함되지 않거나 'Unknown'인 채널은 'ETC'로 변경
data['sales_channel_aggregated'] = data['sales_channel'].apply(lambda x: x if x in top_10_channels_without_unknown else 'ETC')

# 게시물 종류 별 판매 채널 갯수 계산
channel_counts_aggregated = data.groupby(['post_type', 'sales_channel_aggregated']).size().unstack(level=0).reset_index()
channel_counts_aggregated["total"] = channel_counts_aggregated["general"] + channel_counts_aggregated["popular/hot"]
channel_counts_aggregated["general_ratio"] = round(channel_counts_aggregated["general"] / channel_counts_aggregated["total"] * 100, 2)
channel_counts_aggregated["popular/hot_ratio"] = round(channel_counts_aggregated["popular/hot"] / channel_counts_aggregated["total"] * 100, 2)
idx = channel_counts_aggregated[channel_counts_aggregated['sales_channel_aggregated'] == "ETC"].index
channel_counts_aggregated.drop(idx , inplace=True)
channel_counts = channel_counts_aggregated.sort_values(by="general_ratio", ascending=True)
channel_counts = channel_counts.rename_axis(None, axis=1).reset_index(drop=True)
channel_counts.columns = ["판매 채널", "일반 게시물", "인기 게시물", "총합", "일반 게시물 비율", "인기 게시물 비율"]
channel_counts

channel_counts = channel_counts_aggregated.sort_values(by="general_ratio", ascending=False)

plt.figure(figsize=(14,6))
bar_general = plt.barh(channel_counts["sales_channel_aggregated"], channel_counts["general_ratio"], color="skyblue", label="일반 게시물")
bar_popular_hot = plt.barh(channel_counts["sales_channel_aggregated"], channel_counts["popular/hot_ratio"], left=channel_counts["general_ratio"], color="lightgreen", label="인기 게시물")

autolabel(bar_general)
autolabel(bar_popular_hot, previous_bars=[bar_general])

plt.xlabel("비율")
plt.ylabel("판매채널별")
plt.legend(bbox_to_anchor=(1.0, 1.0))
plt.title("판매채널별 일반과 인기/핫 게시물의 비율", size=14, fontweight="bold")
sns.despine()
plt.show()

channel_counts = channel_counts.sort_values(by="general", ascending=True)

plt.figure(figsize=(14,6))
bar_general = plt.barh(channel_counts["sales_channel_aggregated"], channel_counts["general"], color="skyblue", label="일반 게시물")
bar_popular = plt.barh(channel_counts["sales_channel_aggregated"], channel_counts["popular/hot"], left=channel_counts["general"], color="lightgreen", label="인기 게시물")

# 각 바 위에 수치 추가
for bar in bar_general:
    plt.text(bar.get_width() - 0.02 * bar.get_width(), bar.get_y() + bar.get_height()/2, 
             f'{int(bar.get_width())}', va='center', ha='right', color='black', fontsize=10)

for bar in bar_popular:
    plt.text(bar.get_x() + bar.get_width() + 0.02 * bar.get_width(), bar.get_y() + bar.get_height()/2, 
             f'{int(bar.get_width())}', va='center', ha='left', color='black', fontsize=10)

plt.xlabel("비율")
plt.ylabel("판매 채널")
plt.legend(bbox_to_anchor=(1, 1))
plt.title("채널별 일반, 인기, 핫 게시물의 갯수", size=14, fontweight="bold")
sns.despine()
plt.show()

# 날짜 형식 변환
data['date'] = pd.to_datetime(data['date'], format='%y.%m.%d %H:%M:%S')

# 연도별 분석
data['year'] = data['date'].dt.year
yearly_data = data[(data['year'] != 2018) & (data['year'] != 2023)]
yearly_analysis = yearly_data.groupby(['year', 'post_type']).size().unstack(level=1).fillna(0).reset_index()
yearly_analysis = yearly_analysis.rename_axis(None, axis=1).reset_index(drop=True)
yearly_analysis.columns = ["연도", "일반 게시물", "인기 게시물"]
yearly_analysis["종합"] = yearly_analysis["일반 게시물"] + yearly_analysis["인기 게시물"]
yearly_analysis

# 월별 분석
data['month'] = data['date'].dt.month
monthly_data = data[(data['year'] >= 2019) & (data['year'] <= 2022)]
monthly_analysis = monthly_data.groupby(['month', 'post_type']).size().unstack(level=1).fillna(0).reset_index()
monthly_analysis = monthly_analysis.rename_axis(None, axis=1).reset_index(drop=True)
monthly_analysis.columns = ["월", "일반 게시물", "인기 게시물"]
monthly_analysis["종합"] = monthly_analysis["일반 게시물"] + monthly_analysis["인기 게시물"]
monthly_analysis

# 일별 분석
data['day'] = data['date'].dt.day
day_analysis = data.groupby(['day', 'post_type']).size().unstack(level=1).fillna(0).reset_index()
day_analysis = day_analysis.rename_axis(None, axis=1).reset_index(drop=True)
day_analysis.columns = ["일", "일반 게시물", "인기 게시물"]
day_analysis["종합"] = day_analysis["일반 게시물"] + day_analysis["인기 게시물"]
day_analysis

# 요일별 분석
data['weekday'] = data['date'].dt.day_name()
weekday_order = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
weekday_analysis = data.groupby(['weekday', 'post_type']).size().unstack(level=1).fillna(0).reindex(weekday_order).reset_index()
weekday_analysis = weekday_analysis.rename_axis(None, axis=1).reset_index(drop=True)
weekday_analysis.columns = ["요일", "일반 게시물", "인기 게시물"]
weekday_analysis["종합"] = weekday_analysis["일반 게시물"] + weekday_analysis["인기 게시물"]
weekday_analysis

# 시간 분석
data['hour'] = data['date'].dt.hour
hour_analysis = data.groupby(['hour', 'post_type']).size().unstack(level=1).fillna(0).reset_index()
hour_analysis = hour_analysis.rename_axis(None, axis=1).reset_index(drop=True)
hour_analysis.columns = ["시간", "일반 게시물", "인기 게시물"]
hour_analysis["종합"] = hour_analysis["일반 게시물"] + hour_analysis["인기 게시물"]
hour_analysis

# 각 선 그래프에서 가장 큰 값과 가장 작은 값을 표시하는 함수를 정의합니다.
def annotate_max_min(line, ax):
    xdata = line.get_xdata()
    ydata = line.get_ydata()
    max_index = np.argmax(ydata)
    min_index = np.argmin(ydata)
    if ydata[min_index] > 300:
        # 최대값 표시
        ax.text(xdata[max_index], ydata[max_index] + 100, int(ydata[max_index]), 
                ha='center', va='bottom', fontsize=9)

        # 최소값 표시
        ax.text(xdata[min_index], ydata[min_index] + 100, int(ydata[min_index]), 
                ha='center', va='bottom', fontsize=9)
    else:
        pass

# 그래프 그리기
fig, axes = plt.subplots(nrows=5, ncols=1, figsize=(12, 20))

# 연도별 그래프 ---------
axes[0].plot(yearly_analysis["연도"], yearly_analysis['일반 게시물'], label='일반', marker='o', color=custom_palette[0])
axes[0].plot(yearly_analysis["연도"], yearly_analysis['인기 게시물'], label='인기', linestyle='--', marker='o', color=custom_palette[1])


# 월별 그래프 ---------
axes[1].plot(monthly_analysis["월"], monthly_analysis['일반 게시물'], label='일반', marker='o', color=custom_palette[0])
axes[1].plot(monthly_analysis["월"], monthly_analysis['인기 게시물'], label='인기', linestyle='--', marker='o', color=custom_palette[1])

# 일별 그래프 ---------
axes[2].plot(day_analysis["일"], day_analysis['일반 게시물'], label='일반', marker='o', color=custom_palette[0])
axes[2].plot(day_analysis["일"], day_analysis['인기 게시물'], label='인기', linestyle='--', marker='o', color=custom_palette[1])

# 요일별 그래프 ---------
axes[3].plot(weekday_analysis["요일"], weekday_analysis['일반 게시물'], label='일반', marker='o', color=custom_palette[0])
axes[3].plot(weekday_analysis["요일"], weekday_analysis['인기 게시물'], label='인기', linestyle='--', marker='o', color=custom_palette[1])

# 시간별 그래프 ---------
axes[4].plot(hour_analysis["시간"], hour_analysis['일반 게시물'], label='일반', marker='o', color=custom_palette[0])
axes[4].plot(hour_analysis["시간"], hour_analysis['인기 게시물'], label='인기', linestyle='--', marker='o', color=custom_palette[1])

#그래프 숫자 작성
for i in range(0,5):
    for line in axes[i].get_lines():
        annotate_max_min(line, axes[i])
        
# 그래프 설정
axes[0].legend(["일반", "인기"], loc='upper right', bbox_to_anchor=(0.65, 0.7, 0.4, 0.5))

axes[0].set_title("연도 별 분석")
axes[1].set_title("월별 분석")
axes[2].set_title("일 별 분석")
axes[3].set_title("요일 별 분석")
axes[4].set_title("시간 별 분석")

axes[0].set_xlabel("")
axes[1].set_xlabel("")
axes[2].set_xlabel("월")
axes[3].set_xlabel("요일")
axes[4].set_xlabel("시간")

axes[0].set_ylabel("")
axes[1].set_ylabel("")
axes[2].set_ylabel("")
axes[3].set_ylabel("")
axes[4].set_ylabel("")

axes[0].set_xticks(range(2019, 2023))
axes[1].set_xticks(range(1, 13))
axes[2].set_xticks(range(1, 32))
axes[3].set_xticks(range(0,7))
axes[3].set_xticklabels(["월요일", "화요일", "수요일", "목요일", "금요일", "토요일", "일요일"])
axes[4].set_xticks(range(0, 25))

fig.suptitle("게시물 유형 별 시계열 분석", size=title_font_size, fontweight="bold")
plt.tight_layout(pad=1.7)
sns.despine()
plt.show()        

# 5월은 지마켓/옥션에서 11월은 지마켓/옥션과 11번가에서 각 스마일 데이와 그랜드 십일절 이라는 연례 특가 행사 이벤트를 한다. 이때문에 5월과 11월에 특가 게시물의 등록수가 많은것인지 확인한다.
# 11일은 11번가에서 십일절 이라는 특가 행사를하여 특가가 많은것인지 확인이 필요하다.
channel_counts = channel_counts_aggregated.sort_values(by="general_ratio", ascending=True)
order = list(channel_counts["sales_channel_aggregated"])
order.append("ETC")

# 월별 판매 채널 카운트
monthly_channel_counts = data.groupby([data['date'].dt.month, 'sales_channel_aggregated']).size().reset_index(name='counts')
monthly_channel_counts_pivot = monthly_channel_counts.pivot(index='date', columns='sales_channel_aggregated', values='counts').fillna(0)

# 비율로 변환
monthly_channel_percentage = monthly_channel_counts_pivot.divide(monthly_channel_counts_pivot.sum(axis=1), axis=0) * 100
monthly_channel_percentage = monthly_channel_percentage[order]
monthly_channel_percentage.rename_axis(None, axis=1).reset_index().round(2)

# 일별 판매 채널 카운트
daily_channel_counts = data.groupby([data['date'].dt.day, 'sales_channel_aggregated']).size().reset_index(name='counts')
daily_channel_counts_pivot = daily_channel_counts.pivot(index='date', columns='sales_channel_aggregated', values='counts').fillna(0)

# 비율로 변환
daily_channel_percentage = daily_channel_counts_pivot.divide(daily_channel_counts_pivot.sum(axis=1), axis=0) * 100
daily_channel_percentage = daily_channel_percentage[order]
daily_channel_percentage.rename_axis(None, axis=1).reset_index().round(2)

# 시간 별 판매 채널 카운트
hour_channel_counts = data.groupby([data['date'].dt.hour, 'sales_channel_aggregated']).size().reset_index(name='counts')
hour_channel_counts_pivot = hour_channel_counts.pivot(index='date', columns='sales_channel_aggregated', values='counts').fillna(0)

# 비율로 변환
hour_channel_percentage = hour_channel_counts_pivot.divide(hour_channel_counts_pivot.sum(axis=1), axis=0) * 100
hour_channel_percentage = hour_channel_percentage[order]
hour_channel_percentage.rename_axis(None, axis=1).reset_index().round(2)

# 두 그래프를 2x1로 합치기
fig, axes = plt.subplots(3, 1, figsize=(15, 20))

# 월별 판매 채널 비율
sns.heatmap(monthly_channel_percentage, cmap='YlGnBu', annot=True, fmt='.2f', linewidths=.5, ax=axes[0], cbar=False)

# 일별 판매 채널 비율
sns.heatmap(daily_channel_percentage, cmap='YlGnBu', annot=True, fmt='.2f', linewidths=.5, ax=axes[1], cbar=False)

# 시간별 판매 채널 비율
sns.heatmap(hour_channel_percentage, cmap='YlGnBu', annot=True, fmt='.2f', linewidths=.5, ax=axes[2], cbar=False)


# 그래프 설정
axes[0].set_title("월 별")
axes[1].set_title("일 별")
axes[2].set_title("시간 별")

axes[0].set_xlabel("")
axes[1].set_xlabel("")
axes[2].set_xlabel("판매 채널")

axes[0].set_ylabel("월")
axes[1].set_ylabel("일")
axes[2].set_ylabel("시간")

fig.suptitle("판매 채널 게시물 등록 비율", size=14, fontweight="bold")
plt.tight_layout(pad=1.7)
sns.despine()
plt.show()