Python

3. 데이터 모델

3.1. 객체, 값, 형

객체(Objects) 는 파이썬의 데이터에 대한 추상화입니다. 파이썬 프로그램의 모든 데이터는 객체 또는 객체 간의 관계로 표현됩니다. 코드 또한 객체로 표현됩니다.

모든 객체는 아이덴티티(identity), 타입, 값을 가집니다. 객체의 아이덴티티 는 생성된 후에는 절대 변하지 않으며, 메모리상의 객체 주소로 생각할 수 있습니다. is 연산자는 두 객체의 아이덴티티를 비교하며, id() 함수는 그 아이덴티티를 나타내는 정수를 반환합니다.

CPython 의 경우, id(x) 는 x 가 저장된 메모리의 주소입니다.

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

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

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

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

구현의 추적 또는 디버깅 기능을 사용하면 보통 가비지 수거(garbage-collect)되어야 할 객체가 살아 있게 될 수 있음에 유의하십시오. 또한, try…except 문으로 예외를 잡는 경우에도 객체가 유지될 수 있습니다.

일부 객체는 열려 있는 파일이나 윈도우와 같은 “외부” 리소스에 대한 참조를 포함합니다. 이러한 리소스는 객체가 가비지 수거될 때 해제되는 것으로 이해되지만, 가비지 수거가 보장되지 않기 때문에 이러한 객체들은 보통 close() 메서드와 같이 외부 리소스를 해제하는 명시적인 방법을 제공합니다. 프로그램에서 이러한 객체를 명시적으로 닫는 것을 강력히 권장합니다. try…finally 문과 with 문은 이를 처리하기 위한 편리한 방법을 제공합니다.

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

타입은 객체 동작의 거의 모든 측면에 영향을 미칩니다. 객체의 아이덴티티 중요성조차 어떤 의미에서 영향을 받습니다. 불변(immutable) 타입의 경우, 새로운 값을 계산하는 연산이 실제로 동일한 타입과 값을 가진 기존 객체의 참조를 반환할 수 있는 반면, 가변(mutable) 객체에서는 이것이 허용되지 않습니다. 예를 들어, a = 1; b = 1 이후 a 와 b 가 값 하나를 가진 동일한 객체를 가리킬지 여부는 구현에 따라 다릅니다. 이는 int 가 불변 타입이므로 1 에 대한 참조를 재사용할 수 있기 때문입니다. 이러한 동작은 사용되는 구현에 따라 달라지므로 의존해서는 안 되지만, 객체 아이덴티티 검사를 사용할 때 유의해야 할 사항입니다. 그러나 c = []; d = [] 이후 c 와 d 는 서로 다른 고유한 신규 생성 빈 리스트를 가리키는 것이 보장됩니다. (참고로 e = f = [] 는 e 와 f 에 동일한 객체를 할당합니다.)

3.2. 표준형 계층

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

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

3.2.1. None

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

3.2.2. NotImplemented

이 타입은 단 하나의 값만을 가집니다. 이 값을 가진 객체도 하나뿐입니다. 이 객체는 내장된 이름 NotImplemented 를 통해 접근합니다. 수치 메서드 및 풍부한 비교(rich comparison) 메서드는 제공된 피연산자에 대해 해당 연산을 구현하지 않는 경우 이 값을 반환해야 합니다. (그 후 인터프리터는 연산자에 따라 반영된 연산이나 다른 대체 방법을 시도합니다.) 이 값은 불리언 문맥에서 평가해서는 안 됩니다.

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

버전 3.9에서 변경: NotImplemented 을 불리언 문맥에서 평가하는 것이 폐지되었습니다.

버전 3.14에서 변경: NotImplemented 을 불리언 문맥에서 평가하면 이제 TypeError 가 발생합니다. 이전에는 파이썬 3.9부터 True 를 반환하며 DeprecationWarning 을 발생시켰습니다.

3.2.3. Ellipsis

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

3.2.4. numbers.Number

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

__repr__() 및 __str__() 에 의해 계산되는 수치 클래스의 문자열 표현은 다음과 같은 특성을 가집니다:

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

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

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

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

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

파이썬은 정수, 부동 소수점 수, 복소수를 구분합니다.

3.2.4.1. numbers.Integral

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

참고

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

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

정수 (int)

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

불린 (bool)

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

3.2.4.2. numbers.Real (float)

이것들은 머신 수준의 배정밀도(double precision) 부동 소수점 수를 나타냅니다. 허용 범위 및 오버플로 처리는 기반 하드웨어 아키텍처(및 C 또는 Java 구현)에 따릅니다. 파이썬은 단정밀도(single-precision) 부동 소수점 수를 지원하지 않습니다. 단정밀도를 사용하여 얻을 수 있는 프로세서 및 메모리 절약 효과가 파이썬에서 객체를 사용하는 오버헤드에 비해 미미하기 때문에, 두 종류의 부동 소수점 수로 언어를 복잡하게 만들 이유가 없습니다.

3.2.4.3. numbers.Complex (complex)

이것들은 복소수를 머신 수준의 배정밀도 부동 소수점 수 쌍으로 나타냅니다. 부동 소수점 수와 동일한 주의 사항이 적용됩니다. 복소수 z 의 실수부와 허수부는 읽기 전용 속성인 z.real 및 z.imag 을 통해 가져올 수 있습니다.

3.2.5. 시퀀스들

이것들은 비음수로 인덱싱되는 유한 순서 집합을 나타냅니다. 내장 함수 len() 은 시퀀스의 항목 수를 반환합니다. 시퀀스의 길이가 n 인 경우, 인덱스 세트는 0, 1, …, n-1의 숫자를 포함합니다. 시퀀스 a 의 항목 i 는 a[i] 로 선택됩니다. 내장 시퀀스를 포함한 일부 시퀀스는 음수 인덱스를 시퀀스 길이를 더하여 해석합니다. 예를 들어, a[-2] 는 길이가 n 인 시퀀스 a의 마지막에서 두 번째 항목인 a[n-2] 와 같습니다.

결과 값은 시퀀스 항목 수보다 작은 비음수 정수여금여야 합니다. 그렇지 않으면 IndexError 가 발생합니다.

시퀀스는 슬라이싱도 지원합니다: a[start:stop] 은 start <= k < stop 을 만족하는 인덱스 k 를 가진 모든 항목을 선택합니다. 표현식으로 사용될 때, 슬라이스는 동일한 유형의 시퀀스입니다. 음수 인덱스에 관한 위의 설명은 음수 슬라이스 위치에도 적용됩니다. 슬라이스 위치가 0보다 작거나 시퀀스의 길이보다 큰 경우 오류가 발생하지 않습니다.

If start is missing or None, slicing behaves as if start was zero. If stop is missing or None, slicing behaves as if stop was equal to the length of the sequence.

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

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

3.2.5.1. 불변 시퀀스

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

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

문자열(Strings)

문자열(str)은 문자`를 표현하는 값들의 시퀀스이며, 더 엄밀하게는 *유니코드 코드 포인트*입니다. ``0``에서 ``0x10FFFF` 범위의 모든 코드 포인트를 문자열로 표현할 수 있습니다.

Python에는 별도의 문자(character) 형이 없습니다. 대신 문자열의 모든 코드 포인트는 길이가 1 인 문자열 객체로 표현됩니다.

내장 함수 ord() 는 코드 포인트를 문자열 형태에서 0 부터 0x10FFFF 사이의 정수로 변환하며, chr() 은 0 부터 0x10FFFF 사이의 정수를 해당 길이 1 의 문자열 객체로 변환합니다. str.encode() 는 주어진 텍스트 인코딩을 사용하여 str 을 bytes 로 변환하는 데 사용되며, bytes.decode() 는 그 반대의 작업을 수행할 때 사용됩니다.

튜플(Tuples)

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

바이트열(Bytes)

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

3.2.5.2. 가변 시퀀스

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

참고

collections 및 array 모듈은 가변 시퀀스 형의 추가적인 사례를 제공합니다.

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

리스트(Lists)

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

바이트 배열(Byte Arrays)

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

3.2.6. 집합 형들(Set types)

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

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

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

집합(Sets)

이것들은 가변 집합을 나타냅니다. 내장 set() 생성자로 생성되며 이후에 add() 와 같은 여러 메서드에 의해 수정될 수 있습니다.

불변 집합(Frozen sets)

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

3.2.7. 매핑(Mappings)

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

두 가지 내장 매핑 형이 있습니다:

3.2.7.1. 딕셔너리(Dictionaries)

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

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

딕셔너리는 가변적입니다. {} 표기법을 사용하여 생성할 수 있습니다(섹션 딕셔너리 디스플레이 참조).

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

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

3.2.7.2. 동결된 딕셔너리 (Frozen dictionaries)

These represent an immutable dictionary. They are created by the built-in frozendict() constructor. A frozendict is hashable if all of its keys and values are hashable, in which case it can be used as an element of a set, or as a key in another mapping. frozendict is not a subclass of dict; it inherits directly from object.

Added in version 3.15.

3.2.8. 콜러블(Callable types)

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

3.2.8.1. 사용자 정의 함수

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

3.2.8.1.1. 특수 읽기 전용 어트리뷰트

어트리뷰트

의미
function.__builtins__

함수의 내장(builtins) 네임스페이스를 포함하는 딕셔너리 에 대한 참조.

Added in version 3.10.
function.__globals__

함수의 전역 변수 을 포함하는 딕셔너리 에 대한 참조. 이는 함수가 정의된 모듈의 전역 네임스페이스입니다.
function.__closure__

None or a tuple of cells that contain bindings for the names specified in the co_freevars attribute of the function’s code object.

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

이 어트리뷰트 대부분은 할당된 값의 형을 확인합니다.

어트리뷰트

의미
function.__doc__

함수의 문서화 문자열(docstring), 또는 사용할 수 없는 경우 None.
function.__name__

함수의 이름. 참고: __name__ 어트리뷰트.
function.__qualname__

함수의 정규화된 이름. 참고: __qualname__ 어트리뷰트.

Added in version 3.3.
function.__module__

함수가 정의된 모듈의 이름 또는 (없는 경우) None
function.__defaults__

A tuple containing default parameter values for those parameters that have defaults, or None if no parameters have a default value.
function.__code__

컴파일된 함수 바디를 나타내는 코드 객체.
function.__dict__

임의의 함수 어트리뷰트를 지원하는 네임스페이스. 참고: __dict__ 어트리뷰트.
function.__annotations__

매개 변수 의 어노테이션을 포함하는 딕셔너리 입니다. 딕셔너리의 키는 매개 변수 이름이며, 제공되는 경우 반환 어노테이션은 'return' 이 됩니다. 참고: object.__annotations__.

버전 3.14에서 변경: 어노테이션은 이제 지연 평가됩니다. PEP 649 를 참조하십시오.
function.__annotate__

이 함수의 어노테이트 함수, 또는 함수에 어노테이션이 없는 경우 None. object.__annotate__ 를 참조하십시오.

Added in version 3.14.
function.__kwdefaults__

키워드 전용 매개 변수 의 기본값을 포함하는 딕셔너리.
function.__type_params__

A tuple containing the type parameters of a generic function.

Added in version 3.12.

