리스트가 느린 이유

• 각 원소가 독립된 파이썬 객체(PyObject)라 메모리에 흩어져 있음
• 리스트는 그 객체들의 주소(포인터)만 들고 있음
• 값 하나 읽으려면 포인터를 따라 점프해야 함 → CPU 캐시 미스
• 더할 때마다 “이게 int인가 str인가” 타입 검사를 반복

배열이 빠른 이유

• 값들이 연속된 메모리 블록에 나란히 놓임
• 모든 원소가 같은 타입·같은 크기 → 주소 계산만으로 접근
• 연산 루프가 C로 컴파일되어 돌아감 (파이썬 인터프리터 밖)
• CPU의 SIMD(한 번에 여러 값 계산) 명령까지 활용

첫 코드

import numpy as np      # 관례적 별칭

a = np.array([1, 2, 3, 4])
a * 2                   # array([2, 4, 6, 8])  <- 반복문 없음!

lst = [1, 2, 3, 4]
lst * 2                 # [1,2,3,4,1,2,3,4]    <- 리스트는 '반복'!

기본 생성

np.array([1,2,3])              # 리스트 -> 배열
np.array([[1,2],[3,4]])        # 2차원
np.array([1,2,3], dtype=float) # 타입 지정

np.zeros(5)          # [0. 0. 0. 0. 0.]
np.zeros((2,3))      # 2행 3열 0 행렬
np.ones((3,3))       # 전부 1
np.full((2,2), 7)    # 전부 7
np.eye(3)            # 단위행렬 (대각선만 1)
np.empty(3)          # 초기화 안 함 (쓰레기값, 가장 빠름)

# 기존 배열과 같은 모양으로
np.zeros_like(a)
np.ones_like(a)

수열 · 난수

np.arange(5)            # [0 1 2 3 4]
np.arange(2, 10, 2)     # [2 4 6 8]  (시작, 끝, 간격)
np.linspace(0, 1, 5)    # [0. 0.25 0.5 0.75 1.] (개수 지정)

# 난수 (신형 API 권장)
rng = np.random.default_rng(42)   # seed 고정 -> 재현 가능
rng.random(5)              # 0~1 균등분포
rng.integers(1, 7, 10)     # 주사위 10번
rng.normal(0, 1, 1000)     # 정규분포 (평균0, 표준편차1)
rng.choice([1,2,3], 5)     # 임의 추출
rng.shuffle(a)             # 섞기

필수 속성

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

a.shape      # (2, 3)   행 2, 열 3
a.ndim       # 2        차원 수
a.size       # 6        전체 원소 개수
a.dtype      # int64    데이터 타입
a.itemsize   # 8        원소 하나의 바이트
a.nbytes     # 48       전체 바이트
a.T          # 전치 (행<->열)

dtype — 타입이 곧 메모리

a.astype(np.float32)     # 타입 변환 (복사본 생성)
np.array([1,2], dtype=np.int8)

# 정수 오버플로 주의!
np.array([127], dtype=np.int8) + 1   # -128 로 뒤집힘

인덱싱 문법

a = np.arange(12).reshape(3,4)

a[0]         # 0행 전체 -> [0 1 2 3]
a[0, 2]      # 0행 2열 -> 2   (a[0][2] 보다 빠름)
a[:, 1]      # 1열 전체 -> [1 5 9]
a[1:, 2:]    # 1행부터 x 2열부터
a[::2]       # 2칸씩 건너뛰기
a[::-1]      # 뒤집기
a[-1, -1]    # 마지막 원소

# 리스트와 다른 점: 콤마로 차원을 구분!
# 리스트라면 a[0][2], 배열은 a[0, 2]

view vs copy

a = np.arange(5)          # [0 1 2 3 4]

b = a[1:4]                # view (원본 공유!)
b[0] = 99
print(a)                  # [0 99 2 3 4]  <- 원본이 바뀜!

c = a[1:4].copy()         # 명시적 복사
c[0] = 0
print(a)                  # 원본 그대로

# view 여부 확인
b.base is a               # True -> view
c.base is None            # True -> 독립 배열

# 팬시 인덱싱은 항상 copy
d = a[[0,2,4]]            # copy

모양 바꾸기

a = np.arange(12)

a.reshape(3, 4)      # 3행 4열
a.reshape(4, -1)     # -1 = 알아서 계산 -> (4,3)
a.reshape(2, 2, 3)   # 3차원으로

a.ravel()            # 1차원으로 펴기 (가능하면 view)
a.flatten()          # 1차원으로 펴기 (항상 copy)

a.reshape(3, 4).T    # 전치 → (4,3)  (1차원 a.T 는 그대로)
np.transpose(a.reshape(2, 3, 2), (1,0,2))   # 축 순서 직접 지정 → (3,2,2)

# 차원 추가/제거 — 브로드캐스팅에서 자주 씀
a[:, np.newaxis]     # (12,) -> (12,1)
a[np.newaxis, :]     # (12,) -> (1,12)
np.expand_dims(a, 0)
np.squeeze(a[:, np.newaxis])   # 크기 1인 축 제거 (12,1) -> (12,)

reshape의 규칙

• 원소 개수(size)가 반드시 같아야 합니다. 12 → (5,3)은 에러
• 채우는 순서는 기본이 C 순서(행 우선). 마지막 축부터 채웁니다
• -1은 “나머지 하나는 알아서” — 한 번만 쓸 수 있습니다
• reshape은 대개 view라 값을 바꾸면 원본도 바뀝니다

브로드캐스팅 규칙 3줄

• ① 뒤에서부터 차원을 하나씩 비교합니다
• ② 크기가 같거나, 둘 중 하나가 1이면 통과
• ③ 1인 쪽이 상대 크기만큼 늘어난 것처럼 동작 (실제 복사 없음)

# 뒤에서부터 맞춰보기
(3, 4) + (4,)      -> (3, 4)   ✅  4==4, 3은 그대로
(3, 4) + (3, 1)    -> (3, 4)   ✅  1이 4로 확장
(3, 1) + (1, 4)    -> (3, 4)   ✅  양쪽 다 확장
(3, 4) + (3,)      -> ❌ ERROR  4 != 3
(2, 3, 4) + (3, 1) -> (2, 3, 4) ✅

실전 활용

a = np.arange(12).reshape(3,4)

# 전체에 상수 연산
a * 2 + 1

# 열마다 다른 가중치 적용 (shape (4,))
가중치 = np.array([1, 2, 3, 4])
a * 가중치

# 행마다 다른 값 더하기 -> 축을 세워줘야 함
행보정 = np.array([10, 20, 30])
a + 행보정[:, None]        # (3,1) 로 만들어 브로드캐스팅

# 표준화 (열 기준) — 머신러닝 전처리의 정석
(a - a.mean(axis=0)) / a.std(axis=0)

# 구구단 표 한 줄로 (외적)
np.arange(1,10)[:, None] * np.arange(1,10)[None, :]

집계 함수

a = np.arange(12).reshape(3,4)

a.sum()            # 66      전체
a.sum(axis=0)      # (4,)    열별 합  <- 행이 사라짐
a.sum(axis=1)      # (3,)    행별 합  <- 열이 사라짐
a.sum(axis=0, keepdims=True)   # (1,4) 축 유지

a.mean()   a.std()   a.var()
np.median(a)          # median 은 메서드가 아니라 np. 함수
a.min()    a.max()    # np.ptp(a) = max-min
a.argmin() a.argmax()          # 최소/최대 '위치'
a.cumsum() a.prod()

np.percentile(a, [25, 50, 75])
np.unique(a, return_counts=True)

axis 외우는 법

• shape의 몇 번째 숫자를 없앨 것인가가 axis입니다
• (3,4)에서 axis=0 → 3이 사라져 (4,) = 열마다 하나씩
• (3,4)에서 axis=1 → 4가 사라져 (3,) = 행마다 하나씩
• 화살표 방향으로 훑으면서 뭉갠다고 상상하면 헷갈리지 않습니다
• keepdims=True를 쓰면 축이 1로 남아 브로드캐스팅에 바로 쓸 수 있습니다

# keepdims의 진가 — 행별 비율 구하기
행합 = a.sum(axis=1, keepdims=True)   # (3,1)
비율 = a / 행합                        # 브로드캐스팅 성공!

# keepdims 없으면
행합 = a.sum(axis=1)     # (3,)
a / 행합                 # ❌ (3,4) vs (3,) 에러

불리언 마스킹

a = np.arange(12)

mask = a > 5           # bool 배열
a[mask]                # True인 것만 -> 1차원으로 평탄화
a[a % 2 == 0]          # 짝수만

# 조건 조합 — 반드시 & | ~ 와 괄호!
a[(a > 3) & (a < 8)]
a[(a < 2) | (a > 9)]
a[~(a > 5)]

# 값 대입도 가능
a[a > 5] = 0           # 조건에 맞는 곳만 0으로

# 개수/존재 확인
(a > 5).sum()          # 조건 만족 개수 (True=1)
(a > 5).any()          # 하나라도 있나
(a > 5).all()          # 전부 그런가
np.count_nonzero(a > 5)

팬시 인덱싱 · 위치 찾기

# 원하는 위치를 리스트로 지정 (결과는 항상 copy)
a[[0, 3, 7]]           # 0,3,7번째
m = a.reshape(3, 4)    # 2차원에서는 행 목록·열 목록을 짝지어
m[[0,2], [1,3]]        # (0,1), (2,3) 원소 두 개

# 순서 바꾸기/반복도 가능
a[[2, 2, 0]]

# 조건을 만족하는 '위치' 찾기
np.where(a > 5)              # 인덱스 튜플
np.argwhere(a > 5)           # (n, ndim) 좌표 배열
np.flatnonzero(a > 5)        # 평탄화된 인덱스

# 정렬
np.sort(a)              # 정렬된 복사본
a.sort()                # 제자리 정렬
np.argsort(a)           # 정렬 순서의 인덱스
a[np.argsort(a)[::-1]]  # 내림차순 정렬

# 상위 3개 (전체 정렬보다 빠름)
np.partition(a, -3)[-3:]

메모리 절약

a.nbytes / 1024**2          # MB 확인

# 타입만 바꿔도 절반
a32 = a.astype(np.float32)  # float64 대비 50% 절감

# 제자리 연산 — 새 배열을 안 만듦
a += 1          # a = a + 1 보다 메모리 유리
np.add(a, 1, out=a)         # 결과를 a에 직접 씀
np.multiply(a, 2, out=a)

# 큰 파일은 메모리맵으로 (RAM보다 큰 파일도 처리)
a = np.memmap("big.dat", dtype="float32", mode="r", shape=(10**7,))

# 저장/불러오기
np.save("a.npy", a)         # 단일 배열 (빠름)
np.load("a.npy")
np.savez("multi.npz", x=a, y=b)
np.savetxt("a.csv", a, delimiter=",")   # 느림, 호환용

성능 체크리스트

• for 문이 보이면 의심 — 대부분 벡터 연산으로 바꿀 수 있습니다
• 배열을 키우지 마세요 — np.empty(n)로 미리 잡고 채우기
• dtype을 줄이세요 — float64 → float32면 메모리 절반, 속도 향상
• out= / += 로 임시 배열 생성을 줄이세요
• 연속 메모리가 빠릅니다 — 전치를 반복 연산할 땐 np.ascontiguousarray()
• 그래도 느리면 numba · cupy(GPU) 검토

# 측정하는 습관 (Jupyter)
%timeit a ** 2
%timeit [x**2 for x in lst]

# 일반 파이썬에서는
import time
t = time.perf_counter()
result = a ** 2
print(time.perf_counter() - t)

np.einsum — 축 연산의 만능 표기

