Python

탄생과 ABC의 영향

Python은 1980년대 말 네덜란드 암스테르담의 수학·컴퓨터 과학 연구 기관인 CWI에서 귀도 반 로섬이 개발하기 시작했다. 반 로섬은 CWI의 ABC 언어 개발 집단에서 인터프리터 구현과 언어 설계에 참여했으며, 이 과정에서 얻은 경험을 Python의 초기 설계에 반영했다. 들여쓰기로 문장 블록을 구분하는 방식과 목록·문자열·매핑과 같은 고수준 자료형을 언어의 기본 요소로 제공하는 설계는 ABC에서 직접적인 영향을 받았다.^[10]

ABC는 비전문가도 쉽게 사용할 수 있는 대화형 프로그래밍 환경을 목표로 했지만, 운영체제 기능이나 외부 라이브러리와 연동하기 어렵고 언어 구현을 확장하기도 쉽지 않았다. 반 로섬은 ABC의 간결한 문법과 높은 수준의 자료형은 유지하면서도, C로 작성된 모듈을 연결하고 운영체제 기능에 직접 접근할 수 있는 확장 가능한 언어가 필요하다고 판단했다.

당시 반 로섬은 CWI의 Amoeba 분산 운영체제 개발에 참여하고 있었다. Amoeba의 시스템 관리 작업은 C 프로그램으로 작성하기에는 번거로웠고, Bourne shell 스크립트에서는 Amoeba의 시스템 호출 인터페이스를 충분히 이용하기 어려웠다. 이에 따라 그는 ABC와 유사한 간결한 문법을 가지면서 Amoeba의 시스템 호출과 연결할 수 있는 스크립트 언어를 구상했다. 다만 특정 운영체제에만 종속된 언어가 아니라 다른 시스템에서도 사용할 수 있는 범용적이고 확장 가능한 언어로 설계하는 방향을 선택했다.^[11]

예외 처리의 개념과 일부 문법은 Modula-3의 영향을 받았다. 반 로섬은 Amoeba 개발 과정에서 오류 처리가 프로그램 구조에 미치는 중요성을 경험했으며, 오류를 단순한 반환값으로 처리하는 대신 언어 차원에서 예외를 전달하고 처리할 수 있도록 설계했다. 이와 함께 모듈, 함수, 클래스와 내장 자료형을 하나의 대화형 실행 환경에서 사용할 수 있도록 초기 언어 구조를 구성했다.

반 로섬은 1989년 12월 크리스마스 휴가 기간에 Python 인터프리터 구현을 시작했다. 초기 작업은 개인적인 실험 프로젝트에 가까웠지만, 이듬해 Amoeba 개발 과정에서 실제로 사용되기 시작했고 동료들의 피드백을 반영하면서 언어 기능이 확장되었다.^[12]

언어 이름은 뱀에서 직접 유래한 것이 아니라 영국의 코미디 집단 Monty Python과 텔레비전 프로그램 《Monty Python's Flying Circus》에서 따왔다. 반 로섬은 짧고 독특하며 약간은 신비로운 이름을 원했고, 당시 읽고 있던 Monty Python 대본에서 이름을 선택했다.^[13]

최초 공개와 초기 버전

Python은 약 1년 이상의 개발을 거쳐 1991년 2월 유즈넷의 alt.sources 뉴스그룹에 처음 공개되었다. 최초 공개 계열인 Python 0.9.0에는 이미 함수, 예외 처리, 클래스와 상속, 모듈, 문자열, 목록과 사전 등의 핵심 기능이 포함되어 있었다. 이러한 구성은 Python이 처음부터 단순한 명령어 처리기보다는 비교적 완전한 범용 프로그래밍 언어를 지향했음을 보여준다.^[14]

초기 구현은 대부분 C로 작성되었으며, 소스 코드를 중간 형태의 바이트코드로 변환한 뒤 가상 머신에서 실행하는 구조를 사용했다. 이 구현은 이후 CPython으로 불리게 되었고 Python 언어의 기준 구현체로 발전했다. Python은 대화형 인터프리터를 제공하면서도 소스 파일을 모듈 단위로 구성하고, C 확장 모듈을 통해 운영체제와 기존 라이브러리에 접근할 수 있도록 했다.

1994년 1월 26일 Python 1.0이 공개되었다. Python 1.0은 초기 실험 버전에서 발전한 첫 번째 정식 주 버전으로, 함수형 프로그래밍에 활용할 수 있는 lambda, map(), filter(), reduce() 등의 기능을 포함했다.^[15]

초기 Python 공동체는 유즈넷의 comp.lang.python과 전자우편 목록을 중심으로 성장했다. 외부 개발자들이 이식성 개선, 확장 모듈, 문서와 표준 라이브러리에 기여하면서 Python은 CWI 내부 프로젝트에서 공개적인 오픈 소스 언어로 변화했다. 반 로섬은 주요 설계 결정을 담당했지만, 실제 구현과 생태계는 점차 공동체의 기여로 확장되었다.

CNRI 시기와 Python 1.x

1995년 반 로섬은 미국 버지니아주 레스턴의 CNRI로 자리를 옮겼으며, Python 개발도 CNRI에서 계속되었다. CWI에서 마지막으로 공개된 버전은 Python 1.2였고, Python 1.3부터 Python 1.5.2까지는 CNRI에서 개발·배포되었다.^[16]

Python 1.x 시기에는 언어 기능뿐 아니라 모듈과 패키지를 이용해 프로그램을 구성하는 방식이 정착되었다. Python 1.4와 1.5를 거치며 키워드 인자, 이름 맹글링, 정규 표현식 모듈, 패키지 지원과 표준 예외 클래스 등이 도입되거나 정비되었다. 특히 Python 1.5에서는 디렉터리와 __init__.py 파일을 이용하는 패키지 구조가 공식적으로 지원되면서 대규모 라이브러리를 계층적으로 구성할 수 있게 되었다.^[17]

Python 1.5는 1998년 2월 17일 공개되었고, 안정화 버전인 Python 1.5.2는 1999년 4월 30일 공개되었다. Python 1.5.2는 이후 상당 기간 널리 사용되었으며, 2.0으로 넘어가기 전 Python 생태계의 주요 기반 버전이 되었다.^[18]

1990년대 후반에는 Python을 이용한 웹 프로그래밍, 시스템 관리, 그래픽 사용자 인터페이스, 과학 계산과 교육용 소프트웨어가 증가했다. 표준 라이브러리와 외부 모듈의 범위도 확대되었으며, Python 코드를 배포하고 설치하기 위한 Distutils 개발도 진행되었다. 이 시기 Python은 단순한 Amoeba용 도구에서 여러 운영체제에서 사용할 수 있는 독립적인 범용 언어로 자리 잡았다.

BeOpen PythonLabs와 Python 2.0

2000년 5월 반 로섬과 Python 핵심 개발진은 CNRI를 떠나 BeOpen.com으로 이동하고 BeOpen PythonLabs 팀을 구성했다. CNRI에서 진행되었던 개발 결과를 정리하기 위해 Python 1.6이 별도로 준비되었으며, Python 1.6 최종판은 2000년 9월 5일 공개되었다.^[19]

Python 1.6에는 Unicode 지원과 문자열 처리 개선 등 Python 2.0으로 이어지는 기능이 포함되었다. 그러나 CNRI가 적용한 Python 1.6 라이선스에는 다른 자유 소프트웨어 라이선스와 결합할 때 문제가 될 수 있는 조항이 포함되어 있었고, 이후 Python 1.6.1과 후속 라이선스에서 호환성 문제가 조정되었다.

Python 2.0은 2000년 10월 16일 공개되었다. Python 2.0에는 리스트 컴프리헨션, 순환 참조를 처리할 수 있는 가비지 컬렉터, Unicode 지원과 확장된 표준 라이브러리가 포함되었다. 개발 과정에서는 공개 소스 관리와 버그 추적 기반 시설이 도입되었고, 핵심 개발진 외부의 기여를 수용하는 공동 개발 방식이 더욱 강화되었다.^[20][21]

2000년 10월 PythonLabs 팀은 Digital Creations로 이동했다. 이 회사는 이후 Zope Corporation으로 이름을 변경했다. Zope는 Python으로 개발된 초기 웹 애플리케이션 서버 가운데 하나였으며, Python의 웹 개발 생태계가 성장하는 데 중요한 역할을 했다.

Python Software Foundation의 설립

Python 프로젝트가 여러 기관을 거치면서 개발됨에 따라 저작권, 상표, 라이선스와 기반 시설을 장기적으로 관리할 독립 조직의 필요성이 커졌다. 이에 따라 2001년 미국 델라웨어주에 비영리 조직인 Python Software Foundation이 설립되었다.^[22]

Python Software Foundation은 Python 관련 지식 재산을 보유하고 언어와 공동체의 발전을 지원하는 역할을 맡았다. Python 2.1부터 주요 저작권은 PSF가 관리하게 되었으며, Python 배포판은 Python Software Foundation License를 중심으로 배포되었다. PSF는 이후 Python 공식 웹사이트와 개발 기반 시설, 상표, 재정 지원, 공동체 행사와 개발 지원 사업을 관리하게 되었다.^[23]

독립 재단의 설립은 Python이 특정 회사나 연구 기관의 프로젝트에서 벗어나, 공개 공동체가 지속적으로 개발하는 언어로 전환되었음을 의미했다. 기업과 개인 개발자는 서로 다른 조직에 소속된 상태에서도 Python 핵심 개발과 라이브러리 생태계에 참여할 수 있게 되었다.

Python 2 계열의 발전

Python 2 계열은 2000년대 동안 언어와 표준 라이브러리의 기반을 크게 확장했다. Python 2.2에서는 기존의 내장 타입과 사용자가 정의한 클래스를 보다 일관된 객체 모델로 통합하는 작업이 진행되었으며, 새 스타일 클래스와 프로퍼티, 정적 메서드와 클래스 메서드 등이 도입되었다. 이 변화는 Python의 객체 모델을 확장하고 메타프로그래밍 기능을 발전시키는 기반이 되었다.

Python 2.3과 2.4에서는 집합 자료형, 데코레이터, 제너레이터 표현식과 표준 라이브러리 개선이 이어졌다. Python 2.5에서는 with 문과 컨텍스트 관리자, 조건 표현식이 추가되었으며, Python 2.6은 Python 3으로 이전하기 위한 여러 호환 기능을 제공했다.

Python 2.7은 2010년 7월 3일 공개되었고 Python 2 계열의 마지막 기능 버전이 되었다. Python 3으로의 이전에 시간이 필요한 프로젝트를 지원하기 위해 Python 2.7의 유지보수 기간은 당초 계획보다 연장되었다. 공식 지원은 2020년 1월 1일 종료되었으며, 마지막 배포판인 Python 2.7.18은 2020년 4월 20일 공개되었다. Python 2.8은 개발되지 않았다.^[24]

PEP와 언어 개발 절차

Python 공동체가 확대되면서 언어 변경을 공개적으로 제안하고 기록하는 절차도 필요해졌다. 2000년부터 Python Enhancement Proposal, 즉 PEP 제도가 사용되기 시작했다. PEP는 새로운 언어 기능, 표준 라이브러리, 개발 절차, 패키징 표준과 거버넌스 변경을 설명하는 설계 문서이다.^[25]

PEP에는 제안의 배경, 기술적 명세, 호환성, 대안과 결정 결과가 기록된다. 제안이 받아들여지지 않더라도 논의 과정과 거부 이유가 보존되므로, Python의 설계가 어떤 선택을 통해 형성되었는지 추적할 수 있다.

초기에는 반 로섬이 언어 설계의 최종 결정을 내리는 역할을 맡았으며, Python 공동체에서는 그를 BDFL이라는 명칭으로 불렀다. 다만 실제 기능 개발과 검토는 PEP 작성자, 핵심 개발자와 관련 분야의 기여자들이 함께 수행했고, 특정 영역의 결정 권한을 다른 개발자에게 위임하기도 했다.

Python 3의 설계와 공개

Python 2가 장기간 발전하면서 초기 설계와의 호환성을 유지하기 위해 남겨 둔 기능과 일관되지 않은 동작이 누적되었다. 기존 프로그램과의 호환성을 계속 유지한 상태에서는 이러한 문제를 근본적으로 수정하기 어려웠기 때문에, 개발진은 하위 호환성을 일부 포기하고 언어를 정리하는 새 주 버전을 계획했다. 이 프로젝트는 Python 3000 또는 Py3k라고 불렸다.

Python 3의 개발 원칙은 PEP 3000을 비롯한 여러 PEP에 기록되었다. Python 3은 완전히 새로운 언어를 만드는 것보다 Python의 기존 설계를 유지하면서 중복되거나 오래된 기능을 제거하고, 문자열과 반복 처리, 정수 연산, 예외 처리와 표준 라이브러리 구조를 일관되게 만드는 것을 목표로 했다.^[26]

Python 3.0은 2008년 12월 3일 공개되었다. Python 3.0은 Python 역사상 처음으로 의도적으로 이전 주 버전과 완전한 하위 호환성을 제공하지 않은 배포판이었다. print는 문장에서 함수로 변경되었고, 문자열은 기본적으로 Unicode를 표현하도록 정리되었다. 정수 나눗셈과 반복자 동작이 일관되게 변경되었으며, 중복된 구문과 오래된 기능이 제거되고 표준 라이브러리의 여러 모듈이 재구성되었다.^[27][28]

Python 2 코드의 이전을 지원하기 위해 2to3 변환 도구와 Python 2.6·2.7의 호환 기능이 제공되었다. 그러나 문자열과 바이트 처리, 외부 라이브러리, 확장 모듈과 패키징 도구까지 함께 변경해야 했기 때문에 대규모 프로젝트의 이전에는 긴 시간이 필요했다. 그 결과 Python 2와 Python 3은 약 10년 이상 병행 사용되었다.

초기 Python 3 버전은 Python 2 생태계의 라이브러리를 모두 사용할 수 없었기 때문에 채택 속도가 제한적이었다. 이후 주요 웹 프레임워크, 과학 계산 라이브러리, 패키징 도구와 운영체제 배포판이 Python 3을 지원하면서 Python 3이 기본 계열로 자리 잡았다.

현대 Python 3의 발전

Python 3 계열은 초기의 호환성 단절 이후에는 기존 프로그램의 안정성을 중시하면서 점진적으로 발전했다. Python 3.3에서는 venv와 yield from, Python 3.4에서는 asyncio, enum과 pathlib, Python 3.5에서는 타입 힌트와 async·await 문법이 도입되었다. 이 기능들은 각각 개발 환경 격리, 비동기 프로그래밍과 정적 분석 생태계의 기반이 되었다.

Python 3.6에서는 포맷 문자열 리터럴인 f-string과 변수 주석이 추가되었고, Python 3.7에서는 데이터 클래스를 비롯한 기능이 도입되었다. Python 3.8은 대입 표현식과 위치 전용 매개변수를 추가했으며, Python 3.9부터는 PEP 602에 따라 기능 버전을 매년 한 차례 공개하는 주기가 적용되었다.^[29]

Python 3.10은 구조적 패턴 매칭을 도입했고, Python 3.11은 인터프리터 실행 성능과 오류 메시지를 크게 개선했다. Python 3.12 이후에는 인터프리터 내부 구조, 타입 매개변수 문법, 디버깅과 프로파일링, 전역 인터프리터 잠금과 관련된 실행 모델을 개선하는 작업이 계속되었다.

현대 Python 개발에서는 PEP 387의 하위 호환성 정책에 따라 기존 기능을 즉시 제거하기보다 폐기 예정 경고와 전환 기간을 제공하는 방식이 사용된다. Python 3의 초기 전환 과정에서 발생한 생태계 분할을 반복하지 않도록, 호환되지 않는 변경은 명확한 필요성과 이전 경로를 갖추도록 요구된다.^[30]

거버넌스 체계의 변화

귀도 반 로섬은 Python 탄생 이후 오랫동안 언어 설계의 최종 결정권자 역할을 맡았다. 그러나 Python 공동체와 PEP의 규모가 커지면서 한 사람이 모든 주요 설계 논쟁을 최종 조정하는 구조의 부담도 증가했다.

2018년 7월 반 로섬은 BDFL 역할에서 물러났다. 이후 핵심 개발자들은 여러 거버넌스 모델을 PEP로 제안하고 투표를 진행했다. 2018년 12월 핵심 개발자 투표를 통해 PEP 8016의 운영위원회 모델이 채택되었다.^[31]

운영위원회는 핵심 개발자들이 선출하는 5명의 위원으로 구성된다. 위원회는 Python 언어와 CPython의 품질과 안정성을 유지하고, PEP의 승인 절차와 개발 정책을 관리하며, 합의가 이루어지지 않는 사안에 대해 최종 결정을 내릴 수 있다. 다만 가능한 한 직접 권한을 행사하기보다 공개적인 논의와 합의, 다른 담당자에게 위임하는 방식을 우선하도록 설계되었다.

운영위원회 모델의 공식 규칙은 현재 PEP 13에서 관리된다. 새로운 운영위원회는 정기적으로 선출되며, Python의 의사 결정 구조는 한 명의 창시자에게 집중된 형태에서 핵심 개발자 공동체가 대표자를 선출하는 형태로 전환되었다.^[32]

이러한 변화 이후에도 Python은 언어 사양, 기준 구현체, 표준 라이브러리와 패키징 생태계를 서로 연계하여 개발하는 구조를 유지하고 있다. 언어와 CPython의 기술적 결정은 PEP와 핵심 개발 절차를 통해 이루어지며, Python Software Foundation은 지식 재산, 재정, 기반 시설과 국제 공동체를 지원한다.

Python은 프로그램의 동작을 가능한 한 명확하게 드러내면서도, 자주 사용하는 작업을 짧고 읽기 쉬운 코드로 표현하는 것을 중심으로 설계되었다. 언어의 문법과 표준 라이브러리는 서로 다른 기능을 무작정 추가하기보다, 일반적인 문제를 일관된 방식으로 해결하고 코드의 의도를 사람이 쉽게 파악할 수 있도록 구성되는 경향을 가진다.

Python의 설계 철학은 언어의 특정 문법 규칙만을 의미하지 않는다. 들여쓰기 기반 블록 구조, 동적 타입, 객체 중심 데이터 모델, 반복 프로토콜, 예외 처리, 모듈과 패키지 체계, 자동 메모리 관리와 표준 라이브러리가 함께 Python의 프로그래밍 모델을 구성한다. 이 구조는 작은 스크립트를 빠르게 작성하는 용도와 여러 모듈로 이루어진 대규모 프로그램을 개발하는 용도를 모두 지원하도록 발전했다.

가독성과 명시성

Python은 소스 코드가 작성자뿐 아니라 다른 개발자에게도 쉽게 읽혀야 한다는 원칙을 중요하게 여긴다. 이러한 방향은 PEP 20에 수록된 Python의 선에서 “가독성은 중요하다”, “암시적인 것보다 명시적인 것이 낫다”, “복잡한 것보다 단순한 것이 낫다”라는 문장으로 표현된다.^[33]

가독성은 단순히 코드 길이를 줄이는 것과 같지 않다. Python에서는 한 줄로 압축할 수 있더라도 여러 단계의 처리를 지나치게 중첩하거나 부수 효과를 숨기는 표현은 관용적인 코드로 평가되지 않을 수 있다. 반대로 언어가 제공하는 컴프리헨션, 다중 대입, 반복자와 컨텍스트 관리자처럼 의미가 널리 정착된 표현은 코드의 목적을 더 직접적으로 보여줄 수 있다.

Python의 이름 바인딩과 함수 호출 문법도 명시성을 지원한다. 함수 호출에서 키워드 인자를 사용하면 각 값의 역할을 호출 위치에 나타낼 수 있고, 언패킹 문법은 값의 구조를 직접 표현한다. 예외 처리에서는 발생 가능한 오류를 반환값의 특수한 상태로 숨기기보다 예외 객체로 전달하며, 호출자가 필요한 위치에서 이를 명시적으로 처리할 수 있다.

PEP 8은 Python 코드의 공식적인 스타일 지침으로, 코드 배치와 이름 규칙, 들여쓰기와 공백 사용을 정리한다. 그러나 PEP 8은 모든 상황에서 기계적으로 동일한 형식을 강제하기보다 프로젝트와 모듈 내부의 일관성, 기존 코드와의 호환성 및 실제 가독성을 우선하도록 설명한다.^[34]

들여쓰기를 이용한 블록 구조

Python에서는 들여쓰기가 조건문, 반복문, 함수와 클래스 등의 코드 블록을 구분하는 문법 요소로 사용된다. 다른 여러 언어가 중괄호나 begin·end 같은 키워드로 블록 범위를 표시하는 것과 달리, Python은 같은 깊이의 문장을 동일한 블록에 속한 것으로 해석한다.

def classify(value):
    if value > 0:
        return "positive"
    if value < 0:
        return "negative"
    return "zero"

