# 3. 데이터 모델

## 3.1. 객체, 값, 형

객체 (Objects)는 파이썬이 데이터(data)를 추상화한 것(abstraction)입니다. 파이썬 프로그램의 모든 데이터는 객체나 객체 간의 관계로 표현됩니다. (폰 노이만(Von Neumann)의 “프로그램 내장식 컴퓨터(stored program computer)” 모델을 따르고, 또 그 관점에서 코드 역시 객체로 표현됩니다.)

모든 객체는 아이덴티티(identity), 형(type), 값(value)을 갖습니다. 객체의 아이덴티티 는 한 번 만들어진 후에는 변경되지 않습니다. 메모리상에서의 객체의 주소로 생각해도 좋습니다. ‘`is`’ 연산자는 두 객체의 아이덴티티를 비교합니다; `id()` 함수는 아이덴티티를 정수로 표현한 값을 돌려줍니다.

CPython 구현 상세: CPython 의 경우, `id(x)` 는 `x` 가 저장된 메모리의 주소입니다.

객체의 형은 객체가 지원하는 연산들을 정의하고 (예를 들어, “길이를 갖고 있나?”) 그 형의 객체들이 가질 수 있는 가능한 값들을 정의합니다. `type()` 함수는 객체의 형(이것 역시 객체다)을 돌려줍니다. 아이덴티티와 마찬가지로, 객체의 형 (type) 역시 변경되지 않습니다. 1

어떤 객체들의 값 은 변경할 수 있습니다. 값을 변경할 수 있는 객체들을 가변(mutable) 이라고 합니다. 일단 만들어진 후에 값을 변경할 수 없는 객체들을 불변(immutable) 이라고 합니다. (가변 객체에 대한 참조를 저장하고 있는 불변 컨테이너의 값은 가변 객체의 값이 변할 때 변경된다고 볼 수도 있습니다; 하지만 저장하고 있는 객체들의 집합이 바뀔 수 없으므로 컨테이너는 여전히 불변이라고 여겨집니다. 따라서 불변성은 엄밀하게는 변경 불가능한 값을 갖는 것과는 다릅니다. 좀 더 미묘합니다.) 객체의 가변성(mutability)은 그것의 형에 의해 결정됩니다; 예를 들어 숫자, 문자열, 튜플(tuple)은 불변이지만, 딕셔너리(dictionary) 와 리스트(list)는 가변입니다.

객체는 결코 명시적으로 파괴되지 않습니다; 더 참조되지 않을 때(unreachable) 가비지 수거(garbage collect)됩니다. 구현이 가비지 수거를 지연시키거나 아예 생략하는 것이 허락됩니다 — 아직 참조되는 객체들을 수거하지 않는 이상 가비지 수거가 어떤 식으로 구현되는지는 구현의 품질 문제입니다.

CPython 구현 상세: CPython 은 현재 참조 횟수 계산(reference-counting) 방식을 사용하는데, (선택 사항으로) 순환적으로 연결된 가비지의 지연된 감지가 추가됩니다. 이 방법으로 대부분 객체를 참조가 제거되자마자 수거할 수 있습니다. 하지만 순환 참조가 있는 가비지들을 수거한다는 보장은 없습니다. 순환적 가비지 수거의 제어에 관한 정보는 `gc` 모듈 문서를 참조하면 됩니다. 다른 구현들은 다른 식으로 동작하고, CPython 도 변경될 수 있습니다. 참조가 제거될 때 즉각적으로 파이널리제이션(finalization)되는 것에 의존하지 말아야 합니다 (그래서 항상 파일을 명시적으로 닫아주어야 합니다).

구현이 제공하는 추적이나 디버깅 장치의 사용은 그렇지 않으면 수거될 수 있는 객체들을 살아있도록 만들 수 있음에 주의해야 합니다. 또한 ‘`try`…`except`’ 문으로 예외를 잡는 것도 객체를 살아있게 만들 수 있습니다.

어떤 객체들은 열린 파일이나 창 같은 “외부(external)” 자원들에 대한 참조를 포함합니다. 이 자원들은 객체가 가비지 수거될 때 반납된다고 이해되지만, 가비지 수거는 보장되는 것이 아니므로, 그런 객체들은 외부자원을 반납하는 명시적인 방법 또한 제공합니다. 보통 `close()` 메서드다. 프로그램을 작성할 때는 그러한 객체들을 항상 명시적으로 닫아야(close) 합니다. ‘`try`…`finally`’ 문과 ‘`with`’ 문은 이렇게 하는 편리한 방법을 제공합니다.

어떤 객체들은 다른 객체에 대한 참조를 포함하고 있습니다. 이런 것들을 컨테이너(container) 라고 부릅니다. 튜플, 리스트, 딕셔너리등이 컨테이너의 예입니다. 이 참조들은 컨테이너의 값의 일부입니다. 대부분은, 우리가 컨테이너의 값을 논할 때는, 들어있는 객체들의 아이덴티티 보다는 값을 따집니다. 하지만, 컨테이너의 가변성에 대해 논할 때는 직접 가진 객체들의 아이덴티티만을 따집니다. 그래서, (튜플 같은) 불변 컨테이너가 가변 객체로의 참조를 하고 있다면, 그 가변 객체가 변경되면 컨테이너의 값도 변경됩니다.

형은 거의 모든 측면에서 객체가 동작하는 방법에 영향을 줍니다. 객체의 아이덴티디가 갖는 중요성조차도 어떤 면에서는 영향을 받습니다: 불변형의 경우, 새 값을 만드는 연산은 실제로는 이미 존재하는 객체 중에서 같은 형과 값을 갖는 것을 돌려줄 수 있습니다. 반면에 가변 객체에서는 이런 것이 허용되지 않습니다. 예를 들어, `a = 1; b = 1` 후에, `a` 와 `b` 는 값 1을 갖는 같은 객체일 수도 있고, 아닐 수도 있습니다. 하지만 `c = []; d = []` 후에, `c` 와 `d` 는 두 개의 서로 다르고, 독립적이고, 새로 만들어진 빈 리스트임이 보장됩니다. (`c = d = []` 는 객은 객체를 `c` 와 `d` 에 대입합니다.)

## 3.2. 표준형 계층

아래에 파이썬에 내장된 형들의 목록이 있습니다. (구현에 따라 C 나 자바나 다른 언어로 작성된) 확장 모듈들은 추가의 형을 정의할 수 있습니다. 파이썬의 미래 버전 역시 형 계층에 형을 더할 수 있는데 (예를 들어, 유리수, 효율적으로 저장된 정수 배열 등등), 표준 라이브러리를 통해 추가될 가능성이 더 크기는 합니다.

아래에 나오는 몇몇 형에 대한 설명은 ‘특수 어트리뷰트(special attribute)’ 를 나열하는 문단을 포함합니다. 이것들은 구현에 접근할 방법을 제공하는데, 일반적인 사용을 위한 것이 아닙니다. 정의는 앞으로 변경될 수 있습니다.

None

  이 형은 하나의 값만을 갖습니다. 이 값을 갖는 하나의 객체가 존재합니다. 이 객체에는 내장된 이름 `None` 을 통해 접근합니다. 여러 가지 상황에서 값의 부재를 알리는 데 사용됩니다. 예를 들어, 명시적으로 뭔가를 돌려주지 않는 함수의 반환 값입니다. 논리값은 거짓입니다.

NotImplemented

  이 형은 하나의 값만을 갖습니다. 이 값을 갖는 하나의 객체가 존재합니다. 이 객체에는 내장된 이름 `NotImplemented` 을 통해 접근합니다. 숫자 메서드(numeric method)와 비교(rich comparison) 메서드는 제공된 피연산자에 대해 연산이 구현되지 않으면 이 값을 돌려줘야 합니다. (그러면 인터프리터는 연산자에 따라 뒤집힌 연산이나, 어떤 다른 대안을 시도합니다.) 불리언 문맥에서 평가되지 않아야 합니다.

  더 자세한 내용은 산술 연산 구현 을 참고하십시오.

  버전 3.9에서 변경: 불리언 문맥에서 `NotImplemented`를 평가하는 것은 폐지되었습니다. 현재는 참으로 평가되지만, `DeprecationWarning`를 방출합니다. 향후 버전의 파이썬에서는 `TypeError`를 발생시킬 것입니다.

Ellipsis

  이 형은 하나의 값만을 갖습니다. 이 값을 갖는 하나의 객체가 존재합니다. 이 객체에는 리터럴 `...` 이나 내장된 이름 `Ellipsis` 을 통해 접근합니다. 논리값은 참입니다.

`numbers.Number`

  이것들은 숫자 리터럴에 의해 만들어지고, 산술 연산과 내장 산술 함수들이 결과로 돌려줍니다. 숫자 객체는 불변입니다; 한 번 값이 만들어지면 절대 변하지 않습니다. 파이썬의 숫자는 당연히 수학적인 숫자들과 밀접하게 관련되어 있습니다, 하지만 컴퓨터의 숫자 표현상의 제약을 받고 있습니다.

  The string representations of the numeric classes, computed by `__repr__()` and `__str__()`, have the following properties:

  - 클래스 생성자에 전달될 때 원래 숫자 값을 가진 객체를 생성하는 유효한 숫자 리터럴 입니다.

  - 가능하면, 표현은 10진법입니다.

  - 소수점 앞의 단일 0을 제외하고, 선행 0은 표시되지 않습니다.

  - 소수점 뒤의 단일 0을 제외하고, 후행 0은 표시되지 않습니다.

  - 부호는 숫자가 음수일 때만 표시됩니다.

  파이썬은 정수, 실수, 복소수를 구분합니다:

  `numbers.Integral`

    이것들은 수학적인 정수 집합(양과 음)에 속하는 요소들을 나타냅니다.

    두 가지 종류의 정수가 있습니다:

    정수 (`int`)

      이것은 (가상) 메모리가 허락하는 한, 제약 없는 범위의 숫자를 표현합니다. 시프트(shift)와 마스크(mask) 연산이 목적일 때는 이진 표현이 가정되고, 음수는 일종의 2의 보수(2’s complement)로 표현되는데, 부호 비트가 왼쪽으로 무한히 확장된 것과 같은 효과를 줍니다.

    불린 (`bool`)

      이것은 논리값 거짓과 참을 나타냅니다. `False` 와 `True` 두 객체만 불린 형 객체입니다. 불린 형은 int 형의 자식형(subtype)이고, 대부분 상황에서 각기 0과1처럼 동작합니다. 예외는 문자열로 변환되는 경우인데, 각기 문자열 `"False"` 와 `"True"` 가 반환됩니다.

    정수 표현 규칙은 음수가 포함된 시프트와 마스크 연산에 가장 의미 있는 해석을 제공하기 위한 것입니다.

  `numbers.Real` (`float`)

    이것들은 기계 수준의 배정도(double precision) 부동 소수점 수를 나타냅니다. 허락되는 값의 범위와 오버플로의 처리에 관해서는 하부 기계의 설계(와 C 나 자바 구현)에 따르는 수밖에 없습니다. 파이썬은 단정도(single precision) 부동 소수점 수를 지원하지 않습니다; 이것들을 사용하는 이유가 되는 프로세서와 메모리의 절감은 파이썬에서 객체를 사용하는데 들어가는 비용과 상쇄되어 미미해집니다. 그 때문에 두 가지 종류의 부동 소수점 수로 언어를 복잡하게 만들만한 가치가 없습니다.

  `numbers.Complex` (`complex`)

    이것들은 기계 수준 배정도 부동 소수점 수의 쌍으로 복소수를 나타냅니다. 부동 소수점 수와 한계와 문제점을 공유합니다. 복소수 `z` 의 실수부와 허수부는, 읽기 전용 어트리뷰트 `z.real` 와 `z.imag` 로 꺼낼 수 있습니다.

시퀀스들

  음이 아닌 정수로 인덱싱(indexing)될 수 있는 유한한 길이의 순서 있는 집합을 나타냅니다. 내장함수 `len()` 은 시퀀스가 가진 항목들의 개수를 돌려줍니다. 시퀀스의 길이가 n 일 때, 인덱스(index) 집합은 숫자 0, 1, …, n-1을 포함합니다. 시퀀스 a 의 항목 i 는 `a[i]` 로 선택됩니다.

  시퀀스는 슬라이싱도 지원합니다: `a[i:j]` 는 i `<=` k `<` j 를 만족하는 모든 항목 k 를 선택합니다. 표현식에서 사용될 때, 슬라이스는 같은 형의 시퀀스입니다. 인덱스 집합은 0에서 시작되도록 다시 번호 매겨집니다.

  어떤 시퀀스는 세 번째 “스텝(step)” 매개변수를 사용하는 “확장 슬라이싱(extended slicing)”도 지원합니다: `a[i:j:k]` 는 `x = i + n*k`, n `>=` `0`, i `<=` x `<` j 를 만족하는 모든 항목 x 를 선택합니다.

  시퀀스는 불변성에 따라 구분됩니다

  불변 시퀀스

    불변 시퀀스 형의 객체는 일단 만들어진 후에는 변경될 수 없습니다. (만약 다른 객체로의 참조를 포함하면, 그 객체는 가변일 수 있고, 변경될 수 있습니다; 하지만, 불변 객체로부터 참조되는 객체의 집합 자체는 변경될 수 없습니다.)

    다음과 같은 형들은 불변 시퀀스입니다:

    문자열(Strings)

      A string is a sequence of values that represent Unicode code points. All the code points in the range `U+0000 - U+10FFFF` can be represented in a string. Python doesn’t have a `char` type; instead, every code point in the string is represented as a string object with length `1`. The built-in function `ord()` converts a code point from its string form to an integer in the range `0 - 10FFFF`; `chr()` converts an integer in the range `0 - 10FFFF` to the corresponding length `1` string object. `str.encode()` can be used to convert a `str` to `bytes` using the given text encoding, and `bytes.decode()` can be used to achieve the opposite.

    튜플(Tuples)

      튜플의 항목은 임의의 파이썬 객체입니다. 두 개 이상의 항목으로 구성되는 튜플은 콤마로 분리된 표현식의 목록으로 만들 수 있습니다. 하나의 항목으로 구성된 튜플(싱글턴,singleton)은 표현식에 콤마를 붙여서 만들 수 있습니다(괄호로 표현식을 묶을 수 있으므로, 표현식 만으로는 튜플을 만들지 않습니다). 빈 튜플은 한 쌍의 빈 괄호로 만들 수 있습니다.

    바이트열(Bytes)

      바이트열(bytes) 객체는 불변 배열입니다. 항목은 8-비트 바이트인데, 0 <= x < 256 범위의 정수로 표현됩니다. 바이트 객체를 만들 때는 바이트열 리터럴(`b'abc'` 와 같은) 과 내장 `bytes()` 생성자(constructor)를 사용할 수 있습니다. 또한, 바이트열 객체는 `decode()` 메서드를 통해 문자열로 디코딩될 수 있습니다.

  가변 시퀀스

    가변 시퀀스는 만들어진 후에 변경될 수 있습니다. 서브스크립션(subscription)과 슬라이싱은 대입문과 `del` (삭제) 문의 대상으로 사용될 수 있습니다.

    현재 두 개의 내장 가변 시퀀스형이 있습니다:

    리스트(Lists)

      리스트의 항목은 임의의 파이썬 객체입니다. 리스트는 콤마로 분리된 표현식을 대괄호 안에 넣어서 만들 수 있습니다. (길이 0이나 1의 리스트를 만드는데 별도의 규칙이 필요 없습니다.)

    바이트 배열(Byte Arrays)

      바이트 배열(bytearray) 객체는 가변 배열입니다. 내장 `bytearray()` 생성자로 만들어집니다. 가변이라는 것(그래서 해싱 불가능하다는 것)을 제외하고, 바이트 배열은 불변 바이트열( `bytes`) 객체와 같은 인터페이스와 기능을 제공합니다.

    확장 모듈 `array` 는 추가의 가변 시퀀스 형을 제공하는데, `collections` 모듈 역시 마찬가지입니다.