# "입력축 -> 출력축" 문자열로 곱셈+축소를 한 번에
np.einsum("ij,jk->ik", A, B)      # 행렬곱 (= A @ B)
np.einsum("ij->ji", A)            # 전치
np.einsum("ii->", A)              # trace (대각합)
np.einsum("ij->i", A)             # 행별 합 (= sum(axis=1))
np.einsum("i,i->", u, v)          # 내적
np.einsum("i,j->ij", u, v)        # 외적

# 진가: 3차원 이상 배치 연산이 한 줄
# (배치 100개의 행렬곱: (100,3,4) x (100,4,5) -> (100,3,5))
np.einsum("bij,bjk->bik", X, Y)

# 규칙: 같은 문자 = 곱해서 더할 축, 출력에서 빠진 문자 = 축소

stride 트릭 — 복사 없는 뷰의 원리

a = np.arange(12, dtype=np.int64).reshape(3, 4)
a.strides        # (32, 8) — 다음 행까지 32B, 다음 열까지 8B

a.T.strides      # (8, 32) — 전치가 공짜인 이유:
#                  메모리는 그대로, 걷는 보폭만 바꿈

# 슬라이딩 윈도우도 복사 없이 (이동평균의 원리)
from numpy.lib.stride_tricks import sliding_window_view
x = np.arange(10)
w = sliding_window_view(x, 4)    # shape (7, 4), 메모리 공유!
w.mean(axis=1)                   # 이동평균 완성

# 연속성 확인·복구
a.T.flags["C_CONTIGUOUS"]        # False
b = np.ascontiguousarray(a.T)    # 반복 연산 전 정렬

서로 변환하기

import numpy as np, pandas as pd

# NumPy -> Pandas
a = np.arange(12).reshape(3,4)
df = pd.DataFrame(a, columns=list("ABCD"))
s  = pd.Series(np.array([1,2,3]))

# Pandas -> NumPy
df.to_numpy()          # ★ 권장
df["A"].to_numpy()
df.values              # 구형 (여전히 동작)

# 판다스 안에서 NumPy 함수 그대로 사용
df["log"] = np.log1p(df["A"])     # log(1+x) — A 에 0 이 있어 np.log 면 -inf
df["등급"] = np.where(df["A"] > 5, "상", "하")
df["clip"] = np.clip(df["A"], 0, 10)

언제 무엇을 쓸까

파일 실행 말고도 이만큼

python -c "print(1+1)"          # 한 줄 즉석 실행 (스크립트 파일 없이)
python -i main.py               # 실행이 끝난 뒤 REPL 로 남기 ★ 디버깅 최강
python -m pdb main.py           # 디버거로 실행
python -X dev main.py           # 개발 모드 — 평소 숨은 경고까지 다 켬

# 설치된 모듈을 '명령'처럼 쓰기 — 설치 없이 되는 것들
python -m http.server 8000      # 즉석 파일 서버 (지금 폴더를 웹으로)
python -m json.tool data.json   # JSON 예쁘게 정렬해 출력
python -m venv .venv            # 표준 가상환경
python -m zipfile -c a.zip x/   # 압축
python -m calendar              # 달력
python -m this                  # 파이썬 철학 (한 번은 읽어 보세요)

python x.py 와 python -m x 는 다릅니다

# 겉보기엔 같아 보이지만 import 기준 경로가 다릅니다
python src/main.py     # sys.path[0] = src/        ← 파일이 있는 폴더
python -m src.main     # sys.path[0] = 현재 폴더    ← 명령을 친 폴더

# 그래서 이런 일이 벌어집니다
#   src/main.py 안에서  from src.utils import f
#   → python src/main.py   ❌ ModuleNotFoundError: No module named 'src'
#   → python -m src.main   ✅ 됩니다

알고 나면 계속 쓰게 되는 것들

# 긴 숫자에 언더바 — 자릿수 세지 않아도 됩니다 (값은 그대로)
매출 = 1_250_000_000          # 12억 5천

# 여러 개 한 번에 · 남는 건 몰아서
a, b = 1, 2
a, b = b, a                   # 임시 변수 없이 교환
첫째, *나머지 = [1, 2, 3, 4]   # 첫째=1, 나머지=[2,3,4]
_, 중요, _ = 세개짜리          # 관심 없는 건 _ 로

# 진법
0b1010   0o17   0xff          # 2 · 8 · 16진수 리터럴
int("ff", 16)                 # 255
f"{255:b}"  f"{255:x}"        # '11111111'  'ff'

# 몫과 나머지를 한 번에
분, 초 = divmod(총초, 60)

# 조건 안에서 대입까지 (:= 바다코끼리, 3.8+)
if (줄수 := len(행들)) > 100:
    print(f"{줄수}줄은 너무 많습니다")   # 계산을 두 번 하지 않음

타입 힌트, 여기까지 쓰면 확 달라집니다

from typing import Literal, Final, TypedDict, NamedTuple
from dataclasses import dataclass

# ① 정해진 값만 허용 — 오타를 편집기가 잡아 줍니다
def 정렬(방향: Literal["asc", "desc"]) -> None: ...
정렬("aesc")        # ← mypy 가 여기서 빨간 줄

# ② 상수 표시
최대_재시도: Final = 3

# ③ 딕셔너리의 모양을 고정 (JSON 응답에 딱)
class 주문(TypedDict):
    id: int
    금액: int
    비고: str | None

# ④ 값 묶음은 dataclass — __init__·__repr__·== 가 공짜
@dataclass
class 좌표:
    x: float
    y: float = 0.0

# ⑤ 3.12+ 타입 별칭
type 아이디목록 = list[int]

규칙 — 이 네 가지가 전부입니다

s = "Hello, Python"
#    0부터 시작        음수는 뒤에서부터: 마지막 글자가 -1

# ① 끝 인덱스는 '직전까지' — s[a:b] 의 길이는 b-a
s[0:5]      # 'Hello'
s[7:]       # 'Python'    끝 생략 = 끝까지
s[:5]       # 'Hello'     시작 생략 = 처음부터
s[-6:]      # 'Python'    뒤에서 6글자
s[2:-2]     # 'llo, Pyth' 앞 2개·뒤 2개 잘라내기

# ② 인덱스는 넘치면 에러, 슬라이스는 관대합니다 ★
s[100]      # IndexError ❌
s[7:100]    # 'Python'   ✅ 있는 만큼만 줍니다
s[100:]     # ''         ✅ 빈 문자열 (에러 아님)

# ③ 세 번째 칸 = 간격(step)
s[::2]      # 'Hlo yhn'   두 칸씩 건너뛰며
s[1::2]     # 'el,Pto'    1번부터 두 칸씩
s[::-1]     # 'nohtyP ,olleH'   뒤집기 ★

# ④ 간격이 음수면 '뒤에서 앞으로' 갑니다 — 시작·끝도 뒤집혀야 합니다
s[5:0:-1]   # ',olle'   ← 0번은 미포함 (끝은 여전히 '직전까지')
s[5::-1]    # ',olleH'  ← 처음까지 다 가려면 끝을 비웁니다
s[0:5:-1]   # ''        ← 방향이 안 맞으면 조용히 빈 값 (에러 아님 ⚠)

실전 관용구 — 그대로 복사해서 쓰세요

f = "보고서_2026-08-13.xlsx"

f[-5:]                # '.xlsx'   뒤에서 n글자 (확장자가 고정 폭일 때)
f[:-5]                # '보고서_2026-08-13'   뒤 n글자 잘라내기
f[4:14]               # '2026-08-13'   고정 폭 자리 뽑기

# 마스킹 — 앞뒤만 남기고 가리기
전화 = "01012345678"
전화[:3] + "****" + 전화[-4:]      # '010****5678'

# 말줄임
제목 = 글[:20] + "…" if len(글) > 20 else 글

# 회문(앞뒤가 같은 말) 검사
s == s[::-1]

# slice 객체 — 자주 쓰는 구간에 '이름'을 붙입니다 ★
날짜 = slice(4, 14)
확장자 = slice(-5, None)          # 생략 자리는 None 으로
f[날짜], f[확장자]                # 고정 폭 로그 파싱이 읽기 쉬워집니다

# 문자열은 불변 — 한 글자 교체는 잘라서 새로 조립합니다
s[0] = "h"            # ❌ TypeError
"h" + s[1:]           # ✅
s[:7] + "World"       # ✅ 뒷부분 교체

정렬 · 폭 · 자릿수

w, n, pi = "파이썬", 42, 3.14159

f"{w:<10}|"     # '파이썬       |'   왼쪽 정렬 10칸
f"{w:>10}|"     # '       파이썬|'   오른쪽 정렬
f"{w:^10}|"     # '   파이썬    |'   가운데
f"{w:*^10}|"    # '***파이썬****|'   채움문자 지정

f"{n:5d}"       # '   42'
f"{n:05d}"      # '00042'    0 채우기
f"{n:+d}"       # '+42'      부호 항상 표시
f"{pi:8.3f}"    # '   3.142'
f"{pi:.0f}"     # '3'        반올림
f"{1234567.891:,.2f}"   # '1,234,567.89'
f"{1234567:_}"          # '1_234_567'

# 폭·정밀도를 변수로 넘기기 (중첩 포맷)
width, prec = 12, 3
f"{pi:{width}.{prec}f}"     # '       3.142'

진법 · 퍼센트 · 날짜 · 디버깅

f"{255:b}"     # '11111111'   2진수
f"{255:o}"     # '377'        8진수
f"{255:x}"     # 'ff'         16진수
f"{255:#X}"    # '0XFF'       접두사 포함
f"{255:08b}"   # '11111111'   진법 + 0 채우기 조합

f"{0.0834:.1%}"     # '8.3%'      퍼센트 변환까지 해줍니다
f"{12345678:.2e}"   # '1.23e+07'  지수 표기

from datetime import datetime
now = datetime(2026, 7, 31, 14, 5)
f"{now:%Y-%m-%d %H:%M}"   # '2026-07-31 14:05'
f"{now:%y%m%d}"           # '260731'  파일명 만들 때

items = ["사과", "배"]
f"{items}"      # ['사과', '배'] 처럼 str() 결과
f"{items!r}"    # repr() 로 (따옴표까지 보임)
f"{items=}"     # "items=['사과', '배']"  ★ 디버깅 최강
f"{{중괄호}}"    # '{중괄호}'  중괄호 자체를 쓰려면 두 번

쪼개기 — split 말고도 많습니다

s = "2026-07-31 ERROR 결제 실패: 카드 한도"

s.split()             # 공백 기준 전부 쪼개기 (연속 공백도 알아서)
s.split(" ", 2)       # 최대 2번만 → 3조각 ★ 로그 파싱의 정석
s.rsplit(":", 1)      # 오른쪽에서부터 1번만 (확장자 분리 등)
s.partition(" ")      # ('2026-07-31', ' ', 'ERROR 결제 …')
                      #   ★ 항상 3개를 반환 → 없어도 에러가 안 납니다
"a\nb\nc".splitlines()   # ['a','b','c']  개행 문자는 제거됨

# 접두/접미 제거 (3.9+) — strip 과 완전히 다릅니다
"img_001.png".removesuffix(".png")   # 'img_001'   ✅
"song.png".strip(".png")             # 'so'  ❌ 'song' 이 아닙니다!
# strip 은 '문자 집합'을 지웁니다 → 양 끝에서 . p n g 중 하나면 계속 깎습니다
#   ("img_001.png" 처럼 우연히 맞아 보이는 경우가 있어 더 위험합니다)

바꾸기 · 검사하기 · 붙이기

# 여러 문자를 한 번에 치환 (replace 여러 번보다 빠름)
table = str.maketrans({"-": "/", ".": "/"})
"2026-07.31".translate(table)      # '2026/07/31'