함수 객체는 또한 임의의 어트리뷰트를 가져오고 설정하는 것을 지원하며, 이는 예를 들어 함수에 메타데이터를 첨부하는 데 사용될 수 있습니다. 이러한 어트리뷰트를 가져오거나 설정할 때는 일반적인 어트리뷰트 점(dot) 표기법이 사용됩니다.

현재 CPython 구현은 사용자 정의 함수에 대해서만 함수 어트리뷰트를 지원합니다. 내장 함수 의 함수 어트리뷰트는 향후 지원될 수 있습니다.

함수 정의에 관한 추가 정보는 해당 함수의 코드 객체 (어트리뷰트 __code__ 를 통해 접근 가능)에서 가져올 수 있습니다.

3.2.8.2. 인스턴스 메서드(Instance methods)

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

특수 읽기 전용 어트리뷰트:

method.__self__

메서드가 결합된 클래스 인스턴스 객체를 가리킵니다.
method.__func__

원본 함수 객체 를 가리킵니다.
method.__doc__

메서드의 문서화 내용(어트리뷰트 method.__func__.__doc__ 와 동일). 원본 함수가 문서화 문자열을 가졌다면 문자열, 그렇지 않으면 None 입니다.
method.__name__

메서드의 이름(어트리뷰트 method.__func__.__name__ 와 동일)
method.__module__

메서드가 정의된 모듈의 이름 또는 사용할 수 없는 경우 None.

메서드는 또한 하위에 있는 함수 객체 의 임의의 함수 어트리뷰트에 접근하는 것을 지원합니다(설정은 불가).

클래스의 어트리뷰트를 가져올 때(해당 클래스의 인스턴스를 통해서일 수도 있음) 해당 어트리뷰트가 사용자 정의 함수 객체 또는 classmethod 객체인 경우, 사용자 정의 메서드 객체가 생성될 수 있습니다.

인스턴스를 통해 클래스로부터 사용자 정의 함수 객체 를 가져와 인스턴스 메서드 객체가 생성될 때, 해당 객체의 __self__ 어트리뷰트는 그 인스턴스가 되며, 이 메서드 객체는 결합된(bound) 상태라고 합니다. 새 메서드의 __func__ 어트리뷰트는 원본 함수 객체입니다.

클래스나 인스턴스로부터 classmethod 객체를 가져와 인스턴스 메서드 객체가 생성될 때, 그 객체의 __self__ 어트리뷰트는 클래스 자체이며, __func__ 어트리뷰트는 해당 클래스 메서드의 기반이 되는 함수 객체입니다.

인스턴스 메서드 객체가 호출될 때 기반이 되는 함수(__func__)가 호출되며, 이때 클래스 인스턴스(__self__)가 인자 목록의 맨 앞에 추가됩니다. 예를 들어, C 가 메서드 f() 를 포함하는 클래스이고 x 가 C 의 인스턴스인 경우, x.f(1) 을 호출하는 것은 C.f(x, 1) 을 호출하는 것과 동일합니다.

인스턴스 메서드 객체가 classmethod 객체로부터 파생된 경우, __self__ 에 저장되는 “클래스 인스턴스”는 실제로 클래스 자체가 됩니다. 따라서 x.f(1) 또는 C.f(1) 중 어느 것을 호출하든 기반이 되는 함수가 f 인 경우 f(C, 1) 을 호출하는 것과 동일합니다.

클래스 인스턴스의 어트리뷰스인 사용자 정의 함수는 결합된 메서드로 변환되지 않는다는 점에 주의해야 합니다. 이 변환은 오직 해당 함수가 클래스의 어트리뷰스일 때만 발생합니다.