집합 형들(Set types)

  이것들은 중복 없는 불변 객체들의 순서 없고 유한한 집합을 나타냅니다. 인덱싱할 수 없습니다. 하지만 이터레이트할 수 있고, 내장 함수 `len()` 은 집합 안에 있는 항목들의 개수를 돌려줍니다. 집합의 일반적인 용도는 빠른 멤버십 검사(fast membership testing), 시퀀스에서 중복된 항목 제거, 교집합(intersection), 합집합(union), 차집합(difference), 대칭차집합(symmetric difference)과 같은 집합 연산을 계산하는 것입니다.

  집합의 원소들에는 딕셔너리 키와 같은 불변성 규칙이 적용됩니다. 숫자 형의 경우는 숫자 비교에 관한 일반 원칙이 적용된다는 점에 주의해야 합니다: 만약 두 숫자가 같다고 비교되면(예를 들어, `1` 과 `1.0`), 그중 하나만 집합에 들어갈 수 있습니다.

  현재 두 개의 내장 집합 형이 있습니다:

  집합(Sets)

    이것들은 가변 집합을 나타냅니다. 내장 `set()` 생성자로 만들 수 있고, `add()` 같은 메서드들을 사용해서 나중에 수정할 수 있습니다.

  불변 집합(Frozen sets)

    이것들은 불변 집합을 나타냅니다. 내장 `frozenset()` 생성자로 만들 수 있습니다. 불변 집합(frozenset)은 불변이고 해시 가능 하므로, 다른 집합의 원소나, 딕셔너리의 키로 사용될 수 있습니다.

매핑(Mappings)

  이것들은 임의의 인덱스 집합으로 인덱싱되는 객체들의 유한한 집합을 나타냅니다. 인덱스 표기법(subscript notation) `a[k]` 는 매핑 `a` 에서 `k` 로 인덱스 되는 항목을 선택합니다; 이것은 표현식에 사용될 수도 있고, 대입이나 `del` 문장의 대상이 될 수도 있습니다. 내장 함수 `len()` 은 매핑에 포함된 항목들의 개수를 돌려줍니다.

  현재 한 개의 내장 매핑 형이 있습니다:

  딕셔너리(Dictionaries)

    이것들은 거의 임의의 인덱스 집합으로 인덱싱되는 객체들의 유한한 집합을 나타냅니다. 키로 사용할 수 없는 것들은 리스트, 딕셔너리나 그 외의 가변형 중에서 아이덴티티가 아니라 값으로 비교되는 것들뿐입니다. 딕셔너리의 효율적인 구현이, 키의 해시값이 도중에 변경되지 않고 계속 같은 값으로 유지되도록 요구하고 있기 때문입니다. 키로 사용되는 숫자 형의 경우는 숫자 비교에 관한 일반 원칙이 적용됩니다: 만약 두 숫자가 같다고 비교되면(예를 들어, `1` 과 `1.0`), 둘 다 같은 딕셔너리 항목을 인덱싱하는데 사용될 수 있습니다.

    딕셔너리는 삽입 순서를 유지합니다, 키가 딕셔너리에 순차적으로 추가된 순서와 같은 순서로 생성됨을 뜻합니다. 기존 키를 교체해도 순서는 변경되지 않지만, 키를 제거했다가 다시 삽입하면 이전 위치를 유지하는 대신 끝에 추가됩니다.

    딕셔너리는 가변입니다; `{...}` 표기법으로 만들 수 있습니다 (딕셔너리 디스플레이 섹션을 참고하십시오).

    확장 모듈 `dbm.ndbm` 과 `dbm.gnu` 는 추가의 매핑 형을 제공하는데, `collections` 모듈 역시 마찬가지입니다.

    버전 3.7에서 변경: 딕셔너리는 3.6 이전의 파이썬 버전에서 삽입 순서를 유지하지 않았습니다. CPython 3.6에서, 삽입 순서가 유지되었지만, 그 시점에는 언어 보증이 아니라 구현 세부 사항으로 간주하였습니다.

콜러블(Callable types)

  이것들은 함수 호출 연산(호출 섹션 참고)이 적용될 수 있는 형들입니다:

  사용자 정의 함수

    사용자 정의 함수 객체는 함수 정의를 통해 만들어집니다 (함수 정의 섹션 참고). 함수의 형식 매개변수(formal parameter) 목록과 같은 개수의 항목을 포함하는 인자(argument) 목록으로 호출되어야 합니다.

    특수 어트리뷰트들(Special attributes):

    어트리뷰트 | 의미 |
    --- | --- | ---
    `__doc__` | 함수를 설명하는 문자열 또는 없는 경우 `None`; 서브 클래스로 상속되지 않습니다. | 쓰기 가능
    `__name__` | 함수의 이름. | 쓰기 가능
    `__qualname__` | 함수의 정규화된 이름. 버전 3.3에 추가. | 쓰기 가능
    `__module__` | 함수가 정의된 모듈의 이름 또는 (없는 경우) `None` | 쓰기 가능
    `__defaults__` | 인자의 기본값 또는 (없는 경우) None 으로 만들어진 튜플. | 쓰기 가능
    `__code__` | 컴파일된 함수의 바디(body) 를 나타내는 코드 객체 | 쓰기 가능
    `__globals__` | 함수의 전역 변수들을 가진 딕셔너리에 대한 참조 — 함수가 정의된 모듈의 전역 이름 공간(namespace) | 읽기 전용
    `__dict__` | 임의의 함수 어트리뷰트를 지원하는 이름 공간. | 쓰기 가능
    `__closure__` | `None` 또는 함수의 자유 변수(free variable)들에 대한 연결을 가진 셀(cell)들의 튜플. `cell_contents` 어트리뷰트에 대한 정보는 아래를 보십시오. | 읽기 전용
    `__annotations__` | A dict containing annotations of parameters. The keys of the dict are the parameter names, and `'return'` for the return annotation, if provided. For more information on working with this attribute, see Annotations Best Practices. | 쓰기 가능
    `__kwdefaults__` | 키워드 형태로만 전달 가능한 매개변수들의 기본값을 가진 dict. | 쓰기 가능

    “쓰기 가능” 하다고 표시된 대부분의 어트리뷰트들은 값이 대입될 때 형을 검사합니다.

    함수 객체는 임의의 어트리뷰트를 읽고 쓸 수 있도록 지원하는데, 예를 들어 함수에 메타데이터(metadata)를 붙이는데 사용될 수 있습니다. 어트리뷰트를 읽거나 쓸 때는 일반적인 점 표현법(dot-notation)이 사용됩니다. 현재 구현은 오직 사용자 정의 함수만 함수 어트리뷰트를 지원함에 주의해야 합니다. 내장 함수의 함수 어트리뷰트는 미래에 지원될 수 있습니다.

    셀 객체는 `cell_contents` 어트리뷰트를 가지고 있습니다. 셀의 값을 읽을 뿐만 아니라 값을 설정하는 데도 사용할 수 있습니다.

    함수 정의에 관한 추가적인 정보를 코드 객체로부터 얻을 수 있습니다. 아래에 나오는 내부 형의 기술을 참고하십시오. `셀` 형은 `types` 모듈에서 액세스할 수 있습니다.

  인스턴스 메서드(Instance methods)

    인스턴스 메서드는 클래스, 클래스 인스턴스와 모든 콜러블 객체 (보통 사용자 정의 함수)을 결합합니다.

    특수 읽기 전용 어트리뷰트들: `__self__` 는 클래스 인스턴스 객체, `__func__` 는 함수 객체; `__doc__` 은 메서드의 설명 (`__func__.__doc__` 과 같습니다); `__name__` 은 메서드의 이름 (`__func__.__name__` 과 같습니다); `__module__` 은 메서드가 정의된 모듈의 이름이거나 없는 경우 `None`.

    메서드는 기반 함수의 모든 함수 어트리뷰트들을 읽을 수 있도록 지원합니다(하지만 쓰기는 지원하지 않습니다).

    어트리뷰트가 사용자 정의 함수 객체이거나 클래스 메서드 객체면, 사용자 정의 메서드 객체는 클래스의 어트리뷰트를 읽을 때 만들어질 수 있습니다 (아마도 그 클래스의 인스턴스를 통해서).

    인스턴스 메서드 객체가 클래스 인스턴스를 통해 클래스의 사용자 정의 함수 객체를 읽음으로써 만들어질 때, `__self__` 어트리뷰트는 인스턴스이고, 메서드 객체는 결합(bound)하였다고 말합니다. 새 메서드의 `__func__` 어트리뷰트는 원래의 함수 객체입니다.

    인스턴스 메서드 객체가 클래스나 인스턴스로부터 클래스 메서드 객체를 읽음으로써 만들어질 때, `__self__` 어트리뷰트는 클래스 자신이고, `__func__` 어트리뷰트는 클래스 메서드가 기반을 두는 함수 객체입니다.

    인스턴스 메서드 객체가 호출될 때, 기반을 두는 함수 (`__func__`) 가 호출되는데, 인자 목록의 앞에 클래스 인스턴스 (`__self__`) 가 삽입됩니다. 예를 들어, `C` 가 함수 `f()` 의 정의를 포함하는 클래스이고, `x` 가 `C` 의 인스턴스일 때, `x.f(1)` 를 호출하는 것은 `C.f(x, 1)` 을 호출하는 것과 같습니다.

    인스턴스 메서드 객체가 클래스 메서드 객체로부터 올 때, `__self__` 에 저장된 “클래스 인스턴스” 는 실제로는 클래스 자신입니다. 그래서 `x.f(1)` 이나 `C.f(1)` 을 호출하는 것은 `f(C,1)` 를 호출하는 것과 같습니다 (`f` 는 기반 함수입니다).

    함수 객체에서 인스턴스 객체로의 변환은 인스턴스로부터 어트리뷰트를 읽을 때마다 일어남에 주의해야 합니다. 어떤 경우에, 어트리뷰트를 지역 변수에 대입하고, 그 지역 변수를 호출하는 것이 효과적인 최적화가 됩니다. 또한, 이 변환이 사용자 정의 함수에 대해서만 발생함에 주의해야 합니다; 다른 콜러블 객체 (그리고 콜러블이 아닌 모든 객체)는 변환 없이 읽힙니다. 클래스 인스턴스의 어트리뷰트인 사용자 정의 함수는 결합한 메서드로 변환되지 않는다는 것도 중요합니다; 이 변환은 함수가 클래스 어트리뷰트일 때만 일어납니다.

  제너레이터 함수(Generator functions)

    A function or method which uses the `yield` statement (see section yield 문) is called a generator function. Such a function, when called, always returns an iterator object which can be used to execute the body of the function: calling the iterator’s `iterator.__next__()` method will cause the function to execute until it provides a value using the `yield` statement. When the function executes a `return` statement or falls off the end, a `StopIteration` exception is raised and the iterator will have reached the end of the set of values to be returned.

  코루틴 함수(Coroutine functions)

    `async def` 를 사용해서 정의되는 함수나 메서드를 코루틴 함수 (coroutine function) 라고 부릅니다. 이런 함수를 호출하면 코루틴 객체를 돌려줍니다. `await` 표현식을 비롯해, `async with` 와 `async for` 문을 사용할 수 있습니다. 코루틴 객체(Coroutine Objects) 섹션을 참조하십시오.

  비동기 제너레이터 함수(Asynchronous generator functions)

    A function or method which is defined using `async def` and which uses the `yield` statement is called a asynchronous generator function. Such a function, when called, returns an asynchronous iterator object which can be used in an `async for` statement to execute the body of the function.

    Calling the asynchronous iterator’s `aiterator.__anext__` method will return an awaitable which when awaited will execute until it provides a value using the `yield` expression. When the function executes an empty `return` statement or falls off the end, a `StopAsyncIteration` exception is raised and the asynchronous iterator will have reached the end of the set of values to be yielded.

  내장 함수(Built-in functions)

    내장 함수 객체는 C 함수를 둘러싸고 있습니다(wrapper). 내장 함수의 예로는 `len()` 과 `math.sin()` (`math` 는 표준 내장 모듈입니다) 가 있습니다. 인자의 개수와 형은 C 함수에 의해 결정됩니다. 특수 읽기 전용 어트리뷰트들: `__doc__` 은 함수의 설명 문자열 또는 없는 경우 `None` 입니다; `__name__` 은 함수의 이름입니다; `__self__` 는 `None` 으로 설정됩니다 (하지만 다음 항목을 보십시오); `__module__` 은 함수가 정의된 모듈의 이름이거나 없는 경우 `None` 입니다.

  내장 메서드(Built-in methods)

    이것은 사실 내장 함수의 다른 모습입니다. 이번에는 묵시적인 추가의 인자로 C 함수에 전달되는 객체를 갖고 있습니다. 내장 메서드의 예로는 `alist.append()` 가 있는데, alist 는 리스트 객체입니다. 이 경우에, 특수 읽기 전용 어트리뷰트 `__self__` 는 alist 로 표현된 객체로 설정됩니다.

  클래스(Classes)

    Classes are callable. These objects normally act as factories for new instances of themselves, but variations are possible for class types that override `__new__()`. The arguments of the call are passed to `__new__()` and, in the typical case, to `__init__()` to initialize the new instance.

  클래스 인스턴스(Class Instances)

    Instances of arbitrary classes can be made callable by defining a `__call__()` method in their class.

모듈(Modules)

  모듈은 파이썬 코드의 기본적인 조직화 단위이고, `import` 문이나, `importlib.import_module()` 과 내장 `__import__()` 함수를 호출해서 구동할 수 있는 임포트 시스템 에 의해 만들어집니다. 모듈 객체는 딕셔너리 객체로 구현되는 이름 공간을 갖습니다(이 딕셔너리 객체는 모듈에서 정의되는 함수들의 `__globals__` 어트리뷰트로 참조됩니다). 어트리뷰트 참조는 이 딕셔너리에 대한 조회로 변환됩니다. 예를 들어, `m.x` 는 `m.__dict__["x"]` 와 같습니다. 모듈 객체는 모듈을 초기화하는데 사용된 코드 객체를 갖고 있지 않습니다 (일단 초기화가 끝나면 필요 없으므로).

  어트리뷰트 대입은 모듈의 이름 공간 딕셔너리를 갱신합니다. 예를 들어, `m.x = 1` 은 `m.__dict__["x"] = 1` 과 같습니다.

  Predefined (writable) attributes:

  > `__name__`

  >   The module’s name.

  > `__doc__`

  >   The module’s documentation string, or `None` if unavailable.

  > `__file__`

  >   The pathname of the file from which the module was loaded, if it was loaded from a file. The `__file__` attribute may be missing for certain types of modules, such as C modules that are statically linked into the interpreter. For extension modules loaded dynamically from a shared library, it’s the pathname of the shared library file.

  > `__annotations__`

  >   A dictionary containing variable annotations collected during module body execution. For best practices on working with `__annotations__`, please see Annotations Best Practices.

  특수 읽기 전용 어트리뷰트들: `__dict__` 는 딕셔너리로 표현되는 모듈의 이름 공간입니다.

  CPython 구현 상세: CPython 이 모듈 딕셔너리를 비우는 방법 때문에, 딕셔너리에 대한 참조가 남아있더라도, 모듈이 스코프를 벗어나면 모듈 딕셔너리는 비워집니다. 이것을 피하려면, 딕셔너리를 복사하거나 딕셔너리를 직접 이용하는 동안은 모듈을 잡아두어야 합니다.