들여쓰기 기반 구조는 프로그램의 시각적인 배치와 구문 구조가 서로 달라지는 상황을 줄인다. 중괄호를 사용하는 언어에서는 들여쓰기가 실제 블록 구조와 달라도 문법적으로 허용될 수 있지만, Python에서는 들여쓰기가 잘못되면 다른 블록으로 해석되거나 구문 오류가 발생한다.

귀도 반 로섬은 들여쓰기를 문법에 포함한 이유로 코드의 수평·수직 공간을 효율적으로 사용하고, 별도의 블록 구분 기호 없이도 프로그램 구조를 명확히 드러낼 수 있다는 점을 들었다. 또한 일반적인 코드가 어차피 들여쓰기를 사용하므로, 이를 문법 구조와 일치시키는 것이 가독성에 도움이 된다고 설명했다.^[35]

들여쓰기의 깊이는 공백의 개수로 결정된다. 언어 자체가 항상 네 칸을 강제하는 것은 아니지만, Python 공동체와 PEP 8에서는 각 단계에 공백 네 칸을 사용하는 방식을 표준적인 스타일로 권장한다.

간결한 문법과 높은 표현력

Python은 자주 사용하는 자료 처리와 제어 흐름을 비교적 적은 문법 요소로 표현할 수 있도록 설계되었다. 목록, 튜플, 사전과 집합은 언어 차원의 리터럴을 제공하며, 다중 대입과 언패킹을 통해 여러 값을 한 번에 분해하거나 교환할 수 있다.

left, right = right, left
name, extension = filename.rsplit(".", 1)

컴프리헨션은 반복과 조건을 이용해 새로운 컬렉션을 생성하는 과정을 하나의 표현식으로 나타낸다. 이는 단순한 변환과 필터링을 반복문보다 직접적으로 표현할 수 있게 한다.

squares = [number * number for number in values if number >= 0]

다만 Python의 간결성은 가능한 모든 처리를 짧은 표현식으로 만드는 것을 목표로 하지 않는다. 지나치게 중첩된 컴프리헨션이나 여러 부수 효과를 한 문장에 결합한 코드는 실행할 수 있더라도 읽기 어려워질 수 있다. Python의 관용적 스타일에서는 코드 길이보다 처리 흐름과 의도가 명확하게 드러나는지가 더 중요하게 취급된다.

Python은 문법 요소를 다른 기능과 결합할 수 있도록 설계한다. 예를 들어 반복 프로토콜을 구현한 객체는 for 문, 컴프리헨션, sum()과 min() 같은 내장 함수, 튜플 언패킹 등에서 공통으로 사용할 수 있다. 개별 기능마다 별도의 반복 방식을 제공하지 않고 하나의 프로토콜을 여러 문법과 라이브러리가 공유하는 구조이다.

실용성을 우선하는 설계

Python은 일관성과 단순성을 중요하게 여기지만, 순수한 이론적 모델보다 실제 프로그램 작성과 기존 코드의 사용성을 함께 고려한다. PEP 20은 이를 “실용성은 순수성보다 우선한다”라는 원칙으로 표현한다.^[36]

이 원칙에 따라 Python에는 서로 다른 프로그래밍 방식에서 유래한 기능이 함께 존재한다. 클래스와 상속을 이용할 수 있지만 모든 코드를 클래스에 넣을 필요는 없으며, 함수형 프로그래밍에서 사용하는 고차 함수와 지연 반복 도구를 제공하면서도 순수 함수형 언어의 제약을 적용하지 않는다. 필요에 따라 상태 변경, 예외, 반복문과 객체를 함께 사용할 수 있다.

언어의 일관성을 높이기 위한 변경도 기존 생태계와의 비용을 함께 고려한다. Python 3에서는 오래된 설계 문제를 정리하기 위해 의도적인 호환성 단절이 이루어졌지만, 현대 Python에서는 기능을 제거하기 전에 폐기 예정 경고와 이전 기간을 제공하는 방식을 주로 사용한다.

Python은 특정 사용 방식만을 절대적인 형태로 강제하지 않는다. 여러 방법이 존재할 수 있지만, 일반적으로 이해하기 쉽고 표준 라이브러리와 잘 결합되는 대표적인 방식이 자연스럽게 선택되도록 언어와 문서, 공동체 관습이 함께 작동한다.

다중 패러다임 지원

Python은 하나의 프로그래밍 패러다임에만 속하지 않는 다중 패러다임 프로그래밍 언어이다. 기본적인 문장과 함수, 가변 상태를 이용하는 명령형·절차형 프로그래밍을 지원하며, 클래스와 객체를 이용한 객체 지향 프로그래밍도 제공한다. 함수가 일급 객체이므로 고차 함수, 클로저와 데코레이터를 비롯한 함수형 프로그래밍 기법도 사용할 수 있다.

def apply(values, operation):
    return [operation(value) for value in values]

result = apply([1, 2, 3], lambda value: value * 2)

Python의 객체 지향 모델은 클래스 상속, 다중 상속, 메서드 오버라이딩과 메타클래스를 지원한다. 그러나 Java처럼 모든 실행 코드를 클래스 안에 배치하도록 요구하지 않으며, 모듈 수준의 함수와 변수도 일반적인 프로그램 구성 요소로 사용한다.

함수형 기능 역시 언어 전체를 순수 함수와 불변 자료구조에 맞추는 형태가 아니다. map(), filter(), functools, itertools와 같은 기능을 제공하지만, 단순한 변환에서는 컴프리헨션이나 일반 반복문이 더 읽기 쉬운 방식으로 사용되기도 한다. 표준 라이브러리의 itertools는 여러 반복자 구성 요소를 조합해 메모리 효율적인 처리 흐름을 구성할 수 있도록 한다.^[37]

Python에서는 문제와 프로그램 규모에 따라 여러 패러다임을 함께 사용할 수 있다. 데이터 모델은 객체 지향적이지만, 실제 프로그램 구조는 모듈과 함수 중심으로 구성할 수 있고, 특정 처리 과정만 반복자나 선언적인 표현으로 구현할 수도 있다.

통일된 객체 모델

Python 프로그램의 모든 데이터는 객체 또는 객체 사이의 관계로 표현된다. 숫자와 문자열, 컬렉션뿐 아니라 함수, 클래스, 모듈과 코드 자체도 객체로 취급된다. 모든 객체는 정체성, 타입과 값을 가지며, 이름은 이러한 객체에 바인딩된다.^[38]

def greet(name):
    return f"Hello, {name}"

handler = greet
message = handler("Python")

함수도 객체이므로 변수에 저장하거나 다른 함수에 인자로 전달하고 반환할 수 있다. 클래스 또한 객체이며, 기본적으로 호출하면 인스턴스를 생성한다. 이러한 구조는 데코레이터, 메타클래스와 런타임 코드 생성 같은 기능의 기반이 된다.

Python의 언어 연산은 객체 모델에 정의된 특수 메서드를 통해 확장된다. 예를 들어 + 연산은 객체의 __add__() 계열 메서드와 연결되고, len()은 __len__(), 반복은 __iter__()와 __next__(), with 문은 컨텍스트 관리자 프로토콜과 연결된다.

이 구조를 통해 사용자가 정의한 객체도 내장 자료형과 동일한 문법 구조에 참여할 수 있다. 특정 클래스가 반복 프로토콜을 구현하면 for 문에서 사용할 수 있고, 컨텍스트 관리자 프로토콜을 구현하면 with 문에서 사용할 수 있다. Python에서는 이런 동작을 흔히 데이터 모델 또는 Python 프로토콜의 구현으로 설명한다.

동적 타입과 이름 바인딩

Python은 객체가 타입을 가지고 이름은 객체를 참조하는 동적 타입 언어이다. 변수 선언 시 고정된 타입을 지정할 필요가 없으며, 같은 이름이 실행 과정에서 서로 다른 타입의 객체에 다시 바인딩될 수 있다.

value = 10
value = "ten"

이 구조에서 타입 검사는 주로 연산이 실행되는 시점에 이루어진다. 객체가 요청된 연산을 지원하면 구체적인 클래스 계층과 관계없이 사용할 수 있으며, 이러한 작성 방식을 덕 타이핑이라고 부른다.

def write_message(stream, message):
    stream.write(message)

write_message()는 stream이 반드시 특정 클래스의 인스턴스인지 먼저 확인하지 않는다. 대신 실행 시점에 write() 메서드를 제공하는 객체라면 파일, 메모리 버퍼나 사용자 정의 객체를 사용할 수 있다.

Python의 동적 타입 체계는 타입 정보가 존재하지 않는다는 뜻이 아니다. 모든 객체에는 런타임 타입이 있으며, type()과 isinstance() 같은 기능으로 이를 검사할 수 있다. 또한 타입 힌트를 통해 함수 인자와 반환값, 변수와 클래스 속성의 예상 타입을 기록할 수 있다. 타입 힌트는 기본적으로 런타임의 이름 바인딩 방식을 바꾸지 않으며, 정적 분석기와 개발 도구가 프로그램을 검사할 수 있도록 추가 정보를 제공한다.

자동 메모리 관리

Python은 객체의 메모리 할당과 해제를 실행 환경에서 자동으로 관리한다. 개발자는 일반적인 Python 코드에서 객체를 직접 해제하지 않으며, 더 이상 도달할 수 없는 객체는 구현체의 메모리 관리 체계에 따라 회수된다.

기준 구현체인 CPython은 주로 참조 횟수를 이용해 객체 수명을 관리하고, 서로를 참조하는 객체 집합처럼 참조 횟수만으로 정리할 수 없는 순환 참조를 별도의 가비지 컬렉터로 처리한다. 다만 참조 횟수의 구체적인 사용 방식과 객체가 제거되는 정확한 시점은 Python 언어 자체보다 구현체의 특성에 해당한다.

Python의 메모리 관리자는 Python 객체와 내부 자료구조가 저장되는 전용 힙을 관리한다. 이 과정에는 객체 할당, 재사용, 캐싱과 가비지 컬렉션을 비롯한 여러 구성 요소가 관여한다.^[39]

자동 메모리 관리는 일반 객체의 수명을 단순화하지만, 파일과 네트워크 연결, 잠금처럼 사용 후 즉시 반환해야 하는 외부 자원까지 가비지 컬렉션에 의존하는 방식은 권장되지 않는다. 이러한 자원은 with 문과 컨텍스트 관리자를 사용해 블록 종료 시 정리 작업이 실행되도록 구성한다.

예외 중심의 오류 처리

Python은 실행 과정의 비정상 상태를 예외 객체로 표현한다. 함수가 모든 실패를 별도의 오류 코드로 반환하는 대신, 정상적인 반환 흐름과 오류 전달 흐름을 분리할 수 있다.

try:
    value = int(text)
except ValueError:
    value = 0

예외가 현재 실행 위치에서 처리되지 않으면 호출 스택의 상위 영역으로 전파된다. 호출자는 처리할 수 있는 예외만 선택적으로 잡을 수 있고, 나머지는 더 높은 수준의 코드로 전달할 수 있다.

Python에서는 객체가 필요한 동작을 지원한다고 예상하고 먼저 연산을 수행한 뒤, 실패할 경우 예외를 처리하는 방식이 자주 사용된다. 이는 사전에 가능한 모든 조건과 타입을 확인하는 방식보다 실제 동작을 직접 요청한다는 점에서 동적 타입과 덕 타이핑에 잘 맞는다.

그러나 예외를 일반적인 분기 처리의 대체물로 무조건 사용하는 것은 아니다. 실패가 예외적인 상황인지, 조건 확인이 더 읽기 쉬운지, 연산과 검사 사이에 상태가 바뀔 가능성이 있는지를 고려해 구조를 선택한다.

반복자와 프로토콜 중심 설계

Python의 여러 기능은 특정 상위 클래스의 상속보다 객체가 제공하는 동작의 집합인 프로토콜을 중심으로 구성된다. 반복 가능한 객체는 반복자 프로토콜을 구현하며, for 문과 컴프리헨션, tuple()과 sum()을 비롯한 여러 내장 기능에서 공통으로 사용된다.

for item in collection:
    process(item)

for 문은 컬렉션의 내부 저장 구조를 직접 알 필요 없이 반복 프로토콜을 통해 값을 차례로 얻는다. 사용자 정의 클래스도 같은 프로토콜을 구현하면 내장 컬렉션처럼 반복할 수 있다.

컨텍스트 관리자, 비동기 반복자, 숫자 연산, 길이 조회, 포함 관계 검사와 속성 접근도 각각의 프로토콜을 통해 확장된다. 이러한 방식은 내장 문법을 특정 클래스에 고정하지 않고, 필요한 동작을 제공하는 다양한 객체가 참여하도록 만든다.

프로토콜 중심 설계는 덕 타이핑과 연결된다. 객체의 명목상 타입보다 실제로 지원하는 연산이 중요하며, 서로 상속 관계가 없는 클래스도 같은 프로토콜을 구현하면 동일한 코드에서 사용할 수 있다.

모듈성과 점진적인 확장

Python 프로그램은 모듈과 패키지를 기본 단위로 구성된다. 작은 프로그램은 하나의 소스 파일에서 시작할 수 있고, 규모가 커지면 기능을 여러 모듈과 패키지로 분리할 수 있다. Python 소스 파일 자체가 모듈로 사용되므로 작은 스크립트와 재사용 가능한 라이브러리 사이의 구조적 차이가 크지 않다.

모듈은 각자의 전역 이름 공간을 가지며, import 문을 통해 다른 모듈이 공개한 객체를 사용할 수 있다. 패키지는 관련 모듈을 계층적으로 묶어 이름 충돌을 줄이고 프로그램 구조를 표현한다.

Python은 대화형 인터프리터, 스크립트 실행, 모듈 가져오기와 애플리케이션 구성을 같은 언어와 객체 모델 위에서 지원한다. 대화형 환경에서 시험한 함수나 표현을 소스 파일로 옮기고, 이후 패키지의 일부로 확장하는 점진적인 개발 흐름을 사용할 수 있다.

확장성은 다른 언어와의 연동에도 적용된다. Python 모듈은 Python 자체로 작성할 수 있을 뿐 아니라 C API와 외부 함수 인터페이스, 별도의 바인딩 도구를 통해 C, C++, Rust와 다른 언어로 구현된 라이브러리를 연결할 수 있다. 이를 통해 상위 수준의 제어와 조합은 Python으로 작성하고, 성능이나 시스템 접근이 중요한 부분은 다른 언어로 구현하는 구조를 만들 수 있다.

배터리 포함 표준 라이브러리

Python은 언어와 함께 광범위한 표준 라이브러리를 제공하는 배터리 포함 철학을 따른다. 표준 라이브러리에는 파일과 디렉터리 처리, 자료구조, 날짜와 시간, 정규 표현식, 데이터 직렬화, 압축, 네트워크 프로토콜, 동시성, 테스트와 디버깅을 비롯한 기능이 포함된다.^[40]

표준 라이브러리의 목적은 모든 분야의 기능을 자체적으로 포함하는 것이 아니라, 일반적인 프로그램 작성에 필요한 기반 기능을 별도의 외부 의존성 없이 사용할 수 있게 하는 것이다. 운영체제 인터페이스, 파일 경로 처리, JSON과 CSV, HTTP 클라이언트, SQLite 데이터베이스, 단위 테스트와 로깅 같은 기능을 Python 설치 환경에서 바로 사용할 수 있다.

from pathlib import Path
import json

config = json.loads(Path("config.json").read_text(encoding="utf-8"))

Python 언어 참조는 문법과 실행 의미를 정의하고, 표준 라이브러리는 실제 프로그램을 구성하는 공통 기능을 제공한다. 이 둘은 구분되지만 함께 Python의 기본 개발 환경을 형성한다.^[41]

표준 라이브러리는 안정성과 호환성을 중요하게 관리하지만, 모든 모듈을 영구적으로 유지하지는 않는다. 사용이 중단되었거나 현대 환경에 맞지 않는 기능은 폐기 절차를 거쳐 제거될 수 있으며, 전문 분야나 빠르게 변화하는 기능은 PyPI의 외부 패키지 생태계에서 발전한다.

하나의 명확한 방법

Python의 선에는 문제를 해결하는 “하나의 명확한 방법”이 존재하는 것이 바람직하다는 원칙이 포함된다. 이는 모든 문제에 단 하나의 문법만 허용한다는 의미가 아니라, 비슷한 목적의 기능이 불필요하게 중복되어 사용자가 여러 방식 사이에서 혼란을 겪는 상황을 줄이려는 방향을 뜻한다.

Python은 반복, 자원 관리, 문자열 포매팅과 파일 경로 처리처럼 반복적으로 등장하는 문제에 대해 표준적이고 널리 이해되는 방식을 발전시켜 왔다. 예를 들어 반복 가능한 객체는 for 문과 반복자 프로토콜을 사용하고, 자원 정리는 with 문, 문자열 내부 값 삽입은 현대 코드에서 주로 f-string을 사용한다.

그러나 언어가 오랜 기간 발전하면서 같은 목적을 가진 과거 방식과 새로운 방식이 함께 남기도 한다. 기존 프로그램과의 호환성을 유지해야 하므로 오래된 기능이 즉시 제거되지 않으며, 새로운 방식이 충분히 정착한 뒤 폐기 절차를 거쳐 정리될 수 있다.

따라서 하나의 명확한 방법이라는 철학은 문법적 제한이라기보다 표준 라이브러리, 문서와 공동체 관습을 통해 대표적인 해결 방식을 형성하는 설계 방향에 가깝다.

Pythonic 코드와 관용적 표현

Pythonic은 Python의 언어 기능과 관습을 자연스럽게 활용하여 작성된 코드를 가리키는 표현이다. 단순히 Python 문법으로 실행되는 코드가 아니라, 언어의 반복 모델, 객체 모델, 표준 라이브러리와 일반적인 스타일을 활용해 의도를 직접적으로 나타내는 코드에 사용된다.

예를 들어 인덱스를 직접 증가시키면서 컬렉션에 접근하는 대신 객체를 직접 반복하고, 인덱스가 필요하면 enumerate()를 사용한다.

for index, item in enumerate(items):
    print(index, item)

두 컬렉션을 같은 위치끼리 처리할 때는 직접 인덱스를 관리하기보다 zip()을 사용할 수 있다.

for name, score in zip(names, scores):
    print(name, score)

파일과 같은 자원은 수동으로 열고 모든 제어 흐름에서 닫기보다 컨텍스트 관리자를 이용한다.

with open("data.txt", encoding="utf-8") as file:
    contents = file.read()

Pythonic 코드가 항상 가장 짧거나 가장 빠른 코드를 의미하는 것은 아니다. 언어와 표준 라이브러리가 제공하는 공통 표현을 사용해 다른 Python 개발자가 동작을 쉽게 이해하고, 예외 처리와 자원 수명 같은 경계 조건까지 자연스럽게 다룰 수 있는 코드에 가깝다.

관용적인 표현은 고정된 규칙이 아니라 Python의 발전에 따라 달라질 수 있다. 과거에 일반적이었던 작성 방식이 새로운 문법이나 라이브러리 기능의 도입으로 대체될 수 있으며, 대상 Python 버전과 프로젝트의 호환성 정책에 따라 적절한 방식도 달라진다.

접근성과 전문성의 결합

Python은 간결한 문법과 대화형 실행 환경 덕분에 프로그래밍 입문에 널리 사용된다. 변수 선언과 프로그램 진입점을 위한 복잡한 상용구가 적고, 문자열과 컬렉션을 초기 단계부터 직접 다룰 수 있어 작은 프로그램을 빠르게 실행할 수 있다. Python 공식 사이트도 깨끗한 문법과 들여쓰기 구조가 초보자의 학습을 돕는 특성으로 설명한다.^[42]

name = input("Name: ")
print(f"Hello, {name}")

동시에 Python은 디스크립터, 메타클래스, 비동기 프로그래밍, 네이티브 확장, 메모리 뷰와 사용자 정의 가져오기 시스템처럼 복잡한 소프트웨어를 구성하는 기능도 제공한다. 초보자가 언어 전체를 먼저 익히지 않아도 기본 문법으로 프로그램을 시작할 수 있고, 필요한 시점에 더 깊은 기능을 단계적으로 사용할 수 있다.

이러한 점진적 복잡성은 Python 생태계의 주요 특징이다. 간단한 자동화 스크립트와 교육용 프로그램, 대규모 웹 서비스, 데이터 처리 시스템과 과학 계산 도구가 같은 언어를 사용하지만, 각 분야에서 요구하는 언어 기능과 라이브러리의 깊이는 서로 다르다.

Python의 접근성은 내부 구조가 단순하다는 뜻은 아니다. 언어 참조의 객체 모델, 디스크립터와 메서드 결정 순서, 가져오기 시스템과 비동기 실행 의미는 상당히 정교하다. Python은 이러한 복잡성을 일상적인 프로그램 작성에서 필요한 만큼만 드러내는 방향으로 설계되었다.

Python 프로그램은 문자로 작성된 소스 코드를 토큰으로 나누는 어휘 분석, 토큰의 배열을 문법 구조로 해석하는 구문 분석과 각 문장 및 표현식을 실행하는 과정으로 처리된다. Python 언어 참조는 구문과 핵심 실행 의미를 정의하며, 실제 프로그램은 표현식, 단순문, 복합문, 함수와 클래스 정의 및 모듈 구조의 조합으로 구성된다.^[43]