3.2.8.3. 제너레이터 함수(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.

3.2.8.4. 코루틴 함수(Coroutine functions)

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

3.2.8.5. 비동기 제너레이터 함수(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.

3.2.8.6. 내장 함수(Built-in functions)

내장 함수 객체는 C 함수를 래핑한 것입니다. 내장 함수의 예로는 len() 과 math.sin() (math 은 표준 내장 모듈임)이 있습니다. 인수의 개수와 유형은 C 함수에 의해 결정됩니다. 특수 읽기 전용 어트리뷰트:

  • __doc__ 는 함수의 문서화 문자열이며, 사용할 수 없는 경우 None 입니다. function.__doc__ 를 참조하십시오.

  • __name__ 는 함수의 이름입니다. function.__name__ 을 참조하십시오.

  • __self__ 는 None 으로 설정됩니다(그러나 다음 항목을 참고하십시오).

  • __module__ 은 함수가 정의된 모듈의 이름이며, 사용할 수 없는 경우 None 입니다. function.__module__ 을 참조하십시오.

3.2.8.7. 내장 메서드(Built-in methods)

이것은 사실 내장 함수의 또 다른 형태이며, 이번에는 C 함수에 암시적 추가 인자로 전달되는 객체를 포함합니다. 내장 메서드의 예로 alist 가 리스트 객체라고 가정할 때 alist.append() 를 들 수 있습니다. 이 경우 특수 읽기 전용 어트리뷰트인 __self__ 는 alist 로 표시되는 객체로 설정됩니다.(이 어트리뷰트는 다른 인스턴스 메서드 와 동일한 의미를 갖습니다.)

3.2.8.8. 클래스(Classes)

클래스는 호출 가능합니다. 이러한 객체들은 보통 자기 자신의 새로운 인스턴스를 만드는 팩토리 역할을 하지만, __new__() 를 재정의하는 클래스 타입의 경우 변동이 있을 수 있습니다. 호출 시 전달된 인자들은 __new__() 로 전달되며, 일반적인 경우 새 인스턴스를 초기화하기 위해 __init__() 로 전달됩니다.

3.2.8.9. 클래스 인스턴스(Class Instances)

임의의 클래스 인스턴스는 해당 클래스에 __call__() 메서드를 정의함으로써 호출 가능하게 만들 수 있습니다.

3.2.9. 모듈(Modules)

모듈은 파이썬 코드의 기본 조직 단위이며, import 문이나 importlib.import_module() 및 내장된 __import__() 와 같은 함수를 호출할 때 활성화되는 import system 에 의해 생성됩니다. 모듈 객체는 dictionary 객체로 구현된 이름 공간(namespace)을 가집니다 (이는 모듈 내에서 정의된 함수의 __globals__ 어트리뷰트가 참조하는 딕셔너리입니다). 어트리뷰트 참조는 이 딕셔너리에서의 조회로 변환되며, 예를 들어 m.x 는 m.__dict__["x"] 와 동일합니다. 모듈 객체는 모듈을 초기화하는 데 사용된 코드 객체를 포함하지 않습니다 (초기화가 완료되면 필요하지 않기 때문입니다).

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

3.2.9.2. 모듈 객체의 기타 쓰기 가능 어트리뷰트

위에서 나열한 임포트 관련 어트리뷰트 외에도 모듈 객체는 다음과 같은 쓰기 가능한 어트리뷰트를 가집니다.

module.__doc__

모듈의 설명 문자열이며, 사용할 수 없는 경우 None 입니다. 또한 __doc__ attributes 를 참조하십시오.

module.__annotations__

모듈 본문 실행 중에 수집된 변수 어노테이션 을 포함하는 딕셔너리입니다. __annotations__ 를 사용하는 모범 사례는 annotationlib 를 참조하십시오.

버전 3.14에서 변경: 어노테이션은 이제 지연 평가됩니다. PEP 649 를 참조하십시오.

module.__annotate__

이 모듈의 annotate function 이며, 모듈에 어노테이션이 없는 경우 None 입니다. 또한 __annotate__ 어트리뷰트를 참조하십시오.

Added in version 3.14.

module.__lazy_modules__

전체 경로가 포함된 모듈 이름 문자열의 컨테이너( __contains__() 를 구현하는 객체)입니다. 모듈 범위에서 정의될 때, 해당 모듈 내의 일반적인 import 문 중 대상 모듈 이름이 이 컨테이너에 포함된 경우, 마치 lazy 키워드가 사용된 것처럼 lazy import 로 취급됩니다. 함수 내부, 클래스 본문, 또는 try/except/finally 블록 내의 임포트는 영향을 받지 않습니다.

자세한 내용과 예제는 __lazy_modules__ 를 통한 호환성 를 참조하십시오.

Added in version 3.15.

3.2.9.3. 모듈 딕셔너리

모듈 객체는 다음과 같은 특수한 읽기 전용 어트리뷰트도 가집니다.

module.__dict__

딕셔너리 객체로서의 모듈 이름 공간입니다. 여기에 나열된 어트리뷰트 중 유독 __dict__ 는 모듈 내부에서 전역 변수로 접근할 수 없으며, 오직 모듈 객체의 어트리뷰트로만 접근 가능합니다.

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

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

사용자 정의 클래스 타입은 보통 클래스 정의에 의해 생성됩니다(섹션 클래스 정의 참조). 클래스는 딕셔너리 객체로 구현된 이름 공간을 갖습니다. 클래스 어트리뷰트 참조는 이 딕셔너리에서의 조회로 변환되며, 예를 들어 C.x 는 C.__dict__["x"] 로 해석됩니다(어트리뷰트를 찾는 다른 방법들을 허용하는 여러 후크가 존재하지만). 해당 위치에서 어트리뷰트 이름을 찾지 못하면 어트리뷰트 검색은 베이스 클래스에서 계속됩니다. 이 베이스 클래스 검색에는 C3 메서드 결정 순서(MRO)를 사용하며, 이는 공통 조상으로 이어지는 여러 상속 경로가 존재하는 ‘다이아몬드’ 상속 구조에서도 올바르게 동작합니다. 파이썬이 사용하는 C3 MRO에 대한 자세한 내용은 Python 2.3 메서드 결정 순서 에서 확인할 수 있습니다.

클래스 어트리뷰트 참조(예를 들어 클래스 C)가 클래스 메서드 객체를 반환할 경우, 이는 __self__ 어트리뷰트가 C 인 인스턴스 메서드 객체로 변환됩니다. staticmethod 객체를 반환하는 경우, 이는 정적 메서드 객체에 의해 래핑된 객체로 변환됩니다. 클래스에서 가져온 어트리뷰트가 실제로 그 어트리뷰트의 __dict__ 에 포함된 것과 다를 수 있는 또 다른 방식은 디스크립터 구현하기 섹션을 참조하십시오.

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

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

3.2.10.1. 특수 어트리뷰트

어트리뷰트

의미
type.__name__

클래스의 이름입니다. 또한 __name__ attributes 를 참조하십시오.
type.__qualname__

클래스의 qualified name 입니다. 또한 __qualname__ attributes 를 참조하십시오.
type.__module__

해당 클래스가 정의된 모듈의 이름입니다.
type.__dict__

클래스의 이름 공간을 읽기 전용으로 보여주는 mapping proxy 입니다. 또한 __dict__ attributes 를 참조하십시오.
type.__bases__

클래스의 베이스를 포함하는 tuple 입니다. 대부분의 경우, class X(A, B, C) 와 같이 정의된 클래스에 대해 X.__bases__ 는 정확히 (A, B, C) 와 일치합니다.
type.__base__

인스턴스의 메모리 레이아웃을 담당하는 상속 체인 내의 단일 베이스 클래스입니다. 이 어트리뷰트는 C 수준에서 tp_base 에 해당합니다.
type.__doc__

클래스의 설명 문자열이며, 정의되지 않은 경우 None 입니다. 하위 클래스에 상속되지 않습니다.
type.__annotations__

클래스 바디 실행 중에 수집된 변수 어노테이션 을 포함하는 딕셔너리입니다. 관련 내용: __annotations__ 어트리뷰트.

__annotations__ 를 다루는 모범 사례에 대해서는 annotationlib 을 참조하십시오. 이 어트리뷰트에 직접 접근하는 대신 annotationlib.get_annotations() 를 사용하십시오.

경고

클래스 객체에서 __annotations__ 어트리뷰트에 직접 접근하면 잘못된 클래스의 어노테이션이 반환될 수 있습니다. 특히 클래스, 베이스 클래스 또는 메타클래스가 from __future__ import annotations 하에 정의된 특정 경우에 그러합니다. 자세한 내용은 749 를 참조하십시오.

이 어트리뷰트는 일부 내장 클래스에는 존재하지 않습니다. __annotations__ 가 없는 사용자 정의 클래스의 경우, 이는 빈 딕셔너리입니다.

버전 3.14에서 변경: 어노테이션은 이제 지연 평가됩니다. PEP 649 를 참조하십시오.
type.__annotate__()

The annotate function for this class, or None if the class has no annotations. See also: __annotate__ attributes.

Added in version 3.14.
type.__type_params__

제네릭 클래스(generic class)의 타입 매개변수 를 포함하는 tuple 입니다.

Added in version 3.12.
type.__static_attributes__

클래스 바디 내의 모든 함수에서 self.X 를 통해 할당되는 어트리뷰트 이름들을 포함하는 tuple 입니다.

Added in version 3.13.
type.__firstlineno__

데코레이터를 포함한 클래스 정의의 첫 번째 줄 번호입니다. __module__ 어트리뷰트를 설정하면 타입 딕셔너리에서 __firstlineno__ 항목이 제거됩니다.

Added in version 3.13.
type.__mro__

메서드 결정 과정에서 베이스 클래스를 찾을 때 고려되는 클래스들의 tuple 입니다.

3.2.10.2. 특수 메서드

위에 설명된 특수 어트리뷰트 외에도 모든 파이썬 클래스는 다음 두 가지 메서드를 사용할 수 있습니다.

type.mro()

이 메서드는 인스턴스의 메서드 결정 순서를 사용자 정의하기 위해 메타클래스에 의해 재정의될 수 있습니다. 클래스 인스턴스 생성 시 호출되며, 그 결과는 __mro__ 에 저장됩니다.

type.__subclasses__()

각 클래스는 직계 서브클래스에 대한 약한 참조의 리스트를 유지합니다. 이 메서드는 아직 살아있는 모든 참조의 리스트를 반환하며, 리스트는 정의 순서대로 되어 있습니다. 예시:

>>> class A: pass
>>> class B(A): pass
>>> A.__subclasses__()
[<class 'B'>]

3.2.11. 클래스 인스턴스(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.

어트리뷰트 할당 및 삭제는 인스턴스의 딕셔너리를 업데이트하며, 클래스 딕셔너리는 절대 수정하지 않습니다. 만약 클래스가 __setattr__() 또는 __delattr__() 메서드를 보유하고 있다면, 인스턴스 딕셔너리를 직접 업데이트하는 대신 이 메서드들이 호출됩니다.

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

3.2.11.1. 특수 어트리뷰트

object.__class__

클래스 인스턴스가 속한 클래스입니다.

object.__dict__

객체의 (쓰기 가능한) 어트리뷰트를 저장하는 데 사용되는 딕셔너리 또는 기타 매핑 객체입니다. 모든 인스턴스가 __dict__ 어트리뷰트를 가지는 것은 아닙니다. 자세한 내용은 __slots__ 섹션을 참조하십시오.

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

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

파일 객체는 일반적인 코드에서 사용을 간소화하기 위해 아래 나열된 공통 메서드들을 구현합니다. 이들은 with 문 컨텍스트 관리자 로 동작해야 합니다.

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

file.read(size=-1, /)

파일에서 최대 size 만큼의 데이터를 가져옵니다. 편리함을 위해 size 가 지정되지 않거나 -1인 경우 사용 가능한 모든 데이터를 가져옵니다.

file.write(data, /)

data 를 파일에 저장합니다.

file.close()

모든 버퍼를 플러시하고 기본 파일을 닫습니다.

3.2.13. 내부 형(Internal types)

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

3.2.13.1. 코드 객체(Code objects)

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

3.2.13.1.1. 특수 읽기 전용 어트리뷰트
codeobject.co_name

함수 이름
codeobject.co_qualname

전체 경로가 포함된 함수 이름

Added in version 3.11.
codeobject.co_argcount

함수가 가진 위치형 매개변수 의 총 개수(위치 전용 매개변수 및 기본값이 있는 매개변수 포함)
codeobject.co_posonlyargcount

함수가 가진 위치 전용 매개변수 의 개수(기본값이 있는 인자 포함)
codeobject.co_kwonlyargcount

함수가 가진 키워드 전용 매개변수 의 개수(기본값이 있는 인자 포함)
codeobject.co_nlocals

함수에서 사용되는 지역 변수 의 수(매개변수 포함)
codeobject.co_varnames

함수 내 지역 변수들의 이름을 포함하는 tuple (매개변수 이름부터 시작).
codeobject.co_cellvars

함수 내의 최소 하나 이상의 중첩된 범위 에서 참조되는 지역 변수 들의 이름을 포함하는 tuple.
codeobject.co_freevars

함수 내부의 중첩된 범위 가 외부 범위에서 참조하는 자유 (클로저) 변수 들의 이름을 포함하는 tuple 입니다. 관련 내용: function.__closure__.

참고: 전역 및 내장 이름에 대한 참조는 포함되지 않습니다.
codeobject.co_code

함수 내의 바이트 코드 명령 시퀀스를 나타내는 문자열입니다.
codeobject.co_consts

함수의 바이트 코드 에서 사용되는 리터럴을 포함하는 tuple 입니다.
codeobject.co_names

함수의 바이트 코드 에서 사용되는 이름을 포함하는 tuple 입니다.
codeobject.co_filename

코드가 컴파일된 파일의 이름입니다.
codeobject.co_firstlineno

함수의 첫 번째 줄 번호입니다.
codeobject.co_stacksize

코드 객체에 필요한 스택 크기입니다.
codeobject.co_flags

인터프리터를 위한 여러 플래그를 인코딩하는 정수 입니다.

co_flags 에는 다음과 같은 플래그 비트가 정의되어 있습니다: 비트 0x04 는 함수가 임의의 수의 위치 인자를 받기 위해 *arguments 구문을 사용하는 경우 설정됩니다. 비트 0x08 은 함수가 임의의 키워드 인자를 받기 위해 **keywords 구문을 사용하는 경우 설정됩니다. 비트 0x20 는 함수가 제너레이터인 경우 설정됩니다. 존재할 수 있는 각 플래그의 의미에 대한 자세한 내용은 코드 객체 비트 플래그 를 참조하십시오.

미래 기능 선언(예: from __future__ import division) 또한 특정 기능이 활성화된 상태에서 코드 객체가 컴파일되었는지 여부를 나타내기 위해 co_flags 의 비트를 사용합니다. compiler_flag 를 참조하십시오.

co_flags 의 다른 비트들은 내부 용도로 예약되어 있습니다.

코드 객체가 함수를 나타내고 독스트링을 포함하는 경우, co_flags 에 CO_HAS_DOCSTRING 비트가 설정되며, co_consts 의 첫 번째 항목이 함수의 독스트링이 됩니다.

3.2.13.1.2. 코드 객체의 메서드
codeobject.co_positions()

코드 객체 내의 각 바이트 코드 명령에 대한 소스 코드 위치를 이터레이블로 반환합니다.

이터레이터는 (start_line, end_line, start_column, end_column) 을 포함하는 tuple 들을 반환합니다. i 번째 튜플은 i 번째 코드 단위로 컴파일된 소스 코드의 위치에 해당합니다. 열 정보는 주어진 소스 줄에서 인덱스가 0부터 시작하는 UTF-8 바이트 오프셋입니다.

이 위치 정보는 누락될 수 있습니다. 발생 가능한 사례의 일부를 나열하면 다음과 같습니다.

  • -X no_debug_ranges 와 함께 인터프리터를 실행하는 경우.

  • -X no_debug_ranges 를 사용하여 컴파일된 pyc 파일을 로드하는 경우.

  • 인위적인 명령에 해당하는 위치 튜플.

  • 구현상의 제약으로 인해 표현할 수 없는 줄 및 열 번호.

이런 경우 발생하면, 튜플 요소 중 일부 또는 전체가 None 일 수 있습니다.

Added in version 3.11.

참고

이 기능은 코드 객체에 열 위치를 저장해야 하므로 컴파일된 파이썬 파일의 디스크 사용량이나 인터프리터 메모리 사용량이 약간 증가할 수 있습니다. 추가 정보를 저장하지 않거나 추가 트레이스백 정보 출력을 비활성화하려면 -X no_debug_ranges 명령줄 플래그 또는 PYTHONNODEBUGRANGES 환경 변수를 사용할 수 있습니다.

codeobject.co_lines()

연속된 바이트 코드 범위에 대한 정보를 생성하는 이터레이터를 반환합니다. 출력되는 각 항목은 (start, end, lineno) 형태의 tuple 입니다.

  • start (int)는 바이트 코드 범위 시작의 오프셋(포함)을 나타냅니다.

  • end (int)는 바이트 코드 범위 끝의 오프셋(제외)을 나타냅니다.

  • lineno 는 바이트 코드 범위의 줄 번호를 나타내는 int 이며, 해당 범위의 바이트 코드가 줄 번호가 없는 경우 None 입니다.

생성되는 항목은 다음과 같은 속성을 가집니다:

  • 첫 번째로 생성되는 범위는 start 가 0입니다.

  • (start, end) 범위는 비감소하며 연속적입니다. 즉, 모든 tuple 쌍에 대해 두 번째 요소의 start 는 첫 번째 요소의 end 와 동일합니다.

  • 모든 트리플에 대해 end >= start 이므로 범위가 역순으로 나타나지 않습니다.

  • 마지막으로 생성되는 tuple 은 end 가 bytecode 의 크기와 같습니다.

start == end 인 너비가 0인 범위도 허용됩니다. 너비가 0인 범위는 소스 코드에는 존재하지만 bytecode 컴파일러에 의해 제거된 줄에 사용됩니다.

Added in version 3.10.

더 보기

PEP 626 - 디버깅 및 기타 도구를 위한 정확한 줄 번호

co_lines() 메서드를 도입한 PEP입니다.

codeobject.replace(**kwargs)

지정된 필드에 대한 새 값으로 코드 객체의 복사본을 반환합니다.

코드 객체는 일반 함수인 copy.replace() 에 의해서도 지원됩니다.

Added in version 3.8.

3.2.13.2. 프레임 객체(Frame objects)

프레임(Frame) 객체는 실행 프레임을 나타냅니다. 이들은 traceback objects 에서 발생할 수 있으며, 등록된 트레이스 함수에도 전달됩니다.

3.2.13.2.1. 특수 읽기 전용 어트리뷰트
frame.f_back

이전 스택 프레임(호출자 방향)을 가리키며, 현재가 최하위 스택 프레임인 경우 None 을 반환합니다.
frame.f_code

이 프레임에서 실행 중인 code object 입니다. 이 어트리뷰트에 접근하면 인자 obj 와 "f_code" 를 가진 auditing event object.__getattr__ 가 발생합니다.
frame.f_locals

프레임이 local variables 을 조회하는 데 사용하는 매핑입니다. 프레임이 optimized scope 를 참조하는 경우, 쓰기-투과(write-through) 프록시 객체를 반환할 수 있습니다.

버전 3.13에서 변경: 최적화된 스코프를 위한 프록시를 반환합니다.
frame.f_globals

프레임이 global variables 을 조회하는 데 사용하는 딕셔너리입니다.
frame.f_builtins

프레임이 built-in (intrinsic) names 를 조회하는 데 사용하는 딕셔너리입니다.
frame.f_lasti

프레임 객체의 “정확한 명령(precise instruction)”입니다(이는 code object 의 bytecode 문자열 내 인덱스입니다).
frame.f_generator

이 프레임을 소유하는 generator 또는 coroutine 객체이며, 프레임이 일반 함수인 경우 None 을 반환합니다.

Added in version 3.14.
3.2.13.2.2. 특수 쓰기 가능 어트리뷰트
frame.f_trace

None 이 아닌 경우, 이는 코드 실행 중 발생하는 다양한 이벤트에 대해 호출되는 함수입니다(디버거에서 사용됨). 일반적으로 새 소스 줄마다 이벤트가 트리거됩니다(참고: f_trace_lines).
frame.f_trace_lines

이 어트리뷰트를 False 로 설정하여 각 소스 줄에 대한 트레이싱 이벤트를 비활성화할 수 있습니다.
frame.f_trace_opcodes

이 어트리뷰트를 True 로 설정하여 옵코드별(per-opcode) 이벤트를 요청할 수 있게 합니다. 주의: 트레이스 함수에서 발생한 예외가 추적 중인 함수로 전파될 경우 인터프리터 동작이 정의되지 않을 수 있습니다.
frame.f_lineno

프레임의 현재 줄 번호입니다. 트레이스 함수 내에서 이 값을 쓰면 해당 줄로 이동합니다(최하위 프레임에만 적용). 디버거는 이 어트리뷰션에 값을 써서 Jump 명령(또는 Set Next Statement)을 구현할 수 있습니다.
3.2.13.2.3. 프레임 객체 메서드

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

frame.clear()

이 메서드는 프레임이 보유하는 모든 local variables 에 대한 참조를 해제합니다. 또한, 프레임이 generator 에 속한 경우 해당 제너레이터를 마무리(finalize)합니다. 이는 프레임 객체가 포함된 참조 순환을 끊는 데 도움이 됩니다(예: exception 를 포착하고 나중에 사용하기 위해 그 traceback 를 저장하는 경우).

프레임이 현재 실행 중이거나 일시 중단된 상태인 경우 RuntimeError 가 발생합니다.

Added in version 3.4.

버전 3.13에서 변경: 일시 중지된 프레임을 해제하려고 시도하면 RuntimeError 가 발생합니다(실행 중인 프레임의 경우와 마찬가지로).

3.2.13.3. 트레이스백 객체(Traceback objects)

Traceback 객체는 exception 의 스택 트레이스를 나타냅니다. 예외가 발생할 때 Traceback 객체가 암시적으로 생성되며, types.TracebackType 을 호출하여 명시적으로 생성할 수도 있습니다.

버전 3.7에서 변경: 이제 Traceback 객체를 파이썬 코드에서 명시적으로 인스턴스화할 수 있습니다.

암시적으로 생성된 트레이스백의 경우, 예외 핸들러를 찾는 과정에서 실행 스택을 거꾸로 올라갈 때(unwind), 각 단계마다 현재 트레이스백 앞에 트레이스백 객체가 삽입됩니다. 예외 핸들러에 진입하면 프로그램에서 스택 트레이스를 사용할 수 있게 됩니다.(try 문 섹션 참조) 이는 sys.exc_info() 가 반환하는 튜플의 세 번째 항목으로 접근하거나, 포획된 예외의 __traceback__ 어트리뷰스로 접근할 수 있습니다.

프로그램에 적절한 핸들러가 없는 경우 스택 트레이스가 표준 에러 스트림에 (보기 좋게 포맷되어) 기록됩니다. 인터프리터가 대화형 모드인 경우, 사용자에게 sys.last_traceback 으로도 제공됩니다.

명시적으로 생성된 트레이스백의 경우, tb_next 어트리뷰스가 전체 스택 트레이스를 형성하도록 연결되는 방식은 트레이스백을 생성한 쪽에서 결정합니다.

특수 읽기 전용 어트리뷰트:

traceback.tb_frame

현재 레벨의 실행 frame 를 가리킵니다.

이 어트리뷰스에 접근하면 인자 obj 와 "tb_frame" 을 가진 auditing event object.__getattr__ 가 발생합니다.
traceback.tb_lineno

예외가 발생한 줄 번호를 제공합니다.
traceback.tb_lasti

“정확한 명령(precise instruction)”을 나타냅니다.

트레이스백의 줄 번호와 마지막 명령은 일치하는 except 절이 없는 try 문이나 finally 절에서 예외가 발생한 경우, 해당 frame object 의 줄 번호와 다를 수 있습니다.

traceback.tb_next

특별한 쓰기 가능 어트리뷰스인 tb_next 는 스택 트레이스의 다음 레벨(예외가 발생한 프레임 방향)을 가리키며, 다음 레벨이 없는 경우 None 입니다.

버전 3.7에서 변경: 이 어트리뷰스는 이제 쓰기 가능합니다.

3.2.13.4. 슬라이스 객체(Slice objects)

Slice 객체는 __getitem__() 메서드용 슬라이스를 나타내는 데 사용됩니다. 또한 내장된 slice() 함수에 의해 생성됩니다.

Added in version 3.15: slice() 타입은 이제 subscription 를 지원합니다. 예를 들어, 타입 어노테이션에서 slice[float] 를 사용하여 float 객체를 포함하는 슬라이스를 나타낼 수 있습니다.

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

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

slice.indices(self, length)

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

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

스태틱 메서드(Static method) 객체는 앞서 설명한 함수 객체가 메서드 객체로 변환되는 것을 방지하는 방법을 제공합니다. 스태틱 메서드 객체는 다른 객체(보통 사용자가 정의한 메서드 객체)를 감싸는 래퍼입니다. 클래스나 클래스 인스턴스에서 스태틱 메서드 객체를 가져올 때, 실제로 반환되는 것은 랩핑된 객체이며 더 이상의 변환을 거치지 않습니다. 또한 스태틱 메서드 객체는 호출 가능합니다. 스태틱 메서드 객체는 내장된 staticmethod() 생성자에 의해 만들어집니다.

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

클래스 메서드(Class method) 객체는 스태틱 메서드와 마찬가지로 다른 객체를 감싸며, 해당 객체가 클래스와 클래스 인스턴스에서 가져오는 방식을 변경합니다. 이러한 호출 시 클래스 메서드 객체의 동작은 위에서 설명한 “instance methods” 항목 아래에 기술되어 있습니다. 클래스 메서드 객체는 내장된 classmethod() 생성자에 의해 만들어집니다.

3.3. 특수 메서드 이름들

클래스는 특별한 이름의 메서드를 정의함으로써 특수한 구문(산술 연산이나 인덱싱 및 슬라이싱 등)에 의해 호출되는 특정 연산을 구현할 수 있습니다. 이는 파이썬이 operator overloading 을 처리하는 방식이며, 클래스가 언어 연산자에 대한 고유한 동작을 정의할 수 있게 해줍니다. 예를 들어, 클래스가 __getitem__() 이라는 이름의 메서드를 정의하고 x 가 이 클래스의 인스턴스라면, x[i] 는 대략적으로 type(x).__getitem__(x, i) 와 동일합니다. 별도로 언급되지 않는 한, 적절한 메서드가 정의되어 있지 않은 상태에서 연산을 실행하려고 하면 예외가 발생합니다(일반적으로 AttributeError 또는 TypeError).

특별한 메서드를 None 으로 설정하는 것은 해당 연산이 사용 가능하지 않음을 나타냅니다. 예를 들어, 클래스가 __iter__() 를 None 으로 설정하면, 그 클래스는 반복 가능하지 않으므로 인스턴스에 iter() 를 호출하면 ( __getitem__() 으로 폴백되지 않고) TypeError 가 발생합니다. [2]

내장 타입을 모방하는 클래스를 구현할 때는 모델링되는 객체에 적합한 범위 내에서만 모방이 이루어지도록 하는 것이 중요합니다. 예를 들어, 일부 시퀀스는 개별 요소를 가져오는 것은 잘 작동할 수 있지만 슬라이스를 추출하는 것은 의미가 없을 수 있습니다. (이것의 한 예로 W3C 문서 객체 모델(DOM)의 NodeList 인터페이스가 있습니다.)

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

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

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

일반적인 구현은 적절한 인자를 사용하여 super().__new__(cls[, ...]) 로 상위 클래스의 __new__() 메서드를 호출하여 클래스의 새 인스턴스를 생성하고, 반환하기 전에 필요에 따라 새로 생성된 인스턴스를 수정합니다.

객체 생성 중에 __new__() 가 호출되고 cls 의 인스턴스를 반환하면, 새 인스턴스의 __init__() 메서드가 __init__(self[, ...]) 와 같이 호출됩니다. 이때 self 는 새 인스턴스이며 나머지 인자는 객체 생성자 표현에 전달된 것과 동일합니다.

만약 __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__() 메서드가 호출된다는 보장이 없습니다. weakref.finalize 를 사용하면 객체가 가비지 컬렉션될 때 실행될 정리 함수를 등록하는 간단한 방법을 제공합니다.

참고

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

참조 순환으로 인해 객체의 참조 횟수가 0이 되지 않을 수 있습니다. 이 경우 해당 순환은 나중에 cyclic garbage collector 에 의해 감지되어 삭제됩니다. 참조 순환의 흔한 원인은 지역 변수에서 예외를 잡았을 때 발생합니다. 프레임의 로컬 변수가 예외를 참조하고, 그 예외가 자신의 추적(traceback)을 참조하며, 해당 추적이 다시 추적에 포착된 모든 프레임의 로컬 변수를 참조하게 되기 때문입니다.

더 보기

gc 모듈에 대한 문서.

경고

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

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

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

object.__repr__(self)

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

이것은 대개 디버깅에 사용되므로 표현이 풍부한 정보를 담고 모호하지 않아야 합니다. 기본 구현은 object 클래스 자체에 의해 제공됩니다.

object.__str__(self)

객체의 “비형식적”이거나 읽기 좋게 출력 가능한 문자열 표현을 계산하기 위해 str(object), 기본 __format__() 구현, 및 내장 함수 print() 에 의해 호출됩니다. 반환 값은 반드시 str 객체여야 합니다.

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

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

object.__bytes__(self)

객체의 바이트 문자열 표현을 계산하기 위해 bytes 에 의해 호출됩니다. 이 메서드는 bytes 객체를 반환해야 합니다. object 클래스 자체는 이 메서드를 제공하지 않습니다.

object.__format__(self, format_spec)

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

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

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

object 클래스에 의한 기본 구현은 빈 format_spec 문자열을 받습니다. 이 메서드는 __str__() 로 작업을 넘깁니다.

버전 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) 를 호출합니다.

풍부한 비교(rich comparison) 메서드는 주어진 인자 쌍에 대해 해당 연산을 구현하지 않은 경우 단일 객체인 NotImplemented 를 반환할 수 있습니다. 관례적으로 성공적인 비교의 경우 False 와 True 가 반환됩니다. 그러나 이러한 메서드들은 어떤 값이라도 반환할 수 있으므로, 비교 연산자가 불리언(Boolean) 문맥에서 사용될 경우(예: if 문의 조건문), 파이썬은 해당 값을 통해 결과가 참인지 거짓인지 판단하기 위해 bool() 을 호출합니다.

기본적으로 object 는 is 를 사용하여 __eq__() 를 구현하며, 비교가 거짓인 경우 NotImplemented 를 반환합니다: True if x is y else NotImplemented. __ne__() 의 경우 기본적으로 __eq__() 에 위임하고 결과가 NotImplemented 가 아닌 한 결과를 반전시킵니다. 비교 연산자나 기본 구현 사이에 다른 암묵적인 관계는 없습니다. 예를 들어, (x<y or x==y) 가 참이라고 해서 x<=y 가 참임을 보장하지 않습니다. 단일 루트 연산으로부터 정렬 연산을 자동으로 생성하려면 @functools.total_ordering 을 참조하십시오.

기본적으로 object 클래스는 값 비교 와 일치하는 구현을 제공합니다. 즉, 동등성은 객체의 동일성에 따라 비교하고, 순서 비교는 TypeError 를 발생시킵니다. 각 기본 메서드는 이러한 결과를 직접 생성할 수도 있고, NotImplemented 를 반환할 수도 있습니다.

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

이 메서드들은 인자가 뒤바뀐 버전(왼쪽 인자가 연산을 지원하지 않지만 오른쪽 인자가 지원하는 경우에 사용)이 없습니다. 대신, __lt__() 와 __gt__() 는 서로의 반사(reflection)이고, __le__() 와 __ge__() 도 서로의 반사이며, __eq__() 와 __ne__() 은 각각 자체적인 반사입니다. 피연산자가 다른 유형이고 오른쪽 피연산자의 타입이 왼쪽 피연산자 타입의 직접 또는 간접 서브클래스인 경우, 오른쪽 피연산자의 반영된 메서드가 우선권을 가지며, 그렇지 않으면 왼쪽 피연산자의 메서드가 우선권을 갖습니다. 가상(virtual) 서브클래싱은 고려되지 않습니다.

적절한 메서드가 NotImplemented 이외의 값을 반환하지 않는 경우, == 및 != 연산자는 각각 is 및 is not 으로 대체됩니다.

object.__hash__(self)

내장 함수 hash() 에 의해 호출되며, set, frozenset, dict, frozendict 를 포함한 해시 컬렉션 멤버의 연산 시 사용됩니다. __hash__() 메서드는 정수를 반환해야 합니다. 유일하게 요구되는 속성은 동등하게 비교되는 객체들이 동일한 해시 값을 가져야 한다는 것입니다. 객체의 구성 요소 중 객체 비교에도 관여하는 부분의 해시 값들을 튜플로 묶어 튜플을 해싱함으로써 혼합하여 사용하는 것이 권장됩니다. 예시:

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)" 입니다.

클래스가 __eq__() 메서드를 정의하지 않는다면 __hash__() 연산도 정의해서는 안 됩니다. 만약 클래스가 __eq__() 를 정의하지만 __hash__() 를 정의하지 않는 경우, 해당 인스턴스는 해시 가능한 컬렉션의 요소로 사용할 수 없습니다. 클래스가 가변 객체를 정의하고 __eq__() 메서드를 구현하는 경우, hashable 컬렉션의 구현은 키의 해시 값이 불변임을 요구하므로(객체의 해시 값이 변경되면 잘못된 해시 버킷에 위치하게 됨) __hash__() 를 구현해서는 안 됩니다.

사용자가 정의한 클래스는 기본적으로 __eq__() 와 __hash__() 메서드를 가집니다(object 클래스에서 상속됨). 이 메서드들을 통해 모든 객체는 (자기 자신을 제외하고) 서로 다르다고 비교되며, 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)” 있습니다. 개별 파이썬 프로세스 내에서는 변하지 않는 값으로 유지되지만, 파이썬을 반복적으로 실행할 때는 예측할 수 없게 됩니다.

