std_wswn

빅분기 실기 작업형3 정리

_jju — Thu, 18 Jun 2026 19:30:52 +0900

1. 가설검정

1-1. 단일표본검정

한개의 집단이 있고 그 집단의 평균값이 특정값이랑 얼마나 비슷한지를 추정하는것

from scipy.stats import ttest_1samp(표본데이터, 특정값, alternative=)

alternative 옵션의 안에는 'greater', 'less', 'two-sided'가 들어갈 수 있다.

stats에 있는 shapiro() 함수로 정규성을 검사할 수 있다.

shapiro(표본데이터) 이 값의 pvalue를 보고 판정, 만약 pvalue가 0.05보다 작다면 정규성을 만족하지 않는 것.

표본집단이 정규성을 만족하지 않는다면 윌콕슨검정을 쓰자.

마찬가지 stats에 있고 wilcoxon(표본데이터 - 특정값, alternative=) 넣고 돌리면 된다.

1-2. 대응표본검정

한개의 모집단에서 전, 후 차이의 유의미함을 추정하는 것

from scipy.stats import ttest_rel(전, 후, alternative=)

여기서 전, 후, alternative 방향성이 헷갈리는데

후가 전보다 작아졌다. -> 전>후 -> ttest_rel(큰거, 작은거, alternative='greater') -> ttest_rel(전, 후, alternative='greater')

후가 전보다 커졌다. -> 후>전 -> ttest_rel(후, 전, alternative='greater')

앞에서 뒤에꺼 뺀게 양수면 greater, 음수면 less

대응표본검정도 마찬가지 shapiro()로 정규성 검정을 해주는데

shapiro(전 - 후) 이렇게 두 데이터를 넣어주어야 한다. 전, 후 순서는 상관 없다. (검정하는 대상이 둘의 차이니까)

역시 이 경우에도 정규성을 만족하지 않으면 wilcoxon에 때려넣는다. 다만 대응표본검정의 경우

wilcoxon(전, 후, alternative=) 이런식으로 쉼표로 두 집단을 구분해서 때려넣어야한다. (- 써도되지만 그럼 아까 외웠던 방향성이 달라져서 따로 외워줘야하기에... 그냥 쉼표로 외우자.)

1-3. 독립표본검정

마찬가지 stats의 ttest_ind를 쓰면 된다. ttest_ind(A, B, alternative=)

아까 말한 전, 후, alternative 방향성과 똑같이 작동한다.

ex) a반이 b반보다 크다. ttest_ind(A, B, alternative='greater')

앞서본 단일표본, 대응표본검정은 정규성 만족만 봤다면, 독립표본검정은 정규성과 등분산성 이 두개를 봐야한다.

정규성만족은 shapiro(A), shapiro(B)를 보면 되고

등분산검정은 levene(A, B) 이라는 함수를 사용하면 된다. pvalue가 0.05 이하면 등분산이 아니다.

먼저 등분산이 아닌 경우부터 보자. 등분산이 아닌건 그냥 ttest_ind에 equal_var=False라는 옵션을 더해주면 된다.

ttest_ind(A, B, alternative=, equal_var=False)

그리고 정규성을 만족하지 않는다면, manwhitneyu() 만 휘트니 유 검정을 써야한다. 마찬가지 stats에 있고 인자들은 ttest_ind와 동일하다.

2. 범주형데이터분석

2-1. 적합도 검정

조사한 데이터가 원래 알려진 확률분포에 잘 적합하는가?를 판별하는 녀석

기출6회 작업형3에 잘 정리되어있기에 문풀프로세스만 정리하자면

1. 로우데이터로 주어졌다면 일단 각 범주가 몇개씩 나왔는지 value_counts()함수를 이용해서 세어줘야 한다.

그리고 index순서대로 정렬해야 원래 알려진 확률분포 데이터랑 순서가 맞을테니

df.value_counts().sort_index()

2. 원래 알려진 확률분포 데이터로부터 기대빈도를 계산한다.

별거없다. 조사한 데이터의 개수 X 원래 알려진 확률분포(퍼센트) 곱해주면 된다.

expected = [total * percent for percent in origin]

3. chisquare(f_obs=, f_exp=) 함수에 넣어준다!

chisquare(f_obs= , f_exp=) 각각 조사한 데이터, 기대빈도 데이터를 넣어주면 된다.

2-2. 독립성/동질성 검정

독립성/동질성 검정은 두 변수간 영향이 있는지 없는지를 보는건데 정확히는

독립성 검정: 두 변수 서로 독립?

동질성 검정: 두 집단에서 두 변수의 분포 서로 같음?

이거다. 사실 같은 방법으로 풀면 되기에 문제에서 두 변수가 어쩌고~ 하면 무조건 독립/동질성 검정이다.

아까 적합도 검정에서는 chisquare()함수를 썼지만 독립성, 동질성 검정에서는 chi2_contingency()를 써야한다.

이 chi2_contingency() 함수는 어떤 2차원 테이블을 넣었을 때 행과 열의 독립성을 검정해준다.

마찬가지 stats에 있고 chi2_contingency(table)

이 문제에서는 table을 바로 주지 않고 로우데이터로 주는 경우가 있는데, 우리가 직접 2차원 테이블을 만들어서 써야한다.

동질성 검사의 경우, 두 집단에서 변수의 분포가 서로 같은지를 물어볼텐데

집단 종류를 행으로, 변수를 열으로 해서 2차원 리스트형태로 테이블을 직접 만들어줘야 한다.

suwon = ['a', 'a', 'b', 'a', 'b']
busan = ['b', 'b', 'a', 'b', 'a']

# 각 집단에서 a와 b의 빈도수를 직접 세어서 2차원 리스트로
# [[수원의 a개수, 수원의 b개수], [부산의 a개수, 부산의 b개수]]
table = [
    [suwon.count('a'), suwon.count('b')],  # 수원 행
    [busan.count('a'), busan.count('b')]   # 부산 행
]

반면 독립성 검사의 경우 한 집단에서 두 변수 간 독립성을 묻기에

region = ['수원', '수원', '수원', '수원', '수원', '부산', '부산', '부산', '부산', '부산']
product = ['a', 'a', 'b', 'a', 'b', 'b', 'b', 'a', 'b', 'a']

# 변환 없이 바로 crosstab에 넣기
table = pd.crosstab(region, product)

