cd-record 님의 블로그

[스나이퍼팩토리] 한컴AI아카데미(26.06.24) KNN 알고리즘, GridSearchCV

cd-record — Wed, 24 Jun 2026 19:02:27 +0900

KNN 알고리즘

데이터로부터 거리가 가까운 'k'개의 다른 데이터의 레이블을 참조하여 분류하는 알고리즘 (지도학습)

핵심 원리

동작 방식: 새로운 데이터가 들어왔을 때, 기존에 학습된 데이터 중 가장 가까운 거리의 데이터 K개를 찾습니다.
분류(Classification): 가장 많이 뽑힌(다수결) 클래스로 새로운 데이터를 분류합니다.
회귀(Regression): 가장 가까운 K개 데이터들의 평균값을 새로운 데이터의 값으로 예측합니다.

K값에 따른 결과 변화

Case 1: K = 3 일 때

가장 가까운 3개를 찾았더니 [●, ●, ▲] 가 나왔습니다.

결과: 다수결에 따라 A그룹으로 분류합니다.

Case 2: K = 7 일 때

가장 가까운 7개를 찾았더니 [●, ●, ▲, ▲, ▲, ▲, ▲] 가 나왔습니다.

결과: 다수결에 따라 B그룹으로 분류합니다.

거리를 재는 방법 (시각화)

데이터들 사이의 거리를 계산할 때는 주로 유클리드 거리 공식 사용

* K의 개수는 짝수가 아닌 홀수로 하는 것이 좋다.

만약, K개가 짝수일 경우 아래와 같이 2:2 동점 상황이 만들어져서 A를 분류할 수 없는 경우가 발생할 수 있기 때문이다.

K-NN 알고리즘의 장/단점

장점	단점
단순하고 효율적이다.	모델을 생성하지 않아 특징과 클래스 간 관계를 이해하는 데 제한적이다.
기저 데이터 분포에 대한 가정을 하지 않는다. (기저 데이터: 특정 분석, 모델링, 또는 변환 작업의 바탕이 되는 기준 원본 데이터)	적절한 k의 선택이 필요하다.
훈련 단계가 빠르다.	데이터가 많아지면 분류 단계가 느리다.
수치 기반 데이터 분류 작업에서 성능이 우수하다.	명목 특징 및 누락 데이터를 위한 추가 처리가 필요하다.

GridSearchCV

사이킷런에서 교차 검증을 기반으로 하이퍼파라미터의 최적값을 찾을 수 있는 함수

(최적의 하이퍼파라미터 조합을 찾는자동화된 방법)

* 하이퍼파라미터(Hyperparameter): 머신러닝이나 딥러닝 모델을 훈련할 때, 사용자가 직접 사전에 설정해야하는 변수값

사용 이유

모델마다 우리가 직접 설정해야 하는 값(하이퍼파라미터)이 있습니다.

KNN 알고리즘 예시: "K를 몇으로 할까?" (K=1, 3, 5, 7...)
의사결정나무 예시: "나무의 깊이(depth)는 얼마나 깊게 할까?" (깊이=3, 5, 10...)

이 값들을 감으로 찍는 것이 아니라, 컴퓨터가 수학적으로 가장 점수가 높은 조합을 찾게 만드는 것입니다.

작동 방식

마치 격자(Grid) 모양의 표를 만들어 모든 칸을 탐색하는 것과 같습니다.

	파라미터 A=1	파라미터 A=2	파라미터 A=3
파라미터 B=10	성능 0.75	성능 0.82	성능 0.78
파라미터 B=20	성능 0.85	성능 0.91 (최고)	성능 0.88

Grid 정의: 테스트하고 싶은 파라미터들의 후보군을 정합니다.
모든 조합 생성: 위 표처럼 가능한 모든 경우의 수를 만듭니다.
Cross-Validation(교차 검증) 수행: 각 조합마다 데이터를 여러 조각으로 나누어(K-Fold) 학습과 검증을 반복합니다. 이를 통해 특정 데이터에만 과적합되는 것을 방지합니다.
최적 조합 선택: 평균 성능이 가장 높은 조합을 최종 모델의 파라미터로 선택합니다.

GridSearchCV의 장/단점

장점	단점
철저함: 범위 내의 모든 조합을 확인하므로 이론상 가장 좋은 성능을 낼 수 있다.	시간 소모: 파라미터 조합이 많아질수록 연산량이 기하급수적으로 늘어난다. (학습 시간이 오래걸릴 수 있음.)
편의성: 한 번 설정해두면 컴퓨터가 알아서 최적의 값을 찾는다.

머신러닝 파이프라인 및 응용 구현 실습 정리

전체 흐름

데이터 준비 → 전처리 → 모델 학습 → 하이퍼파라미터 튜닝 → 모델 저장 → 신규 데이터 예측 → API 서비스

Iris 데이터셋을 이용한 KNN 분류 모델 학습

1. 데이터 로드

iris = load_iris()
X = pd.DataFrame(iris.data, columns=iris.feature_names)
y = iris.target

역할: Iris 데이터셋 가져오기

꽃받침 길이	꽃받침 너비	꽃잎 길이	꽃잎 너비
5.1	3.5	1.4	0.2

정답(Label)

= setosa
= versicolor
= virginica

2. 학습 데이터와 테스트 데이터 분할

train_test_split(
    X,
    y,
    test_size=0.2,
    random_state=42,
    stratify=y
)

주요 옵션

옵션의미

test_size=0.2	학습 80%, 테스트 20%
random_state=42	결과 재현
stratify=y	클래스 비율 유지

* stratify 사용 이유

Iris 데이터는 각 클래스가 50개씩 존재한다.

setosa      50
versicolor  50
virginica   50

분할 후에도 비슷한 비율이 유지되도록 한다.

Train
40 / 40 / 40

Test
10 / 10 / 10

데이터 정규화 (Scaling)

1. 왜 필요한가?

KNN은 거리 기반 알고리즘이다.

예)

꽃받침 길이 : 7.0
꽃잎 너비 : 0.2

값의 범위 차이가 크면 큰 값이 거리에 더 큰 영향을 준다.

따라서 모든 특징을 같은 범위로 맞춰야 한다.

2. 학습 데이터(MinMaxScaler 사용)

scaler = MinMaxScaler()

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

fit

최소값과 최대값 계산

min
max

transform

다음 공식 적용

(x - min) / (max - min)

결과 범위

0 ~ 1

* test 데이터 fit_transform 안하는 이유

X_test_scaled = scaler.fit_transform(X_test)

테스트 데이터의 최소/최대값을 보고 학습하게 됨(즉, 시험지를 미리 보고 공부 하는 꼴)

이를 데이터 누수 (Data Leakage) 라고 함.

KNN 생성

knn = KNeighborsClassifier()

GridSearchCV를 이용한 하이퍼파라미터 튜닝

KNN의 주요 하이퍼파라미터

n_neighbors

즉,

몇 개의 이웃을 참고할 것인가?

1. 후보 생성

param_grid = {
    'n_neighbors': [i for i in range(1,31) if i % 2 != 0]
}

결과

[1,3,5,7,9,11,13,15,17,19,21,23,25,27,29]

2. GridSearchCV

grid_search = GridSearchCV(
    knn,
    param_grid,
    cv=5,
    scoring='accuracy',
    n_jobs=-1
)

옵션 설명

cv=5	5-Fold 교차검증 (전체 데이터를 5개의 그룹으로 쪼갠 뒤, 학습과 검증을 총 5번 반복)
scoring='accuracy'	정확도 평가("정확도"라는 지표를 기준한다는 의미)
n_jobs=-1	모든 CPU 사용 (컴퓨터의 모든 CPU 코어를 동시에 사용하여 병렬 연산을 수행합니다. 그리드 서치는 탐색할 조합이 많아 시간이 오래 걸리는데 이 옵션을 쓰면 연산 속도가 극대화됩니다.)

학습

grid_search.fit(X_train_scaled, y_train)

실제 과정

K=1 학습
↓
정확도 측정

K=3 학습
↓
정확도 측정

K=5 학습
↓
정확도 측정
...

그 후 가장 높은 정확도 선택

최적 모델 평가

최고 성능 모델 추출

best_model = grid_search.best_estimator_

예측(테스트)

y_pred = best_model.predict(X_test_scaled)

평가

print(f"최종 테스트 데이터 정확도: {accuracy_score(y_test, y_pred):.4f}")

정확도 계산

정답 개수
-------------
전체 개수

모델 저장 및 불러오기

1. 왜 저장하는가?

학습은 시간이 오래 걸린다.

서비스 시에는 학습을 다시 하지 않고 저장된 모델을 사용한다.

2 .저장

joblib.dump(best_model, 'best_model.joblib')

joblib.dump(scaler,scaler.scaler')
3. 모델 불러오기

model = joblib.load('best_model.joblib')
scaler = joblib.load('scaler.scaler')

신규 데이터 생성 ~ 예측

1. 신규 데이터 생성

new_data = pd.DataFrame({
    ...
})

2. 스케일링 수행 (반드시)

new_data_scaled = scaler.transform(new_data)

주의

fit_transform()

사용하면 안 됨.

학습 시 계산한 min/max를 그대로 사용해야 한다.

3. 예측

predictions = model.predict(new_data)

결과

[1, 0]

예)

1 → versicolor
0 → setosa

Flask 기반 머신러닝 API

라이브러리 불러오기 및 플라스크

import joblib
import numpy as np
from flask import Flask, request, jsonify

app = Flask(__name__)

1. 모델 로드

model = joblib.load('best_model.joblib')

scaler = joblib.load('scaler.joblib')

서버 시작 시 한 번만 로드

2. POST 요청만 허용

@app.route('/predict',methods=['POST'])

3. JSON 데이터 받기

data = request.get_json()

예)

{
    "features": [5.1,3.5,1.4,0.2]
}

4. 유효성 검사

if not data or 'features' not in data:
	return jsonify({'error': 'JSON 데이터에 "features" 키가 필요합니다.'}), 400

5. 모델 입력 형식 맞추기(2차원 배열 반환)

입력 데이터 추출

features = data['features']

[5.1,3.5,1.4,0.2]

모델 입력

input_data = np.array([features])

변환

[[5.1,3.5,1.4,0.2]]

6. 스케일링(정규화)

scaled_data = scaler.transform(input_data)

7. 예측

prediction = model.predict(scaled_data)

8. 확률 계산

probability = model.predict_proba(scaled_data)

예)

[[0.98,0.01,0.01]]

9. JSON 응답 반환 신뢰도 추출