이것은 딕셔너리 삽입의 최악의 경우 성능인 O(n2) 복잡도를 악용하는 정교하게 선택된 입력으로 인해 발생하는 서비스 거부(DoS)를 방지하기 위한 것입니다. 자세한 내용은 https://ocert.org/advisories/ocert-2011-003.html을 참조하십시오.

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

PYTHONHASHSEED 를 참고하십시오.

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

object.__bool__(self)

참/거짓 값 테스트 및 내장 연산 bool() 을 구현하기 위해 호출되며, False 또는 True 를 반환해야 합니다. 이 메서드가 정의되지 않은 경우, 정의되어 있다면 __len__() 이 호출되며 그 결과가 0이 아니면 객체가 참으로 간주됩니다. 클래스가 __len__() 과 __bool__() 을 모두 정의하지 않는 경우(이것은 object 클래스 자체에 해당함), 모든 인스턴스가 참으로 간주됩니다.

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

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

object.__getattr__(self, name)

기본 속성 액세스가 AttributeError 로 실패할 때 호출됩니다(name 이 인스턴스 속성이 아니거나 self 의 클래스 트리 내에 있는 속성이 아니어서 __getattribute__() 가 AttributeError 를 발생시키거나, name 프로퍼티의 __get__() 이 AttributeError 를 발생시키는 경우). 이 메서드는 (계산된) 속성 값을 반환하거나 AttributeError 예외를 발생시켜야 합니다. object 클래스 자체는 이 메서드를 제공하지 않습니다.