pd.crosstab()함수에 두 변수를 때려박아주면 알아서 테이블로 변환해준다. 판다스에 있다는 것을 꼭 기억할 것.

두 경우 모두 테이블로 만들고 내가 생각하던 모양으로 테이블이 만들어졌는지 확인해보고 chi2_contingency() 돌리자!

3. 회귀분석

3-1. 상관관계, 상관계수

df.corr() 으로 모든 변수들간 상관계수를 볼 수 있다.

만약 키에 대한 몸무게의 상관변수를 알고 싶으면 df['키'].corr(df['몸무게']) 하면 된다.

그리고 문제에서 피어슨 상관계수를 구하라, 켄달타우 상관계수를 구하라 하는데 그런 경우에는 corr의 옵션으로 methoc='spearman', method='kendall' 을 넣어줄 수도 있지만

상관계수를 구하고 pvalue까지 구하는 경우가 많기에 아래 세 녀석을 꼭 외워줘야한다.

마찬가지 scipy.stats 모듈에 있으며

pearsonr(df키, df몸무게)

spearmanr(df키, df몸무게)

kendalltau(df키, df몸무게)

특히 피어슨이랑 스피어만의 경우 맨 뒤에 r이 붙어있다는 것을 명심하자. 이 세 함수는 상관계수뿐 아니라 pvalue까지 준다.

3-2. 선형회귀분석

최소제곱법으로 회귀: ols

로지스틱회귀: logit

이 두개만 나오는 것 같다.

from statsmodels.formula.api import logit, ols

이 두개 중 문제에서 말한 것을 이용해

model = logit('Y~X1+X2', data=df).fit()

하면 된다. 이건 너무 많이 해서 더 볼 필요도 없다.

+ 선형회귀분석해야하는데 만약 범주형변수가 있더라도 상관없다. statsmodels 내부에서 알아서 인코딩됨

3-3. 문제에서 묻는 것

MSE, RMSE, 신뢰구간, 예측구간, 회귀계수, 모델의 pvalue 등을 묻거나 또는 새로운 데이터를 주고 적합한 모델으로 예측해보라고 한다.

꼭 새로운 데이터를 안줘도 원래 데이터들을 가지고 y값을 예측하고 실제 y값과의 mse를 예측하라고 하기도 한다.

예측하는건 너무 당연히 pred = model.predict(df) 이고

MSE는 model.squared 또는

from sklearn.metrics import mean_squared_error 으로 구할 수 있고

RMSE는 model.rsquared 또는
from sklearn.metrics import root_mean_squared_error 으로 구할 수 있다.

답지가 항상 먼저, 그다음 예측데이터를 인자로 넘긴다는 점에 유의해야한다.

신뢰구간 예측구간

pred = model.get_prediction(data)
pred.summary_frame(alpha=0.05)

이 두개를 못외우면 그냥 틀려야 하는 문제다. 제발 외워...

순서대로 mean이 예측값, 신뢰구간 하한 상한, 예측구간 하한 상한

회귀계수, 모델의 pvalue등도 있는데 이건

model.summary

model.params

model.pvalue

이 세 함수를 외워두자.

4. 분산분석

3개 이상의 집단의 평균을 비교할 때 쓴다.

4-1. 일원분산분석

평균에 영향을 주는 원인이 딱 1개일때, 3개이상의 집단에 대해서

ex) 치킨브랜드에 따라 치킨만족도에 차이가 있는가?

from scipy.stats import f_oneway

f_oneway(A, B, C)

이렇게 f_oneway() 함수를 쓰면 가장 편하고

from statsmodels.stats.anova import anova_lm

# 참고로 치킨브랜드는 한컬럼이지만 내부적으로 인코딩돼서 여러 변수가 될 것

# 범주형변수인데 숫자라면 C(치킨브랜드) 로 적어줘서 범주형변수임을 알려줄 것

model = ols('치킨만족도~치킨브랜드', data=df).fit()

anova_table = anova_lm(model) 하는 방법도 있다. 두가지 다 알아놓기.

4-2. 이원분산분석

평균에 영향을 주는 요인이 2개일때, 3개이상의 집단에 대해서

ex) 치킨브랜드와 성별에 따라 치킨만족도에 차이가 있는가?

아까는 싸이파이 stats의 f_oneway써서 쉽게 했다면 이번엔 어떤 요인인지 적어줘야 하니까 ols 밖에 못쓴다.

그리고 치킨브랜드와 성별의 상호작용효과도 이번엔 고려해야한다. 그래서 꼭 + 대신 *를 적어줘야 한다. 그냥 외우자.

4-3. 사후검정

아까 anova검정했을 때 pvalue가 0.05보다 작게 나왔을 때, 어떤 집단의 평균이 다른건지 알아내는 검정

ex) 치킨브랜드에 따라 치킨만족도 차이가 있다고 나왔을 때, 굽네가 BBQ보다 선호도가 높은건지, 굽네가 BHC보다 선호도가 높은건지 알아내는 검정

투키랑 본페로니를 외워야한다.

1. 투키

from statsmodels.stats.multicomp import pairwise_tukeyhsd, MultiComparison

tukey_result = pairwise_tukeyhsd(결과컬럼, 원인컬럼, alpha=)

2. 본페로니

mc = MultiComparison(결과컬럼, 원인컬럼)

bon_result = mc.allpairtest(stats.ttest_ind, method = 'bonf')

여기 결과컬럼 원인컬럼으로 쓴 것은 df를 melt()해서 세로로 길게 만들어서 넣어줘야 한다.

교촌	굽네	네네	처갓집

뭐 이런식이였다면

df.melt()를 해서

variable	value
교촌
굽네
네네
처갓집
네네
처갓집
교촌

이런식으로 만들어주고 원인컬럼 df['variable'] 결과컬럼 df['value'] 넣어주는 것

4-4. 이제 진짜 마지막으로 분산분석에서 정규성과 등분산성이 지켜지지 않았다면(샤피로, 레닌 해봤겠지)

kruskal() 에 때려넣으면 된다. 모든 검정들은 거의 scipy.stats에 있고 이녀석도 마찬가지이다.

stats.kruskal(df['A'], df['B'] , df['C'])

기출풀이

_jju — Thu, 18 Jun 2026 06:23:18 +0900

다시 풀어볼 문제 목록

기출9회 작업형1 모든 문제
기출8회 작업형1의 3
기출6회 작업형3