result = {
    "prediction_index": 0,
    "prediction_label": "setosa",
    "confidence": float(np.max(probability)
    # 신뢰도 추출: np.max(probability) => 0.98
}

return jsonify(result), 200

——————————————————————————

본 후기는 [한글과컴퓨터x한국생산성본부x스나이퍼팩토리] 한컴 AI 아카데미 (B-log) 리뷰로 작성 되었습니다.

[스나이퍼팩토리] 한컴AI아카데미(26.06.23) 머신러닝, (의사결정나무알고리즘)

cd-record — Tue, 23 Jun 2026 18:33:30 +0900

머신러닝

머신러닝(Machine Leraning)이란?

머신러닝은 사람이 공부를 통해 지식을 습득하듯이, 컴퓨터에게 데이터를 제공하여 스스로 규칙을 학습하게 만드는 기술

머신러닝과 전통적 프로그래밍의 차이점

전통적 프로그래밍

입력 데이터
↓
프로그램(규칙)
↓
결과

머신러닝

데이터 + 정답
      ↓
머신러닝 학습
      ↓
모델 생성
      ↓
새로운 데이터 입력
      ↓
예측 결과

머신러닝의 종류

1. 지도학습(Supervised Learning)

정답이 있는 데이터를 학습하는 방식

대표 알고리즘

의사결정나무
로지스틱 회귀
SVM
랜덤포레스트

사용 예시

스팸메일 분류
질병 진단
주택 가격 예측

2. 비지도학습(Unsupervised Learning)

정답이 없는 데이터를 학습하는 방식

20대 여성 그룹
30대 직장인 그룹
고가 제품 선호 그룹

대표 알고리즘

K-Means
DBSCAN
PCA

사용 예시

고객 세분화
군집 분석
이상치 탐지

3. 강화학습(Reinforcement Learning)

보상(Reward)을 통해 학습하는 방식

예시

게임 AI가 있다고 가정

이기면 +10점
지면 -10점

AI는 높은 점수를 얻기 위해 행동을 계속 수정합니다.

사용 예시

자율주행
게임 AI
로봇 제어

4. 딥러닝(Deep Learning)

인간의 뇌를 모방한 신경망(Neural Network)을 이용하는 학습 방법

대표 사례

ChatGPT
이미지 생성 AI
음성 인식
얼굴 인식

데이터 전처리

데이터 수집
↓
전처리
↓
학습
↓
예측

정규분포

데이터가 가장 많이 나타내는 형태(평균 근처에 데이터가 많이 모이고, 평균에서 멀어질수록 데이터가 적어지는 분포)

대표적으로 정규분포를 따르는 경우

키
몸무게
시험점수

정규분포의 특징

평균 근처에 데이터가 몰려있음
양쪽으로 갈수록 데이터가 적어짐
종 모양(Bell Curve)

## 정규분포
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# 표준정규분포를 따르는 랜덤 데이터 (평균: 0, 표준편차: 1)
np.random.seed(42) # seed
data = np.random.randn(1000) # # 평균이 (0)이고 표준편차가 (1)인 표준정규분포로부터 1000개의 \(z\)-점수 난수를 생성

plt.hist(data, bins=30)
plt.xlabel('Value')
plt.ylabel('Frequency')
plt.title('Nomaly Data')
plt.show()

스케일링

서로 다른 형태나 범위를 가진 데이터들을 공평하게 비교할 수 있도록 동일한 크기(스케일)로 맞춰주는 작업

1. 스케일링이 왜 필요한가요? (일상의 비유)

우리가 사과와 코끼리의 무게를 비교한다고 가정해 보겠습니다.

사과는 '그램(g)' 단위로 재서 '300'이라는 숫자가 나왔습니다.
코끼리는 '톤(t)' 단위로 재서 '4'라는 숫자가 나왔습니다.

숫자만 보면 300이 4보다 훨씬 큽니다. 하지만 컴퓨터는 단위(g, t)를 이해하지 못하고 숫자의 크기(300 vs 4)만 보고 사과가 코끼리보다 75배 더 무겁고 중요하다고 착각합니다. 이런 치명적인 오류를 막기 위해 단위를 통일하는 작업이 스케일링입니다.

2. 스케일링을 하면 무엇이 좋나요?

공정한 비교: 단위와 범위가 다른 데이터(예: 키 180cm, 몸무게 70kg, 연봉 4000만 원)를 동일한 기준에서 비교할 수 있습니다.
인공지능의 속도 향상: 컴퓨터가 정답(최적의 값)을 찾아가는 과정에서 숫자의 범위가 균일하면 지그재그로 헤매지 않고 최단 거리로 빠르게 찾아갑니다.

예측 정확도 상승: 숫자가 크다는 이유만으로 특정 데이터에만 모델이 과도하게 집중하는 현상을 막아주어 전체적인 예측 성능이 올라갑니다.

Z-Score 표준화(Standardization)

데이터의 평균을 0, 표준편차를 1로 변환하여 서로 다른 변수들의 척도를 통일하는 데이터 전처리 기법

장점

이상치에 비교적 강함
정규분포 데이터에 적합
통계 기반 모델에 적합

사용하는 모델

선형회귀
로지스틱회귀
신경망
PCA
SVM

공식

# 공식: (원점수 - 평균) / 표준편차
meat['Korea_std'] = (meat['Korea'] - meat['Korea'].mean()) / meat['Korea'].std()
meat['Japan_std'] = (meat['Japan'] - meat['Japan'].mean()) / meat['Japan'].std()

결과

평균 = 0
표준편차 = 1

# 결과값 변수를 Z라고 할 때
Z=1 => 평균보다 표준편차 1만큼 높은 값입니다.

Z=-2 => 평균보다 표준편차 2만큼 낮은 값입니다.

역변환

Z-Score 공식: z = (X - mu)/ sigma

X: 원래 데이터 값
mu: 데이터의 평균 (Mean)
sigm: 데이터의 표준편차 (Standard Deviation)

이 식을 우리가 구하고자 하는 원래 데이터 $X$에 대해 정리(역변환)하면 다음과 같은 식이 유도

X= (sigma * z) + mu

즉, (표준편차 $\times z$-점수) + 평균의 형태가 됩니다.

# 1000명의 연간 육류 소비량
# 한국인: 평균 53.9kg, 표준편차: 5kg
# 일본인: 평균 32.7kg, 표준편차: 4kg

meat_korea = 5 * np.random.randn(1000) + 53.9
meat_japan = 4 * np.random.randn(1000) + 32.7

Min-Max 정규화

데이터의 범위를 일정하게(보통 0과 1 사이) 조정하는 기법

장점

데이터 범위를 동일하게 맞춤
계산이 빠름
거리 기반 알고리즘에 유리

사용하는 모델

KNN
K-Means
신경망
이미지 데이터

공식

# 공식: (원점수 - 최솟값)/(최댓값 - 최솟값)
Min = np.min(meat['Korea'])
Max = np.max(meat['Korea'])
meat['Korea_mm'] = (meat['Korea'] - Min) / (Max - Min)

meat['Korea_mm'] = (meat['Korea'] - meat['Korea'].min()) / (meat['Korea'].max() - meat['Korea'].min())
meat["Japan_mm"] = (meat['Japan'] - meat['Japan'].min()) / (meat['Japan'].max() - meat['Japan'].min())

meat.sample(10)

결과

# 모든 값이
0 ~ 1

# 원래 값변환 값
10	=> 0
20	=> 0.5
30	=> 1

사이킷런 스케일러를 이용한 표준화/정규화

# 사이킷런 스케일러를 이용한 표준화 / 정규화
from sklearn.preprocessing import StandardScaler, MinMaxScaler

scaler = StandardScaler()
meat['Korea_std2'] = scaler.fit_transform(meat[['Korea']])
meat['Japan_std2'] = scaler.fit_transform(meat[['Japan']])
meat.sample(10)

scaler2 = MinMaxScaler()
meat['Korea_mm2'] = scaler2.fit_transform(meat[['Korea']])
meat['Japan_mm2'] = scaler2.fit_transform(meat[['Japan']])

meat.sample(10)

의사결정나무(지도학습)

데이터를 분류(Classification)하거나 연속적인 값을 예측(Prediction)하기 위해, 의사결정 규칙을 나무(Tree) 구조로 도표화한 지도학습 머신러닝 알고리즘

의사결정나무의 주요 특징

직관적인 구조: 마치 '스무고개'나 조건문(if-else)과 같이 데이터를 분류하여 누구나 쉽게 이해하고 결과를 설명할 수 있습니다.
분류 및 회귀: 범주형 데이터를 분류하는 분류 트리와 연속형 데이터를 예측하는 회귀 트리 모두에 사용됩니다.
데이터 전처리 용도: 변수의 정규화(스케일링) 등 복잡한 데이터 전처리가 거의 필요 없어 사용이 편리합니다.
과적합(Overfitting)의 위험: 나무가 너무 복잡해지면 학습 데이터에만 맞춰져 새로운 데이터에 대한 예측 성능이 떨어질 수 있습니다. 이를 방지하기 위해 가지치기(Pruning) 과정이 필수적입니다

의사결정나무의 핵심 구조와 작동 원리

데이터의 불순도(Impurity)를 낮추고 순도(Purity)를 높이는 방향으로 데이터를 분할합니다.

루트 노드(Root Node): 나무의 가장 최상단으로, 전체 데이터가 시작되는 지점입니다.

분할 기준 (불순도 측정 지표)

지니 계수(Gini Index): 데이터가 얼마나 불순한지를 나타내며, 값이 0에 가까울수록 완벽하게 분류된 상태를 의미합니다.
엔트로피(Entropy): 데이터의 무질서함을 측정하는 지표로, 엔트로피가 낮을수록 정보가 명확합니다.

## 1) 필수 패키지 import
# 패키지 임포트
import pandas as pd
import numpy as np
import sklearn

# 학습 및 테스트 데이터셋 분리를 패키지
from sklearn.model_selection import train_test_split

# 의사결정나무 분류모델을 위한 알고리즘
from sklearn.tree import DecisionTreeClassifier

## 2) 데이터 불러오기
df = pd.read_csv('https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv')
df

## 3) 데이터 탐색
df.shape # 데이터 개수와 열 개수를 확인
df.info()
df.describe()

## 4) 전처리
# 범주형값 바꾸기 (레이블 인코딩)
df['species'].unique()
df['species'].value_counts()
df['species'] = df['species'].replace({'setosa':0, 'versicolor':1,'virginica':2})
df.info()

## 5) 데이터셋 분리
# 분석 데이터셋 준비 (독립변수(피처), 종속변수(타겟))
X = df[['sepal_length','sepal_width','petal_length','petal_width']]
y = df['species']

# 데이터셋 분리 (학습용, 테스트용 = 8:2)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

print(X_train.shape, X_test.shape, y_train.shape, y_test.shape, sep="\n")

## 6) 머신러닝 학습
### DecisionTreeClassifier 객체 생성 (알고리즘 선택)
dt = DecisionTreeClassifier(random_state=42)

# 학습 수행
dt.fit(X_train, y_train) # 학습용 문제와 답지

## 7) 예측 수행
pred = dt.predict(X_test)
pred

y_test.values

## 8) 성능분석 (성능지표 확인)
# 정확도
from sklearn.metrics import accuracy_score
acc = accuracy_score(y_test, pred)
print(acc)

# 정밀도, 재현율, f1-score
from sklearn.metrics import classificaton_report
rpt = classification_report(y_test, pred)
print(rpt)

핵심 4대 척도 (Metrics)

4대 척도의 역할과 쓰임새

모델이 단순히 전체 정확도(Accuracy)만 높다고 좋은 모델은 아닙니다. 데이터가 한쪽으로 치우쳐 있을 때(예: 암 환자가 1%밖에 없는 경우) 정확도는 99%가 나와도 실제 암 환자를 하나도 못 찾을 수 있기 때문입니다. 이때 이 척도들이 필요합니다.

정확도 (Accuracy)

수식: (TP + TN) / (TP + TN + FP + FN)
필요성: 전체 예측 중 맞춘 비율을 나타내므로, 전체 성능을 간단하게 평가 할수 있습니다.
언제 사용하나: 클래스 불균형이 심하지 않은 경우에 유용합니다.
왜 필요한가: 모델이 전반적으로 잘 작동하는지 확인하기 위해 사용합니다.

정밀도 (Precision)

수식: TP / (TP + FP)
용도: 실제는 아닌데 참이라고 잘못 판단하면 큰 손해가 발생하는 경우 중요합니다 (예: 스팸 메일 분류).
필요성: 모델의 긍정 예측이 얼마나 신뢰할 수 있는 지를 측정
언제 사용하나: False Postibie(잘못된 긍정 예측0의 비용이 높은 경우에 중요합니다
왜 필요한가: 긍정 예측의 신뢰성을 높이고자 할 때 사용합니다.

재현율 (Recall 또는 Sensitivity)

수식: TP / (TP + FN)
용도: 실제 참인 것을 놓치면 치명적인 경우 중요합니다 (예: 암 진단, 범죄 탐지).
필요성: 실제 긍정 중에서 모델이 얼마나 잘 긍정 예측을 했는 지를 나타냅니다.
언제 사용하나: False Negative(잘못된 부정 예측)의 비용이 높은 경우에 중요합니다.
왜 필요한가: 긍정 사례를 최대한 많이 찾아내고자 할 때 사용합니다.

F1-Score

수식: 2 x ((Precision x Recall) / (Precision + Recall))
용도: 한쪽 지표에 치우치지 않고 모델의 전체적인 성능을 균형 있게 평가할 때 사용합니다.
필요성: 정밀도와 재현율 간의 균형을 평가합니다.(조화 평균)
언제 사용하나: 정밀도와 재현을 모두 중요할 떄, 특히 데이터가 불균형할 경우에 유용합니다.
왜 필요한가: 두 지표간의 균형을 유지하여, 한쪽에 치우치지 않은 성능 평가를 위해 사용합니다.

Support

개념: 각 클래스에 속한 실제 데이터의 개수입니다.
특징: 성능을 평가할 때 해당 클래스의 데이터 수가 너무 적지는 않은지(신뢰할 수 있는지) 판단하는 기준이 됩니다. 위의 예시에서는 0번 클래스 50개, 1번 클래스 50개로 총 100개의 데이터가 평가에 사용되었음을 의미합니다.

혼동행렬(Confusion Matrix)

4가지 경우의 수 (혼동 행렬의 구성 요소)

모델의 예측값과 실제 정답을 비교했을 때 발생하는 4가지 조합입니다. (여기서 양성/음성은 모델이 분류하고자 하는 대상을 의미합니다.)

TP (True Positive): 실제 정답이 '참'인데, 모델도 '참'이라고 맞춘 경우.
TN (True Negative): 실제 정답이 '거짓'인데, 모델도 '거짓'이라고 맞춘 경우.
FP (False Positive): 실제 정답은 '거짓'인데, 모델이 '참'이라고 틀린 경우 (오경보, 1종 오류).
FN (False Negative): 실제 정답은 '참'인데, 모델이 '거짓'이라고 틀린 경우 (놓침, 2종 오류).

분류 모델의 성능을 '교차표(Cross-table)' 형태

구조 살펴보기 (2x2 이진 분류 예시)

가장 기본이 되는 이진 분류(맞다/틀리다)의 혼동 행렬은 다음과 같습니다.

실제 \ 예측	예측: 양성(Positive)	예측: 음성(Negative)
실제: 양성(Positive)	TP (잘 맞춤)	FN (놓침 - 오답)
실제: 음성(Negative)	FP (잘못된 경고 - 오답)	TN (잘 맞춤)

다중 분류(Multi-class)로 확장

# 혼동 행렬 (가로: 예측, 세로: 실제 답)
from sklearn.metrics import confusion_matrix
confusion_matrix(y_test, pred)

대각선 요소: 실제 클래스와 예측 클래스가 일치하는 경우 (모델이 맞춘 것)
대각선 외 요소: 실제 클래스와 예측 클래스가 다른 경우 (모델이 무엇으로 착각했는지 확인 가능)

——————————————————————————

본 후기는 [한글과컴퓨터x한국생산성본부x스나이퍼팩토리] 한컴 AI 아카데미 (B-log) 리뷰로 작성 되었습니다.

[스나이퍼팩토리] 한컴AI아카데미(26.06.22) Pandas 그룹화/형변환

cd-record — Mon, 22 Jun 2026 18:00:34 +0900

형변환(.astype)

형변환을 하는 이유

데이터가 "무엇인가"에 따라 컴퓨터가 할 수 있는 일이 정해져 있습니다.

계산이 필요할 때: 문자열 '100'은 숫자 100과 다릅니다. '100'은 그냥 글자일 뿐이라서 더하기를 하면 오류가 나거나 글자가 이어붙여집니다. 숫자(int/float)로 바꿔야 계산이 가능합니다.
분석이 필요할 때: 날짜가 적힌 글자('2026-06-22')는 그냥 글자일 뿐이지만, 날짜 타입(datetime)으로 바꾸면 "오늘이 무슨 요일인지", "지난주와 비교하면 어떤지"를 계산할 수 있습니다.
용량 최적화: 메모리를 너무 많이 차지하는 타입을 가벼운 타입으로 바꾸면 대용량 데이터를 다룰 때 훨씬 빠르고 쾌적합니다.

정수형

- .astype(int) 또는 .astype('int64')
    - 소수점 아래를 버리고 정수로 변환

# 1. 단일 열 형변환 (문자열 -> 정수)
df['나이'] = df['나이'].astype(int)
df.info(0)

실수형

- .astype(float) 또는 .astype('float64')
    - 소수점을 포함하는 실수로 변환

문자열

- .astype(str) 또는 .astype('object')
    - 텍스트 데이터로 변환

범주형

- .astype('category')
    - 고유값 종류가 적을 때 메모리를 아끼는 타입

숫자 변환 전용(pd.to_numeric())

errors 옵션에 따라 결과가 달라집니다.

- 1. errors='raise'(기본값): 에러를 발생시킵니다
- 2. errors='ignore': 변환하지 않고 원본을 그대로 둠
- 3. errors='coerce': 숫자로 못 바꾸는 것은 결측치(NaN로 처리)(★가장 많이 씀)

s = pd.Series(['10','20','치명적 오류', '40'])
# s.astype(int) -> '치명적 오류' 문자열 때문에 오류

s_converted = pd.to_numeric(s,errors='coerce')
# 'coerce'를 통해 '치명적 오류' -> NaN 으로 변환
s_converted

결측치(NaN)가 있는 열을 int로 바꿀 때, 콤마(,)가 포함된 가격 데이터

# 1) 결측치를 먼저 채우고 변환하기
df['열이름'] = df['열이름'].fillna(0).astype(int)

# 2) 결측치를 사전에 지우거나 다른 값으로 채우고 변환하기
df['열이름'] = df['열이름'].drop(0)
df['열이름'] = df['열이름'].astype(int)

df['열이름'] = df['열이름'].fillna(df['열이름'].mean()).astype(int)

# 콤마(,)가 포함된 가격 데이터 (1, 250)
df['가격'] = df['가격'].str.replace(',').astype(int)

날짜/시간 변환 전용(pd.to_datetime())

문자열로 된 날짜 데이터를 판다스가 인식하는 datetime64 타입으로 바꿔줍니다

자주 쓰는 기본 단위(Unit)

약어(추천)	풀네임	의미
'D' 또는 'd'	'day' / 'days'	일 (Days)
'h'	'hour' / 'hours'	시간 (Hours)
'm'	'minute' / 'minutes'	분 (Minutes)
's'	'second' / 'seconds'	초 (Seconds)

format='mixed'

df = pd.DataFrame({'날짜': ['2026-01-01','2026/05/15','2026.12.25']})
print(df.info())

df['날짜'] = pd.to_datetime(df['날짜'], format='mixed') 
# format='mixed': 형태가 다 다를 때 문자열에서 바로 변환할 때 사용
# errors='coerce': 유효하지 않은 문자열은 NaN으로 변환
print(df.info())

df=  pd.DataFrame({'날짜': ['20260617','20260618']})
df['날짜'] = pd.to_datetime(df['날짜'], format='%Y%m%d')
df

연, 월, 일 추출 (수치형 데이터로 변환됨)

df['연도'] = df['날짜'].dt.year
df['월'] = df['날짜'].dt.month
df['일'] = df['날짜'].dt.day
df.info()

요일 추출 (0: 월요일, 1: 화요일, ..., 6: 일요일 | Monday, Tuesday, ... )

# 요일 추출 (0: 월요일, 1: 화요일, ..., 6: 일요일)
df['요일_숫자'] = df['날짜'].dt.weekday
df

# 요일 이름 추출 (Mnonday, Tuesday 등)
df['요일_이름'] = df['날짜'].dt.day_name()
df

날짜 연산 (timedelta)

# 두 날짜의 차이 구하기 (날짜 연산 사용시 타입: timedelta)
df_user['유지기간'] = df_user['탈퇴일'] - df_user['가입일']

# timedelta 형태로 바꾸기
pd.to_timedelta(df_user['유지일수'], unit='D')

import pandas as pd

df_user = pd.DataFrame({
    '가입일': pd.to_datetime(['2025-01-01','2025-03-15']),
    '유지일수': [537, 285] # 정수형 일수 데이터
})

# 정수형 숫자를 날짜 간격(Days) 데이터로 변환하여 더하기
df_user['복구일'] = df_user['가입일'] + pd.to_timedelta(df_user['유지일수'], unit = 'D')

df_user

' 정수형 숫자(일수)'만 추출하기 (.dt.days)

# '정수형 숫자(일수)'만 추출하기 (.dt.days)
df_user['유지일수'] = df_user['유지기간'].dt.days

중복 데이터 처리(.duplicated)

import pandas as pd

data = {
    '이름': ['김철수', '이영희', '박민수', '정미영', '강지아', '최현우', '송은지', '송은지'],
    '나이': [25, 30, 50, 28, 32, 35, 29, 29],
    '몸무게': [75.0, 55.0, 68.0, 63.7, 52.0, 80.0, 58.0, 58.0],
    '생년월일': ['20000101', '1994-05-15', '1993-08-22', '1996-02-28', '1998-11-30', '1989-07-12', '1995-03-18', '1995-03-18'],
    '급여': [3500000, 3985714, 4200000, 3800000, 3600000, 5000000, 3900000, 3900000]
}
df = pd.DataFrame(data)
df

df.duplicated().sum()
df.duplicated()
df[df.duplicated()]
df.drop_duplicates() # 원본은 삭제 안됨

df.duplicated() (반환 타입: Series(true/false))

결과: 각 행이 중복인지 여부를 알려주는 True와 False로 이루어진 리스트(Series)를 반환합니다.
의미:
- False: 이 행은 처음 등장함 (중복 아님)
- True: 이 행은 이전에 이미 등장했음 (중복됨)

df.duplicated().sum() (반환 타입: 숫자(int))

결과: 전체 데이터에서 중복된 행이 총 몇 개인지 나타내는 '숫자'를 반환합니다.
의미: True인 행의 개수를 모두 더한 값이므로, 데이터에 전체적으로 중복이 몇 건 있는지 빠르게 파악할 때 사용합니다.

df[df.duplicated()] (반환 타입: DataFrame)

결과: 중복된 행들만 실제로 추출해서 보여주는 '데이터프레임'을 반환합니다.
의미: "도대체 어떤 데이터들이 중복되어 있는 거지?" 하고 직접 눈으로 확인하고 싶을 때 사용합니다. (df 전체에서 중복인 행만 필터링한 결과입니다.)

df.drop_duplicates() (반환 타입: DataFrame)

결과: 중복된 행을 제거한 '새로운 데이터프레임'을 반환합니다.
의미: 말 그대로 중복을 정리하는 명령어입니다. (기본적으로 첫 번째 등장한 행은 살려두고, 뒤에 나타나는 중복값들을 삭제합니다.)

그룹화(Group By)

방대한 데이터를 특정 기준에 따라 분류하고, 그룹별로 통계 정보를 요약하기 위해 사용하는 핵심 기능

import pandas as pd
data = [['김민재', 31, 75, 5428000],
        ['이강인', 22, 57, None],
        ['박찬호', 50, None, 8428000],
        ['차범근', 70, 80, 4428000],
        ['추신수', 43, 100, 4528000],
        ['손흥민', 31, 72, 7028000],
        ['황희찬', 28, 69, 2528000]]
df = pd.DataFrame(data, columns=['성명', '나이', '몸무게', '급여'])
df

df['나이'].unique()

df['종목'] = ['축구','축구','야구','축구','야구','축구','축구']
df

인덱스(Index) 변경

df7 = df.copy()
df7.index = ['A','B','C','D','E','F','G']

df8 = df7.set_index('성명') # 기존 컬럼(열)을 index로
df8

df9 = df8.reset_index() # index를 컬럼(열)으로 
df9

df9 = df8.reset_index(drop=True) # index를 버림
df9

set_index()

특정 컬럼을 인덱스로 변경

reset_index()

인덱스를 다시 일반 컬럼으로 변경

drop=True : 기존 인덱스를 삭제하고 새 인덱스를 생성한다

그룹화(GroupBy)

groupby()

특정 컬럼을 기준으로 데이터를 그룹으로 묶는다.

그룹별 합계 구하기(sum())

df_grp = df.groupby('나이').sum()
df_grp

결과

      몸무게        급여
나이
22    57.0       0
31   147.0 12456000
43   100.0 4528000
...

특정 그룹 조회, 평균 구하기

# 특정 그룹 조회
df_grp.loc[31]
'''
몸무게      147.0
급여   12456000
'''

# 특정 컬럼 평균
df_hap = df.groupby('종목')[['나이','몸무게','급여']].mean()
df_hap
'''
          나이    몸무게        급여
종목
야구      46.5 100.0 6478000
축구      36.4  70.6 4853000
'''

# 숫자형 컬럼 전체 평균(숫자형 컬럼만 자동 선택하여 평균 계산)
df.groupby('종목').mean(numeric_only=True)

다중 그룹화(Multi GroupBy)

df = pd.DataFrame({
    '제품':['노트북','태블릿','스마트폰','노트북','스마트폰','태블릿'],
    '지역':['서울','부산','서울','대구','부산','서울'],
    '판매량':[10,5,8,12,6,4],
    '가격':[1200000,500000,800000,1300000,750000,550000],
    '판매자번호':['A01','A02','A01','A03','A02','A03']
})

제품별 평균 판매량/지역+제품별 판매량

# 제품별 판매량
df.groupby('제품')[['판매량']].mean()
'''
        판매량
제품
노트북    11.0
스마트폰   7.0
태블릿    4.5
'''

# 지역, 제품별 판매량
df_prd = df.groupby(['지역','제품'])[['판매량']].sum()
df_prd
'''
             판매량
지역 제품
부산 스마트폰      6
부산 태블릿       5
대구 노트북      12
서울 노트북      10
서울 스마트폰      8
서울 태블릿       4
'''

특정 그룹 조회

# 서울 전체 조회
df_prd.loc[['서울']]
'''
        판매량
제품
노트북     10
스마트폰     8
태블릿      4
'''

# 서울 스마트폰 판매량
df_prd.loc[[('서울','스마트폰')]]
'''
             판매량
지역 제품
서울 스마트폰     8
'''

다중 인덱스(Multi Index)는 튜플 (지역, 제품) 형태로 조회한다.

agg() 집계 함수

여러 집계 함수를 한 번에 적용할 수 있다.

문법

df.groupby('컬럼').agg({
    '컬럼명':['함수1','함수2']
})

예제

result = df.groupby('제품').agg({
    '판매량':['sum','mean','count'],
    '가격':['min','max']
})

결과

        판매량              가격
         sum mean count    min      max
제품
노트북      22 11.0     2 1200000 1300000
스마트폰     14  7.0     2  750000  800000
태블릿       9  4.5     2  500000  550000

——————————————————————————

본 후기는 [한글과컴퓨터x한국생산성본부x스나이퍼팩토리] 한컴 AI 아카데미 (B-log) 리뷰로 작성 되었습니다.

[스나이퍼팩토리] 한컴AI아카데미(26.06.19) Pandas 데이터 전처리 정리

cd-record — Fri, 19 Jun 2026 18:00:37 +0900

Pandas 데이터 전처리 핵심 정리

import pandas as pd

data = [
    ['김민재', 31, 75, 5428000],
    ['이강인', 22, 57, None],
    ['박찬호', 50, None, 8428000],
    ['차범근', 70, 80, 4428000],
    ['추신수', 43, 100, 4528000],
    ['손흥민', 31, 72, 7028000],
    ['황희찬', 28, 69, 2528000]
]

df = pd.DataFrame(data, columns=['성명', '나이', '몸무게', '급여'])

1. sample() : 랜덤 추출

행 n개 랜덤 추출

df.sample(3)

비율로 랜덤 추출

train = df.sample(frac=0.7)
# 랜덤 (1을 기준 백분율, 0.7~70%)

데이터프레임이나 시리즈에서 전체 데이터 대비 지정된 비율(%)만큼의 데이터를 무작위로 추출할 때 사용

frac=0.7 → 전체 데이터의 70% 추출

랜덤 결과 고정

train = df.sample(frac=0.7, random_state=42)
# 코드를 실행할 때마다 추출되는 데이터가 매번 달라집니다. 이를 방지하고 항상 같은 데이터가 추출되도록 하려면 생성 변수(random_state)를 지정하는 것이 좋습니다.
# random_state(생성 변수)는 무작위(랜덤) 결과를 항상 동일하게 고정해 주는 역할을 합니다.
# 컴퓨터의 랜덤은 사실 완전히 무작위가 아니라 특정 '시작 숫자(Seed)'를 바탕으로 계산된 규칙적인 난수입니다.
# 이 시작 숫자를 고정하는 매개변수가 바로 random_state입니다.

random_state는 무작위(Random) 추출 결과를 언제 실행해도 똑같이 나오도록 고정하는 역할

random_state : 랜덤 시드(seed) 고정
항상 동일한 결과 추출

2. sort_values() : 정렬

오름차순

df.sort_values(by='나이')
# by는 생략 가능!!

내림차순

df.sort_values('나이', ascending=False)
# ascending: 오름차순, 내림차순(안 썼을 시 기본 오름차순)

다중 정렬

df.sort_values(
    ['나이', '몸무게'],
    ascending=True
)

나이 기준 정렬
나이가 같으면 몸무게 기준 정렬

3. 결측치 확인(.isna())

결측치 여부 확인

df.isna()

결측치 개수 확인

df.isna().sum()

특정 컬럼(열)에서 결측치 행 찾기

df[df['몸무게'].isna()]

결측치가 하나라도 있는 행

df[df.isna().any(axis=1)]

특정 컬럼(열)에서 결측치가 없는 행

df[df['몸무게'].notna()]

4. drop() : 행/열 삭제

행 삭제

df.drop(0)

df.drop([1, 3, 5]) # axis = 0 (기본값)

열 삭제

df.drop('몸무게', axis=1)

또는

df.drop(columns=['몸무게','급여']) # 복수 선택 가능

인덱스 위치로 삭제

df.drop(index=[1,3,5])

5. dropna() : 결측치 제거

결측치가 하나라도 있는 행 제거

df.dropna()

결측치가 하나라도 있는 열 제거

df.dropna(axis=1)
how='any'

df.dropna(how='any') # 기본값: axis=0, how='any'

모든 값이 결측치인 경우만 제거

df.dropna(how='all')

df.dropna(how='all', axis=1) # 열 기준

thresh

df.dropna(thresh=4)
# 유효한 데이터가 4개 이상인 행만 유지

df.dropna(axis=1, thresh=6)
# 유효한 데이터가 6개 이상인 열만 유지

6. fillna() : 결측치 채우기

특정 값으로 채우기

df.fillna(0)
# fillna: 결측지를 해당 값으로 수정(자료형: float)

# np.nan: null 값(넘파이 선언 시 사용 가능), 이상치 강은 값을 처리할 경우 np.nan(단, numpy 선언 시 사용 가능)

평균값으로 채우기(mean)

df['몸무게'].fillna(
    df['몸무게'].mean()
)

중앙값(Median)

df['몸무게'].fillna(
    df['몸무게'].median()
)
최빈값(mode)

df['몸무게'].fillna(
    df['몸무게'].mode()[0]
)
※ mode()는 Series를 반환하므로 [0] 사용

여러 컬럼 한 번에 채우기

replace_values = {
    '몸무게': df['몸무게'].mean(),
    '급여': df['급여'].median()
}

df.fillna(value=replace_values)

7. 이상치(Outlier)처리

import pandas as pd
import numpy as np

data = {
    '이름': ['김철수', '이영희', '박민수', '최수진', '홍길동'],
    '나이': [25, 30, 28, 22, 190]  
}
df = pd.DataFrame(data)

요약 통계량(평균, 최소값, 최대값, 사분위수 등)을 한눈에 확인

df.describe()

150세 초과를 이상치로 처리

df.loc[df['나이'] > 150, '나이'] = np.nan

결측치 대체

df['나이'] = df['나이'].fillna(190)

IQR 방식

1단계 : 사분위수 계산

# IQR 및 정상 범위 계산(quantile(분위수): 크기 순서대로 정렬된 데이터를 특정 비율로 나누는 기준값)
Q1 = df['나이'].quantile(0.25)
Q3 = df['나이'].quantile(0.75)

IQR = Q3 - Q1

2단계 : 정상 범위 계산

lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR

3단계 : 이상치 찾기

outlier_condition = (
    (df['나이'] < lower_bound) |
    (df['나이'] > upper_bound)
)

4단계 : NaN 처리

df.loc[outlier_condition, '나이'] = np.nan

8. value_counts() : 빈도수 계산

#판다스(Pandas)의 value_counts()는 시리즈(Series)나 데이터프레임(DataFrame)의 각 값들이 몇 번씩 등장하는지(빈도수)를 세어주는 핵심 함수
import pandas as pd
import numpy as np

data = {
    '품목': ['사과', '바나나', '사과', '오렌지', '바나나', '사과', np.nan],
    '수량': [3, 2, 5, 1, 2, 3, 4]
}
df = pd.DataFrame(data)
print(df)

df['품목'].value_counts()

결과

사과      3
바나나    2
오렌지    1

결측치 포함

df['품목'].value_counts(dropna=False)

비율 확인( 0~1 사이의 비율로 반환)

df['품목'].value_counts(normalize=True)

결과

사과      0.50
바나나    0.33
오렌지    0.17

오름차순 정렬

df['품목'].value_counts(
    ascending=True
)

구간별 빈도수

df['수량'].value_counts(bins=3)

예시

(0.99, 2.33]    3
(2.33, 3.66]    2
(3.66, 5.0]     2

느낀점

이번주는 데이터 전처리 과정에 대해 numpy, matplotlib, pandas의 메소드에 대해 배웠다. 배워야하는 내용들은 되게 많겠지만 시간이 별로 없기 때문에 메소드 위주로 수업을 진행했는데 AI를 들어가기 전 데이터 전처리는 중요하기 때문에 제대로 배워야겠다.

——————————————————————————

본 후기는 [한글과컴퓨터x한국생산성본부x스나이퍼팩토리] 한컴 AI 아카데미 (B-log) 리뷰로 작성 되었습니다.

[스나이퍼팩토리] 한컴AI아카데미(26.06.17) Pandas

cd-record — Wed, 17 Jun 2026 18:13:26 +0900

Pandas

Pandas이란?

Pandas는 파이썬에서 데이터 작업에 사용되는 라이브러리로 데이터 분석, 정리, 탐색, 조작을 위한 기능이 포함되어 빅데이터 분석은 물론 통계 이론에 기반한 데이터 분석이 가능합니다.

1. 데이터 구조(Data Structures)

Series(시리즈): 1차원 배열로, 인덱스(Index)와 값(Value)으로 구성, 하나의 열(Column)데이터라고 생각
DataFrame(데이터 프레임): 2차원 표 구조, 여러 개의 시리즈가 모여 만들어지며, 행(Row), 열(Column)로 구성된 데이터 분석의 기본 단위

2. 주요 기능

데이터 입출력: CSV, Excel, SQL, JSON 등 다양한 형식의 파일을 쉽게 읽고(read) 쓸(to) 수 있습니다.

파일형식 Reader Writer

CSV read_csv to_csv

EXCEL read_excel to_excel

HTML read_html to_html

JSON read_json to_json

SQL read_sql to_sql
데이터 정제 (Data Cleaning): 결측치(NaN/None)를 찾아 삭제하거나 다른 값으로 채우고, 데이터 타입을 변경하는 등 복잡한 전처리가 가능합니다.
데이터 선택 및 필터링: 특정 행이나 열을 선택하고, 조건문을 사용하여 원하는 데이터만 빠르게 추출. 즉, 정제되지 않은 데이터를 정리하여 가독성과 연관성이 높은 데이터로 만들 수 있습니다.
데이터 병합 및 재구조화: 여러 데이터를 하나로 합치거나(Merge/Join), 피벗 테이블(Pivot Table)을 만들어 데이터를 원하는 형태로 변환할 수 있습니다.
데이터 집계 (Grouping): 데이터를 특정 기준으로 그룹화하여 합계, 평균, 개수 등을 계산하는 연산에 탁월합니다.

3. 작업 흐름

로드 (Load): 외부 데이터 파일을 불러옵니다. (pd.read_csv())
탐색 (Explore): 데이터의 형태나 요약 정보를 확인합니다. (df.head(), df.info(), df.describe())
전처리 (Clean/Transform): 불필요한 데이터를 지우거나 값을 보정합니다. (df.dropna(), df.rename())
분석 (Analyze): 통계량을 계산하거나 그룹별 연산을 수행합니다. (df.groupby().mean())
저장/출력 (Visualize/Export): 분석 결과를 파일로 저장하거나 시각화 도구(Matplotlib, Seaborn 등)와 연동합니다.

설치

pip install pandas

사용

import pandas as pd

Series(시리즈)

기본 구조(하나의 컬럼 데이터)

city = ['서울','부산','울산']
df = pd.Series(city)
'''
0    서울
1    부산
2    울산
dtype: str
'''

인덱싱

# 인덱스 변경 ( 0, 1, 2 -> a, b, c)
df = pd.Series(city, index = ['a','b','c'])
print(df)
print(df['a'])

# 시리즈 생성
city = {'서울': 940, '부산':330, '울산':110}
df = pd.Series(city)
print(df)
print(df['부산'])

# 시리즈 생성2
data = [10, 20, 30, 40]
index = ['a','b','c','d']
series = pd.Series(data, index=index)
print(series)

기본 통계량 계산 및 기본 명령

print("Mean:", series.mean()) # 평균
print("Sum:", series.sum()) # 합계
print("Max:", series.max()) # 최댓값
print("Standard Deviation:", series.std()) # 표준편차

series['c'] # 인덱스'c'(위치)에 있는 원소

series > 20 # 조건 지정
'''
a    False
b    False
c     True
d     True
e     True
dtype: bool
'''

series[series > 20] # 조건에 맞는 값만 가져오기

series['c'] = 100 # 원소 수집(원소가 이미 있을 때)

series['e'] = 50 # 원소 추가(원소가 없을 때)

series = series.drop('a') # 원소 삭제
'''
b     20
c    100
d     40
e     50
dtype: int64
'''

인덱스 정렬 및 자동 매칭

data2 = [5, 15, 25, 35]
series2 = pd.Series(data2, index=['b','c','d','e'])

result = series + series2
print(result)
'''
b     25
c    115
d     65
e     85
dtype: int64
'''

핵심 원리: 판다스는 연산을 수행할 때 데이터의 위치(순서)가 아니라 인덱스(Index) 이름을 기준으로 값을 찾아 더합니다.
결과 분석:
- 두 시리즈에 공통으로 존재하는 인덱스(b, c, d)는 값을 서로 더합니다.
- 만약 한쪽에만 존재하는 인덱스(a는 series에만 있음, e는 series2에만 있음)는 더할 상대가 없으므로 결측값인 NaN (Not a Number)으로 처리됩니다.
- 결과: a: NaN, b: 25, c: 45, d: 65, e: NaN 순으로 출력됩니다.

시계열 데이터 생성

date_range = pd.date_range(start='2023-01-01', periods=5)
print(date_range)
'''
DatetimeIndex(['2023-01-01', '2023-01-02', '2023-01-03', '2023-01-04',
               '2023-01-05'],
              dtype='datetime64[us]', freq='D')
'''

핵심 원리: pd.date_range는 지정된 시작일로부터 규칙적인 간격(기본값은 일 단위)으로 날짜 인덱스를 자동으로 생성합니다.
결과 분석: '2023-01-01'부터 시작하여 5일간의 날짜(2023-01-01 ~ 2023-01-05)를 가진 DatetimeIndex 객체가 생성됩니다. 이는 단순히 날짜 텍스트 리스트가 아니라, 날짜 계산이 가능한 전문 객체입니다.

시계열 데이터 다루기

time_series = pd.Series([1,3,5,7,9], index=date_range)
print(time_series)
print(time_series['2023-01-02'])
'''
2023-01-01    1
2023-01-02    3
2023-01-03    5
2023-01-04    7
2023-01-05    9
Freq: D, dtype: int64
3
'''

핵심 원리: 시간 인덱스를 활용하면 문자열 형태의 날짜로 직접 데이터에 접근할 수 있습니다. 굳이 인덱스 번호(0, 1, 2...)를 기억할 필요가 없습니다.
결과 분석:
- time_series['2023-01-02']와 같이 날짜 문자열을 넣어 호출하면, 해당 날짜에 대응하는 값인 3이 바로 반환됩니다.
- 이는 데이터 분석 시 "2023년 1월 2일의 매출이 얼마야?"와 같은 질문에 매우 직관적으로 답할 수 있게 해줍니다.

** dtype, freq

1. dtype (Data Type, 데이터 타입)

왜 중요한가요? 파이썬의 리스트와 달리, 판다스 시리즈는 모든 요소가 동일한 데이터 타입을 가져야 합니다. 타입이 정해져 있어야 컴퓨터가 메모리를 효율적으로 쓰고 연산을 빠르게 수행할 수 있기 때문입니다.
주요 예시:
- int64: 정수형 (64비트)
- float64: 실수형 (소수점이 있는 숫자)
- object: 문자열(String)이거나 여러 타입이 섞여 있을 때 주로 나타남
- datetime64[ns]: 날짜와 시간 정보

2. freq (Frequency, 빈도)

왜 중요한가요? 데이터가 일정한 간격(매일, 매달, 매시간 등)으로 기록되었음을 판다스가 인지하고 있다는 뜻입니다. 이 정보를 알면 나중에 데이터를 리샘플링(Resampling)하거나 미래 날짜를 예측할 때 매우 유용합니다.
주요 예시:
- freq='D': Day, 하루 단위
- freq='M': Month, 월 단위
- freq='H': Hour, 시간 단위
- freq='MS': Month Start, 월 시작일

DataFrame(데이터 프레임)

기본구조

import pandas as pd
city = {
	'도시': ['서울','부산','울산'],
	'인구': [940,330,110]
}

df = pd.DataFrame(city)
df

'''
	도시	인구
0	서울	940
1	부산	330
2	울산	110
'''

데이터프레임으로 변환

df = time_series.to_frame(name='Values')
# name = columns 하지만 to_frame()메서드에서는 columns라는 파라미터 존재 X
print(df)

.loc VS .iloc

구분	.loc (Label-based)	.iloc (Integer-based)
기준	이름(Label)으로 접근	순서(Index 번호)로 접근
슬라이싱	끝점 포함 (0:2 → 0, 1, 2)	끝점 미포함 (0:2 → 0, 1)
상황	인덱스 이름이나 컬럼명을 알 때	데이터의 몇 번째인지 위치를 알 때

.loc[행]: 인덱스 이름(Label)로 지정 (숫자 또는 문자, index 아님 주의)
- df.loc[0] # 시리즈 형태
- df.loc[[0]] # 데이터프레임 형태
- df.loc[[0,1,3]] # 여러 행을 한꺼번에 보려면 대괄호를 포함
- df.loc[0:3] # 슬라이싱을 이용할 때는 대괄호 제거
  - df.loc[0:3] # 0~3번 레이블까지를 의미 -> 4개의 데이터를 보여준다 (0, 1, 2, 3)
  - df.iloc[0:3] # 0~3 index까지를 의미 -> 3개의 데이터를 보여준다. (0, 1, 2)
.loc[행, 열]
- df.loc[0, '성명'] # 시리즈 형태
- df.loc[[0],['성명']] # 데이터프레임 형태 (복수 개 사용시에는 반드시 대괄호 필요)
- df.loc[0:3, ['성명','급여']]
- df.loc[0:3, '성명':'급여'] # 슬라이싱 사용시 대괄호 반드시 제거

.loc[조건, 열]
- df.loc[df['급여']>=50000000] # '급여'컬럼의 데이터에서 5백만원 이상인 행
- df.loc[df['급여']>50000000, ['성명']] # '급여' 컬럼의 데이터에서 5백만원 이상인 행에 대해 '성명' 컬럼만
- 파생 데이터 생성
  - df['체질량']=''" # 새로운 '체질량'이라는 빈 컬럼(열) 추가
  - df.loc[df['몸무게']>80, ['체질량']] = '비만' #몸무게' 컬럼의 데이터에서 80이상인 행을 추출한 다음, 해당 행에 대해서만 '체질량' 컬럼에 '비만'을 입력

.iloc
- .loc와 형식은 동일한데 loc달리 행과 컬럼의 index 정보로만 접근

인덱싱으로

df.iloc[[0,2], [0,3]]
df.iloc[:3, :2]

복사

df2 = df.copy() # 원본 유지하면서 작업을 할 때 반드시 복사해서 작업

df['나이'] > 40
df[df['나이'] > 40]
df[df['나이'] > 40].index

df.drop( 행 인텍스 레이블), df.drop(행, 열 인덱스, axis) # axis 생략 시 기본값은 0

df3 = df.drop(0) # 원본 삭제 x

df3.drop(['몸무게'], axis=1) # axis=0 은 행, axis=1 은 열
df.drop(df[df['나이'] > 40].index) # 특정 조건에 맞는 행만 삭제

import pandas as pd

data = ['김예찬, m, 부장, 010-1234-5678, 서울시 강남구 삼성동',
'이하은, f, 인턴, 010-8765-4321, 부산시 해운대구 우동',
'박지현, f, 과장, 010-1357-2468, 대구시 수성구 범어동',
'최준호, m, 임시, 010-1928-3746, 인천시 연수구 송도동',
'김예서, f, 과장, 010-2846-5937, 천안시 서북구 두정동']

df = pd.DataFrame(data,columns=['직원데이터'])
df = df['직원데이터'].str.split(',',expand=True)
# expand=False(기본값): 결과를 '리스트' 형태로 반환
# exapnd=True: 결과를 '데이터프레임' 형태로 반환

df.columns = ['이름','성별','직급','전화번호','주소']
# df['성별'].str.replace('M','Male') # 수정된 새로운 결과물을 반환하기 때문에 새로운 변수에 저장
df['성별']=df['성별'].str.upper()
df['성별']=df['성별'].str.replace('M','Male')
df['성별']=df['성별'].str.replace('F','Female')
df['성별']=df['성별'].str.replace('Male','남성').str.replace('Female','여성')
df

df['직급'].unique() # 하나만 있는 값 확인
df['직급'] = df['직급'].str.replace('인턴|임시','사원', regex=True)

df

df['직급'].unique()
df['주소'] = df['주소'].str.strip() # 양끝 공백 제거
df[['시','구','동']] = df['주소'].str.split(' ', expand=True)
df.drop(['주소'], axis=1) #열 제거

regex=True의 역할

코드에서 사용하신 '인턴|임시' 부분에서 | (파이프) 기호가 바로 핵심입니다.

| 기호의 의미: 파이썬이나 정규식에서 '또는(OR)'을 의미합니다.
즉, '인턴|임시'는 "인턴이거나, 혹은 임시인 글자를 찾아라"라는 뜻입니다.
regex=True를 설정하면 판다스는 이 '|'를 단순한 문자가 아니라 '논리 연산자'로 인식하여, 해당 패턴에 맞는 모든 단어를 '사원'으로 바꿔줍니다.

정규식 패턴 예시

패턴	의미	활용 예시
^A	A로 시작하는 문자열	^김 (김씨로 시작하는 사람)
A$	A로 끝나는 문자열	님$ (님으로 끝나는 이름)
[0-9]	숫자 0부터 9까지	숫자만 포함된 데이터 필터링
.	아무 글자 하나	패턴의 중간 글자 생략 시

——————————————————————————

본 후기는 [한글과컴퓨터x한국생산성본부x스나이퍼팩토리] 한컴 AI 아카데미 (B-log) 리뷰로 작성 되었습니다.

[스나이퍼팩토리] 한컴AI아카데미(26.06.16) Matplotlib

cd-record — Wed, 17 Jun 2026 00:04:51 +0900

Matplotlib

Matplotlib이란?

파이썬에서 정적, 애니메이션, 대화형 데이터 시각화를 만들기 위해 가장 널리 사용되는 오픈소스 플로팅 라이브러리입니다. 2D 및 3D 그래픽을 모두 지원하며, 학술 논문용 고품질 그래프부터 간단한 데이터 탐색용 차트까지 다양한 시각화 결과물을 생성할 수 있습니다.

다양한 그래프 지원: 선 그래프, 산점도, 히스토그램, 막대 그래프, 파이 차트 등을 그릴 수 있습니다.
뛰어난 호환성: Numpy 배열이나 Pandas 데이터프레임과 완벽하게 연동됩니다.
세밀한 커스터마이징: 축, 라벨, 범례, 색상 등 그래프의 모든 시각적 요소를 직접 제어할 수 있습니다.
여러 포맷 저장: 완성된 그래프를 PNG, JPG, PDF, SVG 등의 파일로 내보낼 수 있습니다.

설치

pip install matplotlib

사용

import matplotlib.pyplot as plt
import numpy as np

1. 선 그래프 (Line Plot)

import matplotlib.pyplot as plt

x = [1,2,3,4]
y = [1,4,9,16]

plt.plot(x, y)
plt.show()

스타일 지정

plt.plot(x, y,
         color='red',
         linestyle='--',
         marker='o')

plt.show()

옵션설명

color	선 색상
linestyle	선 스타일
marker	데이터 표시 모양
linewidth	선 두께

2. 제목과 축 라벨

plt.plot(x, y)

plt.title("성적 변화")
plt.xlabel("시험 횟수")
plt.ylabel("점수")

plt.show()

3. 범례(Legend)

그래프가 여러 개일 때 사용

plt.plot([1,2,3], [2,4,6], label="A반")
plt.plot([1,2,3], [1,3,5], label="B반")

plt.legend()
plt.show()

위치 지정

plt.legend(loc='upper left')

자주 사용하는 위치

best
upper right
upper left
lower right
lower left

4. 축 범위 지정

그래프 표시 범위 설정

plt.plot(x, y)

plt.xlim(0, 5)
plt.ylim(0, 20)

plt.show()

또는

plt.axis([0,5,0,20])

# [xmin, xmax, ymin, ymax]
plt.axis([0,5,0,20])

5. 격자(Grid)

데이터 보기 쉽게 만들기

plt.plot(x, y)

plt.grid(True)

plt.show()

Y축만

plt.grid(True, axis='y')

투명도

plt.grid(True,
         linestyle='--',
         alpha=0.5)

6. 눈금(Ticks)

축 눈금 변경

plt.xticks([1,2,3],
           ['1월','2월','3월'])

plt.yticks([0,50,100])

결과

1월  2월  3월

7. Figure 크기 설정

그래프 전체 크기

plt.figure(figsize=(10,6))

plt.plot(x,y)
plt.show()

# 가로 10인치
# 세로 6인치

8. 막대 그래프 (Bar Chart)

카테고리 비교

years = ['2018','2019','2020']
values = [100,400,900]

plt.bar(years, values)

plt.show()

색상 지정

plt.bar(years,
        values,
        color=['red','green','blue'])

9. 가로 막대 그래프

plt.barh(years, values)

plt.show()

10. 산점도 (Scatter Plot)

데이터 분포 확인

import numpy as np

x = np.random.rand(50)
y = np.random.rand(50)

plt.scatter(x, y)

plt.show()

점 크기 지정

plt.scatter(x, y,
            s=100)

옵션설명

s	점 크기
c	점 색상

11. 히스토그램 (Histogram)

데이터 빈도수 확인

scores = [60,70,80,90,80,75,65]

plt.hist(scores)

plt.show()

구간 개수 지정

plt.hist(scores,
         bins=5)

12. 파이 차트 (Pie Chart)

비율 표현

ratio = [40,30,20,10]
labels = ['A','B','C','D']

plt.pie(ratio,
        labels=labels)

plt.show()

퍼센트 표시

plt.pie(ratio,
        labels=labels,
        autopct='%.1f%%')

plt.show()

13. 여러 그래프 출력 (subplot)

한 화면에 여러 그래프

plt.subplot(1,2,1)

plt.plot([1,2,3],[1,4,9])

plt.subplot(1,2,2)

plt.plot([1,2,3],[9,4,1])

plt.show()

subplot(행, 열, 위치)

예시

plt.subplot(2,1,1)
plt.plot(...)

plt.subplot(2,1,2)
plt.plot(...)

위아래 배치

14. 그래프 저장

이미지 파일로 저장

plt.plot([1,2,3],[1,4,9])

plt.savefig("graph.png")

plt.show()

해상도 지정

plt.savefig("graph.png",
            dpi=300)

자주 사용하는 마커

마커모양

o	원
s	사각형
^	삼각형
x	엑스
*	별
d	마름모

plt.plot(x, y, marker='o')

자주 사용하는 선 스타일

스타일설명

-	실선
--	점선
:	도트선
-.	점-대시선

plt.plot(x, y, '--')

ex) 실무에서 가장 많이 쓰는 패턴

import matplotlib.pyplot as plt
import numpy as np

x = np.arange(1,6)
y = [10,20,15,30,25]

plt.figure(figsize=(8,5))

plt.plot(x, y,
         marker='o',
         linestyle='--',
         color='blue',
         label='매출')

plt.title("월별 매출")
plt.xlabel("월")
plt.ylabel("매출")

plt.grid(True, alpha=0.3)
plt.legend()

plt.tight_layout()

plt.show()

요약

plt.plot()      # 선 그래프
plt.bar()       # 막대 그래프
plt.barh()      # 가로 막대 그래프
plt.scatter()   # 산점도
plt.hist()      # 히스토그램
plt.pie()       # 파이 차트

plt.title()     # 제목
plt.xlabel()    # x축 이름
plt.ylabel()    # y축 이름

plt.legend()    # 범례
plt.grid()      # 격자

plt.xlim()      # x축 범위
plt.ylim()      # y축 범위

plt.subplot()   # 여러 그래프
plt.savefig()   # 이미지 저장
plt.show()      # 그래프 출력

[스나이퍼팩토리] 한컴AI아카데미(26.06.15) NumPy

cd-record — Mon, 15 Jun 2026 18:01:07 +0900

NumPy(Numerical Python)

1. NumPy란??

NumPy는 Numerical Python의 약자로 과학 및 공학 분야에서 사용되는 오픈 소스 파이썬 라이브러리이다.
NumPy 라이브러리에는 다차원 배열 및 행렬 데이터 구조가 포함되어있다.
NumPy는 배열로 저장된 값에 대한 수학 연산을 수행하는데 사용된다.
특징
- 다차원 배열(Array) 지원
- 빠른 수학 연산 가능
- 벡터화(Vectorization) 지원
- Pandas, Matplotlib 등 데이터 분석 라이브러리의 기반
설치

pip install numpy

사용

import numpy as np

2. 리스트와 NumPy 배열 차이

일반 리스트

a = [1, 3, 5]
b = [2, 4, 6]

print(a + b)

결과

[1, 3, 5, 2, 4, 6]

리스트는 연결(Concatenation)만 수행한다.

NumPy 배열

a = np.array([1, 3, 5])
b = np.array([2, 4, 6])

print(a + b)
print(a * b)

결과

[3 7 11]
[2 12 30]

NumPy는 같은 위치의 원소끼리 계산한다.

이를 벡터화 연산(Vectorized Operation) 이라고 한다.

⭐ 시험/실무 중요

a + b
a - b
a * b
a / b

모두 한 번에 계산 가능

3. ndarray(n차원 배열) 생성하기

스칼라: 0차원 배열
벡터: 1차원 배열
매트릭스(행렬): 2차원 배열
텐서: 3차원 배열

array()

arr = np.array([1,2,3])

zeros()

모든 값을 0으로 생성

np.zeros(5)

결과

[0. 0. 0. 0. 0.]

ones()

모든 값을 1로 생성

np.ones(5)

empty()

빈 배열 생성

np.empty(5)

초기값은 랜덤 쓰레기값

arange()

범위 생성

np.arange(5)

결과

[0 1 2 3 4]

범위 생성

np.arange(2,20,3)

결과

[ 2 5 8 11 14 17 ]

linspace()

균등 간격 생성

np.linspace(0,100,num=5)

결과

[  0.  25.  50.  75. 100.]

4. 데이터 타입 확인

arr = np.array([2,4,6,8])

print(arr.dtype)

결과

int64

Upcasting

서로 다른 자료형이 있으면 자동 형변환

arr = np.array(['서울', '부산', 123])

결과

['서울' '부산' '123']

숫자가 문자열로 변환된다.

5. 배열 정보 확인

arr = np.array([[1,2,3],[4,5,6]])

shape

배열 형태

arr.shape

결과

(2,3)

2행 3열

ndim

차원 수

arr.ndim

결과

size

전체 원소 수

arr.size

결과

6. 배열 차원 이해하기

0차원 (Scalar)

np.array(12)

1차원 (Vector)

np.array([1,2,3])

2차원 (Matrix)

np.array([
 [1,2,3],
 [4,5,6]
])

3차원 (Tensor)

np.array([
 [[1,2,3],[4,5,6]],
 [[7,8,9],[10,11,12]]
])

7. 인덱싱

1차원

arr = np.array([2,4,6,8])

print(arr[0])
print(arr[-1])

결과

2
8

2차원

arr = np.array([
 [2,4,6],
 [1,3,5]
])

print(arr[1,1])

결과

3차원

arr[1,1,2]

처럼

[깊이, 행, 열]

순서로 접근한다.

8. 슬라이싱

arr = np.array([10,11,12,13,14,15])

앞 3개

arr[:3]

4번부터 끝

arr[4:]

중간만

arr[2:5]

9. 조건 필터링

조건 검색

arr = np.array([1,2,3,4,5])

print(arr[arr > 3])

결과

[4 5]

짝수 찾기

arr[arr % 2 == 0]

결과

[2 4]

범위 검색

arr[(arr > 3) & (arr < 9)]

⭐ 중요

&
|

사용

and
or

사용 불가

10. 통계 함수

평균

np.mean(arr)

합계

np.sum(arr)

최대값

np.max(arr)

최소값

np.min(arr)

NaN 제외 평균

np.nanmean(arr)

⭐ 데이터 분석에서 자주 사용

11. axis 이해하기

scores = np.array([
 [85,90,88,95],
 [92,87,85,89],
 [78,85,91,87]
])

axis=0 (행축): 세로 방향 (열끼리 묶음)

열 기준 계산

np.mean(scores, axis=0)

결과

과목별 평균

axis=1 (열축): 가로 방향 (행끼리 묶음)

행 기준 계산

np.mean(scores, axis=1)

결과

학생별 평균

⭐ 외우기

axis=0 → 세로
axis=1 → 가로

12. reshape()

배열 형태 변경

arr = np.arange(1,13)

arr.reshape(3,4)

결과

3행 4열

배열 형태 변경

arr.reshape(2,6)

결과

2행 6열

13. flatten()

다차원 배열 → 1차원 배열

arr.flatten()

14. np.where()

조건에 따라 값 변경

np.where(arr > 5, "합격", "불합격")

결과

조건 참 → 합격
조건 거짓 → 불합격

실제 활용

재고 관리

status = np.where(
    inventory >= 30,
    "충분",
    "부족"
)

** 실무에서 가장 많이 쓰는 NumPy 함수 TOP 10

함수용도

np.array()	배열 생성
np.arange()	범위 생성
np.linspace()	균등 간격 생성
np.zeros()	0 배열
np.ones()	1 배열
np.mean()	평균
np.sum()	합계
np.where()	조건 처리
np.reshape()	형태 변경
np.nanmean()	NaN 제외 평균

느낀점

오늘은 numpy에 대해 배웠다. 데이터를 만지는데 기초에 들어섰다. 예전에 학교 수업을 들으면서 잠깐 사용한 기억은 있지만 그 당시 너무 기초만 사용해보았고 너무 오래되었던 기억이라 새로 한다는 생각으로 수업을 따라가야겠다.

——————————————————————————

본 후기는 [한글과컴퓨터x한국생산성본부x스나이퍼팩토리] 한컴 AI 아카데미 (B-log) 리뷰로 작성 되었습니다.

[스나이퍼팩토리] 한컴AI아카데미(26.06.11) JWT 기반 인증

cd-record — Thu, 11 Jun 2026 18:00:49 +0900

JWT

1. 인증(Authentication)

인증은 시스템이나 서비스가 사용자가 누구인지 확인하는 과정

FastAPI에서의 인증 방식

세션 기반: Depends와 같은 의존성 주입을 통해 쉽게 구현 가능, 쿠키 기반의 세션 관리를 사용
토큰 기반: Bearer토큰(와)과 같은 인증 스키마를 사용해 JWT 기반 인증을 구현 일반적

2. JWT이란?

JWT는 주로 인증 목적으로 사용되며, 토큰 안에 사용자의 인증 정보를 포함하고 있어 서버가 별도로 상태를 유지할 필요가 없습니다.

JWT의 구조

Header(헤더): 토큰의 타입(JWT)과 서명 생성에 사용된 암호화 알고리즘(예: HS256) 정보가 담깁니다.
Payload(페이로드): 토큰에 담을 실제 정보(사용자 식별 ID, 권한, 토큰 만료 시간 등)가 Key-Value 형태의 '클레임(Claim)'으로 포함됩니다.
Signature(서명): 헤더와 페이로드를 서버가 가지고 있는 비밀키(Secret Key)로 암호화한 값입니다. 이를 통해 토큰의 위변조 여부를 검증합니다.

JWT 인증 동작 방식

사용자가 아이디와 비밀번호로 로그인을 요청합니다.
서버는 검증 후 , 사용자 정보와 비밀키를 이용해 JWT 토큰을 발급하여 클라이언트에게 전달합니다.
클라이언트는 이 토큰을 저장하고, 서버에 요청을 보낼 때마다 HTTP 헤더(Authorization)에 토큰을 포함시켜 보냅니다.
서버는 토큰의 서명(Signature)을 복호화하고 검증하여 변조되지 않았는지, 만료되지는 않았는 지 확인 후 요청을 처리합니다.

JWT의 장단점

장점

무상태성: 서버가 세션 상태를 기억할 필요 없이 토큰 하나로 사용자를 인증하므로 서버 확정성이 뛰어납니다.
자체 포함: 토큰 안에 필요한 모든 정보가 들어있어 데이터베이스 조회를 줄일 수 있습니다.

단점

토큰 무효화의 어려움: 한 번 발급된 토큰은 서버에서 강제로 만료시킬 수 없어 보안상 위험(토큰 탈취 등)이 있을 수 있습니다.
데이터 크기: 페이로드에 많은 정보를 담을수록 토큰의 길이가 길어져 네트워크 트래픽에 영향을 줄 수 있습니다.

3. FastAPI에서 JWT 사용법

JWT 인증을 구현하기 위해서는 크게 5단계를 거친다.

① 필요한 라이브러리 설치 및 불러오기

JWT 인증을 위해 필요한 라이브러리를 설치한다.

pip install pyjwt bcrypt

import jwt
import bcrypt
from fastapi.security import OAuth2PasswordBearer
from datetime import datetime, timedelta, timezone

② 비밀키와 JWT 설정

JWT를 생성하고 검증하기 위해 서버만 알고 있는 비밀키를 설정한다.

SECRET_KEY = "super-secret-key-change-this-in-production"
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30

SECRET_KEY : 토큰 생성 및 검증에 사용하는 비밀키
ALGORITHM : JWT 암호화 알고리즘
ACCESS_TOKEN_EXPIRE_MINUTES : 토큰 유효 시간

실제 서비스에서는 SECRET_KEY를 코드에 직접 작성하지 않고 .env 파일에 저장하여 사용한다.

③ OAuth2PasswordBearer 생성

FastAPI는 JWT를 쉽게 사용할 수 있도록 OAuth2PasswordBearer를 제공한다.

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="login")