# 검사 계열 — 입력값 검증에 자주 씁니다
"1234".isdigit()      # True    숫자로 이루어졌나
"abc".isalpha()       "a1".isalnum()
"  ".isspace()        "Hello".istitle()
"Hello".casefold() == "hello".casefold()   # 대소문자 무시 비교

# 찾기
s.find("ERROR")       # 위치, 없으면 -1
s.index("ERROR")      # 위치, 없으면 ValueError
s.count("실패")
"ERROR" in s          # ★ 존재만 확인할 땐 이게 제일 읽기 쉽습니다

# 붙이기 — 반복문 안 += 는 금지
parts = []
for r in rows:
    parts.append(f"{r['이름']},{r['점수']}")
csv_text = "\n".join(parts)        # ✅ 한 번에

# 여러 줄을 깔끔하게 (들여쓰기 제거)
import textwrap
textwrap.dedent(sql).strip()

놓치기 쉬운 메서드들 — 알면 if 가 줄어듭니다

# startswith / endswith 는 튜플을 받습니다 ★ or 사슬 제거
이름.endswith((".png", ".jpg", ".webp"))
줄.startswith(("#", "//", ";"))          # 주석 줄 거르기

"hello world".title()        # 'Hello World'   단어 첫 글자만 대문자
"hello".capitalize()         # 'Hello'         문장 첫 글자만
"Hello".swapcase()           # 'hELLO'

"7".zfill(3)                 # '007'
"메뉴".ljust(10, "·")         # '메뉴········'   왼쪽 정렬 채우기
"9,900".rjust(10)            # '     9,900'    오른쪽 정렬
# f-string 의 {값:<10} · {값:>10} 과 같은 일을 메서드로

s.count("l")                 # 부분 문자열 개수 (겹침 없이)
s.rfind("o")                 # 뒤에서부터 찾기 (없으면 -1)
"-" * 40                     # 구분선 — 문자열 곱하기
"a\tb".expandtabs(4)         # 탭 → 공백 4칸

# 글자 ↔ 코드 번호 (정렬·암호화·엑셀 열 이름 계산에 등장)
ord("A"), chr(65)            # (65, 'A')
chr(ord("A") + 2)            # 'C'

바이트 경계와 판별 메서드의 함정

# 문자열 ↔ 바이트 — 파일·네트워크로 나갈 때만 변환합니다
"한글".encode("utf-8")        # b'\xed\x95\x9c\xea\xb8\x80'
b"\xed\x95\x9c\xea\xb8\x80".decode("utf-8")   # '한글'
len("한글"), len("한글".encode())   # (2, 6) ★ 글자 수 ≠ 바이트 수
# DB 컬럼 길이 · API 페이로드 제한은 대부분 '바이트' 기준입니다

# is숫자 3형제는 범위가 다릅니다
"42".isdigit()      # True
"²".isdigit()       # True  ⚠ 위첨자도 digit — int() 는 실패합니다
"½".isnumeric()     # True  ⚠ 분수 기호까지
"42".isdecimal()    # True  ← int() 변환 가능 검사는 이걸로 ★
"-3".isdecimal()    # False ⚠ 부호·소수점은 셋 다 탈락
#   음수·소수까지 허용하려면: try: float(s) 가 정답입니다

"한글".isalpha()     # True  — '알파벳'이 아니라 '문자'면 True
"if".isidentifier() # True 여도 키워드일 수 있음 → keyword.iskeyword()

# 문자열 비교는 사전순 (코드포인트 순서)
"apple" < "banana"   # True
"10" < "9"           # True ⚠ 문자열 숫자는 자릿수를 모릅니다
sorted(["10","9","2"], key=int)    # 숫자로 바꿔 정렬해야 정확

re 5총사

import re

log = "2026-07-31 14:05 ERROR 결제 실패 code=402"

re.search(r"code=(\d+)", log).group(1)   # '402'  어디에 있든 찾기
re.match(r"\d{4}", log)                  # 문자열 '맨 앞'만 검사
re.findall(r"[A-Z]{3,}", log)            # ['ERROR']  전부 찾기
re.sub(r"\d{4}-\d{2}-\d{2}", "[날짜]", log)   # 치환
re.split(r"\s+", log)                    # 공백(여러 칸)으로 분리

# 이름 붙은 그룹 — 가독성이 완전히 달라집니다
m = re.match(r"(?P<date>\S+) (?P<time>\S+) (?P<level>\w+)", log)
m.group("level")     # 'ERROR'
m.groupdict()        # {'date': '2026-07-31', 'time': '14:05', …}

# 자주 쓰면 미리 컴파일해 두기
DATE = re.compile(r"^\d{4}-\d{2}-\d{2}$")
bool(DATE.match("2026-07-31"))     # True

기호 최소 세트

list — 가장 많이 씁니다

a = [3, 1, 2]

a.append(4)        # 끝에 추가
a.insert(0, 9)     # 위치 지정 추가
a.extend([5, 6])   # 여러 개 추가 (a + [5,6] 과 유사)
a.remove(1)        # 값으로 삭제 (첫 번째만)
a.pop()            # 마지막 꺼내기
a.pop(0)           # 인덱스로 꺼내기
del a[0]

a.sort()                    # 제자리 정렬
a.sort(key=abs, reverse=True)   # 기준 함수 + 내림차순 (문자열 리스트라면 key=len)
sorted(a)                   # 정렬된 새 리스트
a.reverse()
len(a)   sum(a)   max(a)   min(a)
a.count(4)   a.index(4)        # index 는 없는 값이면 ValueError

# 슬라이싱
a[1:3]   a[::2]   a[::-1]   a[:]   # a[:] 는 얕은 복사

dict — Map에 해당

d = {"이름": "김민준", "팀": "A"}

d["팀"]                # 없으면 KeyError
d.get("나이")          # 없으면 None (안전)
d.get("나이", 0)       # 기본값 지정
d["나이"] = 30         # 추가/수정
d.setdefault("팀", "B")  # 없을 때만 넣기
del d["팀"]
d.pop("팀", None)

d.keys()   d.values()   d.items()
"팀" in d              # 키 존재 확인

for k, v in d.items():
    print(k, v)

# 병합 (3.9+)
merged = d1 | d2
d.update(d2)

# 리스트를 키별로 묶기 — Collectors.groupingBy 대응
from collections import defaultdict
g = defaultdict(list)
for row in rows:
    g[row["팀"]].append(row)

슬라이싱은 '읽기' 말고 '쓰기'도 됩니다

a = [0, 1, 2, 3, 4, 5]

a[1:3]              # [1, 2]              읽기
a[1:3] = [9, 9, 9]  # 길이가 달라도 OK → [0,9,9,9,3,4,5]
a[::2] = [0, 0, 0, 0]  # 짝수 번째(4칸)만 교체 — 간격 슬라이스는 개수가 정확히 맞아야 함
del a[1:3]          # 구간 통째로 삭제

# ★ a[:] = ... 는 '같은 객체를 유지한 채' 내용만 갈아끼웁니다
#    다른 곳에서 이 리스트를 참조 중일 때 반드시 이 형태를 쓰세요
a[:] = [x for x in a if x != 0]

# 자주 쓰는 슬라이스 관용구
a[::-1]     # 뒤집기 (새 리스트)
a[-3:]      # 마지막 3개
a[:-1]      # 마지막 하나 빼고
a[:]        # 얕은 복사
a[i:i+n]    # n개씩 잘라 쓰기 (배치 처리)

# n개씩 묶어서 처리 — 배치 업로드의 정석
for i in range(0, len(rows), 100):
    upload(rows[i:i+100])

정렬 — key 하나로 다 됩니다

people = [{"이름":"민준","나이":30,"팀":"A"},
          {"이름":"서연","나이":25,"팀":"B"},
          {"이름":"도윤","나이":30,"팀":"A"}]

sorted(people, key=lambda p: p["나이"])              # 나이 오름차순
sorted(people, key=lambda p: p["나이"], reverse=True)

# 여러 기준 — 튜플로 묶으면 끝 (나이 → 같으면 이름)
sorted(people, key=lambda p: (p["나이"], p["이름"]))
# 나이는 내림차순 + 이름은 오름차순 → 숫자만 부호 반전
sorted(people, key=lambda p: (-p["나이"], p["이름"]))

from operator import itemgetter, attrgetter
sorted(people, key=itemgetter("팀", "나이"))   # 람다보다 빠름
sorted(objs,   key=attrgetter("score"))       # 객체 속성으로

sorted(words, key=len)          # 길이순
sorted(words, key=str.lower)    # 대소문자 무시
sorted(files, key=lambda f: f.stat().st_mtime)   # 수정시각순

a.sort()        # ⚠ 제자리 정렬 — 반환값은 None
b = a.sort()    # ❌ b 는 None 입니다
b = sorted(a)   # ✅ 새 리스트가 필요하면 sorted

언패킹 — 인덱스를 안 쓰는 기술

first, *rest = [1, 2, 3, 4]     # 1,  [2,3,4]
*head, last  = [1, 2, 3, 4]     # [1,2,3],  4
a, (b, c) = 1, (2, 3)           # 중첩 언패킹도 됩니다
x, y = y, x                     # 스왑 (임시 변수 불필요)
_, 값, _ = row                  # 안 쓸 자리는 관례상 _

# zip(*리스트) = 전치(transpose) ★ 표 다룰 때 매우 유용
matrix = [[1,2,3],
          [4,5,6]]
list(zip(*matrix))              # [(1,4), (2,5), (3,6)]

rows = [("민준",90), ("서연",95)]
names, scores = zip(*rows)      # ('민준','서연'), (90,95)

# 합치기 · 변환
[*a, *b]        # 두 리스트 이어붙이기
[*range(5)]     # [0,1,2,3,4]
[*set(a)]       # set → list
list(dict.fromkeys(a))   # 중복 제거 + 순서 유지 ★

반복문 없이 계산하기

nums = [3, -1, 7, 0, 5]

sum(nums)   max(nums)   min(nums)   len(nums)

# ★ '최댓값'이 아니라 '최댓값을 가진 원소'가 필요할 때
max(people, key=lambda p: p["나이"])     # {'이름':'민준', …}
min(files,  key=lambda f: f.size)

any(x < 0 for x in nums)        # 하나라도 음수?  → True
all(x < 0 for x in nums)        # 전부 음수?      → False
sum(1 for x in nums if x > 0)   # 조건을 만족하는 개수
sum(p["점수"] for p in people)  # 특정 필드 합계

nums.count(7)     nums.index(7)     7 in nums
list(reversed(nums))
list(enumerate(nums, start=1))   # [(1,3), (2,-1), …]

# 2차원 평탄화
flat = [x for row in matrix for x in row]

# 조건별로 한 번에 나누기
양수 = [x for x in nums if x > 0]
음수 = [x for x in nums if x < 0]

Counter · defaultdict — 이거 모르면 손해

from collections import Counter, defaultdict

words = ["사과","배","사과","감","배","사과"]

c = Counter(words)
c["사과"]              # 3
c["없는키"]            # 0   ★ KeyError 가 나지 않습니다
c.most_common(2)       # [('사과',3), ('배',2)]
Counter("mississippi").most_common(1)     # [('i', 4)]
sum(c.values())        # 전체 개수
c1 + c2,  c1 - c2      # 카운터끼리 더하고 빼기

# 키별로 묶기 — Java 의 Collectors.groupingBy
g = defaultdict(list)
for r in rows:
    g[r["팀"]].append(r["이름"])
dict(g)     # {'A': ['민준','도윤'], 'B': ['서연']}

# 팀별 합계
합계 = defaultdict(int)
for r in rows:
    합계[r["팀"]] += r["점수"]

# 값 기준 정렬 (내림차순)
sorted(c.items(), key=lambda kv: kv[1], reverse=True)
{k: v for k, v in sorted(d.items(), key=lambda kv: -kv[1])}

{v: k for k, v in d.items()}     # 키↔값 뒤집기

