데이터 로드와 탐색

import pandas as pd
 
# 데이터 로드
DATA_PATH = '/data/'  # Cookbook 샘플 데이터 경로
 
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):,}행")
print(f"   - products: {len(products):,}행")
print(f"   - users: {len(users):,}행")

import pandas as pd
import numpy as np
 
print("✅ Pandas 버전:", pd.__version__)
 
# 딕셔너리로 DataFrame 만들기 (가장 쉬운 방법!)
data = {
    '이름': ['철수', '영희', '민수', '지영'],
    '나이': [25, 30, 35, 28],
    '도시': ['서울', '부산', '대구', '서울']
}
 
df = pd.DataFrame(data)
print("✅ DataFrame을 만들었어요!")
print(df)

   이름  나이  도시
0  철수  25  서울
1  영희  30  부산
2  민수  35  대구
3  지영  28  서울

df = pd.read_csv('파일경로.csv')

DATA_PATH = '/data/'  # Cookbook 샘플 데이터 경로
 
# 기본 읽기
df = pd.read_csv(DATA_PATH + 'src_orders.csv')
print(f"전체 데이터: {len(df):,}행")
 
# 특정 열만 읽기
df_cols = pd.read_csv(DATA_PATH + 'src_orders.csv', usecols=['order_id', 'user_id', 'created_at'])
print(f"특정 열만: {df_cols.columns.tolist()}")
 
# 처음 1000행만 읽기
df_sample = pd.read_csv(DATA_PATH + 'src_orders.csv', nrows=1000)
print(f"\n처음 1000행 샘플:")
print(df_sample.head())

# products 데이터로 Excel 실습
products = pd.read_csv('/data/src_products.csv')
 
# 파일 저장 및 읽기 (openpyxl 필요)
try:
    products.head(10).to_excel('products_sample.xlsx', index=False)
 
    # 기본 읽기
    df_excel = pd.read_excel('products_sample.xlsx')
    print("Excel 파일 읽기 성공:")
    print(df_excel.head(3))
except ImportError:
    print("openpyxl 라이브러리가 필요합니다: pip install openpyxl")

# DataFrame을 JSON으로 저장 후 읽기
products = pd.read_csv('/data/src_products.csv')
products.head(5).to_json('products_sample.json', orient='records', force_ascii=False)
 
# JSON 파일 읽기
df_json = pd.read_json('products_sample.json')
print("JSON 파일 읽기:")
print(df_json)
 
# 중첩 JSON 처리 예시
json_data = {
    'company': 'ABC Corp',
    'items': [
        {'name': 'Product A', 'price': 100},
        {'name': 'Product B', 'price': 200}
    ]
}
df_nested = pd.json_normalize(json_data, record_path='items')
print("\n중첩 JSON 처리:")
print(df_nested)

# BigQuery 연동 예시 (실제 환경에서 사용)
# from google.cloud import bigquery
#
# client = bigquery.Client(project='your-project')
#
# query = """
# SELECT *
# FROM `project.dataset.src_orders`
# LIMIT 1000
# """
#
# df = client.query(query).to_dataframe()
# print(f"BigQuery에서 {len(df)}행 로드")
 
# 실습에서는 로컬 CSV 사용
df = pd.read_csv('/data/src_orders.csv', nrows=1000)
print(f"데이터 로드 완료: {len(df)}행")

df = pd.read_csv('/data/src_orders.csv')
 
# 처음 5개 행 (기본값)
print("처음 5개 행:")
print(df.head())
 
print("\n처음 3개 행:")
print(df.head(3))
 
print("\n마지막 2개 행:")
print(df.tail(2))

print("DataFrame 크기 (행, 열):", df.shape)
print("총 행 개수:", len(df))
print("컬럼 이름:", df.columns.tolist())

print("각 컬럼의 데이터 타입:")
print(df.dtypes)

# 모든 정보 요약
df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 100000 entries, 0 to 99999
Data columns (total 5 columns):
 #   Column       Non-Null Count   Dtype
---  ------       --------------   -----
 0   order_id     100000 non-null  int64
 1   user_id      100000 non-null  int64
 2   created_at   100000 non-null  object
 3   status       100000 non-null  object
 4   num_of_item  100000 non-null  int64
dtypes: int64(3), object(2)
memory usage: 3.8+ MB

# 숫자 컬럼들의 통계
print(df.describe())

              나이    10년후_나이
count   4.000000   4.000000
mean   29.500000  39.500000
std     4.203173   4.203173
min    25.000000  35.000000
25%    27.250000  37.250000
50%    29.000000  39.000000
75%    31.250000  41.250000
max    35.000000  45.000000

# 간단한 DataFrame으로 통계 실습
data = {
    '이름': ['철수', '영희', '민수', '지영'],
    '나이': [25, 30, 35, 28],
    '도시': ['서울', '부산', '대구', '서울']
}
df_sample = pd.DataFrame(data)
 