Python의 구문은 불필요한 구분 기호를 줄이고 줄바꿈과 들여쓰기로 프로그램 구조를 드러내도록 설계되었다. 일반적으로 하나의 논리적 줄에는 하나의 단순문을 작성하며, 콜론으로 시작한 복합문의 본문은 한 단계 깊은 들여쓰기로 나타낸다.

temperature = 22

if temperature >= 20:
    message = "warm"
else:
    message = "cold"

print(message)

여기서 대입과 함수 호출은 단순문이고, if와 else로 구성된 조건문은 내부에 다른 문장을 포함하는 복합문이다. 들여쓰기된 두 대입문은 각각 해당 조건 절의 본문에 속한다.

소스 코드와 문자 인코딩

Python 3 소스 코드는 Unicode 문자로 해석되며, 소스 파일의 기본 인코딩은 UTF-8이다. 다른 인코딩을 사용할 때는 파일의 첫째 줄이나 둘째 줄에 인코딩 선언을 작성할 수 있다.^[44]

# -*- coding: utf-8 -*-

message = "안녕하세요"

현대 Python 프로젝트에서는 대부분 UTF-8을 그대로 사용하므로 별도의 인코딩 선언이 필요하지 않다. UTF-8이 아닌 인코딩을 선언하려면 Python이 인식할 수 있는 코덱 이름을 사용해야 하며, 선언된 방식으로 파일을 디코딩할 수 없으면 SyntaxError가 발생한다.

소스 코드의 줄 끝은 운영체제에 따라 LF, CRLF 또는 CR 형식일 수 있지만, Python은 이를 논리적인 줄 종료로 정규화한다. 문자열 리터럴 안에 포함된 줄바꿈은 문자열 표기 규칙에 따라 별도로 처리된다.

실행 파일로 직접 사용하는 스크립트에서는 첫 줄에 운영체제가 해석할 shebang을 둘 수 있다.

#!/usr/bin/env python3

print("Hello")

shebang은 Python 언어 문법 자체가 아니라 유닉스 계열 운영체제가 실행할 인터프리터를 선택하는 방식이다. Python에서는 # 뒤의 내용이 주석이므로 첫 줄 전체가 일반 주석으로 처리된다.

물리적 줄과 논리적 줄

소스 파일에 실제로 존재하는 각각의 줄을 물리적 줄이라고 한다. Python 파서는 하나 이상의 물리적 줄을 결합하여 하나의 논리적 줄로 처리할 수 있다.

괄호, 대괄호 또는 중괄호 안에서는 줄을 명시적인 연결 문자 없이 나눌 수 있다.

result = calculate_total(
    base_price,
    shipping_cost,
    discount,
)

컬렉션 리터럴과 컴프리헨션에서도 같은 방식으로 줄을 나눌 수 있다.

permissions = {
    "read",
    "write",
    "execute",
}

괄호 안의 암시적 줄 연결은 문자열이나 함수 호출, 복잡한 표현식을 여러 줄로 배치할 때 일반적으로 사용된다. 마지막 항목 뒤에 쉼표를 남겨 두면 항목을 추가하거나 순서를 변경할 때 수정 범위를 줄일 수 있다.

백슬래시를 물리적 줄 끝에 작성하여 다음 줄과 명시적으로 연결할 수도 있다.

total = first_value + second_value + \
    third_value

그러나 백슬래시 뒤에는 주석이나 다른 문자를 둘 수 없고, 코드 수정 과정에서 쉽게 깨질 수 있으므로 가능한 경우 괄호를 이용한 암시적 연결이 선호된다.

일반적인 단순문은 논리적 줄의 끝에서 종료된다. 세미콜론을 사용하면 하나의 논리적 줄에 여러 단순문을 작성할 수 있다.

left = 10; right = 20

이 형식은 문법적으로 허용되지만, 각 문장을 별도의 줄에 작성하는 방식이 일반적으로 더 읽기 쉽다. 복합문의 본문을 세미콜론으로 연결한 한 줄 형태도 일부 구문에서 가능하지만, 여러 단계의 실행 구조를 나타낼 때는 들여쓰기된 블록을 사용하는 것이 보통이다.

들여쓰기와 코드 블록

Python의 들여쓰기는 단순한 서식이 아니라 토큰으로 처리되는 문법 요소이다. 어휘 분석기는 논리적 줄의 시작 부분에 있는 공백 깊이를 비교하여 INDENT와 DEDENT 토큰을 생성하고, 파서는 이를 이용해 문장 블록의 시작과 끝을 판단한다.^[45]

if authenticated:
    load_profile()
    show_dashboard()

write_log()

load_profile()과 show_dashboard()는 같은 깊이로 들여쓰기되어 if 문의 본문에 속한다. write_log()는 들여쓰기가 원래 수준으로 돌아왔으므로 조건문 밖에서 실행된다.

한 블록 안에서는 같은 들여쓰기 깊이를 일관되게 사용해야 한다. 탭과 공백을 혼합하여 들여쓰기의 의미가 모호해지면 TabError가 발생할 수 있다. PEP 8에서는 각 들여쓰기 단계에 공백 네 칸을 사용하는 방식을 권장한다.^[46]

복합문은 일반적으로 머리 부분의 끝에 콜론을 작성하고, 다음 줄부터 들여쓰기된 suite를 배치한다. suite는 하나 이상의 문장으로 이루어진 블록을 뜻한다.

while queue:
    item = queue.pop()
    process(item)

아직 구현하지 않은 빈 블록이 필요하면 아무 동작도 하지 않는 pass 문을 사용할 수 있다.

class PendingImplementation:
    pass

주석과 문서 문자열

#부터 물리적 줄 끝까지의 내용은 주석으로 처리된다. 문자열 리터럴 내부의 #은 주석을 시작하지 않는다.

timeout = 30  # 초 단위 제한 시간
pattern = "#[0-9a-fA-F]{6}"

주석은 프로그램 실행에 직접 참여하지 않으며, 코드의 목적이나 구현상의 이유를 설명하는 데 사용된다. 코드가 무엇을 하는지 그대로 반복하기보다 해당 선택의 배경과 주의할 조건을 기록하는 방식이 유용하다.

모듈, 함수, 클래스 또는 메서드 본문의 첫 번째 문장이 문자열 리터럴이면 해당 문자열은 문서 문자열로 취급된다. 문서 문자열은 객체의 __doc__ 속성을 통해 조회할 수 있으며, help()와 문서 생성 도구가 이를 활용한다.^[47]

def normalize_name(name):
    """이름의 앞뒤 공백을 제거하고 소문자로 변환한다."""
    return name.strip().lower()

문서 문자열은 주석과 달리 런타임 객체에 연결될 수 있는 문자열이다. 여러 줄의 설명이 필요할 때는 삼중 따옴표 문자열을 주로 사용한다.

def connect(address, timeout=30):
    """
    지정한 주소에 연결한다.

    연결에 성공하면 세션 객체를 반환한다.
    """
    ...

식별자와 키워드

식별자는 변수, 함수, 클래스, 모듈과 속성 등에 이름을 부여하는 데 사용된다. Python 식별자는 Unicode 문자를 지원하며, 첫 글자에는 문자 또는 밑줄을 사용할 수 있고 이후에는 문자, 숫자와 밑줄을 사용할 수 있다.^[48]

사용자_이름 = "Luna"
version_3 = "3.14"
_internal_value = 10

식별자는 대소문자를 구분하므로 value, Value와 VALUE는 서로 다른 이름이다. 다만 패키지와 외부 도구의 호환성, 협업과 검색 편의를 위해 소스 코드의 공개 식별자에는 일반적으로 ASCII 기반 영어 이름을 사용한다.

if, for, class, return과 같은 예약 키워드는 일반 식별자로 사용할 수 없다. 현재 실행 환경의 키워드는 keyword 표준 라이브러리 모듈을 통해 확인할 수 있다.

import keyword

print(keyword.kwlist)

Python에는 항상 키워드로 취급되는 일반 키워드 외에 특정 문법 위치에서만 특별한 의미를 가지는 소프트 키워드도 있다. 예를 들어 match와 case는 구조적 패턴 매칭 구문 안에서는 문법 요소이지만, 다른 위치에서는 일반 이름으로 사용할 수 있다.

match = "exact"
case = 10

밑줄로 시작하고 끝나는 이름은 Python 내부 프로토콜이나 특별한 의미에 사용되는 경우가 많다. __init__, __iter__, __name__ 같은 이름은 언어와 표준 라이브러리가 정의한 특수 이름이다. 사용자가 임의의 새로운 이중 밑줄 이름 체계를 만드는 것보다 이미 정의된 의미에 맞춰 사용하는 방식이 권장된다.

리터럴

리터럴은 소스 코드에서 상수 값을 직접 나타내는 표기이다. Python의 어휘 문법은 문자열, 바이트열과 숫자 리터럴을 정의하며, None, True, False와 ...도 고정된 값을 나타낸다.^[49]

정수는 10진수 외에 2진수, 8진수와 16진수로 작성할 수 있다.

decimal = 255
binary = 0b11111111
octal = 0o377
hexadecimal = 0xff

숫자 사이의 밑줄은 값을 바꾸지 않으면서 자릿수를 구분하는 데 사용할 수 있다.

population = 51_000_000
mask = 0b1111_0000

부동소수점 수는 소수점이나 지수 표기를 사용할 수 있다.

ratio = 0.125
distance = 1.5e6

복소수 리터럴은 허수부에 j 또는 J를 붙여 표현한다.

position = 3 + 4j

문자열은 작은따옴표나 큰따옴표로 작성할 수 있으며, 삼중 따옴표를 사용하면 여러 물리적 줄에 걸친 문자열을 만들 수 있다.

single = 'Python'
double = "Python"
multiline = """첫 번째 줄
두 번째 줄"""

문자열 접두사로 원시 문자열, 바이트 문자열과 포맷 문자열 등을 표현한다.

path_pattern = r"C:\Users\name"
payload = b"\x50\x79"
name = "Python"
message = f"Language: {name}"

원시 문자열은 대부분의 역슬래시 이스케이프를 문자 그대로 유지하지만, 문자열을 닫는 따옴표와 마지막 역슬래시에는 여전히 문법적 제약이 있다. 바이트 문자열은 Unicode 문자열이 아니라 정수 바이트의 배열을 나타낸다.

목록, 튜플, 사전과 집합은 엄밀히는 어휘 단계의 단일 토큰이 아니라 여러 구문 요소로 만들어지는 표시 표현이다. 그러나 소스 코드에서 값을 직접 구성한다는 점에서 일반적으로 컬렉션 리터럴이라고 부른다.

numbers = [1, 2, 3]
point = (10, 20)
options = {"debug": True, "port": 8080}
permissions = {"read", "write"}

빈 중괄호 {}는 빈 사전을 만들며, 빈 집합은 set()으로 생성한다.

표현식

표현식은 평가되어 값을 만드는 구문이다. 리터럴, 이름 참조, 속성 접근, 인덱싱, 함수 호출과 연산자 적용은 모두 표현식에 해당한다.^[50]

value
user.name
items[index]
calculate_total(price, tax)
left + right

여러 표현식은 연산자와 호출 문법을 통해 더 큰 표현식으로 결합할 수 있다.

total = sum(item.price * item.quantity for item in order.items)

이 표현식에는 속성 접근, 곱셈, 생성기 표현식과 함수 호출이 함께 사용된다. 각 하위 표현식은 정해진 평가 순서와 연산자 우선순위에 따라 처리된다.

Python에서는 모든 언어 구성 요소가 표현식인 것은 아니다. while, for, try, 함수와 클래스 정의는 값을 만드는 표현식이 아니라 문장이다. 일반 대입 역시 문장으로 분류되므로 다른 표현식 내부에 직접 넣을 수 없다.

result = value = calculate()

위 코드는 연쇄 대입문이며 value = calculate() 전체가 값을 반환하는 표현식으로 포함된 것이 아니다. 별도의 대입 표현식인 :=는 제한된 위치에서 값을 이름에 바인딩하면서 해당 값을 표현식의 결과로 사용할 수 있다.

while chunk := stream.read(4096):
    process(chunk)

대입 표현식은 반복 조건이나 컴프리헨션에서 계산 결과를 재사용할 때 유용하지만, 바인딩과 다른 연산을 지나치게 결합하면 흐름을 읽기 어려워질 수 있다.

이름·속성·구독과 슬라이싱

이름 표현식은 현재 실행 범위에서 이름에 바인딩된 객체를 조회한다.

count
process
Configuration

속성 참조는 점 문법으로 객체의 속성을 조회한다.

user.name
document.title
service.start

속성 조회는 객체의 타입과 데이터 모델에 따라 __getattribute__(), 디스크립터와 __getattr__() 등의 동작에 연결될 수 있다. 따라서 점 문법은 단순한 구조체 필드 접근뿐 아니라 계산된 프로퍼티와 동적으로 제공되는 속성에도 사용된다.

대괄호를 이용한 구독은 컬렉션이나 사용자 정의 객체에서 항목을 조회한다.

items[0]
settings["theme"]
matrix[row, column]

정수 인덱스와 문자열 키뿐 아니라 객체가 지원하는 다양한 키를 전달할 수 있다. 구독 연산은 객체의 __getitem__() 프로토콜과 연결된다.

슬라이스는 시작, 끝과 간격을 이용해 범위의 일부를 지정한다.

values[1:5]
values[:3]
values[::2]
values[::-1]

시작 위치는 포함되고 끝 위치는 포함되지 않는다. 시퀀스 객체는 슬라이스를 받아 새로운 시퀀스를 반환하거나, 사용자 정의 의미로 해석할 수 있다.

연산자와 평가 순서

Python은 산술, 비교, 논리, 비트와 포함 관계 연산자를 제공한다. 연산자는 정해진 우선순위에 따라 결합되며, 괄호로 평가 순서를 명확하게 지정할 수 있다.

result = base + width * height
explicit = (base + width) * height

거듭제곱은 **, 나눗셈은 /, 내림 나눗셈은 //, 나머지는 %로 표현한다.

power = 2 ** 10
ratio = 7 / 2
quotient = 7 // 2
remainder = 7 % 2

/는 피연산자가 정수여도 일반적으로 부동소수점 결과를 반환한다. //는 결과를 음의 무한대 방향으로 내림하므로 음수에서는 단순히 소수 부분을 버리는 것과 결과가 다를 수 있다.

비교 연산은 연속해서 작성할 수 있다.

if 0 <= index < len(items):
    process(items[index])

이 표현식은 0 <= index와 index < len(items)를 논리적으로 결합하지만, 가운데의 index는 한 번만 평가된다.

and와 or는 피연산자를 반드시 불리언으로 변환해 반환하지 않고, 평가를 결정한 원래 객체를 반환한다.

display_name = nickname or username

nickname이 참으로 평가되면 그 객체가 반환되고, 거짓이면 username이 평가되어 반환된다. and와 or는 필요한 피연산자만 평가하는 단락 평가를 수행한다.

객체의 동일성을 비교할 때는 is와 is not을 사용하며, 값의 동등성을 비교할 때는 ==와 !=을 사용한다.

if result is None:
    handle_missing()

if current_value == expected_value:
    handle_match()

in과 not in은 컨테이너에 값이 포함되어 있는지 검사한다.

if "admin" in roles:
    grant_access()

함수 호출과 인자 전달

함수 호출은 호출 가능한 객체 뒤에 괄호를 붙여 표현한다. 괄호 안에는 위치 인자, 키워드 인자와 언패킹된 인자를 전달할 수 있다.

connect("localhost", 8080)
connect(host="localhost", port=8080)

위치 인자는 작성된 순서대로 매개변수에 대응하고, 키워드 인자는 매개변수 이름을 지정한다. 일반적으로 위치 인자를 키워드 인자보다 앞에 작성해야 한다.

반복 가능한 객체 앞에 *를 붙이면 위치 인자로 펼칠 수 있고, 매핑 앞에 **를 붙이면 키워드 인자로 펼칠 수 있다.

arguments = ["localhost", 8080]
options = {"timeout": 30, "secure": True}

connect(*arguments, **options)

함수 호출식은 함수가 반환한 객체를 값으로 가진다. 함수가 명시적으로 값을 반환하지 않으면 None을 반환한다.

호출 대상은 일반 함수에 한정되지 않는다. 클래스, 인스턴스 또는 __call__() 프로토콜을 구현한 객체도 호출할 수 있다.

parser = Parser()
result = parser(source)

단순문

단순문은 하나의 논리적 줄 안에서 구성되는 문장이다. 표현식문, 대입문, assert, pass, del, return, yield, raise, break, continue, import, global, nonlocal과 타입 별칭문 등이 단순문에 포함된다.^[51]

표현식을 하나의 문장으로 작성하면 표현식문이 된다.

print("Hello")
service.start()

스크립트 실행에서는 평가 결과가 자동으로 표시되지 않지만, 대화형 인터프리터에서는 None이 아닌 표현식문의 결과가 화면에 표시될 수 있다.

대입문은 표현식의 결과를 하나 이상의 대상에 바인딩한다.

count = 10
left = right = 0
x, y = point

연쇄 대입에서는 오른쪽 표현식을 한 번 평가한 뒤 여러 대상에 같은 객체를 바인딩한다. 언패킹 대입에서는 오른쪽 반복 가능 객체의 요소를 왼쪽 대상 구조에 맞춰 분배한다.

first, *middle, last = values

증강 대입은 기존 값에 연산한 결과를 다시 대상에 저장한다.

count += 1
items *= 2

객체와 연산에 따라 증강 대입은 기존 객체를 제자리에서 변경하거나 새로운 객체를 만들어 다시 바인딩할 수 있다.

return은 함수 실행을 종료하고 호출자에게 값을 돌려준다.

def add(left, right):
    return left + right

raise는 예외를 발생시키며, break는 가장 가까운 반복문을 종료하고 continue는 다음 반복으로 이동한다.

for item in items:
    if item is None:
        continue
    if item == stop_marker:
        break
    process(item)

global과 nonlocal은 함수 안의 이름 바인딩이 어느 범위의 이름을 대상으로 하는지 지정한다. 이들은 실행 중 동적으로 범위를 변경하는 함수가 아니라, 해당 코드 블록의 이름 해석에 영향을 주는 선언이다.

대입 대상과 언패킹

Python 대입문의 왼쪽에는 단순한 이름뿐 아니라 속성, 구독, 슬라이스와 중첩된 대상 목록을 사용할 수 있다.

user.name = "Luna"
settings["theme"] = "dark"
items[1:3] = replacements

이름 대입은 현재 이름 공간의 바인딩을 변경한다. 속성 대입은 객체의 속성 설정 프로토콜을 호출하며, 구독과 슬라이스 대입은 대상 객체의 항목 변경 프로토콜을 사용한다. 따라서 문법이 비슷해도 실제 동작은 대상 종류에 따라 다르다.

시퀀스 언패킹은 오른쪽의 반복 가능한 객체에서 값을 얻어 왼쪽의 대상에 배치한다.

width, height = dimensions
red, green, blue = color

별표 대상은 남은 여러 값을 목록으로 수집한다.

head, *body, tail = values

중첩된 구조도 사용할 수 있다.

name, (x, y) = record

왼쪽 구조와 오른쪽에서 제공되는 값의 개수가 맞지 않으면 ValueError가 발생한다. 별표 대상은 하나의 대입 대상 목록에 하나만 둘 수 있다.

조건문

if 문은 조건의 참과 거짓에 따라 실행할 블록을 선택한다. 첫 조건이 거짓이면 elif 절을 순서대로 검사하고, 모두 거짓이면 선택적인 else 절을 실행한다.^[52]

if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
else:
    grade = "F"

조건에는 불리언 객체뿐 아니라 참·거짓으로 평가할 수 있는 모든 객체를 사용할 수 있다. None, False, 수치형의 0과 비어 있는 문자열 및 컬렉션은 일반적으로 거짓으로 평가된다. 그 밖의 대부분 객체는 참으로 평가되지만, 사용자 정의 클래스는 __bool__() 또는 __len__()을 통해 동작을 정의할 수 있다.

간단한 값 선택은 조건 표현식으로 작성할 수 있다.

status = "adult" if age >= 18 else "minor"

조건 표현식은 값을 만드는 표현식이므로 함수 인자나 대입문의 오른쪽에 포함할 수 있다. 여러 조건을 중첩하면 읽기 어려워질 수 있으므로 복잡한 분기에는 일반 if 문이 더 적합하다.

반복문

while 문은 조건이 참으로 평가되는 동안 본문을 반복한다.

while retries > 0:
    if connect():
        break
    retries -= 1

for 문은 반복 가능한 객체에서 요소를 순서대로 얻어 대상에 바인딩하고 본문을 실행한다.

for item in items:
    process(item)

반복 대상은 목록이나 튜플에 한정되지 않으며, 반복자 프로토콜을 제공하는 모든 객체를 사용할 수 있다. 문자열, 파일, 사전, 제너레이터와 사용자 정의 객체도 for 문의 대상이 될 수 있다.