사용자 정의 클래스(Custom classes)

  사용자 정의 클래스 형들은 보통 클래스 정의 때문에 만들어집니다 (클래스 정의 섹션 참조). 클래스는 딕셔너리로 구현된 이름 공간을 갖습니다. 클래스 어트리뷰트 참조는 이 딕셔너리에 대한 조회로 변환됩니다. 예를 들어, `C.x` 는 `C.__dict__["x"]` 로 변환됩니다 (하지만 어트리뷰트에 접근하는 다른 방법들을 허락하는 여러 가지 훅(hook)이 있습니다.). 거기에서 어트리뷰트 이름이 발견되지 않으면, 어트리뷰트 검색은 부모 클래스들에서 계속됩니다. 이 부모 클래스 검색은 C3 메서드 결정 순서(method resolution order)를 사용하는데, 다중 상속이 같은 부모 클래스로 모이는 ‘다이아몬드(diamond)’ 계승 구조가 존재해도 올바르게 동작합니다. 파이썬이 사용하는 C3 MRO에 관한 좀 더 자세한 내용은 2.3 배포에 첨부된 문서 https://www.python.org/download/releases/2.3/mro/ 에서 찾아볼 수 있습니다.

  클래스 어트리뷰트 참조가 (클래스 `C` 라고 하자) 클래스 메서드 객체로 귀결될 때는, `__self__` 어트리뷰트가 `C` 인 인스턴스 메서드 객체로 변환됩니다. 스태틱 메서드로 귀결될 때는, 스태틱 메서드 객체가 감싸고 있는 객체로 변환됩니다. 클래스로부터 얻은 어트리뷰트가 `__dict__` 에 저장된 값과 달라지도록 만드는 다른 방법이 디스크립터 구현하기 섹션에 나옵니다.

  클래스 어트리뷰트 대입은 클래스의 딕셔너리를 갱신할 뿐, 어떤 경우도 부모 클래스의 딕셔너리를 건드리지는 않습니다.

  클래스 객체는 클래스 인스턴스를 돌려주도록(아래를 보십시오) 호출될 수 있습니다(위를 보십시오).

  특수 어트리뷰트들(Special attributes):

  > `__name__`

  >   The class name.

  > `__module__`

  >   The name of the module in which the class was defined.

  > `__dict__`

  >   The dictionary containing the class’s namespace.

  > `__bases__`

  >   A tuple containing the base classes, in the order of their occurrence in the base class list.

  > `__doc__`

  >   The class’s documentation string, or `None` if undefined.

  > `__annotations__`

  >   A dictionary containing variable annotations collected during class body execution. For best practices on working with `__annotations__`, please see Annotations Best Practices.

클래스 인스턴스(Class instances)

  A class instance is created by calling a class object (see above). A class instance has a namespace implemented as a dictionary which is the first place in which attribute references are searched. When an attribute is not found there, and the instance’s class has an attribute by that name, the search continues with the class attributes. If a class attribute is found that is a user-defined function object, it is transformed into an instance method object whose `__self__` attribute is the instance. Static method and class method objects are also transformed; see above under “Classes”. See section 디스크립터 구현하기 for another way in which attributes of a class retrieved via its instances may differ from the objects actually stored in the class’s `__dict__`. If no class attribute is found, and the object’s class has a `__getattr__()` method, that is called to satisfy the lookup.

  Attribute assignments and deletions update the instance’s dictionary, never a class’s dictionary. If the class has a `__setattr__()` or `__delattr__()` method, this is called instead of updating the instance dictionary directly.

  어떤 특별한 이름들의 메서드들을 가지면, 클래스 인스턴스는 숫자, 시퀀스, 매핑인 척할 수 있습니다. 특수 메서드 이름들 섹션을 보십시오.

  특수 어트리뷰트들: `__dict__` 는 어트리뷰트 딕셔너리입니다; `__class__` 는 인스턴스의 클래스입니다.

I/O 객체 (파일 객체라고도 알려져 있습니다)

  파일 객체 는 열린 파일을 나타냅니다. 파일 객체를 만드는 여러 가지 단축법이 있습니다: `open()` 내장 함수, `os.popen()`, `os.fdopen()` 과 소켓 객체의 `makefile()` 메서드 (그리고, 아마도 확장 모듈들이 제공하는 다른 함수들이나 메서드들).

  `sys.stdin`, `sys.stdout`, `sys.stderr` 는 인터프리터의 표준 입력, 출력, 에러 스트림으로 초기화된 파일 객체들입니다; 모두 텍스트 모드로 열려서 `io.TextIOBase` 추상 클래스에 의해 정의된 인터페이스를 따릅니다.

내부 형(Internal types)

  인터프리터가 내부적으로 사용하는 몇몇 형들은 사용자에게 노출됩니다. 인터프리터의 미래 버전에서 이들의 정의는 변경될 수 있지만, 완전함을 위해 여기서 언급합니다.

  코드 객체(Code objects)

    코드 객체는 바이트로 컴파일된(byte-compiled) 실행 가능한 파이썬 코드를 나타내는데, 그냥 바이트 코드 라고도 부릅니다. 코드 객체와 함수 객체 간에는 차이가 있습니다; 함수 객체는 함수의 전역 공간(globals) (함수가 정의된 모듈)을 명시적으로 참조하고 있지만, 코드 객체는 어떤 문맥(context)도 갖고 있지 않습니다; 또한 기본 인자값들이 함수 객체에 저장되어 있지만 코드 객체에는 들어있지 않습니다 (실행 시간에 계산되는 값들을 나타내기 때문입니다). 함수 객체와는 달리, 코드 객체는 불변이고 가변 객체들에 대한 어떤 참조도 (직접 혹은 간접적으로도) 갖고 있지 않습니다.

    특수 읽기 전용 어트리뷰트들: `co_name` 은 함수의 이름입니다; `co_argcount` 는 위치 인자들 (위치 전용 인자와 기본값이 있는 인자들도 포함됩니다)의 총 개수입니다; `co_posonlyargcount` 는 위치 전용 인자들 (기본값이 있는 인자들도 포함됩니다)의 개수입니다; `co_kwonlyargcount` 는 키워드 전용 인자들 (기본값이 있는 인자들도 포함됩니다)의 개수입니다; `co_nlocals` 는 함수가 사용하는 지역 변수들 (인자들을 포함합니다)의 개수입니다; `co_varnames` 는 지역 변수들의 이름을 담고 있는 튜플입니다(인자들의 이름이 먼저 나옵니다); `co_cellvars` 는 중첩된 함수들이 참조하는 지역 변수들의 이름을 담고 있는 튜플입니다; `co_freevars` 는 자유 변수(free variables)들의 이름을 담고 있는 튜플입니다; `co_code` 는 바이트 코드 명령 시퀀스를 나타내는 문자열입니다; `co_consts` 는 바이트 코드가 사용하는 리터럴을 포함하는 튜플입니다; `co_names` 는 바이트 코드가 사용하는 이름들을 담고 있는 튜플입니다; `co_filename` 은 컴파일된 코드를 제공한 파일의 이름입니다; `co_firstlineno` 는 함수의 첫 번째 줄 번호입니다; `co_lnotab` 은 바이트 코드에서의 위치를 줄 번호로 매핑하는 법을 문자열로 인코딩한 값입니다 (자세한 내용은 인터프리터의 소스 코드를 참고하십시오); `co_stacksize` 는 필요한 스택의 크기입니다; `co_flags` 는 인터프리터의 여러 플래그(flag)들을 정수로 인코딩한 값입니다.

    다음과 같은 값들이 `co_flags` 를 위해 정의되어 있습니다: 함수가 가변 개수의 위치 인자를 받아들이기 위해 사용되는 `*arguments` 문법을 사용하면 비트 `0x04` 가 1이 됩니다; 임의의 키워드 인자를 받아들이기 위해 사용하는 `**keywords` 문법을 사용하면 비트 `0x08` 이 1이 됩니다; 비트 `0x20` 은 함수가 제너레이터일 때 설정됩니다.

    퓨처 기능 선언 (`from __future__ import division`) 또한 코드 객체가 특정 기능이 활성화된 상태에서 컴파일되었는지를 나타내기 위해 `co_flags` 의 비트들을 사용합니다: 함수가 퓨처 division이 활성화된 상태에서 컴파일되었으면 비트 `0x2000` 이 설정됩니다; 비트 `0x10` 과 `0x1000` 는 예전 버전의 파이썬에서 사용되었습니다.

    `co_flags` 의 다른 비트들은 내부 사용을 위해 예약되어 있습니다.

    만약 코드 객체가 함수를 나타낸다면, `co_consts` 의 첫 번째 항목은 설명 문자열이거나 정의되지 않으면 `None` 입니다.

  프레임 객체(Frame objects)

    프레임 객체는 실행 프레임(execution frame)을 나타냅니다. 트레이스백 객체에 등장할 수 있고 (아래를 보십시오), 등록된 추적 함수로도 전달됩니다.

    특수 읽기 전용 어트리뷰트들: `f_back` 은 이전 스택 프레임 (호출자 방향으로)을 가리키거나, 이게 스택의 바닥이라면 `None`; `f_code` 는 이 프레임에서 실행되는 코드 객체; `f_locals` 는 지역 변수를 조회하는데 사용되는 딕셔너리; `f_globals` 는 전역 변수에 사용됩니다; `f_builtins` 는 내장된(intrinsic) 이름들에 사용됩니다; `f_lasti` 는 정확한 바이트 코드 명령(instruction)을 제공합니다 (코드 객체의 바이트 코드 문자열에 대한 인덱스입니다).

    Accessing `f_code` raises an auditing event `object.__getattr__` with arguments `obj` and `"f_code"`.

    특수 쓰기 가능 어트리뷰트들: `f_trace` 는, `None` 이 아니면, 코드 실행 중의 여러 이벤트로 인해 호출되는 함수입니다 (디버거에서 사용됩니다). 보통 이벤트는 각 새 소스 줄에서 발생합니다 - `f_trace_lines`를 `False`로 설정하면 이것을 비활성화할 수 있습니다.

    구현은 `f_trace_opcodes`를 `True`로 설정하는 것으로 요청되는 옵코드(opcode) 당 이벤트를 허용할 수 있습니다. 추적 함수에 의해 발생 된 예외가 추적되는 함수로 빠져나오면 정의되지 않은 인터프리터 동작을 유발할 수 있음에 주의해야 합니다.

    `f_lineno` 는 프레임의 현재 줄 번호입니다 — 트레이스 함수(f_trace)에서 이 값을 쓰면 해당 줄로 점프합니다 (오직 가장 바닥 프레임에서만 가능합니다). 디버거는 f_lineno 를 쓰기 위한 점프 명령을 구현할 수 있습니다 (소위 Set Next Statement).

    프레임 객체는 한가지 메서드를 지원합니다:

    `frame.``clear`()

      이 메서드는 프레임이 잡은 지역 변수들에 대한 모든 참조를 제거합니다. 또한, 만약 프레임이 제너레이터에 속하면, 제너레이터가 종료됩니다(finalize). 이것은 프레임 객체가 관련된 참조 순환을 깨는 데 도움을 줍니다 (예를 들어, 예외를 잡아서 트레이스백을 추후 사용을 위해 저장할 때).

      만약 프레임이 현재 실행 중이면 `RuntimeError` 예외가 발생합니다.

      버전 3.4에 추가.

  트레이스백 객체(Traceback objects)

    트레이스백 객체는 예외의 스택 트레이스를 나타냅니다. 트레이스백 객체는 예외가 발생할 때 만들어지고, `types.TracebackType` 를 호출해서 명시적으로 만들 수도 있습니다.

    묵시적으로 만들어진 트레이스백의 경우, 예외 처리기를 찾아서 실행 스택을 되감을 때, 각각 되감기 단계마다 현재 트레이스백의 앞에 트레이스백 객체를 삽입합니다. 예외 처리기에 들어가면, 스택 트레이스를 프로그램이 사용할 수 있습니다. (try 문 섹션 참조.) `sys.exc_info()` 가 돌려주는 튜플의 세 번째 항목이나 잡힌 예외의 `__traceback__` 어트리뷰트로 액세스할 수 있습니다.

    프로그램이 적절한 처리기를 제공하지 않는 경우, 스택 트레이스는 표준 에러 스트림으로 (보기 좋게 포맷되어) 출력됩니다; 만약 인터프리터가 대화형이면, `sys.last_traceback` 으로 사용자에게 제공합니다.

    명시적으로 생성된 트레이스백의 경우, `tb_next` 어트리뷰트를 어떻게 연결하여 전체 스택 트레이스를 형성해야 하는지를 결정하는 것은 트레이스백을 만드는 주체에게 달려 있습니다.

    특수 읽기 전용 어트리뷰트들: `tb_frame` 은 현 단계에서의 실행 프레임입니다; `tb_lineno` 는 예외가 발생한 줄의 번호를 줍니다; `tb_lasti` 정확한 바이트 코드 명령을 가리킵니다. 만약 예외가 except 절이나 finally 절이 없는 `try` 문에서 발생하면, 줄 번호와 트레이스백의 마지막 명령(last instruction)은 프레임 객체의 줄 번호와 다를 수 있습니다.

    Accessing `tb_frame` raises an auditing event `object.__getattr__` with arguments `obj` and `"tb_frame"`.

    특수 쓰기 가능 어트리뷰트: `tb_next` 는 스택 트레이스의 다음 단계 (예외가 발생한 프레임 방향으로)이거나 다음 단계가 없으면 `None` 입니다.

    버전 3.7에서 변경: 트레이스백 객체는 이제 파이썬 코드에서 명시적으로 인스턴스를 만들 수 있으며 기존 인스턴스의 `tb_next` 어트리뷰트를 변경할 수 있습니다.

  슬라이스 객체(Slice objects)

    Slice objects are used to represent slices for `__getitem__()` methods. They are also created by the built-in `slice()` function.

    특수 읽기 전용 어트리뷰트들: `start` 는 하한(lower bound) 입니다; `stop` 은 상한(upper bound) 입니다; `step` 은 스텝 값입니다; 각 값은 생략될 경우 `None` 입니다. 이 어트리뷰트들은 임의의 형이 될 수 있습니다.

    슬라이스 객체는 하나의 메서드를 지원합니다.

    `slice.``indices`(self, length)

      이 메서드는 하나의 정수 인자 length 를 받아서 슬라이스 객체가 길이 length 인 시퀀스에 적용되었을 때 그 슬라이스에 대한 정보를 계산합니다. 세 개의 정수로 구성된 튜플을 돌려줍니다: 이것들은 각각 start 와 stop 인덱스와, step 또는 슬라이스의 스트라이드(stride) 길이입니다. 생략되었거나 범위를 벗어난 인덱스들은 일반적인 슬라이스와 같은 방법으로 다뤄집니다.

  스태틱 메서드 객체(Static method objects)

    Static method objects provide a way of defeating the transformation of function objects to method objects described above. A static method object is a wrapper around any other object, usually a user-defined method object. When a static method object is retrieved from a class or a class instance, the object actually returned is the wrapped object, which is not subject to any further transformation. Static method objects are also callable. Static method objects are created by the built-in `staticmethod()` constructor.

  클래스 메서드 객체(Class method objects)

    스태틱 메서드 객체처럼, 클래스 메서드 객체 역시 다른 객체를 둘러싸는데, 클래스와 클래스 인스턴스로부터 그 객체를 꺼내는 방식에 변화를 줍니다. 그런 조회에서 클래스 메서드 객체가 동작하는 방식에 대해서는 위 “사용자 정의 메서드(User-defined methods)” 에서 설명했습니다. 클래스 메서드 객체는 내장 `classmethod()` 생성자로 만듭니다.