여기서

tokenUrl="login"

은 토큰을 발급받는 로그인 주소를 의미한다.

JWT가 필요한 API에서는

token: str = Depends(oauth2_scheme)

만 작성하면 자동으로

Authorization: Bearer JWT토큰

헤더에서 토큰을 읽어온다.

④ JWT 토큰 생성

로그인 성공 시 JWT 토큰을 생성하여 사용자에게 반환한다.

def create_access_token(data: dict,
                        expires_delta: Optional[timedelta] = None):

    to_encode = data.copy()

    expire = datetime.now(timezone.utc) + (
        expires_delta or timedelta(minutes=15)
    )

    to_encode.update({"exp": expire})

    return jwt.encode(
        to_encode,
        SECRET_KEY,
        algorithm=ALGORITHM
    )

토큰에는 보통 다음 정보를 저장한다.

{
    "sub": username,
    "exp": 만료시간
}

sub : 사용자 식별 정보
exp : 토큰 만료 시간

로그인 성공 시

access_token = create_access_token(
    data={"sub": user["username"]},
    expires_delta=timedelta(minutes=30)
)

return {
    "access_token": access_token,
    "token_type": "bearer"
}

형태로 클라이언트에게 전달한다.

⑤ JWT 토큰 검증

JWT가 필요한 API에서는 전달받은 토큰을 검증한다.