일반적인 메커니즘을 통해 속성을 찾은 경우, __getattr__() 이 호출되지 않는다는 점에 유의하십시오. (이는 __getattr__() 과 __setattr__() 사이의 의도된 비대칭성입니다.) 이는 효율성 문제와 더불어 그렇지 않을 경우 __getattr__() 이 인스턴스의 다른 속성에 접근할 방법이 없기 때문에 수행됩니다. 최소한 인스턴스 변수의 경우, 인스턴스 속성 딕셔너리에 어떤 값도 삽입하지 않고(대신 다른 객체에 삽입) 완전히 제어할 수 있습니다. 속성 액세스를 실제로 완전히 제어하는 방법을 확인하려면 아래의 __getattribute__() 메서드를 참조하십시오.

object.__getattribute__(self, name)

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

참고

언어 구문을 통한 암시적 호출이나 built-in functions 를 통해 결과로 특수 메서드를 찾는 경우 이 메서드가 무시될 수 있습니다. 특수 메서드 조회 을 참조하십시오.

특정 민감한 어트리뷰트 액세스의 경우, 인자 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() 이 호출될 때 호출됩니다. 반복 가능한(iterable) 객체를 반환해야 합니다. dir() 은 반환된 반복 가능한 객체를 리스트로 변환하고 정렬합니다.

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

module.__getattr__()
module.__dir__()

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

__dir__ 함수는 인수를 받지 않아야 하며, 모듈에서 접근 가능한 이름을 나타내는 문자열의 반복 가능한 객체를 반환해야 합니다. 이 함수가 존재하면 모듈에 대한 표준 dir() 검색을 대체합니다.

module.__class__

모듈 동작(어트리뷰트 설정, 프로퍼티 등)을 보다 세밀하게 사용자 정의하려면, 모듈 객체의 __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__ 모듈 어트리뷰트가 쓰기 가능합니다.

Added in version 3.7: __getattr__ 과 __dir__ 모듈 어트리뷰트.

더 보기

PEP 562 - 모듈 __getattr__ 과 __dir__

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

3.3.2.2. 디스크립터 구현하기

다음 메서드들은 메서드를 포함하는 클래스(소위 디스크립터 클래스)의 인스턴스가 소유자 클래스에 나타날 때만 적용됩니다(디스크립터는 소유자의 클래스 딕셔너리 또는 부모 중 하나의 클래스 딕셔너리에 있어야 합니다). 아래 예제에서 “어트리뷰트”는 소유자 클래스의 __dict__ 에서 속성 키가 곧 이름인 어트리뷰트를 의미합니다. object 클래스 자체는 이러한 프로토콜을 구현하지 않습니다.

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__ 속성을 가질 수 있습니다:

object.__objclass__

속성 __objclass__ 는 inspect 모듈에 의해 이 객체가 정의된 클래스를 명시하는 것으로 해석됩니다(이를 적절하게 설정하면 동적 클래스 속성의 런타임 내성(introspection)이 용이해집니다). 호출 가능한 객체(callable)의 경우, 첫 번째 위치 인수로 주어진 유형(또는 하위 클래스)의 인스턴스가 예상되거나 필요함을 나타낼 수 있습니다 (예를 들어, CPython은 C로 구현된 바인딩되지 않은 메서드에 대해 이 속성을 설정합니다).

3.3.2.3. 디스크립터 호출하기

일반적으로 디스크립터는 “바인딩 동작”을 가진 객체 속성으로, 그 속성에 대한 접근이 디스크립터 프로토콜의 메서드인 __get__(), __set__(), 그리고 __delete__() 에 의해 재정의된 것을 말합니다. 어떤 객체가 이들 중 하나라도 정의하고 있으면 디스크립터라고 합니다.

어트리뷰트 액세스의 기본 동작은 객체의 딕셔너리에서 어트리뷰트를 읽고, 쓰고, 삭제하는 것입니다. 예를 들어 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 결합

super(A, a).x 와 같은 점(dotted) 조항은 a.__class__.__mro__ 에서 A 다음에 오는 베이스 클래스 B 를 검색한 후 B.__dict__['x'].__get__(a, A) 를 반환합니다. 디스크립터가 아닌 경우 x 는 변하지 않은 채로 반환됩니다.