다시 공부해야할 문제 목록

오즈비 관련 문제
표 행과 열 바꿔서 푸는 기출9회 작업형1같은 문제들

9회

작업형1

1. df에 총대출액 컬럼을 하나 만든 뒤 신용대출과 담보대출의 합을 넣음

2. 지역코드랑 성별으로 groupby하고 총 대출액 컬럼에 sum()

3. 성별 간 총대출액 차이가 가장 큰 지역코드를 찾으려면,

지역코드와 성별별로 총대출액의 합계를 계산한 테이블에 unstack() 함수를 일단 씌워야한다.

이건 unstack() 함수 씌우기 전, 인덱스가 두개인 모습

그리고 언스택 함수를 씌우면

이렇게 성별이 컬럼으로 펼쳐지게 된다.

unstack() 함수를 이용해서 현재는 인덱스 자리에 있는 것을 위에 컬럼으로 펼칠 수 있고, 여러번 언스택함에 따라서 결과가 달라지니까 작동 원리 몰라도 계속 해보면서 내가 원하는 모양 찾으면 된다.

연도를 기준으로, 발생건수/검거건수 숫자를 갖고 표를 만들어야 하는 문제이다.

아까 문제1도 지역번호를 기준으로, 남/녀 숫자를 갖고 표를 만드는 문제였다.

이런 경우 발생건수, 검거건수 따로 2개의 데이터프레임을 만들어주면 편하다.

이렇게 발생건수에 대해서 데이터프레임을 만들어주고 강력범죄~기타범죄 중 가장 큰 값을 뽑아내야한다.

원래 우리가 사용하는 max()함수는 한 컬럼을 선택해서 보통 많이 해줬다. df['x'].max()

하지만 이번엔 가로줄중에서 가장 큰 값을 선택해야하는 상황이기에, axis=1을 넣어줘야한다.

근속연수의 결측치를 동일한 부서 및 성과등급에 해당하는 직원들의 평균 근속연수로 대체해야하는데, 여기서의 문제점은 저 두개에 대해서 groupby를 해서 평균값을 구하고 보면 fillna에 넣어주기에는 데이터의 생김새가 전혀 달라진다는거다.

이렇게 되어버린다. 우리는 이런 경우 항시 transform()함수를 통해 그 컬럼의 개수만큼되는 값으로 채워줄 수가 있다!!!

제발 groupby해서 결측치 채울땐 transfrom('mean') 함수를 기억하자

작업형3

from sklearn.metrics import root_mean_squared_error
mse = root_mean_squared_error(test['design'], pred)

rmse 함수가 새버전에 추가되었기에 sqrt함수를 씌워주거나 옵션지정할 필요없이 저 함수를 갖다쓰면 된다.

8회

작업형1

문제3

from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
df['co'] = scaler.fit_transform(df[['co']])
df['nmhc'] = scaler.fit_transform(df[['nmhc']])

문제에서 min-max 스케일링을 요구했다.

min-max스케일링: (X - min_X) / (max_X - min_X)

이 식을 못외웠다면 위와 같이 sklearn의 preprocessing(전처리) 안에 있는 MinMaxScaler을 가져와서 쓰면 된다.

여기서 스케일러는 무조건

scaler = MinMaxScaler()

이렇게 객체를 생성해서 써야하고

df['co'] = scaler.fit_transform(df[['co']])

df['nmhc'] = scaler.fit_transform(df[['nmhc']])

사이킷런 스케일러는 2차원형태의 데이터만 받도록 되어있기에 대괄호 두번 써서 데이터프레임형태로 전달해야한다!

7회

작업형1

문제1

결측치가 있는 행을 제거한 후, 학생이 가장 많이 수강한 과목(id_assessment)을 찾고, 해당 과목 점수(score)를 표준화(스탠다스 스케일) 한 뒤에 표준화된 가장 큰 값을 구하시오. (반올림하여 소수 셋째자리까지 계산)

스케일링할 때 주의해야할 점: 스케일링할 때는 어떤 집단을 표준화할 것인지를 잘 생각해야한다.

전체에 대해서 표준화하는 것과 부분부분들에 대해서 표준화하는 것 다 답이 다르게 나타날 것이다. 이건 식을 생각해보면 너무 당연한거다... 이 문제는 조건에 맞는 녀석들을 표준화한 후 최대값을 구하는 문제이다.

작업형3

이 모델 summary에서 외워야할 녀석들이 몇몇 있다.

Log-Likelihood: 잔차 이탈도

LL-Null: Null 로그 우도

coef: 회귀 계수

P>|z|: p-value, 유의확률

문제 1-3에서 모델로 예측값 구한 뒤 오류율을 구하라는 문제가 나오는데,

오류율 = 1 - 정확도

이기에 accuracy_score을 구해서 1에서 빼주면 구할 수 있다.

6회

작업형1

total_seconds 쓸때 제발제발 앞에 dt붙여!!!

시리즈.dt.total_seconds() 제발!

작업형3

문제1

카이제곱 검정을 하는 두가지 경우가

1. 적합도 검정

내가 조사한 데이터가 기존에 알려진 확률분포에 잘 적합하는지

2. 독립성 검정(동질성 검정)

변수간 얼마나 연관이 있는지

Q1. 항암약 위약을 투여 받은 환자의 부작용은 감기약 위약을 투여 받은 환자의 부작용 분포와 차이가 있는가?

이 문제를 보면 딱봐도 카이제곱검정의 적합도 검정 문제구나 알아야한다.

먼저 적합도 검정 프로세스는 이러하다.

1. 로우데이터로 주어져있다면, 일단 각 범주가 실제로 몇개씩 나왔는지 세어줘야 한다.

import pandas as pd
df = pd.DataFrame({ "항암약":[4,4,3,4,1,4,1,4,1,4,4,2,1,4,2,3,2,4,4,4] })
# 1: '아픔', 2: '조금 아픔', 3: '속쓰림', 4: '무증상'

# 일단 이 raw데이터를 갖고 각 범주가 실제로 몇개씩 나왔는지 세어줘야함
df.value_counts().sort_index()

이런식이다. value_counts()로 값을 세어주고 sort_index()를 해줘야 비교할 데이터와 표 순서가 같아지기에 첨부터 정렬을 해주는게 편하다.

2. 원래 알려진 비율대로라면 기대되는 기대빈도를 계산한다.