payload = jwt.decode(
    token,
    SECRET_KEY,
    algorithms=[ALGORITHM]
)

토큰에서 사용자 정보를 꺼낸다.

username = payload.get("sub")

토큰이

변조되었거나
만료되었거나
올바르지 않으면

예외를 발생시킨다.

except jwt.PyJWTError:
    raise HTTPException(
        status_code=401,
        detail="Could not validate credentials"
    )

이후 DB에서 사용자를 조회하여 실제 존재하는 계정인지 확인한다.

SELECT username
FROM users
WHERE username = ?

존재하면 인증 성공이다.

4. JWT 인증 과정

JWT 인증은 다음 순서로 동작한다.

① 회원가입
        │
        ▼
DB에 사용자 저장
        │
        ▼
② 로그인
(ID / Password)
        │
        ▼
비밀번호 검증
        │
        ▼
JWT 생성
        │
        ▼
클라이언트에게 전달
        │
        ▼
클라이언트가 토큰 저장
(LocalStorage, SessionStorage 등)
        │
        ▼
API 요청
Authorization: Bearer JWT
        │
        ▼
FastAPI가 JWT 검증
        │
        ▼
사용자 정보 확인
        │
        ▼
API 실행

5. 주요 JWT 함수

함수설명

jwt.encode()	JWT 생성
jwt.decode()	JWT 검증 및 데이터 추출
OAuth2PasswordBearer()	Authorization 헤더에서 Bearer 토큰 추출
Depends()	JWT 인증을 필요한 API에 적용
create_access_token()	JWT 생성 함수