## 3.3. 특수 메서드 이름들

A class can implement certain operations that are invoked by special syntax (such as arithmetic operations or subscripting and slicing) by defining methods with special names. This is Python’s approach to operator overloading, allowing classes to define their own behavior with respect to language operators. For instance, if a class defines a method named `__getitem__()`, and `x` is an instance of this class, then `x[i]` is roughly equivalent to `type(x).__getitem__(x, i)`. Except where mentioned, attempts to execute an operation raise an exception when no appropriate method is defined (typically `AttributeError` or `TypeError`).

Setting a special method to `None` indicates that the corresponding operation is not available. For example, if a class sets `__iter__()` to `None`, the class is not iterable, so calling `iter()` on its instances will raise a `TypeError` (without falling back to `__getitem__()`). 2

내장형을 흉내 내는 클래스를 구현할 때, 모방은 모형화하는 객체에 말이 되는 수준까지만 구현하는 것이 중요합니다. 예를 들어, 어떤 시퀀스는 개별 항목들을 꺼내는 것만으로도 잘 동작할 수 있습니다. 하지만 슬라이스를 꺼내는 것은 말이 안 될 수 있습니다. (이런 한가지 예는 W3C의 Document Object Model의 `NodeList` 인터페이스입니다.)

### 3.3.1. 기본적인 커스터마이제이션

`object.``__new__`(cls[, ...])

  클래스 cls 의 새 인스턴스를 만들기 위해 호출됩니다. `__new__()` 는 스태틱 메서드입니다 (그렇게 선언하지 않아도 되는 특별한 경우입니다)인데, 첫 번째 인자로 만들려고 하는 인스턴스의 클래스가 전달됩니다. 나머지 인자들은 객체 생성자 표현(클래스 호출)에 전달된 것들입니다. `__new__()` 의 반환 값은 새 객체 인스턴스이어야 합니다 (보통 cls 의 인스턴스).

  Typical implementations create a new instance of the class by invoking the superclass’s `__new__()` method using `super().__new__(cls[, ...])` with appropriate arguments and then modifying the newly created instance as necessary before returning it.

  If `__new__()` is invoked during object construction and it returns an instance of cls, then the new instance’s `__init__()` method will be invoked like `__init__(self[, ...])`, where self is the new instance and the remaining arguments are the same as were passed to the object constructor.

  만약 `__new__()` 가 cls 의 인스턴스를 돌려주지 않으면, 새 인스턴스의 `__init__()` 는 호출되지 않습니다.

  `__new__()` 는 주로 불변형(int, str, tuple과 같은)의 서브 클래스가 인스턴스 생성을 커스터마이즈할 수 있도록 하는 데 사용됩니다. 또한, 사용자 정의 메타 클래스에서 클래스 생성을 커스터마이즈하기 위해 자주 사용됩니다.

`object.``__init__`(self[, ...])

  (`__new__()` 에 의해) 인스턴스가 만들어진 후에, 하지만 호출자에게 돌려주기 전에 호출됩니다. 인자들은 클래스 생성자 표현으로 전달된 것들입니다. 만약 베이스 클래스가 `__init__()` 메서드를 갖고 있다면, 서브 클래스의 `__init__()` 메서드는, 있다면, 인스턴스에서 베이스 클래스가 차지하는 부분이 올바르게 초기화됨을 확실히 하기 위해 명시적으로 호출해주어야 합니다; 예를 들어: `super().__init__([args...])`.

  객체를 만드는데 `__new__()` 와 `__init__()` 가 협력하고 있으므로 (`__new__()` 는 만들고, `__init__()` 는 그것을 커스터마이즈합니다), `__init__()` 가 `None` 이외의 값을 돌려주면 실행시간에 `TypeError` 를 일으킵니다.

`object.``__del__`(self)

  인스턴스가 파괴되기 직전에 호출됩니다. 파이널라이저 또는 (부적절하게) 파괴자라고 불립니다. 만약 베이스 클래스가 `__del__()` 메서드를 갖고 있다면, 자식 클래스의 `__del__()` 메서드는, 정의되어 있다면, 인스턴스에서 베이스 클래스가 차지하는 부분을 적절하게 삭제하기 위해, 명시적으로 베이스 클래스의 메서드를 호출해야 합니다.

  (권장하지는 않지만!) `__del__()` 메서드는 인스턴스에 대한 새로운 참조를 만듦으로써 인스턴스의 파괴를 지연시킬 수 있습니다. 이것을 객체 부활 이라고 부릅니다. 부활한 객체가 파괴될 때 `__del__()` 이 두 번째로 호출될지는 구현에 따라 다릅니다; 현재 CPython 구현은 오직 한 번만 호출합니다.

  인터프리터가 종료할 때 아직 남아있는 객체들에 대해서는 `__del__()` 메서드의 호출이 보장되지 않습니다.

  참고

  `del x` 는 직접 `x.__del__()` 를 호출하지 않습니다 — 앞에 있는 것은 `x` 의 참조 횟수(reference count)를 하나 감소시키고, 뒤에 있는 것은 `x` 의 참조 횟수가 0 이 될 때 호출됩니다.

  CPython 구현 상세: It is possible for a reference cycle to prevent the reference count of an object from going to zero. In this case, the cycle will be later detected and deleted by the cyclic garbage collector. A common cause of reference cycles is when an exception has been caught in a local variable. The frame’s locals then reference the exception, which references its own traceback, which references the locals of all frames caught in the traceback.

  더 보기

  `gc` 모듈에 대한 문서.

  경고

  `__del__()` 이 호출되는 불안정한 상황 때문에, 이것이 실행 중에 발생시키는 예외는 무시되고, 대신에 `sys.stderr` 로 경고가 출력됩니다. 특히:

  - `__del__()` 은 (임의의 스레드에서) 임의의 코드가 실행되는 동안 호출될 수 있습니다. `__del__()` 이 록을 얻어야 하거나 다른 블로킹 자원을 호출하면, `__del__()` 을 실행하기 위해 중단된 코드가 자원을 이미 차지했을 수 있으므로 교착 상태에 빠질 수 있습니다.

  - `__del__()` 은 인터프리터를 종료할 때 실행될 수 있습니다. 결과적으로, 액세스해야 하는 전역 변수(다른 모듈 포함)가 이미 삭제되었거나 `None` 으로 설정되었을 수 있습니다. 파이썬은 이름이 하나의 밑줄로 시작하는 전역 객체가 다른 전역 객체들보다 먼저 삭제됨을 보장합니다; 이것은, 만약 그 전역 객체들에 대한 다른 참조가 존재하지 않는다면, `__del__()` 메서드가 호출되는 시점에, 임포트된 모듈들이 남아있도록 확실히 하는 데 도움이 될 수 있습니다.

`object.``__repr__`(self)

  `repr()` 내장 함수에 의해 호출되어 객체의 “형식적인(official)” 문자열 표현을 계산합니다. 만약 가능하다면, 이것은 같은 (적절한 환경이 주어질 때) 값을 갖는 객체를 새로 만들 수 있는 올바른 파이썬 표현식처럼 보여야 합니다. 가능하지 않다면, `<...쓸모있는 설명...>` 형태의 문자열을 돌려줘야 합니다. 반환 값은 반드시 문자열이어야 합니다. 만약 클래스가 `__str__()` 없이 `__repr__()` 만 정의한다면, `__repr__()` 은 그 클래스 인스턴스의 “비형식적인(informal)” 문자열 표현이 요구될 때 사용될 수 있습니다.

  이것은 디버깅에 사용되기 때문에, 표현이 풍부한 정보를 담고 모호하지 않게 하는 것이 중요합니다.

`object.``__str__`(self)

  `str(object)` 와 내장 함수 `format()`, `print()` 에 의해 호출되어 객체의 “비형식적인(informal)” 또는 보기 좋게 인쇄 가능한 문자열 표현을 계산합니다. 반환 값은 반드시 문자열 객체여야 합니다.

  이 메서드는 `__str__()` 이 올바른 파이썬 표현식을 돌려줄 것이라고 기대되지 않는다는 점에서 `object.__repr__()` 과 다릅니다: 더 편리하고 간결한 표현이 사용될 수 있습니다.

  내장형 `object` 에 정의된 기본 구현은 `object.__repr__()` 을 호출합니다.

`object.``__bytes__`(self)

  bytes 에 의해 호출되어 객체의 바이트열 표현을 계산합니다. 반환 값은 반드시 `bytes` 객체여야 합니다.

`object.``__format__`(self, format_spec)

  `format()` 내장 함수, 확대하면, 포맷 문자열 리터럴(formatted string literals) 의 계산과 `str.format()` 메서드에 의해 호출되어, 객체의 “포맷된” 문자열 표현을 만들어냅니다. format_spec 인자는 요구되는 포맷 옵션들을 포함하는 문자열입니다. format_spec 인자의 해석은 `__format__()` 을 구현하는 형에 달려있으나, 대부분 클래스는 포매팅을 내향형들의 하나로 위임하거나, 비슷한 포맷 옵션 문법을 사용합니다.

  표준 포매팅 문법에 대해서는 포맷 명세 미니 언어 를 참고하면 됩니다.

  반환 값은 반드시 문자열이어야 합니다.

  버전 3.4에서 변경: `object` 의 __format__ 메서드 자신은, 빈 문자열이 아닌 인자가 전달되면 `TypeError` 를 발생시킵니다.

  버전 3.7에서 변경: 이제 `object.__format__(x, '')` 는 `format(str(x), '')` 가 아니라 `str(x)` 와 동등합니다.

`object.``__lt__`(self, other)
`object.``__le__`(self, other)
`object.``__eq__`(self, other)
`object.``__ne__`(self, other)
`object.``__gt__`(self, other)
`object.``__ge__`(self, other)

  이것들은 소위 “풍부한 비교(rich comparison)” 메서드입니다. 연산자 기호와 메서드 이름 간의 관계는 다음과 같습니다: `x<y` 는 `x.__lt__(y)` 를 호출합니다, `x<=y` 는 `x.__le__(y)` 를 호출합니다, `x==y` 는 `x.__eq__(y)` 를 호출합니다, `x!=y` 는 `x.__ne__(y)` 를 호출합니다, `x>y` 는 `x.__gt__(y)` 를 호출합니다, `x>=y` 는 `x.__ge__(y)` 를 호출합니다.

  풍부한 비교 메서드는 주어진 한 쌍의 인자에게 해당 연산을 구현하지 않는 경우 단일자(singleton) `NotImplemented` 를 돌려줄 수 있습니다. 관례상, 성공적인 비교면 `False` 나 `True` 를 돌려줍니다. 하지만, 이 메서드는 어떤 형의 값이건 돌려줄 수 있습니다, 그래서 비교 연산자가 논리 문맥(Boolean context) (예를 들어 `if` 문의 조건)에서 사용되면, 파이썬은 결과의 참 거짓을 파악하기 위해 값에 대해 `bool()` 을 호출합니다.

  기본적으로, `object`는 `is`를 사용해서 거짓으로 비교될 때 `NotImplemented`를 반환하는 `__eq__()`를 구현합니다: `True if x is y else NotImplemented`. `__ne__()`의 경우는, 기본적으로 `__eq__()`에 위임하고 `NotImplemented` 가 아니라면 그 결과를 뒤집습니다. 비교 연산자나 기본 구현 간의 다른 암시적인 관계는 없습니다; 예를 들어, `(x<y or x==y)` 가 참이라고 해서 `x<=y` 가 참일 필요는 없습니다. 하나의 기본 연산으로부터 대소관계 연산을 자동으로 만들어내려면, `functools.total_ordering()`을 보십시오.

  사용자 정의 비교 연산자를 지원하고 딕셔너리 키로 사용될 수 있는 해시 가능 객체를 만드는 것에 관한 몇 가지 중요한 내용이 `__hash__()` 에 관한 문단에 나옵니다.

  이 메서드들에 대한 (왼편의 인자는 연산을 지원하지 않지만, 오른편 인자가 지원할 때 사용되는) 뒤집힌 버전은 따로 없습니다; 대신에 `__lt__()` 와 `__gt__()` 는 서로의 뒤집힌 연산입니다; `__le__()` 와 `__ge__()` 는 서로의 뒤집힌 연산입니다; `__eq__()` 와 `__ne__()` 는 서로의 뒤집힌 연산입니다; 만약 피연산자가 서로 다른 형이고, 오른편 피연산자의 형이 왼편 피연산자의 형의 직간접적인 서브 클래스면, 오른편 피연산자의 뒤집힌 버전이 우선순위가 높습니다; 그렇지 않으면 왼편 피연산자의 메서드가 우선순위가 높습니다. 가상 서브 클래싱(virtual subclassing)은 고려되지 않습니다.