# 1. 아픔: 10%

# 2. 조금 아픔 5%

# 3. 속 쓰림 15%

# 4. 무증상: 70%

이렇게 알려진 비율이 있으면

total = df['항암약'].count()
ex_ratio = [0.1, 0.05, 0.15, 0,7]
expected = [total * ratio for ratio in ex_ratio]

이렇게 기대빈도를 구해준다. 막줄처럼 리스트안에 for문 바로 적어주면 한줄에 끝나지만 도저히 기억안나면 하나하나 곱해주거나 여러줄에 for문 돌려서 리스트에 넣어줘도 된다.

그리고 싸이파이에 있는 chisquare() 돌려주면 된다.

from scipy.stats import chisquare
chisquare(f_obs=observed, f_exp=expected)

+ 참고로 카이제곱 사용하는게 1. 적합성 검사, 2. 독립성/동질성 검사라고 했는데 둘다 카이제곱을 쓰는건 맞지만 쓰는 함수가 다르다. 이번 문제처럼 적합성 검사의 경우에는 chisquare을 쓰지만 두 변수의 독립성, 동질성 검사에서 쓰는 카이제곱함수는 chi2_contingency()이다.

문제2

데이터에서 'solar'와 'o3' 값을 고정한 상태에서, 'wind'의 세기가 증가함에 따라 'temperature'가 감소하는지를 검증하기 위해 다중 선형 회귀 분석을 수행하고, 이 때'wind'의 회귀 계수에 대한 p-value 값을 구하시오. (유의수준: 0.05)

고정한 상태에서 구하라길래 쫄았지만 그냥 서로간의 상호작용효과를 고려하지 않는다는 뜻이다. wind의 세기가 증가해서 temperature값이 달라지는건 solar와 o3값이 함께 변했기 때문이 아니라는 것이기 때문. 그래서 그냥 +로 묶어서 ols돌려서 풀면 되는 문제다.

solar:100, wind:5, o3:30일 때 예측값과 그에 대한 95% 신뢰구간을 구하시오.

데이터프레임 만들어서 예측하는 것까진 무난하게 할 수 있다. 다만 신뢰구간을 구하는게 문젠데, 이럴 땐 제발

get_prediction() 이라는 함수를 사용해야한다. 그리고 summary_frame()이라는 함수까지 세트로 알아둬야한다. 이 두개를 모르고 못쓰면 그냥 틀려야 하는 문제다.

# solar:100, wind:5, o3:30일 때 예측값과 그에 대한 95% 신뢰구간을 구하시오.
new_data = pd.DataFrame({'solar': [100], 'wind': [5], 'o3': [30]})
pred = model.get_prediction(new_data)
pred.summary_frame(alpha=0.05)

mean값이 예측값이고 mean_ci가 신뢰구간 하한 상한, obs_ci가 예측구간 하한 상한이다.

작업형3 추가적으로

_jju — Sun, 14 Jun 2026 22:03:34 +0900

로지스틱 회귀, 오즈비

from statsmodels.formula.api import logit

ols와 같은 statsmodels.formula.api에 있다.

기출에서는 로지스틱회귀와 함께 오즈비도 물어봤었는데,

독립변수 여럿에 대해서 y를 예측했다고 하자. 한 독립변수가 y에 미친 영향에 대해서 오즈비를 구하라는 문제가 나오면

import numpy as np

np.exp(model.params[''])

이렇게 넘파이의 exp를 써주면 오즈비를 구할 수 있다.

작업형2 문풀

_jju — Sun, 14 Jun 2026 02:45:05 +0900

컬럼이 너무 많아서 직접 고를 수 없을 경우

select_dtypes(include=['', ''])

이 함수를 이용해서 인코딩 필요없는 숫자 컬럼들만 가져오거나

아니면 unique값 너무 높은 + 결측치값 너무 많은 컬럼만 drop하고 쓰기

타겟이 너무 치우쳐 있는 경우 (분류ㄴㄴ 회귀에서)(이건 고급 내용...)

타겟이 너무 치우쳐있으면 로그변환을 해줘야하는데

1. 타겟이 치우쳐있는지 어떻게 알아?

왜도(skewness) 를 보면된다.

print(y_train['charges'].skew())

이렇게 데이터의 왜도를 출력해봤을 때

1이상이면 로그변환을 해줘야한다고 생각하면 된다.

2. 로그변환은 언제 어떻게 해?

y_train['charges'] = np.log1p(y_train['charges'])

넘파이의 log1p()를 기억하자.

3. 모델으로 다 예측하고 가장 score 좋게 받은 모델 선정까지 다 끝낸다음, 꼭!!! 원래 스케일로 돌려주고 제출해야한다!!!

np.log1p() 함수로 로그변환했다면 무조건 np.expm1()함수로 돌려줄 수 있다.

예측값을 expm1()함수로 꼭 돌려주자.

작업형 제1유형 헷갈리는 내용 정리

_jju — Wed, 10 Jun 2026 22:16:56 +0900

IQR을 활용한 이상치 찾기

# pandas 활용
Q1 = df[col].quantile(.25)
Q3 = df[col].quantile(.75)

# numpy 활용
Q1 = np.percentile(df[col], 25)
Q3 = np.percentile(df[col], 75)

Q1 - IQR*1.5 보다 작거나

Q3 + IQR*1.5 보다 크면 이상치로 판단(포함x)

올림, 내림, 절사

import numpy as np
올림: np.ceil()
내림: np.floor()
버림: np.trunc()

groupby와 map, transform

# city별 중앙값으로 대체
# 인덱스 안맞을 때 transform으로 해결하는 방법
medi_seri = df['f1'].groupby(df['city']).transform('median')
df['f1'].fillna(medi_seri)

# city별 중앙값으로 대체
# 인덱스 안맞을 때 map으로 해결하는 방법
medi_seri = df['f1'].groupby(df['city']).median()
df['f1'].fillna(df['city'].map(medi_seri))

왜도와 첨도, 로그변환

왜도: 분포의 비대칭 정도
첨도: 꼬리의 두꺼운 정도

# 왜도구하기
df(['']).skew()

# 첨도구하기
df(['']).kurt()

로그스케일링으로 변환하는 방법

df['SalePrice'] = np.log1p(df['SalePrice'])

넘파이에 log1p가 있다는 것을 기억할 것

파이썬의 조건식