안전하게 꺼내고 깔끔하게 합치기

d = {"이름": "민준", "설정": {"테마": "dark"}}

d.get("나이", 0)                # 없으면 기본값 (KeyError 회피)
d.setdefault("태그", []).append("VIP")   # 없으면 만들고 바로 사용
d.get("설정", {}).get("폰트", "기본")     # 중첩 안전 접근 ★
d.pop("설정", None)             # 없어도 에러 없이 삭제

d | {"나이": 30}      # 합친 '새 dict' (3.9+)
d |= {"나이": 30}     # 제자리 갱신
{**d1, **d2}         # 예전 방식 — 뒤쪽이 우선

# 키 집합 연산 — 두 설정 파일 비교에 딱
d1.keys() & d2.keys()    # 공통 키
d1.keys() - d2.keys()    # d1 에만 있는 키
{k for k in d1.keys() & d2.keys() if d1[k] != d2[k]}   # 값이 다른 키

# 필요한 키만 골라내기
{k: d[k] for k in ("이름","나이") if k in d}

# dict 를 switch 처럼 쓰기 (if-elif 사슬 제거)
handlers = {"add": do_add, "del": do_del}
handlers.get(cmd, do_default)(arg)

list(d)          # 키 목록 — 넣은 순서가 보장됩니다 (3.7+)
list(d.values()) list(d.items())

set — 비교·중복 제거 전용 도구

a = {1, 2, 3}; b = {3, 4}

a | b    # {1,2,3,4}   합집합  (a.union(b))
a & b    # {3}         교집합  (a.intersection(b))
a - b    # {1,2}       차집합  (a.difference(b))
a ^ b    # {1,2,4}     한쪽에만 있는 것

a <= b            # 부분집합인가 (a.issubset(b))
a.isdisjoint(b)   # 겹치는 게 하나도 없나

a.add(5)
a.discard(9)      # 없어도 조용히 넘어감 ✅
a.remove(9)       # 없으면 KeyError ❌

# 배포 전후 비교 — 실무에서 매일 씁니다
새로생김 = set(after) - set(before)
사라짐   = set(before) - set(after)
그대로   = set(before) & set(after)

# 중복 제거
list(set(items))               # 빠르지만 순서 보장 ❌
list(dict.fromkeys(items))     # 순서 유지 ✅

{r["팀"] for r in rows}        # 세트 컴프리헨션
frozenset({1,2})               # 불변 set → dict 의 키가 될 수 있음

tuple — “바뀌면 안 되는 묶음”

p = (37.5, 127.0)      # 좌표·RGB·설정처럼 고정된 묶음
lat, lon = p           # 언패킹

# ★ list 와 달리 dict 의 키가 될 수 있습니다
가격표 = {("서울","대"): 12000, ("부산","소"): 8000}
가격표[("서울","대")]

# 이름 붙은 튜플 — 인덱스 대신 이름으로 읽기
from typing import NamedTuple

class Point(NamedTuple):
    x: float
    y: float
    def dist(self) -> float:
        return (self.x ** 2 + self.y ** 2) ** 0.5

p = Point(3, 4)
p.x, p[0]           # 둘 다 됩니다 (튜플이면서 객체)
p.dist()            # 5.0
p._replace(x=6)     # 값 바꾸기 = '새 객체' 반환 (원본 불변)
p._asdict()         # {'x': 3, 'y': 4}

# 함수의 다중 반환값도 사실은 튜플입니다
def stat(a):
    return min(a), max(a), sum(a) / len(a)
lo, hi, avg = stat(nums)

deque · heapq — 큐와 우선순위

from collections import deque
import heapq

# list.pop(0) 은 뒤의 원소를 전부 한 칸씩 당깁니다 → O(n)
# 앞에서 빼는 일이 잦으면 deque (양끝 모두 O(1))
q = deque([1, 2, 3])
q.append(4);  q.appendleft(0)
q.pop();      q.popleft()
q.rotate(1)                    # 통째로 회전

# 최근 N개만 유지 — 슬라이딩 윈도우가 한 줄로
recent = deque(maxlen=100)
for line in log_lines:
    recent.append(line)        # 100개가 넘으면 앞에서 자동 삭제

# 우선순위 큐 — 항상 '가장 작은 것'이 먼저 나옵니다
h = []
heapq.heappush(h, (3, "보통 작업"))
heapq.heappush(h, (1, "긴급 작업"))
heapq.heappop(h)               # (1, '긴급 작업')

# 전체 정렬 없이 상위 N개만 (훨씬 빠름)
heapq.nlargest(3, nums)
heapq.nsmallest(3, people, key=lambda p: p["나이"])

bisect — 정렬된 목록의 이분 탐색

import bisect

scores = [50, 60, 70, 80, 90]      # 항상 정렬 상태 유지가 전제

bisect.insort(scores, 75)          # 자리 찾아 삽입 → [50,60,70,75,80,90]
bisect.bisect_left(scores, 70)     # 2  (같은 값의 왼쪽 자리)
bisect.bisect_right(scores, 70)    # 3  (오른쪽 자리)

# ① 구간 → 등급 매핑: if-elif 사슬을 없앱니다
컷   = [60, 70, 80, 90]
등급 = ["F", "D", "C", "B", "A"]
등급[bisect.bisect_right(컷, 85)]     # 'B'

# ② '70점 이상 몇 명?' — 세지 않고 위치 계산으로
len(scores) - bisect.bisect_left(scores, 70)

# ③ 범위 조회 [70, 90)
lo = bisect.bisect_left(scores, 70)
hi = bisect.bisect_left(scores, 90)
scores[lo:hi]

루프 안의 조회를 인덱스로 바꾸기 — 가장 흔한 리팩터링

# ❌ 주문 1만 건 × 회원 1만 건 = 1억 번 비교 (수 분)
for 주문 in 주문들:
    회원 = next(m for m in 회원들 if m["id"] == 주문["회원id"])

# ✅ 한 번만 인덱스를 만들어 두면 O(1) 조회 (1초 미만)
회원index = {m["id"]: m for m in 회원들}
for 주문 in 주문들:
    회원 = 회원index[주문["회원id"]]

# 같은 원리 — 그룹으로 묶어 두기
from collections import defaultdict
주문index = defaultdict(list)
for 주문 in 주문들:
    주문index[주문["회원id"]].append(주문)

# 순서를 지키면서 중복 제거 (set 은 순서가 없습니다)
목록 = list(dict.fromkeys(원본))

# 큰 작업을 배치로 자르기 (3.12+)
from itertools import batched
for 묶음 in batched(전체, 500):
    api.전송(list(묶음))

이 세 가지는 실제로 사고가 납니다

# ① 가변 기본 인자 — 파이썬 입문자가 가장 많이 밟는 지뢰
def 추가(항목, 바구니=[]):      # ❌ 기본값은 함수 정의 시 딱 한 번 만들어집니다
    바구니.append(항목)
    return 바구니

추가("a")   # ['a']
추가("b")   # ['a', 'b']  ← 이전 호출이 남아 있습니다

def 추가(항목, 바구니=None):    # ✅ 관용구
    if 바구니 is None:
        바구니 = []
    바구니.append(항목)
    return 바구니

# ② 순회 중 수정 — 조용히 건너뛰거나 터집니다
for k in 설정:
    if 낡음(k):
        del 설정[k]          # ❌ RuntimeError: dictionary changed size

for k in list(설정):          # ✅ 키 목록을 먼저 떠서 순회
    if 낡음(k):
        del 설정[k]

# ③ 리스트 곱하기로 2차원 만들기
표 = [[0] * 3] * 3           # ❌ 같은 행 3개가 참조로 들어갑니다
표[0][0] = 1                 # → [[1,0,0],[1,0,0],[1,0,0]]
표 = [[0] * 3 for _ in range(3)]   # ✅

여러 값을 한 번에 비교하기 ★

and 를 늘어놓지 않아도 됩니다. 파이썬은 비교를 이어 쓸 수 있습니다.

# 범위 검사 — "0 이상이고 그리고 100 미만" 을 한 번에
if 0 <= 점수 <= 100: ...          # 수학책에 쓰는 그대로
if 0 <= 인덱스 < len(목록): ...    # 인덱스 검사의 정석

# 위 코드는 이것과 완전히 같은 뜻입니다
if 0 <= 점수 and 점수 <= 100: ...  # 길고 실수하기 쉬움

# 셋 다 같은지
if a == b == c: ...
if x == y == z == 0: ...          # 전부 0인지

# "여러 값 중 하나인지"는 == 반복 대신 in
if 확장자 in (".png", ".jpg", ".webp"): ...
if 상태 not in ("취소", "환불"): ...   # 어느 것도 아닌지

# 버전처럼 "자리수가 여러 개"인 값은 튜플째 비교
if sys.version_info >= (3, 12): ...   # 앞자리부터 차례로 비교됨

# 두 목록이 같은 내용인지 (순서 상관없이)
sorted(a) == sorted(b)     # 개수까지 똑같은가
set(a) == set(b)           # 종류만 같으면 되는가

None 확인하기 — 규칙은 딱 셋 ★

None 은 “값이 아예 없음”을 뜻하는 표시입니다. 0도 아니고 빈 문자열도 아닙니다.

# 규칙 ① None 검사는 항상 is (== 아님)
if 값 is None: ...          # ✅ "없음" 인가
if 값 is not None: ...      # ✅ "있음" 인가
if 값 == None: ...          # ❌ 금지 — 라이브러리가 == 를 바꿔치기하면 오답

# 규칙 ② "없음" 과 "0 · 빈 문자열" 은 다릅니다
if not 값: ...              # None, 0, "", [] 전부 걸림 (뭉뚱그린 검사)
if 값 is None: ...          # None 만 걸림 (정확한 검사)
# → 0 이 정상 값인 자리(수량·가격)에서는 반드시 is None 으로

# 규칙 ③ 기본값 채울 때 or 는 조심
타임아웃 = 설정값 or 30      # ⚠ 0 을 넣어도 30이 됨 (0도 거짓이라서)
타임아웃 = 설정값 if 설정값 is not None else 30   # ✅ None 일 때만 30

# 자주 쓰는 모양 — "없으면 ~한다"
사용자 = find_user(uid)      # 못 찾으면 None 을 주는 함수
if 사용자 is None:
    return "없는 사용자"      # 없는 경우를 먼저 치우고
...                          # 아래는 안심하고 사용

# None 일 수 있는 것을 타고 들어갈 때 (파이썬엔 ?. 가 없습니다)
도시 = 사용자.주소.도시 if 사용자.주소 else "미입력"

갈래가 많을 때 — elif · dict · match

범위면 elif, 표면 dict, 모양이면 match. 이 한 문장이 기준입니다.

# elif — "90 이상, 80 이상, …" 처럼 범위로 나눌 때
def 등급(점수):
    if 점수 >= 90: return "A"
    if 점수 >= 80: return "B"     # return 으로 끝나면 elif 없이도 됩니다
    return "F"

# dict — "A면 20%, B면 10%" 처럼 표로 그려질 때
할인율 = {"A": 0.2, "B": 0.1}
할인 = 할인율.get(등급, 0)        # 표에 없으면 0

# dict 에 함수를 담으면 switch 문이 됩니다
처리 = {"add": 추가하기, "del": 삭제하기}
처리.get(명령, 도움말출력)(인자)   # 명령에 맞는 함수를 골라 실행

# match — 값이 아니라 데이터의 '모양'으로 나눌 때 (3.10+)
match 응답:
    case {"ok": True,  "data": data}:  return data      # 성공 모양
    case {"ok": False, "error": msg}:  raise ApiError(msg)
    case _:                            raise ValueError("형식 오류")

될지 안 될지 모를 땐 — 일단 해 보고 안 되면 처리

