작업형 1·2·3에서 쓰는 파이썬 코드 75개

import pandas as pd
import numpy as np

df = pd.read_csv('data/파일명.csv')
print(df.shape)                        # (행, 열)
print(df.head(3).to_string(index=False))
df.info()                              # 자료형 · 결측 개수
print(df.describe())                   # 수치형 요약

df['score']                         # Series
df[['group', 'score']]              # DataFrame
df.loc[df['flag'] == 1, 'amount']   # 조건 + 컬럼
df.loc[0, 'score']                  # 라벨 기준
df.iloc[0, 2]                       # 위치 기준 (0번 행, 2번 열)
df.iloc[:10]                        # 앞 10행

s = df.sort_values('amount', ascending=False)
print(s.iloc[0]['id'])             # 1등
print(s.iloc[2]['amount'])         # 3등 값

# 여러 기준 정렬
df.sort_values(['score', 'age'], ascending=[False, True])

df.nlargest(10, 'amount')          # 상위 10행 바로

df['score'].sum(); df['score'].mean(); df['score'].median()
df['score'].std()        # 표본표준편차 (ddof=1)
df['score'].std(ddof=0)  # 모표준편차 — 문제에 「모」가 있으면
df['score'].var()
df['score'].quantile(0.75)
df['group'].nunique()    # 고유값 개수

print(df.isna().sum())               # 컬럼별 결측 개수
print(df['views'].isna().sum())
print(df.isna().sum().sum())         # 전체 결측 개수

drop_df = df.dropna(subset=['rating', 'views'])
print(len(df) - len(drop_df))        # 제거된 행 수

work = df.copy()
med = work['rating'].median()     # 채우기 「전」 값으로 구한다
work['rating'] = work['rating'].fillna(med)

work['views'] = work['views'].fillna(work['views'].mean())
work['status'] = work['status'].fillna(work['status'].mode()[0])

work = df.copy()
grp_med = work.groupby('group')['views'].transform('median')
work['views'] = work['views'].fillna(grp_med)
# 그룹 전체가 결측이면 전체 중앙값으로 한 번 더
work['views'] = work['views'].fillna(work['views'].median())

q1 = df['price'].quantile(0.25)
q3 = df['price'].quantile(0.75)
iqr = q3 - q1
lower, upper = q1 - 1.5 * iqr, q3 + 1.5 * iqr

out = (df['price'] < lower) | (df['price'] > upper)
print(out.sum())                      # 이상치 개수
print(df.loc[~out, 'price'].mean())   # 이상치 제외 평균

# lower · upper 는 앞 카드(IQR 이상치)에서 구한 값
capped = df['price'].clip(lower, upper)    # 경계값으로 대체

z = (df['score'] - df['score'].mean()) / df['score'].std()   # ddof=1
print((z.abs() > 3).sum())                 # |z| > 3 개수
# scipy.stats.zscore · StandardScaler 는 ddof=0 — 경계 개수가 달라질 수 있다

lo, hi = df['score'].min(), df['score'].max()
mm = (df['score'] - lo) / (hi - lo)              # min-max 0~1

print(df.duplicated().sum())                    # 완전 중복 행 수
print(df.duplicated(subset=['id']).sum())       # id 기준 중복
dedup = df.drop_duplicates(subset=['id'], keep='first')

df['total'] = df['qty'] * df['unit_price']
df['is_high'] = (df['amount'] >= 150000).astype(int)

bins = [0, 30, 40, 50, float('inf')]
df['age_band'] = pd.cut(df['age'], bins=bins,
                        labels=['~29', '30대', '40대', '50+'],
                        right=False)      # [0,30) [30,40) ...
df['q4'] = pd.qcut(df['score'], 4, labels=False)   # 4분위 0~3

df['flag_txt'] = df['flag'].map({1: 'Y', 0: 'N'})
df['status2'] = df['status'].map({'방문': 1, '취소': -1, '대기': 0})
df['region2'] = df['region'].replace('central', 'center')
df['grade'] = np.where(df['score'] >= 70, 'pass', 'fail')
df['len'] = df['name'].apply(lambda x: len(x))