파이썬에서 조건식 만들 때는 절대 and나 or 사용하지 말것

반환되는게 true/false값이 들어있는 series 형태로 반환되는거지 단일 불리언 값으로 반환되는게 아니기에 영문자 and, or 쓰면 에러가 난다

-> 무조건 괄호 묶고 &나 |나 ~ 쓰기!

한 칼럼의 결측치가 있는 행을 지우는 방법

# 내가 푼 방법
cond = df['f1'].isna()
df = df.drop(df[cond].index)

# 더 쉬운 방법 2개
df = df.dropna(subset=['f1'])

df = df[df['f1'].notna()] # notna는 isna의 반대함수로 널이 아닌 값들만 모으는 함수

groupby...

result = df.groupby(['city', 'f2'])['f1'].sum()

df에 대해서 그룹으로 먼저 묶고, f1칼럼의 값을 sum하는 아주 합리적인 흐름!!!

조건에 맞는 값을 변경할 때

제발 loc을 써라 loc[조건, '컬럼명']으로 쓰기도 하고 loc[행인덱스, 컬럼인덱스] 이런식으로 쓰기도 하고...

df[cond]['f4'] = 'INFJ'
# 위와 같이 하면 절대 안된다!! 임시객체를 수정하는거지 df는 수정이 안되는 것

# 값을 수정한다는 말이 나오면 무조건 무조건 loc을 떠올리자
# df.loc[조건, '컬럼명'] = 값
df.loc[cond, 'f4'] = 'INFJ'

누적합과 결측치 앞뒤 값으로 채우는 방법

누적합 구하는 함수: cumsum()

결측치를 뒤에 나오는 값으로 채울 때: df.fillna(method = 'bfill')

결측치를 이전값으로 채울 때: df.fillna(method = 'pad')

수치형변수 표준화

표준화하는 식이

이거니까 컬럼의 평균과 표준편차를 구해서 빼고 나눠서 z-score값을 구해도 된다. 하지만 sklearn의 preprocessing의 StandardScaler를 사용할 수도 있다는 점!

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
df['f5'] = scaler.fit_transform(df[['f5']])

sklearn의 함수들에 넣는 데이터는 항상 2차원이여야 하기에, 한줄짜리 series를 넣고싶어도 꼭 대괄호 두개를 써서 데이터프레임 형태로 써야한다.

그리고 fit만 하면 그 컬럼의 평균과 표준편차를 저장하기만 한다. 무조건 fit_transform을 통해 변환한 값을 반환해야한다.

MinMaxScaler

마찬가지 sklearn의 preprocessing 안에 있다. MinMaxScaler()이라는 스케일러를 사용하여 fit_transform() 하면 된다.

이렇게 구하는 방법 말고 두번째 방법으로는

# min-max scale 방법2
df['f5_2'] = df['f5'].transform(lambda x: ((x - x.min()) / (x.max() - x.min())))

위의 모듈이 생각나지 않는다면 방법2처럼 직접 minmax스케일링 식에 넣어도 된다. x에서 최소값 뺀거/최대값에서 최소값 뺀거

이게 민맥스 스케일링이다. 참고로 transform(함수)는 이 함수에 값을 넣은 결과값을 같은 길이로 반환하는 함수다.

분위수

quantile(0.05)

정렬

정렬은 sort_values(by='컬럼명')

상위n개 하위n개 뽑기

df['a'].nlargest(10)

df['a'].nsmallest(10)

이렇게 할 수도 있고

정렬된 상태라면

df['a'].head(10)

df['a'].tail(10)

이렇게 뽑기도 가능

건너뛴 문제

10번 Yeo-Johnson & Box-Cox
20번 데이터병합
21번 Binning Data
24번 Lagged Feature
28번

시계열데이터 년 월 일

df['Date'] = pd.to_datetime(df['Date'])
df['year'] = df['Date'].dt.year
df['month'] = df['Date'].dt.month
df['day'] = df['Date'].dt.day

일단 pd.to_datetime 함수를 이용해서 datetime형으로 변환해주면,

dt.year

dt.month

dt.day

이렇게 분리해낼 수 있다.

이건 함수아니니까 괄호하지마

그리고 to_datetime()으로 형변환할때 판다스꺼니까 pd 붙이는거 제발 절대 까먹지마라

df['date'] = pd.to_datetime(df['date'], format='%Y%m%d')

format 옵션도 기억해야하고

이 to_datetime() 함수는 str데이터에 대해서 적용되는거니까 string으로 형변환하고 해주고 쓰거나 정수형이면 format함수 쓰거나

시계열데이터 무슨요일?

dt.dayofweek
dt.weekday

월요일0~일요일6 으로 매핑

마찬가지 함수 아니니까 괄호하지마

시계열데이터 몇주차?

몇주찬지 알아보려면 앞에서 본 것 처럼

dt.week

를 쓸 수도 있다. 하지만 여러해의 데이터가 같이 있다면, 22년도 1주차와 23년도 1주차가 같은 week값을 가진다.

주별 통계값을 구하는 중인데 여러해의 데이터가 같이 있다면 groupby(['year', 'week']) 이런식으로 년도도 꼭 묶어주도록 하자.

두번째 방법으로,

인덱스가 시계열데이터인 경우 쓸 수 있는

df_w = df.resample('W').sum()

이 resample()이라는 함수도 있다.

만약 인덱스가 아니라 컬럼에 날짜데이터가 있다면, resample('W', on='Date') 이런식으로 on 옵션에 컬럼이름을 넣어주면 된다.

주 단위 W
2주 단위 2W
월 단위 M

중복제거

df = df.drop_duplicates(subset=['age'])

drop_duplicates(subset=) 외우자!

도저히 생각안날땐 코딩을 하자..

# age 컬럼 중복 제거
x = 0
idx = 1
for y in df.loc[1:,'age']:
    if y == df.loc[x, 'age']:
        df = df.drop(idx)
        idx += 1
    else:
        idx += 1

for문에서 인덱스까지 같이 반환하는 함수 enumerate()마저 또 까먹어서 idx 변수 만들어서 함...

문자열 다루기

컬럼이 string 타입이 아닐 때 -> astype(str)

startswith()

endswith()

contains()

얘네로 문자열을 다루는데, 시리즈.startswith() 이렇게 쓰면 에러가 난다.

이 함수들은 시리즈가 아니라 오직 str에 대해서만 작동하기에