파이썬은 “미리 다 확인하고 실행”보다 “일단 하고, 안 되면 except 로 받기”를 권장합니다. 확인하는 사이에 상황이 바뀔 수 있기 때문입니다.

# 숫자로 바꿀 수 있는지 — 검사하지 말고 바꿔 보세요
try:
    나이 = int(입력값)
except ValueError:               # 못 바꾸는 값이면 여기로
    print("숫자가 아닙니다")
# 참고: "-3".isdigit() 은 False — 검사 함수는 음수를 놓칩니다

# 파일이 있는지 — 열어 보는 게 정확합니다
try:
    with open(경로, encoding="utf-8") as f:
        내용 = f.read()
except FileNotFoundError:
    내용 = ""                    # 없으면 빈 값으로 시작

# 단, 이미 전용 도구가 있으면 그게 최선입니다
값 = d.get("키", 기본값)                     # dict 는 get
표시명 = getattr(사용자, "별명", 사용자.이름)  # 속성은 getattr

한 줄로 쓰는 조건

# 삼항 — 둘 중 하나를 '골라 담을 때'
요금 = 0 if 나이 < 8 else 1200
# 읽는 법: "나이가 8 미만이면 0, 아니면 1200"

# 두 단계까지만 — 그보다 길면 elif 로 펴세요
크기 = "소" if n < 10 else ("중" if n < 100 else "대")

# := (walrus) — "계산하고, 그 값을 바로 조건에서" (3.8+)
if (줄수 := len(lines)) > 1000:
    print(f"{줄수}줄 — 너무 큽니다")    # 계산을 한 번만 하고 재사용

if (m := re.search(r"code=(\d+)", 로그)):
    코드 = m.group(1)                  # "찾았으면 쓴다" 를 한 줄에

# 컴프리헨션 안의 if — 위치에 따라 뜻이 다릅니다
[x for x in nums if x > 0]           # 뒤에 있으면 → 거르기
[x if x > 0 else 0 for x in nums]    # 앞에 있으면 → 값 바꾸기

이렇게 쓰면 지적받습니다 — 5가지

# ① True 랑 또 비교하기
if 활성 == True: ...        # ❌ 이미 True/False 인 값입니다
if 활성: ...                # ✅

# ② 길이로 빈 검사
if len(목록) > 0: ...       # ❌
if 목록: ...                # ✅ 값이 있으면 참

# ③ 비교 결과를 삼항으로 다시 포장
프리미엄 = True if 등급 == "gold" else False   # ❌
프리미엄 = (등급 == "gold")                    # ✅ 비교 자체가 답

# ④ 표를 elif 로 늘어놓기
if 등급 == "A": 할인 = 0.2       # ❌ 3줄
elif 등급 == "B": 할인 = 0.1
else: 할인 = 0
할인 = {"A": 0.2, "B": 0.1}.get(등급, 0)   # ✅ 1줄

# ⑤ "찾았나" 플래그 변수 만들기
찾음 = False                     # ❌ 변수 + 3줄
for s in 서버들:
    if s.정상: 찾음 = True; break
대상 = next((s for s in 서버들 if s.정상), None)   # ✅
if 대상 is None: print("살아 있는 서버 없음")

같은지 · 다른지 — == 와 != ★

이름 = "kim"

if 이름 == "kim":            # 글자가 하나도 빠짐없이 같으면 True
    print("김 씨입니다")

if 이름 != "lee":            # 하나라도 다르면 True
    print("이 씨가 아닙니다")

# if / elif / else 로 여러 갈래
if 등급 == "gold":
    할인 = 0.2
elif 등급 == "silver":
    할인 = 0.1
else:
    할인 = 0

# 눈에는 비슷해도 전부 '다른' 문자열입니다
"Kim"  == "kim"      # False  대문자 K
"kim " == "kim"      # False  뒤에 공백 한 칸
"김"   == "김 "       # False
"1"    == 1          # False  ⚠ 글자 1 과 숫자 1 은 다릅니다 (에러도 안 남)

# 사람이 입력한 값은 '다듬고 나서' 비교 ★
답 = input("계속할까요? (y/n) ")      # 사용자가 " Y " 라고 쳐도
if 답.strip().lower() == "y":         # 공백 제거 → 소문자로 → 비교
    print("계속합니다")

포함 · 시작 · 끝 — in, startswith, endswith

메일 = "hong@company.com"

if "@" in 메일:                        # '@' 글자가 들어 있나
    print("메일 형식")
if "@" not in 메일:                    # 안 들어 있나
    print("메일 주소가 아닙니다")

if 메일.endswith("@company.com"):      # 회사 메일로 끝나나
    print("사내 사용자")
if 파일명.startswith("report_"):        # report_ 로 시작하나
    print("보고서 파일")

# 여러 개 중 하나로 끝나는지 — 튜플로 한 번에 ★
if 파일명.endswith((".xlsx", ".xls", ".csv")):
    print("표 파일")

# ⚠ in 은 붙는 대상에 따라 뜻이 바뀝니다
"kim" in "kimchi"              # True  — 문자열 안에 '부분'으로 있나
"kim" in ["kimchi", "lee"]     # False — 목록에 '통째로 같은 값'이 있나
"kim" in ("kim", "lee")        # True  — "여러 값 중 하나인가" 는 이 모양

# 빈 문자열 검사 — 상황에 맞게 하나 고르기
if not 이름: ...            # "" 과 None 둘 다 걸림 (가장 흔함)
if 이름 == "": ...          # 빈 문자열만
if not 이름.strip(): ...    # "   " 처럼 공백만 있는 것도 '비었다'로

크다 · 작다 — 문자열은 사전순으로 비교됩니다

# 첫 글자부터 하나씩 비교, 다르면 거기서 결정
"apple"  < "banana"     # True   a < b
"apple"  < "apricot"    # True   ap 까지 같고 p < r
"app"    < "apple"      # True   앞이 같으면 짧은 쪽이 앞
"가"     < "나"         # True   한글 완성형은 가나다순 그대로
"Z"      < "a"          # True ⚠ 대문자가 소문자보다 앞 (글자 번호 순)

# 사전순이라서 이런 조건이 가능합니다
if "가" <= 성 < "나":      # ㄱ·ㄲ 으로 시작하는 성 (가, 강, 고, 김 …)
    print("ㄱ 그룹")

# ⚠ 숫자가 든 문자열은 숫자로 바꿔서 비교
"10" < "9"                 # True  ⚠ 첫 글자 '1' 과 '9' 를 비교했을 뿐
int("10") < int("9")       # False ✅

# input() 은 항상 문자열을 줍니다 → 숫자 비교 전에 int()
나이 = input("나이: ")
if int(나이) >= 19: ...     # ✅
if 나이 >= 19: ...          # ❌ TypeError — str 과 int 는 크기 비교 불가

# 자릿수가 고정된 날짜·시각 문자열은 그대로 비교해도 정확
"2026-09-22" < "2026-10-01"   # True ✅ (0 으로 채운 ISO 형식일 때만)

자주 쓰는 모양 — 복사해서 바로 쓰기

# ① 예/아니오 답 받기
답 = input("삭제할까요? ").strip().lower()
if 답 in ("y", "yes", "예", "ㅇ"):
    삭제()
elif 답 in ("n", "no", "아니오", "ㄴ"):
    print("취소")
else:
    print("y 또는 n 으로 입력하세요")

# ② 로그 줄 골라내기
for 줄 in 로그줄들:
    if 줄.startswith("#"):        # 주석은 건너뜀
        continue
    if "ERROR" in 줄:
        print("에러:", 줄)

# ③ 비밀번호 확인 (연습용 — 실무는 아래 실무 편)
if 입력 == 비밀번호 and len(입력) >= 8:
    print("통과")

# ④ 상태값으로 분기
if 주문.상태 == "PAID":
    배송준비(주문)
elif 주문.상태 in ("CANCEL", "REFUND"):
    환불처리(주문)

and · or 에서 실제로 나는 버그 3가지

전부 “문법은 맞는데 뜻이 다른” 코드라서 에러도 안 납니다. 눈으로 익혀 두세요.

# 버그 ① or 뒤에 조건을 안 쓰고 값만 쓰기
if cmd == "start" or "go":        # ❌ "go" 는 항상 참 → 무조건 실행
if cmd in ("start", "go"):        # ✅ "여럿 중 하나"는 in 으로

# 버그 ② and 가 or 보다 먼저 묶이는 걸 모름
if a or b and c:                  # 실제 뜻: a or (b and c)
if (a or b) and c:                # ✅ 의도가 이거면 괄호를 치세요
# 헷갈리면 무조건 괄호 — 괄호는 성능도 가독성도 손해가 없습니다

# 버그 ③ 검사 순서가 뒤집힘
if user is not None and user.active:   # ✅ 앞이 거짓이면 뒤는 실행 안 됨
if user.active and user is not None:   # ❌ user 가 None 이면 첫 칸에서 터짐
# 파이썬은 왼쪽부터 보다가 답이 정해지면 멈춥니다
# → "None 검사"를 앞에, "값 사용"을 뒤에

조건이 4개를 넘으면 — 나열하지 말고 구조로

# ❌ 한 줄에 다 밀어 넣으면 리뷰가 불가능합니다
if 나이 >= 19 and 국가 == "KR" and not 정지 and 잔액 > 0 and 인증됨:

# ✅ ① 이름 붙이기 — 조건 자체가 문서가 됩니다
성인이다   = 나이 >= 19
국내회원   = 국가 == "KR"
거래가능   = not 정지 and 잔액 > 0
if 성인이다 and 국내회원 and 거래가능 and 인증됨:

# ✅ ② all / any 로 목록화 — 개수가 늘어도 모양이 안 변합니다
조건들 = [
    나이 >= 19,
    국가 == "KR",
    not 정지,
    잔액 > 0,
]
if all(조건들):  ...        # 전부 만족
if any(조건들):  ...        # 하나라도 만족

# ✅ ③ 실패 이유까지 알려 주는 검증 — 실무 폼 검증의 정석
검사표 = [
    (나이 >= 19,        "미성년자는 가입할 수 없습니다"),
    (국가 == "KR",      "국내 서비스입니다"),
    (not 정지,          "정지된 계정입니다"),
]
오류 = [메시지 for 통과, 메시지 in 검사표 if not 통과]
if 오류:
    return {"ok": False, "errors": 오류}   # 전부 모아 한 번에 반환

# ✅ ④ 걷어내기(guard) — 겹겹의 if 대신 탈락부터 처리
def 결제가능(주문):
    if 주문 is None:        return False
    if 주문.금액 <= 0:      return False
    if 주문.상태 != "대기":  return False
    return True

대소문자 무시 · 후보 여러 개 · 금지어 검사

# 대소문자 무시 비교 — lower() 도 되지만 casefold() 가 더 정확
"Straße".lower()    == "strasse"   # False
"Straße".casefold() == "strasse"   # True ✅ 독일어 ß 까지 처리
# 영어·한글만 다룬다면 lower() 로도 충분합니다

# 후보가 여러 개 — 먼저 다듬고, 집합(set)에 담아 두고 in
허용 = {"admin", "manager", "owner"}
if 역할.strip().casefold() in 허용: ...
# 후보가 수십 개 이상이면 튜플보다 set 이 빠릅니다 (해시로 한 번에 찾음)

# 문자열 안에 '여러 단어 중 하나라도' 있는지 — any
금지어 = ["광고", "무료", "대출"]
if any(단어 in 제목 for 단어 in 금지어):
    print("스팸 의심")

# 전부 들어 있는지 — all
if all(k in 본문 for k in ("주문번호", "금액")): ...

# 어느 단어에 걸렸는지까지 알고 싶으면 next
걸린 = next((w for w in 금지어 if w in 제목), None)
if 걸린 is not None:
    print(f"'{걸린}' 때문에 차단")