`object.``__hash__`(self)

  Called by built-in function `hash()` and for operations on members of hashed collections including `set`, `frozenset`, and `dict`. The `__hash__()` method should return an integer. The only required property is that objects which compare equal have the same hash value; it is advised to mix together the hash values of the components of the object that also play a part in comparison of objects by packing them into a tuple and hashing the tuple. Example:

      def __hash__(self):
          return hash((self.name, self.nick, self.color))

  참고

  `hash()` 는 객체가 정의한 `__hash__()` 메서드가 돌려주는 값을 `Py_ssize_t` 의 크기로 자릅니다(truncate). 이것은 보통 64-bit 빌드에서는 8바이트고, 32-bit 빌드에서는 4바이트입니다. 만약 객체의 `__hash__()` 가 서로 다른 비트 크기를 갖는 빌드들 사이에서 함께 사용되어야 한다면, 모든 지원할 빌드들에서의 폭을 검사해야 합니다. 이렇게 하는 쉬운 방법은 `python -c "import sys; print(sys.hash_info.width)"` 입니다.

  If a class does not define an `__eq__()` method it should not define a `__hash__()` operation either; if it defines `__eq__()` but not `__hash__()`, its instances will not be usable as items in hashable collections. If a class defines mutable objects and implements an `__eq__()` method, it should not implement `__hash__()`, since the implementation of hashable collections requires that a key’s hash value is immutable (if the object’s hash value changes, it will be in the wrong hash bucket).

  사용자 정의 클래스는 기본적으로 `__eq__()` 와 `__hash__()` 메서드를 갖습니다; 모든 객체는 (자기 자신을 제외하고) 같지 않다고 비교되고, `x.__hash__()` 는 적절한 값을 돌려주어, `x == y` 일 때 `x is y` 와 `hash(x) == hash(y)` 가 동시에 성립할 수 있도록 합니다.

  `__eq__()` 를 재정의하고 `__hash__()` 를 정의하지 않는 클래스는 `__hash__()` 가 `None` 으로 설정됩니다. 클래스의 `__hash__()` 메서드가 `None` 이면, 클래스의 인스턴스는 프로그램이 해시값을 얻으려 시도할 때 `TypeError` 를 일으키고, `isinstance(obj, collections.abc.Hashable)` 로 검사할 때 해시 가능하지 않다고 올바로 감지됩니다.

  만약 `__eq__()` 를 재정의하는 클래스가 부모 클래스로부터 `__hash__()` 의 구현을 물려받고 싶으면 인터프리터에게 명시적으로 이렇게 지정해주어야 합니다: `__hash__ = <ParentClass>.__hash__`.

  만약 `__eq__()` 를 재정의하지 않는 클래스가 해시 지원을 멈추고 싶으면, 클래스 정의에 `__hash__ = None` 을 포함해야 합니다. 자신의 `__hash__()` 을 정의한 후에 직접 `TypeError` 를 일으키는 경우는 `isinstance(obj, collections.abc.Hashable)` 호출이 해시 가능하다고 잘못 인식합니다.

  참고

  기본적으로, str과 bytes 객체들의 `__hash__()` 값은 예측할 수 없는 난수값으로 “솔트되어(salted)” 있습니다. 개별 파이썬 프로세스 내에서는 변하지 않는 값으로 유지되지만, 파이썬을 반복적으로 실행할 때는 예측할 수 없게 됩니다.

  This is intended to provide protection against a denial-of-service caused by carefully chosen inputs that exploit the worst case performance of a dict insertion, O(n2) complexity. See http://www.ocert.org/advisories/ocert-2011-003.html for details.

  해시값의 변경은 집합의 이터레이션 순서에 영향을 줍니다, 파이썬은 이 순서에 대해 어떤 보장도 하지 않습니다 (그리고 보통 32-bit 와 64-bit 빌드 사이에서도 다릅니다).

  `PYTHONHASHSEED` 를 참고하십시오.

  버전 3.3에서 변경: 해시 난수 화는 기본적으로 활성화됩니다.

`object.``__bool__`(self)

  논리값 검사와 내장 연산 `bool()` 구현을 위해 호출됩니다; `False` 나 `True` 를 돌려줘야 합니다. 이 메서드가 정의되지 않는 경우, 정의되어 있다면 `__len__()` 이 호출되어, 값이 0 이 아니면 참으로 인식합니다. 만약 클래스가 `__len__()` 과 `__bool__()` 모두 정의하지 않는다면, 모든 인스턴스는 참으로 취급됩니다.

### 3.3.2. 어트리뷰트 액세스 커스터마이제이션

클래스 인스턴스의 어트리뷰트 참조(읽기, 대입하기, `x.name` 을 삭제하기)의 의미를 변경하기 위해 다음과 같은 메서드들이 정의될 수 있습니다.

`object.``__getattr__`(self, name)

  기본 어트리뷰트 액세스가 `AttributeError` 로 실패할 때 호출됩니다 (name 이 인스턴스 어트리뷰트 또는 `self` 의 클래스 트리에 있는 어트리뷰트가 아니라서 `__getattribute__()` 가 `AttributeError` 를 일으키거나; name 프로퍼티의 `__get__()` 이 `AttributeError` 를 일으킬 때). 이 메서드는 (계산된) 어트리뷰트 값을 반환하거나 `AttributeError` 예외를 일으켜야 합니다.

  일반적인 메커니즘을 통해 어트리뷰트가 발견되면 `__getattr__()` 이 호출되지 않음에 주의해야 합니다 (이것은 `__getattr__()` 과 `__setattr__()` 간의 의도된 비대칭입니다). 이렇게 하는 이유는 효율 때문이기도 하고, 그렇게 하지 않으면 `__getattr__()` 가 인스턴스의 다른 어트리뷰트에 접근할 방법이 없기 때문이기도 합니다. 적어도 인스턴스 변수의 경우, 어떤 값도 인스턴스 어트리뷰트 딕셔너리에 넣지 않음으로써 (대신에 그것들을 다른 객체에 넣습니다) 완전한 제어인 것처럼 조작할 수 있습니다. 어트리뷰트 액세스를 실제로 완전히 조작하는 방법에 대해서는 아래에 나오는 `__getattribute__()` 에서 다룹니다.

`object.``__getattribute__`(self, name)

  클래스 인스턴스의 어트리뷰트 액세스를 구현하기 위해 조건 없이 호출됩니다. 만약 클래스가 `__getattr__()` 도 함께 구현하면, `__getattribute__()` 가 명시적으로 호출하거나 `AttributeError` 를 일으키지 않는 이상 __getattr__ 는 호출되지 않습니다. 이 메서드는 어트리뷰트의 (계산된) 값을 돌려주거나 `AttributeError` 예외를 일으켜야 합니다. 이 메서드에서 무한 재귀(infinite recursion)가 발생하는 것을 막기 위해, 구현은 언제나 필요한 어트리뷰트에 접근하기 위해 같은 이름의 베이스 클래스의 메서드를 호출해야 합니다. 예를 들어, `object.__getattribute__(self, name)`.

  참고

  언어 문법이나 내장 함수에 의한 묵시적인 호출이 결과로 특수 메서드를 참조하는 경우에는 이 메서드를 거치지 않을 수 있습니다. 자세한 내용은 특수 메서드 조회 에서 다룹니다.

  인자 `obj`, `name`으로 감사 이벤트 `object.__getattr__`을 발생시킵니다.

`object.``__setattr__`(self, name, value)

  어트리뷰트 대입이 시도될 때 호출됩니다. 일반적인 메커니즘(즉 인스턴스 딕셔너리에 값을 저장하는 것) 대신에 이것이 호출됩니다. name 은 어트리뷰트 이름이고, value 는 그것에 대입하려는 값입니다.

  `__setattr__()` 에서 인스턴스 어트리뷰트에 대입하려고 할 때는, 같은 이름의 베이스 클래스의 메서드를 호출해야 합니다. 예를 들어 `object.__setattr__(self, name, value)`

  인자 `obj`, `name`, `value`로 감사 이벤트 `object.__setattr__`을 발생시킵니다.

`object.``__delattr__`(self, name)

  `__setattr__()` 과 비슷하지만 어트리뷰트를 대입하는 대신에 삭제합니다. 이것은 `del obj.name` 이 객체에 의미가 있는 경우에만 구현되어야 합니다.

  인자 `obj`, `name`으로 감사 이벤트 `object.__delattr__`을 발생시킵니다.

`object.``__dir__`(self)

  객체에 `dir()` 이 호출될 때 호출됩니다. 시퀀스를 돌려줘야 합니다. `dir()` 은 돌려준 시퀀스를 리스트로 변환한 후 정렬합니다.

#### 3.3.2.1. 모듈 어트리뷰트 액세스 커스터마이제이션

특수한 이름 `__getattr__` 과 `__dir__` 는 모듈 어트리뷰트에 대한 접근을 사용자 정의하는 데 사용될 수도 있습니다. 모듈 수준의 `__getattr__` 함수는 하나의 인자로 어트리뷰트의 이름을 받아서 계산된 값을 돌려주거나 `AttributeError` 를 발생시켜야 합니다. 일반적인 조회(즉 `object.__getattribute__()`)를 통해 어트리뷰트가 모듈 객체에서 발견되지 않으면, `AttributeError` 를 일으키기 전에 모듈 `__dict__` 에서 `__getattr__` 을 검색합니다. 발견되면, 어트리뷰트 이름으로 그 함수를 호출하고 결과를 돌려줍니다.

`__dir__` 함수는 인자를 받지 않고 모듈에서 접근 할 수 있는 이름을 나타내는 문자열의 시퀀스를 돌려줘야 합니다. 존재하면, 이 함수는 모듈에 대한 표준 `dir()` 검색을 재정의합니다.

모듈 동작(어트리뷰트 설정, 프로퍼티 등)을 보다 세밀하게 사용자 정의하려면, 모듈 객체의 `__class__` 어트리뷰트를 `types.ModuleType` 의 서브 클래스로 설정할 수 있습니다. 예를 들면:

    import sys
    from types import ModuleType

    class VerboseModule(ModuleType):
        def __repr__(self):
            return f'Verbose {self.__name__}'

        def __setattr__(self, attr, value):
            print(f'Setting {attr}...')
            super().__setattr__(attr, value)

    sys.modules[__name__].__class__ = VerboseModule

참고

모듈 `__getattr__` 정의와 모듈 `__class__` 설정은 어트리뷰트 액세스 구문을 사용하는 조회에만 영향을 미칩니다 – 모듈 전역에 대한 직접적인 액세스(모듈 내의 코드에 의한 액세스이거나 모듈의 전역 딕셔너리에 대한 참조를 거치거나)는 영향받지 않습니다.

버전 3.5에서 변경: 이제 `__class__` 모듈 어트리뷰트가 쓰기 가능합니다.

버전 3.7에 추가: `__getattr__` 과 `__dir__` 모듈 어트리뷰트.

더 보기

PEP 562 - 모듈 __getattr__ 과 __dir__

  모듈에 대한 `__getattr__` 과 `__dir__` 함수를 설명합니다.

#### 3.3.2.2. 디스크립터 구현하기

다음에 오는 메서드들은 메서드를 가진 클래스(소위 디스크립터(descriptor) 클래스)의 인스턴스가 소유자(owner) 클래스에 등장할 때만 적용됩니다(디스크립터는 소유자 클래스의 딕셔너리나 그 부모 클래스 중 하나의 딕셔너리에 있어야 합니다). 아래의 예에서, “어트리뷰트” 는 이름이 소유자 클래스의 `__dict__` 의 키로 사용되고 있는 어트리뷰트를 가리킵니다.

`object.``__get__`(self, instance, owner=None)

  소유자 클래스(클래스 어트리뷰트 액세스) 나 그 클래스의 인스턴스(인스턴스 어트리뷰트 액세스)의 어트리뷰트를 취하려고 할 때 호출됩니다. 선택적 owner 인자는 소유자 클래스입니다. 반면에 instance 는 어트리뷰트 참조가 일어나고 있는 인스턴스이거나, 어트리뷰트가 owner 를 통해 액세스 되는 경우 None 입니다.

  이 메서드는 계산된 어트리뷰트 값을 돌려주거나 `AttributeError` 예외를 일으켜야 합니다.

  PEP 252는 `__get__()`이 하나나 두 개의 인자를 갖는 콜러블이라고 지정합니다. 파이썬 자신의 내장 디스크립터는 이 명세를 지원합니다; 그러나, 일부 제삼자 도구에는 두 인수를 모두 요구하는 디스크립터가 있을 수 있습니다. 파이썬 자신의 `__getattribute__()` 구현은 필요한지와 관계없이 항상 두 인자를 모두 전달합니다.

`object.``__set__`(self, instance, value)

  소유자 클래스의 인스턴스 instance 의 어트리뷰트를 새 값 value 로 설정할 때 호출됩니다.

  `__set__()`이나 `__delete__()`를 추가하면 디스크립터 유형이 “데이터 디스크립터(data descriptor)”로 변경됨에 유의하십시오. 자세한 내용은 디스크립터 호출하기를 참조하십시오.

`object.``__delete__`(self, instance)

  소유자 클래스의 인스턴스 instance 의 어트리뷰트를 삭제할 때 호출됩니다.

어트리뷰트 `__objclass__` 는 `inspect` 모듈에 의해 이 객체가 정의된 클래스를 지정하는 것으로 해석됩니다(이 값을 적절히 설정하면 동적인 클래스 어트리뷰트의 실행시간 인트로스펙션(introspection)을 지원할 수 있습니다). 콜러블의 경우, 첫 번째 위치 인자에, 주어진 형(또는 서브 클래스)의 인스턴스가 기대되거나 요구됨을 가리킬 수 있습니다(예를 들어, CPython 은 C로 구현된 연결되지 않은 메서드(unbound method)에 이 어트리뷰트를 설정합니다).

#### 3.3.2.3. 디스크립터 호출하기

In general, a descriptor is an object attribute with “binding behavior”, one whose attribute access has been overridden by methods in the descriptor protocol: `__get__()`, `__set__()`, and `__delete__()`. If any of those methods are defined for an object, it is said to be a descriptor.

어트리뷰트 액세스의 기본 동작은 객체의 딕셔너리에서 어트리뷰트를 읽고, 쓰고, 삭제하는 것입니다. 예를 들어 `a.x` 는 `a.__dict__['x']` 에서 시작해서 `type(a).__dict__['x']` 를 거쳐 `type(a)` 의 메타 클래스를 제외한 베이스 클래스들을 거쳐 가는 일련의 조회로 구성됩니다.

그러나, 만약 조회한 값이 디스크립터 메서드를 구현한 객체면, 파이썬은 기본 동작 대신에 디스크립터 메서드를 호출할 수 있습니다. 우선순위 목록의 어느 위치에서 이런 일이 일어나는지는 어떤 디스크립터 메서드가 정의되어 있고 어떤 식으로 호출되는지에 따라 다릅니다.

디스크립터 호출의 시작점은 결합(binding)입니다, `a.x`. 어떻게 인자들이 조합되는지는 `a` 에 따라 다릅니다:

직접 호출

  가장 간단하면서도 가장 덜 사용되는 호출은 사용자의 코드가 디스크립터 메서드를 직접 호출할 때입니다: `x.__get__(a)`

인스턴스 결합

  객체 인스턴스에 결합하면, `a.x` 는 이런 호출로 변환됩니다: `type(a).__dict__['x'].__get__(a, type(a))`.

클래스 결합

  클래스에 결합하면, `A.x` 는 이런 호출로 변환됩니다: `A.__dict__['x'].__get__(None, A)`.

Super 결합

  If `a` is an instance of `super`, then the binding `super(B, obj).m()` searches `obj.__class__.__mro__` for the base class `A` immediately following `B` and then invokes the descriptor with the call: `A.__dict__['m'].__get__(obj, obj.__class__)`.

For instance bindings, the precedence of descriptor invocation depends on which descriptor methods are defined. A descriptor can define any combination of `__get__()`, `__set__()` and `__delete__()`. If it does not define `__get__()`, then accessing the attribute will return the descriptor object itself unless there is a value in the object’s instance dictionary. If the descriptor defines `__set__()` and/or `__delete__()`, it is a data descriptor; if it defines neither, it is a non-data descriptor. Normally, data descriptors define both `__get__()` and `__set__()`, while non-data descriptors have just the `__get__()` method. Data descriptors with `__get__()` and `__set__()` (and/or `__delete__()`) defined always override a redefinition in an instance dictionary. In contrast, non-data descriptors can be overridden by instances.

Python methods (including those decorated with `@staticmethod` and `@classmethod`) are implemented as non-data descriptors. Accordingly, instances can redefine and override methods. This allows individual instances to acquire behaviors that differ from other instances of the same class.