df['f1'].str.startswith()

이런식으로 꼭 .str을 붙여주어야 한다!

그리고 replace(): 앞 인수를 뒤의 인수로 바꾸기

df['menu'].str.replace(' ','')

이렇게 하면 공백이 사라지겠지

빅분기 실기 작업형2 정리

_jju — Sun, 17 May 2026 14:27:25 +0900

빅데이터분석기사 실기 작업형2 문제는 데이터셋이 csv파일로 주어지고, 데이터 전처리하고, 모델 학습시키고 하이퍼 파라미터 튜닝 등 해서 test데이터에 대해 예측값 생성하고 파일로 저장하는 머신러닝 문제이다. 여기서 전처리를 어떻게 하냐에 따라서, 어떤 모델을 선택하냐에 따라서, 하이퍼파라미터튜닝을 어떻게 하냐에 따라서 예측 성능이 달라지는데 이 예측 성능에 따라 점수를 매긴다고 한다.

졸업작품.. 넥스원 산학협력 과제... 이런거 할 때 항상 파이썬으로 했어서 모델학습 코드가 익숙하긴 하지만 이제 모든 라이브러리랑 함수를 다 외워서 써야해!

먼저 대략적으로 순서를 읊어보자면,

EDA (탐색적데이터분석)
데이터전처리, 피처엔지니어링
결측치, 이상치 처리
인코딩
스케일링
검증데이터 분리
모델학습
모델평가
가장 좋은 결과를 내는 모델을 찾을 때까지 4, 5번 반복
그 모델로 test집합 예측, csv파일로 만들기

이렇게 되겠다.

1st. EDA (탐색적데이터분석)

이 단계에서 하는건 말그대로 데이터를 분석하는 것이다. 칼럼의 수는 몇개인지, 데이터의 크기가 어떤지, 데이터 타입은 어떻게 되는지, 결측치가 있는지, 이상치가 있는지 등을 파악해야 데이터 전처리 단계에서 뭘할지 정할 수 있기 때문이다.

# 데이터의 상위 5개 행을 출력해서 실제 데이터 형태 확인
train.head()

# 컬럼명, 데이터 타입, 결측치 개수 등 전체 구조 확인
train.info()

# 숫자형 컬럼들의 기초 통계량(평균, 표준편차, 최소/최대값 등) 확인
train.describe()
# 문자형 컬럼들의 데이터 통계 확인
train.describe(include="O")

# 각 컬럼별 결측치(NaN) 개수 확인
train.isnull().sum()
train.isna().sum()

# 특정 컬럼의 값들이 각각 몇 개씩 존재하는지 확인
train['컬럼명'].value_counts()

위의 함수들로 데이터 분석을 진행할 수 있다.

이 단계에서 판단할 수 있는 것은,

타겟에 영향을 안미치는 쓸데 없는 칼럼(예를 들어 뭐 회원ID라든가)이 있네? -> drop해야겠다.
unique값이 너무 커서 거의 count에 준하네? -> drop해야겠다.
문자형 데이터인데 unique값이 꽤 크네? -> 원핫인코딩하면 칼럼 너무 많아지겠다. 라벨인코딩 해야겠다.
결측치, 이상치가 있네? -> 얘네 처리해야겠다.
스케일링 해줘야 할 변수가 있는데 최대값 혹은 최솟값이 이상치라서 다른 값들이랑 너무 큰 차이가 나네? -> MinMaxScaler로 스케일링하면 일반적인 값들이 0.00023 이런식으로 너무 작아지거나 0.9998 이런식으로 너무 커지게 되니까 Standard Scaler 사용해야겠다.

이정도가 되겠다.

2nd. 데이터 전처리 및 피처 엔지니어링

모델을 학습시킬 train데이터도, 모델에 넣어볼 test데이터도 모두 전처리 해줘야한다.

전처리가 끝나고나면 train데이터의 결측치, test데이터읙 결측치가 모두 채워져있어야 하고 칼럼의 변동이 있었다면 test에서도 같은 변동이 있어야 했을 것!

1. 필요없는 칼럼 삭제

# 1. 제출에 필요하다면 없애기 전에 따로 저장해놔야 한다.
test_id = X_test['ID']

# 2. axis 안적으면 행에서 찾게 된다. 적어서 칼럼임을 명시!
X_train = X_train.drop('ID', axis=1)
X_test = X_test.drop('ID', axis=1)

2. 결측치 처리

# 수치형 변수의 결측치를 중앙값으로 대체
# train의 중앙값으로 test까지 채워야 함!!!!!!!
median_val = X_train['수치형컬럼'].median()
X_train['수치형컬럼'] = X_train['수치형컬럼'].fillna(median_val)
X_test['수치형컬럼'] = X_test['수치형컬럼'].fillna(median_val)

# 범주형 변수의 결측치를 최빈값으로 대체
mode_val = X_train['범주형컬럼'].mode()[0]
X_train['범주형컬럼'] = X_train['범주형컬럼'].fillna(mode_val)
X_test['범주형컬럼'] = X_test['범주형컬럼'].fillna(mode_val)

물론 수치형을 중앙값 말고 최빈값으로 채울 수도 있고 평균값으로 채울 수도 있다. 크게 달라지지 않을 것 같지만 mode, mean으로 바꿔서 다시 학습시켜보고 최적의 경우를 제출하는게 좋긴하겠다.

mode() 함수는 시리즈를 뱉는다. 시리즈 형태를 그대로 fillna에 넣게 되면 두 시리즈의 인덱스를 맞춰서 넣도록 동작하게 된다. 우리가 원하는건 그냥 str을 null자리에 넣는 것이기에, str형태로 만들어주기 위해서 mode()[0]를 붙이는 것!!!

그리고 절대 test의 데이터로 test의 데이터를 전처리 하면 안된다!!! train의 데이터로 test를 전처리해야한다. 모델은 train의 데이터로 학습하고 예측하기에, test데이터의 결측치가 train데이터의 결측치와 같은 값으로 채워져있어야 모델이 학습된 값을 뱉게 된다.

# train데이터에만 이상치가 약간 있고 test데이터에는 이상치가 없는 경우
# train데이터에서 몇개 행은 버린다 생각하고 drop해도 된다!

train = train.dropna()