# 개별 통계
print("평균:", df_sample['나이'].mean())
print("합계:", df_sample['나이'].sum())
print("최소:", df_sample['나이'].min())
print("최대:", df_sample['나이'].max())
print("중간값:", df_sample['나이'].median())
print("표준편차:", df_sample['나이'].std())
print("고유값 개수:", df_sample['도시'].nunique())
print("\n값별 개수:")
print(df_sample['도시'].value_counts())

# 테스트용 DataFrame
df_convert = pd.DataFrame({
    'quantity': ['10', '20', '30', '40'],
    'price': ['100.5', '200.3', '300.0', 'N/A']
})
 
print("변환 전:")
print(df_convert.dtypes)
 
# 문자열을 정수로
df_convert['quantity'] = df_convert['quantity'].astype(int)
 
# 오류 무시하고 변환 (변환 불가 → NaN)
df_convert['price'] = pd.to_numeric(df_convert['price'], errors='coerce')
 
print("\n변환 후:")
print(df_convert.dtypes)
print(df_convert)

# 주문 데이터 로드
df = pd.read_csv('/data/src_orders.csv')
 
print("변환 전 타입:", df['created_at'].dtype)
 
# 문자열을 datetime으로
df['created_at'] = pd.to_datetime(df['created_at'])
 
print("변환 후 타입:", df['created_at'].dtype)
print("\n날짜 컬럼 샘플:")
print(df['created_at'].head())

df = pd.read_csv('/data/src_orders.csv')
 
# 변환 전 메모리
mem_before = df.memory_usage(deep=True).sum() / 1024**2
print(f"변환 전: {mem_before:.2f} MB")
 
# object → category (메모리 절약)
df['status'] = df['status'].astype('category')
 
# 변환 후 메모리
mem_after = df.memory_usage(deep=True).sum() / 1024**2
print(f"변환 후: {mem_after:.2f} MB")
print(f"절약: {mem_before - mem_after:.2f} MB ({(1 - mem_after/mem_before)*100:.1f}%)")

# 기본 저장 (인덱스 제외)
df.to_csv('output.csv', index=False)
print("output.csv 저장 완료")
 
# 한글 포함 파일
df.head(100).to_csv('주문데이터_저장.csv', index=False, encoding='utf-8-sig')
print("주문데이터_저장.csv 저장 완료")

# 예시 데이터 준비
df1 = pd.DataFrame({'주문번호': [1, 2, 3], '금액': [100, 200, 300]})
df2 = pd.DataFrame({'고객ID': [101, 102], '이름': ['김철수', '이영희']})
 
try:
    # 여러 시트에 저장
    with pd.ExcelWriter('output.xlsx') as writer:
        df1.to_excel(writer, sheet_name='주문', index=False)
        df2.to_excel(writer, sheet_name='고객', index=False)
    print("output.xlsx 저장 완료 (2개 시트)")
except ImportError:
    print("openpyxl 라이브러리가 필요합니다")

# 기본 저장
df.head(5).to_json('output.json', orient='records')
 
# 한글 포함
df.head(5).to_json('output_korean.json', orient='records', force_ascii=False)
print("JSON 저장 완료")

# 대용량 파일 시뮬레이션 (src_orders.csv 사용)
# 청크 단위로 읽기
chunks = pd.read_csv('/data/src_orders.csv', chunksize=10000)
 
result = []
for i, chunk in enumerate(chunks):
    # 각 청크 처리: Complete 상태만 필터링
    processed = chunk[chunk['status'] == 'Complete']
    result.append(processed)
    if i < 3:  # 처음 3개 청크만 출력
        print(f"청크 {i+1}: {len(chunk)}행 → {len(processed)}행 (Complete만)")
 
df_complete = pd.concat(result)
print(f"\n총 Complete 주문: {len(df_complete):,}행")

def optimize_dtypes(df):
    """메모리 최적화를 위한 데이터 타입 변환"""
    for col in df.columns:
        col_type = df[col].dtype
 
        if col_type == 'object':
            # 고유값이 적으면 category로
            if df[col].nunique() / len(df) < 0.5:
                df[col] = df[col].astype('category')
 
        elif col_type == 'int64':
            # 작은 정수 타입으로
            if df[col].min() >= 0:
                if df[col].max() < 255:
                    df[col] = df[col].astype('uint8')
                elif df[col].max() < 65535:
                    df[col] = df[col].astype('uint16')
                elif df[col].max() < 4294967295:
                    df[col] = df[col].astype('uint32')
 
        elif col_type == 'float64':
            # float32로 변환
            df[col] = df[col].astype('float32')
 
    return df
 
# 적용
df = pd.read_csv('/data/src_orders.csv')
mem_before = df.memory_usage(deep=True).sum() / 1024**2
 
df_optimized = optimize_dtypes(df.copy())
mem_after = df_optimized.memory_usage(deep=True).sum() / 1024**2
 
print(f"최적화 전: {mem_before:.2f} MB")
print(f"최적화 후: {mem_after:.2f} MB")
print(f"절약: {(1 - mem_after/mem_before)*100:.1f}%")
 
print("\n최적화 후 데이터 타입:")
print(df_optimized.dtypes)