6. JWT와 세션 로그인 비교

구분세션 로그인JWT 로그인

인증 정보 저장	서버(Session)	클라이언트(Token)
서버 상태	Stateful	Stateless
서버 메모리	사용	거의 사용하지 않음
확장성	낮음	높음
로그아웃	쉬움	토큰 만료 전까지 무효화 어려움
사용 예시	웹 사이트	REST API, 모바일 앱

——————————————————————————

본 후기는 [한글과컴퓨터x한국생산성본부x스나이퍼팩토리] 한컴 AI 아카데미 (B-log) 리뷰로 작성 되었습니다.

[스나이퍼팩토리] 한컴AI아카데미(26.06.10) Fast API

cd-record — Wed, 10 Jun 2026 19:29:14 +0900

FastAPI

# FastAPI란 무엇인가?

FastAPI는 파이썬으로 웹 서버(API)를 만들기 위한 현대적이고 매우 빠른 프레임워크입니다.

왜 쓰는가?: 코드가 직관적이고, 실행 속도가 매우 빠르며, 비동기(Async) 처리가 쉬워서 현대적인 웹 서비스 구축에 적합합니다.
핵심 개념: @app.get이나 @app.post처럼 데코레이터(@)를 사용해 "이 주소(URL)로 접속하면 이 함수를 실행해라"라고 지정하는 방식입니다.