train데이터에만 이상치가 몇개 있고 test데이터에는 없을 경우에는, train데이터에서 결측치 있는 몇개 행은 그냥 학습에 포함 안시키고 버린다 생각하고 drop해도 된다. 하지만 절대 test데이터는 1개의 행도 드롭하면 안된다!!!!! 얘를 예측해야하니까!!!!!

3. 이상치 처리

# clip(): 0보다 작으면 0으로, 100보다 크면 100으로 강제 고정
X_train['Age'] = X_train['Age'].clip(0, 100)
X_test['Age'] = X_test['Age'].clip(0, 100)

클립함수를 외워두자.

4. 문자열 변수(범주형 변수) 인코딩

인코딩 방법은 두개를 알아두자. 하나는 라벨인코딩, 하나는 원핫인코딩

# 라벨 인코딩
from sklearn.preprocessing import LabelEncoder

cat_cols = ['문자열컬럼1', '문자열컬럼2']

for col in cat_cols:
    le = LabelEncoder()
    # train과 test의 문자열을 모두 커버하기 위해 train 기준 학습(fit)후 적용(transform)
    X_train[col] = le.fit_transform(X_train[col])
    X_test[col] = le.transform(X_test[col])

# 원-핫 인코딩
# 자동으로 object 타입만 찾아서 0과 1의 열로 쪼개줌, 너무 편하긴 함
X_train = pd.get_dummies(X_train)
X_test = pd.get_dummies(X_test)

원핫 인코딩은 get_dummies()로 알아서 문자형 변수 인코딩해줘서 편하긴 한데

unique값 클 경우에는 칼럼수 너무 많아지는 사태가 발생돼서 아무래도 라벨인코딩이 더 추천되긴 한다.

라벨인코딩은 문자열컬럼 내가 직접 지정해서 반복문 돌려야 한다. train기준으로 학습시킨 라벨링은 test에 적용해야하니까 제발 fit_transform()함수는 오직 train에만! test에는 transform()함수만!

5. 스케일링

사실 작업형2에선 거의 트리모델(랜덤포레스트나 XGBoost, LightGBM)만 쓰기 때문에 굳이 스케일링이 필요가 없다. 다만 로지스틱 회귀같은 선형모델이나 KNN같은 거리기반모델 같은걸 쓰게 되면 숫자가 큰 컬럼에 과하게 치중돼서 학습되기 때문에 스케일링이 필수적이겠다. 일단 어떻게 하는지만 보고 지나가자. 작업형1이나 3에 나올 수도 있다.

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()

# 주의: 수치형 컬럼들만 묶어서 스케일링 진행
num_cols = ['수치형컬럼1', '수치형컬럼2']

# train 데이터로 fit 및 transform, test 데이터는 transform만!
X_train[num_cols] = scaler.fit_transform(X_train[num_cols])
X_test[num_cols] = scaler.transform(X_test[num_cols])

스케일러의 경우 여러칼럼을 동시에 계산할 수 있게 만들어져서 라벨인코더랑 다르게 num_cols 시리즈 넣어도 된다. 라벨인코더는 너무 귀찮지만 반복문 돌려야 한다...

3rd. 검증데이터 분리

from sklearn.model_selection import train_test_split

X_tr, X_val, y_tr, y_val = train_test_split(train.drop('price', axis=1), train['price'],
                                            test_size=0.2, random_state=0)

train_test_split() 함수에서 첫번째 인자는 x_train, 두번째 인자는 정답 칼럼인 y_train, 세번째는 몇퍼센트를 검증집합으로 만들건지, random_state값은 지정해줘야 다른 모델로 바꿨을때도 같은 검증집합이 나온다.

그리고 불균형 데이터일 때는 이런식으로 stratify 옵션을 설정해줘야 한다.

target = train.pop('타겟 컬럼')

train_test_split(train,target, test_size=0.2, random_state=0, stratify=target)

4th. 모델 학습

분류모델은 Classification 사용! 회귀모델은 Regression 사용!

전부 트리 모델을 쓰면 된다.

랜덤포레스트

# Random Forest 모델 학습
from sklearn.ensemble import RandomForestClassifier

rf_model = RandomForestClassifier(random_state=0)
rf_model.fit(X_train, y_train)
y_pred = rf_model.predict(X_val)

n_estimators(나무개수) : 100이 기본값, 200, 300으로 설정할 수도 있지만 데이터 많을 경우에는 너무 느려짐

max_depth(트리깊이) : 3~12, 데이터 컬럼 수가 적을 때는 적게, 데이터 컬럼 수가 많을 때는 많게해서 깊이 학습

random_state

LightGBM

# LightGBM 모델 학습
from lightgbm import LGBMClassifier

lgbm_model = LGBMClassifier(random_state=42)
lgbm_model.fit(X_train, y_train)
y_pred = lgbm_model.predict(X_Val)

Decision Tree

# Decision Tree 모델 학습
from sklearn.tree import DecisionTreeClassifier

dt_model = DecisionTreeClassifier(random_state=0)
dt_model.fit(X_train, y_train)
y_pred = dt_model.predict(X_val)

XGBoost

# XGBoost 모델 학습
from xgboost import XGBClassifier

xgb_model = XGBClassifier(random_state=0)
xgb_model.fit(X_train, y_train)
y_pred = xgb_model.predict(X_val)

만약 회귀모델이라면 Classifier을 Regressor로 바꾸면 된다.

그리고 마찬가지로 불균형데이터라면 이 옵션을 모델에 넣어주도록 하자.

class_weight='balanced'

5th. 모델 평가

from sklearn.metrics import 함수이름

# 분류 평가 

# 정확도(Accuracy) 검증
# 전체 데이터 중 맞게 예측한 비율 확인
accuracy_score(y_valid, y_pred)

# 정밀도(Precision) 검증
# 모델이 1이라고 예측한 것 중 실제 1의 비율 확인
precision_score(y_valid, y_pred)

# 재현율(Recall) 검증
# 실제 1인 데이터 중 모델이 맞춘 비율 확인
recall_score(y_valid, y_pred)

# F1 Score 검증
# Precision과 Recall의 조화평균 확인
f1_score(y_valid, y_pred)

# ROC-AUC 검증
# 분류 모델의 전체적인 성능 평가 (1에 가까울수록 좋음)
roc_auc_score(y_valid, y_pred_proba)

# Confusion Matrix(혼동행렬) 확인
# 실제값과 예측값 비교 결과 확인
confusion_matrix(y_valid, y_pred)