df['code'].str.split('-').str[0]          # 'AB-01' → 'AB'
df['code'].str[:2]                        # 앞 두 글자
df['name'].str.lower().str.contains('apple')
df['code'].str.startswith('AB')
df['name'].str.replace(' ', '')
df['name'].str.len()

df['date'] = pd.to_datetime(df['date'])
df['year'] = df['date'].dt.year
df['month'] = df['date'].dt.month
df['weekday'] = df['date'].dt.weekday     # 월=0 … 일=6
df['is_weekend'] = (df['weekday'] >= 5).astype(int)
df[(df['date'] >= '2024-03-01') & (df['date'] < '2024-04-01')]

df['date'] = pd.to_datetime(df['date'])
df['end_date'] = pd.to_datetime(df['end_date'])
df['days'] = (df['end_date'] - df['date']).dt.days
df['hours'] = (df['end_date'] - df['date']).dt.total_seconds() / 3600

df.groupby('group')['amount'].mean()
df.groupby('group')['amount'].sum().sort_values(ascending=False)
df.groupby('group').size()             # 그룹별 행 수
df.groupby(['region', 'group'])['score'].mean().reset_index()

summary = df.groupby('region').agg(
    cnt=('id', 'count'),
    amount_sum=('amount', 'sum'),
    score_mean=('score', 'mean'),
).sort_values('amount_sum', ascending=False)
print(summary.round(2))

g = df.groupby('group')['amount'].mean()
print(g.idxmax(), g.max())     # 평균이 가장 큰 그룹과 그 값
print(g.idxmin())

score = df['status'].map({'방문': 1, '취소': -1, '대기': 0})
bal = score.groupby(df['region']).sum()    # 음수도 나오는 합
key = bal.abs().idxmax()       # 절댓값이 가장 큰 그룹
print(key, bal.loc[key])       # 값은 원래 부호로

pt = df.pivot_table(index='region', columns='group',
                    values='amount', aggfunc='mean')
ct = pd.crosstab(df['region'], df['group'])            # 빈도
ct_r = pd.crosstab(df['region'], df['group'], normalize='index')  # 행 비율
wide = df.groupby(['region', 'group'])['amount'].mean().unstack()

m = pd.merge(df, other, on='id', how='left')   # inner/left/right/outer
both = pd.concat([df, df], axis=0, ignore_index=True)  # 위아래
side = pd.concat([df, other], axis=1)                  # 좌우
# axis=1 은 키가 아니라 「행 번호」로 붙인다 — id 로 맞추려면 merge

df[['age', 'score', 'amount']].corr()
df['age'].corr(df['score'])                    # 피어슨
df['age'].corr(df['score'], method='spearman')
df['rank'] = df['amount'].rank(ascending=False, method='min')
df['cum'] = df['amount'].cumsum()
df['prev'] = df['amount'].shift(1)

import math
print(int(-2.7))         # -2  (0 쪽으로)
print(math.floor(-2.7))  # -3  (아래로)
print(math.ceil(2.1))    # 3
np.floor(df['score'])    # Series 버림
np.ceil(df['score'])

print((df['amount'] >= 150000).sum())   # 조건 만족 개수
print(df['views'].isna().sum())         # 결측 개수
print(df['flag'].sum())                 # 0/1 합
print(len(df[df['flag'] == 1]))

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
from sklearn.metrics import roc_auc_score, f1_score, accuracy_score
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score

train = pd.read_csv('data/train.csv')
test = pd.read_csv('data/test.csv')
print(train.shape, test.shape)

# train 에만 있는 컬럼 = target 후보
print(set(train.columns) - set(test.columns))
print(train[target_col].value_counts().sort_index())
print(train[target_col].nunique())
# 값 2개   → 이진분류 (ROC-AUC 면 확률 제출)
# 값 여러 개 → 다중분류 (Macro F1 · 클래스 제출)
# 연속값   → 회귀