인스턴스 바인딩의 경우, 디스크립터 호출 우선순위는 어떤 디스크립터 메서드가 정의되어 있는지에 따라 달라집니다. 디스크립터는 __get__(), __set__(), 그리고 만약 :meth:()!__get__`을 정의하지 않는다면, 객체의 인스턴스 딕셔너리에 값이 있는 경우를 제외하고 해당 속성에 접근하면 디스크립터 객체 자체가 반환됩니다. 만약 디스크립터가 __set__() 및/또는 __delete__`를 정의하면 데이터 디스크립터(data descriptor)이고, 둘 다 정의하지 않으면 비데이터 디스크립터(non-data descriptor)입니다. 보통 데이터 디스크립터는 :meth:()!__get__`과 __set__`을 모두 정의하고, 비데이터 디스크립터는 :meth:()!__get__` 메서드만 가집니다. __get__`과 :meth:()!__set__` (및/또는 __delete__())이 정의된 데이터 디스크립터는 인스턴스 딕셔너리에서의 재정의를 항상 무시합니다. 이와 대조적으로, 비데이터 디스크립터는 인스턴스에 의해 재정의될 수 있습니다.

파이썬 메서드(는 @staticmethod 및 @classmethod 로 데코레이션된 것을 포함하여)는 비데이터 디스크립터로 구현됩니다. 따라서 인스턴스는 메서드를 재정의하고 덮어쓸 수 있습니다. 이를 통해 개별 인스턴스가 동일한 클래스의 다른 인스턴스와는 다른 동작을 가질 수 있게 됩니다.

@property 데코레이터는 데이터 디스크립터로 구현됩니다. 따라서 인스턴스는 프로퍼티의 동작을 덮어쓸 수 없습니다.

3.3.2.4. __slots__

__slots__ 을 사용하면 데이터 멤버(프로퍼티와 같은)를 명시적으로 선언하고, __dict__ 와 __weakref__ 의 생성을 방지할 수 있습니다(단, __slots__ 에 명시적으로 선언되거나 부모 클래스에서 제공되는 경우는 제외).

__dict__ 를 사용하는 대신 절약되는 공간이 상당할 수 있으며, 속성 조회 속도 또한 크게 향상될 수 있습니다.

object.__slots__

이 클래스 변수에는 인스턴스에서 사용되는 변수 이름이 포함된 문자열, 반복 가능한 객체 또는 문자열 시퀀스를 할당할 수 있습니다. __slots__ 은 선언된 변수를 위한 공간을 예약하고 각 인스턴스에 대해 __dict__ 와 __weakref__ 가 자동으로 생성되는 것을 방지합니다.

__slots__ 사용 시 주의사항:

  • __slots__ 이 없는 클래스로부터 상속할 때, 인스턴스의 __dict__ 와 __weakref__ 속성은 항상 접근 가능합니다.

  • __dict__ 변수가 없으면 인스턴스에 __slots__ 정의에 나열되지 않은 새 변수를 할당할 수 없습니다. 목록에 없는 변수 이름에 할당을 시도하면 AttributeError 가 발생합니다. 새로운 변수의 동적 할당이 필요한 경우, __slots__ 선언의 문자열 시퀀스에 '__dict__' 를 추가하십시오.

  • 각 인스턴스에 대한 __weakref__ 변수가 없으면, __slots__ 을 정의하는 클래스는 인스턴스에 대한 weak references 를 지원하지 않습니다. 약한 참조(weak reference) 지원이 필요한 경우, __slots__ 선언의 문자열 시퀀스에 '__weakref__' 를 추가하십시오.

  • __slots__ 은 각 변수 이름에 대해 descriptors 를 생성함으로써 클래스 수준에서 구현됩니다. 그 결과, __slots__ 로 정의된 인스턴스 변수에 대한 기본값을 설정하는 데 클래스 속성을 사용할 수 없습니다(그렇지 않으면 클래스 속성이 디스크립터 할당을 덮어쓰게 됩니다).

  • __slots__ 선언의 효과는 정의된 클래스에만 국한되지 않습니다. 부모에서 선언된 __slots__ 은 자식 클래스에서도 사용할 수 있습니다. 그러나 서브클래스가 별도로 __slots__ 을 정의하지 않는 한, 해당 서브클래스의 인스턴스는 __dict__ 와 __weakref__ 를 가지게 됩니다(이때 서브클래스에서 정의하는 __slots__ 은 추가적인 슬롯의 이름만 포함해야 합니다).

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

  • tuple 을 제외하고, int, bytes, type 과 같은 "가변 길이" 내장 타입 에서 파생된 클래스에 대해 __dict__ 및 __weakref__ 이외의 __slots__ 를 정의하면 TypeError 가 발생합니다.

  • iterable 형식의 모든 비문자열 객체는 __slots__ 에 할당될 수 있습니다.

  • __slots__ 를 할당하는 데 딕셔너리 를 사용하면, 딕셔너리의 키가 슬롯 이름으로 사용됩니다. 딕셔너리의 값은 inspect.getdoc() 이 인식하고 help() 출력 시 표시되는 어트리뷰트별 독스트링을 제공하는 데 사용될 수 있습니다.

  • __class__ 할당은 두 클래스가 모두 동일한 __slots__ 를 가질 때만 작동합니다.

  • 여러 개의 슬롯이 적용된 부모 클래스를 포함하는 다중 상속 을 사용할 수 있지만, 단 하나의 부모만 슬롯에 의해 생성된 어트리뷰트를 가질 수 있습니다(다른 베이스는 빈 슬롯 레이아웃을 가져야 합니다). 이를 위반하면 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.15에서 변경: 모든 클래스에 대해 __dict__ 및 __weakref__ __slots__ 를 정의할 수 있습니다. tuple 에서 파생된 클래스에는 어떤 __slots__ 이든 정의할 수 있습니다.

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

클래스가 다른 클래스를 상속할 때마다 부모 클래스에서 __init_subclass__() 가 호출됩니다. 이를 통해 서브클래스의 동작을 변경하는 클래스를 작성할 수 있습니다. 이는 클래스 데코레이터와 밀접하게 관련되어 있지만, 클래스 데코레이터는 적용된 특정 클래스에만 영향을 주는 반면, __init_subclass__ 는 해당 메서드를 정의한 클래스의 향후 서브클래스들에만 적용됩니다.

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) 로 액세스할 수 있습니다.

Added in version 3.6.

클래스가 생성될 때, type.__new__() 는 클래스 변수를 스캔하고 __set_name__() 훅이 있는 변수들에 대해 콜백을 수행합니다.

object.__set_name__(self, owner, name)

소유 클래스 owner 가 생성될 때 자동으로 호출됩니다. 해당 객체는 그 클래스의 name 에 할당되었습니다:

class A:
    x = C()  # 자동으로 호출됨: x.__set_name__(A, 'x')

클래스 변수가 클래스 생성 후 할당되는 경우, __set_name__() 이 자동으로 호출되지 않습니다. 필요한 경우, __set_name__() 을 직접 호출할 수 있습니다:

class A:
   pass

c = C()
A.x = c                  # 훅이 호출되지 않음
c.__set_name__(A, 'x')   # 수동으로 훅 실행

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

Added in version 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 항목 결정하기

object.__mro_entries__(self, bases)

If a base that appears in a class definition is not an instance of type, then an __mro_entries__() method is searched on the base. If an __mro_entries__() method is found, the base is substituted with the result of a call to __mro_entries__() when creating the class. The method is called with the original bases tuple passed to the bases parameter, and must return a tuple of classes that will be used instead of the base. The returned tuple may be empty: in these cases, the original base is ignored.

더 보기

types.resolve_bases()

type 의 인스턴스가 아닌 베이스를 동적으로 해결합니다.

types.get_original_bases()

__mro_entries__() 에 의해 수정되기 전 클래스의 “원래 베이스”를 가져옵니다.

PEP 560

typing 모듈 및 제네릭 형에 대한 핵심 지원.

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

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

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

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

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

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

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

적절한 메타클래스가 확인되면 클래스 네임스페이스를 준비합니다. 메타클래스에 __prepare__ 어트리뷰트가 있으면, namespace = metaclass.__prepare__(name, bases, **kwds) 로 호출됩니다(여기에서 추가적인 키워드 인자는 클래스 정의에서 가져옵니다). __prepare__ 메서드는 classmethod 로 구현되어야 합니다. __prepare__ 가 반환한 네임스페이스는 __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 3.6 이상에서, __class__ 셀(cell)은 클래스 이름 공간의 __classcell__ 엔트리로 메타 클래스에 전달됩니다. 만약 존재한다면, 이것은 클래스가 올바르게 초기화되기 위해 type.__new__ 호출까지 거슬러서 전파되어야 합니다. 이렇게 하지 못하면 파이썬 3.8 에서는 RuntimeError로 이어질 것입니다.

기본 메타클래스인 type 을 사용하거나 궁극적으로 type.__new__ 를 호출하는 모든 메타클래스를 사용할 때, 클래스 객체를 생성한 후 다음과 같은 추가적인 사용자 정의 단계가 실행됩니다:

  1. type.__new__ 메서드는 클래스 네임스페이스에서 __set_name__() 메서드를 정의하는 모든 어트리뷰트를 수집합니다.

  2. 해당 __set_name__ 메서드들은 정의 중인 클래스와 해당 어트리뷰트에 할당된 이름과 함께 호출됩니다.

  3. __init_subclass__() 훅이 새로운 클래스의 메서드 해결 순서에서 즉각적인 부모에게 호출됩니다.

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

type.__new__ 에 의해 새 클래스가 생성될 때, 네임스페이스 매개변수로 제공된 객체는 새로운 순서 있는 매핑으로 복사되고 원본 객체는 버려집니다. 이 새로운 복사본은 읽기 전용 프록시로 감싸지며, 이는 클래스 객체의 __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)”로 추가할 수 있게 하려고 이 메서드들을 구현합니다.

type.__instancecheck__(self, instance)

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

type.__subclasscheck__(self, subclass)

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

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

더 보기

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

__instancecheck__() 및 __subclasscheck__() 를 통해 isinstance() 및 issubclass() 동작을 사용자 정의하는 사양을 포함하며, 이는 언어에 추상 베이스 클래스(ABC, 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 - 형 힌트

파이썬의 형 어노테이션 프레임워크 도입

제네릭 에일리어스 타입

매개 변수화된 제네릭 클래스를 나타내는 객체에 대한 설명

제네릭, 사용자 정의 제네릭 및 typing.Generic

런타임에서 매개 변수화가 가능하고 정적 형 검사기에서 인식될 수 있는 제네릭 클래스 구현 방법에 대한 문서.

클래스가 일반적으로 매개 변수화되려면 특별한 클래스 메서드인 __class_getitem__() 를 정의해야 합니다.

classmethod object.__class_getitem__(cls, key)

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

클래스에서 정의될 때 __class_getitem__() 은 자동으로 클래스 메서드가 됩니다. 따라서 정의할 때 @classmethod 로 데코레이트할 필요가 없습니다.

3.3.5.1. __class_getitem__ 의 목적

__class_getitem__() 의 목적은 표준 라이브러리 제네릭 클래스에 형 힌트 를 더 쉽게 적용할 수 있도록 실행 중에 매개 변수화하는 것입니다.

실행 중에 매개 변수화가 가능하고 정적 타입 검사기가 인식할 수 있는 사용자 정의 제네릭 클래스를 구현하려면, 이미 __class_getitem__() 을 구현하는 표준 라이브러리 클래스를 상속하거나 __class_getitem__() 의 자체 구현이 포함된 typing.Generic 을 상속해야 합니다.

표준 라이브러리 외부에서 정의된 클래스에 대한 __class_getitem__() 의 사용자 정의 구현은 mypy와 같은 서드파티 타입 검사기에서 인식되지 않을 수 있습니다. 형 힌트 이외의 목적으로 어떤 클래스에서 __class_getitem__() 을 사용하는 것은 권장되지 않습니다.

3.3.5.2. __class_getitem__ 와 __getitem__ 의 비교

일반적으로 대괄호를 사용하는 객체의 서브스크립션 은 객체의 클래스에 정의된 __getitem__() 인스턴스 메서드를 호출합니다. 그러나 서브스크립션 대상이 클래스인 경우, 대신 클래스 메서드인 __class_getitem__() 이 호출될 수 있습니다. __class_getitem__() 은 올바르게 정의된 경우 GenericAlias 객체를 반환해야 합니다.

expression 인 obj[x] 를 받으면, 파이썬 인터프리터는 어떤 프로세스를 따르는지 결정합니다 __getitem__() 을 호출해야 할지 아니면 __class_getitem__() 를 호출해야 할지를 판단하는 과정입니다.

from inspect import isclass

def subscribe(obj, x):
    """'obj[x]' 표현식의 결과를 반환합니다"""

    class_of_obj = type(obj)

    # obj의 클래스가 __getitem__을 정의한 경우,
    # class_of_obj.__getitem__(obj, x)를 호출합니다
    if hasattr(class_of_obj, '__getitem__'):
        return class_of_obj.__getitem__(obj, x)

    # 그렇지 않고 obj가 클래스이며 __class_getitem__을 정의한 경우,
    # obj.__class_getitem__(x)를 호출합니다
    elif isclass(obj) and hasattr(obj, '__class_getitem__'):
        return obj.__class_getitem__(x)

    # 그 외의 경우 예외를 발생시킵니다
    else:
        raise TypeError(
            f"'{class_of_obj.__name__}' 객체는 서브스크립트가 가능하지 않습니다"
        )

파이썬에서 모든 클래스는 다른 클래스의 인스턴스입니다. 클래스의 클래스를 해당 클래스의 metaclass 라고 하며, 대부분의 클래스는 자신들의 메타클래스로 type 클래스를 가집니다. type 은 __getitem__() 을 정의하지 않기 때문에 list[int], dict[str, float] 및 tuple[str, bytes] 와 같은 표현식들은 모두 __class_getitem__() 이 호출되게 합니다.

>>> # 대부분의 클래스와 마찬가지로 list는 "type"을 메타클래스로 가집니다:
>>> type(list)
<class 'type'>
>>> type(dict) == type(list) == type(tuple) == type(str) == type(bytes)
True
>>> # "list[int]"는 "list.__class_getitem__(int)"를 호출합니다.
>>> list[int]
list[int]
>>> # list.__class_getitem__은 GenericAlias 객체를 반환합니다:
>>> type(list[int])
<class 'types.GenericAlias'>

하지만, __getitem__() 을 정의하는 커스텀 메타클래스를 가진 클래스의 경우, 해당 클래스를 구독할 때 다른 동작이 발생할 수 있습니다. 이에 대한 예시는 enum 모듈에서 확인할 수 있습니다.

>>> from enum import Enum
>>> class Menu(Enum):
...     """A breakfast menu"""
...     SPAM = 'spam'
...     BACON = 'bacon'
...
>>> # Enum 클래스는 커스텀 메타클래스를 가집니다:
>>> type(Menu)
<class 'enum.EnumMeta'>
>>> # EnumMeta가 __getitem__을 정의하므로,
>>> # __class_getitem__이 호출되지 않으며,
>>> # 결과도 GenericAlias 객체가 아닙니다:
>>> Menu['SPAM']
<Menu.SPAM: 'spam'>
>>> type(Menu['SPAM'])
<enum 'Menu'>

더 보기

PEP 560 - typing 모듈 및 제네릭 타입에 대한 핵심 지원

__class_getitem__() 을 도입하고, subscription 이 __getitem__() 대신 __class_getitem__() 를 호출하게 되는 경우를 설명합니다.

3.3.6. 콜러블 객체 흉내 내기

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

인스턴스가 함수처럼 “호출”될 때 호출됩니다. 이 메서드가 정의된 경우, x(arg1, arg2, ...) 는 대략 type(x).__call__(x, arg1, ...) 로 변환됩니다. object 클래스 자체는 이 메서드를 제공하지 않습니다.

3.3.7. 컨테이너형 흉내 내기

컨테이너 객체를 구현하기 위해 다음 메서드들을 정의할 수 있습니다. 이 중 어느 것도 object 클래스 자체에서 제공되지 않습니다. 컨테이너는 대개 sequences (예: lists 또는 tuples)나 mappings (예: dictionaries)이며, 다른 종류의 컨테이너도 나타낼 수 있습니다. 첫 번째 메서드 세트는 시퀀스를 흉내 내거나 매핑을 흉내 내는 데 사용됩니다. 차이점은 시퀀스의 경우 허용되는 키가 0 <= k < N ` (여기서 N 은 시퀀스의 길이)인 정수 k 또는 항목 범위를 정의하는 slice 객체여야 한다는 것입니다. 또한 매핑의 경우 파이썬 표준 dictionary 객체와 유사하게 동작하는 keys(), values(), items(), get(), clear(), setdefault(), pop(), popitem(), copy(), 그리고 update() 메서드를 제공하는 것이 권장됩니다. collections.abc 모듈은 __getitem__(), __setitem__(), __delitem__(), 그리고 keys() 라는 기본 메서드 세트로부터 이러한 메서드들을 생성하는 데 도움을 주는 MutableMapping abstract base class 를 제공합니다.