대상 위치에 언패킹 구조를 사용할 수 있다.

for name, score in results:
    print(name, score)

range()는 일정한 정수 범위를 반복할 때 자주 사용된다.

for index in range(10):
    print(index)

Python의 while과 for 문에는 선택적인 else 절을 붙일 수 있다. 반복문이 break 없이 정상적으로 끝났을 때 else 절이 실행된다.

for item in items:
    if item.id == target_id:
        found = item
        break
else:
    found = None

for 문의 else는 반복이 한 번도 실행되지 않았을 때만 사용하는 구조가 아니라, 반복이 고갈될 때까지 완료되었는지를 나타낸다. 예외나 return으로 반복문을 벗어난 경우에도 실행되지 않는다.

구조적 패턴 매칭

match 문은 하나의 주제 값을 여러 패턴과 순서대로 비교하고, 처음 성공한 case 블록을 실행한다. Python 3.10에서 도입되었으며 단순한 값 비교뿐 아니라 시퀀스, 매핑과 객체의 구조를 분해할 수 있다.^[53]

match command:
    case "start":
        start_service()
    case "stop":
        stop_service()
    case _:
        report_unknown_command()

_는 일반적으로 어떤 값과도 일치하면서 값을 이름에 저장하지 않는 와일드카드 패턴으로 사용된다.

시퀀스 패턴은 값의 구조를 검사하고 동시에 요소를 이름에 바인딩할 수 있다.

match point:
    case (0, 0):
        location = "origin"
    case (x, 0):
        location = f"x-axis at {x}"
    case (0, y):
        location = f"y-axis at {y}"
    case (x, y):
        location = f"point at {x}, {y}"

매핑 패턴은 필요한 키가 존재하는지 검사하고 대응하는 값을 추출한다.

match message:
    case {"type": "text", "content": content}:
        handle_text(content)
    case {"type": "image", "url": url}:
        handle_image(url)

클래스 패턴은 객체의 타입과 지정한 속성 구조를 함께 검사할 수 있다.

match event:
    case MouseEvent(x=x, y=y, button="left"):
        handle_left_click(x, y)
    case KeyEvent(key="Escape"):
        close_window()

case 뒤에 if 가드를 추가하면 패턴이 일치한 뒤 추가 조건을 검사한다.

match value:
    case number if number < 0:
        category = "negative"
    case number if number > 0:
        category = "positive"
    case _:
        category = "zero"

패턴 안의 이름은 기존 변수의 값을 비교하는 것이 아니라, 대부분 새 값을 캡처하는 대상으로 동작한다. 특정 상수와 비교하려면 리터럴 패턴이나 점으로 한정된 값 패턴을 사용한다. 이러한 차이 때문에 match 문은 단순히 여러 if 문을 짧게 표현하는 구문이 아니라 데이터 구조를 검사하고 분해하는 독립적인 기능이다.^[54]

컴프리헨션

컴프리헨션은 반복 가능한 객체를 변환하거나 필터링하여 새로운 컬렉션을 만드는 표현식이다. 목록, 집합과 사전 컴프리헨션을 제공한다.

squares = [number ** 2 for number in values]
unique_names = {name.lower() for name in names}
name_lengths = {name: len(name) for name in names}

하나 이상의 for 절과 if 절을 조합할 수 있다.

coordinates = [
    (x, y)
    for x in range(width)
    for y in range(height)
    if is_available(x, y)
]

절의 실행 순서는 일반 반복문으로 작성했을 때의 왼쪽에서 오른쪽 순서와 대응한다.

coordinates = []

for x in range(width):
    for y in range(height):
        if is_available(x, y):
            coordinates.append((x, y))

목록 컴프리헨션은 결과 목록 전체를 즉시 생성한다. 대괄호 대신 괄호를 사용한 생성기 표현식은 값을 요청받을 때마다 계산하는 반복자를 만든다.

total = sum(number ** 2 for number in values)

생성기 표현식은 전체 중간 목록이 필요하지 않은 합산이나 검색, 큰 입력 처리에서 메모리 사용을 줄일 수 있다. 반대로 결과를 여러 번 순회하거나 인덱스로 접근해야 한다면 목록과 같은 구체적인 컬렉션이 적합할 수 있다.^[55]

컴프리헨션은 단순한 변환과 필터링을 직접 표현하는 데 유용하지만, 여러 단계의 조건과 부수 효과가 결합되면 일반 반복문보다 이해하기 어려워질 수 있다. 외부 상태를 변경하는 작업보다 새로운 값을 구성하는 작업에 주로 사용한다.

예외 처리 구문

try 문은 실행 중 발생한 예외를 처리하거나, 실행 결과와 관계없이 정리 작업을 수행하는 복합문이다.

try:
    value = int(text)
except ValueError:
    value = 0

except 절은 지정한 예외 타입과 일치하는 예외를 처리한다. 일치하는 처리기가 없으면 예외는 바깥쪽 실행 문맥으로 계속 전달된다.^[56]

여러 예외를 각각 처리할 수 있다.

try:
    response = request(url)
except TimeoutError:
    retry_later()
except ConnectionError as error:
    report_connection_failure(error)

else 절은 try 본문에서 예외가 발생하지 않았을 때 실행되며, finally 절은 정상 종료, 예외, return, break와 관계없이 정리 단계에서 실행된다.

resource = acquire()

try:
    use(resource)
finally:
    release(resource)

except에서 예외를 잡은 뒤 원래 예외를 다시 발생시키려면 인자 없는 raise를 사용할 수 있다. 다른 예외를 원인으로 연결하려면 raise ... from ... 구문을 사용한다.

try:
    config = parse_config(source)
except ValueError as error:
    raise ConfigurationError("설정을 해석할 수 없다") from error

with 문과 자원 범위

with 문은 컨텍스트 관리자를 사용해 블록 진입과 종료 처리를 구조화한다. 파일, 잠금, 데이터베이스 트랜잭션과 임시 상태처럼 사용 전후에 정해진 처리가 필요한 객체에 사용한다.

with open("data.txt", encoding="utf-8") as file:
    contents = file.read()

컨텍스트 관리자의 __enter__() 동작은 블록 진입 시 실행되고, __exit__() 동작은 블록에서 빠져나올 때 실행된다. 종료 처리는 정상 실행뿐 아니라 예외가 발생하거나 return으로 벗어나는 경우에도 수행된다.^[57]

여러 컨텍스트 관리자를 하나의 with 문에서 사용할 수 있다.

with (
    open("source.txt", encoding="utf-8") as source,
    open("target.txt", "w", encoding="utf-8") as target,
):
    target.write(source.read())

with 문은 단순히 try와 finally를 짧게 쓰는 구문을 넘어, 자원의 획득과 반환 규칙을 객체 자체에 캡슐화하는 구조를 제공한다.

함수와 클래스 정의

함수 정의와 클래스 정의는 실행 가능한 복합문이다. 인터프리터가 def 문을 실행하면 함수 객체를 만들고 지정한 이름에 바인딩한다.

def calculate_area(width, height):
    return width * height

함수 본문은 정의 시점에 즉시 실행되지 않으며, 함수가 호출될 때 새로운 실행 프레임에서 실행된다. 기본 인자 표현식은 함수가 호출될 때마다가 아니라 def 문이 실행되는 시점에 평가된다.

def append_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

클래스 정의문이 실행되면 새로운 이름 공간에서 클래스 본문을 실행한 뒤, 그 결과를 바탕으로 클래스 객체를 생성한다.

class Rectangle:
    unit = "px"

    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

클래스 본문에는 메서드 정의뿐 아니라 일반 대입, 조건문과 함수 호출도 작성할 수 있다. 클래스 본문에서 만들어진 이름은 클래스의 속성 이름 공간을 구성한다.

함수와 클래스 정의 앞에는 데코레이터를 둘 수 있다.

@register_handler("message")
def handle_message(message):
    process(message)

데코레이터 표현식은 정의 시점에 평가되며, 생성된 함수나 클래스 객체를 받아 다른 객체로 변환하거나 등록할 수 있다.

모듈과 최상위 코드

Python 소스 파일은 일반적으로 하나의 모듈로 실행된다. 모듈의 최상위 문장은 파일의 처음부터 순서대로 실행되며, 그 과정에서 생성된 이름은 모듈의 전역 이름 공간에 저장된다.

DEFAULT_PORT = 8080

def start_server(port=DEFAULT_PORT):
    ...

print("module loaded")

이 모듈을 가져오면 함수 정의뿐 아니라 최상위의 print() 호출도 실행된다. 라이브러리 모듈에서는 가져오기만 해도 불필요한 작업이나 사용자 상호작용이 발생하지 않도록 최상위 실행 코드를 제한하는 것이 일반적이다.

모듈이 스크립트로 직접 실행되면 __name__에 "__main__"이 바인딩된다. 다른 모듈에서 가져오면 __name__에는 모듈의 정규 이름이 들어간다.

def main():
    start_application()

if __name__ == "__main__":
    main()

이 구조를 사용하면 함수와 클래스는 다른 모듈에서 재사용하면서, 파일을 직접 실행할 때만 프로그램 진입 코드를 수행할 수 있다.

Python 인터프리터는 파일뿐 아니라 표준 입력, -c로 전달된 문자열, 대화형 입력과 가져온 모듈 등 여러 형태로 최상위 코드를 받을 수 있다.^[58]

프로그램의 실행 순서

모듈의 최상위 코드는 기본적으로 위에서 아래로 실행된다. 함수와 클래스 정의문도 이 순서에서 객체를 생성하고 이름에 바인딩하는 실행 문장이다.

print("before")

def greet():
    print("inside")

print("after")
greet()

이 프로그램은 "before", "after", "inside" 순서로 출력한다. 함수 본문은 def가 처리될 때 실행되지 않고 실제 호출 시 실행되기 때문이다.

조건문과 반복문, 예외 처리, 함수 호출은 이 기본 순서를 변경한다. return, break, continue, raise는 현재 실행 중인 흐름을 다른 위치로 이동시키며, 제너레이터의 yield와 코루틴의 await는 실행을 일시 중단했다가 이후 이어서 실행할 수 있게 한다.

이름은 사용되기 전에 해당 실행 경로에서 바인딩되어 있어야 한다. 소스 파일의 아래쪽에 정의된 함수라도 현재 함수가 실제로 호출되기 전에 정의문이 실행되었다면 사용할 수 있다.

def main():
    helper()

def helper():
    print("helper")

main()

반면 정의가 실행되기 전에 호출하면 이름을 찾을 수 없다.

main()

def main():
    print("main")

Python의 프로그램 구조는 선언만을 모아 먼저 처리하는 방식보다, 모듈 자체를 하나의 실행 가능한 코드 블록으로 취급하는 방식에 가깝다. 이 특성은 조건부 정의, 동적 등록과 모듈 초기화를 가능하게 하지만, 가져오기 시 발생하는 부수 효과와 이름의 정의 순서를 함께 고려해야 한다.

문법과 객체 모델의 연결

Python의 문법 요소는 내부적으로 객체가 제공하는 프로토콜과 연결되는 경우가 많다. for 문은 반복자 프로토콜, with 문은 컨텍스트 관리자 프로토콜, 연산자는 수치 및 비교 특수 메서드, 구독은 항목 접근 프로토콜을 사용한다.

for item in container:
    process(item)

위 구문은 개념적으로 container에서 반복자를 얻고, 반복자의 다음 값을 요청하는 과정으로 이루어진다.

iterator = iter(container)

while True:
    try:
        item = next(iterator)
    except StopIteration:
        break
    process(item)

실제 언어 구현은 이를 그대로 소스 코드로 변환하지 않지만, 두 구조는 반복자 프로토콜이라는 동일한 실행 모델을 공유한다.

마찬가지로 다음 연산은 객체의 특수 메서드에 연결된다.

result = left + right
length = len(container)
value = container[key]

각각 __add__() 계열 연산, __len__()과 __getitem__() 프로토콜이 관여한다. 이로 인해 사용자 정의 클래스도 Python의 내장 문법에 자연스럽게 참여할 수 있다.

Python 문법은 단순한 표기법과 객체 모델이 분리되어 있는 것이 아니라, 문장과 표현식이 객체의 공통 프로토콜을 호출하도록 구성되어 있다. 이 관계는 내장 자료형과 사용자 정의 객체가 같은 제어문, 연산자와 함수에 사용될 수 있게 하는 기반이다.

Python에서 객체는 데이터를 표현하는 기본 단위이다. 숫자와 문자열, 컬렉션뿐 아니라 함수, 클래스, 모듈, 코드와 실행 프레임도 객체로 표현된다. 프로그램의 상태는 객체와 객체 사이의 관계, 그리고 이름이 객체에 바인딩된 구조로 구성된다.^[59]

객체가 어떤 연산을 지원하는지는 객체의 타입과 데이터 모델에 의해 결정된다. +와 같은 연산자, for 반복, 함수 호출, 속성 접근, 구독, 문자열 변환과 with 문은 각각 객체가 제공하는 특수 메서드 및 프로토콜에 연결된다. 사용자 정의 클래스도 이러한 프로토콜을 구현하면 내장 객체와 같은 문법에 참여할 수 있다.

class Counter:
    def __init__(self, limit):
        self.limit = limit

    def __iter__(self):
        return iter(range(self.limit))


for number in Counter(3):
    print(number)

Counter는 목록이나 튜플이 아니지만 __iter__()를 구현하므로 반복 가능한 객체로 동작한다. Python의 데이터 모델은 특정 내장 클래스만 문법에 사용할 수 있도록 고정하기보다, 객체가 필요한 동작을 제공하는지를 중심으로 구성된다.

객체의 정체성·타입·값

모든 Python 객체는 정체성, 타입과 값을 가진다. 이 세 요소는 객체를 설명하는 기본 속성이다.^[60]

객체의 정체성은 다른 객체와 구별되는 고유한 특성이다. 객체가 생성된 뒤에는 정체성이 바뀌지 않으며, is 연산자는 두 표현식이 같은 객체를 가리키는지 비교한다. id()는 객체의 정체성을 나타내는 정수를 반환한다.

first = []
second = []
alias = first

print(first is second)
print(first is alias)

first와 second는 내용이 같은 빈 목록이지만 별도로 생성된 객체이므로 first is second는 거짓이다. alias는 first와 같은 객체에 바인딩되므로 first is alias는 참이다.

CPython에서는 현재 id()가 객체가 저장된 메모리 주소와 연결되지만, 이는 CPython의 구현 세부 사항이다. Python 언어는 id()가 객체의 수명 동안 고유하고 변하지 않는 정체성 값을 제공한다는 점만 보장한다.

객체의 타입은 객체가 가질 수 있는 값의 범위와 지원하는 연산을 결정한다. type()은 객체의 타입 객체를 반환한다.

value = 42

print(type(value))
print(isinstance(value, int))

객체의 타입 역시 객체 생성 후에는 일반적으로 바뀌지 않는다. 이름이 다른 타입의 객체에 다시 바인딩될 수는 있지만, 기존 객체 자체의 타입이 변경되는 것은 아니다.

value = 42
value = "forty-two"

첫 번째 대입에서 value는 정수 객체를 가리키고, 두 번째 대입에서는 문자열 객체를 가리킨다. 정수 객체가 문자열 객체로 변환된 것이 아니라 이름의 바인딩 대상이 바뀐 것이다.

객체의 값은 객체가 나타내는 데이터와 상태이다. 값의 변경 가능 여부는 객체의 타입에 따라 결정된다.

이름과 객체의 바인딩

Python 변수는 값을 담는 고정된 타입의 저장 상자라기보다, 객체와 연결되는 이름으로 이해할 수 있다. 대입문은 오른쪽 표현식이 만든 객체를 왼쪽 이름에 바인딩한다.

items = [1, 2, 3]

이 코드는 목록 객체를 생성하고 items라는 이름을 해당 객체에 연결한다. 다른 이름을 같은 객체에 바인딩할 수도 있다.

first = [1, 2]
second = first

second.append(3)

print(first)

first와 second는 같은 목록 객체를 가리키므로 second를 통해 객체를 변경하면 first를 통해서도 변경된 값이 보인다.

이러한 관계를 별칭이라고 한다. 가변 객체를 여러 이름이나 컨테이너가 공유할 때는 한 위치에서의 변경이 다른 위치에서도 관찰될 수 있다.

settings = {"theme": "dark"}
profiles = [settings, settings]

profiles[0]["theme"] = "light"

print(profiles[1]["theme"])

두 목록 원소는 같은 사전 객체를 참조하므로 한 원소를 통해 변경한 결과가 다른 원소에서도 나타난다.

대입은 기본적으로 객체를 복사하지 않는다. 별도의 객체가 필요하면 객체 종류에 맞는 복사 방법을 사용해야 한다.

original = [1, 2, 3]
copied = original.copy()

copied.append(4)

동등성과 동일성

Python은 객체의 값이 같은지 비교하는 동등성과 같은 객체인지 비교하는 동일성을 구분한다.

left = [1, 2]
right = [1, 2]

print(left == right)
print(left is right)

==는 객체가 정의한 값 비교 연산을 수행하므로 두 목록의 원소가 같으면 참이다. is는 정체성을 비교하므로 별도로 생성된 두 목록에서는 거짓이다.

일반적인 값 비교에는 ==를 사용하고, 객체의 정체성을 확인해야 할 때만 is를 사용한다. 특히 None은 하나만 존재하는 싱글턴 객체이므로 다음과 같이 비교한다.

if result is None:
    handle_missing_value()

일부 정수와 문자열 객체는 구현체의 최적화에 의해 재사용될 수 있으므로, 같은 리터럴이 우연히 같은 정체성을 가질 수 있다.

first = 100
second = 100

이 경우 first is second의 결과에 의존해서는 안 된다. 불변 객체의 재사용 여부는 구현체와 실행 상황에 따라 달라질 수 있으며 값 비교에는 항상 ==를 사용해야 한다.

사용자 정의 클래스의 기본 동등성 비교는 일반적으로 객체 정체성을 기반으로 한다. 값 기반 비교가 필요하면 __eq__()를 구현할 수 있다.

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __eq__(self, other):
        if not isinstance(other, Point):
            return NotImplemented

        return self.x == other.x and self.y == other.y

NotImplemented는 비교 대상의 타입을 현재 메서드가 처리하지 못한다는 사실을 인터프리터에 알린다. 이는 일반적인 실패를 나타내는 None이나 예외와는 다른 특수 값이다.

가변 객체와 불변 객체

객체의 값이 생성 후 변경될 수 있으면 가변 객체, 변경될 수 없으면 불변 객체라고 한다. 객체의 가변성은 타입에 의해 결정된다.^[61]

정수, 부동소수점 수, 복소수, 문자열, 바이트열과 튜플은 대표적인 불변 객체이다. 목록, 사전, 집합과 대부분의 사용자 정의 클래스 인스턴스는 가변 객체이다.

number = 10
number += 1

정수 객체 자체의 값이 10에서 11로 변경되는 것이 아니다. 10 + 1의 결과인 새로운 정수 객체가 만들어지고 number가 그 객체에 다시 바인딩된다.

문자열도 불변이다.

message = "Python"
message += " language"

이 연산은 기존 문자열 객체를 수정하는 대신 새로운 문자열 값을 만들고 이름을 다시 바인딩한다.

목록은 가변이므로 객체 자체의 원소 구성을 변경할 수 있다.

numbers = [1, 2]
numbers.append(3)
numbers[0] = 10

가변성과 이름 재바인딩은 서로 다른 동작이다.

items = [1, 2]
alias = items

items = [3, 4]

마지막 대입은 기존 목록을 수정하지 않는다. items를 새 목록 객체에 바인딩하며 alias는 계속 기존 [1, 2] 목록을 가리킨다.

items = [1, 2]
alias = items

items.append(3)

이 경우에는 같은 목록 객체를 직접 변경하므로 alias에서도 [1, 2, 3]이 보인다.

불변 컨테이너와 내부 가변성

튜플과 같은 불변 컨테이너는 생성 후 자신이 직접 참조하는 객체의 구성을 변경할 수 없다. 그러나 내부에 가변 객체가 들어 있으면 그 내부 객체의 상태는 변경될 수 있다.

record = ("user", ["read", "write"])

record[1].append("execute")

튜플의 두 번째 원소가 다른 객체로 교체된 것은 아니다. 튜플은 여전히 같은 목록 객체를 참조하지만, 그 목록의 내부 값이 변경되었다.

따라서 불변 컨테이너라는 표현은 내부에 포함된 모든 상태가 영원히 동일하다는 뜻이 아니다. 컨테이너가 직접 보유한 참조 구조를 변경할 수 없다는 의미에 가깝다.

record[1] = ["admin"]

이 코드는 튜플 원소 자체를 교체하려 하므로 TypeError를 발생시킨다.

불변 객체가 해시 가능한지도 내부 구성에 따라 달라질 수 있다. 가변 목록을 포함한 튜플은 전체 값에 안정적인 해시를 제공할 수 없으므로 사전 키로 사용할 수 없다.

key = ("user", ["read", "write"])