X_raw = train.drop(columns=[target_col, id_col]).copy()
y = train[target_col].copy()
test_raw = test.drop(columns=[id_col]).copy()
print(X_raw.shape, y.shape, test_raw.shape)

from sklearn.preprocessing import LabelEncoder

X_le, test_le = X_raw.copy(), test_raw.copy()
for col in cat_cols:
    le = LabelEncoder()
    le.fit(pd.concat([X_le[col], test_le[col]]))   # test 에만 있는 값 대비
    X_le[col] = le.transform(X_le[col])
    test_le[col] = le.transform(test_le[col])

def prepare_features(ref_X, other_X):
    ref_X, other_X = ref_X.copy(), other_X.copy()
    cat = ref_X.select_dtypes(include='object').columns
    num = ref_X.select_dtypes(exclude='object').columns
    for c in num:
        m = ref_X[c].median()
        ref_X[c] = ref_X[c].fillna(m)
        other_X[c] = other_X[c].fillna(m)
    for c in cat:
        ref_X[c] = ref_X[c].fillna('unknown')
        other_X[c] = other_X[c].fillna('unknown')
    ref_X = pd.get_dummies(ref_X)
    other_X = pd.get_dummies(other_X)
    other_X = other_X.reindex(columns=ref_X.columns, fill_value=0)
    return ref_X, other_X

X_raw = train.drop(columns=[target_col, id_col])
test_raw = test.drop(columns=[id_col])

from sklearn.preprocessing import StandardScaler

X_enc, test_enc = prepare_features(X_raw, test_raw)
sc = StandardScaler()
X_sc = sc.fit_transform(X_enc)      # train 은 fit_transform
test_sc = sc.transform(test_enc)    # test 는 transform 만
# 트리 모델(RandomForest)은 스케일링 없이도 된다

X_tr_raw, X_va_raw, y_tr, y_va = train_test_split(
    X_raw, y, test_size=0.2, random_state=0,
    stratify=y)              # 분류면 stratify, 회귀면 빼기
X_tr, X_va = prepare_features(X_tr_raw, X_va_raw)

model = RandomForestClassifier(n_estimators=200, random_state=0)
model.fit(X_tr, y_tr)
pred = model.predict(X_va)
print(accuracy_score(y_va, pred))

from sklearn.metrics import precision_score, recall_score

accuracy_score(y_va, pred)
f1_score(y_va, pred)                    # 이진 (양성 = 1)
# 라벨이 문자열이면 f1_score(y_va, pred, pos_label='Yes')
f1_score(y_va, pred, average='macro')   # 다중분류 Macro F1
precision_score(y_va, pred); recall_score(y_va, pred)
roc_auc_score(y_va, p1)                 # 확률값 넣기

Xr_tr_raw, Xr_va_raw, yr_tr, yr_va = train_test_split(
    X_raw, yr, test_size=0.2, random_state=0)
Xr_tr, Xr_va = prepare_features(Xr_tr_raw, Xr_va_raw)

reg = RandomForestRegressor(n_estimators=200, random_state=0)
reg.fit(Xr_tr, yr_tr)
r_pred = reg.predict(Xr_va)

from sklearn.metrics import mean_squared_log_error

mae = mean_absolute_error(yr_va, r_pred)
mse = mean_squared_error(yr_va, r_pred)
rmse = np.sqrt(mse)                                      # RMSE
rmsle = np.sqrt(mean_squared_log_error(yr_va, np.clip(r_pred, 0, None)))
# 음수 예측이 섞이면 sklearn 1.2 는 오류, 최신은 값이 틀어진다 → 0 으로 자른 뒤 계산
# 지표가 RMSLE 면 제출값도 np.clip(test_pred, 0, None) 으로 자른다
r2 = r2_score(yr_va, r_pred)