* Flask vs FastAPI

구분	Flask	FastAPI
속도	상대적으로 느림 (동기 방식)	매우 빠름 (Node.js/Go와 비견됨)
비동기 처리	지원이 제한적임	완벽하게 지원 (Async/Await)
데이터 검증	직접 구현하거나 외부 라이브러리 필요	Pydantic을 통한 자동 검증
문서화	직접 만들어야 함	Swagger API 문서 자동 생성
학습 난이도	아주 쉬움	중간 정도 (비동기 개념 필요)

# Uvicorn

Python으로 작성된 초고속 비동기 ASGI(Asynchronous Server Gateway Interface) 웹 서버

Uvicorn의 핵심 역할

웹 서버와 애플리케이션 연결: 외부(사용자)로부터 들어오는 HTTP 요청을 받아 애플리케이션에 전달하고, 애플리케이션의 응답을 다시 사용자에게 돌려주는 역할을 합니다.
비동기(Async/Await) 지원: 파이썬의 asyncio를 기반으로 설계되어 빠르고 효율적인 비동기 처리가 가능합니다.
초고속 성능: uvloop 및 httptools와 같은 라이브러리를 사용하여 Node.js나 Go와 견줄 만큼 빠른 속도를 자랑합니다.
웹소켓(WebSocket) 기본 지원: HTTP 요청뿐만 아니라 실시간 양방향 통신인 WebSocket을 기본적으로 지원합니다.