이 객체를 hash()에 전달하면 목록이 해시 가능하지 않기 때문에 오류가 발생한다.

표준 타입 계층

Python은 여러 내장 타입을 제공하며, 이들은 데이터 모델의 공통 규칙 아래에서 서로 다른 값을 표현한다.^[62]

특수 싱글턴 객체에는 None, NotImplemented와 Ellipsis가 있다.

None은 값의 부재나 명시적인 결과가 없음을 나타내는 데 사용된다. 함수가 return 없이 종료되면 None을 반환한다.

def log_message(message):
    print(message)


result = log_message("started")

NotImplemented는 주로 이항 연산과 비교 특수 메서드에서 현재 피연산자 조합을 처리하지 않는다는 의미로 반환한다.

def __eq__(self, other):
    if not isinstance(other, type(self)):
        return NotImplemented

    return self.value == other.value

Ellipsis는 ...로 표현되며 다차원 슬라이싱과 타입 표기, 구현 예정 코드 등의 문맥에서 사용된다.

def pending():
    ...

수치형 계층에는 bool, int, float와 complex가 포함된다. bool은 int의 하위 타입이며 False와 True는 각각 대부분의 수치 문맥에서 0과 1처럼 동작한다.

시퀀스는 순서가 있는 유한한 값의 집합을 나타낸다. 문자열, 튜플과 bytes는 불변 시퀀스이며, 목록과 bytearray는 가변 시퀀스이다.

집합 타입에는 가변인 set과 불변이며 해시 가능한 frozenset이 있다. 매핑의 대표적인 내장 타입은 dict이며, 키와 값의 관계를 저장한다.

호출 가능한 타입에는 사용자 정의 함수, 내장 함수, 메서드, 클래스와 __call__()을 구현한 인스턴스가 포함된다.

모듈, 클래스, 코드 객체, 프레임, 트레이스백과 슬라이스도 모두 독립된 객체 타입이다. 이러한 구조로 인해 Python 프로그램은 자신의 함수나 클래스, 실행 상태를 런타임에 조사할 수 있다.

컨테이너와 객체 관계

다른 객체에 대한 참조를 포함하는 객체를 컨테이너라고 한다. 목록, 튜플, 사전, 집합과 사용자 정의 인스턴스는 다른 객체를 포함하거나 참조할 수 있다.

user = {
    "name": "Luna",
    "permissions": ["read", "write"],
}

이 사전 객체는 문자열 객체와 목록 객체에 대한 참조를 보유한다. 목록은 다시 여러 문자열 객체를 참조한다.

Python 컨테이너는 일반적으로 다른 객체 자체를 내부에 복제해 저장하기보다 객체에 대한 참조를 보유한다. 같은 객체가 여러 컨테이너에 동시에 포함될 수 있다.

shared = {"enabled": True}

first = [shared]
second = {"config": shared}

first[0]과 second["config"]는 같은 사전 객체이다.

print(first[0] is second["config"])

컨테이너의 얕은 복사는 바깥 컨테이너만 새로 만들고 내부 객체에 대한 참조는 그대로 공유한다.

original = [[1, 2], [3, 4]]
copied = original.copy()

copied[0].append(5)

original과 copied는 서로 다른 바깥 목록이지만 첫 번째 내부 목록을 공유하므로 변경이 양쪽에서 보인다.

전체 객체 관계를 재귀적으로 복사하려면 copy.deepcopy()를 사용할 수 있다. 다만 모든 객체가 의미 있는 깊은 복사를 지원하는 것은 아니며, 파일·모듈·함수나 외부 자원을 나타내는 객체에는 그대로 적용하기 적합하지 않을 수 있다.

해시 가능성

해시 가능한 객체는 객체의 수명 동안 변하지 않는 해시값을 제공하며, 다른 객체와 동등하다고 비교되면 같은 해시값을 가져야 한다. 해시 가능한 객체는 사전의 키나 집합의 원소로 사용할 수 있다.

coordinates = {
    (10, 20): "spawn",
    (30, 40): "exit",
}

정수, 문자열과 해시 가능한 원소만 포함한 튜플은 일반적으로 해시 가능하다. 목록, 사전과 집합처럼 값이 변경될 수 있는 내장 객체는 해시 가능하지 않다.

lookup = {
    [1, 2]: "value",
}

목록은 사전 키로 사용할 수 없으므로 이 코드는 TypeError를 발생시킨다. 객체가 사전에 삽입된 뒤 값이 바뀌어 해시값까지 달라지면 원래 저장 위치를 안정적으로 찾을 수 없기 때문이다.

사용자 정의 클래스는 __hash__()와 __eq__()의 관계를 고려해야 한다. 값 기반 __eq__()를 정의하면서 객체를 가변으로 유지한다면 일반적으로 해시를 제공하지 않는 편이 적합하다.

class User:
    __hash__ = None

    def __init__(self, name):
        self.name = name

    def __eq__(self, other):
        if not isinstance(other, User):
            return NotImplemented

        return self.name == other.name

불변 값 객체라면 동등한 객체가 같은 해시를 반환하도록 구현할 수 있다.

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __eq__(self, other):
        if not isinstance(other, Point):
            return NotImplemented

        return self.x == other.x and self.y == other.y

    def __hash__(self):
        return hash((self.x, self.y))

이 경우 x와 y가 객체를 사전 키로 사용하는 동안 변경되지 않는다는 설계가 함께 필요하다.

함수도 객체라는 특성

Python 함수는 함수 정의문이 실행될 때 만들어지는 객체이다. 함수 객체는 변수에 저장하거나 컨테이너에 넣고, 다른 함수에 인자로 전달하거나 반환할 수 있다.

def greet(name):
    return f"Hello, {name}"


operation = greet
print(operation("Python"))

함수 객체에는 이름, 문서 문자열, 기본 인자, 주석, 전역 이름 공간, 클로저와 컴파일된 코드 객체에 대한 정보가 연결된다.

print(greet.__name__)
print(greet.__doc__)
print(greet.__code__)

함수에는 사용자 정의 속성을 연결할 수도 있다.

def handler(message):
    return message


handler.priority = 10

함수가 클래스 속성으로 저장되고 인스턴스를 통해 조회되면 디스크립터 동작에 의해 바인딩된 메서드 객체가 만들어진다.

class Greeter:
    def greet(self, name):
        return f"Hello, {name}"


instance = Greeter()
method = instance.greet

method는 원래 함수와 인스턴스를 함께 묶은 바인딩된 메서드이다.

print(method.__self__ is instance)
print(method.__func__ is Greeter.greet)

instance.greet("Python") 호출은 개념적으로 Greeter.greet(instance, "Python")과 대응한다.

클래스도 객체라는 특성

클래스는 객체를 생성하는 설계도이면서 그 자체로도 객체이다. 클래스 정의문이 실행되면 클래스 본문을 별도의 이름 공간에서 실행한 뒤 클래스 객체가 생성되고 이름에 바인딩된다.

class User:
    role = "member"

    def __init__(self, name):
        self.name = name

User는 클래스 객체이며 type(User)를 통해 그 타입을 확인할 수 있다.

print(type(User))

일반적인 사용자 정의 클래스의 타입은 type이다. 클래스 호출은 기본적으로 새 인스턴스를 생성하고 초기화한다.

user = User("Luna")

클래스 객체도 변수에 저장하고 함수에 전달하거나 컬렉션에 넣을 수 있다.

model_types = {
    "user": User,
}

model = model_types["user"]("Luna")

클래스의 속성은 인스턴스가 공유하는 기본 동작과 데이터를 제공한다. 인스턴스 속성과 클래스 속성은 서로 다른 이름 공간에 저장된다.

class Account:
    category = "standard"

    def __init__(self, owner):
        self.owner = owner

category는 클래스 속성이고 owner는 각 인스턴스에 저장되는 속성이다.

인스턴스와 속성 이름 공간

일반적인 사용자 정의 인스턴스는 각자의 속성 이름 공간을 가진다. 기본적으로 이 이름 공간은 __dict__를 통해 확인할 수 있다.

class Device:
    def __init__(self, name, enabled):
        self.name = name
        self.enabled = enabled


device = Device("sensor", True)

print(device.__dict__)

속성에 값을 대입하면 일반적으로 인스턴스 이름 공간에 항목이 추가되거나 변경된다.

device.status = "ready"

속성 조회는 단순히 인스턴스 사전만 확인하는 동작이 아니다. 인스턴스의 클래스와 상위 클래스, 디스크립터 및 사용자 정의 속성 접근 메서드가 함께 관여한다.

print(device.name)

일반적인 조회는 개념적으로 다음 순서의 영향을 받는다.

1. 클래스 계층에서 데이터 디스크립터를 찾는다.
2. 인스턴스의 속성 이름 공간을 확인한다.
3. 클래스 계층의 일반 속성이나 비데이터 디스크립터를 찾는다.
4. 찾지 못하면 __getattr__()을 호출할 수 있다.

정확한 동작은 __getattribute__()와 디스크립터 프로토콜에 의해 구현된다.

속성 접근의 사용자 정의

사용자 정의 클래스는 특수 메서드를 통해 속성 조회, 설정과 삭제 동작을 변경할 수 있다.

__getattribute__()는 대부분의 인스턴스 속성 조회에서 호출된다.

class LoggedObject:
    def __getattribute__(self, name):
        print(f"read: {name}")
        return super().__getattribute__(name)

__getattribute__() 안에서 다시 self.name과 같은 일반 속성 접근을 사용하면 재귀 호출이 발생할 수 있으므로 super().__getattribute__() 또는 object.__getattribute__()를 통해 기본 동작을 호출한다.

__getattr__()은 일반적인 조회 과정에서 속성을 찾지 못했을 때 호출된다.

class Configuration:
    def __getattr__(self, name):
        return None

이 구조는 동적 속성이나 위임 객체를 구현할 때 사용할 수 있다. 다만 오타까지 조용히 값으로 처리하면 오류 발견이 어려워질 수 있으므로, 처리할 수 없는 이름에는 AttributeError를 발생시키는 것이 중요하다.

__setattr__()은 속성 대입을 제어한다.

class PositiveValue:
    def __setattr__(self, name, value):
        if name == "value" and value < 0:
            raise ValueError("value must be positive")

        super().__setattr__(name, value)

__delattr__()은 속성 삭제를 사용자 정의한다.

이러한 특수 메서드는 객체의 모든 속성 접근에 개입하므로 검증, 프록시, 지연 로딩과 불변 객체 구현 등에 활용할 수 있다.

디스크립터

디스크립터는 다른 객체의 속성으로 저장되어 속성 조회·대입·삭제 동작을 제어하는 객체이다. __get__(), __set__() 또는 __delete__() 가운데 하나 이상을 정의한 객체가 디스크립터 프로토콜에 참여한다.^[63]

class Positive:
    def __set_name__(self, owner, name):
        self.name = name

    def __get__(self, instance, owner=None):
        if instance is None:
            return self

        return instance.__dict__[self.name]

    def __set__(self, instance, value):
        if value < 0:
            raise ValueError(f"{self.name} must be positive")

        instance.__dict__[self.name] = value

디스크립터를 클래스 속성으로 배치하면 여러 인스턴스의 속성 동작을 공통으로 관리할 수 있다.

class Product:
    price = Positive()
    quantity = Positive()

    def __init__(self, price, quantity):
        self.price = price
        self.quantity = quantity

product.price = 10은 단순히 인스턴스 사전에 값을 저장하는 대신 Positive.__set__()을 호출한다.

디스크립터는 Python 객체 모델의 핵심 구성 요소이며, 함수의 메서드 바인딩, property, classmethod, staticmethod와 일부 슬롯 구현도 디스크립터 프로토콜을 활용한다.

class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius

    @property
    def celsius(self):
        return self._celsius

    @celsius.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("below absolute zero")

        self._celsius = value

property는 접근자 메서드를 일반 속성과 같은 문법으로 노출하는 데이터 디스크립터이다.

데이터 디스크립터와 비데이터 디스크립터

__set__()이나 __delete__()을 정의한 디스크립터를 일반적으로 데이터 디스크립터라고 한다. __get__()만 정의한 객체는 비데이터 디스크립터이다.

데이터 디스크립터는 일반적인 인스턴스 속성보다 우선해서 조회된다. 따라서 인스턴스의 __dict__에 같은 이름이 있어도 데이터 디스크립터의 __get__()이 사용될 수 있다.

비데이터 디스크립터는 인스턴스 속성보다 낮은 우선순위를 가진다. 클래스에 정의된 일반 함수는 비데이터 디스크립터이므로, 인스턴스 속성에 같은 이름을 넣으면 가려질 수 있다.

class Service:
    def run(self):
        return "class method"


service = Service()
service.run = lambda: "instance value"

print(service.run())

반면 property처럼 데이터 디스크립터로 구현된 속성은 인스턴스 사전에 같은 이름을 직접 저장하는 방식으로 쉽게 우회되지 않는다.

이 우선순위는 메서드, 프로퍼티, ORM 필드와 검증 속성 등이 일관되게 동작하는 기반이다.

__slots__

일반적인 인스턴스는 동적인 속성 저장을 위해 __dict__를 가진다. 클래스에서 __slots__를 정의하면 허용할 인스턴스 속성 이름을 명시하고, 기본 인스턴스 사전을 생략할 수 있다.

class Point:
    __slots__ = ("x", "y")

    def __init__(self, x, y):
        self.x = x
        self.y = y

정의되지 않은 속성을 추가하려 하면 오류가 발생한다.

point = Point(10, 20)
point.color = "red"

__slots__는 인스턴스 수가 매우 많을 때 메모리 사용을 줄이고 속성 이름의 실수를 제한하는 데 활용할 수 있다. 슬롯 속성은 클래스에 생성되는 디스크립터를 통해 관리된다.

__slots__가 객체를 완전히 불변으로 만드는 것은 아니다. 정의된 슬롯의 값은 계속 변경할 수 있으며, 하위 클래스가 __dict__를 다시 제공할 수도 있다.

약한 참조를 지원하려면 필요한 경우 __weakref__를 슬롯에 포함해야 한다. 다중 상속과 클래스 레이아웃에도 제약이 있으므로 단순한 성능 최적화 수단으로 무조건 적용하기보다 객체 설계를 함께 고려해야 한다.

특수 메서드

이중 밑줄로 시작하고 끝나는 이름 가운데 Python 데이터 모델이 특별한 의미를 부여한 메서드를 특수 메서드라고 한다. 특수 메서드는 객체가 언어 문법과 내장 함수에 어떻게 반응하는지를 정의한다.^[64]

객체 생성과 초기화에는 __new__()와 __init__()이 관여한다.

class User:
    def __new__(cls, *args, **kwargs):
        instance = super().__new__(cls)
        return instance

    def __init__(self, name):
        self.name = name

__new__()는 새 인스턴스를 생성해 반환하고, __init__()은 이미 생성된 인스턴스의 초기 상태를 설정한다. 불변 타입의 하위 클래스를 구현하거나 인스턴스 생성을 제어할 때는 __new__()가 중요하다.

문자열 표현에는 __repr__(), __str__()와 __format__()이 사용된다.

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __repr__(self):
        return f"Point(x={self.x!r}, y={self.y!r})"

    def __str__(self):
        return f"({self.x}, {self.y})"

repr()은 주로 개발과 디버깅에 적합한 명확한 표현을 요청하고, str()은 사용자에게 보여줄 읽기 쉬운 표현을 요청한다.

불리언 평가에는 __bool__() 또는 __len__()이 사용된다.

class Queue:
    def __init__(self):
        self.items = []

    def __bool__(self):
        return bool(self.items)

호출 동작은 __call__()로 구현한다.

class Multiplier:
    def __init__(self, factor):
        self.factor = factor

    def __call__(self, value):
        return value * self.factor

이 객체는 함수처럼 호출할 수 있다.

double = Multiplier(2)
print(double(10))

연산자 오버로딩

수치 연산과 비교 연산은 특수 메서드를 통해 사용자 정의할 수 있다.

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        if not isinstance(other, Vector):
            return NotImplemented

        return Vector(
            self.x + other.x,
            self.y + other.y,
        )

left + right는 왼쪽 객체의 __add__()와 필요에 따라 오른쪽 객체의 반사 연산인 __radd__()에 연결된다.

first = Vector(1, 2)
second = Vector(3, 4)
result = first + second

증강 대입에는 __iadd__()와 같은 제자리 연산 메서드가 사용될 수 있다. 메서드가 없거나 지원하지 않으면 일반 이항 연산과 재바인딩으로 처리될 수 있다.

비교 연산에는 __eq__(), __ne__(), __lt__(), __le__(), __gt__()와 __ge__()가 사용된다. 처리할 수 없는 상대 타입에는 NotImplemented를 반환하여 반대쪽 연산이나 기본 처리 기회를 제공한다.

객체의 연산자 의미는 해당 타입의 개념과 자연스럽게 대응하도록 설계하는 것이 중요하다. 단순히 문법을 짧게 만들기 위해 예상하기 어려운 의미를 부여하면 코드의 가독성이 낮아질 수 있다.

컨테이너 프로토콜

사용자 정의 객체는 특수 메서드를 구현해 시퀀스나 매핑과 유사하게 동작할 수 있다.

__len__()은 객체의 길이를 제공한다.

class Collection:
    def __init__(self, values):
        self.values = list(values)

    def __len__(self):
        return len(self.values)

__getitem__()은 구독 연산을 처리한다.

class Collection:
    def __init__(self, values):
        self.values = list(values)

    def __getitem__(self, index):
        return self.values[index]

__setitem__()과 __delitem__()은 항목 대입과 삭제를 지원한다.

def __setitem__(self, index, value):
    self.values[index] = value

def __delitem__(self, index):
    del self.values[index]

포함 관계 검사는 __contains__()로 사용자 정의할 수 있다.

def __contains__(self, value):
    return value in self.values

객체가 __contains__()을 제공하지 않으면 Python은 반복이나 구독을 이용한 대체 동작을 시도할 수 있다.

컨테이너의 동작을 구현할 때는 지원하는 개념을 명확히 구분해야 한다. 순서와 인덱스를 가진 시퀀스인지, 임의의 키를 사용하는 매핑인지에 따라 기대되는 메서드와 예외가 달라진다.

반복자 프로토콜

반복 가능한 객체는 __iter__()를 통해 반복자를 반환한다. 반복자는 __next__()를 통해 다음 값을 반환하며, 더 이상 값이 없으면 StopIteration을 발생시킨다.

class CountDown:
    def __init__(self, start):
        self.current = start

    def __iter__(self):
        return self

    def __next__(self):
        if self.current <= 0:
            raise StopIteration

        value = self.current
        self.current -= 1
        return value

이 객체는 for 문과 list() 등 반복 가능한 객체를 받는 기능에 사용할 수 있다.

for number in CountDown(3):
    print(number)

컬렉션 객체와 반복자 객체를 분리하면 같은 컬렉션을 여러 번 독립적으로 반복할 수 있다.

class RangeCollection:
    def __init__(self, stop):
        self.stop = stop

    def __iter__(self):
        return iter(range(self.stop))

제너레이터 함수는 반복자 프로토콜을 더 간결하게 구현하는 방법을 제공한다.

def count_down(start):
    while start > 0:
        yield start
        start -= 1

컨텍스트 관리자 프로토콜

with 문에 사용되는 객체는 컨텍스트 관리자 프로토콜을 구현한다. 동기 컨텍스트 관리자는 __enter__()와 __exit__()을 제공한다.

class ManagedResource:
    def __enter__(self):
        self.open()
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        self.close()

with ManagedResource() as resource:
    resource.use()

__exit__()은 블록에서 예외가 발생했는지에 대한 정보를 받는다. 참을 반환하면 해당 예외를 처리한 것으로 간주해 전파를 중단할 수 있으며, 거짓이나 None을 반환하면 예외가 계속 전달된다.

비동기 컨텍스트 관리자는 __aenter__()와 __aexit__()을 구현하고 async with에서 사용된다.

이 프로토콜은 파일, 잠금, 트랜잭션과 임시 상태처럼 반드시 정리해야 하는 자원을 객체의 생명 주기와 구조적으로 연결한다.

객체 생성과 초기화

클래스 호출을 통한 인스턴스 생성에는 일반적으로 메타클래스의 호출 동작, 클래스의 __new__()와 __init__()이 관여한다.

instance = User("Luna")

개념적으로는 __new__()가 인스턴스를 생성한 뒤, 반환된 객체가 해당 클래스의 인스턴스라면 __init__()이 호출된다.

__new__()는 클래스 메서드처럼 클래스 객체를 첫 인자로 받고 새 객체를 반환한다.

class Identifier(str):
    def __new__(cls, value):
        normalized = value.strip().lower()
        return super().__new__(cls, normalized)

문자열은 불변이므로 값의 초기화는 이미 객체가 생성된 뒤 실행되는 __init__()보다 __new__()에서 수행한다.

__init__()은 객체를 반환해서는 안 되며 기존 인스턴스의 상태를 설정한다.

class Account:
    def __init__(self, owner):
        self.owner = owner
        self.balance = 0