from sklearn.linear_model import LogisticRegression, LinearRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import GradientBoostingClassifier

LogisticRegression(max_iter=1000).fit(X_tr, y_tr)
DecisionTreeClassifier(max_depth=5, random_state=0).fit(X_tr, y_tr)
GradientBoostingClassifier(random_state=0).fit(X_tr, y_tr)
LinearRegression().fit(Xr_tr, yr_tr)

X_full, test_enc = prepare_features(X_raw, test_raw)
final = RandomForestClassifier(n_estimators=200, random_state=0)
final.fit(X_full, y)

pos = list(final.classes_).index(1)
test_pred = final.predict_proba(test_enc)[:, pos]   # 확률 제출
# test_pred = final.predict(test_enc)              # 클래스 제출

check = pd.read_csv('result.csv')
print(check.shape)                     # (test 행 수, 1)
print(check.columns.tolist())          # ['pred']
print(len(check) == len(test))         # True
print(check.isna().sum().sum())        # 0
print(check.head())

print(check['pred'].min(), check['pred'].max())  # 확률이면 0~1
print(check['pred'].value_counts().head())        # 클래스면 분포 확인
# target 이 양수뿐인 회귀면 음수 예측이 없는지도 본다
print((check['pred'] < 0).sum())

from scipy import stats
import statsmodels.api as sm
from statsmodels.formula.api import ols
from statsmodels.stats.proportion import proportions_ztest

r = stats.ttest_1samp(df['x'], 50, alternative='two-sided')
print(round(r.statistic, 4), round(r.pvalue, 4))

print(stats.shapiro(a).pvalue)          # p ≥ 0.05 → 정규성 기각 못 함
print(stats.levene(a, b).pvalue)        # p ≥ 0.05 → 등분산 기각 못 함
print(stats.bartlett(a, b).pvalue)

lev_p = stats.levene(a, b).pvalue
r = stats.ttest_ind(a, b, equal_var=(lev_p >= 0.05))   # 등분산 아니면 Welch
print(round(r.statistic, 4), round(r.pvalue, 4))
print(round(a.mean() - b.mean(), 4))     # 평균 차이 방향 확인

# 문제가 정한 「A − B」 순서대로 넣는다 (여기선 사후 − 사전)
# 순서를 바꾸면 t 부호와 단측 p-value 가 뒤집힌다
r = stats.ttest_rel(df['after'], df['before'], alternative='greater')
print(round(r.statistic, 4), round(r.pvalue, 4))
print(round((df['after'] - df['before']).mean(), 4))

r = stats.ttest_1samp(df['x'], 50)
ci = r.confidence_interval(confidence_level=0.95)   # scipy 1.10 이상
print(round(ci.low, 4), round(ci.high, 4))

# 버전이 낮아 위가 오류면 — 버전과 상관없이 되는 방법
se = stats.sem(df['x'])
stats.t.interval(0.95, len(df) - 1, loc=df['x'].mean(), scale=se)

n = len(df); m = df['x'].mean(); s = df['x'].std()
t = (m - 50) / (s / np.sqrt(n))
p = 2 * (1 - stats.t.cdf(abs(t), df=n - 1))   # 양측
print(round(t, 4), round(p, 4))

cnt, nobs = df['success'].sum(), len(df)
z, p = proportions_ztest(count=cnt, nobs=nobs, value=0.5)     # 1표본
# 기본은 표준오차를 「표본 비율」로 계산한다 (교재 풀이와 같음)
# 귀무 비율로 계산하라는 문제면 prop_var=0.5 를 더한다

s = df.groupby('cat')['success'].agg(['sum', 'count'])
z2, p2 = proportions_ztest(count=s['sum'].values,
                           nobs=s['count'].values)             # 2표본

groups = [g['x'].values for _, g in df.groupby('group')]
r = stats.f_oneway(*groups)
print(round(r.statistic, 4), round(r.pvalue, 4))

model = ols('x ~ C(group)', data=df).fit()
print(sm.stats.anova_lm(model, typ=2))