가변 시퀀스는 파이썬 표준 list 객체와 마찬가지로 append(), clear(), count(), extend(), index(), insert(), pop(), remove(), 그리고 reverse() 메서드를 제공해야 합니다. 마지막으로, 시퀀스 타입은 아래에 설명된 __add__(), __radd__(), __iadd__(), __mul__(), __rmul__() 및 __imul__() 메서드를 정의하여 덧셈(연결을 의미함)과 곱셈(반복을 의미함)을 구현해야 하며, 다른 수치 연산자는 정의해서는 안 됩니다.

매핑과 시퀀스 모두 in 연산자를 효율적으로 사용할 수 있도록 __contains__() 메서드를 구현하는 것이 권장됩니다. 매핑의 경우 in 은 매핑의 키를 검색해야 하며, 시퀀스의 경우 값(value)을 통해 검색해야 합니다. 또한 매핑과 시퀀스 모두 컨테이너를 효율적으로 반복할 수 있도록 __iter__() 메서드를 구현하는 것이 권장됩니다. 매핑에서 __iter__() 는 객체의 키를 순회해야 하며, 시퀀스에서는 값을 순회해야 합니다.

object.__len__(self)

내장 함수 len() 을 구현하기 위해 호출됩니다. 객체의 길이인 0 이상의 정수를 반환해야 합니다. 또한, __bool__() 메서드를 정의하지 않고 __len__() 메서드가 0을 반환하는 객체는 불리언 문맥에서 False로 간주됩니다.

CPython에서 길이는 최대 sys.maxsize`여야 합니다. 길이가 :data:!sys.maxsize`보다 크면 일부 기능(예: len())이 OverflowError`를 발생시킬 수 있습니다. 진리값 테스트 시 :exc:!OverflowError`가 발생하는 것을 방지하려면 객체가 반드시 __bool__() 메서드를 정의해야 합니다.

object.__length_hint__(self)

operator.length_hint() 를 구현하기 위해 호출됩니다. 객체에 대한 예상 길이(실제 길이와 다를 수 있음)를 반환해야 합니다. 길이는 0 이상의 정수여야 합니다. 반환 값은 NotImplemented 일 수도 있으며, 이는 __length_hint__ 메서드가 아예 존재하지 않는 것과 동일하게 취급됩니다. 이 메서드는 순전히 최적화를 위한 것이며 정확성을 위해 필수적인 것은 아닙니다.

Added in version 3.4.

object.__getitem__(self, subscript)

서브스크립션(즉, self[subscript])을 구현하기 위해 호출됩니다. 구문에 대한 자세한 내용은 서브스크립션 및 슬라이싱 를 참조하십시오.

__getitem__() 을 통해 서브스크립션을 지원하는 내장 객체에는 두 가지 유형이 있습니다:

  • 시퀀스, 여기서 subscript (바인딩된 index)는 정수이거나 slice 객체여야 합니다. slice 객체의 처리와 음수 인덱싱을 포함하여 예상되는 동작은 datamodel-sequences 문서를 참조하십시오.

  • 매핑, 여기서 subscript 는 key 라고도 불립니다. 예상되는 동작은 datamodel-mappings 를 참조하십시오.

subscript 의 타입이 부적절한 경우, __getitem__() 은 TypeError 를 발생시켜야 합니다. subscript 의 값이 부적절한 경우, __getitem__() 은 LookupError 또는 그 하위 클래스(IndexError 는 시퀀스에서, KeyError 는 매핑에서)를 발생시켜야 합니다.

참고

슬라이싱은 __getitem__(), __setitem__(), 그리고 __delitem__() 에 의해 처리됩니다. 다음과 같은 호출의 경우:

a[1:2] = b

과 같은 호출은

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

등등. 누락된 슬라이스 항목은 항상 None 으로 채워집니다.

참고

시퀀스 반복 프로토콜(예를 들어, for 루프에서 사용됨)은 시퀀스의 끝을 적절히 감지할 수 있도록 부적절한 인덱스에 대해 IndexError 가 발생할 것을 예상합니다.

참고

클래스를 subscripting 할 때, 일반적인 __getitem__() 대신 특수한 클래스 메서드인 __class_getitem__() 이 호출될 수 있습니다. 자세한 내용은 __class_getitem__ 와 __getitem__ 의 비교 을 참조하십시오.

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)

컨테이너에 대해 iterator 가 필요한 경우 이 메서드가 호출됩니다. 이 메서드는 컨테이너 내의 모든 객체를 순회할 수 있는 새로운 이터레이터 객체를 반환해야 합니다. 매핑의 경우, 컨테이너의 키를 순회해야 합니다.

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 를 평가하기 위해 type(x).__add__(x, 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)

These methods are called to implement the binary arithmetic operations (+, -, *, @, /, //, %, divmod(), pow(), **, <<, >>, &, ^, |) with reflected (swapped) operands. These functions are only called if the operands are of different types, when the left operand does not support the corresponding operation [3], or the right operand’s class is derived from the left operand’s class. [4] For instance, to evaluate the expression x - y, where y is an instance of a class that has an __rsub__() method, type(y).__rsub__(y, x) is called if type(x).__sub__(x, y) returns NotImplemented or type(y) is a subclass of type(x). [5]

내장 기능인 pow() 의 세 개 인자 버전을 지원하려면 __rpow__() 가 선택적인 세 번째 인수를 수용하도록 정의되어야 함을 유의하십시오.

버전 3.14에서 변경: 세 개의 인자를 받는 pow() 는 이제 필요한 경우에 __rpow__() 를 호출합니다. 이전에는 두 개의 인자를 받는 pow() 와 이항 거듭제곱 연산자에서만 호출되었습니다.

참고

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

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)

