데이터 정제와 전처리

import pandas as pd
import numpy as np
 
# 데이터 로드
DATA_PATH = '/data/'
 
orders = pd.read_csv(DATA_PATH + 'src_orders.csv', parse_dates=['created_at'])
order_items = pd.read_csv(DATA_PATH + 'src_order_items.csv')
products = pd.read_csv(DATA_PATH + 'src_products.csv')
users = pd.read_csv(DATA_PATH + 'src_users.csv')
 
print(f"✅ 데이터 로드 완료!")
print(f"   - orders: {len(orders):,}행")
print(f"   - order_items: {len(order_items):,}행")

import pandas as pd
import numpy as np
 
# 샘플 데이터
df_sample = pd.DataFrame({
    'user_id': [1, 2, 3, 4, 5],
    'name': ['철수', None, '민수', '지영', '영희'],
    'age': [25, 30, np.nan, 28, 35],
    'city': ['서울', '부산', '대구', None, '서울']
})
 
# 1. 결측치 개수 확인
print("컬럼별 결측치 개수:")
print(df_sample.isnull().sum())
 
# 2. 결측치 비율 확인
print("\n컬럼별 결측치 비율(%):")
print((df_sample.isnull().sum() / len(df_sample) * 100).round(2))
 
# 3. 전체 정보 확인
df_sample.info()

컬럼별 결측치 개수:
user_id    0
name       1
age        1
city       1
dtype: int64

컬럼별 결측치 비율(%):
user_id     0.0
name       20.0
age        20.0
city       20.0
dtype: float64

# 결측치가 있는 컬럼만 표시
missing = df_sample.isnull().sum()
missing_pct = (missing / len(df_sample) * 100).round(2)
 
missing_df = pd.DataFrame({
    '결측치_개수': missing,
    '결측치_비율(%)': missing_pct
})
 
# 결측치가 있는 컬럼만 필터링
missing_df = missing_df[missing_df['결측치_개수'] > 0]
missing_df = missing_df.sort_values('결측치_개수', ascending=False)
 
if len(missing_df) > 0:
    print(missing_df)
else:
    print("결측치가 없습니다!")

# 샘플 데이터 재생성
df_test = pd.DataFrame({
    'user_id': [1, 2, 3, 4, 5],
    'name': ['철수', None, '민수', '지영', '영희'],
    'age': [25, 30, np.nan, 28, 35],
    'city': ['서울', '부산', '대구', None, '서울']
})
 
# 결측치가 있는 행 삭제
df_dropped = df_test.dropna()
print(f"삭제 전: {len(df_test)}행 → 삭제 후: {len(df_dropped)}행")
 
# 특정 컬럼에서 결측치가 있는 행만 삭제
df_dropped_name = df_test.dropna(subset=['name'])
print(f"name 기준 삭제 후: {len(df_dropped_name)}행")
 
# 모든 값이 결측치인 행만 삭제
df_dropped_all = df_test.dropna(how='all')
print(f"how='all' 삭제 후: {len(df_dropped_all)}행")

# 샘플 데이터 재생성
df_fill = pd.DataFrame({
    'user_id': [1, 2, 3, 4, 5],
    'name': ['철수', None, '민수', '지영', '영희'],
    'age': [25, 30, np.nan, 28, 35],
    'city': ['서울', '부산', '대구', None, '서울'],
    'value': [100, np.nan, 150, np.nan, 200]
})
 
# 1. 특정 값으로 대체
df_fill['city'] = df_fill['city'].fillna('알 수 없음')
print("city 대체 후:")
print(df_fill['city'].tolist())
 
# 2. 평균값으로 대체 (수치형)
df_fill['age'] = df_fill['age'].fillna(df_fill['age'].mean())
print(f"\nage 평균 대체 후: {df_fill['age'].tolist()}")
 
# 3. 앞의 값으로 채우기 (forward fill)
df_fill['value'] = df_fill['value'].ffill()
print(f"value ffill 후: {df_fill['value'].tolist()}")
 
# 4. 뒤의 값으로 채우기 (backward fill)
df_test2 = pd.DataFrame({'v': [np.nan, 10, np.nan, 30, np.nan]})
df_test2['v'] = df_test2['v'].bfill()
print(f"bfill 결과: {df_test2['v'].tolist()}")