# 대소문자 무시로 정렬 · 최솟값
sorted(이름들, key=str.casefold)     # ['apple', 'Banana', 'cherry']
min(이름들, key=str.casefold)
# key 없이 정렬하면 대문자 전부가 소문자보다 앞에 섭니다

문자열로 분기 — match · 와일드카드 · 정규식

# match 로 문자열 분기 (3.10+) — | 로 '이 중 하나'
match 명령.strip().lower():
    case "start" | "run" | "go":
        시작()
    case "stop" | "quit" | "exit":
        종료()
    case s if s.startswith("#"):       # 조건(guard)까지 붙일 수 있음
        pass                           # 주석은 무시
    case _:
        print(f"모르는 명령: {명령}")

# 공백으로 나눈 다음 '모양'으로 분기 — 명령어 파서의 정석
match 입력.split():
    case ["go", 방향]:           return 이동(방향)       # go north
    case ["take", *물건들]:      return 줍기(물건들)     # take key lamp
    case []:                    return None            # 빈 입력

# 와일드카드(*, ?) 비교 — 파일명 고를 때
from fnmatch import fnmatch, fnmatchcase
fnmatch("app_2026.log", "app_*.log")       # True
fnmatchcase("APP.LOG", "*.log")            # False — 대소문자 엄격
# fnmatch 는 윈도우에서 대소문자를 무시하고, 리눅스에선 구분합니다

# 정규식 — "이런 모양인가" 를 엄격하게
import re
if re.fullmatch(r"\d{3}-\d{4}-\d{4}", 전화): ...   # 전체가 이 모양
if re.search(r"ERROR|FATAL", 줄): ...              # 어딘가에 있나
# fullmatch = 처음부터 끝까지 / match = 앞부분만 / search = 아무 데나 ★

enumerate · zip 을 제대로 쓰기

items  = ["사과", "배", "감"]
prices = [1200, 3000]

for i, x in enumerate(items):        # 0부터 (인덱스용)
for i, x in enumerate(items, 1):     # 1부터 (사람에게 보여줄 때)

# ⚠ 길이가 다르면 zip 은 짧은 쪽에서 '조용히' 끝납니다
list(zip(items, prices))             # 2개만! '감'은 사라짐

from itertools import zip_longest
list(zip_longest(items, prices, fillvalue=0))   # 3개, 감→0
list(zip(items, prices, strict=True))  # 3.10+: 길이 다르면 에러 ✅

# 세 개 이상도 됩니다
for name, price, qty in zip(names, prices, qtys):
    ...

# 조합해서 쓰기
for i, (name, price) in enumerate(zip(names, prices), 1):
    print(f"{i}. {name} {price:,}원")

for x in reversed(items): ...
for x in sorted(people, key=lambda p: p["나이"]): ...

dict(zip(names, prices))     # 두 리스트를 dict 로 ★

itertools — 반복문을 대신 써 주는 도구함

from itertools import (chain, islice, groupby, product,
                       combinations, permutations,
                       accumulate, count, cycle, pairwise)

list(chain(a, b, c))              # 여러 리스트를 하나로
list(chain.from_iterable(matrix)) # 2차원 평탄화

list(islice(gen, 5))              # 앞에서 5개만 (제너레이터 자르기)
list(islice(gen, 10, 20))         # 10~19번째만

list(accumulate([1, 2, 3, 4]))    # [1,3,6,10]  누적합 (그래프용)
list(accumulate(nums, max))       # 지금까지의 최댓값

list(combinations([1,2,3], 2))    # [(1,2),(1,3),(2,3)]  순서 무시
list(permutations([1,2,3], 2))    # 순서 구분
list(product("AB", repeat=2))     # 중첩 for문 대체 (AA AB BA BB)
list(pairwise([1, 4, 9]))         # [(1,4),(4,9)]  이웃끼리 (3.10+)

# 키로 묶기 — ★ 같은 키로 '정렬 먼저' 하지 않으면 쪼개집니다
rows.sort(key=lambda r: r["팀"])
for 팀, 그룹 in groupby(rows, key=lambda r: r["팀"]):
    멤버 = list(그룹)             # 한 번만 소비 가능! 바로 list 로
    print(팀, len(멤버))

모양으로 분기하고 값까지 꺼내기

def handle(event):
    match event:
        # dict 모양 + 안쪽 값을 x, y 로 바로 꺼냄
        case {"type": "click", "x": x, "y": y}:
            return f"클릭 ({x}, {y})"

        # 조건(guard) 을 덧붙일 수 있습니다
        case {"type": "key", "code": code} if code < 32:
            return "제어 문자"

        # 리스트 모양 — 나머지는 *rest 로
        case ["move", *rest]:
            return f"이동 {rest}"

        # 클래스 모양 (dataclass·NamedTuple 과 궁합이 좋습니다)
        case Point(x=0, y=0):
            return "원점"

        # 타입 검사 + 이름 붙이기
        case str() as s:
            return s.upper()

        case 1 | 2 | 3:          # 여러 값 중 하나
            return "작은 수"

        case _:                  # 나머지 전부 (default)
            return "모름"

언제 쓰고, 언제 쓰지 말까

오타 하나로 조건이 영원히 False — 상수는 Enum 으로

# ❌ 문자열을 여기저기 직접 씀 — 한 곳만 "Paid" 로 써도 그 분기는 죽습니다
if 주문.상태 == "PAID": ...
if 주문.상태 == "Paid": ...     # 에러 없이 항상 False

# ✅ StrEnum (3.11+) — 오타는 즉시 AttributeError, 자동완성도 됨
from enum import StrEnum

class 상태(StrEnum):
    대기 = "WAIT"
    결제 = "PAID"
    취소 = "CANCEL"

if 주문.상태 == 상태.결제: ...          # DB·JSON 에서 온 "PAID" 와도 그대로 같음
if 주문.상태 in {상태.취소, 상태.결제}: ...
상태("PAID")                            # 문자열 → Enum, 없는 값이면 ValueError
# 3.10 이하는  class 상태(str, Enum): ...  로 같은 효과

# 입구에서 한 번 정규화 — 비교할 때마다 lower() 하지 않습니다
import unicodedata

def 비교키(s: str) -> str:
    s = unicodedata.normalize("NFKC", s)   # 맥 파일명 자모 분리 · 전각 문자 통일
    return " ".join(s.split()).casefold()  # 앞뒤·중복 공백 정리 + 대소문자 통일

# 가입·검색·중복 체크가 모두 같은 함수를 거치게 합니다
if 비교키(새이메일) in {비교키(e) for e in 기존이메일}:
    raise ValueError("이미 가입된 이메일")

is 금지 · 비밀값 비교 · 버전과 파일명 정렬

# ❌ 문자열에 is — "우연히" 맞다가 운영에서 틀립니다
if 명령 is "stop": ...
# SyntaxWarning: "is" with 'str' literal. Did you mean "=="?
# 짧은 문자열은 파이썬이 재사용해서 True 가 나오기도 하지만,
# input()·파일·네트워크에서 온 문자열은 다른 객체라 False 가 됩니다
if 명령 == "stop": ...       # ✅ 문자열은 무조건 ==

# 토큰·API 키·서명 비교는 == 금지 → compare_digest
import hmac
if hmac.compare_digest(받은토큰.encode(), 저장토큰.encode()):
    허용()
# == 는 다른 글자를 만나면 바로 멈춥니다 → 걸린 시간으로 몇 글자 맞췄는지 추측 가능
# compare_digest 는 항상 끝까지 비교해 시간이 일정합니다 (타이밍 공격 방어)
# 비밀번호 자체는 비교하지 말고 해시로: bcrypt / argon2 의 verify 함수 사용

# 버전 문자열 — 사전순 비교는 틀립니다
"3.10" < "3.9"                                  # True ⚠
tuple(map(int, "3.10".split("."))) >= (3, 9)    # True ✅ 숫자 튜플로
# "1.0.0rc1" 같은 표기까지 다루면: from packaging.version import Version

# 파일명 '자연 정렬' — file2 가 file10 보다 앞에 오게
import re
def 자연키(s: str):
    return [int(t) if t.isdecimal() else t.casefold()
            for t in re.split(r"(\d+)", s)]
sorted(["file10.txt", "file2.txt", "File1.txt"], key=자연키)
# ['File1.txt', 'file2.txt', 'file10.txt']

4가지 컴프리헨션

# 리스트
[x * 2 for x in range(5)]              # [0,2,4,6,8]
[x for x in nums if x > 0]             # 필터
[x if x > 0 else 0 for x in nums]      # 값 변환 (앞쪽 if-else)

# 딕셔너리
{name: len(name) for name in names}
{k: v for k, v in d.items() if v > 10}

# 세트
{x % 3 for x in range(10)}             # {0,1,2}

# 제너레이터 (괄호!) — 메모리를 안 씀
sum(x * 2 for x in range(1_000_000))

# 중첩 (읽기 어려워지면 그냥 for문 쓰세요)
[(i, j) for i in range(3) for j in range(3)]
[x for row in matrix for x in row]      # 평탄화

Java Stream 대응표

조건의 '위치'가 의미를 바꿉니다

nums = [3, -1, 7, None, 5]

# ① 뒤쪽 if = 필터 (거를 것)         → 개수가 줄어듭니다
[x for x in nums if x]

# ② 앞쪽 if-else = 값 선택           → 개수는 그대로
[x if x else 0 for x in nums]

# ③ 둘 다 쓰기 (순서: 값 → for → 필터)
[x * 2 if x > 0 else 0
 for x in nums
 if x is not None]

# 중첩 = for문을 위에서부터 쓴 순서 그대로
[(i, j) for i in range(3) for j in range(3)]
# ≡  for i in range(3):
#        for j in range(3):

[x for row in matrix for x in row]        # 평탄화 (1차원으로)
[[x*2 for x in row] for row in matrix]    # 모양 유지 (2차원 그대로)

# 길어지면 줄바꿈 — 훨씬 읽기 좋아집니다
성인 = [
    f"{p['이름']}({p['나이']})"
    for p in people
    if p["나이"] >= 20
]

대괄호 대신 괄호 — 메모리가 달라집니다

# [ ] = 전부 만들어 메모리에 올림 / ( ) = 필요할 때 하나씩
sum([x*x for x in range(10_000_000)])   # 리스트 통째로 (수백 MB)
sum(x*x for x in range(10_000_000))     # ✅ 메모리 거의 0

# 함수 인자로 넘길 땐 괄호를 생략할 수 있습니다
max(len(w) for w in words)
"\n".join(f"- {t}" for t in todos)
any(r["점수"] < 0 for r in rows)     # 첫 건에서 바로 멈춤 ★
all(r["점수"] >= 0 for r in rows)

# 계산을 한 번만 하고 재사용 — 왈러스(:=, 3.8+)
[y for x in data if (y := heavy(x)) is not None]

# dict · set 도 규칙은 같습니다
{p["이름"]: p["나이"] for p in people}
{p["팀"] for p in people}
{k: v for k, v in d.items() if v}      # 빈 값 제거

# ⚠ 컴프리헨션 안의 변수는 밖으로 새지 않습니다 (파이썬 3)
[i for i in range(3)]
print(i)      # NameError — for문과 다른 점

위치 전용 / · 키워드 전용 *

def order(품목, 수량, /, 할인=0, *, 포장=False):
    #            위치 전용 ↑   보통   ↑ 이후는 키워드 전용
    ...

order("사과", 3, 0.1, 포장=True)     # ✅
order(품목="사과", 수량=3)           # ❌ 위치 전용이라 에러
order("사과", 3, True)              # ⚠ 에러는 없지만 True 가 '할인'으로 들어감 — 포장은 키워드로만

# 왜 쓰나 — 나중에 인자 '이름'을 바꿔도 호출부가 안 깨지고,
#          True/False 를 그냥 던져 뜻을 알 수 없게 되는 것을 막습니다