팩토리나 캐싱을 구현하기 위해 __new__()가 기존 객체나 다른 타입의 객체를 반환할 수도 있다. 이 경우 일반적인 초기화 흐름이 달라질 수 있으므로 클래스 사용자에게 예측 가능한 의미를 유지해야 한다.

클래스 생성과 메타클래스

클래스 객체를 생성하는 객체를 메타클래스라고 한다. 일반적인 Python 클래스의 메타클래스는 type이다.

class Service:
    pass


print(type(Service) is type)

클래스 정의문이 실행되면 기본 클래스와 메타클래스를 결정하고, 클래스 이름 공간을 준비한 뒤 클래스 본문을 실행하고 클래스 객체를 생성한다.^[65]

사용자 정의 메타클래스는 클래스 생성 과정을 검증하거나 변경할 수 있다.

class RegisteredType(type):
    registry = {}

    def __new__(mcls, name, bases, namespace):
        cls = super().__new__(mcls, name, bases, namespace)
        mcls.registry[name] = cls
        return cls

class Plugin(metaclass=RegisteredType):
    pass

메타클래스는 프레임워크의 모델 선언, 자동 등록, 인터페이스 검사와 클래스 수준 코드 생성 등에 활용될 수 있다. 다만 클래스 데코레이터나 __init_subclass__()로 해결할 수 있는 작업보다 구조가 복잡하므로 클래스 생성 전체를 제어해야 할 때 주로 사용한다.

__init_subclass__()는 하위 클래스가 생성될 때 상위 클래스에 알림을 제공한다.

class Plugin:
    plugins = []

    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        Plugin.plugins.append(cls)

이 방식은 단순한 하위 클래스 등록에 별도의 메타클래스를 만들지 않아도 되는 선택지를 제공한다.

메서드 결정 순서

클래스가 여러 상위 클래스를 상속하면 Python은 메서드 결정 순서, 즉 MRO에 따라 속성과 메서드를 검색한다.

class Root:
    pass


class Left(Root):
    pass


class Right(Root):
    pass


class Child(Left, Right):
    pass

클래스의 MRO는 __mro__ 또는 mro()를 통해 확인할 수 있다.

print(Child.__mro__)

Python은 C3 선형화 알고리즘을 사용해 지역적인 상속 순서, 기존 상위 클래스 순서와 일관되는 MRO를 구성한다.

super()는 단순히 직접 부모 클래스를 의미하지 않고 현재 클래스 다음에 위치하는 MRO 항목으로 위임한다.

class Base:
    def initialize(self):
        print("Base")


class Feature(Base):
    def initialize(self):
        print("Feature")
        super().initialize()

협력적 다중 상속에서는 각 클래스가 super()를 사용하고 호환되는 메서드 시그니처를 유지해야 MRO 전체가 이어질 수 있다.

객체 표현과 포매팅

객체는 여러 종류의 문자열 표현을 제공할 수 있다.

__repr__()은 객체를 명확하게 식별하고 디버깅에 사용할 표현을 반환한다.

class User:
    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return f"User(name={self.name!r})"

__str__()은 사용자에게 표시할 읽기 쉬운 표현을 반환한다.

def __str__(self):
    return self.name

__format__()은 format()과 f-string의 형식 지정자 처리를 담당한다.

class FileSize:
    def __init__(self, bytes_count):
        self.bytes_count = bytes_count

    def __format__(self, specification):
        if specification == "kb":
            return f"{self.bytes_count / 1024:.2f} KiB"

        return str(self.bytes_count)

size = FileSize(4096)
print(f"{size:kb}")

바이트 표현이 필요한 객체는 __bytes__()를 구현할 수 있다.

이 표현 메서드는 객체의 내부 상태를 이해하고 로그, 오류 메시지와 사용자 인터페이스에 표시하는 방식을 정의한다.

복사와 직렬화

Python의 대입은 객체를 복제하지 않으므로 독립적인 객체 사본이 필요한 경우 복사 프로토콜이나 객체별 생성 방식을 사용한다.

copy.copy()는 얕은 복사를 수행하며 __copy__()로 사용자 정의할 수 있다. copy.deepcopy()는 객체 그래프를 재귀적으로 복사하며 __deepcopy__()로 동작을 제어할 수 있다.

import copy

original = {
    "values": [1, 2, 3],
}

shallow = copy.copy(original)
deep = copy.deepcopy(original)

얕은 복사는 내부 목록을 공유하지만 깊은 복사는 일반적으로 내부 목록도 새로 만든다.

직렬화는 객체 상태를 저장하거나 전송 가능한 표현으로 변환하는 과정이다. pickle은 Python 객체 구조를 저장할 수 있으며 클래스는 __reduce__(), __getstate__()와 __setstate__() 등을 통해 직렬화 동작을 제어할 수 있다.

pickle 데이터는 객체 생성과 코드 실행을 유발할 수 있으므로 신뢰할 수 없는 입력을 역직렬화하는 용도로 사용하지 않는다. JSON처럼 제한된 데이터 모델을 사용하는 형식은 외부 시스템과 데이터를 교환하는 데 더 적합할 수 있다.

약한 참조

일반적인 참조는 객체가 살아 있도록 유지하는 강한 참조이다. 약한 참조는 객체를 가리키지만 객체의 수명을 연장하지 않는다.

import weakref


class Resource:
    pass


resource = Resource()
reference = weakref.ref(resource)

print(reference() is resource)

원래 객체에 대한 강한 참조가 모두 사라지고 객체가 정리되면 약한 참조는 None을 반환한다.

del resource
print(reference())

약한 참조는 캐시, 객체 등록소, 관찰자 목록처럼 객체가 다른 곳에서 사용되는 동안만 부가 정보를 유지해야 하는 구조에 활용된다.

weakref.WeakKeyDictionary와 WeakValueDictionary는 키 또는 값에 대한 약한 참조를 사용하는 매핑을 제공한다. 모든 객체가 약한 참조를 지원하는 것은 아니며, 사용자 정의 슬롯 클래스에서는 __weakref__ 지원을 명시해야 할 수 있다.

객체 수명과 도달 가능성

Python 프로그램에서 객체를 직접 파괴하는 문장은 없다. 객체가 실행 중인 프로그램에서 더 이상 도달할 수 없게 되면 구현체가 이를 회수할 수 있다.^[66]

items = [1, 2, 3]
items = None

첫 번째 목록을 가리키는 다른 참조가 없다면 해당 객체는 더 이상 도달할 수 없는 상태가 된다.

del 문은 객체 자체를 직접 삭제하는 것이 아니라 이름, 속성이나 컨테이너 항목의 바인딩을 제거한다.

value = object()
del value

다른 이름이 같은 객체를 참조하고 있다면 객체는 계속 살아 있다.

first = object()
second = first

del first

second가 여전히 객체를 참조하므로 객체는 도달 가능한 상태이다.

Python 언어는 도달할 수 없는 객체가 즉시 회수되는 시점을 보장하지 않는다. 구현체는 가비지 컬렉션을 지연하거나 서로 다른 방식으로 수행할 수 있다.

파일, 네트워크 연결, 창이나 잠금처럼 외부 자원을 보유한 객체는 가비지 컬렉션 시점에 의존하지 않고 명시적으로 닫아야 한다.

with open("data.txt", encoding="utf-8") as file:
    contents = file.read()

with 문은 정상 종료와 예외 발생 모두에서 정리 동작을 구조적으로 실행한다.

CPython의 참조 계수

기준 구현체인 CPython은 객체 수명 관리의 주요 수단으로 참조 계수를 사용한다. 객체를 가리키는 강한 참조가 추가되면 참조 계수가 증가하고, 참조가 제거되면 감소한다. 마지막 강한 참조가 사라져 참조 계수가 0이 되면 일반적으로 객체의 해제 절차가 시작된다.^[67]

first = []
second = first

del first
del second

이 코드에서 두 이름은 같은 목록에 대한 참조를 가진다. 각 이름의 제거가 객체에 대한 강한 참조를 줄인다.

참조 계수는 Python 언어 사양이 아니라 CPython의 구현 방식이다. PyPy와 다른 구현체는 객체 수명을 다른 가비지 컬렉션 전략으로 관리할 수 있다. 따라서 파일 닫기나 잠금 해제와 같은 동작을 CPython의 즉각적인 참조 계수 감소에 의존해서는 안 된다.

CPython의 C API에서는 새 참조, 빌린 참조와 참조 소유권 이전을 구분한다. 확장 모듈은 이러한 규칙을 지키며 참조 계수를 관리해야 한다. Python 코드에서는 이 작업이 인터프리터 내부에서 자동으로 처리된다.

순환 참조와 가비지 컬렉션

참조 계수만으로는 서로를 참조하는 객체 집합을 정리하지 못할 수 있다.

first = []
second = []

first.append(second)
second.append(first)

외부에서 first와 second를 더 이상 참조하지 않더라도 두 목록은 서로를 참조하므로 각 객체의 참조 계수가 0이 되지 않는다.

CPython은 이러한 순환 구조를 감지하기 위해 참조 계수를 보완하는 순환 가비지 컬렉터를 제공한다. gc 모듈은 수집 실행, 활성화 상태와 디버깅 정보를 제어하거나 조회하는 인터페이스를 제공한다.^[68]

import gc

collected = gc.collect()
print(collected)

일반적인 프로그램에서는 직접 gc.collect()를 호출할 필요가 없다. 수집기는 자동으로 동작하며 명시적 호출은 디버깅, 측정이나 특수한 메모리 관리 상황에서 사용한다.

참조 순환이 언제 수집되는지는 즉시 보장되지 않는다. 디버거, 트레이싱 기능, 예외의 트레이스백과 전역 캐시가 객체를 계속 참조하여 예상보다 오래 유지할 수도 있다.

종료 처리와 __del__()

클래스는 __del__() 메서드를 정의하여 객체가 최종화될 때 실행할 동작을 제공할 수 있다.

class TrackedObject:
    def __del__(self):
        print("finalized")

그러나 __del__()이 정확히 언제 호출되는지는 보장되지 않으며, 인터프리터 종료 과정이나 복잡한 참조 관계에서는 예상과 다른 환경에서 실행될 수 있다.

__del__() 안에서 객체를 다시 전역 변수나 외부 컨테이너에 연결하면 객체가 되살아날 수도 있다. 종료 순서가 정해지지 않은 다른 객체나 모듈 전역 상태에 의존하는 코드 역시 안정적이지 않을 수 있다.

따라서 외부 자원 반환과 중요한 저장 작업은 __del__()에만 의존하지 않고 컨텍스트 관리자, 명시적인 close() 메서드 또는 try·finally로 처리한다.

resource = acquire_resource()

try:
    use_resource(resource)
finally:
    resource.close()

필요한 정리 콜백을 객체 수명에 연결하면서 __del__()의 제약을 피하려면 weakref.finalize를 사용할 수 있다.

객체 부활

객체의 종료 처리 과정에서 해당 객체에 대한 새 참조를 외부에 저장하면 객체가 다시 도달 가능한 상태가 될 수 있다. 이를 객체 부활이라고 한다.

saved = None


class Resurrectable:
    def __del__(self):
        global saved
        saved = self

객체 부활은 최종화와 가비지 컬렉션의 흐름을 복잡하게 만들며, 객체가 일부 종료 처리를 수행한 뒤 다시 사용되는 상태를 만들 수 있다.

일반적인 애플리케이션 설계에서는 객체 부활에 의존하지 않는다. 객체 수명과 자원 반환이 명시적으로 관리되는 구조가 더 예측 가능하다.

코드·프레임·트레이스백 객체

Python은 실행 중인 코드와 실행 상태도 객체로 표현한다.

함수의 __code__ 속성은 컴파일된 함수 본문을 나타내는 코드 객체를 참조한다.

def add(left, right):
    return left + right


code = add.__code__

print(code.co_name)
print(code.co_argcount)

코드 객체는 바이트코드, 상수, 지역 이름과 소스 위치 등 실행에 필요한 정보를 포함하며 불변 객체로 취급된다.

함수가 실행될 때는 프레임 객체가 생성된다. 프레임은 현재 실행 중인 코드 객체, 지역·전역 이름 공간과 실행 위치 등의 상태를 나타낸다.

예외가 전파되면 트레이스백 객체가 생성되어 예외가 지나온 프레임과 코드 위치를 연결한다.

try:
    1 / 0
except ZeroDivisionError as error:
    traceback = error.__traceback__

트레이스백은 프레임을 참조하고 프레임은 지역 객체를 참조할 수 있으므로, 예외 객체나 트레이스백을 장기간 저장하면 관련 객체의 수명이 길어질 수 있다.

이러한 내부 객체는 디버거, 프로파일러, 테스트 도구와 검사 도구에서 활용된다.

리플렉션과 검사

Python 객체는 런타임에 자신의 타입, 속성 및 일부 정의 정보를 조사할 수 있다. 이를 리플렉션 또는 인트로스펙션이라고 한다.

print(type(value))
print(dir(value))
print(hasattr(value, "name"))
print(getattr(value, "name", None))

dir()은 객체에서 사용할 수 있는 속성 이름의 목록을 구성한다. getattr()과 setattr()은 문자열 이름을 이용해 속성을 조회하거나 설정한다.

field_name = "enabled"

setattr(device, field_name, True)
value = getattr(device, field_name)

callable()은 객체가 호출 가능한지 검사하고, isinstance()와 issubclass()는 타입과 상속 관계를 확인한다.

inspect 표준 라이브러리는 함수 시그니처, 소스 위치, 클래스와 실행 프레임을 검사하는 고수준 기능을 제공한다.

리플렉션은 프레임워크, 직렬화, 의존성 주입, 테스트와 개발 도구에 유용하지만, 비공개 속성과 구현 세부에 과도하게 의존하면 버전 변경과 구현체 차이에 취약해질 수 있다.

데이터 모델의 확장성

Python 데이터 모델의 핵심은 내장 문법과 사용자 정의 객체가 동일한 프로토콜을 공유한다는 점이다.

사용자 정의 객체는 다음과 같은 역할에 참여할 수 있다.

• __iter__()를 구현해 반복 가능한 객체가 된다.
• __getitem__()을 구현해 구독과 슬라이싱을 지원한다.
• __enter__()와 __exit__()을 구현해 with 문에 사용된다.
• __call__()을 구현해 함수처럼 호출된다.
• 산술 특수 메서드를 구현해 연산자에 참여한다.
• __await__()을 구현해 기다릴 수 있는 객체가 된다.
• 디스크립터 프로토콜을 구현해 속성 접근을 제어한다.
• __class_getitem__()을 구현해 제네릭 표기와 클래스 구독을 지원한다.

이 구조는 새로운 문법을 계속 추가하지 않고도 기존 문법을 새로운 타입에 적용할 수 있게 한다. 배열, 텐서, 데이터베이스 질의 객체와 경로 객체 등은 Python의 공통 연산과 프로토콜을 각자의 의미에 맞게 구현할 수 있다.

다만 특수 메서드는 단순한 이름 규칙이 아니라 언어가 정의한 계약이다. 반환값, 예외와 다른 피연산자 처리 방식이 해당 프로토콜의 기대와 맞아야 내장 객체 및 다른 라이브러리와 일관되게 동작한다.

Python의 객체 모델은 동적 타입과 메타프로그래밍을 가능하게 하는 기반인 동시에, 함수·클래스·모듈·실행 상태를 같은 객체 개념 아래 통합한다. 이로 인해 작은 사용자 정의 클래스부터 프레임워크와 언어 도구에 이르기까지 동일한 데이터 모델을 단계적으로 활용할 수 있다.

Python은 객체가 런타임 타입을 가지며 이름은 객체에 동적으로 바인딩되는 동적 타입 언어이다. 변수나 함수 매개변수의 타입을 미리 선언하지 않아도 프로그램을 실행할 수 있으며, 연산이 수행되는 시점에 해당 객체가 필요한 동작을 지원하는지 검사한다.

value = 10
value = "Python"
value = [1, 2, 3]

위 코드에서 value라는 이름은 실행 과정에서 정수, 문자열과 목록 객체에 차례로 바인딩된다. 기존 객체의 타입이 바뀌는 것이 아니라 이름이 서로 다른 타입의 객체를 가리키도록 재바인딩되는 것이다.

Python은 이 동적 실행 모델 위에 선택적인 정적 타입 체계를 제공한다. 함수, 변수, 클래스와 타입 별칭에 타입 정보를 기록할 수 있으며, 타입 검사기와 통합 개발 환경은 프로그램을 실행하기 전에 이러한 정보를 분석한다. 타입 표기는 기본적으로 Python 인터프리터가 값의 대입이나 함수 호출을 강제로 제한하는 문법이 아니다.^[69]

def greet(name: str) -> str:
    return f"Hello, {name}"

name: str은 name에 문자열이 전달될 것으로 예상한다는 정적 타입 정보이고, -> str은 함수가 문자열을 반환할 것으로 예상한다는 뜻이다. 일반적인 Python 런타임은 이 표기를 보고 인자를 자동으로 검사하지 않는다.

Python의 타입 체계는 다음 두 층을 함께 가진다.

• 런타임에는 모든 객체가 실제 타입을 가진다.
• 개발 과정에서는 선택적으로 정적 타입 정보를 추가할 수 있다.

이 구조는 동적 코드와 정적으로 분석되는 코드를 같은 언어와 프로젝트 안에서 함께 사용할 수 있게 한다. Python 타입 시스템 명세에서는 이를 정적 타입과 동적 타입을 세밀한 단위로 혼합할 수 있는 점진적 타입 체계로 설명한다.^[70]

동적 타입

Python에서 타입은 변수 이름이 아니라 객체에 속한다. 객체의 타입은 해당 객체가 지원하는 연산, 값의 해석 방식과 데이터 모델 동작을 결정한다.

number = 10
text = "10"

print(type(number))
print(type(text))

number와 text는 이름 자체에 타입이 선언된 것이 아니라 각각 int와 str 객체를 참조한다.

대입문은 일반적으로 새로운 타입을 선언하지 않고 이름과 객체 사이의 바인딩을 만든다.

result = calculate()

result가 가리키는 객체의 타입은 calculate()가 실제로 반환한 객체에 따라 결정된다. 같은 함수도 실행 조건에 따라 서로 다른 타입의 객체를 반환할 수 있다.

def parse(value):
    if value.isdigit():
        return int(value)

    return value

이 함수는 입력에 따라 int 또는 str 객체를 반환한다. 정적 타입 정보를 추가한다면 이를 합집합 타입으로 표현할 수 있다.

def parse(value: str) -> int | str:
    if value.isdigit():
        return int(value)

    return value

동적 타입은 프로그램의 구조가 고정되지 않는다는 뜻은 아니다. 모든 객체는 런타임에 명확한 타입을 가지며, 해당 타입이 제공하지 않는 연산을 수행하면 예외가 발생한다.

value = "Python"
result = value + 10

문자열과 정수 사이의 덧셈이 정의되어 있지 않으므로 이 코드는 TypeError를 발생시킨다.

Python은 암시적으로 모든 값을 임의의 다른 타입으로 변환하여 연산하지 않는다. 필요한 변환은 일반적으로 명시적으로 수행한다.

value = "10"
result = int(value) + 5

강한 타입

Python은 일반적으로 강한 타입 언어로 분류된다. 타입이 서로 다른 객체 사이의 연산이 의미상 정의되지 않았다면, 인터프리터는 임의의 자동 변환으로 연산을 계속하기보다 예외를 발생시킨다.

print("5" + 5)

문자열 "5"를 자동으로 정수로 변환하거나 정수 5를 자동으로 문자열로 변환하지 않으므로 TypeError가 발생한다.

반면 같은 연산자가 여러 타입에서 서로 다른 의미를 가질 수는 있다.

print(10 + 20)
print("Py" + "thon")
print([1, 2] + [3, 4])

+는 정수에서는 산술 덧셈, 문자열과 목록에서는 연결 연산으로 동작한다. 이는 피연산자의 타입이 정의한 연산자 프로토콜에 따른 다형성이지, 타입 구분이 사라지는 것은 아니다.

수치형 사이에는 언어가 정의한 변환 규칙이 존재한다.

result = 10 + 2.5

이 경우 정수와 부동소수점 수는 공통 수치 연산 규칙에 따라 계산된다. 이러한 변환은 관련 없는 타입을 임의로 섞는 것이 아니라 수치형 계층에 정의된 동작이다.

강한 타입이라는 표현에는 하나의 완전한 형식적 정의가 존재하지 않으므로, Python 문서에서는 일반적으로 동적 타입과 객체별 연산 규칙을 직접 설명한다. Python에서는 객체의 실제 타입과 해당 타입이 제공하는 프로토콜이 실행 가능성을 결정한다.

런타임 타입 검사

type()은 객체의 직접적인 타입 객체를 반환한다.

value = 10

print(type(value))

특정 타입이나 그 하위 타입의 인스턴스인지 검사할 때는 isinstance()를 사용할 수 있다.

if isinstance(value, int):
    print(value + 1)

여러 타입 가운데 하나인지 검사할 수도 있다.

if isinstance(value, int | float):
    print("numeric")