`property()` 함수는 데이터 디스크립터로 구현됩니다. 이 때문에, 인스턴스는 프로퍼티(property)의 동작을 변경할 수 없습니다.

#### 3.3.2.4. __slots__

__slots__ allow us to explicitly declare data members (like properties) and deny the creation of `__dict__` and __weakref__ (unless explicitly declared in __slots__ or available in a parent.)

The space saved over using `__dict__` can be significant. Attribute lookup speed can be significantly improved as well.

`object.``__slots__`

  This class variable can be assigned a string, iterable, or sequence of strings with variable names used by instances. __slots__ reserves space for the declared variables and prevents the automatic creation of `__dict__` and __weakref__ for each instance.

##### 3.3.2.4.1. __slots__ 사용에 관한 노트

- When inheriting from a class without __slots__, the `__dict__` and __weakref__ attribute of the instances will always be accessible.

- Without a `__dict__` variable, instances cannot be assigned new variables not listed in the __slots__ definition. Attempts to assign to an unlisted variable name raises `AttributeError`. If dynamic assignment of new variables is desired, then add `'__dict__'` to the sequence of strings in the __slots__ declaration.

- Without a __weakref__ variable for each instance, classes defining __slots__ do not support `weak references` to its instances. If weak reference support is needed, then add `'__weakref__'` to the sequence of strings in the __slots__ declaration.

- __slots__ are implemented at the class level by creating descriptors for each variable name. As a result, class attributes cannot be used to set default values for instance variables defined by __slots__; otherwise, the class attribute would overwrite the descriptor assignment.

- The action of a __slots__ declaration is not limited to the class where it is defined. __slots__ declared in parents are available in child classes. However, child subclasses will get a `__dict__` and __weakref__ unless they also define __slots__ (which should only contain names of any additional slots).

- 클래스가 베이스 클래스의 __slots__ 에 정의된 이름과 같은 이름의 변수를 __slots__ 에 선언한다면, 베이스 클래스가 정의한 변수는 액세스할 수 없는 상태가 됩니다(베이스 클래스로부터 디스크립터를 직접 조회하는 경우는 예외다). 이것은 프로그램을 정의되지 않은 상태로 보내게 됩니다. 미래에는, 이를 방지하기 위한 검사가 추가될 것입니다.

- `TypeError` will be raised if nonempty __slots__ are defined for a class derived from a `"variable-length" built-in type` such as `int`, `bytes`, and `tuple`.

- Any non-string iterable may be assigned to __slots__.

- If a `dictionary` is used to assign __slots__, the dictionary keys will be used as the slot names. The values of the dictionary can be used to provide per-attribute docstrings that will be recognised by `inspect.getdoc()` and displayed in the output of `help()`.

- `__class__` assignment works only if both classes have the same __slots__.

- Multiple inheritance with multiple slotted parent classes can be used, but only one parent is allowed to have attributes created by slots (the other bases must have empty slot layouts) - violations raise `TypeError`.

- If an iterator is used for __slots__ then a descriptor is created for each of the iterator’s values. However, the __slots__ attribute will be an empty iterator.

### 3.3.3. 클래스 생성 커스터마이제이션

Whenever a class inherits from another class, `__init_subclass__()` is called on the parent class. This way, it is possible to write classes which change the behavior of subclasses. This is closely related to class decorators, but where class decorators only affect the specific class they’re applied to, `__init_subclass__` solely applies to future subclasses of the class defining the method.

classmethod `object.``__init_subclass__`(cls)

  이 메서드는 포함하는 클래스의 서브 클래스가 만들어질 때마다 호출됩니다. cls 는 새 서브 클래스입니다. 만약 일반적인 인스턴스 메서드로 정의되면, 이 메서드는 묵시적으로 클래스 메서드로 변경됩니다.

  새 클래스에 주어진 키워드 인자들은 부모 클래스의 `__init_subclass__` 로 전달됩니다. `__init_subclass__` 를 사용하는 다른 클래스들과의 호환성을 위해, 필요한 키워드 인자들을 꺼낸 후에 다른 것들을 베이스 클래스로 전달해야 합니다. 이런 식입니다:

      class Philosopher:
          def __init_subclass__(cls, /, default_name, **kwargs):
              super().__init_subclass__(**kwargs)
              cls.default_name = default_name

      class AustralianPhilosopher(Philosopher, default_name="Bruce"):
          pass

  기본 구현 `object.__init_subclass__` 는 아무 일도 하지 않지만, 인자가 포함되어 호출되면 예외를 발생시킵니다.

  참고

  메타 클래스 힌트 `metaclass` 는 나머지 형 절차에 의해 소비되고, `__init_subclass__` 로 전달되지 않습니다. 실제 메타 클래스 (명시적인 힌트 대신에) 는 `type(cls)` 로 액세스할 수 있습니다.

  버전 3.6에 추가.

When a class is created, `type.__new__()` scans the class variables and makes callbacks to those with a `__set_name__()` hook.

`object.``__set_name__`(self, owner, name)

  Automatically called at the time the owning class owner is created. The object has been assigned to name in that class:

      class A:
          x = C()  # Automatically calls: x.__set_name__(A, 'x')

  If the class variable is assigned after the class is created, `__set_name__()` will not be called automatically. If needed, `__set_name__()` can be called directly:

      class A:
         pass

      c = C()
      A.x = c                  # The hook is not called
      c.__set_name__(A, 'x')   # Manually invoke the hook

  더 자세한 내용은 클래스 객체 만들기 을 참고하십시오.

  버전 3.6에 추가.

#### 3.3.3.1. 메타 클래스

기본적으로, 클래스는 `type()` 을 사용해서 만들어집니다. 클래스의 바디는 새 이름 공간에서 실행되고, 클래스 이름은 `type(name, bases, namespace)` 의 결과에 지역적으로 연결됩니다.

클래스를 만드는 과정은 클래스 정의 줄에 `metaclass` 키워드 인자를 전달하거나, 그런 인자를 포함한 이미 존재하는 클래스를 계승함으로써 커스터마이즈될 수 있습니다. 다음 예에서, `MyClass` 와 `MySubclass` 는 모두 `Meta` 의 인스턴스입니다.

    class Meta(type):
        pass

    class MyClass(metaclass=Meta):
        pass

    class MySubclass(MyClass):
        pass

클래스 정의에서 지정된 다른 키워드 인자들은 아래에서 설명되는 모든 메타 클래스 연산들로 전달됩니다.

클래스 정의가 실행될 때, 다음과 같은 단계가 수행됩니다.:

- MRO 항목이 결정됩니다;

- 적절한 메타 클래스가 결정됩니다;

- 클래스 이름 공간이 준비됩니다;

- 클래스 바디가 실행됩니다;

- 클래스 객체가 만들어집니다.

#### 3.3.3.2. MRO 항목 결정하기

클래스 정의에 나타나는 베이스 클래스가 `type` 의 인스턴스가 아닌 경우, 거기에서 `__mro_entries__` 메서드를 검색합니다. 발견되면, 원래의 베이스 튜플로 호출됩니다. 이 메서드는 이 베이스 대신에 사용될 클래스의 튜플을 돌려줘야 합니다. 튜플은 비어있을 수 있습니다. 이 경우 원래 베이스는 무시됩니다.

더 보기

PEP 560 - typing 모듈과 제네릭 형에 대한 코어 지원

#### 3.3.3.3. 적절한 메타 클래스 선택하기

클래스 정의의 적절한 메타 클래스는 다음과 같이 결정됩니다:

- 베이스와 명시적인 메타 클래스를 주지 않는 경우 `type()` 이 사용됩니다;

- 명시적인 메타 클래스가 지정되고, 그것이 `type()` 의 인스턴스가 아니면, 그것을 메타 클래스로 사용합니다;

- `type()` 의 인스턴스가 명시적인 메타 클래스로 주어지거나, 베이스가 정의되었으면, 가장 많이 파생된 메타 클래스가 사용됩니다.

가장 많이 파생된 메타 클래스는 명시적으로 지정된 메타 클래스(있다면)와 지정된 모든 베이스 클래스들의 메타 클래스들(즉, `type(cls)`) 중에서 선택됩니다. 가장 많이 파생된 메타 클래스는 이들 모두 의 서브 타입(subtype)입니다. 만약 어느 것도 이 조건을 만족하지 못한다면, 클래스 정의는 `TypeError` 를 발생시키며 실패합니다.

#### 3.3.3.4. 클래스 이름 공간 준비하기

Once the appropriate metaclass has been identified, then the class namespace is prepared. If the metaclass has a `__prepare__` attribute, it is called as `namespace = metaclass.__prepare__(name, bases, **kwds)` (where the additional keyword arguments, if any, come from the class definition). The `__prepare__` method should be implemented as a `classmethod`. The namespace returned by `__prepare__` is passed in to `__new__`, but when the final class object is created the namespace is copied into a new `dict`.

만약 메타 클래스에 `__prepare__` 어트리뷰트가 없다면, 클래스 이름 공간은 빈 순서 있는 매핑으로 초기화됩니다.

더 보기

PEP 3115 - 파이썬 3000 에서의 메타 클래스

  `__prepare__` 이름 공간 훅을 도입했습니다

#### 3.3.3.5. 클래스 바디 실행하기

클래스 바디는 (대략) `exec(body, globals(), namespace)` 과같이 실행됩니다. 일반적인 `exec()` 호출과 주된 차이점은 클래스 정의가 함수 내부에서 이루어질 때 어휘 스코핑(lexical scoping) 이 클래스 바디(모든 메서드들을 포함해서)로 하여금 현재와 외부 스코프에 있는 이름들을 참조하도록 허락한다는 것입니다.

하지만, 클래스 정의가 함수 내부에서 이루어질 때조차도, 클래스 내부에서 정의된 메서드들은 클래스 스코프에서 정의된 이름들을 볼 수 없습니다. 클래스 변수는 인스턴스나 클래스 메서드의 첫 번째 매개변수를 통해 액세스하거나 다음 섹션에서 설명하는 묵시적으로 어휘 스코핑된 `__class__` 참조를 통해야 합니다.

#### 3.3.3.6. 클래스 객체 만들기

일단 클래스 이름 공간이 클래스 바디를 실행함으로써 채워지면, 클래스 객체가 `metaclass(name, bases, namespace, **kwds)` 을 통해 만들어집니다(여기에서 전달되는 추가적인 키워드 인자들은 `__prepare__` 에 전달된 것들과 같습니다).

이 클래스 객체는 `super()` 에 인자를 주지 않는 경우 참조되는 것입니다. `__class__` 는 클래스 바디의 메서드들 중 어느 하나라도 `__class__` 나 `super` 를 참조할 경우 컴파일러에 의해 만들어지는 묵시적인 클로저(closure) 참조입니다. 이것은 인자 없는 형태의 `super()` 가 어휘 스코핑 기반으로 현재 정의되고 있는 클래스를 올바르게 찾을 수 있도록 합니다. 반면에 현재의 호출에 사용된 클래스나 인스턴스는 메서드로 전달된 첫 번째 인자에 기초해서 식별됩니다.

CPython 구현 상세: CPython 3.6 이상에서, `__class__` 셀(cell)은 클래스 이름 공간의 `__classcell__` 엔트리로 메타 클래스에 전달됩니다. 만약 존재한다면, 이것은 클래스가 올바르게 초기화되기 위해 `type.__new__` 호출까지 거슬러서 전파되어야 합니다. 이렇게 하지 못하면 파이썬 3.8 에서는 `RuntimeError`로 이어질 것입니다.

When using the default metaclass `type`, or any metaclass that ultimately calls `type.__new__`, the following additional customization steps are invoked after creating the class object:

1. The `type.__new__` method collects all of the attributes in the class namespace that define a `__set_name__()` method;

2. Those `__set_name__` methods are called with the class being defined and the assigned name of that particular attribute;

3. The `__init_subclass__()` hook is called on the immediate parent of the new class in its method resolution order.

클래스 객체가 만들어진 후에, 클래스 정의에 포함된 클래스 데코레이터들에게 (있다면) 클래스를 전달하고, 그 결과를 클래스가 정의되는 지역 이름 공간에 연결합니다.

`type.__new__` 로 새 클래스가 만들어질 때, 이름 공간 매개변수로 제공되는 객체는 새로 만든 순서 있는 매핑으로 복사되고, 원래의 객체는 버립니다. 새 사본은 읽기 전용 프락시(read-only proxy)로 둘러싸이는데, 이것이 클래스 객체의 `__dict__` 어트리뷰트가 됩니다.

더 보기

PEP 3135 - 새 super

  묵시적인 __class__ 클로저 참조를 설명합니다

#### 3.3.3.7. 메타 클래스의 용도

메타 클래스의 잠재적인 용도에는 한계가 없습니다. 탐색 된 몇 가지 아이디어들에는 enum, 로깅, 인터페이스 검사, 자동화된 위임(automatic delegation), 자동화된 프로퍼티(properety) 생성, 프락시(proxy), 프레임웍(framework), 자동화된 자원 로킹/동기화(automatic resource locking/synchronization) 등이 있습니다.

### 3.3.4. 인스턴스 및 서브 클래스 검사 커스터마이제이션

다음 메서드들은 `isinstance()` 와 `issubclass()` 내장 함수들의 기본 동작을 재정의하는 데 사용됩니다.

특히, 메타 클래스 `abc.ABCMeta` 는 추상 베이스 클래스(Abstract Base Class, ABC)를 다른 ABC를 포함한 임의의 클래스나 형(내장형을 포함합니다)에 “가상 베이스 클래스(virtual base class)”로 추가할 수 있게 하려고 이 메서드들을 구현합니다.

`class.``__instancecheck__`(self, instance)

  instance 가 (직접적이거나 간접적으로) class 의 인스턴스로 취급될 수 있으면 참을 돌려줍니다. 만약 정의되면, `isinstance(instance, class)` 를 구현하기 위해 호출됩니다.

`class.``__subclasscheck__`(self, subclass)

  subclass 가 (직접적이거나 간접적으로) class 의 서브 클래스로 취급될 수 있으면 참을 돌려줍니다. 만약 정의되면, `issubclass(subclass, class)` 를 구현하기 위해 호출됩니다.

이 메서드들은 클래스의 형(메타 클래스)에서 조회된다는 것에 주의해야 합니다. 실제 클래스에서 클래스 메서드로 정의될 수 없습니다. 이것은 인스턴스에 대해 호출되는 특수 메서드들의 조회와 일관성 있습니다. 이 경우 인스턴스는 클래스 자체다.

더 보기

PEP 3119 - 추상 베이스 클래스의 도입

  `__instancecheck__()` 와 `__subclasscheck__()` 를 통해 `isinstance()` 와 `issubclass()` 의 동작을 커스터마이징하는 데 필요한 규약을 포함하는데, 이 기능의 동기는 언어에 추상 베이스 클래스 (`abc` 모듈을 보십시오)를 추가하고자 하는 데 있습니다.

### 3.3.5. 제네릭 형 흉내 내기

When using type annotations, it is often useful to parameterize a generic type using Python’s square-brackets notation. For example, the annotation `list[int]` might be used to signify a `list` in which all the elements are of type `int`.

더 보기

PEP 484 - Type Hints

  Introducing Python’s framework for type annotations

Generic Alias Types

  Documentation for objects representing parameterized generic classes