# 가변 인자
def log(*msgs, sep=" ", **meta):
    print(sep.join(msgs), meta)
log("결제", "실패", user="민준", code=402)

# 언패킹해서 넘기기 (딕셔너리 → 키워드 인자)
args = ("사과", 3); kw = {"할인": 0.1, "포장": True}
order(*args, **kw)

# 타입 힌트 (3.10+ 표기)
def top(rows: list[dict], n: int = 3) -> list[str]: ...
def find(name: str) -> str | None: ...          # 없을 수도 있음
def apply(fn: Callable[[int], int], a: list[int]) -> list[int]: ...

문서화 · 중첩 · 반환

def bmi(kg: float, m: float) -> float:
    """체질량지수(BMI)를 계산합니다.

    Args:
        kg: 몸무게(킬로그램)
        m:  키(미터)
    Returns:
        BMI 값 (kg / m²)
    Raises:
        ZeroDivisionError: 키가 0일 때
    """
    return kg / m ** 2

help(bmi)        # 위 설명이 그대로 출력됩니다
bmi.__doc__      # 문자열로도 접근 가능

# 여러 값 반환 + 즉시 언패킹 (사실은 튜플)
def split_name(full: str) -> tuple[str, str]:
    return full[0], full[1:]
성, 이름 = split_name("김민준")

# 함수 안의 함수 — 밖으로 노출할 필요가 없을 때
def report(rows) -> str:
    def fmt(r):
        return f"{r['이름']:<6}{r['점수']:>4}"
    return "\n".join(fmt(r) for r in rows)

# 인자가 5개를 넘어가면 '묶는' 것을 고려하세요
from dataclasses import dataclass
@dataclass
class 주문:
    품목: str; 수량: int; 할인: float = 0
def process(o: 주문): ...

한 줄로 성능을 바꾸는 도구들

from functools import cache, lru_cache, partial, reduce, wraps

# ① 캐시 — 같은 인자로 다시 부르면 계산을 건너뜁니다
@cache                       # 3.9+ (무제한)
def fib(n):
    return n if n < 2 else fib(n-1) + fib(n-2)
fib(100)                     # 즉시 (없으면 사실상 영원히 안 끝남)

@lru_cache(maxsize=1024)     # 개수 제한 — API·DB 조회에 적합
def geocode(주소: str): ...
geocode.cache_info()         # 히트/미스 통계
geocode.cache_clear()
# ⚠ 인자는 해시 가능해야 합니다 (list ❌ → tuple 로 바꿔 넘기기)

# ② 인자를 미리 채운 '새 함수' 만들기
import json
from operator import mul
double    = partial(mul, 2);  double(5)      # 10
save_json = partial(json.dump, ensure_ascii=False, indent=2)

# ③ 누적 계산 (Java 의 reduce)
reduce(lambda a, b: a * b, [1,2,3,4])        # 24
# 대부분은 sum·max·min 이나 for문이 더 읽기 쉽습니다

클로저 — 값을 '기억하는' 함수

def counter():
    n = 0
    def inc():
        nonlocal n        # ★ 없으면 새 지역 변수가 되어 UnboundLocalError
        n += 1
        return n
    return inc

c = counter()
c(); c()          # 1, 2   (n 이 함수 안에 살아 있습니다)

# ⚠ 반복문 안 람다의 '늦은 바인딩' — 가장 헷갈리는 함정
fs = [lambda: i for i in range(3)]
[f() for f in fs]              # [2, 2, 2]  ❌ 전부 마지막 i
fs = [lambda i=i: i for i in range(3)]
[f() for f in fs]              # [0, 1, 2]  ✅ 기본값으로 현재 값 고정

# 데코레이터를 만들 땐 @wraps 를 꼭 붙이세요
import time
def timed(fn):
    @wraps(fn)                 # 원래 이름·docstring 보존
    def wrapper(*a, **kw):
        t0 = time.perf_counter()
        try:
            return fn(*a, **kw)
        finally:
            print(f"{fn.__name__} {time.perf_counter()-t0:.3f}s")
    return wrapper

@timed
def load(): ...

복사 방법 정리

import copy

b = a                    # 복사 아님! 같은 객체
b = a.copy()             # 얕은 복사
b = a[:]                 # 얕은 복사 (리스트)
b = list(a)              # 얕은 복사
b = {**d}                # 얕은 복사 (딕셔너리)
b = copy.deepcopy(a)     # 깊은 복사 (중첩까지 전부)

a is b        # 같은 객체인가
id(a)         # 객체 고유 번호 (Java 의 identityHashCode)

가변 vs 불변

def add_item(items):
    items.append("새 항목")   # ⚠️ 원본이 바뀜

def add_item_safe(items):
    items = items + ["새 항목"]  # 새 리스트
    return items

불변으로 만들어 두면 복사 고민이 사라집니다

from dataclasses import dataclass, replace, field

@dataclass(frozen=True)          # 만든 뒤에는 못 바꿉니다
class 설정:
    호스트: str
    포트: int = 5432

기본 = 설정("db.local")
개발 = replace(기본, 호스트="localhost")   # '바꾼 새 것'을 만듭니다
기본.포트 = 1                               # FrozenInstanceError ← 실수를 막아 줍니다

# ⚠ 가변 기본값은 dataclass 가 아예 막습니다 (field 로 지정)
@dataclass
class 바구니:
    항목: list[str] = field(default_factory=list)   # ✅ 인스턴스마다 새 리스트
    # 항목: list[str] = []   ← ValueError 로 알려 줍니다

# 읽기 전용 뷰로 넘기기 — 복사 없이 '건드리지 마세요'를 표현
from types import MappingProxyType
설정보기 = MappingProxyType(설정딕셔너리)   # 읽기 전용 dict
설정보기["k"] = 1                            # TypeError

# 큰 바이트 데이터는 잘라도 복사가 일어납니다 → memoryview 는 복사 없음
데이터 = bytearray(10_000_000)
조각 = 데이터[100:200]              # 복사 발생
조각 = memoryview(데이터)[100:200]  # 복사 없이 '창'만 냅니다

deepcopy 가 필요 없는 경우가 대부분입니다

# deepcopy 는 느리고, 예상 못 한 것까지 복사합니다
#   (DB 커넥션·락·파일 핸들이 딸려 있으면 그대로 복제되거나 터집니다)

# ① 중첩 dict/list 를 새로 만들 때 — 직렬화 왕복이 더 빠를 때가 많습니다
import json
사본 = json.loads(json.dumps(원본))     # JSON 으로 표현 가능한 자료라면

# ② 어차피 새로 만들 거라면 컴프리헨션으로 명시적으로
사본 = [{**행, "상태": "신규"} for 행 in 원본]

# ③ 정말 필요할 때만 deepcopy — 내 클래스는 복사 방식을 정할 수 있습니다
import copy
class 연결있는객체:
    def __deepcopy__(self, memo):
        새것 = 연결있는객체()
        새것.데이터 = copy.deepcopy(self.데이터, memo)
        새것.연결 = self.연결          # 연결은 공유 (복제하지 않음)
        return 새것

예제 — 장바구니를 “파이썬답게”

class 장바구니:
    def __init__(self, 상품들=None):
        self.상품들 = list(상품들 or [])

    def __len__(self):                 # len(바구니)
        return len(self.상품들)

    def __getitem__(self, i):          # 바구니[0]
        return self.상품들[i]

    def __iter__(self):                # for 상품 in 바구니
        return iter(self.상품들)

    def __contains__(self, 이름):       # "사과" in 바구니
        return any(s["이름"] == 이름 for s in self.상품들)

    def __add__(self, 다른):            # 바구니A + 바구니B
        return 장바구니(self.상품들 + 다른.상품들)

    def __repr__(self):
        return f"장바구니({len(self)}개)"

바구니 = 장바구니([{"이름":"사과","가격":3000}])
len(바구니)          # 1
"사과" in 바구니      # True
for 상품 in 바구니:   # 그냥 돌아갑니다
    print(상품)

정렬·비교·집합에 넣기

from dataclasses import dataclass
from functools import total_ordering

# dataclass 는 __eq__ 를 자동으로 만들어 줍니다
@dataclass(order=True)          # order=True -> 비교 연산까지
class 점수:
    값: int
    이름: str = ""

sorted([점수(90), 점수(70)])     # 값 기준 정렬 — 그냥 됩니다

# frozen=True 면 __hash__ 도 생겨 set/dict 키로 쓸 수 있습니다
@dataclass(frozen=True)
class 좌표:
    x: int
    y: int

방문 = {좌표(1,2), 좌표(1,2)}    # 중복 제거됨 -> 1개

# 직접 만들 때: __lt__ 하나만 정의하고 나머지는 자동 생성
@total_ordering
class 버전:
    def __init__(self, n): self.n = n
    def __eq__(self, o): return self.n == o.n
    def __lt__(self, o): return self.n < o.n

버전(2) >= 버전(1)               # True (자동으로 만들어짐)

무엇으로 데이터를 담을까 — 실무 선택표

# 무거운 준비는 __init__ 이 아니라 팩토리로 — 테스트가 쉬워집니다
class 리포트:
    def __init__(self, 행들: list[dict]):     # 순수하게 값만 받습니다
        self.행들 = 행들

    @classmethod
    def csv에서(cls, 경로: Path) -> "리포트":   # I/O 는 여기로 몰기
        return cls(list(csv.DictReader(경로.open(encoding="utf-8-sig"))))

상속은 마지막 수단입니다

# ❌ 기능 재사용을 위한 상속 — 부모가 바뀌면 자식이 다 깨집니다
class 엑셀리포트(리포트, 메일발송, 로깅믹스인): ...

# ✅ ① 필요한 것을 '가지기' (컴포지션)
class 엑셀리포트:
    def __init__(self, 리포트, 발송기):
        self.리포트, self.발송기 = 리포트, 발송기

# ✅ ② 계약이 필요하면 Protocol (구현 선언 없이 모양만 맞추기)
from typing import Protocol
class 발송기(Protocol):
    def 보내기(self, 제목: str, 본문: str) -> None: ...

# ✅ ③ 진짜 '반드시 구현' 을 강제해야 하면 ABC
from abc import ABC, abstractmethod
class 저장소(ABC):
    @abstractmethod
    def 저장(self, 키: str, 값: bytes) -> None: ...
#   구현을 빠뜨리면 인스턴스를 만들 때 TypeError 로 막힙니다

패키지의 얼굴을 __init__.py 로 만들기

# myapp/services/__init__.py
from .report import 리포트생성
from .mail import 메일발송

__all__ = ["리포트생성", "메일발송"]   # from ... import * 로 나갈 것 + 공개 API 선언

# 쓰는 쪽 — 내부 파일 구조를 몰라도 됩니다
from myapp.services import 리포트생성      # ✅
from myapp.services.report import 리포트생성  # 이것도 되지만 내부 구조에 묶입니다

# 나중에 report.py 를 report/ 폴더로 쪼개도 쓰는 쪽은 그대로입니다 ★

# 조건부 import — 선택 의존성 처리
try:
    import orjson as json_impl        # 있으면 빠른 것
except ImportError:
    import json as json_impl          # 없으면 표준

# 무거운 것은 쓸 때 불러오기 (시작 시간 절약)
def 엑셀쓰기(df):
    import openpyxl                   # 이 함수를 호출할 때만

# 문자열로 모듈 지정 — 플러그인 구조의 기본
import importlib
플러그인 = importlib.import_module(설정["핸들러"])   # "myapp.handlers.slack"

순환 import 를 푸는 세 가지 방법

# a.py 가 b 를 부르고, b.py 가 다시 a 를 부르면
#   ImportError: cannot import name 'X' from partially initialized module
#   (most likely due to a circular import)