상속 관계는 issubclass()로 검사한다.

print(issubclass(bool, int))

type(value) is SomeType은 정확히 해당 타입인지만 검사하지만, isinstance(value, SomeType)은 하위 클래스 관계와 일부 추상 기반 클래스의 등록 관계도 고려할 수 있다.

class Base:
    pass


class Derived(Base):
    pass


instance = Derived()

print(type(instance) is Base)
print(isinstance(instance, Base))

다형성을 허용하는 일반적인 코드에서는 직접적인 타입 일치보다 isinstance()나 객체가 제공하는 동작을 사용하는 방식이 적합할 수 있다.

런타임 타입 검사는 외부 입력 검증, 역직렬화, API 경계와 여러 표현을 받는 함수 등에 사용할 수 있다. 그러나 모든 함수 호출에서 구체 타입을 먼저 검사하면 Python의 덕 타이핑과 확장성을 제한할 수 있다.

덕 타이핑

Python에서는 객체의 명목상 클래스보다 실제로 필요한 동작을 제공하는지가 중요하게 취급된다. 객체가 특정 메서드나 프로토콜을 지원한다면 서로 상속 관계가 없어도 같은 코드에서 사용할 수 있다. 이를 덕 타이핑이라고 한다.

def save(destination, data):
    destination.write(data)

save()는 destination의 구체적인 클래스를 검사하지 않는다. write() 메서드를 제공하고 전달된 데이터를 처리할 수 있는 객체라면 파일, 메모리 버퍼, 네트워크 스트림이나 사용자 정의 객체를 사용할 수 있다.

from io import StringIO


buffer = StringIO()
save(buffer, "Python")

덕 타이핑은 Python의 프로토콜 중심 데이터 모델과 연결된다. 반복 가능한 객체는 반드시 하나의 공통 구현 클래스를 상속할 필요 없이 __iter__() 또는 시퀀스 방식의 반복 동작을 제공하면 for 문에서 사용할 수 있다.

def first_item(values):
    for value in values:
        return value

    raise ValueError("empty iterable")

이 함수는 목록뿐 아니라 튜플, 집합, 문자열, 제너레이터와 사용자 정의 반복 가능 객체를 받을 수 있다.

덕 타이핑은 객체의 타입을 전혀 고려하지 않는다는 뜻이 아니다. 필요한 연산과 그 의미가 인터페이스 역할을 하며, 객체가 해당 계약을 만족하지 않으면 실행 중 예외가 발생한다.

명목적 서브타이핑

클래스 상속을 통해 타입 관계를 정의하는 방식을 명목적 서브타이핑이라고 한다. 하위 클래스는 상위 클래스와 명시적인 상속 관계를 가진다.

class Animal:
    def speak(self) -> str:
        raise NotImplementedError


class Dog(Animal):
    def speak(self) -> str:
        return "woof"

Dog는 Animal을 명시적으로 상속하므로 Dog의 인스턴스는 Animal이 요구되는 위치에서 사용할 수 있다.

def announce(animal: Animal) -> None:
    print(animal.speak())


announce(Dog())

명목적 타입 관계는 클래스 선언에 기록되므로 타입 검사기와 런타임의 isinstance()가 공통으로 이해할 수 있다.

추상 기반 클래스는 명목적 인터페이스를 정의하는 데 사용할 수 있다.

from abc import ABC, abstractmethod


class Storage(ABC):
    @abstractmethod
    def load(self, key: str) -> bytes:
        raise NotImplementedError

하위 클래스는 추상 메서드를 구현해야 정상적으로 인스턴스를 생성할 수 있다.

일부 추상 기반 클래스는 직접 상속하지 않은 클래스를 가상 하위 클래스로 등록하거나 특정 특수 메서드의 존재에 따라 관계를 판단할 수 있다. 그러나 이러한 런타임 관계와 정적 타입 검사기의 판단이 항상 완전히 같지는 않다.

구조적 서브타이핑

Python의 정적 타입 체계는 Protocol을 통해 구조적 서브타이핑을 표현할 수 있다. 특정 클래스를 명시적으로 상속하지 않아도 프로토콜이 요구하는 멤버를 제공하면 해당 타입과 호환되는 것으로 판단한다.^[71]

from typing import Protocol


class Writable(Protocol):
    def write(self, data: str) -> int:
        ...

Writable을 직접 상속하지 않은 클래스도 호환되는 write() 메서드를 제공하면 정적 타입 검사에서 사용할 수 있다.

class MemoryWriter:
    def __init__(self) -> None:
        self.contents = ""

    def write(self, data: str) -> int:
        self.contents += data
        return len(data)


def emit(writer: Writable, text: str) -> None:
    writer.write(text)

MemoryWriter는 Writable을 상속하지 않지만 필요한 메서드 시그니처를 제공하므로 구조적으로 호환된다.

프로토콜은 동적 덕 타이핑의 관습을 정적 타입으로 설명할 수 있게 한다. 라이브러리는 구현체가 특정 상위 클래스를 상속하도록 강제하지 않으면서 필요한 동작만 명시할 수 있다.

프로토콜에는 속성과 메서드, 프로퍼티와 클래스 메서드 등을 선언할 수 있다.

class Named(Protocol):
    name: str

    def rename(self, name: str) -> None:
        ...

@runtime_checkable을 적용하면 일부 프로토콜을 isinstance() 검사에 사용할 수 있다.

from typing import Protocol, runtime_checkable


@runtime_checkable
class Closable(Protocol):
    def close(self) -> None:
        ...

다만 런타임 프로토콜 검사는 일반적으로 멤버의 존재 여부를 중심으로 하며, 정적 타입 검사처럼 세부 시그니처까지 완전히 검증하지 않는다.

점진적 타입

Python의 정적 타입 체계는 타입 표기를 프로그램 전체에 한 번에 적용하도록 요구하지 않는다. 필요한 모듈, 함수나 변수부터 선택적으로 추가할 수 있다.

def typed_add(left: int, right: int) -> int:
    return left + right


def dynamic_process(value):
    return value.transform()

첫 번째 함수는 매개변수와 반환 타입을 명시하지만 두 번째 함수는 정적 타입을 지정하지 않았다. 두 형태는 같은 모듈에서 함께 사용할 수 있다.

타입 표기가 없는 부분은 타입 검사기의 설정과 문맥에 따라 동적인 영역으로 취급될 수 있다. 이를 통해 기존의 대규모 Python 코드베이스에도 타입 정보를 단계적으로 도입할 수 있다.

점진적 타입은 정적으로 검사되는 코드와 동적으로 처리되는 코드 사이에 경계가 생긴다는 뜻이기도 하다. 동적 영역에서 잘못된 타입의 값이 들어오면 정적 분석만으로 모든 오류를 막을 수 없다.

def dynamic_source():
    return "not an integer"


def double(value: int) -> int:
    return value * 2


result = double(dynamic_source())

동적 함수의 반환 타입을 검사기가 Any로 취급하면 이 호출을 허용할 수 있다. 실제 결과는 문자열 반복이 되어 정수 반환이라는 의도와 달라질 수 있다.

따라서 점진적 타입을 사용할 때는 외부 입력, 동적 라이브러리와 정적 영역이 만나는 경계의 타입을 명확히 표현하는 것이 중요하다.

타입 힌트

타입 힌트는 소스 코드에 예상 타입을 기록하는 표준 문법과 규칙이다. PEP 484는 함수 주석을 정적 분석과 리팩터링, 코드 완성과 같은 도구에서 사용할 수 있도록 표준 타입 표기 체계를 제안했다.^[72]

함수 매개변수에는 이름 뒤의 콜론으로 타입을 표기하고, 반환 타입에는 ->를 사용한다.

def calculate_total(
    price: float,
    quantity: int,
) -> float:
    return price * quantity

변수 주석은 이름 뒤에 타입을 작성한다.

username: str = "Luna"
retry_count: int = 3
enabled: bool

변수 주석 문법은 PEP 526에서 표준화되었다.^[73]

주석과 초기값은 별개이다.

result: int

이 코드는 result가 정수로 사용될 것이라는 주석을 만들지만 값을 바인딩하지 않는다. 값을 대입하기 전에 result를 읽으면 이름 오류가 발생할 수 있다.

클래스 속성과 인스턴스 속성도 표기할 수 있다.

from typing import ClassVar


class User:
    species: ClassVar[str] = "human"
    name: str
    age: int

    def __init__(self, name: str, age: int) -> None:
        self.name = name
        self.age = age

ClassVar는 클래스 수준에서 공유되는 속성임을 타입 검사기에 알린다.

타입 표기의 런타임 의미

Python 런타임은 일반적으로 타입 주석을 자동으로 강제하지 않는다.

def square(value: int) -> int:
    return value * value


square("Python")

이 호출은 타입 주석과 맞지 않지만 인터프리터가 주석만을 근거로 호출을 차단하지 않는다. 실제 연산이 가능한지에 따라 실행 결과가 결정된다.

함수 주석은 일반적으로 함수 객체의 __annotations__와 관련된 인터페이스를 통해 조회할 수 있다. 모듈과 클래스의 변수 주석도 주석 정보로 저장될 수 있다.

def convert(value: str) -> int:
    return int(value)


print(convert.__annotations__)

타입 주석은 런타임 프레임워크에서도 활용될 수 있다. 데이터 검증, 직렬화, 명령행 인터페이스 생성, 의존성 주입과 웹 프레임워크가 주석을 읽어 자체 동작을 구현할 수 있다. 이 경우의 검증과 변환은 Python 언어가 자동으로 제공하는 것이 아니라 해당 라이브러리가 정의한 동작이다.

Python 3.14에는 주석을 다양한 형식으로 안전하게 조사하기 위한 annotationlib 모듈이 추가되었다.^[74]

주석의 평가 방식은 Python 버전과 설정에 따라 달라질 수 있으므로, 런타임에서 주석을 직접 읽는 라이브러리는 공식 검사 인터페이스를 사용하는 것이 적합하다.

내장 제네릭 표기

컬렉션이 포함하는 원소의 타입은 대괄호를 이용한 제네릭 타입 표기로 나타낼 수 있다.

names: list[str] = ["Alice", "Bob"]
scores: dict[str, int] = {
    "Alice": 90,
    "Bob": 85,
}
coordinates: tuple[int, int] = (10, 20)

list[str]은 문자열 원소로 이루어진 목록, dict[str, int]는 문자열 키와 정수 값으로 이루어진 사전을 나타낸다.

Python 3.9부터 list, dict, tuple, set과 여러 표준 컬렉션 클래스 자체를 제네릭 타입 표기에 사용할 수 있다. 이 구조는 PEP 585에서 도입되었다.^[75]

이전 버전에서는 typing.List, typing.Dict와 같은 이름이 주로 사용되었다.

from typing import Dict, List


names: List[str]
scores: Dict[str, int]

현대 Python 코드에서는 지원 버전이 허용한다면 내장 제네릭 문법을 주로 사용한다.

길이와 원소 위치가 정해진 튜플은 각 위치의 타입을 나열한다.

record: tuple[str, int, bool]

같은 타입의 원소를 임의 개수 포함하는 튜플은 다음과 같이 표기한다.

values: tuple[int, ...]

빈 튜플의 타입은 tuple[()]으로 나타낼 수 있다.^[76]

합집합 타입과 선택적 값

값이 여러 타입 가운데 하나일 수 있으면 합집합 타입을 사용한다.

def parse(value: str) -> int | float:
    if "." in value:
        return float(value)

    return int(value)

int | float은 값이 정수 또는 부동소수점 수일 수 있음을 나타낸다. |를 이용한 합집합 표기는 Python 3.10에서 도입되었다.^[77]

이전 표기는 typing.Union을 사용한다.

from typing import Union


result: Union[int, float]

값이 특정 타입 또는 None일 수 있다면 다음과 같이 표현한다.

def find_user(user_id: int) -> User | None:
    ...

이전에는 Optional[User]도 사용되었다.

from typing import Optional


def find_user(user_id: int) -> Optional[User]:
    ...

Optional[T]는 매개변수가 생략 가능하다는 뜻이 아니라 T | None과 같은 타입을 뜻한다. 기본 인자가 존재하는지 여부와 값으로 None을 허용하는지는 서로 다른 개념이다.

def connect(timeout: int = 30) -> None:
    ...

timeout은 호출에서 생략할 수 있지만 함수 내부에서 예상되는 타입은 int이다.

def connect(timeout: int | None = None) -> None:
    ...

이 경우에는 생략할 수도 있고 명시적으로 None을 전달할 수도 있다.

Any

Any는 정적 타입이 알려지지 않았거나 동적으로 취급되는 값을 나타낸다. 모든 타입의 값은 Any에 대입할 수 있고, Any 값도 정적 검사에서 다른 타입이 필요한 위치에 전달할 수 있다.^[78]

from typing import Any


value: Any = load_dynamic_value()

value.run()
value + 10
result: str = value

타입 검사기는 일반적으로 Any에 대한 임의의 속성 접근과 연산을 허용한다. 이는 동적 코드와 정적 코드의 연결에 유용하지만, 해당 영역에서 타입 오류를 정적으로 찾는 능력은 줄어든다.

주석이 없는 함수의 매개변수나 타입 인자를 생략한 일부 제네릭은 설정에 따라 Any로 처리될 수 있다.

def process(value):
    return value.execute()

Any와 object는 다르다.

from typing import Any


dynamic_value: Any
unknown_value: object

Any에는 임의의 연산을 적용할 수 있지만, object는 모든 Python 객체가 될 수 있다는 사실만 나타낸다. object 값에서 특정 메서드를 사용하려면 타입 검사나 다른 방식으로 타입을 좁혀야 한다.

def stringify(value: object) -> str:
    return str(value)

object는 타입 안전성을 유지하면서 모든 객체를 받는 인터페이스에 사용할 수 있다.

Never와 NoReturn

정상적으로 값을 반환하지 않는 함수는 Never 또는 과거의 NoReturn으로 표현할 수 있다.

from typing import Never


def fail(message: str) -> Never:
    raise RuntimeError(message)

Never는 가능한 값이 하나도 없는 바닥 타입을 나타낸다. 함수가 항상 예외를 발생시키거나 프로그램을 종료하는 경우 반환 타입으로 사용할 수 있다.

도달할 수 없는 분기를 검사할 때도 사용할 수 있다.

from typing import assert_never


def handle_status(status: Status) -> None:
    match status:
        case Status.READY:
            start()
        case Status.STOPPED:
            stop()
        case _ as unreachable:
            assert_never(unreachable)

열거형이나 합집합에 새로운 경우가 추가되면 정적 타입 검사기가 처리되지 않은 분기를 찾는 데 활용할 수 있다.

리터럴 타입

Literal은 특정 타입 전체가 아니라 하나 이상의 구체적인 값을 타입으로 표현한다.^[79]

from typing import Literal


Mode = Literal["read", "write", "append"]


def open_resource(mode: Mode) -> None:
    ...

호출자는 지정된 문자열 가운데 하나를 전달해야 한다.

open_resource("read")

리터럴 타입은 인자 값에 따라 반환 타입이 달라지는 API, 설정 값과 상태 표현에 유용하다.

from typing import Literal, overload


@overload
def decode(data: bytes, as_text: Literal[True]) -> str:
    ...


@overload
def decode(data: bytes, as_text: Literal[False]) -> bytes:
    ...

리터럴 값은 해당 일반 타입의 하위 타입으로 취급된다. 예를 들어 Literal[3]은 int의 더 구체적인 형태이다.

타입 별칭

복잡한 타입 표현에 이름을 부여하면 타입 별칭을 만들 수 있다.

type UserId = int
type Headers = dict[str, str]
type Result = str | bytes | None

Python 3.12부터 type 문을 이용해 타입 별칭을 명시적으로 선언할 수 있다. 이 문법은 PEP 695에서 도입되었다.^[80]

이전 버전에서는 일반 대입과 TypeAlias를 사용했다.

from typing import TypeAlias


Headers: TypeAlias = dict[str, str]

타입 별칭은 새로운 런타임 클래스를 생성하지 않는다. UserId가 int의 별칭이라면 정적 타입에서도 기본적으로 같은 타입으로 취급된다.

서로 다른 의미의 값을 정적으로 구별하고 싶다면 NewType을 사용할 수 있다.

from typing import NewType


UserId = NewType("UserId", int)
OrderId = NewType("OrderId", int)

def load_user(user_id: UserId) -> User:
    ...

UserId와 OrderId는 정적 검사에서 구분되지만 런타임에는 기본 값을 가볍게 감싸는 형태로 동작한다. 실제 런타임 서브클래스와 동일한 개념은 아니다.

제네릭

제네릭은 하나의 클래스나 함수가 여러 타입에 대해 동작하면서 입력과 출력 사이의 타입 관계를 보존하도록 표현한다.

def first[T](values: list[T]) -> T:
    return values[0]

T는 호출 시 실제 원소 타입으로 대체되는 타입 매개변수이다.

name = first(["Alice", "Bob"])
number = first([10, 20])

타입 검사기는 첫 번째 호출의 반환 타입을 str, 두 번째 호출의 반환 타입을 int로 추론할 수 있다.

제네릭 클래스도 정의할 수 있다.

class Box[T]:
    def __init__(self, value: T) -> None:
        self.value = value

    def get(self) -> T:
        return self.value

text_box = Box("Python")
number_box = Box(10)

Python 3.12 이전의 일반적인 문법은 TypeVar와 Generic을 사용한다.

from typing import Generic, TypeVar


T = TypeVar("T")


class Box(Generic[T]):
    def __init__(self, value: T) -> None:
        self.value = value

    def get(self) -> T:
        return self.value

새 타입 매개변수 문법과 기존 문법은 지원 대상 Python 버전과 라이브러리 호환성에 따라 선택할 수 있다.

제한된 타입 변수와 상한

타입 변수에 허용할 타입을 제한할 수 있다.

def add[T: (int, float)](left: T, right: T) -> T:
    return left + right

이 형태의 타입 변수는 지정된 제약 타입 가운데 하나로 결정된다.

상한을 사용하면 특정 타입의 하위 타입만 허용할 수 있다.

from collections.abc import Sized


def choose_longer[T: Sized](left: T, right: T) -> T:
    if len(left) >= len(right):
        return left

    return right

T는 Sized 프로토콜을 만족하는 구체적인 타입으로 결정되며 반환 타입도 그 구체 타입을 유지한다.

제약과 상한은 서로 다르다. 제약은 나열된 후보 타입 가운데 하나로 타입 변수를 해석하고, 상한은 지정한 타입의 임의 하위 타입을 허용한다.

분산

제네릭 타입 사이의 서브타입 관계가 타입 인자의 서브타입 관계를 어떻게 따르는지를 분산이라고 한다.

읽기 전용 값을 제공하는 컨테이너는 공변으로 설계할 수 있다. Dog가 Animal의 하위 타입일 때 Producer[Dog]를 Producer[Animal]로 사용할 수 있는 관계이다.

class Producer[T]:
    def __init__(self, value: T) -> None:
        self._value = value

    def get(self) -> T:
        return self._value

값을 소비하는 인터페이스는 반공변 관계가 적합할 수 있다. Animal을 처리할 수 있는 소비자는 Dog만 필요한 위치에서도 사용할 수 있다.

값을 읽고 쓰는 가변 컨테이너는 일반적으로 무공변이다. list[Dog]를 list[Animal]로 허용하면 다른 동물 객체를 삽입하여 원래 목록의 타입 가정을 깨뜨릴 수 있다.

dogs: list[Dog]
animals: list[Animal] = dogs
animals.append(Cat())

따라서 정적 타입 체계에서는 list[Dog]를 list[Animal]의 하위 타입으로 취급하지 않는다.

Python의 현대 타입 매개변수 문법에서는 타입 검사기가 사용 위치를 바탕으로 분산을 추론할 수 있으며, 기존 TypeVar 문법에서는 공변·반공변 여부를 명시할 수 있다.

호출 가능 객체

함수와 호출 가능한 객체의 타입은 Callable로 표현할 수 있다.

from collections.abc import Callable


Operation = Callable[[int, int], int]


def apply(
    operation: Operation,
    left: int,
    right: int,
) -> int:
    return operation(left, right)

Callable[[int, int], int]은 정수 인자 두 개를 받고 정수를 반환하는 호출 가능 객체를 나타낸다.

def add(left: int, right: int) -> int:
    return left + right


result = apply(add, 10, 20)

단순한 Callable 표기는 키워드 전용 매개변수, 오버로드와 복잡한 호출 규칙을 충분히 표현하지 못할 수 있다. 이런 경우 호출 메서드를 가진 프로토콜을 사용할 수 있다.

from typing import Protocol


class Formatter(Protocol):
    def __call__(
        self,
        value: int,
        *,
        prefix: str = "",
    ) -> str:
        ...

매개변수 명세 변수

데코레이터처럼 다른 함수의 호출 시그니처를 보존해야 할 때는 ParamSpec을 사용할 수 있다.

from collections.abc import Callable
from typing import ParamSpec, TypeVar


P = ParamSpec("P")
R = TypeVar("R")