# Classification Report 확인
# Precision, Recall, F1-score 등을 한 번에 확인
print(classification_report(y_valid, y_pred))

# 회귀 평가

# R-Squared(R²) 검증
# 회귀 모델이 데이터를 얼마나 잘 설명하는지 확인
r2_score(y_valid, y_pred)

# MAE(평균 절대 오차) 검증
# 예측값과 실제값 차이의 절대값 평균 확인
mean_absolute_error(y_valid, y_pred)

# MSE(평균 제곱 오차) 검증
# 오차를 제곱해서 평균낸 값 확인
mean_squared_error(y_valid, y_pred)

6th. 모델 바꿔가면서 값 제일 좋은 녀석 선택

7th. test집합 예측, csv파일로 만들기

pred = model.predict(test)
# 분류문제에서 roc_auc가 평가지표라면 predict_proba()[:, 1] 이용!

submit = pd.DataFrame({'pred':pred})
submit.to_csv("result.csv", index=False)

# pd.read_csv("result.csv")로 확인해보면 된다.

[알고리즘 고득점 kit/스택, 큐] 주식가격

_jju — Wed, 29 Apr 2026 21:02:52 +0900

def solution(prices):
    answer = []
    
    n = len(prices)
    for i in range(n):
        j = i
        while j < n -1:
            j += 1
            if prices[j] < prices[i]:
                break
        answer.append(j-i)
    return answer

입출력 예시에서 3초 지점 같은 경우, 3초 지점의 3은 바로 뒤에 2가 됐음에도 불구하고 1초간 가격이 떨어지지 않은걸로 본다. 따라서 배열크기만 안넘으면 무조건 j+=1해주고 다시 반복 돌릴지 break로 탈출할지 결정하면 된다.

시간 제한이 없었기에 위와 같은 이중 포문 시간복잡도 O(N제곱)의 ㅆㄹㄱ 코드로도 통과는 했지만, 만약 시간제한이 있었다 생각하고 풀어보자.

from collections import deque

def solution(prices):
    answer = [0 for i in range(len(prices))]
    stack = []
    n = len(prices)
    
    for i in range(n):
        if not stack:
            stack.append(i) # 인덱스를 넣어줘야 나중에 answer배열의 인덱스로 접근할 수 있음
        else:
            while stack and prices[stack[-1]] > prices[i]:
                answer[stack[-1]] = i - stack[-1]
                stack.pop()
            else:
                stack.append(i)
    size = len(prices)-1
    while stack:
        answer[stack[-1]] = size - stack[-1]
        stack.pop()
    
    return answer

배워가야할...

1. answer배열의 인덱스에 접근해서 넣어줘야 하기에 스택에 값 넣는게 아니라 인덱스 넣어주는거

2. 스택에 남아있는 값들 따로 처리하는거

3. 빈 배열 인덱스로 접근 못하기에 일단 answer배열 0으로 채워넣고 접근해야 하는 것

4. 그리고 제발 인덱스 오버하지말기, pop한 뒤엔 배열 비었는지 체크하고 접근하기

[알고리즘 고득점 kit/스택, 큐] 다리를 지나는 트럭

_jju — Wed, 29 Apr 2026 19:56:48 +0900

from collections import deque

def solution(bridge_length, weight, truck_weights):
    answer = 0
    dq = deque(0 for i in range(bridge_length))
    truck = deque(truck_weights)
    
    sum = 0
    t = 0
    result = []
    
    while result != truck_weights:
        n = dq.popleft()
        sum -= n
        result.append(n)
        if sum + truck[0] <= weight:
            sum += truck[0]
            dq.append(truck.popleft())
        else:
            dq.append(0)
        
    return answer

맨 앞에서 pop을 하고 그 값을 result에 넣어준 뒤, 맨 뒤에서 대기하고 있는 버스들을 넣어주는 방식으로 구현했다. result가 초기 대기열이랑 같아지면 멈추고 시간을 반환한다.

[알고리즘 고득점 kit/스택, 큐] 프로세스

_jju — Wed, 29 Apr 2026 18:20:31 +0900

from collections import deque

def solution(priorities, location):
    answer = 0
    q = deque(priorities)
    num = deque()
    for i in range(len(q)):
        num.append(i)
    
    pr = 0
    while q:
        i = 1
        size = len(q)
        while i < size and q[i] <= q[0]:
            i+=1
        if i != size: # 첫번째 원소보다 우선순위가 높은 녀석이 있었을 경우
            for _ in range(i):
                q.append(q.popleft())
                num.append(num.popleft())
        else:
            pr +=1
            if location == num[0]:
                return pr
            q.popleft()
            num.popleft()

첫번째 원소보다 우선순위가 높은게 있을 때와 없을 때로 나눠서

첫번째 원소보다 우선순위 높은게 뒷쪽에 있을 때는
그 우선순위가 더 높은녀석이 제일 첫번째로 오도록 반복문 돌려서 앞에서 빼고 뒤로 넣어줬고

첫번째 원소의 우선순위가 가장 높을 때는

그 첫번째 원소가 찾던 녀석이 맞는지를 확인하고 몇번째로 출력된건지 pr이라는 변수에 누적 저장해서 반환해줬다.

찾던 녀석이 맞는지 확인하기 위해서는 자신의 초기 위치를 기억할 num 배열이 필요하다고 생각했고 얘도 이름표처럼 똑같이 따라다니도록 하려면 덱으로 구성해서 똑같이 동작하도록 만들어줘야했다.

[알고리즘 고득점 kit/스택, 큐] 올바른 괄호

_jju — Wed, 29 Apr 2026 17:44:58 +0900

이건 백준에서 풀었던 문제!

누가봐도 스택을 사용하는 문제다. 아까 풀었던 문제처럼 또 deque를 이용해서 풀어보자.

from collections import deque

stack = deque()

def solution(s):
    ln = len(s)
    for i in range(ln):
        if s[i] == '(':
            stack.append(1)
        else:
            if stack:
                stack.pop()
            elif i ==0:
                return False
    if stack:
        return False
    return True

( 가 나타나면 스택에 값을 넣어주고 )가 나타나면 스택에서 빼주면 되는 문제다.

다만 elif 부분을 보면 알 수 있듯이 첫번째로 )가 나오면 무조건 틀린 것이기에 원래 코드에서 예외처리 해줘야 한다.