def handle_missing_values(df):
    """데이터 타입에 따라 결측치 자동 처리"""
    df_clean = df.copy()
 
    # 수치형 컬럼: 중앙값으로 대체
    numeric_cols = df_clean.select_dtypes(include=[np.number]).columns
    for col in numeric_cols:
        if df_clean[col].isnull().sum() > 0:
            median_val = df_clean[col].median()
            df_clean[col] = df_clean[col].fillna(median_val)
            print(f"✅ {col}: 중앙값({median_val:.2f})으로 대체")
 
    # 텍스트형 컬럼: '알 수 없음'으로 대체
    object_cols = df_clean.select_dtypes(include=['object']).columns
    for col in object_cols:
        if df_clean[col].isnull().sum() > 0:
            df_clean[col] = df_clean[col].fillna('알 수 없음')
            print(f"✅ {col}: '알 수 없음'으로 대체")
 
    return df_clean
 
# 적용 (orders 데이터 사용)
print("결측치 현황:")
print(orders.isnull().sum()[orders.isnull().sum() > 0])
print()
 
orders_clean = handle_missing_values(orders)
print(f"\n처리 후 결측치: {orders_clean.isnull().sum().sum()}개")

# order_items에서 중복 확인
print("=== order_items 중복 확인 ===")
 
# 1. 완전히 동일한 행 확인
n_duplicates = order_items.duplicated().sum()
print(f"중복된 행 개수: {n_duplicates:,}개")
 
# 2. 중복된 행 보기 (처음 5개만)
print("\n중복된 행 (샘플):")
duplicates = order_items[order_items.duplicated(keep=False)]
print(duplicates.head())
 
# 3. 중복 제거 (첫 번째 행만 유지)
order_items_clean = order_items.drop_duplicates(keep='first')
print(f"\n제거 전: {len(order_items):,}행")
print(f"제거 후: {len(order_items_clean):,}행")

# 중복 데이터 상세 분석
def analyze_duplicates(df, subset=None):
    """중복 데이터 상세 분석"""
    print("🔍 중복 데이터 분석")
    print("=" * 60)
 
    # 전체 중복
    n_dup = df.duplicated(subset=subset).sum()
    pct_dup = (n_dup / len(df) * 100)
 
    print(f"✓ 총 행 수: {len(df):,}개")
    print(f"✓ 중복된 행: {n_dup:,}개 ({pct_dup:.2f}%)")
 
    # 제거 시뮬레이션
    df_dedup = df.drop_duplicates(subset=subset, keep='first')
    n_after = len(df_dedup)
 
    print(f"✓ 중복 제거 후: {n_after:,}개")
    print(f"✓ 제거될 행: {len(df) - n_after:,}개")
 
    return df_dedup
 
# 실행
order_items_clean = analyze_duplicates(order_items)

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
 
def detect_outliers_iqr(df, column):
    """IQR 방법으로 이상치 탐지"""
    print(f"🔍 {column} 이상치 탐지 (IQR 방법)")
    print("=" * 60)
 
    # IQR 계산
    Q1 = df[column].quantile(0.25)
    Q3 = df[column].quantile(0.75)
    IQR = Q3 - Q1
 
    # 이상치 경계
    lower_bound = Q1 - 1.5 * IQR
    upper_bound = Q3 + 1.5 * IQR
 
    print(f"✓ Q1 (25백분위수): {Q1:,.2f}")
    print(f"✓ Q3 (75백분위수): {Q3:,.2f}")
    print(f"✓ IQR: {IQR:,.2f}")
    print(f"✓ 하한선: {lower_bound:,.2f}")
    print(f"✓ 상한선: {upper_bound:,.2f}")
 
    # 이상치 찾기
    outliers = df[(df[column] < lower_bound) | (df[column] > upper_bound)]
    n_outliers = len(outliers)
 
    print(f"\n이상치 개수: {n_outliers:,}개 ({n_outliers/len(df)*100:.2f}%)")
 
    return outliers, lower_bound, upper_bound
 
# 실행 (order_items의 sale_price 컬럼 사용)
outliers, lower_bound, upper_bound = detect_outliers_iqr(order_items, 'sale_price')

# 이상치가 포함된 테스트 데이터 생성
np.random.seed(42)
test_prices = pd.DataFrame({
    'sale_price': np.concatenate([
        np.random.normal(100, 30, 9500),  # 정상 데이터
        np.random.uniform(300, 500, 300),  # 높은 이상치
        np.random.uniform(-50, 0, 200)     # 낮은 이상치 (음수 가격)
    ])
})
 
outliers, lower_bound, upper_bound = detect_outliers_iqr(test_prices, 'sale_price')
print(f"\n이상치 샘플 (상위 5개):")
print(outliers.nlargest(5, 'sale_price'))