## FastAPI랑 Uvicorn 관계

FastAPI (웹 프레임워크): 누가 어떤 주소로 들어왔을 때, 어떤 함수를 실행할지 결정하는 '두뇌'입니다. 하지만 이 두뇌는 스스로 외부와 통신하는 능력이 없습니다.
Uvicorn (서버/통신사): 외부 브라우저(크롬 등)로부터 오는 복잡한 신호를 받아서, FastAPI라는 두뇌가 이해할 수 있는 형식으로 전달해 주는 '심장'이자 '통신사'입니다.

# EX) PYTHON01

1. 라이브러리 임포트 및 앱 생성

from fastapi import FastAPI
from pydantic import BaseModel, Field
from fastapi.responses import HTMLResponse, PlainTextResponse, JSONResponse
import uvicorn

app = FastAPI()

FastAPI: 웹 서버 기능을 제공하는 핵심 클래스입니다.
BaseModel: 데이터의 구조를 정의하고 검증하기 위한 Pydantic의 도구입니다.
responses: JSON 외에 HTML이나 일반 텍스트 등 다양한 형식의 응답을 반환할 때 사용합니다.

2. Pydantic 모델 정의 (데이터 틀 만들기)

class UserItem(BaseModel):
    name: str
    age: int  # 나이는 반드시 정수여야 함

class Item(BaseModel):
    name: str = Field(examples=["맥북 프로"]) # 예시 값 지정
    price: float

BaseModel: 이 클래스를 상속받으면, 들어오는 데이터가 name은 문자열(str), age는 정수(int)인지 자동으로 확인합니다. 틀린 타입이 들어오면 서버가 알아서 에러 메시지를 보내줍니다.
Field(examples=[...]): API 문서(Swagger)를 볼 때 사용자에게 "이런 값을 넣으세요"라고 예시를 보여주는 친절한 기능입니다.

3. API 엔드포인트 분석

[상품 생성 API]

@app.post("/items", response_model=Item)
def create_item(item: Item):
    """
    ## 상품을 생성합니다
    이 API는 ...
    """
    return item

response_model=Item: 이 API가 돌려주는 데이터도 Item 모델을 따르도록 강제합니다.
Docstring ("""..."""): 함수 안에 쓴 주석은 나중에 자동으로 API 문서(Swagger)의 상세 설명으로 변환됩니다.

[기본 응답 및 사용자 생성]

@app.get("/")
def read_root():
    return {"Hello": "World"}

@app.post("/users")
def create_user(user: UserItem):
    return {"message": f"{user.name}님 환영합니다."}

create_user: UserItem 모델을 사용하여 클라이언트가 보낸 데이터가 올바른지 검증하고, 정상일 경우 user.name을 이용해 환영 메시지를 반환합니다.

4. 다양한 응답 형식 반환

FastAPI는 기본적으로 JSON을 반환하지만, 특정 형식으로 강제할 수 있습니다.

# 1. 텍스트 반환
@app.get("/text", response_class=PlainTextResponse)
def get_text():
    return "Hello World"

# 2. HTML 반환
@app.get("/html", response_class=HTMLResponse)
def get_html():
    return "<h1>안녕하세요</h1>"

response_class: 서버가 응답을 보낼 때 브라우저에게 "이건 JSON이야", "이건 HTML이야"라고 알려주는 역할을 합니다.

5. 서버 실행

if __name__ == "__main__":
    uvicorn.run("S001:app", host="127.0.0.1", port=8000, reload=True)
    # 콘솔과 동일: uvicorn main:app --host 127.0.0.1 --port 8000 --reload

uvicorn.run: FastAPI 애플리케이션(app)을 실행하는 서버 엔진입니다.
reload=True: 코드를 수정하고 저장하면 서버를 껐다 켜지 않아도 자동으로 반영해주는 개발용 핵심 옵션입니다.

# EX) PYTHON02

1. 필수 라이브러리 및 설정

from fastapi import FastAPI, Request
from fastapi.templating import Jinja2Templates
from fastapi.staticfiles import StaticFiles

app = FastAPI()

# 템플릿(HTML)이 있는 폴더 지정
templates = Jinja2Templates(directory="0610/templates")

# 정적 파일(CSS, JS, 이미지)이 있는 폴더 마운트
app.mount("/static", StaticFiles(directory="0610/static"), name="static")

Jinja2Templates: HTML 파일 안에 파이썬 변수를 쏙 집어넣어 동적인 웹 페이지를 만드는 도구입니다. (예: {{ title }})
app.mount("/static", ...): 브라우저가 CSS나 JS 파일을 요청할 때, 서버 내부의 0610/static 폴더에서 파일을 찾아 건네주겠다는 약속입니다.

2. 메인 페이지 라우팅

@app.get("/")
async def read_root(request: Request):
    context = {"title": "FastAPI 템플릿 예제", "message": "Hello World"}
    return templates.TemplateResponse(        
        request=request,
        name="index.html",
        context=context
    )

request: Request: FastAPI가 현재 접속한 사용자의 정보(IP, 헤더 등)를 담아 자동으로 전달해주는 객체입니다. 템플릿을 렌더링할 때 반드시 필요합니다. (HTML 페이지를 보여줄 때만 필요)
async (비동기): 이 함수가 실행되는 동안 서버가 멈추지 않고 다른 요청도 동시에 처리할 수 있게 합니다. 데이터베이스 조회나 파일 읽기처럼 시간이 걸리는 작업을 할 때 매우 중요합니다.
request=request: 이 템플릿을 요청한 사용자가 누구인지, 어떤 환경(브라우저 언어, 쿠키 등)인지 파악해서 보내기
name = "index.html": 어떤 HTML 파일을 가져올 지 보내기
context: HTML 파일로 보낼 파이썬 데이터입니다. index.html 안에서 {{ title }}이라고 쓰면 "FastAPI 템플릿 예제"라는 글자가 나타나게 됩니다.

Q. 왜 async를 붙이나요?

FastAPI는 비동기 프레임워크입니다.

보통 웹 서버는 한 번에 한 명의 요청만 처리하면 느려지는데, async를 사용하면 "데이터를 DB에서 가져오는 동안(기다리는 시간)" 다른 사용자의 접속을 먼저 처리할 수 있습니다.
따라서, 성능을 극대화하려면 DB 작업이 포함된 함수에는 async를 붙이는 것이 권장됩니다.

# EX) PYTHON03

1. 주요 라이브러리 및 변수

from fastapi import FastAPI
import asyncio
import uvicorn
from fastapi.responses import PlainTextResponse

app = FastAPI()

total = ''

asyncio: 파이썬에서 비동기 프로그래밍을 할 때 사용하는 표준 라이브러리입니다.
total: 여러 비동기 함수들이 결과를 합치는 공용 변수입니다.

2. 비동기 함수 (Async Tasks)

async def async_func():
    await asyncio.sleep(2) # 2초 동안 '대기' (다른 일 할 수 있음)
    global total
    total += "Async World1 "

async def async_func2():
    await asyncio.sleep(1) # 1초 동안 '대기'
    global total
    total += "Async World2 "

async def: 이 함수는 비동기 함수(코루틴)임을 선언합니다.
await asyncio.sleep(n): 가장 중요한 부분입니다. 여기서 "n초간 쉬어라"라고 명령하는데, 이때 "나는 쉬는 동안 CPU는 다른 일을 해!"라고 컴퓨터에게 제어권을 넘겨줍니다.
덕분에 async_func가 2초를 쉬는 동안 CPU는 1초 쉬는 async_func2를 먼저 처리할 수 있게 됩니다.

3. 메인 API 엔드포인트 (read_root)

@app.get("/", response_class=PlainTextResponse)
async def read_root():
    global total
    total = ""

    # 작업을 생성하고 동시에 실행 시작
    task1 = asyncio.create_task(async_func())
    task2 = asyncio.create_task(async_func2())

    # 모든 작업이 끝날 때까지 기다림
    await task1
    await task2

    return total

asyncio.create_task(...): 이 명령은 함수를 바로 실행하지 않고, "이 작업을 백그라운드에서 실행해 놔!"라고 예약하는 것과 같습니다.
동시 처리의 마법: task1을 만들자마자 바로 task2도 만들어버립니다. 즉, task1이 2초를 쉬는 동안 task2가 1초를 쉬고 먼저 완료되는 구조가 됩니다.
await task1, await task2: 예약해 둔 작업들이 끝날 때까지 기다렸다가 다음 단계로 넘어갑니다.

# EX) PYTHON04

1. 외부 데이터 호출의 핵심 httpx

import httpx

# ...

async with httpx.AsyncClient() as client:
    response = await client.get(url)
    weather_data = response.json()

httpx: 파이썬에서 다른 서버(여기서는 Open-Meteo)로 데이터를 요청할 때 사용하는 라이브러리입니다. requests와 비슷하지만, 비동기(Async)를 지원하기 때문에 FastAPI와 궁합이 매우 좋습니다.
AsyncClient(): 비동기 방식으로 데이터를 받아옵니다. await를 사용하여 데이터가 올 때까지 서버가 멈추지 않게 합니다.

2. 데이터 가공 (데이터 정제)

times = weather_data["hourly"]["time"]
temperatures = weather_data["hourly"]["temperature_2m"]
hourly_forecast = list(zip(times, temperatures))

zip(times, temperatures): 이것은 아주 효율적인 기법입니다. 시간 리스트와 기온 리스트가 따로 놀고 있을 때, 이 둘을 순서대로 하나씩 짝을 지어 (시간, 온도) 형태의 튜플 리스트로 만들어 줍니다.
- HTML에서 반복문을 돌릴 때 아주 편리한 구조가 됩니다.

3. 화면 전달 및 제한

context = {
    "title": "서울 시간별 기온 예보",
    "forecast": hourly_forecast[:24]
}

hourly_forecast[:24]: 데이터가 너무 많으면 사용자가 읽기 힘듭니다. 파이썬의 슬라이싱([:24]) 기능을 사용해 딱 필요한 24시간치만 잘라서 깔끔하게 보여줍니다.

001.ipynb

0.02MB

——————————————————————————

본 후기는 [한글과컴퓨터x한국생산성본부x스나이퍼팩토리] 한컴 AI 아카데미 (B-log) 리뷰로 작성 되었습니다.

[스나이퍼팩토리] 한컴AI아카데미(26.06.09) 네이버메일보내기자동화(Selenium)

cd-record — Wed, 10 Jun 2026 00:29:50 +0900

Selenium & PyAutoGUI를 활용한 네이버 메일 자동화

목적: 네이버 로그인부터 메일 작성, 내용 입력 및 전송까지의 과정을 자동화. 특히 단순 자동화를 넘어 pyperclip을 이용해 클립보드에 텍스트를 복사한 뒤 Ctrl+V를 수행함으로써, 한글 입력 시 발생할 수 있는 브라우저 매크로 오류를 우회하는 전략을 사용