제네릭, user-defined generics and `typing.Generic`

  Documentation on how to implement generic classes that can be parameterized at runtime and understood by static type-checkers.

A class can generally only be parameterized if it defines the special class method `__class_getitem__()`.

classmethod `object.``__class_getitem__`(cls, key)

  key 에 있는 형 인자에 의한 제네릭 클래스의 특수화를 나타내는 객체를 돌려줍니다.

  When defined on a class, `__class_getitem__()` is automatically a class method. As such, there is no need for it to be decorated with `@classmethod` when it is defined.

#### 3.3.5.1. The purpose of __class_getitem__

The purpose of `__class_getitem__()` is to allow runtime parameterization of standard-library generic classes in order to more easily apply type hints to these classes.

To implement custom generic classes that can be parameterized at runtime and understood by static type-checkers, users should either inherit from a standard library class that already implements `__class_getitem__()`, or inherit from `typing.Generic`, which has its own implementation of `__class_getitem__()`.

Custom implementations of `__class_getitem__()` on classes defined outside of the standard library may not be understood by third-party type-checkers such as mypy. Using `__class_getitem__()` on any class for purposes other than type hinting is discouraged.

#### 3.3.5.2. __class_getitem__ versus __getitem__

Usually, the subscription of an object using square brackets will call the `__getitem__()` instance method defined on the object’s class. However, if the object being subscribed is itself a class, the class method `__class_getitem__()` may be called instead. `__class_getitem__()` should return a GenericAlias object if it is properly defined.

Presented with the expression `obj[x]`, the Python interpreter follows something like the following process to decide whether `__getitem__()` or `__class_getitem__()` should be called:

    from inspect import isclass

    def subscribe(obj, x):
        """Return the result of the expression `obj[x]`"""

        class_of_obj = type(obj)

        # If the class of obj defines __getitem__,
        # call class_of_obj.__getitem__(obj, x)
        if hasattr(class_of_obj, '__getitem__'):
            return class_of_obj.__getitem__(obj, x)

        # Else, if obj is a class and defines __class_getitem__,
        # call obj.__class_getitem__(x)
        elif isclass(obj) and hasattr(obj, '__class_getitem__'):
            return obj.__class_getitem__(x)

        # Else, raise an exception
        else:
            raise TypeError(
                f"'{class_of_obj.__name__}' object is not subscriptable"
            )

In Python, all classes are themselves instances of other classes. The class of a class is known as that class’s metaclass, and most classes have the `type` class as their metaclass. `type` does not define `__getitem__()`, meaning that expressions such as `list[int]`, `dict[str, float]` and `tuple[str, bytes]` all result in `__class_getitem__()` being called:

    >>> # list has class "type" as its metaclass, like most classes:
    >>> type(list)
    <class 'type'>
    >>> type(dict) == type(list) == type(tuple) == type(str) == type(bytes)
    True
    >>> # "list[int]" calls "list.__class_getitem__(int)"
    >>> list[int]
    list[int]
    >>> # list.__class_getitem__ returns a GenericAlias object:
    >>> type(list[int])
    <class 'types.GenericAlias'>

However, if a class has a custom metaclass that defines `__getitem__()`, subscribing the class may result in different behaviour. An example of this can be found in the `enum` module:

    >>> from enum import Enum
    >>> class Menu(Enum):
    ...     """A breakfast menu"""
    ...     SPAM = 'spam'
    ...     BACON = 'bacon'
    ...
    >>> # Enum classes have a custom metaclass:
    >>> type(Menu)
    <class 'enum.EnumMeta'>
    >>> # EnumMeta defines __getitem__,
    >>> # so __class_getitem__ is not called,
    >>> # and the result is not a GenericAlias object:
    >>> Menu['SPAM']
    <Menu.SPAM: 'spam'>
    >>> type(Menu['SPAM'])
    <enum 'Menu'>

더 보기

PEP 560 - Core Support for typing module and generic types

  Introducing `__class_getitem__()`, and outlining when a subscription results in `__class_getitem__()` being called instead of `__getitem__()`

### 3.3.6. 콜러블 객체 흉내 내기

`object.``__call__`(self[, args...])

  인스턴스가 함수처럼 “호출될” 때 호출됩니다; 이 메서드가 정의되면, `x(arg1, arg2, ...)` 는 대략 `type(x).__call__(x, arg1, ...)`로 번역됩니다.

### 3.3.7. 컨테이너형 흉내 내기

The following methods can be defined to implement container objects. Containers usually are sequences (such as `lists` or `tuples`) or mappings (like `dictionaries`), but can represent other containers as well. The first set of methods is used either to emulate a sequence or to emulate a mapping; the difference is that for a sequence, the allowable keys should be the integers k for which `0 <= k < N` where N is the length of the sequence, or `slice` objects, which define a range of items. It is also recommended that mappings provide the methods `keys()`, `values()`, `items()`, `get()`, `clear()`, `setdefault()`, `pop()`, `popitem()`, `copy()`, and `update()` behaving similar to those for Python’s standard `dictionary` objects. The `collections.abc` module provides a `MutableMapping` abstract base class to help create those methods from a base set of `__getitem__()`, `__setitem__()`, `__delitem__()`, and `keys()`. Mutable sequences should provide methods `append()`, `count()`, `index()`, `extend()`, `insert()`, `pop()`, `remove()`, `reverse()` and `sort()`, like Python standard `list` objects. Finally, sequence types should implement addition (meaning concatenation) and multiplication (meaning repetition) by defining the methods `__add__()`, `__radd__()`, `__iadd__()`, `__mul__()`, `__rmul__()` and `__imul__()` described below; they should not define other numerical operators. It is recommended that both mappings and sequences implement the `__contains__()` method to allow efficient use of the `in` operator; for mappings, `in` should search the mapping’s keys; for sequences, it should search through the values. It is further recommended that both mappings and sequences implement the `__iter__()` method to allow efficient iteration through the container; for mappings, `__iter__()` should iterate through the object’s keys; for sequences, it should iterate through the values.

`object.``__len__`(self)

  내장함수 `len()` 를 구현하기 위해 호출됩니다. 객체의 길이를 돌려줘야 하는데, `>=` 0인 정수입니다. 또한 `__bool__()` 메서드를 정의하지 않은 객체의 `__len__()` 이 0을 돌려주면 논리 문맥에서 거짓으로 취급됩니다.

  CPython 구현 상세: CPython 에서, 길이는 최대 `sys.maxsize` 일 것이 요구됩니다. 만약 길이가 `sys.maxsize` 보다 크면, 어떤 기능들 (`len()` 과 같은)은 `OverflowError` 를 일으킬 수 있습니다. 참 거짓 검사에서 `OverflowError` 가 일어나는 것을 막기 위해, 객체는 `__bool__()` 를 정의해야 합니다.

`object.``__length_hint__`(self)

  `operator.length_hint()` 를 구현하기 위해 호출됩니다. 객체의 추정된 길이를 돌려줘야 합니다(실제 길이보다 크거나 작을 수 있습니다). 길이는 `>=` 0인 정수여야 합니다. 반환 값은 `NotImplemented` 일 수도 있으며, `__length_hint__` 메서드가 아예 존재하지 않는 것처럼 처리됩니다. 이 메서드는 순수하게 최적화를 위한 것이고 결코 올바름이 요구되지는 않습니다.

  버전 3.4에 추가.

참고

슬라이싱은 전적으로 다음에 나오는 세 메서드들에의해 수행됩니다

    a[1:2] = b

과 같은 호출은

    a[slice(1, 2, None)] = b

로 번역되고, 다른 형태도 마찬가지입니다. 빠진 슬라이스 항목은 항상 `None` 으로 채워집니다.

`object.``__getitem__`(self, key)

  Called to implement evaluation of `self[key]`. For sequence types, the accepted keys should be integers and slice objects. Note that the special interpretation of negative indexes (if the class wishes to emulate a sequence type) is up to the `__getitem__()` method. If key is of an inappropriate type, `TypeError` may be raised; if of a value outside the set of indexes for the sequence (after any special interpretation of negative values), `IndexError` should be raised. For mapping types, if key is missing (not in the container), `KeyError` should be raised.

  참고

  `for` 루프는 시퀀스의 끝을 올바로 감지하기 위해, 잘못된 인덱스에 대해 `IndexError` 가 일어날 것으로 기대하고 있습니다.

  참고

  When subscripting a class, the special class method `__class_getitem__()` may be called instead of `__getitem__()`. See __class_getitem__ versus __getitem__ for more details.

`object.``__setitem__`(self, key, value)

  `self[key]` 로의 대입을 구현하기 위해 호출됩니다. `__getitem__()` 과 같은 주의가 필요합니다. 매핑의 경우에는, 객체가 키에 대해 값의 변경이나 새 키의 추가를 허락할 경우, 시퀀스의 경우는 항목이 교체될 수 있을 때만 구현되어야 합니다. 잘못된 key 값의 경우는 `__getitem__()` 에서와 같은 예외를 일으켜야 합니다.

`object.``__delitem__`(self, key)

  `self[key]` 의 삭제를 구현하기 위해 호출됩니다. `__getitem__()` 과 같은 주의가 필요합니다. 매핑의 경우에는, 객체가 키의 삭제를 허락할 경우, 시퀀스의 경우는 항목이 시퀀스로부터 제거될 수 있을 때만 구현되어야 합니다. 잘못된 key 값의 경우는 `__getitem__()` 에서와 같은 예외를 일으켜야 합니다.

`object.``__missing__`(self, key)

  `dict`.`__getitem__()` 이 dict 서브 클래스에서 키가 딕셔너리에 없으면 `self[key]` 를 구현하기 위해 호출합니다.

`object.``__iter__`(self)

  This method is called when an iterator is required for a container. This method should return a new iterator object that can iterate over all the objects in the container. For mappings, it should iterate over the keys of the container.

`object.``__reversed__`(self)

  `reversed()` 내장 함수가 역 이터레이션(reverse iteration)을 구현하기 위해 (있다면) 호출합니다. 컨테이너에 있는 객체들을 역 순으로 탐색하는 새 이터레이터 객체를 돌려줘야 합니다.

  `__reversed__()` 메서드가 제공되지 않으면, `reversed()` 내장함수는 시퀀스 프로토콜(`__len__()` 과 `__getitem__()`)을 대안으로 사용합니다. 시퀀스 프로토콜을 지원하는 객체들은 `reversed()` 가 제공하는 것보다 더 효율적인 구현을 제공할 수 있을 때만 `__reversed__()` 를 제공해야 합니다.

멤버십 검사 연산자들(`in` 과 `not in`) 은 보통 컨테이너에 대한 이터레이션으로 구현됩니다. 하지만, 컨테이너 객체는 더 효율적인 구현을 다음과 같은 특수 메서드를 통해 제공할 수 있습니다. 이 경우 객체는 이터러블일 필요도 없습니다.

`object.``__contains__`(self, item)

  멤버십 검사 연산자를 구현하기 위해 호출됩니다. item 이 self 에 있으면 참을, 그렇지 않으면 거짓을 돌려줘야 합니다. 매핑 객체의 경우, 키-값 쌍이 아니라 매핑의 키가 고려되어야 합니다.

  `__contains__()` 를 정의하지 않는 객체의 경우, 멤버십 검사는 먼저 `__iter__()` 를 통한 이터레이션을 시도한 후, `__getitem__()` 을 통한 낡은 시퀀스 이터레이션 프로토콜을 시도합니다. 언어 레퍼런스의 이 절을 참고하십시오.

### 3.3.8. 숫자 형 흉내 내기

숫자 형을 흉내 내기 위해 다음과 같은 메서드들을 정의할 수 있습니다. 구현되는 특별한 종류의 숫자에 의해 지원되지 않는 연산들(예를 들어, 정수가 아닌 숫자들에 대한 비트 연산들)에 대응하는 메서드들을 정의되지 않은 채로 남겨두어야 합니다.

`object.``__add__`(self, other)
`object.``__sub__`(self, other)
`object.``__mul__`(self, other)
`object.``__matmul__`(self, other)
`object.``__truediv__`(self, other)
`object.``__floordiv__`(self, other)
`object.``__mod__`(self, other)
`object.``__divmod__`(self, other)
`object.``__pow__`(self, other[, modulo])
`object.``__lshift__`(self, other)
`object.``__rshift__`(self, other)
`object.``__and__`(self, other)
`object.``__xor__`(self, other)
`object.``__or__`(self, other)

  이 메서드들은 이항 산술 연산들(`+`, `-`, `*`, `@`, `/`, `//`, `%`, `divmod()`, `pow()`, `**`, `<<`, `>>`, `&`, `^`, `|`)을 구현하기 위해 호출됩니다. 예를 들어, x 가 `__add__()` 메서드를 가진 클래스의 인스턴스일 때, 표현식 `x + y` 의 값을 구하기 위해, `x.__add__(y)` 가 호출됩니다. `__divmod__()` 메서드는 `__floordiv__()` 와 `__mod__()` 를 사용하는 것과 동등해야 합니다; `__truediv__()` 와 연관되지 않아야 합니다; 내장 `pow()` 함수의 삼 항 버전이 지원되기 위해서는, `__pow__()` 메서드가 생략할 수 있는 세 번째 인자를 받도록 정의되어야 함에 주의해야 합니다.

  만약 이 메서드들 중 하나가 제공된 인자에 대해 연산을 지원하지 않으면, `NotImplemented` 를 돌려줘야 합니다.

`object.``__radd__`(self, other)
`object.``__rsub__`(self, other)
`object.``__rmul__`(self, other)
`object.``__rmatmul__`(self, other)
`object.``__rtruediv__`(self, other)
`object.``__rfloordiv__`(self, other)
`object.``__rmod__`(self, other)
`object.``__rdivmod__`(self, other)
`object.``__rpow__`(self, other[, modulo])
`object.``__rlshift__`(self, other)
`object.``__rrshift__`(self, other)
`object.``__rand__`(self, other)
`object.``__rxor__`(self, other)
`object.``__ror__`(self, other)

  이 메서드들은 뒤집힌 피연산자들에 대해 이항 산술 연산들(`+`, `-`, `*`, `@`, `/`, `//`, `%`, `divmod()`, `pow()`, `**`, `<<`, `>>`, `&`, `^`, `|`)을 구현하기 위해 호출됩니다. 이 함수들은 왼쪽의 피연산자가 해당 연산을 지원하지 않고 3, 피연산자들이 서로 다른 형일 때만 호출됩니다. 4 예를 들어, 표현식 `x - y` 의 값을 구하려고 할 때, y 가 `__rsub__()` 를 갖는 클래스의 인스턴스이고, `x.__sub__(y)` 가 NotImplemented 를 돌려주면 `y.__rsub__(x)` 가 호출됩니다.

  삼 항 `pow()` 는 `__rpow__()` 를 호출하려고 시도하지 않음에 주의해야 합니다 (그렇게 하려면 코어션 규칙이 너무 복잡해집니다).

  참고

  만약 오른쪽 피연산자의 형이 왼쪽 피연산자의 형의 서브 클래스이고, 그 서브 클래스가 연산의 뒤집힌 메서드의 다른 구현을 제공하면, 이 메서드가 왼쪽 연산자의 뒤집히지 않은 메서드보다 먼저 호출됩니다. 이 동작은 서브 클래스가 조상들의 연산을 재정의할 수 있도록 합니다.

