왈러스 연산자 vs 일반 대입
Python 3.8에 들어온 := 연산자는 표현식 안에서 대입을 합니다. 일반 대입과 무엇이 다른지, 어디서 코드를 간결하게 만들고 어디서 오히려 해치는지 정리합니다.
PALDYN LEARN
AI 학습
AI가 어떻게 작동하는지 배웁니다. 모델의 원리부터 그 아래를 떠받치는 수학, 실제로 굴리는 방법까지.
- 466편
- 전체
- 08
- 분야
얕은 복사 vs 깊은 복사
리스트를 복사했는데 원본이 같이 바뀌는 당황스러운 현상. 얕은 복사가 안쪽 객체를 공유하는 원리와 copy.deepcopy로 끝까지 떼어내는 법을 정리합니다.
리스트 vs 튜플, 언제 무엇을 쓸까
리스트와 튜플은 둘 다 순서 있는 모음이지만 쓰임이 다릅니다. 변경 가능성, 해시 가능 여부, 그리고 '모음 vs 레코드'라는 의미의 차이로 선택 기준을 정리합니다.
덕 타이핑 vs isinstance — 타입을 묻지 않는 법
'오리처럼 행동하면 오리다.' 파이썬의 덕 타이핑이 무엇인지, 그리고 isinstance로 타입을 직접 검사하는 것이 언제 적절하고 언제 코드를 굳게 만드는지 비교합니다.
파이썬다운 코드란? — Pythonic vs Non-Pythonic
동작은 같지만 읽는 느낌이 다른 코드. '파이썬답다'는 말이 가리키는 구체적인 습관들을 컴프리헨션, EAFP, 언패킹 같은 실제 예제로 정리합니다.
클로저의 늦은 바인딩 함정
반복문 안에서 만든 람다들이 모두 같은 마지막 값을 돌려주는 이유를 클로저의 늦은 바인딩으로 이해하고, 기본 인자와 partial로 해결하는 법을 정리합니다.
가변 기본 인자의 함정
def f(x, lst=[])가 호출마다 같은 리스트를 공유해 버그가 되는 이유를 함수 정의 시점의 동작으로 이해하고, None 센티넬 패턴으로 안전하게 푸는 법을 정리합니다.
인코딩·디코딩 에러 다루기
UnicodeDecodeError와 UnicodeEncodeError가 왜 나는지 str과 bytes의 관계로 이해하고, 올바른 코덱 지정과 errors 인자로 해결하는 법을 정리합니다.
순환 임포트 해결하기
두 모듈이 서로를 import할 때 발생하는 ImportError의 원인을 모듈 로딩 과정으로 이해하고, 구조 분리·지연 import·TYPE_CHECKING으로 푸는 방법을 정리합니다.
의존성 취약점 스캔: pip-audit로 안전한 패키지 관리
우리가 직접 쓰지 않는 간접 의존성에도 취약점이 숨습니다. pip-audit로 알려진 CVE를 점검하고, 버전 고정과 자동화로 공급망을 지키는 방법을 정리합니다.
eval과 exec의 위험성
문자열을 코드로 실행하는 eval과 exec이 왜 위험한지, 그리고 ast.literal_eval, json, 디스패치 딕트 같은 안전한 대안으로 같은 목적을 달성하는 법을 정리합니다.
pickle의 보안 위험: 신뢰할 수 없는 데이터를 풀지 마라
pickle은 데이터가 아니라 코드를 실행할 수 있는 직렬화 형식입니다. 어떻게 임의 코드 실행으로 이어지는지, 그리고 언제 pickle 대신 json을 써야 하는지 정리합니다.
bcrypt로 비밀번호 안전하게 저장하기
비밀번호를 평문이나 단순 해시로 저장하면 안 되는 이유부터, salt와 work factor로 무차별 대입을 막는 bcrypt의 원리와 올바른 사용법까지 정리합니다.
secrets vs random: 보안에 안전한 난수 만들기
토큰과 비밀번호 재설정 링크에 random 모듈을 쓰면 안 되는 이유, 그리고 암호학적으로 안전한 난수를 제공하는 secrets 모듈의 올바른 사용법을 정리합니다.
SQLAlchemy ORM: 파이썬으로 SQL 다루기
Python에서 가장 널리 쓰이는 데이터베이스 툴킷 SQLAlchemy. Core와 ORM 두 층, 모델 매핑, 그리고 변경을 모았다 한 번에 반영하는 Session과 트랜잭션까지 핵심을 정리합니다.
Celery: 무거운 작업을 백그라운드로
시간이 오래 걸리는 작업을 요청 흐름 밖으로 떼어 내는 작업 큐 Celery. 생산자·브로커·워커 구조, .delay() 호출, 작업 상태 추적과 재시도까지 비동기 작업 처리의 기본을 정리합니다.
marshmallow: 스키마 기반 직렬화
Schema 클래스로 직렬화와 역직렬화를 다루는 marshmallow. load와 dump의 두 방향, 필드 검증, 그리고 Pydantic과의 차이까지 데이터 변환 라이브러리의 또 다른 접근을 정리합니다.
Pydantic: 데이터 검증을 타입으로
타입 힌트로 데이터 검증을 선언하는 Pydantic. BaseModel로 모델을 정의하고, 자동 형변환과 Field 제약, ValidationError, 그리고 직렬화까지 신뢰할 수 있는 데이터의 경계를 만드는 법을 정리합니다.
requests vs httpx: HTTP 클라이언트 고르기
외부 API를 호출하는 두 라이브러리 requests와 httpx를 비교합니다. 거의 같은 사용법, Session/Client로 연결 재사용, 비동기 지원과 HTTP/2까지 어느 쪽을 언제 쓸지 정리합니다.
Jinja2 템플릿: 데이터를 HTML로
Flask와 Django가 쓰는 템플릿 엔진 Jinja2. 변수 출력과 제어 구문, 필터, 그리고 중복을 없애는 템플릿 상속과 자동 이스케이프까지 서버가 HTML을 그려 내는 방법을 정리합니다.
uvicorn과 ASGI: 비동기 서버의 토대
FastAPI를 떠받치는 ASGI 규약과 그 대표 서버 uvicorn. WSGI와의 차이, 서버와 앱이 분리된 이유, 그리고 개발용과 운영용 실행 방법까지 비동기 웹의 토대를 정리합니다.
FastAPI 기초: 타입 힌트로 만드는 API
타입 힌트를 그대로 검증과 문서화에 활용하는 현대적 웹 프레임워크 FastAPI. 경로·쿼리 파라미터, Pydantic 요청 본문, 자동 생성되는 대화형 문서까지 핵심을 정리합니다.
Django ORM 기초: 모델로 DB 다루기
SQL을 직접 쓰지 않고 파이썬 클래스로 데이터베이스를 다루는 Django ORM. 모델 정의와 마이그레이션, CRUD, 그리고 게으른 QuerySet의 동작 원리까지 한 번에 정리합니다.
Flask 입문: 가장 작은 웹 앱부터
마이크로 웹 프레임워크 Flask의 기본기. 다섯 줄짜리 앱으로 라우팅을 이해하고, 변수 규칙과 HTTP 메서드, 그리고 템플릿과 JSON 응답까지 웹 서버의 출발점을 정리합니다.
pandas 시계열: 날짜 인덱스와 리샘플링
pandas로 시계열 데이터를 다루는 기본기. DatetimeIndex로 날짜 기반 슬라이싱을 열고, resample로 시간 단위를 바꾸고, rolling으로 이동평균을 구하는 흐름을 정리합니다.
대용량 CSV: 메모리 안에서 다 읽지 않기
RAM보다 큰 CSV를 다루는 pandas 기법. chunksize로 조각내 읽기, usecols와 dtype으로 메모리 줄이기, 그리고 Parquet 같은 대안까지 메모리 한계를 넘는 실전 전략을 정리합니다.
데이터 클리닝: 결측치와 이상치 다루기
pandas로 데이터를 정제하는 실전 흐름. 결측치를 제거·대치·표시하는 세 갈래 선택, 타입과 중복 처리, 이상치를 찾는 방법까지 분석 전 반드시 거치는 단계를 정리합니다.
scikit-learn 입문: fit과 predict의 흐름
scikit-learn의 일관된 estimator API(fit·predict)를 이해하고, train_test_split으로 데이터를 나누는 이유, 첫 분류 모델을 학습하고 평가하는 전체 흐름을 정리합니다.
Jupyter Notebook: 셀 단위로 탐색하기
Jupyter Notebook의 셀 구조와 커널 개념을 이해하고, 실행 순서가 위치와 다를 수 있다는 가장 흔한 함정과 Restart & Run All의 중요성까지 데이터 탐색 관점에서 정리합니다.
matplotlib 기초: 첫 그래프 그리기
matplotlib의 Figure와 Axes 구조를 이해하고, 객체지향 방식으로 첫 그래프를 그리는 흐름을 정리합니다. plt.subplots부터 축 라벨·범례·저장까지 기본기를 한 번에 잡습니다.
pandas merge: 표를 키로 이어 붙이기
pandas merge로 서로 다른 두 DataFrame을 공통 키로 결합하는 법. inner·left·right·outer 조인의 차이, on과 how 인자, concat과의 차이까지 그림과 함께 정리합니다.
pandas groupby: 나누고 적용하고 합치기
pandas groupby의 핵심 개념인 split-apply-combine을 그림으로 이해하고, 단일 집계부터 agg로 여러 통계를 동시에 구하는 법, transform과의 차이까지 정리합니다.
pandas DataFrame: 표 데이터의 기본 단위
pandas의 핵심 자료구조 DataFrame이 무엇인지, 인덱스와 컬럼(Series)으로 어떻게 구성되는지, 그리고 컬럼 선택과 loc·iloc로 데이터를 골라내는 기본기를 정리합니다.
NumPy 기초: ndarray와 벡터화 연산
NumPy의 핵심 자료구조 ndarray가 파이썬 리스트와 무엇이 다른지, shape·dtype·ndim의 의미, 그리고 루프 없이 배열 전체를 한 번에 계산하는 벡터화의 원리를 정리합니다.
icecream: print 디버깅을 견딜 만하게
print 디버깅의 불편을 덜어 주는 icecream(ic). 식 텍스트 자동 표시, 위치 추적, 통과값 반환, 한 줄로 전체 끄기 같은 기능과, 적절한 사용 범위까지 정리합니다.
py-spy: 코드 수정 없는 샘플링 프로파일러
실행 중인 파이썬 프로세스에 코드 수정 없이 붙어 프로파일링하는 py-spy. top·record·dump 세 모드, 낮은 오버헤드로 운영에서도 쓰는 법, 샘플링 방식의 원리까지 정리합니다.
tracemalloc: 메모리 할당을 추적하기
표준 라이브러리 tracemalloc으로 메모리 할당 위치를 추적하는 법. start와 take_snapshot, 두 스냅샷의 compare_to로 누수를 찾는 흐름, statistics로 상위 할당 지점 보기까지 정리합니다.
memory_profiler: 줄 단위로 메모리 보기
memory_profiler로 함수의 각 줄이 메모리를 얼마나 쓰는지 측정하는 법. @profile 데코레이터와 Mem usage·Increment 컬럼 읽기, mprof로 시간에 따른 메모리 추이까지 정리합니다.
cProfile: 시간이 어디서 새는지 측정하기
표준 라이브러리 cProfile로 함수별 실행 시간을 측정하는 법. ncalls·tottime·cumtime의 차이, sort_stats로 병목을 찾는 흐름, 측정 없이 추측하지 말라는 원칙까지 정리합니다.
logging 설정: 로거 계층과 dictConfig
로거의 점 표기 계층과 전파(propagation), 핸들러·포매터를 한곳에 묶는 dictConfig, 라이브러리는 핸들러를 달지 않는다는 원칙까지 — 실전 logging 설정을 정리합니다.
logging 모듈: print를 졸업하는 법
표준 라이브러리 logging의 기본기 — 다섯 가지 레벨, Logger·Handler·Formatter의 역할 분담, getLogger(__name__) 관례, %s 지연 포매팅까지 한 번에 정리합니다.
print 디버깅의 함정과 졸업
print 디버깅이 왜 자주 우리를 배신하는지 — 지우는 걸 잊고, 위치를 모르고, 켜고 끌 수 없고, 버퍼링에 묻히는 네 가지 함정과, 더 나은 대안으로 넘어가는 법을 정리합니다.
breakpoint(): 디버거를 부르는 표준 한 줄
파이썬 3.7의 내장 함수 breakpoint()와 PYTHONBREAKPOINT 환경변수로 디버거를 호출하고, 교체하고, 한꺼번에 끄는 법을 정리합니다. set_trace와 무엇이 다른지도 짚습니다.
pdb 기초: 파이썬 내장 디버거 시작하기
표준 라이브러리 pdb로 코드를 한 줄씩 따라가며 변수를 들여다보는 법. set_trace와 breakpoint, n·s·c·l·p 같은 핵심 명령어, 호출 스택 이동까지 정리합니다.
테스트 디스커버리: 도구가 테스트를 찾는 규칙
pytest와 unittest가 테스트 파일·클래스·함수를 찾아내는 이름 규칙, rootdir와 conftest, 프로젝트 레이아웃과 import 문제까지 완전 정복합니다.
doctest: 문서 속 예제를 테스트로
docstring 안의 >>> 예제를 그대로 실행해 검증하는 doctest의 원리와 실행법, 옵션 플래그, 그리고 적합한 자리와 한계를 완전 정복합니다.
Hypothesis로 시작하는 속성 기반 테스트
내가 고른 예시 대신 라이브러리가 입력을 생성하는 속성 기반 테스트의 원리, @given과 전략, 반례 최소화(shrink)까지 Hypothesis로 완전 정복합니다.
tox와 nox: 여러 환경에서 자동으로 테스트하기
여러 파이썬 버전·의존성 조합에서 격리된 가상환경으로 테스트를 자동화하는 tox와 nox의 구조, 선언형과 코드형의 차이, 활용법을 완전 정복합니다.
코드 커버리지: 테스트가 닿지 않은 곳 찾기
coverage.py와 pytest-cov로 라인·브랜치 커버리지를 측정하고 보고서를 읽는 법, 그리고 커버리지 숫자를 올바르게 해석하는 관점을 완전 정복합니다.
mock과 monkeypatch: 의존성을 가짜로 바꾸기
외부 API·시간·랜덤처럼 통제하기 어려운 의존성을 테스트 중에만 가짜로 대체하는 monkeypatch와 unittest.mock의 사용법과 검증 패턴을 완전 정복합니다.
parametrize: 하나의 테스트를 여러 입력으로 펼치기
@pytest.mark.parametrize로 같은 검증 로직을 여러 입력에 자동 적용하는 법, 루프와의 차이, id와 fixture 조합까지 완전 정복합니다.
pytest fixture: 테스트 준비물을 우아하게 주입하기
함수 인자 이름으로 자동 주입되는 pytest fixture의 원리, yield 기반 정리, scope로 재생성 주기를 조절하는 법까지 완전 정복합니다.
pytest 기초: assert 한 줄로 쓰는 테스트
평범한 함수와 내장 assert만으로 테스트를 작성하는 pytest의 철학, 풍부한 실패 메시지, 실행과 선택 방법까지 완전 정복합니다.
unittest 기초: 표준 라이브러리로 시작하는 테스트
파이썬에 내장된 unittest로 TestCase를 작성하는 법, assert 메서드와 setUp·tearDown 생명주기, 테스트를 실행하고 읽는 법까지 완전 정복합니다.
버전 고정과 lock 파일: 재현 가능한 빌드
==·>=·~= 같은 버전 지정자의 의미와, lock 파일이 전이 의존성까지 고정해 빌드를 재현 가능하게 만드는 원리를 실전 전략과 함께 완전 정복합니다.
PyPI 배포: 내 패키지를 세상에 공개하기
build로 배포물을 만들고 twine으로 TestPyPI를 거쳐 PyPI에 올리는 전 과정과, API 토큰·이름 충돌 등 실전 주의점까지 함께 완전 정복합니다.
wheel vs sdist: 두 가지 배포 아티팩트
소스 배포물 sdist와 빌드 완료물 wheel의 구조·설치 경로·플랫폼 태그 차이를, 왜 둘 다 배포하는지까지 함께 완전 정복합니다.
setup.py vs pyproject.toml: 패키징 설정의 세대 교체
명령형 setup.py에서 선언형 pyproject.toml로 넘어온 패키징 설정의 흐름과 그 이유, 마이그레이션 요령까지 함께 완전 정복합니다.
pyproject.toml: 프로젝트 설정의 단일 표준
build-system·project·tool 세 영역으로 나뉘는 pyproject.toml의 구조와 빌드 백엔드가 호출되는 흐름을, 작성 예시와 함께 완전 정복합니다.
uv: Rust로 다시 쓴 초고속 패키지 매니저
uv가 Rust 기반 설계와 전역 캐시로 설치를 극적으로 빠르게 만드는 원리와, pip·venv·pip-tools를 하나로 통합하는 사용법까지 완전 정복합니다.
PDM: 표준을 따르는 현대적 패키지 관리자
PDM이 PEP 621 표준 메타데이터를 그대로 쓰면서 빠른 의존성 해결과 lock을 제공하는 방식을, 핵심 명령과 Poetry와의 차이까지 함께 완전 정복합니다.
Poetry: 의존성·환경·패키징을 한 도구로
Poetry로 의존성 해결과 lock, 가상환경, 빌드·배포를 하나의 워크플로로 묶는 법을, 핵심 명령과 동작 방식까지 함께 완전 정복합니다.
venv: 프로젝트마다 격리된 가상환경 만들기
venv로 프로젝트별 의존성을 격리해 버전 충돌을 없애는 법을, 생성·활성화·동작 원리와 흔한 함정까지 함께 완전 정복합니다.
pip 기초: 패키지를 설치하고 관리하기
pip로 패키지를 설치·제거·조회하고 requirements.txt로 환경을 재현하는 기본기를, 동작 원리와 흔한 함정까지 함께 완전 정복합니다.
Self 타입: 메서드 체이닝과 자기 참조
Self 타입으로 메서드 체이닝과 팩토리 메서드를 서브클래스에서도 정확히 추론하게 만드는 법, TypeVar bound 방식과의 비교까지 완전 정복합니다.
런타임 타입 검사: runtime_checkable과 그 한계
runtime_checkable Protocol로 isinstance를 쓰는 법과 그것이 검증하지 못하는 것, get_type_hints·typeguard·pydantic까지 런타임 타입 검사를 완전 정복합니다.
mypy와 pyright: 두 정적 타입 검사기 비교
파이썬 대표 타입 검사기 mypy와 pyright의 구조·속도·엄격성 차이를 비교하고, 설정과 strict 모드, CI 통합까지 실전 운영법을 완전 정복합니다.
ParamSpec: 데코레이터의 시그니처를 보존하기
ParamSpec과 P.args·P.kwargs로 데코레이터가 원본 함수의 매개변수 시그니처를 그대로 유지하게 만드는 법, Concatenate까지 완전 정복합니다.
typing.Protocol: 상속 없는 구조적 타이핑
Protocol로 명시적 상속 없이 인터페이스를 정의하는 구조적 서브타이핑을 다루고, ABC와의 차이·제네릭 Protocol·실전 활용까지 완전 정복합니다.
TypedDict: 딕셔너리에 구조를 부여하기
TypedDict로 딕셔너리의 키와 값 타입을 고정하고, 선택적 키·total 옵션·중첩 구조까지 다루며 JSON 데이터를 안전하게 처리하는 법을 완전 정복합니다.
Literal과 Final: 값과 불변을 타입으로 표현하기
Literal로 허용 값을 특정 상수로 제한하고, Final로 재할당을 금지하는 법, 그리고 둘을 조합한 안전한 상수 설계까지 완전 정복합니다.
Union과 Optional: 여러 타입을 허용하기
Union, 파이프 신문법, Optional의 정확한 의미와 타입 좁히기(narrowing)까지, 여러 타입을 안전하게 다루는 법을 완전 정복합니다.
제네릭: TypeVar와 Generic으로 타입을 재사용하기
TypeVar로 타입 변수를 선언하고, 제네릭 함수와 제네릭 클래스를 만드는 법, 그리고 PEP 695의 새 문법까지 파이썬 제네릭을 완전 정복합니다.
타입 힌트 입문: 파이썬에 타입을 더하는 법
파이썬의 타입 힌트가 무엇이고 왜 필요한지, 변수·함수에 어떻게 붙이는지, 그리고 정적 검사기와 런타임의 관계를 완전 정복합니다.
Lock, RLock, Semaphore
threading의 Lock으로 임계 구역을 보호하는 법, 재진입이 가능한 RLock의 필요성, 동시 접근 수를 제한하는 Semaphore, with 문으로 안전하게 락을 다루는 패턴과 교착 상태를 설명합니다.
스레드 안전 Queue
queue.Queue로 스레드 사이에서 안전하게 데이터를 주고받는 생산자-소비자 패턴, put과 get의 블로킹 동작, task_done과 join, LifoQueue와 PriorityQueue까지 설명합니다.
Trio와 AnyIO
구조적 동시성을 내세운 Trio의 nursery 개념과 asyncio와의 차이, 두 백엔드를 모두 지원하는 AnyIO로 라이브러리를 작성하는 방법, 언제 어떤 것을 선택할지 설명합니다.
aiohttp와 httpx
비동기 HTTP 클라이언트 aiohttp와 httpx의 차이와 선택 기준, 세션을 재사용해 동시 요청을 보내는 패턴, asyncio.gather와 함께 수백 개 요청을 병렬 처리하는 방법을 설명합니다.
블로킹 I/O와 asyncio
asyncio에서 동기 블로킹 호출이 이벤트 루프 전체를 멈추는 이유와 증상, run_in_executor와 asyncio.to_thread로 블로킹 코드를 스레드로 떠넘기는 방법, CPU 바운드 작업의 처리를 설명합니다.
async / await 문법
async def로 코루틴을 정의하고 await로 결과를 기다리는 문법의 정확한 의미, awaitable의 종류, async for와 async with, 코루틴과 제너레이터의 차이를 정리합니다.
asyncio 작업 취소
asyncio Task를 cancel로 취소하는 원리, CancelledError를 다루는 올바른 방법, asyncio.timeout과 wait_for로 시간 제한을 거는 법, shield로 취소를 막는 패턴을 설명합니다.
asyncio Task와 gather
create_task로 코루틴을 동시 실행하는 Task를 만드는 방법, gather로 여러 작업을 모아 기다리기, return_exceptions 옵션, TaskGroup까지 asyncio 동시성의 핵심 도구를 설명합니다.
asyncio 이벤트 루프
asyncio 이벤트 루프가 코루틴을 어떻게 스케줄링하는지, run의 동작, get_running_loop, call_soon과 call_later, 루프를 직접 다룰 때 주의할 점을 설명합니다.
asyncio 기초
asyncio가 무엇이고 언제 쓰는지, 코루틴과 async/await로 단일 스레드에서 동시성을 구현하는 원리, asyncio.run으로 비동기 프로그램을 시작하는 기본 패턴을 설명합니다.
ThreadPoolExecutor
concurrent.futures.ThreadPoolExecutor로 I/O 바운드 작업을 스레드 풀로 병렬화하는 방법, map과 submit 차이, as_completed, Future 객체 사용법을 설명합니다.
ProcessPoolExecutor
concurrent.futures.ProcessPoolExecutor로 프로세스 풀을 관리하고 CPU 바운드 작업을 병렬화하는 방법, map과 submit 차이, as_completed, chunksize 튜닝을 설명합니다.
multiprocessing 기초
Python multiprocessing 모듈로 별도 프로세스를 생성하는 방법, Queue와 Pipe로 프로세스 간 통신(IPC), Pool.map 기초, Windows/Linux 차이점을 설명합니다.
threading 모듈
Python threading 모듈로 스레드를 생성하고 관리하는 방법, daemon 스레드, Lock/Event/Semaphore 동기화 프리미티브, threading.local() 스레드 로컬 저장소를 설명합니다.
GIL — 전역 인터프리터 잠금
CPython의 GIL이 무엇인지, 왜 존재하는지, CPU 바운드와 I/O 바운드 작업에 각각 어떤 영향을 미치는지, Python 3.13의 free-threaded 실험까지 설명합니다.
비동기 컨텍스트 매니저
__aenter__와 __aexit__을 구현해 async with 문에서 비동기 자원을 관리하는 방법, @asynccontextmanager 데코레이터, AsyncExitStack 활용법을 설명합니다.
ExitStack — 동적 컨텍스트 매니저 스택
contextlib.ExitStack으로 런타임에 결정된 개수의 컨텍스트 매니저를 동적으로 쌓고 LIFO 순서로 해제하는 방법, callback 등록, 소유권 이전 패턴을 설명합니다.
contextlib.suppress와 redirect
contextlib.suppress로 특정 예외를 억제하는 방법, redirect_stdout/redirect_stderr로 출력을 리다이렉트하는 방법, nullcontext 활용법을 설명합니다.
contextlib.contextmanager 데코레이터
@contextmanager 데코레이터로 제너레이터 함수를 컨텍스트 매니저로 변환하는 방법, yield 전/후 코드 흐름, try/finally 패턴, 클래스 방식과의 비교를 설명합니다.
컨텍스트 매니저 클래스
__enter__와 __exit__ 메서드를 구현해 with 문에서 사용 가능한 컨텍스트 매니저 클래스를 만드는 방법, __exit__의 예외 처리 로직, 실용 예제를 다룹니다.
deprecated 경고 데코레이터
warnings 모듈을 활용해 deprecated 함수 경고 데코레이터를 구현하는 방법, stacklevel 파라미터의 의미, 경고 필터 제어, Python 3.13 내장 데코레이터를 설명합니다.
캐시 데코레이터: lru_cache와 cache
functools.lru_cache, cache, cached_property의 동작 원리, LRU 알고리즘, 메모이제이션 패턴, 메서드에서의 메모리 누수 주의사항을 설명합니다.
property 데코레이터 완전 이해
@property로 getter/setter/deleter를 정의하는 방법, 디스크립터 프로토콜과의 관계, computed property와 캐싱 패턴을 설명합니다.
타입 힌트와 데코레이터
Callable, TypeVar, ParamSpec을 사용해 데코레이터에 정확한 타입 힌트를 붙이는 방법과 mypy/pyright가 데코레이터 타입을 추론하는 원리를 설명합니다.
상태를 가진 데코레이터
함수 속성, 클로저 변수, 클래스 인스턴스를 활용해 데코레이터에 상태를 저장하는 세 가지 패턴과 각각의 장단점을 설명합니다.
중첩 데코레이터와 적용 순서
@A @B @C로 여러 데코레이터를 쌓을 때 적용 순서와 실행 순서가 어떻게 다른지, 순서가 결과에 미치는 영향을 코드 예제로 설명합니다.
클래스로 만드는 데코레이터
__call__을 구현한 callable 클래스로 데코레이터를 만드는 패턴, 클래스에 데코레이터를 적용하는 패턴, 함수 데코레이터와의 차이를 설명합니다.
인자를 받는 데코레이터 만들기
@repeat(n=3)처럼 인자를 전달하는 데코레이터 패턴, 3겹 중첩 함수 구조, functools.partial을 활용한 단순화 방법을 설명합니다.
functools.wraps: 데코레이터와 메타데이터 보존
데코레이터 적용 후 사라지는 __name__, __doc__, __annotations__ 등 메타데이터를 functools.wraps로 보존하는 방법과 그 원리를 설명합니다.
데코레이터의 본질: 함수를 감싸는 함수
Python 데코레이터가 왜 '고차 함수'인지, @syntax가 내부에서 어떻게 동작하는지, 클로저와의 관계를 예제 중심으로 설명합니다.
부작용 격리 패턴: 순수와 불순을 분리하는 설계
부작용(side effect)을 순수 코어에서 분리하는 계층 분리 패턴, 의존성 주입, 효과를 반환값으로 표현하기, 테스트 전략을 코드 예제와 함께 설명합니다.
함수형 데이터 파이프라인: 실전 설계 패턴
순수 함수 조합으로 데이터 파이프라인을 구축하는 방법, 불순 코드를 경계로 격리하는 설계, pandas 파이프라인, 제너레이터 파이프라인, 병렬 처리 통합을 설명합니다.
메모이제이션 패턴: 계산 결과 캐싱 전략
메모이제이션의 원리, functools.lru_cache와 cache 데코레이터, 수동 딕셔너리 캐시, TTL 캐시, 캐시 무효화 전략, 그리고 메모이제이션 함정을 설명합니다.
꼬리 재귀와 재귀 깊이 제한: sys.setrecursionlimit 완전 이해
Python의 재귀 깊이 제한(1000), RecursionError 원인, 꼬리 재귀 최적화(TCO) 부재, 트램폴린 기법, 반복문 변환, lru_cache 활용 등 실전 해결책을 설명합니다.
파이프 패턴: 데이터를 흘리는 함수형 파이프라인
함수형 파이프 패턴의 개념, toolz.pipe와 커스텀 Pipe 클래스 구현, pandas .pipe() 메서드 활용, 그리고 파이프 패턴의 적절한 사용 기준을 설명합니다.
toolz와 cytoolz: Python 함수형 프로그래밍 라이브러리
toolz의 itertoolz, functoolz, dicttoolz 모듈 핵심 함수들과 cytoolz 성능 차이, compose/pipe/curry/frequencies 등 실전 활용법을 소개합니다.
커링과 부분 적용: functools.partial 완전 정복
커링과 부분 적용의 차이, functools.partial 사용법, sorted/map/threading/URL 빌더 등 실전 패턴, 그리고 Python에서 직접 커링을 구현하는 방법을 설명합니다.
functools.reduce: 시퀀스를 단일 값으로 접기
functools.reduce의 동작 원리, 초기값 사용법, 딕셔너리 병합과 함수 합성 활용 패턴, 그리고 내장 함수와의 선택 기준을 설명합니다.
순수 함수(Pure Functions): 부작용 없는 함수 설계
순수 함수의 정의, 불순 함수와의 차이, 리팩터링 방법, 테스트 용이성, 메모이제이션, 병렬 처리 안전성을 코드 예제와 함께 설명합니다.
불변성(Immutability): Python에서 변하지 않는 것들
Python의 불변 타입(int, str, tuple 등)과 가변 타입(list, dict 등)의 차이, 인터닝, 해싱, 얕은 불변성 함정과 frozen dataclass 패턴을 설명합니다.
무한 이터레이터: count, cycle, repeat와 islice 활용
itertools의 count(), cycle(), repeat() 무한 이터레이터와 이를 안전하게 제어하는 islice(), takewhile(), next() 패턴을 실전 예제와 함께 설명합니다.
itertools 핵심: chain, product, combinations
Python itertools 모듈의 핵심 함수들 chain, product, permutations, combinations, groupby, takewhile을 실용 예제와 함께 설명합니다.
비동기 제너레이터: async def + yield의 결합
async def에 yield를 결합한 비동기 제너레이터의 동작 원리, 동기 제너레이터와의 차이, 비동기 컴프리헨션, 실전 스트리밍 패턴을 설명합니다.
비동기 이터레이터: __aiter__와 __anext__ 프로토콜
비동기 이터레이터 프로토콜(__aiter__, __anext__), async for 루프 동작 원리, StopAsyncIteration, 실전 구현 예제를 설명합니다.
제너레이터 제어: send(), throw(), close() 완전 정복
제너레이터의 세 가지 제어 메서드 send(), throw(), close()의 동작 원리, 실전 활용 패턴, GeneratorExit 처리 방법을 설명합니다.
제너레이터 기반 코루틴: send()와 초기 코루틴 패턴
yield를 이용한 코루틴의 개념, send()로 값을 주입하는 방법, 프라이밍 규칙, 데이터 파이프라인 패턴을 설명합니다.
yield from: 서브제너레이터 위임과 투명한 전달
yield from의 동작 원리, 서브제너레이터 위임, send/throw/close 투명 전달, return 값 수집 패턴을 실습 코드와 함께 설명합니다.
제너레이터 함수: yield로 만드는 지연 이터레이터
yield 키워드로 제너레이터 함수를 만드는 방법, 실행 흐름의 일시 정지와 재개, 지연 평가의 장점을 실용 예제와 함께 설명합니다.
iter()와 next() 내장 함수 심층 탐구
iter()의 두 가지 형태(이터러블 변환, 센티넬 패턴)와 next()의 기본값 형태를 실무 예제와 함께 완전히 이해합니다.
Python 이터레이터 프로토콜: __iter__와 __next__ 완전 이해
이터러블과 이터레이터의 차이, __iter__/__next__ 메서드, for 루프 동작 원리, 사용자 정의 이터레이터 구현을 설명합니다.
예외 처리 모범 사례와 안티패턴
Python 예외 처리에서 흔히 저지르는 안티패턴과 올바른 대안을 코드로 비교합니다. 예외를 언제 써야 하는지, 어떻게 설계해야 하는지, 프로덕션에서 예외를 어떻게 다뤄야 하는지를 정리합니다.
traceback 모듈로 예외 정보 완전 제어하기
Python traceback 모듈의 주요 함수를 설명합니다. print_exc, format_exc, walk_tb의 사용법, 트레이스백 구조 분석, 로깅과의 통합, 예외 정보를 커스텀 형식으로 출력하는 방법을 다룹니다.
warnings 모듈: 경고를 오류처럼 다루기
Python warnings 모듈의 동작 원리와 사용법을 설명합니다. 경고 카테고리, filterwarnings로 경고를 오류로 전환하는 방법, 테스트에서 경고를 검증하는 방법까지 완전히 다룹니다.
예외 그룹과 except*: Python 3.11의 새 문법
Python 3.11에서 추가된 ExceptionGroup과 except* 문법을 설명합니다. 비동기 작업의 여러 예외를 동시에 처리해야 할 때 어떻게 ExceptionGroup을 사용하는지, asyncio.TaskGroup과 함께 쓰는 방법도 다룹니다.
예외 연결: __cause__와 __context__
Python 예외 연결의 내부 메커니즘을 설명합니다. __cause__와 __context__의 차이, raise from의 동작 원리, suppress_context로 원인 숨기기, 예외 체인 순회까지 완전히 다룹니다.
커스텀 예외 클래스 설계하기
Python에서 커스텀 예외 클래스를 만드는 방법을 설명합니다. 앱 루트 예외 설계, 계층 구조 만들기, 컨텍스트 속성 추가, __str__ 오버라이드까지 실무에서 바로 쓸 수 있는 패턴을 정리합니다.
Python 예외 계층 구조 완전 탐구
Python 내장 예외 클래스의 전체 계층 구조를 살펴봅니다. BaseException에서 시작해 Exception, ArithmeticError, LookupError 등 주요 그룹과 자주 만나는 내장 예외를 완전히 정리합니다.
raise와 raise from: 예외 재발생과 원인 연결
Python에서 raise와 raise ... from ...의 차이를 설명합니다. 예외 연결의 의미, __cause__와 __context__의 차이, raise ... from None으로 원인을 숨기는 방법까지 완전히 다룹니다.
try / except / else / finally 완전 정복
Python try/except/else/finally 네 절의 정확한 역할과 실행 순서를 설명합니다. else와 finally가 없는 코드는 왜 위험한지, 각 절을 어떤 상황에서 써야 하는지를 코드 예시로 완전히 정리합니다.
Python 예외 처리 기초: try, except, 그리고 예외 객체
Python 예외 처리의 핵심 개념을 설명합니다. 예외란 무엇인지, BaseException과 Exception의 차이, try/except의 기본 사용법과 예외 객체에서 정보를 얻는 방법을 배웁니다.
줄 끝 문자: \n·\r\n·\r과 크로스 플랫폼 처리
Python 파일 처리에서 만나는 LF·CRLF·CR 줄 끝 문자의 차이와 Python의 Universal Newlines 처리 방식을 설명합니다. 줄 끝 감지·변환, newline 매개변수, .gitattributes·.editorconfig 설정까지 다룹니다.
mmap: 메모리 맵 파일로 대용량 처리
Python mmap 모듈로 파일을 메모리처럼 직접 접근하는 방법을 설명합니다. OS 페이지 캐시 활용, 복사 없는 읽기·쓰기, 대용량 파일 고속 검색, 정규식 적용, 공유 메모리 패턴까지 다룹니다.
pathlib로 파일 읽고 쓰기: 현대적인 파일 I/O
Python 3.4+의 pathlib.Path를 활용한 파일 읽기·쓰기를 설명합니다. read_text·write_text·read_bytes·write_bytes, / 연산자 경로 조합, glob·rglob, mkdir·unlink·rename, os.path 대비 장점까지 다룹니다.
seek·tell: 파일 포인터로 임의 위치 읽기·쓰기
Python 파일 객체의 seek()와 tell()로 파일 포인터를 제어하는 방법을 설명합니다. whence 매개변수, 텍스트·이진 모드에서의 제약, 파일 크기 확인, 이진 파일 파싱, r+ 편집 패턴까지 다룹니다.
write·flush·버퍼: 파일 쓰기의 내부 동작
Python f.write()가 호출될 때 데이터가 실제로 디스크에 저장되기까지의 과정을 설명합니다. 버퍼링 레이어, flush()와 close()의 차이, 원자적 파일 쓰기 패턴, print(flush=True)까지 정리합니다.
readline vs readlines: 파일 읽기 방법 완전 비교
Python 파일 읽기 메서드 read·readline·readlines와 for 반복자의 차이를 완전히 비교합니다. 메모리 사용량, 줄 처리 방식, 대용량 파일 스트리밍, 개행 문자 제거 패턴까지 정리합니다.
파일 인코딩: UTF-8부터 EUC-KR까지
Python 파일 입출력에서 발생하는 인코딩 문제를 완전히 정리합니다. UTF-8·EUC-KR·CP949·UTF-8-SIG의 차이, UnicodeDecodeError 원인과 해결, chardet 감지, 인코딩 변환 패턴까지 다룹니다.
텍스트 vs 이진 모드: 개행 문자와 인코딩의 차이
Python 파일 입출력에서 텍스트 모드와 이진 모드의 차이를 정확히 설명합니다. 개행 문자 자동 변환, str vs bytes, newline 매개변수, 이진 파일 손상 방지까지 다룹니다.
with 문과 컨텍스트 매니저: 자원을 안전하게 관리하는 법
Python with 문의 동작 원리(__enter__/__exit__ 프로토콜), 파일·락·DB 연결 등 다양한 자원 관리 패턴, contextlib.contextmanager로 직접 만드는 방법까지 정리합니다.
파일 열기 모드: open() 완전 정리
Python open() 함수의 r·w·a·x·b·+ 모드를 완전히 정리합니다. 각 모드의 동작 차이, 이진 모드, FileNotFoundError·FileExistsError 발생 조건, 실전 패턴까지 다룹니다.
hashlib: 해시 함수와 암호화 기초
Python hashlib 모듈로 SHA-256, Blake2b 등 해시 함수를 사용하는 방법을 정리합니다. update/hexdigest/digest, 알고리즘별 특성 비교, 파일 체크섬, HMAC, hashlib.scrypt, 비밀번호 저장 주의사항까지 다룹니다.
uuid: 유일 식별자 생성
Python uuid 모듈의 UUID 버전별 특성과 사용법을 정리합니다. uuid1/uuid3/uuid4/uuid5의 차이, UUID 객체 속성(hex/bytes/int), 이름 기반 UUID, 데이터베이스 기본 키 패턴, 보안 고려사항을 다룹니다.
sqlite3: 내장 관계형 데이터베이스
Python sqlite3 모듈 사용법을 정리합니다. Connection과 Cursor, execute/executemany, row_factory, 트랜잭션 관리, SQL 인젝션 방지, 메모리 DB 활용, 커스텀 타입 어댑터까지 다룹니다.
pickle: Python 객체 직렬화
Python pickle 모듈의 사용법과 주의사항을 정리합니다. dumps/loads/dump/load, protocol 버전, 직렬화 가능·불가능 타입, __reduce__와 __getstate__/__setstate__ 커스터마이징, 보안 취약점, 대안 라이브러리를 다룹니다.
csv 모듈: CSV 파일 읽기와 쓰기
Python csv 모듈 사용법을 정리합니다. reader/writer와 DictReader/DictWriter 차이, delimiter/quotechar/dialect 옵션, newline='' 주의사항, StringIO 활용, 한글 인코딩 처리, 대용량 파일 처리 전략을 다룹니다.
json 모듈: JSON 직렬화와 역직렬화
Python json 모듈의 핵심 사용법을 정리합니다. dumps/loads/dump/load, indent와 ensure_ascii, 타입 매핑, 커스텀 JSONEncoder와 default 함수, 큰 JSON 파일 스트리밍, 보안 주의사항까지 다룹니다.
operator 모듈: 연산을 함수로 다루기
Python operator 모듈의 핵심 기능을 설명합니다. add/sub/mul 등 산술 함수, itemgetter/attrgetter/methodcaller, 비교 함수, reduce와 조합, lambda 대체 패턴까지 실전 예제와 함께 정리합니다.
functools.partial: 인자를 고정한 함수 만들기
Python functools.partial의 동작 원리와 활용 패턴을 설명합니다. 위치·키워드 인자 고정, partial 객체 내부 구조(func/args/keywords), lambda와의 차이, 콜백 등록, map/filter 조합, partialmethod까지 다룹니다.
functools.lru_cache: 메모이제이션 캐싱
Python functools.lru_cache와 cache 데코레이터를 설명합니다. LRU 캐싱 원리, maxsize 설정, cache_info/cache_clear, hashable 제약, 재귀 함수 최적화, 메서드에 사용할 때의 주의사항을 다룹니다.
itertools 기초: 조합형 이터레이터 완벽 활용
Python itertools 모듈의 핵심 함수를 정리합니다. count, cycle, repeat, chain, islice, takewhile, dropwhile, groupby, combinations, permutations, product, accumulate, starmap 등 이터레이터 조합 도구의 원리와 실전 활용 패턴을 다룹니다.
time 모듈 vs datetime: 언제 무엇을 쓸까
Python time 모듈과 datetime 모듈의 차이를 설명합니다. time.time(), time.sleep(), time.perf_counter(), time.monotonic() 등 time 모듈의 핵심 함수와 datetime과의 역할 구분을 다룹니다.
zoneinfo로 타임존 다루기
Python 3.9+ zoneinfo 모듈로 타임존을 처리하는 방법을 설명합니다. ZoneInfo, astimezone, DST 자동 처리, naive vs aware 변환, 고정 오프셋과의 차이를 다룹니다.
datetime 기초: 날짜와 시간 다루기
Python datetime 모듈의 핵심 타입과 사용법을 설명합니다. date, time, datetime, timedelta, strftime, strptime, ISO 8601 변환, naive vs aware datetime을 다룹니다.
tempfile: 임시 파일과 디렉토리 안전하게 다루기
Python tempfile 모듈로 임시 파일과 디렉토리를 안전하게 생성하고 자동 정리하는 방법을 설명합니다. NamedTemporaryFile, TemporaryDirectory, SpooledTemporaryFile, mkstemp 등을 다룹니다.
glob과 fnmatch: 파일 패턴 매칭
Python glob과 fnmatch 모듈의 패턴 매칭 기능을 설명합니다. *, ?, [], ** 와일드카드 패턴, iglob, fnmatch.filter, fnmatch.translate 등 실무 활용법을 다룹니다.
subprocess: 외부 프로세스 실행하기
Python subprocess 모듈로 외부 명령어를 실행하는 방법을 설명합니다. subprocess.run(), capture_output, check, Popen, CalledProcessError 등 실무 패턴을 다룹니다.
shutil: 고수준 파일 복사·이동·압축
Python shutil 모듈로 파일과 디렉토리를 다루는 법을 설명합니다. copy, copy2, copytree, move, rmtree, make_archive, disk_usage 등 실무 패턴을 정리합니다.
sys 모듈: Python 인터프리터와 직접 대화하기
Python sys 모듈의 핵심 기능을 설명합니다. sys.argv, sys.path, sys.exit, sys.stdin/stdout/stderr, sys.version_info 등 실무에서 자주 쓰는 속성과 함수를 다룹니다.
pathlib으로 경로 다루기: 객체지향 파일시스템 API
Python 3.4+ pathlib 모듈의 Path 객체 사용법을 정리합니다. / 연산자, glob, rglob, read_text, write_text, mkdir 등 실무에서 자주 쓰는 패턴을 다룹니다.
os 모듈 완전 정복: 파일·디렉토리·환경변수 다루기
Python os 모듈로 운영체제와 상호작용하는 법을 설명합니다. getcwd, makedirs, walk, environ, os.path 등 핵심 함수와 실무 패턴을 다룹니다.
이름 맹글링과 private 네임: _, __ 접두사 완전 정리
Python 이름 맹글링(__name → _ClassName__name), 단일 언더스코어 관례, 던더 메서드(__name__), 임시 변수(_) 등 네이밍 규약을 설명합니다.
조건부 임포트: 선택적 의존성과 폴백 처리
Python 조건부 임포트 패턴(try/except ImportError, find_spec, TYPE_CHECKING), 플랫폼·버전별 임포트 분기, 선택적 의존성 설계 방법을 설명합니다.
모듈 캐싱과 sys.modules: 한 번만 로드되는 이유
Python sys.modules 캐시 동작 원리, importlib.reload() 한계와 올바른 사용법, __pycache__ 바이트코드 캐시 구조를 설명합니다.
if __name__ == "__main__" 이디엄 완전 정복
Python __name__ 변수의 의미, if __name__ == '__main__' 가드의 동작 원리, __main__.py를 활용한 패키지 진입점 설계를 설명합니다.
importlib로 동적 임포트: 런타임 모듈 로딩
importlib.import_module(), importlib.util.find_spec(), importlib.reload()를 활용한 동적 임포트, 플러그인 로더 구현, 선택적 의존성 처리 패턴을 설명합니다.
순환 임포트: 원인, 동작 원리, 해결 패턴
Python 순환 임포트(circular import) 발생 원인, sys.modules 부분 초기화 메커니즘, 함수 내 임포트·TYPE_CHECKING·공통 모듈 분리 등 해결책을 설명합니다.
네임스페이스 패키지: __init__.py 없는 패키지
Python 3.3+ 네임스페이스 패키지(PEP 420) 동작 원리, 일반 패키지와 차이, 플러그인 아키텍처 활용법, __path__ 속성을 설명합니다.
패키지와 __init__.py: 역할과 설계 패턴
Python 패키지 선언 파일 __init__.py의 역할(패키지 인식, API 노출, 초기화), __all__ 활용, lazy import 패턴, 비어 있어도 되는 이유를 설명합니다.
절대 임포트 vs 상대 임포트: 언제 무엇을 써야 하나
Python 절대 임포트와 상대 임포트의 문법 차이, 점(.) 표기 의미, 직접 실행 시 ImportError 원인, PEP 8 권고를 설명합니다.
Python 모듈 검색 경로: sys.path 완전 정복
Python이 import 문 실행 시 모듈을 찾는 순서(sys.modules 캐시 → 내장 → sys.path), PYTHONPATH 환경변수, .pth 파일, site-packages 구조를 설명합니다.
__slots__: 메모리 효율적인 클래스
Python __slots__ 선언 방법, __dict__ 대비 메모리 절감 원리, 속성 접근 성능 향상, 상속 시 주의사항, @dataclass(slots=True)를 설명합니다.
frozen dataclass: 불변 데이터 클래스
Python @dataclass(frozen=True)의 동작 방식, 자동 __hash__ 생성, dict/set 키로의 활용, __post_init__에서의 값 설정, 상속 시 주의사항을 설명합니다.
@dataclass: 보일러플레이트 없는 데이터 클래스
Python @dataclass 데코레이터로 __init__·__repr__·__eq__ 자동 생성, field()로 기본값 팩토리 설정, __post_init__으로 초기화 후 처리하는 방법을 설명합니다.
Protocol: 구조적 서브타이핑
Python typing.Protocol로 구조적 서브타이핑을 구현하는 방법, @runtime_checkable 데코레이터, ABC와의 차이점, 실용적인 Protocol 설계 패턴을 설명합니다.
추상 기반 클래스: ABC와 abstractmethod
Python abc 모듈, ABC 클래스, @abstractmethod·@abstractproperty 사용법, 인터페이스 강제 메커니즘, collections.abc 내장 ABC를 설명합니다.
super(): 협력적 다중 상속의 핵심
Python super() 함수의 동작 원리, MRO 기반 위임 체계, 협력적 다중 상속에서의 올바른 사용법, **kwargs 패턴을 설명합니다.
다중 상속과 MRO: 다이아몬드 문제 해결
Python 다중 상속 문법, C3 선형화 알고리즘, MRO(Method Resolution Order), 다이아몬드 문제 해결 방식을 설명합니다.
단일 상속: 코드 재사용의 기본
Python 단일 상속 문법, 메서드 오버라이드와 super() 기초, isinstance·issubclass 활용법, 상속 설계 지침을 설명합니다.
@classmethod와 @staticmethod: 세 가지 메서드 종류
Python 인스턴스 메서드·클래스 메서드·정적 메서드의 차이점, @classmethod로 팩토리 패턴 구현하기, @staticmethod의 올바른 사용 시점을 설명합니다.
@property 데코레이터: 캡슐화된 속성 접근
Python @property 데코레이터로 getter·setter·deleter를 구현하는 방법, 읽기 전용 속성 패턴, 유효성 검사와 지연 계산(lazy property) 활용법을 설명합니다.
컨텍스트 매니저 프로토콜: __enter__와 __exit__
Python with 문의 동작 원리, __enter__와 __exit__ 구현 방법, 예외 억제와 전파, contextlib.contextmanager 데코레이터 활용법을 설명합니다.
산술 연산 메서드: __add__, __mul__ 외
Python 산술 연산 매직 메서드 종류, 반사 메서드(radd/rmul), 복합 대입 메서드(iadd), sum() 지원을 위한 __radd__ 구현법을 설명합니다.
비교 메서드: __lt__, __le__, __gt__, __ge__
Python 순서 비교 매직 메서드 구현, 반사 호출 원리, functools.total_ordering 활용법, sorted/min/max와의 연동을 설명합니다.
__eq__와 __hash__: 동등성과 해시 계약
Python __eq__와 __hash__의 관계, 동등성 계약, dict 키와 set 원소로 사용하기 위한 올바른 구현 방법을 설명합니다.
__repr__ vs __str__: 객체를 문자열로
Python __repr__과 __str__의 차이, 각각의 사용처, f-string 포맷 지정자, __format__ 구현법을 설명합니다.
매직 메서드(Special Methods) 개요
Python의 __dunder__ 매직 메서드 전체 카테고리, 연산자 오버로딩 원리, Vec2 예제로 보는 산술·비교·표현 메서드 구현 방법을 설명합니다.
__init__ vs __new__: 객체 생성의 두 단계
Python 객체 생성 과정에서 __new__와 __init__의 역할 차이, 호출 순서, 싱글턴 패턴과 불변 타입 서브클래스에서의 활용법을 설명합니다.
self 키워드 완전 이해
Python 메서드의 첫 번째 매개변수 self가 무엇인지, 어떻게 자동 전달되는지, 메서드 체이닝에 활용하는 방법을 설명합니다.
인스턴스 속성 vs 클래스 속성
Python에서 인스턴스 속성과 클래스 속성의 차이, 속성 조회 순서, 가변 클래스 속성 함정, 클래스 속성의 올바른 활용 방법을 설명합니다.
클래스 기초: 사용자 정의 타입 만들기
Python class 키워드로 사용자 정의 타입을 만드는 방법, 클래스 속성과 인스턴스 속성, 메서드 정의, 객체 생성 흐름을 설명합니다.
array 모듈: 타입 고정 배열
Python array 모듈로 타입 고정 배열을 사용하는 방법, 타입코드, 메모리 효율, 바이너리 파일 I/O 패턴을 설명합니다.
bisect: 이진 탐색으로 정렬 유지
Python bisect 모듈로 정렬된 리스트에서 O(log n) 이진 탐색을 수행하고, insort로 정렬을 유지하며 삽입하는 방법을 배웁니다.
heapq: 파이썬 힙과 우선순위 큐
Python heapq 모듈로 최소 힙을 구현하고, 우선순위 큐, nlargest/nsmallest, 최대 힙 패턴까지 완전히 이해합니다.
collections.namedtuple: 이름 있는 튜플
Python collections.namedtuple로 읽기 좋은 불변 데이터 구조를 만드는 방법과 _replace, _asdict, typing.NamedTuple까지 완전 정리합니다.
collections.OrderedDict: 순서 보장 딕셔너리
Python collections.OrderedDict의 순서 기반 동등성, move_to_end, popitem 메서드와 LRU 캐시 구현 패턴을 살펴봅니다.
collections.defaultdict: KeyError 없는 딕셔너리
Python collections.defaultdict로 없는 키에 자동으로 기본값을 생성하는 방법과 그룹화, 빈도 집계, 중첩 딕셔너리 패턴을 정리합니다.
collections.Counter: 빠른 빈도 분석
Python collections.Counter로 요소 빈도를 집계하고, most_common, update, subtract, 산술 연산까지 실전 패턴을 완벽하게 익힙니다.
collections.deque: 양방향 큐의 모든 것
Python collections.deque의 내부 구조, O(1) 양방향 연산, maxlen 슬라이딩 윈도우, BFS 큐 패턴까지 완벽하게 정리합니다.
sorted vs sort: 정렬 함수 완벽 비교
Python의 sorted()와 list.sort()를 비교하고, key 매개변수를 활용한 다양한 정렬 패턴을 배웁니다.
map·filter·reduce 완전 이해
Python의 map(), filter(), reduce() 함수를 원리부터 실전 패턴까지 완전히 이해하고, 리스트 컴프리헨션과의 차이점도 짚어봅니다.
파이썬 zip과 enumerate 완전 활용
파이썬 zip·enumerate의 동작 원리, 지연 평가 특성, zip_longest·언패킹(unzip)·다중 이터러블 조합 패턴, enumerate의 start 파라미터까지 실전 예제로 정리합니다.
파이썬 제너레이터 표현식과 지연 평가
파이썬 제너레이터 표현식의 문법, 리스트 컴프리헨션과의 메모리 차이, 파이프라인 패턴, any/all/sum과의 조합, 한 번만 순회 가능한 특성을 설명합니다.
파이썬 집합 컴프리헨션과 frozenset
파이썬 집합 컴프리헨션의 문법, 중복 제거 동작, 집합 연산(교집합·합집합·차집합), frozenset의 불변성과 해시 가능성을 실전 예제로 설명합니다.
파이썬 딕셔너리 컴프리헨션 — 데이터 변환의 핵심 도구
파이썬 딕셔너리 컴프리헨션의 문법, 키-값 교환·필터링·zip·enumerate 패턴, 중첩 구조, 중복 키 처리까지 실전 예제로 총정리합니다.
파이썬 리스트 컴프리헨션 완전 정복
파이썬 리스트 컴프리헨션의 문법 구조, 필터·중첩·조건 표현식 패턴, 성능 비교, 바다코끼리 연산자 활용까지 실전 예제로 총정리합니다.
순수 함수 vs 부수 효과 — 파이썬에서의 함수형 사고
순수 함수와 부순수 함수의 차이, 참조 투명성과 부수 효과의 의미, 그리고 실전에서 부수 효과를 경계로 격리하는 패턴을 파이썬 예제로 설명합니다.
파이썬 콜 스택과 트레이스백 읽기
파이썬 콜 스택의 동작 원리, 트레이스백 해석 방법, traceback·inspect·sys 모듈로 스택 프레임에 프로그래밍으로 접근하는 방법을 설명합니다.
파이썬 함수 어노테이션 완전 가이드
파이썬 함수 어노테이션의 문법, __annotations__ 딕셔너리, typing 모듈 변천사, Callable·Optional·Union 표기법을 실전 예제와 함께 정리합니다.
파이썬 고차 함수 완전 정복 — map, filter, sorted와 직접 만들기
파이썬의 고차 함수 개념과 map·filter·sorted 내장 함수, 그리고 함수 합성·메모이제이션·파이프라인 같은 직접 만드는 패턴을 예제 중심으로 정리합니다.
파이썬의 일급 함수 — 함수를 값처럼 다루기
파이썬에서 함수가 일급 객체인 이유와 변수 할당·인자 전달·반환값·자료구조 저장 등 실전 활용 패턴을 깊이 있게 설명합니다.
재귀 깊이 제한: sys.setrecursionlimit과 스택 오버플로
Python의 기본 재귀 깊이 제한(1000), RecursionError의 원인, sys.setrecursionlimit 사용법, 깊은 재귀를 반복문으로 안전하게 전환하는 방법을 설명합니다.
클로저: 함수가 환경을 기억하는 방법
Python 클로저의 정의, 자유 변수가 캡처되는 원리, LEGB 스코프 규칙, nonlocal 키워드로 외부 변수를 수정하는 방법, 팩토리 패턴 활용을 설명합니다.
람다 함수: 익명 함수의 용법과 한계
Python lambda 키워드로 만드는 익명 함수의 문법, def와의 차이, sorted/map/filter에서의 활용, 그리고 람다를 피해야 할 상황을 설명합니다.
여러 값 반환하기: 튜플 언패킹과 Python다운 반환
Python에서 여러 값을 반환하는 원리(튜플), 언패킹 패턴, 스타 언패킹, _ 관례, NamedTuple을 이용한 이름 있는 반환값을 설명합니다.
위치 전용 인수: / 슬래시로 인터페이스 강화하기
Python 3.8에서 도입된 / 구분자를 사용해 특정 매개변수를 위치로만 전달하도록 강제하는 방법과, 내부 구현 보호 및 이름 충돌 방지 패턴을 설명합니다.
키워드 전용 인수: * 이후 매개변수 강제하기
Python의 * 구분자를 사용해 특정 매개변수를 반드시 이름으로만 전달하도록 강제하는 방법과, API 안전성을 높이는 실용 패턴을 설명합니다.
*args와 **kwargs: 가변 인수 완전 정리
Python에서 임의 개수의 인수를 받는 *args(튜플)와 **kwargs(딕셔너리)의 동작 원리, 혼합 선언 순서, 호출 시 언패킹까지 예제로 설명합니다.
기본 인수의 함정: 가변 객체를 기본값으로 쓰면 안 되는 이유
리스트나 딕셔너리를 함수 기본값으로 사용하면 호출마다 공유되는 이유와, None 센티널 패턴으로 안전하게 해결하는 방법을 설명합니다.
위치 인수와 키워드 인수: Python 인수 전달 방식의 기본
함수 호출 시 인수를 순서로 전달하는 위치 인수와 이름으로 전달하는 키워드 인수의 차이, 혼합 규칙, 실수 방지법을 설명합니다.
Python 함수 정의: def 키워드로 코드를 묶다
def 키워드 문법, 매개변수, 반환값, 독스트링까지 — Python 함수 정의의 모든 것을 예제 중심으로 설명합니다.
루프 함정: Python 루프에서 흔히 만나는 버그와 해결책
Python 루프의 대표 함정 5가지 — 순회 중 컬렉션 수정, 클로저의 지연 바인딩, range(len) 안티패턴, 루프 내 비싼 연산, 루프 변수 누출 — 원인과 해결책을 정리합니다.
pass 키워드: 아무것도 하지 않는 것의 역할
Python pass 키워드의 문법적 역할, 스텁·마커 클래스·예외 무시 패턴, ... (Ellipsis)와 raise NotImplementedError와의 비교, contextlib.suppress 대안을 정리합니다.
바다코끼리 연산자 :=: 할당 표현식
Python 3.8에서 추가된 walrus 연산자 :=의 동작 원리, while 루프·if 조건·컴프리헨션에서의 활용, 일반 = 할당과의 차이, 과용 금지 원칙을 정리합니다.
조건 표현식: x if 조건 else y 삼항 연산자
Python 조건 표현식(삼항 연산자)의 문법과 평가 순서, if/else 문과의 차이, f-string·람다·컴프리헨션 활용, 중첩 금지 원칙까지 정리합니다.
match 문: Python 3.10 구조적 패턴 매칭
Python 3.10에서 도입된 match/case 구문의 리터럴·캡처·시퀀스·매핑·클래스 패턴, 가드 조건, OR 패턴, if-elif와의 비교까지 정리합니다.
루프의 else: break 없이 완주했을 때만 실행되는 블록
Python for/while else 구문의 정확한 동작 원리, 검색 실패 감지 패턴, 플래그 변수 대체, while else 재시도 패턴, 가독성 트레이드오프를 정리합니다.
break와 continue: 루프 흐름 세밀하게 제어하기
Python break와 continue의 동작 차이, 중첩 루프 탈출 전략(플래그·함수·예외), continue vs 컴프리헨션 비교, 실전 패턴을 정리합니다.
while 루프: 조건 기반 반복과 무한 루프 제어
Python while 루프의 실행 흐름, 무한 루프와 break 패턴, do-while 흉내 내기, for vs while 선택 기준, 무한 루프 방지 전략까지 정리합니다.
for 루프: 반복 가능 객체 순회의 모든 것
Python for 루프의 이터러블/이터레이터 메커니즘, range·enumerate·zip 활용법, 중첩 루프와 언패킹 패턴, 루프 중 수정 금지 함정까지 체계적으로 정리합니다.
if / elif / else: Python 조건문 완전 정복
Python 조건문 if/elif/else의 구조와 실행 흐름, 다양한 조건식 작성법, 중첩 조건문 vs elif 체인 비교, 실전 패턴까지 체계적으로 정리합니다.
해시와 동등성: __hash__와 __eq__의 관계
Python 해시 계약(a==b → hash(a)==hash(b))을 이해하고, __hash__/__eq__ 올바른 구현 방법, dataclass frozen 옵션, 해시 불변성 주의사항을 정리합니다.
동등성 vs 동일성: == 와 is 의 차이
Python에서 == 는 값 비교, is 는 객체 동일성 검사임을 이해하고, id(), 인터닝(작은 정수 캐시·문자열 인터닝), 올바른 사용 규칙을 정리합니다.
참·거짓값(Truthy/Falsy): Python 조건식 완전 이해
Python에서 조건식으로 평가되는 모든 객체의 참·거짓 규칙, bool() 변환, 단락 평가, __bool__/__len__ 커스텀, all/any를 정리합니다.
타입 변환: int, str, float, list 상호 변환
Python의 명시적 타입 변환(int, float, str, list, set, dict, bool)과 암묵적 변환을 이해하고, ValueError/TypeError를 안전하게 처리하는 패턴을 정리합니다.
집합과 frozenset: 중복 없는 컬렉션
Python set의 생성·집합 연산(합·교·차·대칭차)·활용 패턴과, 불변 집합 frozenset을 정리합니다.
딕셔너리 기초: 키-값 매핑의 모든 것
Python dict의 생성·접근·수정·순회 메서드를 정리하고, 컴프리헨션·병합(|)·setdefault·update 패턴까지 다룹니다.
튜플: 불변 시퀀스의 힘과 언패킹 패턴
Python tuple의 생성·불변성·해시 가능성을 이해하고, 언패킹·스왑·namedtuple 활용까지 실전 패턴을 정리합니다.
리스트 기초: Python의 만능 순서형 자료구조
Python list의 생성·접근·슬라이싱·변경 메서드를 정리하고, 정렬(sort/sorted)과 얕은·깊은 복사의 차이까지 다룹니다.
None: Python의 '없음'을 나타내는 단 하나의 값
Python None의 정체(NoneType 싱글턴), 올바른 검사 방법(is/is not), 선택적 인수 기본값 패턴, 그리고 다른 Falsy 값과의 차이를 정리합니다.
bytes와 bytearray: 이진 데이터를 다루는 두 가지 방법
Python의 bytes(불변)와 bytearray(가변) 타입을 비교하고, 인코딩/디코딩, hex 변환, int 변환 등 실전 패턴을 정리합니다.
문자열 메서드: split, join, replace와 친구들
Python 문자열 메서드를 체계적으로 정리합니다. split/join 쌍, 검색·판별, 변환, 공백 처리 메서드와 실전 패턴까지 예제 중심으로 설명합니다.
f-string: 파이썬 문자열 포매팅의 정석
Python f-string의 기본 문법부터 포맷 명세, = 디버깅 출력, 조건식 삽입, 중첩 사용까지 완전히 다룹니다. 구식 % 포매팅 및 .format()과도 비교합니다.
문자열 기초: 생성, 인덱싱, 슬라이싱
Python 문자열의 기본 개념인 리터럴 생성, 인덱싱, 슬라이싱, 연산자 사용법을 설명합니다. 불변성, raw string, 접두사 문자열도 다룹니다.
bool과 Truthiness: 참과 거짓을 판별하는 방법
Python의 bool 타입과 Truthiness(진릿값) 규칙을 설명합니다. Falsy 값 목록, 논리 연산자, 단락 평가, 실전 패턴까지 다룹니다.
숫자 타입: int, float, complex
Python의 세 가지 숫자 타입인 int, float, complex를 설명합니다. 산술 연산자, 부동소수점 정밀도 문제, Decimal 모듈, 진수 리터럴까지 다룹니다.
인코딩과 UTF-8: Python이 텍스트를 다루는 방식
Python의 문자열 인코딩 개념을 설명합니다. 유니코드, UTF-8, encode/decode 메서드, 파일 입출력 시 인코딩 지정, UnicodeDecodeError 해결법을 다룹니다.
셔뱅(Shebang)과 스크립트 실행 권한
Python 스크립트 첫 줄의 셔뱅(#!) 라인이 무엇인지, chmod +x와 함께 스크립트를 직접 실행하는 방법, 가상환경과의 관계를 설명합니다.
모듈과 import: 코드를 나누고 재사용하는 방법
Python 모듈의 개념과 import 문법을 설명합니다. import, from...import, as 별칭 사용법과 직접 모듈을 작성하는 방법까지 다룹니다.
스크립트 vs REPL: Python 실행 방식의 차이
Python을 실행하는 두 가지 방식, 스크립트 파일과 REPL(대화형 셸)의 차이를 비교합니다. 각각 언제 어떻게 사용하는지 예제와 함께 설명합니다.
input()과 print(): 표준 입출력 완전 정리
Python input()과 print() 함수의 모든 매개변수를 다룹니다. sep, end, file, flush 옵션과 타입 변환 패턴을 예제 중심으로 설명합니다.
들여쓰기: Python이 공백을 문법으로 삼은 이유
Python 들여쓰기 규칙을 설명합니다. 왜 공백이 문법인지, 스페이스 vs 탭, 들여쓰기 수준, 자주 발생하는 IndentationError 해결법을 다룹니다.
주석 완전 정복: 좋은 주석과 나쁜 주석
Python 주석의 종류(#, docstring)와 작성 원칙을 설명합니다. WHY를 설명하는 좋은 주석과 코드를 반복하는 나쁜 주석의 차이를 다룹니다.
Hello, World! Python 첫 프로그램 해부하기
Python 첫 프로그램 Hello World를 작성하고 실행하는 방법을 설명합니다. print() 함수의 모든 기능과 스크립트 파일 실행 방법을 다룹니다.
PEP 8 스타일 가이드: 읽기 쉬운 코드의 기준
Python 공식 스타일 가이드 PEP 8의 핵심 규칙을 설명합니다. 들여쓰기, 줄 길이, 이름 규칙, 공백, import 순서와 자동 포매터를 다룹니다.
The Zen of Python: PEP 20이 말하는 아름다운 코드
Python 설계 철학 19가지를 담은 PEP 20을 코드 예시와 함께 설명합니다. 왜 Python다운 코드를 써야 하는지 이해합니다.
pyenv로 Python 버전 마스터하기
pyenv를 사용해 여러 Python 버전을 관리하는 방법을 설명합니다. 설치, 버전 전환, 프로젝트별 버전 고정, 가상환경 연동까지 다룹니다.
CPython과 PyPy: Python 구현체의 세계
CPython이 표준인 이유, PyPy의 JIT 가속 원리, Jython과 IronPython의 용도를 설명합니다. Python 구현체를 선택하는 기준을 알아봅니다.
Python 2 vs 3: 왜 모두가 3으로 넘어왔는가
Python 2와 3의 핵심 차이를 코드로 비교합니다. print, 나누기, 유니코드, range의 변화와 마이그레이션 도구를 설명합니다.
Python의 탄생과 역사: Guido에서 3.12까지
Python이 어떻게 탄생했고 어떤 과정을 거쳐 오늘날의 모습이 되었는지 살펴봅니다. Guido van Rossum, ABC 언어, Python 1~3의 역사.
Python이란 무엇인가? 언어의 본질을 파악하다
Python의 핵심 특징과 강점을 소개합니다. 인터프리터 언어, 동적 타이핑, 범용성, 가독성을 코드와 함께 이해합니다.