# ① 함수 안으로 내리기 — 가장 간단합니다
def 처리():
    from .b import 도우미        # 모듈 로딩이 끝난 뒤에 실행됩니다
    return 도우미()

# ② 타입 힌트 때문이라면 런타임에 아예 안 부르기
from typing import TYPE_CHECKING
if TYPE_CHECKING:
    from .b import 사용자
def f(u: "사용자") -> None: ...

# ③ 진짜 해결 — 공통 부분을 아래층으로 빼기
#    a → b, b → a  (순환)
#    a → core ← b  (core 는 아무도 안 부름)   ★ 이게 정답인 경우가 대부분입니다

__file__이 없거나 통하지 않는 자리

import os, sys
from pathlib import Path

# ① 주피터 노트북 · 파이썬 대화형 셸 — __file__ 자체가 없습니다
루트 = Path.cwd()        # 노트북이 열린 폴더가 보통 cwd

# ② exe 로 묶었을 때(PyInstaller) — 코드는 임시폴더에 풀립니다
if getattr(sys, "frozen", False):
    실행폴더 = Path(sys.executable).parent   # exe 가 놓인 곳 → 설정·로그는 여기
    자원 = Path(sys._MEIPASS)                # 동봉한 데이터 → 읽기 전용
else:
    실행폴더 = 자원 = Path(__file__).resolve().parent

# ③ 패키지에 동봉한 데이터 — 경로 계산 대신 이게 정석
from importlib.resources import files
본문 = files("내패키지.templates").joinpath("mail.html").read_text("utf-8")

# ④ 사용자별 저장 위치 (설정·캐시 — 프로젝트 폴더에 쓰면 안 되는 것들)
Path.home() / ".myapp"                          # 어느 OS나
Path(os.environ["LOCALAPPDATA"]) / "내앱"        # 윈도우 앱 데이터

경로를 다룰 때 자주 쓰는 것

제너레이터

# return 대신 yield
def read_big_file(path):
    with open(path, encoding="utf-8") as f:
        for line in f:
            yield line.strip()     # 한 줄씩 내어줌

for line in read_big_file("10GB.log"):
    process(line)          # 메모리는 한 줄 분량만 사용

# 제너레이터 표현식 (대괄호 대신 소괄호)
total = sum(x**2 for x in range(10_000_000))

# 무한 수열도 가능
def counter():
    n = 0
    while True:
        yield n
        n += 1

from itertools import islice, chain, groupby, count
list(islice(counter(), 5))     # [0,1,2,3,4]

데코레이터

import functools, time

def timer(func):
    @functools.wraps(func)          # 원본 이름/독스트링 보존
    def wrapper(*args, **kwargs):
        t = time.perf_counter()
        result = func(*args, **kwargs)
        print(f"{func.__name__}: {time.perf_counter()-t:.3f}s")
        return result
    return wrapper

@timer                              # 이 한 줄이 핵심
def slow_task():
    time.sleep(1)

slow_task()      # slow_task: 1.001s

# 자주 쓰는 내장 데코레이터
from functools import lru_cache

@lru_cache(maxsize=128)             # 결과 캐싱
def fib(n):
    return n if n < 2 else fib(n-1) + fib(n-2)

데코레이터에 옵션 주기 — 괄호가 한 겹 늘어납니다

import functools, time

def 재시도(횟수=3, 대기=1.0):        # ① 옵션을 받는 바깥 함수
    def 데코(fn):                    # ② 진짜 데코레이터
        @functools.wraps(fn)
        def 안쪽(*a, **k):           # ③ 실제 호출을 감싸는 함수
            for i in range(횟수):
                try:
                    return fn(*a, **k)
                except (TimeoutError, ConnectionError):
                    if i == 횟수 - 1:
                        raise
                    time.sleep(대기 * 2 ** i)   # 1 → 2 → 4초
        return 안쪽
    return 데코

@재시도(횟수=5, 대기=0.5)
def 외부호출(): ...

# 여러 개를 겹치면 '아래에서 위로' 감쌉니다
@로깅          # 나중에 감쌈 (바깥)
@재시도()      # 먼저 감쌈 (안쪽)
def 작업(): ...
#   호출 순서: 로깅 → 재시도 → 작업

yield from 과 상태를 가진 제너레이터

# 중첩 구조를 평평하게 — 재귀와 궁합이 좋습니다
def 펼치기(항목):
    for x in 항목:
        if isinstance(x, list):
            yield from 펼치기(x)     # 하위 제너레이터에 위임
        else:
            yield x

list(펼치기([1, [2, [3, 4]], 5]))     # [1, 2, 3, 4, 5]

# 폴더 전체를 흘려보내기
def 모든줄(폴더):
    for p in sorted(Path(폴더).rglob("*.log")):
        with p.open(encoding="utf-8") as f:
            yield from f              # 파일 경계 없이 한 줄씩

# 상태를 들고 도는 제너레이터 — 슬라이딩 윈도우
def 이동평균(값들, n=3):
    from collections import deque
    창 = deque(maxlen=n)
    for v in 값들:
        창.append(v)
        if len(창) == n:
            yield sum(창) / n

# 무한 수열도 안전하게 잘라 쓰기
from itertools import count, islice
list(islice((x*x for x in count(1)), 5))   # [1, 4, 9, 16, 25]

with 문 직접 만들기 — @contextmanager

from contextlib import contextmanager
import time, sqlite3

@contextmanager
def 시간측정(label):
    t = time.perf_counter()
    try:
        yield                      # 여기서 with 블록 실행
    finally:
        print(f"{label}: {time.perf_counter()-t:.3f}s")

with 시간측정("집계"):
    df.groupby("팀").sum()

@contextmanager
def transaction(path):
    conn = sqlite3.connect(path)
    try:
        yield conn
        conn.commit()              # 정상 종료 → 커밋
    except Exception:
        conn.rollback()            # 예외 → 롤백
        raise
    finally:
        conn.close()

with transaction("app.db") as conn:
    conn.execute("INSERT ...")

타입 시스템 고급 — 인터페이스와 제네릭

from typing import Literal, Protocol, TypeVar, overload

# Protocol = 구조적 인터페이스 (implements 선언 불필요!)
class Exportable(Protocol):
    def to_excel(self, path: str) -> None: ...

def 저장(report: Exportable, path: str):
    report.to_excel(path)      # to_excel 만 있으면 어떤 객체든 OK

# 제네릭 함수 (3.12+ 새 문법)
def first[T](items: list[T]) -> T | None:
    return items[0] if items else None

# 구버전 문법
T = TypeVar("T")
def first(items: list[T]) -> T | None: ...

# overload — 인자에 따라 반환 타입이 다를 때
@overload
def load(path: str, as_df: Literal[True] = ...) -> "pd.DataFrame": ...
@overload
def load(path: str, as_df: Literal[False]) -> dict: ...
def load(path: str, as_df: bool = True):    # 실제 구현은 하나 (overload 아래에)
    ...
#   bool 로 두 번 쓰면 두 시그니처가 겹쳐 mypy 가 구분하지 못합니다 — Literal 로 갈라 주세요

🐛 에러 해결

파이썬으로 [하려는 일]을 하고 있어.
환경: Windows / Python 3.12 / [라이브러리와 버전]

이 코드를 실행하면:
[코드 전체 붙여넣기]

이런 에러가 나:
[에러 메시지 전체 붙여넣기]

[내가 시도해본 것]도 해봤는데 안 됐어.
원인이 뭔지 설명해주고, 고친 코드를 줘.
왜 그렇게 고쳐야 하는지도 기초부터 설명해줘.

📖 남의 코드(이 가이드 코드) 이해

아래 파이썬 코드를 한 줄씩 주석으로 설명해줘.
나는 파이썬은 처음이고 Java는 할 줄 알아서,
Java 개념에 비유해주면 더 좋아.

[코드 붙여넣기]

특히 [이해 안 되는 부분]이 무슨 뜻인지 자세히.

🛠️ 코드 작성 요청

파이썬으로 [하려는 일]을 하는 스크립트를 만들어줘.

입력: [예: D:\data 폴더의 xlsx 파일들, 형식 설명]
출력: [예: 팀별 합계가 담긴 result.xlsx]
조건:
- Windows, Python 3.12, uv 사용
- pandas 사용, 한글 경로/한글 컬럼명 있음
- 파일이 없거나 형식이 다르면 에러 대신 로그 남기고 건너뛰기

코드에 기초 설명 주석을 달아주고,
실행 전에 uv add 로 설치할 패키지도 알려줘.

🔍 코드 리뷰 · 개선

이 파이썬 코드가 동작은 하는데, 더 나은 방법이 있는지 봐줘.

[코드 붙여넣기]

1) 버그나 위험한 부분  2) 더 파이썬다운 표현
3) 성능 문제  순서로 짚어주고,
고친 버전 전체를 다시 써줘. 바뀐 이유도 설명해줘.

💡 대화를 잘 이어가는 5가지 습관

• 작게 쪼개서 물어보기 — “전체 프로그램 만들어줘”보다 “CSV 읽는 부분부터” 단계별로. 한 번에 하나씩이 정확합니다
• 받은 코드는 반드시 실행해서 검증 — AI도 틀립니다. 에러가 나면 그 에러를 그대로 다시 붙여넣으세요 (이게 정상 흐름입니다)
• “왜?”를 물어보기 — 동작하는 코드를 받고 끝내면 실력이 안 늡니다. “왜 여기서 copy()를 썼어?”가 진짜 공부입니다
• 버전을 명시 — 파이썬·라이브러리는 버전마다 문법이 다릅니다. 버전을 안 알려주면 옛날 문법을 받을 수 있습니다
• 같은 대화에서 이어가기 — 맥락이 쌓일수록 답이 정확해집니다. 주제가 바뀔 때만 새 대화를 여세요

📚 학습 로드맵 요청

나는 [Java 백엔드 3년차 / 프로그래밍 처음]이고,
파이썬으로 [엑셀 업무 자동화]를 하는 게 목표야.
하루 1시간씩 쓸 수 있어.

4주 학습 계획을 짜줘. 주차별로:
- 배울 개념과 이유
- 직접 해볼 미니 과제 1개
- 스스로 확인할 체크리스트
형태로. 과제는 실무와 비슷한 걸로.

① print 로 “진짜 값” 보기

# 무엇이 들어있는지 + 어떤 타입인지 같이
print(f"{데이터=}")        # 데이터=[1, 2, 3]  ← 변수명까지 자동 출력
print(type(데이터), len(데이터))

# 반복문 안이라면 인덱스도
for i, x in enumerate(목록):
    print(i, repr(x))     # repr 이면 공백·따옴표까지 보입니다

추측하지 말고 찍어보세요. 버그의 8할은 “값이 내 생각과 다른 것”입니다.

② breakpoint() 로 멈춰 세우기

def 평균(점수들):
    합계 = sum(점수들)
    개수 = len(점수들)
    breakpoint()          # 여기서 실행이 멈춥니다
    return 합계 / 개수

# 멈춘 뒤 터미널에서:
#   합계        값 확인
#   n           다음 줄 실행
#   c           계속 진행
#   q           종료

설치할 것 없이 파이썬에 내장돼 있습니다. VS Code·PyCharm에서는 줄 번호 옆을 클릭해도 같습니다.

③ 에러를 “잡되 삼키지 않기”

# ❌ 최악 — 무슨 일이 났는지 영영 모릅니다
try:
    작업()
except:
    pass

# ✅ 구체적으로 잡고, 무슨 일인지 남기기
import logging
try:
    작업()
except (ValueError, KeyError) as e:
    logging.exception("작업 실패: %s", e)
    raise                 # 필요하면 다시 던지기

except: 만 쓰면 Ctrl+C 종료까지 잡아버립니다. 항상 종류를 적으세요.