`object.``__iadd__`(self, other)
`object.``__isub__`(self, other)
`object.``__imul__`(self, other)
`object.``__imatmul__`(self, other)
`object.``__itruediv__`(self, other)
`object.``__ifloordiv__`(self, other)
`object.``__imod__`(self, other)
`object.``__ipow__`(self, other[, modulo])
`object.``__ilshift__`(self, other)
`object.``__irshift__`(self, other)
`object.``__iand__`(self, other)
`object.``__ixor__`(self, other)
`object.``__ior__`(self, other)

  이 메서드들은 증분 산술 대입(`+=`, `-=`, `*=`, `@=`, `/=`, `//=`, `%=`, `**=`, `<<=`, `>>=`, `&=`, `^=`, `|=`)을 구현하기 위해 호출됩니다. 이 메서드는 연산을 제자리에서(self 를 수정해서) 하도록 시도해야 하고, 결과(반드시 그래야 하는 것은 아니지만 self 일 수 있습니다)를 돌려줘야 합니다. 만약 특정 메서드가 정의되지 않으면, 중분 대입은 일반적인 메서드들을 대신 사용합니다. 예를 들어, x 가 `__iadd__()` 메서드를 갖는 클래스의 인스턴스면, `x += y` 는 `x = x.__iadd__(y)` 와 동등합니다. 그렇지 않으면, `x + y` 의 값을 구할 때처럼, `x.__add__(y)` 와 `y.__radd__(x)` 가 고려됩니다. 어떤 상황에서, 증분 대입은 예상치 못한 에러로 이어질 수 있습니다. (덧셈은 작동하는데, 왜 a_tuple[i] += [‘item’]이 예외를 일으킵니까? 를 보십시오). 하지만 이 동작은 사실 데이터 모델의 일부입니다.

`object.``__neg__`(self)
`object.``__pos__`(self)
`object.``__abs__`(self)
`object.``__invert__`(self)

  일 항 산술 연산(`-`, `+`, `abs()`, `~`)을 구현하기 위해 호출됩니다.

`object.``__complex__`(self)
`object.``__int__`(self)
`object.``__float__`(self)

  내장 함수 `complex()`, `int()`, `float()`를 구현하기 위해 호출됩니다. 적절한 형의 값을 돌려줘야 합니다.

`object.``__index__`(self)

  `operator.index()` 를 구현하기 위해 호출되고, 파이썬이 숫자 객체를 정수 객체로 손실 없이 변환해야 할 때(슬라이싱이나 내장 `bin()`, `hex()`, `oct()` 함수들에서와같이)마다 호출됩니다. 이 메서드의 존재는 숫자 객체가 정수 형임을 가리킵니다. 반드시 정수를 돌려줘야 합니다.

  `__int__()`, `__float__()` 및 `__complex__()`가 정의되어 있지 않으면, 해당 내장 함수 `int()`, `float()` 및 `complex()`는 `__index__()`를 사용합니다.

`object.``__round__`(self[, ndigits])
`object.``__trunc__`(self)
`object.``__floor__`(self)
`object.``__ceil__`(self)

  내장 함수 `round()`와 `math` 함수 `trunc()`, `floor()`, `ceil()` 을 구현하기 위해 호출됩니다. ndigits 가 `__round__()` 로 전달되지 않는 한, 이 메서드들은 모두 `Integral` (보통 `int`) 로 잘린 객체의 값을 돌려줘야 합니다.

  The built-in function `int()` falls back to `__trunc__()` if neither `__int__()` nor `__index__()` is defined.

### 3.3.9. with 문 컨텍스트 관리자

컨텍스트 관리자 (context manager) 는 `with` 문을 실행할 때 자리 잡는 실행 컨텍스트(context)를 정의하는 객체입니다. 코드 블록의 실행을 위해, 컨텍스트 관리자는 원하는 실행시간 컨텍스트로의 진입과 탈출을 처리합니다. 컨텍스트 관리자는 보통 `with` 문(with 문 섹션에서 설명합니다)으로 시작되지만, 그들의 메서드를 호출해서 직접 사용할 수도 있습니다.

컨텍스트 관리자의 전형적인 용도에는 다양한 종류의 전역 상태(global state)를 보관하고 복구하는 것, 자원을 로킹(locking)하고 언로킹(unlocking)하는 것, 열린 파일을 닫는 것 등이 있습니다.

컨텍스트 관리자에 대한 더 자세한 정보는 컨텍스트 관리자 형 에 나옵니다.

`object.``__enter__`(self)

  이 객체와 연관된 실행시간 컨텍스트에 진입합니다. `with` 문은 `as` 절로 지정된 대상이 있다면, 이 메서드의 반환 값을 연결합니다.

`object.``__exit__`(self, exc_type, exc_value, traceback)

  이 객체와 연관된 실행시간 컨텍스트를 종료합니다. 매개변수들은 컨텍스트에서 벗어나게 만든 예외를 기술합니다. 만약 컨텍스트가 예외 없이 종료한다면, 세 인자 모두 `None` 이 됩니다.

  만약 예외가 제공되고, 메서드가 예외를 중지시키고 싶으면 (즉 확산하는 것을 막으려면) 참(true)을 돌려줘야 합니다. 그렇지 않으면 예외는 이 메서드가 종료한 후에 계속 진행됩니다.

  `__exit__()` 메서드가 전달된 예외를 다시 일으키지(reraise) 않도록 주의해야 합니다; 이것은 호출자(caller)의 책임입니다.

더 보기

PEP 343 - “with” 문

  파이썬 `with` 문에 대한 규격, 배경, 예.

### 3.3.10. Customizing positional arguments in class pattern matching

When using a class name in a pattern, positional arguments in the pattern are not allowed by default, i.e. `case MyClass(x, y)` is typically invalid without special support in `MyClass`. To be able to use that kind of pattern, the class needs to define a __match_args__ attribute.

`object.``__match_args__`

  This class variable can be assigned a tuple of strings. When this class is used in a class pattern with positional arguments, each positional argument will be converted into a keyword argument, using the corresponding value in __match_args__ as the keyword. The absence of this attribute is equivalent to setting it to `()`.

For example, if `MyClass.__match_args__` is `("left", "center", "right")` that means that `case MyClass(x, y)` is equivalent to `case MyClass(left=x, center=y)`. Note that the number of arguments in the pattern must be smaller than or equal to the number of elements in __match_args__; if it is larger, the pattern match attempt will raise a `TypeError`.

버전 3.10에 추가.

더 보기

PEP 634 - Structural Pattern Matching

  The specification for the Python `match` statement.

### 3.3.11. 특수 메서드 조회

사용자 정의 클래스의 경우, 묵시적인 특수 메서드의 호출은 객체의 인스턴스 딕셔너리가 아닌 객체의 형에 정의되어 있을 때만 올바르게 동작함이 보장됩니다. 이런 동작은 다음과 같은 코드가 예외를 일으키는 원인입니다:

    >>> class C:
    ...     pass
    ...
    >>> c = C()
    >>> c.__len__ = lambda: 5
    >>> len(c)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: object of type 'C' has no len()

The rationale behind this behaviour lies with a number of special methods such as `__hash__()` and `__repr__()` that are implemented by all objects, including type objects. If the implicit lookup of these methods used the conventional lookup process, they would fail when invoked on the type object itself:

    >>> 1 .__hash__() == hash(1)
    True
    >>> int.__hash__() == hash(int)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: descriptor '__hash__' of 'int' object needs an argument

클래스의 연결되지 않은 메서드를 호출하려는 이런 식의 잘못된 시도는 종종 ‘메타 클래스 혼란(metaclass confusion)’ 이라고 불리고, 특수 메서드를 조회할 때 인스턴스를 우회하는 방법으로 피할 수 있습니다.

    >>> type(1).__hash__(1) == hash(1)
    True
    >>> type(int).__hash__(int) == hash(int)
    True

In addition to bypassing any instance attributes in the interest of correctness, implicit special method lookup generally also bypasses the `__getattribute__()` method even of the object’s metaclass:

    >>> class Meta(type):
    ...     def __getattribute__(*args):
    ...         print("Metaclass getattribute invoked")
    ...         return type.__getattribute__(*args)
    ...
    >>> class C(object, metaclass=Meta):
    ...     def __len__(self):
    ...         return 10
    ...     def __getattribute__(*args):
    ...         print("Class getattribute invoked")
    ...         return object.__getattribute__(*args)
    ...
    >>> c = C()
    >>> c.__len__()                 # Explicit lookup via instance
    Class getattribute invoked
    10
    >>> type(c).__len__(c)          # Explicit lookup via type
    Metaclass getattribute invoked
    10
    >>> len(c)                      # Implicit lookup
    10

Bypassing the `__getattribute__()` machinery in this fashion provides significant scope for speed optimisations within the interpreter, at the cost of some flexibility in the handling of special methods (the special method must be set on the class object itself in order to be consistently invoked by the interpreter).

## 3.4. 코루틴(Coroutines)

### 3.4.1. 어웨이터블 객체(Awaitable Objects)

An awaitable object generally implements an `__await__()` method. Coroutine objects returned from `async def` functions are awaitable.

참고

The generator iterator objects returned from generators decorated with `types.coroutine()` or `asyncio.coroutine()` are also awaitable, but they do not implement `__await__()`.

`object.``__await__`(self)

  이터레이터 를 돌려줘야 합니다. 어웨이터블 객체를 구현하기 위해 사용되어야 합니다. 예를 들어, `asyncio.Future` 는 `await` 표현식과 호환되기 위해 이 메서드를 구현합니다.

  참고

  The language doesn’t place any restriction on the type or value of the objects yielded by the iterator returned by `__await__`, as this is specific to the implementation of the asynchronous execution framework (e.g. `asyncio`) that will be managing the awaitable object.

버전 3.5에 추가.

더 보기

PEP 492 가 어웨이터블 객체에 대한 더 자세한 정보를 포함하고 있습니다.

### 3.4.2. 코루틴 객체(Coroutine Objects)

Coroutine objects are awaitable objects. A coroutine’s execution can be controlled by calling `__await__()` and iterating over the result. When the coroutine has finished executing and returns, the iterator raises `StopIteration`, and the exception’s `value` attribute holds the return value. If the coroutine raises an exception, it is propagated by the iterator. Coroutines should not directly raise unhandled `StopIteration` exceptions.

코루틴은 다음에 나열하는 메서드들 또한 갖고 있는데, 제너레이터(제너레이터-이터레이터 메서드 를 보십시오)의 것들과 닮았습니다. 하지만, 제너레이터와는 달리, 코루틴은 이터레이션을 직접 지원하지는 않습니다.

버전 3.5.2에서 변경: 코루틴을 두 번 await 하면 `RuntimeError` 를 일으킵니다.

`coroutine.``send`(value)

  Starts or resumes execution of the coroutine. If value is `None`, this is equivalent to advancing the iterator returned by `__await__()`. If value is not `None`, this method delegates to the `send()` method of the iterator that caused the coroutine to suspend. The result (return value, `StopIteration`, or other exception) is the same as when iterating over the `__await__()` return value, described above.

`coroutine.``throw`(value)
`coroutine.``throw`(type[, value[, traceback]])

  Raises the specified exception in the coroutine. This method delegates to the `throw()` method of the iterator that caused the coroutine to suspend, if it has such a method. Otherwise, the exception is raised at the suspension point. The result (return value, `StopIteration`, or other exception) is the same as when iterating over the `__await__()` return value, described above. If the exception is not caught in the coroutine, it propagates back to the caller.

`coroutine.``close`()

  코루틴이 자신을 정리하고 종료하도록 만듭니다. 만약 코루틴이 일시 중지 중이면, 이 메서드는 먼저 코루틴이 일시 중지되도록 한 이터레이터의 `close()` 메서드로 위임합니다(그런 메서드를 가지는 경우). 그런 다음 일시 중지지점에서 `GeneratorExit` 를 발생시키는데, 코루틴이 즉시 자신을 정리하도록 만듭니다. 마지막으로 코루틴에 실행을 종료했다고 표시하는데, 아직 시작하지조차 않았을 때도 그렇다.

  코루틴 객체가 파괴될 때는 위의 프로세스에 따라 자동으로 닫힙니다(closed).

### 3.4.3. 비동기 이터레이터(Asynchronous Iterators)

비동기 이터레이터 는 자신의 `__anext__` 메서드에서 비동기 코드를 호출할 수 있습니다.

비동기 이터레이터는 `async for` 문에서 사용될 수 있습니다.

`object.``__aiter__`(self)

  비동기 이터레이터 객체를 돌려줘야 합니다.

`object.``__anext__`(self)

  이터레이터의 다음 값을 주는 어웨이터블 을 돌려줘야 합니다. 이터레이션이 끝나면 `StopAsyncIteration` 에러를 일으켜야 합니다.

비동기 이터러블 객체의 예:

    class Reader:
        async def readline(self):
            ...

        def __aiter__(self):
            return self

        async def __anext__(self):
            val = await self.readline()
            if val == b'':
                raise StopAsyncIteration
            return val

버전 3.5에 추가.

버전 3.7에서 변경: Prior to Python 3.7, `__aiter__()` could return an awaitable that would resolve to an asynchronous iterator.

Starting with Python 3.7, `__aiter__()` must return an asynchronous iterator object. Returning anything else will result in a `TypeError` error.

### 3.4.4. 비동기 컨텍스트 관리자

비동기 컨텍스트 관리자(asynchronous context manager) 는 `__aenter__` 와 `__aexit__` 메서드에서 실행을 일시 중지할 수 있는 컨텍스트 관리자 입니다.

비동기 컨텍스트 관리자는 `async with` 문에서 사용될 수 있습니다.

`object.``__aenter__`(self)

  `__enter__()` 메서드와 의미상으로 유사한데, 유일한 차이점은 어웨이터블 을 돌려줘야 한다는 것입니다.

`object.``__aexit__`(self, exc_type, exc_value, traceback)

  `__exit__()` 메서드와 의미상으로 유사한데, 유일한 차이점은 어웨이터블 을 돌려줘야 한다는 것입니다.

비동기 컨텍스트 관리자 클래스의 예:

    class AsyncContextManager:
        async def __aenter__(self):
            await log('entering context')

        async def __aexit__(self, exc_type, exc, tb):
            await log('exiting context')

버전 3.5에 추가.

각주

1

  어떤 제한된 조건으로, 어떤 경우에 객체의 형을 변경하는 것이 가능합니다. 하지만 잘못 다뤄지면 아주 괴상한 결과로 이어질 수 있으므로 일반적으로 좋은 생각이 아닙니다.

2

  The `__hash__()`, `__iter__()`, `__reversed__()`, and `__contains__()` methods have special handling for this; others will still raise a `TypeError`, but may do so by relying on the behavior that `None` is not callable.

3

  여기서 “지원하지 않는다” 는 클래스가 그런 메서드를 갖지 않거나, 메서드가 `NotImplemented` 를 돌려줌을 뜻합니다. 오른쪽 피연산자의 뒤집힌 메서드를 사용하는 대안이 시도되도록 하려면 메서드를 `None` 으로 설정하지 말아야 합니다 - 그렇게 하는 것은 그런 대안을 명시적으로 금지하는 반대 효과를 줍니다.

4

  For operands of the same type, it is assumed that if the non-reflected method – such as `__add__()` – fails then the overall operation is not supported, which is why the reflected method is not called.