# 주요 기능 및 라이브러리 역할

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from webdriver_manager.chrome import ChromeDriverManager
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC 
from selenium.webdriver.common.by import By
import time

import pyautogui
import pyperclip

# Selenium (webdriver): 웹 브라우저를 제어하여 요소 탐색 및 클릭 수행.
# PyAutoGUI: 브라우저 내 입력을 제어하며, 사용자로부터 팝업창을 통해 정보를 입력받음.
# Pyperclip: 한글 등 다국어 텍스트 입력 시 발생할 수 있는 전송 오류를 방지하기 위해 클립보드 복사/붙여넣기 방식을 활용.
# WebDriver Manager: 크롬 드라이버를 수동으로 다운로드할 필요 없이 자동으로 설치 및 업데이트 관리.

## PyAutoGUI, Pyperclip을 쓰는 기술적 이유

한글 입력 이슈 해결
- 자음/모음 분리: 안녕하세요가 ㅇㅏㄴㄴㅕㅇㅎㅏㅅㅔㅇㅛ처럼 분리되어 입력되는 현상.
- 글자 누락: 서버 응답 속도가 느릴 경우 중간 글자가 씹히는 현상.
- 인코딩 오류: 브라우저와 Selenium 드라이버 간의 통신 과정에서 한글이 깨지는 현상.
해결책: pyperclip으로 클립보드에 완성된 문자열을 저장하고, pyautogui로 Ctrl+V를 입력하면 OS 레벨에서 복사된 데이터를 한 번에 붙여넣기 때문에 글자 깨짐이나 누락이 발생하지 않습니다.
입력 속도 최적화
- send_keys()는 글자를 한 글자씩 브라우저로 전송합니다. 본문 내용이 아주 긴 경우, 모든 글자를 전송하는 데 시간이 상당히 걸립니다.
  - send_keys(): "안녕하세요... (긴 글)" → 전송까지 초 단위 소요.
  - Ctrl + V: 클립보드의 데이터를 즉시 브라우저로 전달 → 즉시 입력
브라우저의 보안 정책 우회
- 일부 웹사이트는 자동화 툴(Selenium)이 입력하는 send_keys()를 감지하여 봇(Bot)으로 차단하는 경우가 있습니다.
  - pyautogui를 사용하여 Ctrl+V를 수행하는 것은 실제 사용자가 키보드를 누르는 행위와 매우 유사하게 동작합니다. 따라서 자동화 감지 로직을 비교적 안전하게 우회할 수 있는 '사람 같은' 입력 방식이 됩니다.

# 사용자 정보 입력 (PyAutoGUI 활용)

uid = pyautogui.prompt("네이버 ID: ", default="l1234")
pwd = pyautogui.password("비밀번호: ")
toname = pyautogui.prompt("받는사람 이름: ", default="홍길동")
tomail = pyautogui.prompt("받는사람 메일: ", default="12345@gmail.com")
response = pyautogui.confirm(
    '어떤 내용을 하시겠습니까?',
    buttons=['가입안내', '합격안내', '계약서']
)

if response=="가입안내":
    to_subject = "[테스트] 가입안내입니다."
    to_content = f"{toname}님 가입을 환영합니다.\n\n최고의 서비스로 최선을 다하겠습니다.\n\n감사합니다."
elif  response=="합격안내":
    to_subject = "[테스트] 합격결과입니다."
    to_content = f'''{toname}님 이번 면접에 최종 합격 하였습니다.\n
저희 가족이 되심을 축하합니다.
입사일은 2026년 10월 1일입니다.\n
감사합니다.'''
elif  response=="계약서":    
    to_subject = "[테스트] 점심 계약서."
    to_content = f'''{toname}님 최종 계약서 내용입니다.\n
귀하는 2024년 12월 4일 ~ 2025년 4월 24일까지 점심을 사기로 하였습니다.\n
# 계약자 A: {toname}
# 계약자 B: 이순신'''

pyautogui의 prompt와 password 함수를 사용하여 스크립트 실행 시 사용자로부터 ID, 비밀번호, 받는 사람 정보를 실시간으로 입력받습니다. 또한 confirm 함수를 통해 선택된 항목에 따라 메일 본문(to_content)과 제목(to_subject)을 조건문(if-elif)으로 동적 생성합니다.

* 코드를 main()함수로 묶은 이유?

1. 모듈화 및 재사용성 (Import 방지)
- 파이썬에서는 다른 파일에서 이 코드를 import 할 때, 함수 밖의 코드들은 import 되는 순간 즉시 실행됩니다.
- 함수로 묶지 않았을 때: 다른 파일에서 이 코드를 가져오기만 해도 메일 자동화 프로그램이 강제로 실행되어 버립니다.
- 함수로 묶었을 때: main() 함수 안에 로직을 넣어두면, 다른 파일에서 import 해도 함수를 직접 호출(main())하기 전까지는 코드가 실행되지 않습니다. 즉, 필요할 때만 호출할 수 있는 도구로 만드는 것입니다.

2. 코드의 구조적 깔끔함
- 프로그램이 커지면 여러 개의 함수가 생기게 됩니다. main()은 프로그램의 "시작점(Entry Point)" 역할을 합니다.
- 코드를 읽는 사람(또는 미래의 본인)이 어디서부터 프로그램이 시작되는지 직관적으로 알 수 있습니다.
- 스크립트의 흐름(입력 -> 설정 -> 실행 -> 종료)을 한눈에 파악하기 좋습니다.

3. if __name__ == "__main__":의 마법
- 이 구문은 "이 파일을 직접 실행했을 때만 아래 코드를 실행하라"는 뜻입니다.
- 직접 실행할 때: __name__ 변수는 "__main__"이라는 값을 가집니다. 따라서 main()이 실행됩니다.
- 다른 파일에서 불러올 때: __name__ 변수는 파일 이름이 됩니다. 따라서 if 조건이 거짓이 되어 main()이 자동으로 실행되지 않습니다.

# 브라우저 구동 및 로그인

chrome_options = Options()
chrome_options.add_experimental_option("detach", True)

# 불필요한 에러메시지 노출 방지
chrome_options.add_experimental_option("excludeSwitches", ["enable-logging"])

service = Service(excutable_path=ChromeDriverManager().install())
driver = webdriver.Chrome(service=service, options = chrome_options)

time.sleep(2)
driver.implicitly_wait(5)
driver.maximize_window()

driver.get("https://nid.naver.com/nidlogin.login?mode=form&url=https://www.naver.com/")

# 아이디 입력창
id = driver.find_element(By.CSS_SELECTOR, "#input_item_id")
id.click()

pyperclip.copy(uid)
pyautogui.hotkey("ctrl","v")
time.sleep(2)

# 비밀번호 입력 창
pw = driver.find_element(By.CSS_SELECTOR, "#input_item_pw")
pw.click()

pyperclip.copy(pwd)
pyautogui.hotkey("ctrl","v")
time.sleep(2)

login_btn = driver.find_element(By.CSS_SELECTOR, "#log\\.login")
login_btn.click()

time.sleep(30)

detach 옵션: 코드가 끝난 뒤 브라우저가 바로 닫히지 않고 열려 있게 합니다.
로그인 로직: CSS Selector(input_item_id, input_item_pw)를 사용해 아이디와 비밀번호 필드를 찾습니다. 이후 클립보드 복사 → 붙여넣기 방식으로 입력 후 로그인 버튼을 클릭합니다.
time.sleep(30): 네이버의 보안 문자가 뜰 경우를 대비해 사용자가 직접 30초 동안 캡차(CAPTCHA)를 처리할 시간을 줍니다.

# 메일 쓰기 화면 창 넘어가기 및 메일쓰기 (메일 버튼, 메일 받는 사람, 메일 제목)

mail_btn = driver.find_element(By.CSS_SELECTOR, "li.shortcut_item a")
mail_btn.click()

time.sleep(2)

# 윈도우창 핸들링
windows = driver.window_handles
# 새로 열린 창으로 이동
driver.switch_to.window(windows[-1])

# 메일 버튼
write_btn = driver.find_element(By.CSS_SELECTOR, "a.button_write")
write_btn.click()

time.sleep(2)

# 메일 받는 사람
to_email = driver.find_element(By.CSS_SELECTOR, "#recipient_input_element")
to_email.click()

time.sleep(1)

pyperclip.copy(tomail)
pyautogui.hotkey("ctrl", "v")

# 메일 제목
subject_email = driver.find_element(By.CSS_SELECTOR, "#subject_title")
subject_email.click()
pyperclip.copy(to_subject)
pyautogui.hotkey("ctrl", "v")

time.sleep(2)

네이버 메일의 '메일 쓰기'는 새로운 탭(창)에서 열리므로 window_handles를 통해 마지막으로 열린 창으로 포커스를 이동합니다.
CSS Selector를 사용해 메일쓰기버튼을 누른 후 메일 받는 사람, 메일 제목 필드를 찾습니다. 이후 클립보드 복사 → 붙여넣기 방식으로 입력합니다.

# iframe 제어 및 내용 입력 (메일 본문 작성)

# iframe으로 이동
WebDriverWait(driver, 10).until(
    EC.frame_to_be_available_and_switch_to_it((By.CSS_SELECTOR, "#content > div.contents_area > div > div.editor_area > div > div.editor_body > iframe"))
)

time.sleep(2)

# 내용칸 로드후 다음 진행
mail_content = WebDriverWait(driver, 10).until(
    EC.presence_of_element_located((By.CSS_SELECTOR, "div.workseditor-content"))
)

# 내용 붙여넣기
mail_content.click()
pyperclip.copy(to_content)
pyautogui.hotkey("ctrl","v")

time.sleep(2)

네이버 메일의 에디터는 iframe이라는 '페이지 안의 페이지' 구조로 되어 있습니다. 셀레늄은 기본 페이지에만 접근할 수 있으므로, 반드시 switch_to.frame을 통해 에디터 영역으로 진입해야 내용 작성이 가능합니다.
iframe 내부의 본문 영역을 찾아 클릭하고, 앞서 복사해둔 내용을 Ctrl+V로 붙여넣습니다.

* iframe으로 전환 후 바로 클릭하고 붙여넣기 못하고 내용칸 로드될 때까지 기다려야하는 이유

1. 브라우저의 비동기 렌더링 (가장 큰 이유)
- 웹 브라우저는 페이지를 불러올 때 모든 요소를 한 번에 다 보여주지 않습니다. 특히 메일 서비스처럼 복잡한 에디터는 다음과 같은 순서로 작동합니다.
  - 프레임(iframe) 로드: 먼저 큰 틀인 빈 박스(iframe)가 먼저 생성됩니다.
  - 내부 엔진 로드: 그 안에서 자바스크립트가 실제 글을 쓸 수 있는 에디터 영역(div.workseditor-content)을 동적으로 생성하고, 각종 서식 툴바를 입힙니다.

이 과정에서 iframe이라는 '빈 껍데기'가 생성된 직후에 click()을 수행하면, 정작 내부에 글을 쓸 실제 영역인 div는 아직 브라우저에 존재하지 않을 확률이 매우 높습니다. 결과적으로 NoSuchElementException 에러가 발생하게 됩니다.

2. 동적 로딩과 JavaScript의 한계
- 네이버 메일 같은 현대적인 웹사이트는 대부분 SPA(Single Page Application) 방식을 사용합니다.
  - iframe 태그가 HTML에 나타났다고 해서 그 내부의 기능이 완벽하게 초기화(Initialize)된 것은 아닙니다.
  - "내용칸 로드 후 진행"한다는 것은, 단순히 요소가 존재하는지 확인하는 것을 넘어 "브라우저가 해당 영역에 사용자의 입력을 받을 준비를 마쳤는지(Ready 상태)"를 확인하는 필수적인 과정입니다.

# 최종 전송

# 원래 창으로 돌아가기
driver.switch_to.default_content()

# 보내기 버튼
mail_send = driver.find_element(By.CSS_SELECTOR, "#content > div.mail_toolbar.type_write > div:nth-child(1) > div > button.button_write_task")
mail_send.click()

time.sleep(3)
driver.quit()

default_content()를 호출해 다시 메인 페이지로 돌아와 '보내기' 버튼을 누릅니다.
그 후 diver.quit()로 종료합니다.

느낀점

어제 Selenium 개념은 알았지만 제대로 써보지 못해 오늘 네이버 메일 보내기 자동화로 Selenium을 써보았다. 확실히 요즘 반복된 업무를 자동화하는 게 나름 중요한 시대라고 생각되는데, 파이썬으로 자동화하는데 Selenium을 통해 편하게 할 수 있는 거 같아 나중에 기본 틀을 만들어두면 유용하게 사용할 수 있을 것 같다.

——————————————————————————

본 후기는 [한글과컴퓨터x한국생산성본부x스나이퍼팩토리] 한컴 AI 아카데미 (B-log) 리뷰로 작성 되었습니다.

파일형식	Reader	Writer
CSV	read_csv	to_csv
EXCEL	read_excel	to_excel
HTML	read_html	to_html
JSON	read_json	to_json
SQL	read_sql	to_sql