이 메서드들은 증분 산술 할당(+=, -=, *=, @=, /=, //=, %=, **=, <<=, >>=, &=, ^=, |=)을 구현하기 위해 호출됩니다. 이 메서드들은 인플레이스(in-place)로 연산을 수행(즉, self 를 수정)하고 그 결과(것이 될 수도 있고 필수 사항은 아니지만, self 일 수 있음)를 반환해야 합니다. 특정 메서드가 정의되지 않았거나 해당 메서드가 NotImplemented 를 반환하는 경우, 증분 할당은 일반적인 메서드로 대체됩니다. 예를 들어, x 가 __iadd__() 메서드를 가진 클래스의 인스턴스인 경우 x += y 는 x = x.__iadd__(y) 와 동일합니다. 만약 __iadd__() 이 존재하지 않거나 x.__iadd__(y) 가 NotImplemented 를 반환하는 경우, 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) 로 잘린 객체의 값을 돌려줘야 합니다.

버전 3.14에서 변경: int() 는 더 이상 __trunc__() 메서드에 위임하지 않습니다.

3.3.9. with 문 컨텍스트 관리자

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

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

컨텍스트 관리자에 대한 자세한 정보는 컨텍스트 관리자 형 를 참조하십시오. object 클래스 자체는 컨텍스트 매니저 메서드를 제공하지 않습니다.

object.__enter__(self)

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

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

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

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

__exit__() 메서드는 전달된 예외를 다시 발생시켜서는 안 됩니다. 이는 호출자의 책임입니다.

더 보기

PEP 343 - “with” 문

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

3.3.10. 클래스 패턴 매칭에서 위치 인자 사용자 정의

패턴에 클래스 이름을 사용할 때, 기본적으로 패턴 내의 위치 인자는 허용되지 않습니다. 즉, `MyClass 에서 특별한 지원이 없는 경우 case MyClass(x, y) 는 일반적으로 유효하지 않습니다. 이러한 유형의 패턴을 사용하려면 해당 클래스가 __match_args__ 속성을 정의해야 합니다.

object.__match_args__

이 클래스 변수는 문자열의 튜플로 할당될 수 있습니다. 이 클래스가 위치 인자가 포함된 클래스 패턴에서 사용될 때, 각 위치 인자는 __match_args__ 에 대응하는 값을 키로 사용하여 키워드 인자로 변환됩니다. 이 속성이 없는 것은 이를 () 로 설정한 것과 동일합니다.

예를 들어, `MyClass.__match_args__ 가 ("left", "center", "right") 라면 이는 case MyClass(x, y) 가 case MyClass(left=x, center=y) 와 동일함을 의미합니다. 주의할 점은 패턴의 인자 수가 __match_args__ 요소의 수보다 작거나 같아야 한다는 것이며, 더 많은 경우에는 패턴 매칭 시도 중 TypeError 가 발생합니다.

Added in version 3.10.

더 보기

PEP 634 - 구조적 패턴 매칭

파이썬 match 문에 대한 사양입니다.

3.3.11. 버퍼 타입 시뮬레이션

buffer protocol 은 파이썬 객체가 낮은 수준의 메모리 배열에 효율적으로 접근하는 방식을 제공합니다. 이 프로토콜은 bytes 및 memoryview 와 같은 내장 타입에서 구현되며, 타사 라이브러리에서 추가적인 버퍼 타입을 정의할 수 있습니다.

버퍼 타입은 대개 C로 구현되지만 파이썬으로도 프로토콜을 구현할 수 있습니다.

object.__buffer__(self, flags)

self 에서 버퍼를 요청할 때(예를 들어, memoryview 생성자에 의해) 호출됩니다. flags 인자는 요청된 버퍼의 종류를 나타내는 정수이며, 예를 들어 반환된 버퍼가 읽기 전용인지 쓰기 가능인지에 영향을 미칩니다. inspect.BufferFlags 는 플래그를 해석하는 편리한 방법을 제공합니다. 이 메서드는 반드시 memoryview 객체를 반환해야 합니다.

스레드 안전성: free-threaded 파이썬에서 구현체는 원자적 연산을 사용하여 모든 내부 내보내기 카운터를 관리해야 합니다. 이 메서드는 여러 스레드에서 동시에 호출해도 안전해야 하며, 반환된 버퍼의 기본 데이터는 해당 __release_buffer__() 호출이 완료될 때까지 유효한 상태를 유지해야 합니다. 자세한 내용은 memoryview 객체의 스레드 안전성 를 참조하십시오.

object.__release_buffer__(self, buffer)

버퍼가 더 이상 필요하지 않을 때 호출됩니다. buffer 인자는 이전에 __buffer__() 에 의해 반환된 memoryview 객체입니다. 이 메서드는 버퍼와 관련된 모든 리소스를 해제해야 합니다. 이 메서드는 None 을 반환해야 합니다.

스레드 안전성: free-threaded 파이썬에서 모든 내보내기 카운트 감소는 원자적 연산을 사용해야 합니다. 마지막 해제 작업이 다른 스레드의 동시 해제와 경합할 수 있으므로 리소스 정리 과정은 스레드 안전해야 합니다.

어떠한 정리 작업도 수행할 필요가 없는 버퍼 객체는 이 메서드를 구현할 필요가 없습니다.

Added in version 3.12.

더 보기

PEP 688 - 파이썬에서 버퍼 프로토콜에 접근 가능하게 만들기

파이썬의 __buffer__ 및 __release_buffer__ 메서드를 도입합니다.

collections.abc.Buffer

버퍼 형식을 위한 ABC입니다.

3.3.12. 어노테이션

함수, 클래스 및 모듈은 심볼과 정보(일반적으로 형 힌트)를 결합하는 방법인 어노테이션 을 포함할 수 있습니다.

object.__annotations__

이 속성은 객체에 대한 어노테이션을 포함합니다. 이 속성은 지연 평가 되므로, 해당 속성에 접근할 때 임의의 코드가 실행되거나 예외가 발생할 수 있습니다. 평가가 성공하면 해당 속성은 변수 이름을 어노테이션으로 매핑하는 딕셔너리로 설정됩니다.

버전 3.14에서 변경: 어노테이션이 이제 지연 평가됩니다.

object.__annotate__(format)

An annotate function. Returns a new dictionary object mapping attribute/parameter names to their annotation values.

어노테이션 값이 제공되어야 하는 형식을 지정하는 형식 매개변수를 받습니다. 이는 annotationlib.Format 열거형의 멤버이거나 해당 열거형의 멤버에 해당하는 값을 가진 정수여야 합니다.

If an annotate function doesn’t support the requested format, it must raise NotImplementedError. Annotate functions must always support VALUE format; they must not raise NotImplementedError() when called with this format.

VALUE 형식으로 호출될 때 어노테이션 함수는 NameError`를 발생시킬 수 있지만, 다른 형식을 요청하며 호출될 때는 :exc:!NameError`를 발생시켜서는 안 됩니다.

객체에 어노테이션이 없는 경우, __annotate__ 는 빈 딕셔너리를 반환하는 함수 대신 (삭제할 수 없으므로) 가급적 None 으로 설정되어야 합니다.

Added in version 3.14.

더 보기

PEP 649 — 디스크립터를 사용한 어노테이션의 지연 평가

어노테이션의 지연 평가와 __annotate__ 함수를 도입합니다.

3.3.13. 특수 메서드 조회

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

>>> 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

정확성을 위해 인스턴스 어트리뷰트를 우회하는 것 외에도, 암시적 특수 메서드 조회는 일반적으로 객체의 메타클래스의 __getattribute__() 메서드조차도 우회합니다:

>>> 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

이러한 방식으로 __getattribute__() 메커니즘을 우회하면 인터프리터 내에서 속도 최적화의 여지가 커지지만, 특수 메서드 처리에 있어서 어느 정도의 유연성이 희생됩니다(인터프리터에 의해 일관되게 호출되려면 특수 메서드가 반드시 클래스 객체 자체에 설정되어야 합니다).

3.4. 코루틴(Coroutines)

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

어웨이터블 객체는 일반적으로 __await__() 메서드를 구현합니다. async def 함수에서 반환되는 코루틴 객체 는 어웨이터블입니다.

참고

types.coroutine() 으로 데코레이션된 제너레이터에서 반환되는 제너레이터 이터레이터 객체도 어웨이터블이지만, __await__() 를 구현하지는 않습니다.

object.__await__(self)

이터레이터 를 반환해야 합니다. 어웨이터블 객체를 구현하는 데 사용되어야 합니다. 예를 들어, asyncio.Future 는 await 표현식과 호환되도록 이 메서드를 구현합니다. object 클래스 자체는 어웨이터블이 아니며 이 메서드를 제공하지 않습니다.

참고

awaitable 객체를 관리할 비동기 실행 프레임워크(예.: asyncio)에 따라 어떠한 제약도 없습니다. __await__ 가 반환하는 이터레이터가 산출하는 객체의 타입이나 값에 대한 제한은 없으며, 이는 해당 구현체에 국한됩니다.

Added in version 3.5.

더 보기

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

3.4.2. 코루틴 객체(Coroutine Objects)

코루틴 객체 는 어웨이터블 객체입니다. 코루틴의 실행은 __await__() 를 호출하고 그 결과를 이터레이션함으로써 제어할 수 있습니다. 코루틴이 실행을 마치고 반환하면, 이터레이터가 StopIteration 을 발생시키며 예외의 value 속성이 반환 값을 보유합니다. 코루틴이 예외를 발생시키면 이터레이터에 의해 전달됩니다. 코루틴은 처리되지 않은 StopIteration 예외를 직접 발생시켜서는 안 됩니다.

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

코루틴은 각각 yield, send, 반환 값의 타입에 대한 제네릭 입니다.

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

coroutine.send(value)

코루틴의 실행을 시작하거나 재개합니다. value 가 None 인 경우, 이는 __await__() 에 의해 반환된 이터레이터를 진행시키는 것과 동일하게 작동합니다. value 가 None 이 아닌 경우, 이 메서드는 코루틴을 일시 중단시킨 이터레이터의 send() 메서드에 위임합니다. 결과(반환 값, StopIteration, 또는 다른 예외)는 위에서 설명한 대로 __await__() 반환 값을 이터레이션할 때와 동일합니다.

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

코루틴 내에서 지정된 예외를 발생시킵니다. 이 메서드는 코루틴을 일시 중단시킨 이터레이터가 해당 메서드를 가지고 있는 경우 그 이터레이터의 throw() 메서드에 위임합니다. 그렇지 않은 경우에는 일시 중지 시점에서 예외가 발생합니다. 결과(반환 값, StopIteration, 또는 다른 예외)는 위에서 설명한 대로 __await__() 반환 값을 이터레이션할 때와 동일합니다. 코루틴에서 해당 예외를 포착하지 않으면 호출자에게 전달됩니다.

버전 3.12에서 변경: 두 번째 시그니처인 (type[, value[, traceback]])는 더 이상 권장되지 않으며 향후 파이썬 버전에서 제거될 수 있습니다.

coroutine.close()

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

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

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

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

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

object 클래스 자체는 이러한 메서드들을 제공하지 않습니다.

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

Added in version 3.5.

버전 3.7에서 변경: Python 3.7 이전에는 __aiter__() 가 비동기 이터레이터 로 해결되는 어웨이터블 을 반환할 수 있었습니다.

Python 3.7부터는 __aiter__() 가 반드시 비동기 이터레이터 객체를 반환해야 합니다. 다른 것을 반환하면 TypeError 오류가 발생합니다.

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

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

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

object 클래스 자체는 이러한 메서드들을 제공하지 않습니다.

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')

Added in version 3.5.

각주

분실물 보관소