# 이원분산분석 (교호작용 포함)
m2 = ols('x ~ C(group) * C(cat)', data=df).fit()
print(sm.stats.anova_lm(m2, typ=2))
# anova_lm 기본은 typ=1 — 집단 크기가 다른 이원분산분석은 typ 에 따라 F 가 달라진다

from statsmodels.stats.multicomp import pairwise_tukeyhsd

res = pairwise_tukeyhsd(df['x'], df['group'], alpha=0.05)
print(res)

obs = df['grade'].value_counts().sort_index()      # A B C D
exp_ratio = np.array([0.1, 0.2, 0.3, 0.4])
r = stats.chisquare(obs, f_exp=exp_ratio * obs.sum())   # 합이 같아야 한다
print(round(r.statistic, 4), round(r.pvalue, 4))

table = pd.crosstab(df['region'], df['cat'])
chi2, p, dof, expected = stats.chi2_contingency(table)
print(round(chi2, 4), round(p, 4), dof)
print(np.round(expected, 2))
# 2×2 표는 기본이 연속성 보정 — 보정 없이: correction=False

alpha = 0.05
p = r.pvalue
print('기각' if p < alpha else '채택')
# p < α → 귀무가설 기각 (차이·관계가 있다)
# p ≥ α → 귀무가설 채택 (기각하지 못한다)

r, p = stats.pearsonr(df['x'], df['y'])        # 두 값으로 받으면 버전 무관
print(round(r, 4), round(p, 4))
rho, p_s = stats.spearmanr(df['x'], df['y'])
print(round(rho, 4), round(p_s, 4))

X = sm.add_constant(df[['x', 'x2']])     # 상수항 꼭 추가
model = sm.OLS(df['y'], X).fit()
print(model.summary())

m = ols('y ~ x + x2 + C(region)', data=df).fit()
print(m.params)
print(m.rsquared)

print(model.conf_int(alpha=0.05).loc['x'])     # 계수 95% 신뢰구간

new = pd.DataFrame({'x': [55.0], 'x2': [1]})
new_X = sm.add_constant(new, has_constant='add')[model.params.index]
print(model.predict(new_X).iloc[0])
print(model.get_prediction(new_X).summary_frame(alpha=0.05))

X0 = sm.add_constant(df[['x', 'x2', 'x3']])
m0 = sm.OLS(df['y'], X0).fit()
sig = m0.pvalues.drop('const')
cols = sig[sig < 0.05].index.tolist()

m1 = sm.OLS(df['y'], sm.add_constant(df[cols], has_constant='add')).fit()
print(cols, round(m1.rsquared, 4))

X = pd.get_dummies(df[['x', 'region']], columns=['region'],
                   drop_first=True, dtype=int)   # bool 말고 int
X = sm.add_constant(X)
sm.OLS(df['y'], X).fit().params

X = sm.add_constant(df[['x', 'x2']])
logit = sm.Logit(df['label'], X).fit(disp=False)  # 반복 로그 숨김
print(logit.params)
print(logit.pvalues)

prob = logit.predict(X)                 # label=1 일 확률
pred = (prob >= 0.5).astype(int)
err = (pred != df['label']).mean()       # 오분류율
print(round(err, 4), round(1 - err, 4))
print(round(logit.prsquared, 4))         # 의사 R²
print(round(logit.llf, 4), round(logit.aic, 4))   # 로그우도 · AIC

import sklearn.metrics
print([m for m in dir(sklearn.metrics) if 'score' in m])
print([f for f in dir(stats) if f.startswith('ttest')])
help(stats.ttest_ind)          # 인자 · alternative 설명

pd.set_option('display.max_columns', None)
pd.set_option('display.max_rows', 100)
pd.set_option('display.float_format', '{:.4f}'.format)
print(df.head().to_string())

import pandas, scipy, sklearn
print(pandas.__version__, sklearn.__version__, scipy.__version__)