def logged(
    function: Callable[P, R],
) -> Callable[P, R]:
    def wrapper(
        *args: P.args,
        **kwargs: P.kwargs,
    ) -> R:
        print(function.__name__)
        return function(*args, **kwargs)

    return wrapper

P는 위치 인자와 키워드 인자를 포함한 함수의 전체 매개변수 구조를 나타낸다. 따라서 장식된 함수의 인자 타입과 반환 타입을 보존할 수 있다.

Python 3.12 이상의 타입 매개변수 문법에서는 다음과 같이 선언할 수 있다.

def logged[**P, R](
    function: Callable[P, R],
) -> Callable[P, R]:
    ...

매개변수 명세 변수의 현대 문법과 동작은 Python 타입 명세의 제네릭 규칙에 정의되어 있다.^[81]

가변 길이 제네릭

TypeVarTuple은 임의 개수의 타입 매개변수를 표현한다. 이는 배열이나 텐서의 차원처럼 길이가 고정되지 않은 타입 구조를 나타내는 데 사용할 수 있다.^[82]

from typing import TypeVarTuple


Shape = TypeVarTuple("Shape")


class Array[*Shape]:
    ...

가변 길이 제네릭은 하나의 타입 변수로 원소 타입만 표현하는 것을 넘어, 여러 차원의 구조나 가변 길이 튜플의 타입 관계를 보존할 수 있게 한다.

일반적인 애플리케이션 코드보다 수치 계산, 프레임워크와 고급 라이브러리 타입 선언에서 주로 활용된다.

Self

현재 클래스 또는 실제 하위 클래스 타입을 반환하는 메서드는 Self로 표현할 수 있다.^[83]

from typing import Self


class Builder:
    def reset(self) -> Self:
        return self

하위 클래스에서 이 메서드를 호출하면 반환 타입도 해당 하위 클래스 타입으로 유지된다.

class QueryBuilder(Builder):
    def filter(self, condition: str) -> Self:
        return self

Self는 체이닝 메서드, 대체 생성자와 자신과 같은 타입을 인자로 받는 메서드에 사용할 수 있다.

class Node:
    @classmethod
    def create(cls) -> Self:
        return cls()

이전에는 바인딩된 TypeVar를 사용해 같은 관계를 표현했지만 Self가 더 직접적인 표기를 제공한다.

오버로드

하나의 함수가 인자 타입이나 리터럴 값에 따라 서로 다른 반환 타입을 가지면 @overload로 여러 정적 호출 시그니처를 설명할 수 있다.^[84]

from typing import overload


@overload
def fetch(identifier: int) -> User:
    ...


@overload
def fetch(identifier: str) -> list[User]:
    ...


def fetch(identifier: int | str) -> User | list[User]:
    if isinstance(identifier, int):
        return load_user(identifier)

    return search_users(identifier)

오버로드 선언은 타입 검사기를 위한 것이며, 실제 런타임 구현은 마지막에 하나만 정의한다. Python은 같은 이름의 함수 정의를 런타임 인자 타입에 따라 자동 선택하지 않는다.

def process(value: int) -> int:
    return value + 1


def process(value: str) -> str:
    return value.upper()

이 코드는 첫 번째 함수를 오버로드로 유지하지 않고 두 번째 정의가 같은 이름을 다시 바인딩한다.

TypedDict

TypedDict는 런타임에는 일반 사전이지만, 특정 문자열 키와 값 타입을 가진 구조로 정적 분석할 수 있게 한다.^[85]

from typing import TypedDict


class UserData(TypedDict):
    name: str
    age: int
    active: bool

user: UserData = {
    "name": "Luna",
    "age": 20,
    "active": True,
}

UserData의 값은 일반 dict 객체이므로 속성 접근이 아니라 키 구독을 사용한다.

print(user["name"])

선택적인 키를 지정할 수도 있다.

from typing import NotRequired, TypedDict


class Configuration(TypedDict):
    host: str
    port: int
    token: NotRequired[str]

TypedDict는 JSON 객체, 설정 데이터와 외부 API 응답처럼 사전 형태를 유지하면서 필드 구조를 정적으로 표현하는 데 적합하다.

런타임 데이터 검증이나 자동 변환을 제공하는 것은 아니므로 외부 입력에는 별도의 검증이 필요하다.

명명된 구조와 데이터 클래스

고정된 필드를 가진 데이터는 일반 클래스, NamedTuple, 데이터 클래스와 TypedDict 등 여러 형태로 표현할 수 있다.

NamedTuple은 위치 기반 튜플이면서 이름이 있는 필드를 제공한다.

from typing import NamedTuple


class Point(NamedTuple):
    x: float
    y: float

point = Point(10.0, 20.0)

print(point.x)
print(point[0])

데이터 클래스는 일반 클래스 인스턴스에 필드 선언을 사용하고 초기화, 표현과 비교 메서드 등을 자동 생성한다.

from dataclasses import dataclass


@dataclass
class User:
    name: str
    age: int

타입 주석은 데이터 클래스가 필드를 판별하는 데도 사용되지만, 기본적으로 런타임 타입 검증을 수행하지는 않는다.

프레임워크가 데이터 클래스와 유사한 변환을 수행한다는 사실을 타입 검사기에 알리기 위해 dataclass_transform을 사용할 수 있다.^[86]

Final과 불변 의도

Final은 이름이 한 번 바인딩된 뒤 다시 대입되지 않아야 한다는 의도를 정적 타입 검사기에 전달한다.

from typing import Final


MAX_CONNECTIONS: Final = 100

MAX_CONNECTIONS = 200

타입 검사기는 재대입을 오류로 보고할 수 있지만 Python 런타임이 자동으로 막는 것은 아니다.

클래스에서 오버라이드해서는 안 되는 메서드나 클래스를 나타낼 때는 @final을 사용할 수 있다.

from typing import final


class Base:
    @final
    def identifier(self) -> str:
        return "base"

Final은 참조 대상 객체 자체의 깊은 불변성을 보장하지 않는다.

VALUES: Final = [1, 2, 3]

VALUES.append(4)

이 코드는 이름을 다른 목록에 재바인딩하지 않고 기존 목록을 변경한다. 객체 자체의 불변성이 필요하면 불변 타입이나 별도의 인터페이스를 사용해야 한다.

클래스 속성과 인스턴스 속성

타입 검사기는 클래스 속성과 인스턴스 속성을 구분할 수 있다.

from typing import ClassVar


class Connection:
    protocol: ClassVar[str] = "TCP"
    address: str

    def __init__(self, address: str) -> None:
        self.address = address

protocol은 클래스 전체에 속하는 값이고 address는 각 인스턴스에 속하는 값이다.

클래스 본문에 주석이 있는 이름이 항상 ClassVar인 것은 아니다. 데이터 클래스와 일반 타입 검사에서 주석은 인스턴스 속성 선언으로 사용될 수 있으며, 명시적인 클래스 변수에는 ClassVar를 사용할 수 있다.

타입 좁히기

타입 검사기는 조건문과 런타임 검사를 이용해 넓은 타입을 더 구체적인 타입으로 좁힐 수 있다.

def normalize(value: str | bytes) -> str:
    if isinstance(value, bytes):
        return value.decode("utf-8")

    return value

isinstance() 분기 안에서 value는 bytes, 그 이후에는 str로 좁혀질 수 있다.

None 검사도 타입 좁히기에 사용된다.

def length(value: str | None) -> int:
    if value is None:
        return 0

    return len(value)

구조적 패턴 매칭, issubclass(), 리터럴 비교와 일부 불리언 조건도 타입을 좁힐 수 있다.

복잡한 사용자 정의 검사 함수에는 TypeGuard 또는 더 정밀한 타입 좁히기 기능을 사용할 수 있다.

from typing import TypeGuard


def is_string_list(
    values: list[object],
) -> TypeGuard[list[str]]:
    return all(isinstance(value, str) for value in values)

def join_values(values: list[object]) -> str:
    if is_string_list(values):
        return ", ".join(values)

    raise TypeError("strings required")

Python 타입 체계는 타입 좁히기 규칙을 계속 확장하고 있으며, 타입 검사기 간의 공통 의미는 공식 Typing Specification에서 관리된다.

타입 단언

개발자가 검사기보다 구체적인 타입 정보를 알고 있다면 cast()로 정적 타입을 단언할 수 있다.

from typing import cast


value = load_value()
user = cast(User, value)

cast()는 런타임에 값을 변환하거나 검사하지 않으며 일반적으로 입력값을 그대로 반환한다. 실제 값이 User가 아니어도 cast() 자체는 예외를 발생시키지 않는다.

따라서 cast()는 외부 계약이나 앞선 검증으로 타입이 보장되지만 검사기가 이를 추론하지 못하는 경우에 사용한다. 타입 오류를 단순히 숨기는 용도로 남용하면 정적 분석의 신뢰성이 낮아진다.

assert를 이용하면 런타임 검증과 타입 좁히기를 함께 수행할 수 있다.

value = load_value()

assert isinstance(value, User)

value.save()

다만 최적화 옵션에서 assert 문이 제거될 수 있으므로 외부 입력 검증과 반드시 실행되어야 하는 조건 검사에는 명시적인 분기와 예외를 사용해야 한다.

전방 참조와 순환 관계

타입 표기에서 아직 정의되지 않은 클래스나 서로를 참조하는 클래스를 나타내야 할 수 있다.

class Node:
    def __init__(self, parent: "Node | None") -> None:
        self.parent = parent

문자열로 작성된 주석은 전방 참조를 표현할 수 있다.

현대 Python의 주석 평가 모델과 from __future__ import annotations 사용 여부에 따라 주석이 저장되고 평가되는 방식이 달라질 수 있다.

from __future__ import annotations


class Node:
    def __init__(self, parent: Node | None) -> None:
        self.parent = parent

정적 타입 검사기는 이러한 참조를 분석할 수 있지만, 런타임 프레임워크가 주석을 읽을 때는 주석 평가 시점과 이름 공간을 고려해야 한다.

타입 검사에만 필요한 가져오기는 TYPE_CHECKING 조건을 이용해 런타임 순환 가져오기를 피할 수 있다.

from typing import TYPE_CHECKING


if TYPE_CHECKING:
    from project.user import User


def process(user: User) -> None:
    ...

typing.TYPE_CHECKING은 정적 타입 검사 과정에서는 참으로 간주되고 일반 런타임에서는 거짓이다.

타입 스텁

타입 정보를 소스 구현과 분리하려면 .pyi 확장자의 타입 스텁 파일을 사용할 수 있다. 스텁은 함수와 클래스의 인터페이스를 선언하지만 실제 구현 코드는 포함하지 않는다.^[87]

def load_user(user_id: int) -> User: ...
def save_user(user: User) -> None: ...

타입 스텁은 다음과 같은 경우에 사용된다.

• C와 C++로 작성된 확장 모듈에 타입 정보를 제공한다.
• 기존 구현을 수정하지 않고 타입 정보를 추가한다.
• 공개 인터페이스와 내부 구현을 분리한다.
• Python 버전별 인터페이스 차이를 설명한다.

타입 검사기는 일반적으로 대응하는 .pyi 파일이 있으면 정적 분석에서 이를 우선 사용한다.

표준 라이브러리와 여러 외부 패키지의 스텁은 typeshed 프로젝트에서 관리된다. 패키지는 자체 배포본에 py.typed 표시와 인라인 타입 정보를 포함하거나 별도 스텁 패키지를 제공할 수 있다.

타입 검사 도구

Python 인터프리터 자체는 일반적인 정적 타입 검사를 수행하지 않는다. 별도의 타입 검사기나 개발 도구가 소스 코드와 타입 정보를 분석한다.

대표적인 기능은 다음과 같다.

• 함수 호출 인자와 반환 타입 검사
• 잘못된 속성 접근 탐지
• None 처리 누락 탐지
• 제네릭 타입 관계 분석
• 처리되지 않은 합집합 분기 검사
• 오버라이딩 시그니처 호환성 검사
• 코드 완성과 리팩터링 지원

타입 검사기마다 엄격성 설정, 타입 추론 범위와 일부 새 기능의 지원 시점이 다를 수 있다. Python 타입 시스템의 공통 표준은 과거에는 여러 PEP에 분산되어 있었으며, 현재는 공식 Typing Specification으로 통합해 관리한다.^[88]

타입 시스템의 변경 절차와 명세 관리는 PEP 729에 따라 Typing Council과 관련 공동체가 담당한다.^[89]

새 타입 기능은 Python의 특정 릴리스에 포함되기 전에 typing_extensions 패키지를 통해 이전 버전에서 제공되기도 한다. 공식 typing 문서도 새로운 타입 기능의 역이식 수단으로 typing_extensions를 안내한다.^[90]

런타임 검증과 정적 타입 검사의 차이

정적 타입 검사기는 프로그램을 실행하지 않고 가능한 타입 흐름을 분석한다. 런타임 검증은 실제 입력값을 실행 중에 검사한다.

def set_age(age: int) -> None:
    if age < 0:
        raise ValueError("age must not be negative")

정적 타입의 int는 문자열이나 목록이 전달되는 실수를 찾는 데 도움을 주지만, 정수가 음수인지까지 자동으로 보장하지 않는다. 값의 범위와 업무 규칙은 런타임 검증이 필요하다.

외부 JSON 데이터가 타입 주석과 같은 구조를 가진다고 가정할 수도 없다.

class UserData(TypedDict):
    name: str
    age: int

네트워크에서 받은 사전이 실제로 name과 age를 올바른 타입으로 포함하는지는 역직렬화나 검증 단계에서 확인해야 한다.

정적 타입은 개발 중의 오류 탐지와 인터페이스 문서화에 강점이 있고, 런타임 검증은 신뢰할 수 없는 입력과 동적으로 변하는 상태를 확인한다. 실제 프로그램에서는 두 방식을 함께 사용할 수 있다.

타입 힌트와 성능

타입 힌트를 추가한다고 일반적인 CPython 코드가 자동으로 기계어에 컴파일되거나 실행 속도가 빨라지는 것은 아니다. 타입 주석은 기본적으로 정적 분석과 도구를 위한 메타데이터이다.

def add(left: int, right: int) -> int:
    return left + right

인터프리터는 일반적으로 이 함수의 int 주석을 이용해 정수 전용 명령으로 자동 최적화하지 않는다.

다만 외부 컴파일러, JIT 구현체나 코드 생성 도구가 타입 정보를 별도로 활용할 수는 있다. 이는 Python 언어가 모든 구현체에 요구하는 기본 동작이 아니라 해당 도구의 기능이다.

타입 힌트는 실행 성능보다 다음 목적에 주로 사용된다.

• 함수와 클래스의 계약 표현
• 오류의 조기 발견
• 코드 탐색과 자동 완성
• 안전한 리팩터링
• 대규모 코드베이스의 경계 명확화
• 라이브러리 사용자에게 인터페이스 제공

런타임 타입과 정적 타입의 차이

Python의 런타임 클래스와 정적 타입은 밀접하지만 완전히 같은 개념은 아니다.

int, str, User 같은 클래스는 런타임 객체이면서 타입 표현에도 사용할 수 있다.

value: int = 10

print(int)
print(type(int))

반면 Any, Never, Literal, Protocol, 합집합과 일부 제네릭 표현은 정적 타입 체계에서 특별한 의미를 가진다. 이들을 일반 클래스와 같은 방식으로 인스턴스 생성이나 런타임 검사에 사용할 수 없는 경우가 있다.

from typing import Any


value = Any()

Any는 일반 인스턴스를 만드는 클래스가 아니라 타입 검사기에 동적 타입을 알리는 특수 타입 형태이다.

매개변수화된 제네릭 역시 정적 분석과 런타임 검사에서 차이가 있다.

values: list[int] = [1, 2, 3]

list[int]은 원소 타입을 정적으로 표현하지만 일반적인 목록 객체는 런타임에 각 원소가 정수인지 자동으로 강제하지 않는다.

values.append("Python")

인터프리터는 이를 허용하지만 타입 검사기는 오류로 보고할 수 있다.

또한 매개변수화된 제네릭을 그대로 isinstance()의 두 번째 인자로 사용할 수 없는 경우가 있다.

isinstance(values, list[int])

런타임에서는 list인지 확인할 수 있지만 각 원소 타입 검증은 별도의 로직이 필요하다.

타입 추론

정적 타입 검사기는 모든 타입을 명시하지 않아도 대입값과 반환식, 조건 분기를 바탕으로 일부 타입을 추론한다.

name = "Python"
count = 10
enabled = True

타입 검사기는 각각 str, int와 bool로 추론할 수 있다.

컬렉션도 원소를 바탕으로 추론할 수 있다.

numbers = [1, 2, 3]

일반적으로 list[int]로 추론할 수 있다.

빈 컬렉션이나 복잡한 분기에서는 명시적인 타입이 필요할 수 있다.

users: list[User] = []

함수의 공개 인터페이스에는 타입을 명시하고, 지역 변수는 추론에 맡기는 방식이 일반적이다. 명시 범위는 프로젝트의 엄격성, 코드 규모와 도구 설정에 따라 조정할 수 있다.

추론 결과는 검사기와 설정에 따라 일부 차이가 날 수 있으므로, 공개 API나 중요한 타입 관계에는 명시적인 주석이 더 안정적인 계약을 제공한다.

오버라이딩과 치환 가능성

하위 클래스가 상위 클래스의 메서드를 오버라이드할 때는 상위 타입을 기대하는 코드에서 계속 사용할 수 있어야 한다.

class Parser:
    def parse(self, source: str) -> object:
        ...


class JsonParser(Parser):
    def parse(self, source: str) -> dict[str, object]:
        ...

하위 클래스가 더 구체적인 반환 타입을 제공하는 것은 일반적으로 허용될 수 있다.

반면 매개변수 타입을 지나치게 좁히면 상위 타입이 허용한 호출을 하위 타입이 처리하지 못하게 된다.

class Parser:
    def parse(self, source: str) -> object:
        ...


class NarrowParser(Parser):
    def parse(self, source: JsonString) -> object:
        ...

Parser를 받는 코드가 일반 문자열을 전달할 수 있다고 기대한다면 NarrowParser는 이를 만족하지 못할 수 있다.

타입 검사기는 이러한 메서드 시그니처의 호환성을 검사해 상속 구조에서 발생하는 계약 위반을 찾을 수 있다.

타입 체계의 활용 범위

Python의 정적 타입 체계는 모든 프로젝트에 동일한 수준으로 적용해야 하는 의무적인 체계가 아니다. 짧은 개인 스크립트는 주석 없이 충분할 수 있고, 여러 팀과 모듈이 연결되는 대규모 프로젝트에서는 공개 경계의 타입 정보가 큰 가치를 제공할 수 있다.

타입 표기가 특히 유용한 영역은 다음과 같다.

• 공개 라이브러리 API
• 네트워크와 저장소 계층의 데이터 경계
• 복잡한 제네릭 컬렉션
• None 가능성이 있는 값
• 콜백과 이벤트 시스템
• 비동기 함수와 작업 결과
• 여러 구현체를 받는 프로토콜
• 대규모 리팩터링이 자주 이루어지는 코드

동적으로 생성되는 속성, 메타프로그래밍과 런타임 패치가 많은 코드는 정적 타입으로 완전히 표현하기 어려울 수 있다. 이러한 영역에서는 프로토콜, 플러그인, 스텁, Any와 사용자 정의 타입 검사기 확장 등을 조합할 수 있다.

Python의 타입 체계는 동적 실행 모델을 제거하거나 별도의 정적 Python 언어를 만드는 것이 아니라, 기존 언어 위에 분석 가능한 계약을 선택적으로 추가하는 방향으로 발전했다. 타입 정보를 사용하지 않는 코드도 계속 실행할 수 있으며, 필요한 영역에는 정교한 제네릭과 구조적 타입을 적용할 수 있다.

타입 명세의 발전

Python의 타입 힌트는 Python 3.5의 PEP 484를 중심으로 표준화되기 시작했다. 이후 변수 주석, 구조적 프로토콜, 내장 제네릭, 합집합 연산자, 매개변수 명세 변수, 가변 길이 제네릭, Self와 새로운 타입 매개변수 문법 등이 단계적으로 추가되었다.^[91]

초기의 타입 규칙은 개별 PEP의 명세 부분에 분산되어 있었다. PEP 729가 받아들여진 뒤에는 이 내용을 통합한 공식 Python Typing Specification이 타입 시스템의 현재 규칙을 관리한다.^[92]

PEP는 특정 기능이 도입된 역사와 설계 근거를 보존하지만, 이후 수정된 현재 규칙은 최신 Typing Specification을 기준으로 확인해야 한다. 타입 검사기와 라이브러리 개발자는 이 명세와 호환성 테스트를 바탕으로 공통 동작을 구현한다.

Python의 타입 체계는 언어의 동적 특성을 유지하면서도 더 많은 프로그램 구조를 정적으로 설명하는 방향으로 발전하고 있다. 모든 런타임 동작을 정적으로 완전히 증명하기보다, 실제 Python 코드에서 자주 사용되는 패턴을 표현하고 오류 가능성을 줄이는 실용적인 점진적 타입 체계를 목표로 한다.