def visualize_outliers(df, column):
    """박스플롯과 히스토그램으로 이상치 시각화"""
    fig, axes = plt.subplots(1, 2, figsize=(14, 5))
 
    # IQR 계산
    Q1 = df[column].quantile(0.25)
    Q3 = df[column].quantile(0.75)
    IQR = Q3 - Q1
    lower_bound = Q1 - 1.5 * IQR
    upper_bound = Q3 + 1.5 * IQR
 
    # 박스플롯
    axes[0].boxplot(df[column].dropna(), vert=False)
    axes[0].set_xlabel(column)
    axes[0].set_title(f'{column} 박스플롯')
 
    # 히스토그램
    axes[1].hist(df[column].dropna(), bins=50, alpha=0.7, edgecolor='black')
    axes[1].axvline(lower_bound, color='red', linestyle='--', label=f'하한: {lower_bound:.0f}')
    axes[1].axvline(upper_bound, color='red', linestyle='--', label=f'상한: {upper_bound:.0f}')
    axes[1].set_xlabel(column)
    axes[1].set_ylabel('빈도')
    axes[1].set_title(f'{column} 히스토그램')
    axes[1].legend()
 
    plt.tight_layout()
    plt.show()
 
visualize_outliers(test_prices, 'sale_price')

# 이상치 처리 예시 (test_prices 데이터 사용)
df_outlier = test_prices.copy()
 
# 경계값 계산
Q1 = df_outlier['sale_price'].quantile(0.25)
Q3 = df_outlier['sale_price'].quantile(0.75)
IQR = Q3 - Q1
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR
 
print(f"이상치 경계: {lower_bound:.2f} ~ {upper_bound:.2f}")
 
# 1. 이상치 제거
df_removed = df_outlier[(df_outlier['sale_price'] >= lower_bound) &
                        (df_outlier['sale_price'] <= upper_bound)]
print(f"\n1. 이상치 제거: {len(df_outlier):,}행 → {len(df_removed):,}행")
 
# 2. 이상치를 경계값으로 대체 (윈저라이징)
df_capped = df_outlier.copy()
df_capped['sale_price_capped'] = df_capped['sale_price'].clip(lower=lower_bound, upper=upper_bound)
print(f"2. 윈저라이징 적용 완료")
print(f"   원본 최대값: {df_outlier['sale_price'].max():.2f}")
print(f"   클리핑 후 최대값: {df_capped['sale_price_capped'].max():.2f}")
 
# 3. 이상치를 NaN으로 변환 후 중앙값 대체
df_replaced = df_outlier.copy()
mask = (df_replaced['sale_price'] < lower_bound) | (df_replaced['sale_price'] > upper_bound)
median_val = df_replaced.loc[~mask, 'sale_price'].median()
df_replaced.loc[mask, 'sale_price'] = median_val
print(f"3. 중앙값 대체: 이상치 {mask.sum()}개를 {median_val:.2f}로 대체")

import pandas as pd
import numpy as np
 
def clean_data_pipeline(df, verbose=True):
    """데이터 정제 파이프라인"""
 
    df_clean = df.copy()
 
    if verbose:
        print("🔧 데이터 정제 파이프라인 시작")
        print("=" * 60)
        print(f"원본 데이터: {df_clean.shape[0]:,}행 × {df_clean.shape[1]}열")
 
    # 1. 중복 제거
    before = len(df_clean)
    df_clean = df_clean.drop_duplicates()
    after = len(df_clean)
    if verbose:
        print(f"\n[1] 중복 제거: {before - after:,}행 제거")
 
    # 2. 결측치 처리
    missing_before = df_clean.isnull().sum().sum()
 
    # 수치형 → 중앙값
    numeric_cols = df_clean.select_dtypes(include=[np.number]).columns
    for col in numeric_cols:
        df_clean[col] = df_clean[col].fillna(df_clean[col].median())
 
    # 문자형 → '알 수 없음'
    object_cols = df_clean.select_dtypes(include=['object']).columns
    for col in object_cols:
        df_clean[col] = df_clean[col].fillna('알 수 없음')
 
    missing_after = df_clean.isnull().sum().sum()
    if verbose:
        print(f"[2] 결측치 처리: {missing_before - missing_after:,}개 처리")
 
    # 3. 데이터 타입 최적화
    for col in object_cols:
        if df_clean[col].nunique() / len(df_clean) < 0.5:
            df_clean[col] = df_clean[col].astype('category')
 
    if verbose:
        print("[3] 데이터 타입 최적화 완료")
        print(f"\n✅ 정제 완료: {df_clean.shape[0]:,}행 × {df_clean.shape[1]}열")
 
    return df_clean
 
# 실행 (orders 데이터 사용)
orders_clean = clean_data_pipeline(orders)