Python Built-in Types 2/2 – 엔지니어 대한민국

Binary Sequence Types — `bytes`, `bytearray`, `memoryview`

이진 데이터를 조작하기 위한 핵심 기본 제공 유형은 bytes 및 bytearray입니다. 그것들은 버퍼 프로토콜을 사용하여 사본을 만들 필요 없이 다른 이진 객체의 메모리에 액세스하는 memoryview에 의해 지원됩니다.

어레이 모듈은 32비트 정수 및 IEEE754 배정밀도 부동 값과 같은 기본 데이터 유형의 효율적인 저장을 지원합니다.

Bytes Objects

바이트 개체는 단일 바이트의 불변 시퀀스입니다. 많은 주요 이진 프로토콜이 ASCII 텍스트 인코딩을 기반으로 하기 때문에 바이트 객체는 ASCII 호환 데이터로 작업할 때만 유효하고 다양한 다른 방법으로 문자열 객체와 밀접하게 관련된 여러 메서드를 제공합니다.

class bytes([source[, encoding[, errors]]])

첫째, 바이트 리터럴의 구문은 b 접두사가 추가된다는 점을 제외하면 문자열 리터럴의 구문과 대체로 동일합니다.

작은따옴표: b’여전히 “큰따옴표” 포함 허용’
큰따옴표: b”여전히 ‘작은따옴표’ 포함 허용”
3중 따옴표: b”’작은따옴표 3개”’, b”””큰따옴표 3개”””

바이트 리터럴에는 ASCII 문자만 허용됩니다(선언된 소스 코드 인코딩에 관계없이). 127을 초과하는 이진 값은 적절한 이스케이프 시퀀스를 사용하여 바이트 리터럴에 입력해야 합니다.

문자열 리터럴과 마찬가지로 바이트 리터럴도 r 접두사를 사용하여 이스케이프 시퀀스 처리를 비활성화할 수 있습니다. 지원되는 이스케이프 시퀀스를 포함하여 다양한 형태의 바이트 리터럴에 대한 자세한 내용은 문자열 및 바이트 리터럴을 참조하십시오.

바이트 리터럴과 표현은 ASCII 텍스트를 기반으로 하지만 바이트 객체는 실제로 변경할 수 없는 정수 시퀀스처럼 동작하며 시퀀스의 각 값은 0 <= x < 256으로 제한됩니다(이 제한을 위반하려는 시도는 ValueError를 트리거함). 이는 많은 이진 형식이 ASCII 기반 요소를 포함하고 일부 텍스트 지향 알고리즘으로 유용하게 조작될 수 있지만 일반적으로 임의의 이진 데이터에는 해당되지 않는다는 점을 강조하기 위해 의도적으로 수행됩니다. ASCII 호환은 일반적으로 데이터 손상으로 이어집니다).

리터럴 형식 외에도 여러 다른 방법으로 바이트 객체를 만들 수 있습니다.

지정된 길이의 0으로 채워진 바이트열 객체: bytes(10)
정수의 이터러블에서: bytes(range(20))
버퍼 프로토콜을 통해 기존 바이너리 데이터 복사: bytes(obj)

내장 bytes도 참조하십시오.

2개의 16진수는 정확하게 단일 바이트에 해당하므로 16진수는 이진 데이터를 설명하는 데 일반적으로 사용되는 형식입니다. 따라서 바이트 유형에는 해당 형식의 데이터를 읽는 추가 클래스 메서드가 있습니다.

classmethod fromhex(string)

이 바이트 클래스 메서드는 주어진 문자열 객체를 디코딩하여 바이트 객체를 반환합니다. 문자열은 바이트당 두 개의 16진수를 포함해야 하며 ASCII 공백은 무시됩니다.

>>> bytes.fromhex('2Ef0 F1f2  ')
b'.\xf0\xf1\xf2'

버전 3.7에서 변경: bytes.fromhex()는 이제 공백뿐만 아니라 문자열의 모든 ASCII 공백을 건너뜁니다.

역변환 함수는 바이트열 객체를 16진수 표현으로 변환하기 위해 존재합니다.

hex([sep[, bytes_per_sep]])

인스턴스의 각 바이트에 대해 두 개의 16진수를 포함하는 문자열 객체를 반환합니다.

>>> b'\xf0\xf1\xf2'.hex()
'f0f1f2'

16진수 문자열을 읽기 쉽게 만들려면 출력에 포함할 단일 문자 구분자 sep 매개 변수를 지정할 수 있습니다. 기본적으로 이 구분 기호는 각 바이트 사이에 포함됩니다. 두 번째 선택적 bytes_per_sep 매개변수는 간격을 제어합니다. 양수 값은 오른쪽에서 구분자 위치를 계산하고 음수 값은 왼쪽에서 계산합니다.

>>> value = b'\xf0\xf1\xf2'
>>> value.hex('-')
'f0-f1-f2'
>>> value.hex('_', 2)
'f0_f1f2'
>>> b'UUDDLRLRAB'.hex(' ', -4)
'55554444 4c524c52 4142

버전 3.5의 새로운 기능.

버전 3.8에서 변경: bytes.hex()는 이제 선택적 sep 및 bytes_per_sep 매개 변수를 지원하여 16진수 출력에서 바이트 사이에 구분 기호를 삽입합니다.

바이트열 객체는 정수 시퀀스(튜플과 유사)이므로 바이트열 객체 b의 경우 b[0]은 정수이고 b[0:1]은 길이가 1인 바이트열 객체입니다. (텍스트와 대조됩니다. 인덱싱과 슬라이싱 모두 길이가 1인 문자열을 생성하는 문자열

바이트 객체의 표현은 리터럴 형식(b’…’)을 사용합니다. 바이트([46, 46, 46]). 항상 list(b)를 사용하여 바이트 객체를 정수 목록으로 변환할 수 있습니다.

Bytearray Objects

bytearray 객체는 바이트열 객체에 대한 변경 가능한 대응물입니다.

class bytearray([source[, encoding[, errors]]])

bytearray 객체에 대한 전용 리터럴 구문은 없으며 대신 항상 생성자를 호출하여 생성됩니다.

빈 인스턴스 만들기: bytearray()
주어진 길이로 0으로 채워진 인스턴스 만들기: bytearray(10)
정수의 이터러블에서: bytearray(range(20))
버퍼 프로토콜을 통해 기존 바이너리 데이터 복사: bytearray(b’Hi!’)

바이트 배열 객체는 변경 가능하므로 바이트 및 바이트 배열 작업에 설명된 일반 바이트 및 바이트 배열 작업 외에도 변경 가능한 시퀀스 작업을 지원합니다.

bytearray 내장함수도 참조하십시오.

2개의 16진수는 정확하게 단일 바이트에 해당하므로 16진수는 이진 데이터를 설명하는 데 일반적으로 사용되는 형식입니다. 따라서 bytearray 유형에는 해당 형식의 데이터를 읽는 추가 클래스 메서드가 있습니다.

classmethod fromhex(string)

이 bytearray 클래스 메서드는 주어진 문자열 객체를 디코딩하여 bytearray 객체를 반환합니다. 문자열은 바이트당 두 개의 16진수를 포함해야 하며 ASCII 공백은 무시됩니다.

>>> bytearray.fromhex('2Ef0 F1f2  ')
bytearray(b'.\xf0\xf1\xf2')

버전 3.7에서 변경: bytearray.fromhex()는 이제 문자열에서 공백뿐만 아니라 모든 ASCII 공백을 건너뜁니다.

역변환 함수는 bytearray 객체를 16진수 표현으로 변환하기 위해 존재합니다.

hex([sep[, bytes_per_sep]])

인스턴스의 각 바이트에 대해 두 개의 16진수를 포함하는 문자열 객체를 반환합니다.

>>> bytearray(b'\xf0\xf1\xf2').hex()
'f0f1f2'

버전 3.5의 새로운 기능.

버전 3.8에서 변경: bytes.hex()와 유사하게, bytearray.hex()는 이제 선택적 sep 및 bytes_per_sep 매개변수를 지원하여 16진수 출력에서 바이트 사이에 구분 기호를 삽입합니다.

바이트 배열 객체는 정수 시퀀스(목록과 유사)이므로 바이트 배열 객체 b의 경우 b[0]은 정수이고 b[0:1]은 길이가 1인 바이트 배열 객체입니다. (이는 텍스트와 대조됩니다. 인덱싱과 슬라이싱 모두 길이가 1인 문자열을 생성하는 문자열

bytearray 객체의 표현은 바이트열 리터럴 형식(bytearray(b’…’))을 사용합니다. bytearray([46, 46, 46]). 항상 list(b)를 사용하여 bytearray 객체를 정수 목록으로 변환할 수 있습니다.

Bytes and Bytearray Operations

bytes 및 bytearray 객체 모두 공통 시퀀스 연산을 지원합니다. 이들은 동일한 유형의 피연산자뿐만 아니라 모든 바이트열류 객체와도 상호 운용됩니다. 이러한 유연성으로 인해 오류 없이 작업에서 자유롭게 혼합할 수 있습니다. 그러나 결과의 반환 유형은 피연산자의 순서에 따라 달라질 수 있습니다.

참고: 문자열에 대한 메서드가 바이트를 인수로 허용하지 않는 것처럼 바이트열 및 바이트 배열 객체에 대한 메서드는 문자열을 인수로 허용하지 않습니다. 예를 들어 다음과 같이 작성해야 합니다.
a = “abc”
b = a.replace(“a”, “f”)
그리고
a = b”abc”
b = a.replace(b”a”, b”f”)

일부 바이트 및 바이트 배열 작업은 ASCII 호환 이진 형식을 사용한다고 가정하므로 임의의 이진 데이터로 작업할 때는 피해야 합니다. 이러한 제한 사항은 아래에서 다룹니다.

참고: 이러한 ASCII 기반 작업을 사용하여 ASCII 기반 형식으로 저장되지 않은 이진 데이터를 조작하면 데이터가 손상될 수 있습니다.

바이트 및 바이트 배열 개체에 대한 다음 메서드는 임의의 이진 데이터와 함께 사용할 수 있습니다.

bytes.count(sub[, start[, end]])
bytearray.count(sub[, start[, end]])

[start, end] 범위에서 subsequence sub의 겹치지 않는 발생 수를 반환합니다. 선택적 인수 start 및 end는 슬라이스 표기법으로 해석됩니다.

검색할 하위 시퀀스는 바이트열류 객체 또는 0에서 255 범위의 정수일 수 있습니다.

sub가 비어 있으면 바이트 객체의 길이에 1을 더한 문자 사이의 빈 슬라이스 수를 반환합니다.

버전 3.3에서 변경: 또한 하위 시퀀스로 0에서 255 범위의 정수를 허용합니다.

bytes.removeprefix(prefix, /)
bytearray.removeprefix(prefix, /)

이진 데이터가 접두사 문자열로 시작하면 bytes[len(prefix):]를 반환합니다. 그렇지 않으면 원본 이진 데이터의 복사본을 반환합니다.

>>> b'TestHook'.removeprefix(b'Test')
b'Hook'
>>> b'BaseTestCase'.removeprefix(b'Test')
b'BaseTestCase'

접두사는 bytes-like object 객체일 수 있습니다.

참고: 이 메서드의 bytearray 버전은 제자리에서 작동하지 않습니다. 변경 사항이 없더라도 항상 새 개체를 생성합니다.

버전 3.9의 새로운 기능.

bytes.removesuffix(suffix, /)
bytearray.removesuffix(suffix, /)

이진 데이터가 접미사 문자열로 끝나고 해당 접미사가 비어 있지 않으면 bytes[:-len(suffix)]를 반환합니다. 그렇지 않으면 원본 이진 데이터의 복사본을 반환합니다.

>>> b'MiscTests'.removesuffix(b'Tests')
b'Misc'
>>> b'TmpDirMixin'.removesuffix(b'Tests')
b'TmpDirMixin'

접미사는 바이트열류 객체일 수 있습니다.

참고: 이 메서드의 bytearray 버전은 제자리에서 작동하지 않습니다. 변경 사항이 없더라도 항상 새 개체를 생성합니다.

버전 3.9의 새로운 기능.

bytes.decode(encoding=’utf-8′, errors=’strict’)
bytearray.decode(encoding=’utf-8′, errors=’strict’)

str로 디코딩된 바이트를 반환합니다.

인코딩 기본값은 ‘utf-8’입니다. 가능한 값은 표준 인코딩을 참조하십시오.

오류는 디코딩 오류를 처리하는 방법을 제어합니다. ‘strict'(기본값)이면 UnicodeError 예외가 발생합니다. 다른 가능한 값은 ‘ignore’, ‘replace’ 및 codecs.register_error()를 통해 등록된 다른 이름입니다. 자세한 내용은 오류 처리기를 참조하십시오.

성능상의 이유로 디코딩 오류가 실제로 발생하거나 Python 개발 모드가 활성화되거나 디버그 빌드가 사용되지 않는 한 오류 값의 유효성을 확인하지 않습니다.

참고: 인코딩 인수를 str에 전달하면 임시 bytes 또는 bytearray 객체를 만들 필요 없이 모든 바이트열류 객체를 직접 디코딩할 수 있습니다.

버전 3.1에서 변경: 키워드 인수에 대한 지원이 추가되었습니다.

버전 3.9에서 변경: 이제 errors 인수의 값이 Python 개발 모드와 디버그 모드에서 확인됩니다.

bytes.endswith(suffix[, start[, end]])
bytearray.endswith(suffix[, start[, end]])

이진 데이터가 지정된 접미사로 끝나면 True를 반환하고 그렇지 않으면 False를 반환합니다. suffix는 찾을 접미사의 튜플일 수도 있습니다. 선택적 시작으로 해당 위치에서 테스트 시작. 옵션 끝으로 해당 위치에서 비교를 중지합니다.

검색할 접미사는 바이트열류 객체일 수 있습니다.

bytes.find(sub[, start[, end]])
bytearray.find(sub[, start[, end]])

sub가 슬라이스 s[start:end]에 포함되도록 하위 시퀀스 sub가 있는 데이터에서 가장 낮은 인덱스를 반환합니다. 선택적 인수 start 및 end는 슬라이스 표기법으로 해석됩니다. sub를 찾을 수 없으면 -1을 반환합니다.

검색할 하위 시퀀스는 바이트열류 객체 또는 0에서 255 범위의 정수일 수 있습니다.

참고: sub의 위치를 알아야 하는 경우에만 find() 메서드를 사용해야 합니다. sub가 하위 문자열인지 확인하려면 in 연산자를 사용하십시오.
>>> b’Py’ in b’Python’
True

버전 3.3에서 변경: 또한 하위 시퀀스로 0에서 255 범위의 정수를 허용합니다.

bytes.index(sub[, start[, end]])
bytearray.index(sub[, start[, end]])

find()와 비슷하지만 하위 시퀀스를 찾을 수 없으면 ValueError가 발생합니다.

검색할 하위 시퀀스는 바이트열류 객체 또는 0에서 255 범위의 정수일 수 있습니다.

버전 3.3에서 변경: 또한 하위 시퀀스로 0에서 255 범위의 정수를 허용합니다.

bytes.join(iterable)
bytearray.join(iterable)

iterable에서 이진 데이터 시퀀스를 연결한 바이트 또는 바이트 배열 객체를 반환합니다. str 객체를 포함하여 바이트열류 객체가 아닌 값이 iterable에 있으면 TypeError가 발생합니다. 요소 사이의 구분 기호는 이 메서드를 제공하는 바이트 또는 바이트 배열 객체의 내용입니다.

static bytes.maketrans(from, to)
static bytearray.maketrans(from, to)

이 정적 메서드는 각 문자를 같은 위치에 있는 문자로 매핑하는 bytes.translate()에 사용할 수 있는 변환 테이블을 반환합니다. from과 to는 모두 바이트열류 객체여야 하며 길이가 같아야 합니다.

버전 3.1의 새로운 기능.

bytes.partition(sep)
bytearray.partition(sep)

sep가 처음 나타날 때 시퀀스를 분할하고 구분자 앞의 부분, 구분자 자체 또는 bytearray 복사본, 구분자 뒤의 부분을 포함하는 3-튜플을 반환합니다. 구분 기호를 찾을 수 없으면 원래 시퀀스의 복사본을 포함하는 3-튜플을 반환하고 그 뒤에 두 개의 빈 바이트 또는 바이트 배열 객체를 반환합니다.

검색할 구분 기호는 bytes-like object 객체일 수 있습니다.

bytes.replace(old, new[, count])
bytearray.replace(old, new[, count])

new로 대체된 하위 시퀀스 old의 모든 항목이 포함된 시퀀스의 복사본을 반환합니다. 선택적 인수 count가 제공되면 첫 번째 count 항목만 대체됩니다.

검색할 하위 시퀀스 및 대체 항목은 모든 바이트열류 객체일 수 있습니다.

참고: 이 메서드의 bytearray 버전은 제자리에서 작동하지 않습니다. 변경 사항이 없더라도 항상 새 개체를 생성합니다.

bytes.rfind(sub[, start[, end]])
bytearray.rfind(sub[, start[, end]]

sub가 s[start:end] 내에 포함되도록 하위 시퀀스 sub가 있는 시퀀스에서 가장 높은 인덱스를 반환합니다. 선택적 인수 start 및 end는 슬라이스 표기법으로 해석됩니다. 실패하면 -1을 반환합니다.

검색할 하위 시퀀스는 바이트열류 객체 또는 0에서 255 범위의 정수일 수 있습니다.

버전 3.3에서 변경: 또한 하위 시퀀스로 0에서 255 범위의 정수를 허용합니다.

bytes.rindex(sub[, start[, end]])
bytearray.rindex(sub[, start[, end]])

rfind()와 비슷하지만 하위 시퀀스 하위를 찾을 수 없을 때 ValueError를 발생시킵니다.

검색할 하위 시퀀스는 바이트열류 객체 또는 0에서 255 범위의 정수일 수 있습니다.

버전 3.3에서 변경: 또한 하위 시퀀스로 0에서 255 범위의 정수를 허용합니다.

bytes.rpartition(sep)
bytearray.rpartition(sep)

sep의 마지막 발생에서 시퀀스를 분할하고 구분 기호 앞의 부분, 구분 기호 자체 또는 해당 바이트 배열 복사본 및 구분 기호 뒤의 부분을 포함하는 3-튜플을 반환합니다. 구분 기호를 찾을 수 없으면 두 개의 빈 바이트 또는 바이트 배열 객체와 원래 시퀀스의 복사본을 포함하는 3-튜플을 반환합니다.

검색할 구분 기호는 바이트열류 객체일 수 있습니다.

bytes.startswith(prefix[, start[, end]])
bytearray.startswith(prefix[, start[, end]])

이진 데이터가 지정된 접두사로 시작하면 True를 반환하고 그렇지 않으면 False를 반환합니다. 접두사는 찾을 접두사의 튜플일 수도 있습니다. 선택적 시작으로 해당 위치에서 테스트 시작. 옵션 끝으로 해당 위치에서 비교를 중지합니다.

검색할 접두사는 바이트열류 객체일 수 있습니다.

bytes.translate(table, /, delete=b”)
bytearray.translate(table, /, delete=b”)

선택적 인수 delete에서 발생하는 모든 바이트가 제거되고 나머지 바이트는 길이 256의 바이트 객체여야 하는 지정된 변환 테이블을 통해 매핑된 바이트 또는 바이트 배열 객체의 복사본을 반환합니다.

bytes.maketrans() 메서드를 사용하여 변환 테이블을 만들 수 있습니다.

문자만 삭제하는 번역의 경우 테이블 인수를 None으로 설정합니다.

>>> b'read this short text'.translate(None, b'aeiou')
b'rd ths shrt txt'

버전 3.6에서 변경: 이제 delete가 키워드 인수로 지원됩니다.

바이트 및 바이트 배열 객체에 대한 다음 메서드에는 ASCII 호환 이진 형식의 사용을 가정하는 기본 동작이 있지만 적절한 인수를 전달하여 임의의 이진 데이터와 함께 계속 사용할 수 있습니다. 이 섹션의 모든 bytearray 메서드는 제자리에서 작동하지 않고 대신 새 개체를 생성합니다.

bytes.center(width[, fillbyte])
bytearray.center(width[, fillbyte])

길이 너비 시퀀스의 중심에 있는 객체의 복사본을 반환합니다. 패딩은 지정된 필바이트를 사용하여 수행됩니다(기본값은 ASCII 공간임). 바이트 객체의 경우 너비가 len(s)보다 작거나 같으면 원래 시퀀스가 반환됩니다.

참고: 이 메서드의 bytearray 버전은 제자리에서 작동하지 않습니다. 변경 사항이 없더라도 항상 새 개체를 생성합니다.

bytes.ljust(width[, fillbyte])
bytearray.ljust(width[, fillbyte])

길이 너비 시퀀스에서 왼쪽 정렬된 객체의 복사본을 반환합니다. 패딩은 지정된 필바이트를 사용하여 수행됩니다(기본값은 ASCII 공간임). 바이트 객체의 경우 너비가 len(s)보다 작거나 같으면 원래 시퀀스가 반환됩니다.

참고 이 메서드의 bytearray 버전은 제자리에서 작동하지 않습니다. 변경 사항이 없더라도 항상 새 개체를 생성합니다.

bytes.lstrip([chars])
bytearray.lstrip([chars])

지정된 선행 바이트가 제거된 시퀀스의 복사본을 반환합니다. chars 인수는 제거할 바이트 값 집합을 지정하는 이진 시퀀스입니다. 이름은 이 메서드가 일반적으로 ASCII 문자와 함께 사용된다는 사실을 나타냅니다. 생략하거나 None인 경우 chars 인수는 기본적으로 ASCII 공백을 제거합니다. chars 인수는 접두사가 아닙니다. 오히려 해당 값의 모든 조합이 제거됩니다.

>>> b'   spacious   '.lstrip()
b'spacious   '
>>> b'www.example.com'.lstrip(b'cmowz.')
b'example.com'

제거할 바이트 값의 이진 시퀀스는 임의의 바이트열류 객체일 수 있습니다. 모든 문자 집합이 아닌 단일 접두사 문자열을 제거하는 방법은 removeprefix()를 참조하십시오. 예를 들어:

>>> b'Arthur: three!'.lstrip(b'Arthur: ')
b'ee!'
>>> b'Arthur: three!'.removeprefix(b'Arthur: ')
b'three!'

참고 이 메서드의 bytearray 버전은 제자리에서 작동하지 않습니다. 변경 사항이 없더라도 항상 새 개체를 생성합니다.

bytes.rjust(width[, fillbyte])
bytearray.rjust(width[, fillbyte])

길이 너비 시퀀스에서 오른쪽 정렬된 객체의 복사본을 반환합니다. 패딩은 지정된 필바이트를 사용하여 수행됩니다(기본값은 ASCII 공간임). 바이트 객체의 경우 너비가 len(s)보다 작거나 같으면 원래 시퀀스가 반환됩니다.

참고 이 메서드의 bytearray 버전은 제자리에서 작동하지 않습니다. 변경 사항이 없더라도 항상 새 개체를 생성합니다.

bytes.rsplit(sep=None, maxsplit=- 1)
bytearray.rsplit(sep=None, maxsplit=- 1)

sep를 구분 기호 문자열로 사용하여 이진 시퀀스를 동일한 유형의 하위 시퀀스로 분할합니다. maxsplit이 주어지면 최대 maxsplit 분할이 수행됩니다. sep가 지정되지 않았거나 None인 경우 ASCII 공백만으로 구성된 하위 시퀀스는 구분 기호입니다. 오른쪽에서 분할하는 것을 제외하고 rsplit()은 아래에서 자세히 설명하는 split()과 같이 동작합니다.

bytes.rstrip([chars])
bytearray.rstrip([chars])

지정된 후행 바이트가 제거된 시퀀스의 복사본을 반환합니다. chars 인수는 제거할 바이트 값 집합을 지정하는 이진 시퀀스입니다. 이름은 이 메서드가 일반적으로 ASCII 문자와 함께 사용된다는 사실을 나타냅니다. 생략하거나 None인 경우 chars 인수는 기본적으로 ASCII 공백을 제거합니다. chars 인수는 접미사가 아닙니다. 오히려 해당 값의 모든 조합이 제거됩니다.

>>> b'   spacious   '.rstrip()
b'   spacious'
>>> b'mississippi'.rstrip(b'ipz')
b'mississ'

제거할 바이트 값의 이진 시퀀스는 임의의 바이트열류 객체일 수 있습니다. 모든 문자 집합이 아닌 단일 접미사 문자열을 제거하는 메서드는 removesuffix()를 참조하십시오. 예를 들어:

>>> b'Monty Python'.rstrip(b' Python')
b'M'
>>> b'Monty Python'.removesuffix(b' Python')
b'Monty'

참고 이 메서드의 bytearray 버전은 제자리에서 작동하지 않습니다. 변경 사항이 없더라도 항상 새 개체를 생성합니다.

bytes.split(sep=None, maxsplit=- 1)
bytearray.split(sep=None, maxsplit=- 1)

sep를 구분 기호 문자열로 사용하여 이진 시퀀스를 동일한 유형의 하위 시퀀스로 분할합니다. maxsplit이 제공되고 음수가 아닌 경우 최대 maxsplit 분할이 수행됩니다(따라서 목록에는 최대 maxsplit+1 요소가 있음). maxsplit이 지정되지 않았거나 -1이면 분할 수에 제한이 없습니다(가능한 모든 분할이 이루어짐).

sep가 제공되면 연속 구분 기호는 함께 그룹화되지 않고 빈 하위 시퀀스를 구분하는 것으로 간주됩니다(예: b’1,,2′.split(b’,’)는 [b’1′, b”, b’를 반환함) 2′]). sep 인수는 멀티바이트 시퀀스로 구성될 수 있습니다(예: b’1<>2<>3′.split(b'<>’)는 [b’1′, b’2′, b’3′]를 반환함) . 빈 시퀀스를 지정된 구분 기호로 분할하면 분할되는 개체 유형에 따라 [b”] 또는 [bytearray(b”)]가 반환됩니다. sep 인수는 바이트열류 객체일 수 있습니다.

예를 들어:

>>> b'1,2,3'.split(b',')
[b'1', b'2', b'3']
>>> b'1,2,3'.split(b',', maxsplit=1)
[b'1', b'2,3']
>>> b'1,2,,3,'.split(b',')
[b'1', b'2', b'', b'3', b'']

sep가 지정되지 않았거나 None이면 다른 분할 알고리즘이 적용됩니다. 연속적인 ASCII 공백 실행은 단일 구분 기호로 간주되며 시퀀스에 선행 또는 후행 공백이 있으면 결과의 시작 또는 끝에 빈 문자열이 포함되지 않습니다. 결과적으로 빈 시퀀스 또는 지정된 구분 기호 없이 ASCII 공백만으로 구성된 시퀀스를 분할하면 []가 반환됩니다.

예를 들어:

>>> b'1 2 3'.split()
[b'1', b'2', b'3']
>>> b'1 2 3'.split(maxsplit=1)
[b'1', b'2 3']
>>> b'   1   2   3   '.split()
[b'1', b'2', b'3']

bytes.strip([chars])
bytearray.strip([chars])

지정된 선행 및 후행 바이트가 제거된 시퀀스의 복사본을 반환합니다. chars 인수는 제거할 바이트 값 집합을 지정하는 이진 시퀀스입니다. 이름은 이 메서드가 일반적으로 ASCII 문자와 함께 사용된다는 사실을 나타냅니다. 생략하거나 None인 경우 chars 인수는 기본적으로 ASCII 공백을 제거합니다. chars 인수는 접두사 또는 접미사가 아닙니다. 오히려 해당 값의 모든 조합이 제거됩니다.

>>> b'   spacious   '.strip()
b'spacious'
>>> b'www.example.com'.strip(b'cmowz.')
b'example'

제거할 바이트 값의 이진 시퀀스는 임의의 바이트열류 객체일 수 있습니다.

참고 이 메서드의 bytearray 버전은 제자리에서 작동하지 않습니다. 변경 사항이 없더라도 항상 새 개체를 생성합니다.

바이트 및 바이트 배열 개체에 대한 다음 메서드는 ASCII 호환 이진 형식을 사용한다고 가정하며 임의의 이진 데이터에 적용하면 안 됩니다. 이 섹션의 모든 bytearray 메서드는 제자리에서 작동하지 않고 대신 새 개체를 생성합니다.

bytes.capitalize()
bytearray.capitalize()

각 바이트가 ASCII 문자로 해석되고 첫 번째 바이트는 대문자이고 나머지는 소문자로 된 시퀀스의 복사본을 반환합니다. ASCII가 아닌 바이트 값은 변경되지 않은 상태로 전달됩니다.

참고 이 메서드의 bytearray 버전은 제자리에서 작동하지 않습니다. 변경 사항이 없더라도 항상 새 개체를 생성합니다.

bytes.expandtabs(tabsize=8)
bytearray.expandtabs(tabsize=8)

현재 열과 지정된 탭 크기에 따라 모든 ASCII 탭 문자가 하나 이상의 ASCII 공백으로 대체되는 시퀀스의 복사본을 반환합니다. 탭 위치는 tabsize 바이트마다 발생합니다(기본값은 8이며 열 0, 8, 16 등에서 탭 위치를 제공합니다). 시퀀스를 확장하기 위해 현재 열을 0으로 설정하고 시퀀스를 바이트 단위로 검사합니다. 바이트가 ASCII 탭 문자(b’\t’)이면 현재 열이 다음 탭 위치와 같아질 때까지 하나 이상의 공백 문자가 결과에 삽입됩니다. (탭 문자 자체는 복사되지 않습니다.) 현재 바이트가 ASCII 개행 문자(b’\n’) 또는 캐리지 리턴(b’\r’)이면 복사되고 현재 열이 0으로 재설정됩니다. 다른 바이트 값은 변경되지 않고 복사되고 현재 열은 인쇄 시 바이트 값이 어떻게 표시되는지에 관계없이 1씩 증가합니다.

>>> b'01\t012\t0123\t01234'.expandtabs()
b'01      012     0123    01234'
>>> b'01\t012\t0123\t01234'.expandtabs(4)
b'01  012 0123    01234'

참고 이 메서드의 bytearray 버전은 제자리에서 작동하지 않습니다. 변경 사항이 없더라도 항상 새 개체를 생성합니다.

bytes.isalnum()
bytearray.isalnum()

시퀀스의 모든 바이트가 알파벳 ASCII 문자 또는 ASCII 십진수이고 시퀀스가 비어 있지 않으면 True를 반환하고, 그렇지 않으면 False를 반환합니다. 알파벳 ASCII 문자는 시퀀스 b’abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ’의 바이트 값입니다. ASCII 십진수는 시퀀스 b’0123456789’의 바이트 값입니다.

예를 들어:

>>> b'ABCabc1'.isalnum()
True
>>> b'ABC abc1'.isalnum()
False

bytes.isalpha()
bytearray.isalpha()

시퀀스의 모든 바이트가 알파벳 ASCII 문자이고 시퀀스가 비어 있지 않으면 True를 반환하고, 그렇지 않으면 False를 반환합니다. 알파벳 ASCII 문자는 시퀀스 b’abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ’의 바이트 값입니다.

예를 들어:

>>> b'ABCabc'.isalpha()
True
>>> b'ABCabc1'.isalpha()
False

bytes.isascii()
bytearray.isascii()

시퀀스가 비어 있거나 시퀀스의 모든 바이트가 ASCII이면 True를 반환하고 그렇지 않으면 False를 반환합니다. ASCII 바이트는 0-0x7F 범위에 있습니다.

버전 3.7의 새로운 기능.

bytes.isdigit()
bytearray.isdigit()

시퀀스의 모든 바이트가 ASCII 십진수이고 시퀀스가 비어 있지 않으면 True를 반환하고 그렇지 않으면 False를 반환합니다. ASCII 십진수는 시퀀스 b’0123456789’의 바이트 값입니다.

예를 들어:

>>> b'1234'.isdigit()
True
>>> b'1.23'.isdigit()
False

bytes.islower()
bytearray.islower()

시퀀스에 소문자 ASCII 문자가 하나 이상 있고 대문자 ASCII 문자가 없으면 True를 반환하고 그렇지 않으면 False를 반환합니다.

예를 들어:

>>> b'hello world'.islower()
True
>>> b'Hello world'.islower()
False

소문자 ASCII 문자는 시퀀스 b’abcdefghijklmnopqrstuvwxyz’의 바이트 값입니다. 대문자 ASCII 문자는 시퀀스 b’ABCDEFGHIJKLMNOPQRSTUVWXYZ’의 바이트 값입니다.

bytes.isspace()
bytearray.isspace()

시퀀스의 모든 바이트가 ASCII 공백이고 시퀀스가 비어 있지 않으면 True를 반환하고 그렇지 않으면 False를 반환합니다. ASCII 공백 문자는 시퀀스 b’ \t\n\r\x0b\f'(공백, 탭, 줄 바꿈, 캐리지 리턴, 세로 탭, 양식 공급)의 바이트 값입니다.

bytes.istitle()
bytearray.istitle()

시퀀스가 ASCII 제목 케이스이고 시퀀스가 비어 있지 않으면 True를 반환하고, 그렇지 않으면 False를 반환합니다. “titlecase”의 정의에 대한 자세한 내용은 bytes.title()을 참조하세요.

예를 들어:

>>> b'Hello World'.istitle()
True
>>> b'Hello world'.istitle()
False

bytes.isupper()
bytearray.isupper()

시퀀스에 대문자 알파벳 ASCII 문자가 하나 이상 있고 소문자 ASCII 문자가 없으면 True를 반환하고, 그렇지 않으면 False를 반환합니다.

예를 들어:

>>> b'HELLO WORLD'.isupper()
True
>>> b'Hello world'.isupper()
False

소문자 ASCII 문자는 시퀀스 b’abcdefghijklmnopqrstuvwxyz’의 바이트 값입니다. 대문자 ASCII 문자는 시퀀스 b’ABCDEFGHIJKLMNOPQRSTUVWXYZ’의 바이트 값입니다.

bytes.lower()
bytearray.lower()

모든 대문자 ASCII 문자가 해당 소문자로 변환된 시퀀스의 복사본을 반환합니다.

예를 들어:

>>> b'Hello World'.lower()
b'hello world'

소문자 ASCII 문자는 시퀀스 b’abcdefghijklmnopqrstuvwxyz’의 바이트 값입니다. 대문자 ASCII 문자는 시퀀스 b’ABCDEFGHIJKLMNOPQRSTUVWXYZ’의 바이트 값입니다.

참고: 이 메서드의 bytearray 버전은 제자리에서 작동하지 않습니다. 변경 사항이 없더라도 항상 새 개체를 생성합니다.

bytes.splitlines(keepends=False)
bytearray.splitlines(keepends=False)

ASCII 줄 경계에서 끊어지는 이진 시퀀스의 줄 목록을 반환합니다. 이 방법은 줄을 분할하기 위해 범용 개행 접근 방식을 사용합니다. keepends가 제공되고 true가 아니면 결과 목록에 줄바꿈이 포함되지 않습니다.

예를 들어:

>>> b'ab c\n\nde fg\rkl\r\n'.splitlines()
[b'ab c', b'', b'de fg', b'kl']
>>> b'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
[b'ab c\n', b'\n', b'de fg\r', b'kl\r\n']

구분 기호 문자열 sep가 제공될 때 split()과 달리 이 메서드는 빈 문자열에 대해 빈 목록을 반환하고 터미널 줄 바꿈으로 인해 추가 줄이 생성되지 않습니다.

>>> b"".split(b'\n'), b"Two lines\n".split(b'\n')
([b''], [b'Two lines', b''])
>>> b"".splitlines(), b"One line\n".splitlines()
([], [b'One line'])

bytes.swapcase()
bytearray.swapcase()

모든 소문자 ASCII 문자가 해당 대문자로 변환되거나 그 반대로 변환된 시퀀스의 복사본을 반환합니다.

예를 들어:

>>> b'Hello World'.swapcase()
b'hELLO wORLD'

소문자 ASCII 문자는 시퀀스 b’abcdefghijklmnopqrstuvwxyz’의 바이트 값입니다. 대문자 ASCII 문자는 시퀀스 b’ABCDEFGHIJKLMNOPQRSTUVWXYZ’의 바이트 값입니다.

str.swapcase()와 달리 바이너리 버전의 경우 항상 bin.swapcase().swapcase() == bin인 경우입니다. 대소문자 변환은 임의의 유니코드 코드 포인트에 대해 일반적으로 사실이 아니지만 ASCII에서 대칭적입니다.

참고: 이 메서드의 bytearray 버전은 제자리에서 작동하지 않습니다. 변경 사항이 없더라도 항상 새 개체를 생성합니다.

bytes.title()
bytearray.title()

단어가 대문자 ASCII 문자로 시작하고 나머지 문자는 소문자인 바이너리 시퀀스의 제목이 있는 버전을 반환합니다. 케이스가 없는 바이트 값은 수정되지 않은 상태로 남습니다.

예를 들어:

>>> b'Hello world'.title()
b'Hello World'

소문자 ASCII 문자는 시퀀스 b’abcdefghijklmnopqrstuvwxyz’의 바이트 값입니다. 대문자 ASCII 문자는 시퀀스 b’ABCDEFGHIJKLMNOPQRSTUVWXYZ’의 바이트 값입니다. 다른 모든 바이트 값은 대/소문자가 구분되지 않습니다.

알고리즘은 연속 문자 그룹으로 단어의 간단한 언어 독립적 정의를 사용합니다. 이 정의는 많은 맥락에서 작동하지만 축약형 및 소유격의 아포스트로피가 단어 경계를 형성하며 이는 원하는 결과가 아닐 수 있음을 의미합니다.

>>> b"they're bill's friends from the UK".title()
b"They'Re Bill'S Friends From The Uk"

아포스트로피에 대한 해결 방법은 정규식을 사용하여 구성할 수 있습니다.

>>> import re
>>> def titlecase(s):
...     return re.sub(rb"[A-Za-z]+('[A-Za-z]+)?",
...                   lambda mo: mo.group(0)[0:1].upper() +
...                              mo.group(0)[1:].lower(),
...                   s)
... 
>>> titlecase(b"they're bill's friends.")
b"They're Bill's Friends.

참고: 이 메서드의 bytearray 버전은 제자리에서 작동하지 않습니다. 변경 사항이 없더라도 항상 새 개체를 생성합니다.

bytes.upper()
bytearray.upper()

모든 소문자 ASCII 문자가 해당 대문자로 변환된 시퀀스의 복사본을 반환합니다.

예를 들어:

>>> b'Hello World'.upper()
b'HELLO WORLD

소문자 ASCII 문자는 시퀀스 b’abcdefghijklmnopqrstuvwxyz’의 바이트 값입니다. 대문자 ASCII 문자는 시퀀스 b’ABCDEFGHIJKLMNOPQRSTUVWXYZ’의 바이트 값입니다.

참고: 이 메서드의 bytearray 버전은 제자리에서 작동하지 않습니다. 변경 사항이 없더라도 항상 새 개체를 생성합니다.

bytes.zfill(width)
bytearray.zfill(width)

길이 너비의 시퀀스를 만들기 위해 ASCII b’0′ 숫자로 채워진 시퀀스의 복사본을 반환합니다. 앞 기호 접두사(b’+’/ b’-‘)는 앞이 아닌 기호 문자 뒤에 패딩을 삽입하여 처리됩니다. 바이트 객체의 경우 너비가 len(seq)보다 작거나 같으면 원래 시퀀스가 반환됩니다.

예를 들어:

>>> b"42".zfill(5)
b'00042'
>>> b"-42".zfill(5)
b'-0042'

참고: 이 메서드의 bytearray 버전은 제자리에서 작동하지 않습니다. 변경 사항이 없더라도 항상 새 개체를 생성합니다.

`printf`-style Bytes Formatting

참고: 여기에 설명된 서식 지정 작업은 여러 일반적인 오류(예: 튜플 및 사전을 올바르게 표시하지 못함)로 이어지는 다양한 문제를 나타냅니다. 출력되는 값이 튜플이나 딕셔너리일 수 있으면 튜플로 감싸십시오.

바이트 개체(bytes/bytearray)에는 % 연산자(modulo)라는 고유한 내장 연산이 하나 있습니다. 이것은 바이트 형식 지정 또는 보간 연산자라고도 합니다. 형식 % 값이 주어지면(여기서 형식은 바이트 객체임), 형식의 % 변환 사양은 값의 0개 이상의 요소로 대체됩니다. 그 효과는 C 언어에서 sprintf()를 사용하는 것과 비슷합니다.

형식에 단일 인수가 필요한 경우 값은 튜플이 아닌 단일 객체일 수 있습니다. 5 그렇지 않으면 값은 format bytes 개체 또는 단일 매핑 개체(예: 사전)에 의해 지정된 항목 수와 정확히 일치하는 튜플이어야 합니다.

변환 지정자는 두 개 이상의 문자를 포함하며 다음 구성 요소가 있으며 이 순서로 발생해야 합니다.

지정자의 시작을 표시하는 ‘%’ 문자.
괄호로 묶인 일련의 문자(예: (somename))로 구성된 매핑 키(선택 사항).
일부 변환 유형의 결과에 영향을 미치는 변환 플래그(선택 사항).
최소 필드 너비(선택 사항). ‘*'(별표)로 지정된 경우 값의 튜플의 다음 요소에서 실제 너비를 읽고 변환할 개체는 최소 필드 너비와 선택적 정밀도 뒤에 옵니다.
정밀도(선택 사항), ‘.’로 지정됨 (점) 다음에 정밀도가 옵니다. ‘*'(별표)로 지정된 경우 값의 튜플의 다음 요소에서 실제 정밀도를 읽고 변환할 값이 정밀도 뒤에 옵니다.
길이 수정자(선택 사항).
전환 유형.

올바른 인수가 사전(또는 다른 매핑 유형)인 경우 바이트 객체의 형식에는 ‘%’ 문자 바로 뒤에 삽입된 해당 사전에 대한 괄호로 묶인 매핑 키가 포함되어야 합니다. 매핑 키는 매핑에서 형식화할 값을 선택합니다. 예를 들어:

>>> print(b'%(language)s has %(number)03d quote types.' %
...       {b'language': b"Python", b"number": 2})
b'Python has 002 quote types.'

이 경우 형식에 * 지정자가 없을 수 있습니다(순차 매개변수 목록이 필요하기 때문).

변환 플래그 문자는 다음과 같습니다.

Flag	Meaning
`'#'`	값 변환은 “대체 형식”(아래에 정의됨)을 사용합니다.
`'0'`	변환은 숫자 값에 대해 0으로 채워집니다.
`'-'`	변환된 값은 왼쪽으로 조정됩니다(둘 다 제공되는 경우 ‘0’ 변환을 무시함).
`' '`	(공백) 부호 있는 변환으로 생성된 양수(또는 빈 문자열) 앞에는 공백이 있어야 합니다.
`'+'`	부호 문자(‘+’ 또는 ‘-‘)가 변환보다 우선합니다(“공백” 플래그를 재정의함).

길이 수정자(h, l 또는 L)가 있을 수 있지만 Python에 필요하지 않으므로 무시됩니다. %ld은(는) %d와 동일합니다.

전환 유형은 다음과 같습니다.

Conversion	Meaning
`'d'`	부호 있는 정수 십진수.
`'i'`	부호 있는 정수 십진수.
`'o'`	부호 있는 8진수 값.
`'u'`	폐기된 유형 – ‘d’와 동일합니다.
`'x'`	부호 있는 16진수(소문자).
`'X'`	부호 있는 16진수(소문자).
`'e'`	부동 소수점 지수 형식(소문자).
`'E'`	부동 소수점 지수 형식(대문자).
`'f'`	부동 소수점 10진수 형식.
`'F'`	부동 소수점 10진수 형식.
`'g'`	부동 소수점 형식. 지수가 -4보다 작거나 정밀도보다 작지 않으면 소문자 지수 형식을 사용하고 그렇지 않으면 십진수 형식을 사용합니다.
`'G'`	부동 소수점 형식. 지수가 -4보다 작거나 정밀도보다 작지 않으면 대문자 지수 형식을 사용하고 그렇지 않으면 십진수 형식을 사용합니다.
`'c'`	1바이트(정수 또는 1바이트 객체 허용).
`'b'`	바이트(버퍼 프로토콜을 따르거나 __bytes__()를 갖는 모든 객체).
`'s'`	‘s’는 ‘b’의 별칭이며 Python2/3 코드 베이스에만 사용해야 합니다.
`'a'`	바이트(repr(obj).encode(‘ascii’, ‘backslashreplace’)를 사용하여 Python 객체를 변환함).
`'r'`	‘r’은 ‘a’의 별칭이며 Python2/3 코드 베이스에만 사용해야 합니다.
`'%'`	인수가 변환되지 않고 결과에 ‘%’ 문자가 표시됩니다.

노트:

대체 형식을 사용하면 선행 8진수 지정자(‘0o’)가 첫 번째 숫자 앞에 삽입됩니다.
대체 형식을 사용하면 선행 ‘0x’ 또는 ‘0X'(‘x’ 또는 ‘X’ 형식이 사용되었는지 여부에 따라 다름)가 첫 번째 숫자 앞에 삽입됩니다.
대체 형식을 사용하면 뒤에 숫자가 없더라도 결과에 항상 소수점이 포함됩니다.
정밀도는 소수점 이하 자릿수를 결정하며 기본값은 6입니다.
대체 형식을 사용하면 결과에 항상 소수점이 포함되며 후행 0은 제거되지 않습니다.
정밀도는 소수점 전후의 유효 자릿수를 결정하며 기본값은 6입니다.
정밀도가 N이면 출력이 N자로 잘립니다.
b’%s’는 더 이상 사용되지 않지만 3.x 시리즈에서 제거되지 않습니다.
b’%r’은 더 이상 사용되지 않지만 3.x 시리즈에서 제거되지 않습니다.
PEP 237 참조.

참고: 이 메서드의 bytearray 버전은 제자리에서 작동하지 않습니다. 변경 사항이 없더라도 항상 새 개체를 생성합니다.
PEP 461 – 바이트 및 바이트 배열에 % 형식 지정 추가 참조

버전 3.5의 새로운 기능.

Memory Views

memoryview 개체를 사용하면 Python 코드가 복사하지 않고 버퍼 프로토콜을 지원하는 개체의 내부 데이터에 액세스할 수 있습니다.

class memoryview(object)

개체를 참조하는 memoryview를 만듭니다. 개체는 버퍼 프로토콜을 지원해야 합니다. 버퍼 프로토콜을 지원하는 내장 개체에는 bytes 및 bytearray가 포함됩니다.

memoryview에는 원래 개체에서 처리하는 원자 메모리 단위인 요소라는 개념이 있습니다. bytes 및 bytearray와 같은 많은 단순 유형의 경우 요소는 단일 바이트이지만 array.array와 같은 다른 유형에는 더 큰 요소가 있을 수 있습니다.

len(view)는 tolist의 길이와 같습니다. view.ndim = 0이면 길이는 1입니다. view.ndim = 1이면 길이는 보기의 요소 수와 같습니다. 더 높은 차원의 경우 길이는 보기의 중첩 목록 표시 길이와 같습니다. itemsize 속성은 단일 요소의 바이트 수를 제공합니다.

memoryview는 데이터를 노출하기 위해 슬라이싱 및 인덱싱을 지원합니다. 1차원 슬라이싱은 하위 뷰를 생성합니다.

>>> v = memoryview(b'abcefg')
>>> v[1]
98
>>> v[-1]
103
>>> v[1:4]
<memory at 0x7f3ddc9f4350>
>>> bytes(v[1:4])
b'bce'

format이 struct 모듈의 기본 형식 지정자 중 하나인 경우 정수 또는 정수 튜플을 사용한 인덱싱도 지원되며 올바른 유형의 단일 요소를 반환합니다. 1차원 메모리 뷰는 정수 또는 1정수 튜플로 인덱싱할 수 있습니다. 다차원 메모리 뷰는 정확히 ndim 정수의 튜플로 인덱싱할 수 있습니다. 여기서 ndim은 차원 수입니다. 0차원 메모리 뷰는 빈 튜플로 인덱싱할 수 있습니다.

다음은 바이트가 아닌 형식의 예입니다.

>>> import array
>>> a = array.array('l', [-11111111, 22222222, -33333333, 44444444])
>>> m = memoryview(a)
>>> m[0]
-11111111
>>> m[-1]
44444444
>>> m[::2].tolist()
[-11111111, -33333333]

기본 객체가 쓰기 가능한 경우 memoryview는 1차원 슬라이스 할당을 지원합니다. 크기 조정이 허용되지 않습니다:

>>> data = bytearray(b'abcefg')
>>> v = memoryview(data)
>>> v.readonly
False
>>> v[0] = ord(b'z')
>>> data
bytearray(b'zbcefg')
>>> v[1:4] = b'123'
>>> data
bytearray(b'z123fg')
>>> v[2:3] = b'spam'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: memoryview assignment: lvalue and rvalue have different structures
>>> v[2:6] = b'spam'
>>> data
bytearray(b'z1spam')

형식이 ‘B’, ‘b’ 또는 ‘c’인 해시 가능(읽기 전용) 유형의 1차원 메모리 뷰도 해시 가능합니다. 해시는 hash(m) == hash(m.tobytes())로 정의됩니다.

>>> v = memoryview(b'abcefg')
>>> hash(v) == hash(b'abcefg')
True
>>> hash(v[2:4]) == hash(b'ce')
True
>>> hash(v[::-2]) == hash(b'abcefg'[::-2])
True

버전 3.3에서 변경: 이제 1차원 메모리 뷰를 슬라이스할 수 있습니다. ‘B’, ‘b’ 또는 ‘c’ 형식의 1차원 메모리 뷰는 이제 해시 가능합니다.

버전 3.4에서 변경: 이제 memoryview가 collections.abc.Sequence에 자동으로 등록됩니다.

버전 3.5에서 변경: memoryviews는 이제 정수 튜플로 인덱싱할 수 있습니다.

memoryview에는 여러 가지 방법이 있습니다.

__eq__(exporter)

memoryview와 PEP 3118 내보내기는 모양이 동일하고 피연산자의 각 형식 코드가 struct 구문을 사용하여 해석될 때 해당하는 모든 값이 동일하면 동일합니다.

현재 tolist()에서 지원하는 구조체 형식 문자열의 하위 집합의 경우 v.tolist() == w.tolist()인 경우 v와 w는 동일합니다.

>>> import array
>>> a = array.array('I', [1, 2, 3, 4, 5])
>>> b = array.array('d', [1.0, 2.0, 3.0, 4.0, 5.0])
>>> c = array.array('b', [5, 3, 1])
>>> x = memoryview(a)
>>> y = memoryview(b)
>>> x == a == y == b
True
>>> x.tolist() == a.tolist() == y.tolist() == b.tolist()
True
>>> z = y[::-2]
>>> z == c
True
>>> z.tolist() == c.tolist()
True

형식 문자열 중 하나가 struct 모듈에서 지원되지 않으면 개체는 항상 같지 않은 것으로 비교됩니다(형식 문자열과 버퍼 내용이 동일하더라도).

>>> from ctypes import BigEndianStructure, c_long
>>> class BEPoint(BigEndianStructure):
...     _fields_ = [("x", c_long), ("y", c_long)]
...
>>> point = BEPoint(100, 200)
>>> a = memoryview(point)
>>> b = memoryview(point)
>>> a == point
False
>>> a == b
False

부동 소수점 숫자와 마찬가지로 v is w는 memoryview 개체에 대해 v == w를 의미하지 않습니다.

버전 3.3에서 변경: 이전 버전에서는 항목 형식과 논리 배열 구조를 무시하고 원시 메모리를 비교했습니다.

tobytes(order=’C’)

버퍼의 데이터를 바이트열로 반환합니다. 이는 memoryview에서 바이트 생성자를 호출하는 것과 같습니다.

>>> m = memoryview(b"abc")
>>> m.tobytes()
b'abc'
>>> bytes(m)
b'abc'

비연속 배열의 경우 결과는 모든 요소가 바이트로 변환된 평면화된 목록 표현과 동일합니다. tobytes()는 struct 모듈 구문에 없는 것을 포함하여 모든 형식 문자열을 지원합니다.

버전 3.8의 새로운 기능: 주문은 {‘C’, ‘F’, ‘A’}가 될 수 있습니다. 순서가 ‘C’ 또는 ‘F’인 경우 원래 배열의 데이터가 C 또는 Fortran 순서로 변환됩니다. 연속 보기의 경우 ‘A’는 실제 메모리의 정확한 복사본을 반환합니다. 특히 메모리 내 Fortran 순서가 보존됩니다. 비연속 보기의 경우 데이터가 먼저 C로 변환됩니다. order=None은 order=’C’와 동일합니다.

hex([sep[, bytes_per_sep]])

버퍼의 각 바이트에 대해 두 개의 16진수를 포함하는 문자열 객체를 반환합니다.

>>> m = memoryview(b"abc")
>>> m.hex()
'616263'

버전 3.5의 새로운 기능.

버전 3.8에서 변경: bytes.hex()와 유사하게 memoryview.hex()는 이제 16진수 출력에서 바이트 사이에 구분 기호를 삽입하기 위해 선택적 sep 및 bytes_per_sep 매개 변수를 지원합니다.

tolist()

버퍼의 데이터를 요소 목록으로 반환합니다.

>>> memoryview(b'abc').tolist()
[97, 98, 99]
>>> import array
>>> a = array.array('d', [1.1, 2.2, 3.3])
>>> m = memoryview(a)
>>> m.tolist()
[1.1, 2.2, 3.3]

버전 3.3에서 변경: tolist()는 이제 다차원 표현뿐만 아니라 구조체 모듈 구문의 모든 단일 문자 기본 형식을 지원합니다.

toreadonly()

memoryview 객체의 읽기 전용 버전을 반환합니다. 원래 memoryview 개체는 변경되지 않습니다.

>>> m = memoryview(bytearray(b'abc'))
>>> mm = m.toreadonly()
>>> mm.tolist()
[89, 98, 99]
>>> mm[0] = 42
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot modify read-only memory
>>> m[0] = 43
>>> mm.tolist()
[43, 98, 99]

버전 3.8의 새로운 기능.

release()

memoryview 개체에 의해 노출된 기본 버퍼를 해제합니다. 많은 객체는 뷰가 유지될 때 특별한 조치를 취합니다(예를 들어, bytearray는 일시적으로 크기 조정을 금지합니다). 따라서 release()를 호출하면 이러한 제한을 제거하고 가능한 한 빨리 모든 리소스를 해제하는 데 편리합니다.

이 메서드가 호출된 후 뷰에 대한 추가 작업은 ValueError를 발생시킵니다(여러 번 호출할 수 있는 release() 자체는 제외).

>>> m = memoryview(b'abc')
>>> m.release()
>>> m[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: operation forbidden on released memoryview object

컨텍스트 관리 프로토콜은 with 문을 사용하여 유사한 효과를 위해 사용할 수 있습니다.

>>> with memoryview(b'abc') as m:
...     m[0]
...
97
>>> m[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: operation forbidden on released memoryview object

버전 3.2의 새로운 기능.

cast(format[, shape])

memoryview를 새로운 형식이나 형태로 캐스트합니다. 모양은 기본적으로 [byte_length//new_itemsize]로, 이는 결과 보기가 1차원임을 의미합니다. 반환 값은 새로운 memoryview이지만 버퍼 자체는 복사되지 않습니다. 지원되는 캐스트는 1D -> C-연속 및 C-연속 -> 1D입니다.

대상 형식은 구조체 구문의 단일 요소 기본 형식으로 제한됩니다. 형식 중 하나는 바이트 형식(‘B’, ‘b’ 또는 ‘c’)이어야 합니다. 결과의 바이트 길이는 원래 길이와 같아야 합니다.

1D/long을 1D/unsigned 바이트로 캐스트:

>>> import array
>>> a = array.array('l', [1,2,3])
>>> x = memoryview(a)
>>> x.format
'l'
>>> x.itemsize
8
>>> len(x)
3
>>> x.nbytes
24
>>> y = x.cast('B')
>>> y.format
'B'
>>> y.itemsize
1
>>> len(y)
24
>>> y.nbytes
24

1D/unsigned 바이트를 1D/char로 캐스트:

>>> b = bytearray(b'zyz')
>>> x = memoryview(b)
>>> x[0] = b'a'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: memoryview: invalid value for format "B"
>>> y = x.cast('c')
>>> y[0] = b'a'
>>> b
bytearray(b'ayz')

1D/bytes를 3D/ints에서 1D/signed char로 변환:

>>> import struct
>>> buf = struct.pack("i"*12, *list(range(12)))
>>> x = memoryview(buf)
>>> y = x.cast('i', shape=[2,2,3])
>>> y.tolist()
>>> [[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]
>>> y.format
'i'
>>> y.itemsize
4
>>> len(y)
2
>>> y.nbytes
48
>>> z = y.cast('b')
>>> z.format
'b'
>>> z.itemsize
1
>>> len(z)
48
>>> z.nbytes
48

1D/unsigned long을 2D/unsigned long으로 캐스트:

>>> buf = struct.pack("L"*6, *list(range(6)))
>>> x = memoryview(buf)
>>> y = x.cast('L', shape=[2,3])
>>> len(y)
2
>>> y.nbytes
48
>>> y.tolist()
[[0, 1, 2], [3, 4, 5]]

버전 3.3의 새로운 기능.

버전 3.5에서 변경: 바이트 보기로 캐스팅할 때 소스 형식이 더 이상 제한되지 않습니다.

사용할 수 있는 몇 가지 읽기 전용 속성도 있습니다.

obj

memoryview의 기본 개체:

>>> b  = bytearray(b'xyz')
>>> m = memoryview(b)
>>> m.obj is b
True

버전 3.3의 새로운 기능.

nbytes

nbytes == 제품(모양) * 항목 크기 == len(m.tobytes()). 이것은 배열이 연속 표현에서 사용할 공간의 양(바이트)입니다. 반드시 len(m)과 같지는 않습니다:

>>> import array
>>> a = array.array('i', [1,2,3,4,5])
>>> m = memoryview(a)
>>> len(m)
5
>>> m.nbytes
20
>>> y = m[::2]
>>> len(y)
3
>>> y.nbytes
12
>>> len(y.tobytes())
12

다차원 배열:

>>> import struct
>>> buf = struct.pack("d"*12, *[1.5*x for x in range(12)])
>>> x = memoryview(buf)
>>> y = x.cast('d', shape=[3,4])
>>> y.tolist()
[[0.0, 1.5, 3.0, 4.5], [6.0, 7.5, 9.0, 10.5], [12.0, 13.5, 15.0, 16.5]]
>>> len(y)
3
>>> y.nbytes
96

버전 3.3의 새로운 기능.

readonly

메모리가 읽기 전용인지 여부를 나타내는 부울입니다.

format

보기의 각 요소에 대한 형식(구조체 모듈 스타일)을 포함하는 문자열입니다. 임의의 형식 문자열을 사용하여 내보내기에서 memoryview를 만들 수 있지만 일부 메서드(예: tolist())는 기본 단일 요소 형식으로 제한됩니다.

버전 3.3에서 변경: 형식 ‘B’는 이제 struct 모듈 구문에 따라 처리됩니다. 이것은 memoryview(b’abc’)[0] == b’abc'[0] == 97을 의미합니다.

itemsize

memoryview의 각 요소 크기(바이트):

>>> import array, struct
>>> m = memoryview(array.array('H', [32000, 32001, 32002]))
>>> m.itemsize
2
>>> m[0]
32000
>>> struct.calcsize('H') == m.itemsize
True

ndim

메모리가 나타내는 다차원 배열의 차원 수를 나타내는 정수입니다.

shape

메모리의 모양을 N 차원 배열로 제공하는 ndim 길이의 정수 튜플.

버전 3.3에서 변경: ndim = 0일 때 None 대신 빈 튜플.

strides

배열의 각 차원에 대한 각 요소에 액세스하기 위한 크기를 바이트 단위로 제공하는 ndim 길이의 정수 튜플.

버전 3.3에서 변경: ndim = 0일 때 None 대신 빈 튜플.

suboffsets

PIL 스타일 배열에 내부적으로 사용됩니다. 이 값은 정보용입니다.

c_contiguous

메모리가 C-연속인지 여부를 나타내는 부울입니다.

버전 3.3의 새로운 기능.

f_contiguous

메모리가 Fortran 연속인지 여부를 나타내는 부울입니다.

버전 3.3의 새로운 기능.

contiguous

메모리가 연속적인지 여부를 나타내는 부울입니다.

버전 3.3의 새로운 기능.

Set Types — `set`, `frozenset`

집합 객체는 해시 가능한 개별 객체의 정렬되지 않은 모음입니다. 일반적인 용도로는 멤버십 테스트, 시퀀스에서 중복 제거, 교집합, 합집합, 차이 및 대칭 차이와 같은 수학적 연산 계산이 있습니다. (다른 컨테이너의 경우 내장 dict, list 및 tuple 클래스와 collections 모듈을 참조하십시오.)

다른 컬렉션과 마찬가지로 세트는 x in set, len(set) 및 for x in set를 지원합니다. 정렬되지 않은 컬렉션이므로 세트는 요소 위치나 삽입 순서를 기록하지 않습니다. 따라서 세트는 인덱싱, 슬라이싱 또는 기타 시퀀스 유사 동작을 지원하지 않습니다.

현재 두 가지 기본 제공 집합 유형인 set 및 frozenset이 있습니다. 집합 유형은 변경 가능합니다 — 내용은 add() 및 remove()와 같은 메서드를 사용하여 변경할 수 있습니다. 변경 가능하기 때문에 해시 값이 없으며 사전 키 또는 다른 집합의 요소로 사용할 수 없습니다. frozenset 유형은 변경 불가능하고 해시 가능합니다. 생성된 후에 내용을 변경할 수 없습니다. 따라서 사전 키 또는 다른 집합의 요소로 사용할 수 있습니다.

비어 있지 않은 세트(frozensets 아님)는 중괄호 안에 쉼표로 구분된 요소 목록을 배치하여 만들 수 있습니다(예: {‘jack’, ‘sjoerd’}).

두 클래스의 생성자는 동일하게 작동합니다.

class set([iterable])
class frozenset([iterable])

iterable에서 요소를 가져온 새로운 집합 또는 frozenset 객체를 반환합니다. 집합의 요소는 해시 가능해야 합니다. 집합 집합을 나타내려면 내부 집합이 frozenset 객체여야 합니다. iterable이 지정되지 않으면 새로운 빈 세트가 반환됩니다.

세트는 여러 가지 방법으로 만들 수 있습니다.

중괄호 안에 쉼표로 구분된 요소 목록을 사용하세요: {‘jack’, ‘sjoerd’}
집합 이해력 사용: {c for c in ‘abcadabra’ if c not in ‘abc’}
유형 생성자 사용: set(), set(‘foobar’), set([‘a’, ‘b’, ‘foo’])

set 및 frozenset 인스턴스는 다음 작업을 제공합니다.

len(s)
집합 s의 요소 수를 반환합니다(s의 카디널리티).

x in s
x가 s에 속하는지 테스트합니다.

x not in s
s의 비회원에 대해 x를 테스트합니다.

isdisjoint(other)
집합에 다른 요소와 공통된 요소가 없으면 True를 반환합니다. 집합은 그들의 교집합이 빈 집합인 경우에만 서로소입니다.

issubset(other)
set <= other
집합의 모든 요소가 다른 요소에 있는지 테스트합니다.

set < other
집합이 other의 적절한 하위 집합인지 테스트합니다. 즉, set <= other 및 set != other입니다.

issuperset(other)
set >= other
other의 모든 요소가 집합에 있는지 테스트합니다.

set > other
집합이 other의 적절한 상위 집합인지 테스트합니다. 즉, set >= other 및 set != other입니다.

union(*others)
set | other | …
집합과 다른 모든 요소의 요소가 포함된 새 집합을 반환합니다.

intersection(*others)
set & other & …
집합과 다른 모든 요소에 공통적인 요소가 있는 새 집합을 반환합니다.

difference(*others)
set – other – …
다른 세트에는 없는 세트의 요소가 있는 새 세트를 반환합니다.

symmetric_difference(other)
set ^ other
집합 또는 다른 요소가 있는 새 집합을 반환하지만 둘 다는 아닙니다.

copy()
집합의 얕은 복사본을 반환합니다.

연산자가 아닌 버전의 union(), Intersection(), difference(), symmetric_difference(), issubset() 및 issuperset() 메서드는 모든 이터러블을 인수로 허용합니다. 대조적으로, 연산자 기반 상대는 인수를 설정해야 합니다. 이는 더 읽기 쉬운 set(‘abc’).intersection(‘cbs’)을 위해 set(‘abc’) & ‘cbs’와 같은 오류가 발생하기 쉬운 구성을 배제합니다.

set 및 frozenset 모두 set 비교를 지원합니다. 두 세트는 각 세트의 모든 요소가 다른 세트에 포함되어 있는 경우에만 동일합니다(각 세트는 다른 세트의 서브세트임). 집합은 첫 번째 집합이 두 번째 집합의 적절한 부분 집합인 경우에만 다른 집합보다 작습니다(부분 집합이지만 같지 않음). 첫 번째 집합이 두 번째 집합의 적절한 상위 집합인 경우에만 집합이 다른 집합보다 큽니다(상위 집합이지만 같지는 않음).

집합의 인스턴스는 구성원을 기준으로 frozenset의 인스턴스와 비교됩니다. 예를 들어 set(‘abc’) == frozenset(‘abc’)는 True를 반환하고 set([frozenset(‘abc’)])에서 set(‘abc’)도 마찬가지입니다.

부분 집합 및 같음 비교는 전체 순서 지정 함수로 일반화되지 않습니다. 예를 들어 비어 있지 않은 두 개의 분리된 집합은 서로 같지 않고 서로의 하위 집합이 아니므로 ab는 모두 False를 반환합니다.

세트는 부분 순서(하위 세트 관계)만 정의하므로 list.sort() 메서드의 출력은 세트 목록에 대해 정의되지 않습니다.

사전 키와 같은 집합 요소는 해시 가능해야 합니다.

집합 인스턴스를 frozenset과 혼합하는 이진 연산은 첫 번째 피연산자의 형식을 반환합니다. 예: frozenset(‘ab’) | set(‘bc’)는 frozenset의 인스턴스를 반환합니다.

다음 표에는 고정 집합의 불변 인스턴스에 적용되지 않는 집합에 사용할 수 있는 작업이 나열되어 있습니다.

update(*others)
set |= other | …
세트를 업데이트하고 다른 모든 요소를 추가합니다.

intersection_update(*others)
set &= other & …
집합에서 찾은 요소만 유지하고 집합을 업데이트합니다.

difference_update(*others)
set -= other | …
집합을 업데이트하고 다른 항목에서 찾은 요소를 제거합니다.

symmetric_difference_update(other)
set ^= other
세트를 업데이트하여 두 세트 모두가 아니라 두 세트 모두에서 발견된 요소만 유지합니다.

add(elem)
집합에 요소 요소를 추가합니다.

remove(elem)
집합에서 요소 요소를 제거합니다. elem이 세트에 포함되어 있지 않으면 KeyError를 발생시킵니다.

discard(elem)
요소 요소가 있는 경우 집합에서 요소 요소를 제거합니다.

pop()
집합에서 임의의 요소를 제거하고 반환합니다. 세트가 비어 있으면 KeyError 를 발생시킵니다.

clear()
집합에서 모든 요소를 제거합니다.

비연산자 버전의 update(), Intersection_update(), difference_update() 및 symmetric_difference_update() 메서드는 모든 이터러블을 인수로 허용합니다.

참고로, __contains__(), remove() 및 discard() 메서드에 대한 elem 인수는 집합일 수 있습니다. 동등한 frozenset 검색을 지원하기 위해 elem에서 임시 항목이 생성됩니다.

Mapping Types — `dict`

매핑 개체는 해시 가능한 값을 임의의 개체에 매핑합니다. 매핑은 변경 가능한 개체입니다. 현재 하나의 표준 매핑 유형인 사전만 있습니다. (다른 컨테이너에 대해서는 내장 목록, 집합 및 튜플 클래스와 컬렉션 모듈을 참조하십시오.)

사전의 키는 거의 임의의 값입니다. 해시할 수 없는 값, 즉 목록, 사전 또는 기타 변경 가능한 유형(객체 ID가 아닌 값으로 비교됨)을 포함하는 값은 키로 사용할 수 없습니다. 같음을 비교하는 값(예: 1, 1.0 및 True)은 동일한 사전 항목을 색인화하는 데 상호 교환적으로 사용할 수 있습니다.

class dict(kwargs)
class dict(mapping, kwargs)
class dict(iterable, **kwargs)

선택적 위치 인수와 비어 있을 수 있는 키워드 인수 세트에서 초기화된 새 사전을 반환합니다.

다음과 같은 여러 방법으로 사전을 만들 수 있습니다.

중괄호 안에 쉼표로 구분된 키: 값 쌍 목록 사용: {‘jack’: 4098, ‘sjoerd’: 4127} 또는 {4098: ‘jack’, 4127: ‘sjoerd’}
사전 이해 사용: {}, {x: x ** 2 for x in range(10)}
유형 생성자 사용: dict(), dict([(‘foo’, 100), (‘bar’, 200)]), dict(foo=100, bar=200)

위치 인수가 제공되지 않으면 빈 사전이 생성됩니다. 위치 인수가 지정되고 매핑 개체인 경우 매핑 개체와 동일한 키-값 쌍으로 사전이 생성됩니다. 그렇지 않으면 위치 인수는 반복 가능한 객체여야 합니다. iterable의 각 항목은 그 자체로 정확히 두 개의 객체가 있는 iterable이어야 합니다. 각 항목의 첫 번째 개체는 새 사전의 키가 되고 두 번째 개체는 해당 값이 됩니다. 키가 두 번 이상 발생하면 해당 키의 마지막 값이 새 사전의 해당 값이 됩니다.

키워드 인수가 주어지면 키워드 인수와 해당 값이 위치 인수에서 생성된 사전에 추가됩니다. 추가 중인 키가 이미 있는 경우 키워드 인수의 값이 위치 인수의 값을 대체합니다.

설명을 위해 다음 예제는 모두 {“one”: 1, “two”: 2, “three”: 3}과 같은 사전을 반환합니다.

>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})
>>> f = dict({'one': 1, 'three': 3}, two=2)
>>> a == b == c == d == e == f
True

첫 번째 예에서와 같이 키워드 인수를 제공하는 것은 유효한 Python 식별자인 키에 대해서만 작동합니다. 그렇지 않으면 유효한 키를 사용할 수 있습니다.

다음은 사전이 지원하는 작업입니다(따라서 사용자 지정 매핑 유형도 지원해야 함).

list(d)
사전에 사용된 모든 키 목록을 반환합니다. d.

len(d)
사전의 항목 수를 반환합니다. d.

d[key]
키 key로 d의 항목을 반환합니다. 키가 맵에 없으면 KeyError를 발생시킵니다.

dict의 하위 클래스가 메서드 __missing__()을 정의하고 키가 없는 경우, d[key] 연산은 키 키를 인수로 사용하여 해당 메서드를 호출합니다. 그런 다음 d[key] 작업은 __missing__(key) 호출에 의해 반환되거나 발생한 모든 항목을 반환하거나 발생시킵니다. 다른 작업이나 메서드는 __missing__()을 호출하지 않습니다. __missing__()이 정의되지 않은 경우, KeyError가 발생합니다. __missing__()은 메서드여야 합니다; 인스턴스 변수일 수 없습니다.

>>> class Counter(dict):
...     def __missing__(self, key):
...         return 0
>>> c = Counter()
>>> c['red']
0
>>> c['red'] += 1
>>> c['red']
1

위의 예는 collections.Counter 구현의 일부를 보여줍니다. 다른 __missing__ 메서드는 collections.defaultdict에서 사용됩니다.

d[key] = value
d[키]를 값으로 설정합니다.

del d[key]
d에서 d[key]를 제거합니다. 키가 맵에 없으면 KeyError를 발생시킵니다.

key in d
d에 키 키가 있으면 True를 반환하고 그렇지 않으면 False를 반환합니다.

key not in d
키를 입력하지 않는 것과 같습니다. d.

iter(d)
사전의 키에 대한 이터레이터를 반환합니다. 이것은 iter(d.keys())의 단축키입니다.

clear()
사전에서 모든 항목을 제거합니다.

copy()
사전의 얕은 복사본을 반환합니다.

classmethod fromkeys(iterable[, value])

iterable의 키와 value로 설정된 값으로 새 사전을 만듭니다.

fromkeys()는 새 사전을 반환하는 클래스 메서드입니다. 값은 기본적으로 없음입니다. 모든 값은 단일 인스턴스를 참조하므로 일반적으로 값이 빈 목록과 같은 변경 가능한 객체라는 것은 이치에 맞지 않습니다. 고유한 값을 얻으려면 대신 dict comprehension을 사용하십시오.

get(key[, default])
키가 사전에 있으면 키의 값을 반환하고 그렇지 않으면 기본값을 반환합니다. default가 주어지지 않으면 기본값은 None이므로 이 메서드는 KeyError를 발생시키지 않습니다.

items()
사전 항목((키, 값) 쌍)의 새 보기를 반환합니다. 뷰 객체 문서를 참조하십시오.

keys()
사전 키의 새 보기를 반환합니다. 뷰 객체 문서를 참조하십시오.

pop(key[, default])
키가 사전에 있으면 제거하고 해당 값을 반환하고 그렇지 않으면 기본값을 반환합니다. 기본값이 주어지지 않고 키가 사전에 없으면 KeyError가 발생합니다.

popitem()
사전에서 (키, 값) 쌍을 제거하고 반환합니다. 쌍은 LIFO 순서로 반환됩니다.

popitem()은 집합 알고리즘에서 자주 사용되는 사전을 파괴적으로 반복하는 데 유용합니다. 사전이 비어 있으면 popitem()을 호출하면 KeyError가 발생합니다.

버전 3.7에서 변경: 이제 LIFO 주문이 보장됩니다. 이전 버전에서 popitem()은 임의의 키/값 쌍을 반환했습니다.

reversed(d)
사전의 키에 대해 역 반복자를 반환합니다. 이는 reversed(d.keys())의 단축키입니다.

버전 3.8의 새로운 기능.

setdefault(key[, default])
키가 사전에 있으면 해당 값을 반환합니다. 그렇지 않은 경우 기본값으로 키를 삽입하고 기본값을 반환합니다. 기본값은 없음입니다.

update([other])
다른 키/값 쌍으로 사전을 업데이트하여 기존 키를 덮어씁니다. 없음을 반환합니다.

update()는 다른 딕셔너리 객체나 키/값 쌍의 이터러블(튜플 또는 길이가 2인 다른 이터러블로)을 허용합니다. 키워드 인수가 지정되면 사전이 해당 키/값 쌍으로 업데이트됩니다: d.update(red=1, blue=2).

values()
사전 값의 새 보기를 반환합니다. 뷰 객체 문서를 참조하십시오.

하나의 dict.values() 뷰와 다른 뷰 간의 동등성 비교는 항상 False를 반환합니다. 이는 dict.values()를 자신과 비교할 때도 적용됩니다.

>>> d = {'a': 1}
>>> d.values() == d.values()
False

d | other
d와 other의 병합된 키와 값으로 새 사전을 만듭니다. 둘 다 사전이어야 합니다. other의 값은 d와 다른 공유 키일 때 우선합니다.

버전 3.9의 새로운 기능.

d |= other
키/값 쌍의 매핑 또는 이터러블일 수 있는 other의 키와 값으로 사전 d를 업데이트합니다. other의 값은 d와 다른 공유 키일 때 우선합니다.

버전 3.9의 새로운 기능.

사전은 동일한 (키, 값) 쌍(순서에 관계없이)이 있는 경우에만 동일하게 비교됩니다. 순서 비교(‘<‘, ‘<=’, ‘>=’, ‘>’)는 TypeError를 발생시킵니다.

사전은 삽입 순서를 유지합니다. 키 업데이트는 순서에 영향을 미치지 않습니다. 삭제 후 추가된 키는 끝에 삽입됩니다.

>>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
d
>>> {'one': 1, 'two': 2, 'three': 3, 'four': 4}
>>> list(d)
['one', 'two', 'three', 'four']
>>> list(d.values())
[1, 2, 3, 4]
>>> d["one"] = 42
>>> d
{'one': 42, 'two': 2, 'three': 3, 'four': 4}
>>> del d["two"]
>>> d["two"] = None
>>> d
{'one': 42, 'three': 3, 'four': 4, 'two': None}

버전 3.7에서 변경: 사전 순서는 삽입 순서로 보장됩니다. 이 동작은 3.6부터 CPython의 구현 세부 사항이었습니다.

사전 및 사전 보기는 되돌릴 수 있습니다.

>>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> d
{'one': 1, 'two': 2, 'three': 3, 'four': 4}
>>> list(reversed(d))
['four', 'three', 'two', 'one']
>>> list(reversed(d.values()))
[4, 3, 2, 1]
>>> list(reversed(d.items()))
[('four', 4), ('three', 3), ('two', 2), ('one', 1)]

버전 3.8에서 변경: 이제 사전을 되돌릴 수 있습니다.

또한 types.MappingProxyType을 사용하여 dict의 읽기 전용 보기를 만들 수 있습니다.

Dictionary view objects

dict.keys(), dict.values() 및 dict.items()가 반환하는 객체는 뷰 객체입니다. 사전 항목에 대한 동적 보기를 제공합니다. 즉, 사전이 변경되면 보기에 이러한 변경 사항이 반영됩니다.

딕셔너리 뷰는 각각의 데이터를 생성하고 멤버십 테스트를 지원하기 위해 반복될 수 있습니다.

len(dictview)
사전의 항목 수를 반환합니다.

iter(dictview)
사전에서 키, 값 또는 항목((키, 값)의 튜플로 표현됨)에 대한 이터레이터를 반환합니다.

키와 값은 삽입 순서대로 반복됩니다. 이를 통해 zip()을 사용하여 (값, 키) 쌍을 생성할 수 있습니다: pairs = zip(d.values(), d.keys()). 동일한 목록을 만드는 또 다른 방법은 pairs = [(v, k) for (k, v) in d.items()]입니다.

사전에 항목을 추가하거나 삭제하는 동안 보기를 반복하면 RuntimeError가 발생하거나 모든 항목을 반복하지 못할 수 있습니다.

버전 3.7에서 변경: 사전 순서는 삽입 순서로 보장됩니다.

x in dictview
x가 기본 사전의 키, 값 또는 항목에 있으면 True를 반환합니다(후자의 경우 x는 (키, 값) 튜플이어야 합니다).

reversed(dictview)
사전의 키, 값 또는 항목에 대해 역 반복자를 반환합니다. 뷰는 삽입의 역순으로 반복됩니다.

버전 3.8에서 변경: 이제 사전 보기를 되돌릴 수 있습니다.

dictview.mapping
뷰가 참조하는 원래 사전을 래핑하는 types.MappingProxyType을 반환합니다.

버전 3.10의 새로운 기능.

키 뷰는 항목이 고유하고 해시 가능하므로 설정과 유사합니다. 모든 값이 해시 가능하여 (키, 값) 쌍이 고유하고 해시 가능하면 항목 보기도 세트와 유사합니다. (항목이 일반적으로 고유하지 않기 때문에 값 보기는 집합과 같은 것으로 처리되지 않습니다.) 집합과 같은 보기의 경우 추상 기본 클래스 collections.abc.Set에 대해 정의된 모든 작업을 사용할 수 있습니다(예: ==, < , 또는 ^).

사전 보기 사용 예:

>>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
>>> keys = dishes.keys()
>>> values = dishes.values()

>>> # iteration
>>> n = 0
>>> for val in values:
...     n += val
>>> print(n)
504

>>> # keys and values are iterated over in the same order (insertion order)
>>> list(keys)
['eggs', 'sausage', 'bacon', 'spam']
>>> list(values)
[2, 1, 1, 500]

>>> # view objects are dynamic and reflect dict changes
>>> del dishes['eggs']
>>> del dishes['sausage']
>>> list(keys)
['bacon', 'spam']

>>> # set operations
>>> keys & {'eggs', 'bacon', 'salad'}
{'bacon'}
>>> keys ^ {'sausage', 'juice'}
{'juice', 'sausage', 'bacon', 'spam'}

>>> # get back a read-only proxy for the original dictionary
>>> values.mapping
mappingproxy({'bacon': 1, 'spam': 500})
>>> values.mapping['spam']
500

Context Manager Types

Python의 with 문은 컨텍스트 관리자가 정의한 런타임 컨텍스트의 개념을 지원합니다. 이는 명령문 본문이 실행되기 전에 입력되고 명령문이 종료될 때 종료되는 런타임 컨텍스트를 정의하는 사용자 정의 클래스를 허용하는 한 쌍의 메서드를 사용하여 구현됩니다.

contextmanager.enter()

런타임 컨텍스트를 입력하고 이 개체 또는 런타임 컨텍스트와 관련된 다른 개체를 반환합니다. 이 메서드가 반환하는 값은 이 컨텍스트 관리자를 사용하여 with 문의 as 절에 있는 식별자에 바인딩됩니다.

자신을 반환하는 컨텍스트 관리자의 예는 파일 개체입니다. 파일 객체는 __enter__()에서 자신을 반환하여 open()이 with 문에서 컨텍스트 표현식으로 사용될 수 있도록 합니다.

관련 객체를 반환하는 컨텍스트 관리자의 예는 decimal.localcontext()에서 반환하는 것입니다. 이러한 관리자는 활성 십진 컨텍스트를 원래 십진 컨텍스트의 복사본으로 설정한 다음 복사본을 반환합니다. 이렇게 하면 with 문 외부의 코드에 영향을 주지 않고 with 문의 본문에서 현재 십진수 컨텍스트를 변경할 수 있습니다.

contextmanager.exit(exc_type, exc_val, exc_tb)

런타임 컨텍스트를 종료하고 발생한 예외를 억제해야 하는지 여부를 나타내는 부울 플래그를 반환합니다. with 문의 본문을 실행하는 동안 예외가 발생한 경우 인수에는 예외 유형, 값 및 역추적 정보가 포함됩니다. 그렇지 않으면 세 인수 모두 None입니다.

이 메서드에서 참 값을 반환하면 with 문이 예외를 억제하고 with 문 바로 다음에 오는 문으로 실행을 계속합니다. 그렇지 않으면 이 메서드가 실행을 마친 후에도 예외가 계속 전파됩니다. 이 메서드를 실행하는 동안 발생하는 예외는 with 문의 본문에서 발생한 모든 예외를 대체합니다.

전달된 예외는 명시적으로 다시 발생해서는 안 됩니다. 대신 이 메서드는 메서드가 성공적으로 완료되었고 발생한 예외를 억제하지 않으려는 것을 나타내기 위해 false 값을 반환해야 합니다. 이를 통해 컨텍스트 관리 코드는 __exit__() 메서드가 실제로 실패했는지 여부를 쉽게 감지할 수 있습니다.

Python은 손쉬운 스레드 동기화, 파일 또는 기타 개체의 즉각적인 종료, 활성 십진수 산술 컨텍스트의 간단한 조작을 지원하기 위해 여러 컨텍스트 관리자를 정의합니다. 특정 유형은 컨텍스트 관리 프로토콜 구현 이상으로 특별히 취급되지 않습니다. 몇 가지 예는 contextlib 모듈을 참조하십시오.

Python의 생성기와 contextlib.contextmanager 데코레이터는 이러한 프로토콜을 구현하는 편리한 방법을 제공합니다. 제너레이터 함수가 contextlib.contextmanager 데코레이터로 데코레이트된 경우, 데코레이트되지 않은 제너레이터 함수에 의해 생성된 반복자가 아니라 필요한 __enter__() 및 __exit__() 메서드를 구현하는 컨텍스트 관리자를 반환합니다.

Python/C API의 Python 개체에 대한 유형 구조에는 이러한 메서드에 대한 특정 슬롯이 없습니다. 이러한 메서드를 정의하려는 확장 유형은 이를 일반 Python 액세스 가능 메서드로 제공해야 합니다. 런타임 컨텍스트를 설정하는 오버헤드와 비교할 때 단일 클래스 사전 조회의 오버헤드는 무시할 수 있습니다.

Type Annotation Types — Generic Alias, Union

유형 주석의 핵심 기본 제공 유형은 Generic Alias 및 Union입니다.

Generic Alias Type

GenericAlias 개체는 일반적으로 클래스를 첨자로 만들어 만듭니다. 이들은 list 또는 dict와 같은 컨테이너 클래스와 함께 가장 자주 사용됩니다. 예를 들어 list[int]는 인수 int로 목록 클래스를 첨자로 만들어 만든 GenericAlias 객체입니다. GenericAlias 객체는 주로 유형 주석과 함께 사용하기 위한 것입니다.

참고 일반적으로 클래스가 특수 메서드 __class_getitem__()을 구현하는 경우에만 클래스를 첨자화할 수 있습니다.

GenericAlias 개체는 매개 변수가 있는 제네릭을 구현하는 제네릭 형식의 프록시 역할을 합니다.

컨테이너 클래스의 경우 클래스 구독에 제공된 인수는 객체가 포함하는 요소의 유형을 나타낼 수 있습니다. 예를 들어, set[bytes]는 모든 요소가 바이트 유형인 집합을 나타내기 위해 유형 주석에 사용할 수 있습니다.

__class_getitem__()을 정의하지만 컨테이너가 아닌 클래스의 경우, 클래스의 구독에 제공된 인수는 종종 객체에 정의된 하나 이상의 메서드의 반환 유형을 나타냅니다. 예를 들어 정규 표현식은 str 데이터 유형과 bytes 데이터 유형 모두에서 사용할 수 있습니다.

x = re.search(‘foo’, ‘foo’)인 경우 x는 x.group(0) 및 x[0]의 반환 값이 모두 str 유형인 re.Match 객체가 됩니다. GenericAlias re.Match[str]를 사용하여 유형 주석에서 이러한 종류의 객체를 나타낼 수 있습니다.
y = re.search(b’bar’, b’bar’)인 경우(바이트의 경우 b 참고) y도 re.Match의 인스턴스가 되지만 y.group(0) 및 y의 반환 값 [0]은 둘 다 바이트 유형입니다. 유형 주석에서 re.Match[bytes]를 사용하여 이러한 다양한 re.Match 객체를 나타냅니다.

GenericAlias 개체는 클래스 types.GenericAlias의 인스턴스이며 GenericAlias 개체를 직접 만드는 데 사용할 수도 있습니다.

T[X, Y, …]

사용된 T에 따라 유형 X, Y 등으로 매개변수화된 유형 T를 나타내는 GenericAlias를 작성합니다. 예를 들어 float 요소를 포함하는 목록을 기대하는 함수는 다음과 같습니다.

def average(values: list[float]) -> float:
    return sum(values) / len(values)

키 유형과 값 유형을 나타내는 두 가지 유형 매개변수를 예상하는 제네릭 유형인 dict를 사용하는 매핑 객체의 또 다른 예입니다. 이 예에서 함수는 str 유형의 키와 int 유형의 값이 있는 사전을 예상합니다.

def send_post_request(url: str, body: dict[str, int]) -> None:
    ...

내장 함수 isinstance() 및 issubclass()는 두 번째 인수로 GenericAlias 유형을 허용하지 않습니다.

>>> isinstance([1, 2], list[str])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: isinstance() argument 2 cannot be a parameterized generic

Python 런타임은 유형 주석을 적용하지 않습니다. 이는 제네릭 형식 및 해당 형식 매개 변수로 확장됩니다. GenericAlias에서 컨테이너 객체를 생성할 때 컨테이너의 요소는 해당 유형에 대해 확인되지 않습니다. 예를 들어 다음 코드는 권장되지 않지만 오류 없이 실행됩니다.

>>> t = list[str]
>>> t([1, 2, 3])
[1, 2, 3]

또한 매개변수화된 제네릭은 객체 생성 중에 유형 매개변수를 지웁니다.

>>> t = list[str]
>>> type(t)
<class 'types.GenericAlias'>

>>> l = t()
>>> type(l)
<class 'list'>

제네릭에서 repr() 또는 str()을 호출하면 매개변수화된 유형이 표시됩니다.

>>> repr(list[int])
'list[int]'

>>> str(list[int])
'list[int]'

일반 컨테이너의 __getitem__() 메서드는 dict[str][str]과 같은 실수를 허용하지 않는 예외를 발생시킵니다:

>>> dict[str][str]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: There are no type variables left in dict[str]

그러나 이러한 표현은 유형 변수를 사용할 때 유효합니다. 인덱스에는 GenericAlias 객체의 __args__에 있는 유형 변수 항목만큼 많은 요소가 있어야 합니다.

>>> from typing import TypeVar
>>> Y = TypeVar('Y')
>>> dict[str, Y][int]
dict[str, int]

Standard Generic Classes

다음 표준 라이브러리 클래스는 매개변수화된 제네릭을 지원합니다. 이 목록은 완전하지 않습니다.

Special Attributes of `GenericAlias` objects

모든 매개변수화된 제네릭은 특수한 읽기 전용 속성을 구현합니다.

genericalias.__origin__
이 특성은 매개 변수가 없는 일반 클래스를 가리킵니다.

>>> list[int].__origin__
<class 'list'>

genericalias.__args__
이 어트리뷰트는 제네릭 클래스의 원래 __class_getitem__() 에 전달된 제네릭 유형의 튜플(길이 1 가능)입니다:

>>> dict[str, list[int]].__args__
(<class 'str'>, list[int])

genericalias.__parameters__
이 속성은 __args__에 있는 고유한 유형 변수의 늦게 계산된 튜플(비어 있을 수 있음)입니다.

>>> from typing import TypeVar

>>> T = TypeVar('T')
>>> list[T].__parameters__
(~T,)

참고 typing.ParamSpec 매개변수가 있는 GenericAlias 객체는 주로 타이핑.ParamSpec이 정적 유형 검사를 위한 것이기 때문에 대체 후에 올바른 __parameters__를 가질 수 없습니다.

genericalias.__unpacked__

별칭이 * 연산자를 사용하여 압축 해제된 경우 true인 부울입니다(TypeVarTuple 참조).

버전 3.11의 새로운 기능.

또한보십시오
PEP 484 – 유형 힌트
유형 주석을 위한 Python의 프레임워크를 소개합니다.

PEP 585 – 표준 컬렉션의 유형 힌트 제네릭
특수 클래스 메서드 __class_getitem__()을 구현하는 경우 표준 라이브러리 클래스를 기본적으로 매개변수화하는 기능을 소개합니다.

Generics, user-defined generics 및 typing.Generic
런타임에 매개변수화할 수 있고 정적 유형 검사기가 이해할 수 있는 제네릭 클래스를 구현하는 방법에 대한 문서입니다.

버전 3.9의 새로운 기능.

Union Type

유니온 객체는 | (bitwise or) 여러 유형 객체에 대한 연산. 이러한 유형은 주로 유형 주석을 위한 것입니다. 공용체 유형 표현식은 typing.Union에 비해 더 깔끔한 유형 암시 구문을 사용합니다.

X | Y | …

X, Y 등의 유형을 보유하는 통합 개체를 정의합니다. 엑스 | Y는 X 또는 Y를 의미합니다. typing.Union[X, Y]와 동일합니다. 예를 들어, 다음 함수는 int 또는 float 유형의 인수를 예상합니다.

def square(number: int | float) -> int | float:
    return number ** 2

union_object == other

공용체 개체는 다른 공용체 개체와 같은지 테스트할 수 있습니다.

노동 조합은 평평합니다: (int | str) | float == int | str | float
중복 유형이 제거됩니다: int | str | int == int | str
공용체를 비교할 때 순서는 무시됩니다:int | str == str | int
typing.Union과 호환됩니다. 조합::int | str == typing.Union[int, str]
옵셔널 타입은 None과 합집합으로 쓸 수 있습니다:str | None == typing.Optional[str]

isinstance(obj, union_object)
issubclass(obj, union_object)

isinstance() 및 issubclass()에 대한 호출도 공용체 객체로 지원됩니다.

>>> isinstance("", int | str)
True

그러나 매개변수화된 제네릭을 포함하는 통합 개체는 사용할 수 없습니다.

>>> isinstance(1, int | list[int])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: isinstance() argument 2 cannot contain a parameterized generic

공용체 객체에 대한 사용자 노출 유형은 types.UnionType에서 액세스할 수 있으며 isinstance() 검사에 사용할 수 있습니다. 다음 유형에서 개체를 인스턴스화할 수 없습니다.

>>> import types
>>> isinstance(int | str, types.UnionType)
True
>>> types.UnionType()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot create 'types.UnionType' instances

참고 유형 객체에 대한 __or__() 메서드가 추가되어 구문 X | Y. 메타클래스가 __or__()를 구현하면 Union이 이를 재정의할 수 있습니다.

>>> class M(type):
...     def __or__(self, other):
...         return "Hello"
... 
>>> class C(metaclass=M):
...     pass
... 
>>> C | int
'Hello'
>>> int | C
int | __main__.C

PEP 604 – X를 제안하는 PEP | Y 구문 및 Union 유형.

버전 3.10의 새로운 기능.

Other Built-in Types

인터프리터는 다른 여러 종류의 개체를 지원합니다. 이들 중 대부분은 한두 가지 작업만 지원합니다.

Modules

모듈에 대한 유일한 특수 작업은 속성 액세스: m.name입니다. 여기서 m은 모듈이고 이름은 m의 기호 테이블에 정의된 이름에 액세스합니다. 모듈 속성을 할당할 수 있습니다. (import 문은 엄밀히 말하면 모듈 객체에 대한 작업이 아닙니다. import foo는 foo라는 모듈 객체가 있어야 하는 것이 아니라 어딘가에 foo라는 모듈에 대한 (외부) 정의가 필요합니다.)

모든 모듈의 특수 속성은 __dict__입니다. 이것은 모듈의 심볼 테이블을 포함하는 사전입니다. 이 사전을 수정하면 실제로 모듈의 기호 테이블이 변경되지만 __dict__ 속성에 대한 직접 할당은 불가능합니다(m.__dict__[‘a’] = 1로 작성할 수 있으며 m.a를 1로 정의하지만 m은 작성할 수 없습니다. .__dict__ = {}). __dict__를 직접 수정하는 것은 권장하지 않습니다.

인터프리터에 내장된 모듈은 다음과 같이 작성됩니다: <module 'sys' (built-in)>. 파일에서 로드되면<module 'os' from '/usr/local/lib/pythonX.Y/os.pyc'>로 작성됩니다.

Classes and Class Instances

See Objects, values and types and Class definitions for these.

Functions

함수 객체는 함수 정의에 의해 생성됩니다. 함수 개체에 대한 유일한 작업은 func(argument-list)를 호출하는 것입니다.

함수 개체에는 실제로 내장 함수와 사용자 정의 함수의 두 가지 종류가 있습니다. 둘 다 동일한 작업(함수 호출)을 지원하지만 구현이 다르기 때문에 개체 유형이 다릅니다.

자세한 내용은 함수 정의를 참조하십시오.

Methods

메소드는 속성 표기법을 사용하여 호출되는 함수입니다. 내장 메서드(예: 목록의 append())와 클래스 인스턴스 메서드의 두 가지 특징이 있습니다. 내장 메소드는 이를 지원하는 유형으로 설명됩니다.

인스턴스를 통해 메서드(클래스 네임스페이스에 정의된 함수)에 액세스하면 바인딩된 메서드(인스턴스 메서드라고도 함) 개체라는 특수 개체를 얻게 됩니다. 호출되면 자체 인수를 인수 목록에 추가합니다. 바인딩된 메서드에는 두 가지 특수한 읽기 전용 속성이 있습니다. m.__self__는 메서드가 작동하는 객체이고 m.__func__은 메서드를 구현하는 함수입니다. m(arg-1, arg-2, …, arg-n)을 호출하는 것은 m.__func__(m.__self__, arg-1, arg-2, …, arg-n)을 호출하는 것과 완전히 동일합니다.

함수 개체와 마찬가지로 바인딩된 메서드 개체는 임의 속성 가져오기를 지원합니다. 그러나 메소드 속성은 실제로 기본 함수 객체(meth.__func__)에 저장되므로 바인딩된 메소드에 메소드 속성을 설정하는 것은 허용되지 않습니다. 메소드에 속성을 설정하려고 하면 AttributeError가 발생합니다. 메서드 속성을 설정하려면 기본 함수 개체에 명시적으로 설정해야 합니다.

>>> class C:
...     def method(self):
...         pass
... 
>>> c = C()
>>> c.method.whoami = 'my name is method'  # can't set on the method
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'method' object has no attribute 'whoami'
>>> c.method.__func__.whoami = 'my name is method'
>>> c.method.whoami
'my name is method'

자세한 내용은 표준 유형 계층 구조를 참조하십시오.

Code Objects

코드 개체는 함수 본문과 같은 “의사 컴파일된” 실행 가능 Python 코드를 나타내기 위해 구현에서 사용됩니다. 전역 실행 환경에 대한 참조를 포함하지 않기 때문에 함수 개체와 다릅니다. 코드 객체는 내장된 compile() 함수에 의해 반환되며 __code__ 속성을 통해 함수 객체에서 추출할 수 있습니다. 코드 모듈도 참조하십시오.

__code__에 액세스하면 인수 obj 및 “__code__”를 사용하여 감사 이벤트 object.__getattr__이 발생합니다.

코드 객체는 (소스 문자열 대신) exec() 또는 eval() 내장 함수에 전달하여 실행하거나 평가할 수 있습니다.

자세한 내용은 표준 유형 계층 구조를 참조하십시오.

Type Objects

유형 객체는 다양한 객체 유형을 나타냅니다. 객체의 유형은 내장 함수 type()에 의해 액세스됩니다. 유형에 대한 특수 연산은 없습니다. 표준 모듈 유형은 모든 표준 내장 유형의 이름을 정의합니다.

유형은 다음과 같이 작성됩니다: .

The Null Object

이 객체는 명시적으로 값을 반환하지 않는 함수에 의해 반환됩니다. 특별한 작업을 지원하지 않습니다. None(내장 이름)이라는 이름의 null 개체가 정확히 하나 있습니다. type(None)()은 동일한 싱글톤을 생성합니다.

None이라고 씁니다.

The Ellipsis Object

이 개체는 일반적으로 슬라이싱에 사용됩니다(슬라이싱 참조). 특별한 작업을 지원하지 않습니다. Ellipsis(내장 이름)라는 이름의 줄임표 개체가 정확히 하나 있습니다. type(Ellipsis)()는 Ellipsis 싱글톤을 생성합니다.

줄임표 또는 …로 작성됩니다.

The NotImplemented Object

이 개체는 지원하지 않는 유형에 대한 작업을 요청하면 비교 및 이항 작업에서 반환됩니다. 자세한 내용은 비교를 참조하십시오. NotImplemented 개체는 정확히 하나입니다. type(NotImplemented)()는 싱글톤 인스턴스를 생성합니다.

NotImplemented로 작성됩니다.

Boolean Values

부울 값은 두 개의 상수 개체 False 및 True입니다. 그것들은 진리 값을 나타내는 데 사용됩니다(다른 값도 거짓 또는 참으로 간주될 수 있음). 숫자 컨텍스트(예: 산술 연산자의 인수로 사용되는 경우)에서는 각각 정수 0과 1처럼 동작합니다. 내장 함수 bool()은 값이 진리 값으로 해석될 수 있는 경우 모든 값을 부울로 변환하는 데 사용할 수 있습니다(위의 진리 값 테스트 섹션 참조).

그것들은 각각 False와 True로 쓰여집니다.

Internal Objects

이 정보는 표준 유형 계층 구조를 참조하십시오. 스택 프레임 객체, 트레이스백 객체 및 슬라이스 객체를 설명합니다.

Special Attributes

이 구현은 몇 가지 특수한 읽기 전용 속성을 관련이 있는 여러 개체 유형에 추가합니다. 이들 중 일부는 dir() 내장 함수에 의해 보고되지 않습니다.

object.__dict__
객체의 (쓰기 가능한) 속성을 저장하는 데 사용되는 사전 또는 기타 매핑 객체입니다.

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

class.__bases__
클래스 개체의 기본 클래스 튜플입니다.

definition.__name__
클래스, 함수, 메서드, 설명자 또는 생성기 인스턴스의 이름입니다.

definition.__qualname__
클래스, 함수, 메서드, 설명자 또는 생성기 인스턴스의 정규화된 이름입니다.

버전 3.3의 새로운 기능.

class.__mro__
이 특성은 메서드 확인 중에 기본 클래스를 찾을 때 고려되는 클래스의 튜플입니다.

class.mro()
이 메서드는 인스턴스에 대한 메서드 해결 순서를 사용자 지정하기 위해 메타클래스에서 재정의할 수 있습니다. 클래스 인스턴스화 시 호출되며 그 결과는 __mro__에 저장됩니다.

class.__subclasses__()
각 클래스는 직계 하위 클래스에 대한 약한 참조 목록을 유지합니다. 이 메서드는 아직 살아있는 모든 참조 목록을 반환합니다. 목록은 정의 순서입니다. 예:

>>> int.__subclasses__()
[<class 'bool'>]

Integer string conversion length limitation

CPython에는 서비스 거부 공격을 완화하기 위해 int와 str 간 변환에 대한 전역 제한이 있습니다. 이 제한은 10진수 또는 기타 2의 거듭제곱이 아닌 숫자 밑수에만 적용됩니다. 16진수, 8진수 및 2진수 변환은 무제한입니다. 제한을 구성할 수 있습니다.

CPython의 int 유형은 이진 형식으로 저장된 임의의 길이 숫자입니다(일반적으로 “bignum”이라고 함). 밑이 2의 거듭제곱이 아닌 한 선형 시간에서 문자열을 이진 정수로 또는 이진 정수를 문자열로 변환할 수 있는 알고리즘은 존재하지 않습니다. 밑이 10인 가장 잘 알려진 알고리즘도 준이차 복잡성을 가집니다. int(‘1’ * 500_000)과 같은 큰 값을 변환하면 빠른 CPU에서 1초 이상 걸릴 수 있습니다.

변환 크기를 제한하면 CVE-2020-10735를 방지할 수 있는 실용적인 방법이 제공됩니다.

비선형 변환 알고리즘이 관련된 경우 입력 또는 출력 문자열의 숫자 문자 수에 제한이 적용됩니다. 밑줄과 기호는 제한에 포함되지 않습니다.

작업이 제한을 초과하면 ValueError가 발생합니다.

>>> import sys
>>> sys.set_int_max_str_digits(4300)  # Illustrative, this is the default.
>>> _ = int('2' * 5432)
Traceback (most recent call last):
...
ValueError: Exceeds the limit (4300 digits) for integer string conversion: value has 5432 digits; use sys.set_int_max_str_digits() to increase the limit.
>>> i = int('2' * 4300)
>>> len(str(i))
4300
>>> i_squared = i*i
>>> len(str(i_squared))
Traceback (most recent call last):
...
ValueError: Exceeds the limit (4300 digits) for integer string conversion: value has 8599 digits; use sys.set_int_max_str_digits() to increase the limit.
>>> len(hex(i_squared))
7144
>>> assert int(hex(i_squared), base=16) == i*i  # Hexadecimal is unlimited.

기본 제한은 sys.int_info.default_max_str_digits에 제공된 대로 4300자리입니다. 구성할 수 있는 최저 제한은 sys.int_info.str_digits_check_threshold에 제공된 대로 640자리입니다.

확인:

>>> import sys
>>> assert sys.int_info.default_max_str_digits == 4300, sys.int_info
>>> assert sys.int_info.str_digits_check_threshold == 640, sys.int_info
>>> msg = int('578966293710682886880994035146873798396722250538762761564'
          '9252925514383915483333812743580549779436104706260696366600'
          '571186405732').to_bytes(53, 'big')

버전 3.11의 새로운 기능.

Affected APIs

이 제한은 int와 str 또는 바이트 간의 잠재적으로 느린 변환에만 적용됩니다.

기본 10을 사용하는 int(string).
2의 거듭제곱이 아닌 모든 염기에 대한 int(string, base).
str(integer).
repr(integer).
10진수로의 기타 문자열 변환(예: f”{integer}”, “{}”.format(integer) 또는 b”%d” % integer)

제한 사항은 선형 알고리즘이 있는 함수에는 적용되지 않습니다.

int(string, base) with base 2, 4, 8, 16, or 32.
int.from_bytes() and int.to_bytes().
hex(), oct(), bin().
Format Specification Mini-Language for hex, octal, and binary numbers.
str to float.
str to decimal.Decimal

Configuring the limit

Python이 시작되기 전에 환경 변수 또는 인터프리터 명령줄 플래그를 사용하여 제한을 구성할 수 있습니다.

PYTHONINTMAXSTRDIGITS, 예. PYTHONINTMAXSTRDIGITS=640 python3 제한을 640으로 설정하거나 PYTHONINTMAXSTRDIGITS=0 python3 제한을 비활성화합니다.
-X int_max_str_digits, 예: python3 -X int_max_str_digits=640
sys.flags.int_max_str_digits는 PYTHONINTMAXSTRDIGITS 또는 -X int_max_str_digits 값을 포함합니다. env var와 -X 옵션이 모두 설정된 경우 -X 옵션이 우선합니다. -1 값은 둘 다 설정되지 않았음을 나타내므로 초기화 중에 sys.int_info.default_max_str_digits 값이 사용되었습니다.

코드에서 다음 sys API를 사용하여 현재 제한을 검사하고 새 제한을 설정할 수 있습니다.

sys.get_int_max_str_digits() 및 sys.set_int_max_str_digits()는 인터프리터 전체 제한에 대한 getter 및 setter입니다. 부 통역사는 자체 제한이 있습니다.

기본값 및 최소값에 대한 정보는 sys.int_info에서 찾을 수 있습니다.

sys.int_info.default_max_str_digits는 컴파일된 기본 제한입니다.
sys.int_info.str_digits_check_threshold는 제한에 허용되는 가장 낮은 값입니다(비활성화하는 0 제외).

버전 3.11의 새로운 기능.

경고: 주의 하한을 설정하면 문제가 발생할 수 있습니다. 드물기는 하지만 소스에 최소 임계값을 초과하는 십진수 정수 상수가 포함된 코드가 존재합니다. 제한을 설정하면 제한보다 긴 10진수 리터럴을 포함하는 Python 소스 코드는 구문 분석 중에, 일반적으로 시작 시 또는 가져오기 시 또는 설치 시에도 오류가 발생합니다. 최신 .pyc가 아직 존재하지 않는 경우 언제든지 발생합니다. 코드를 위해. 이러한 큰 상수를 포함하는 소스에 대한 해결 방법은 제한이 없으므로 0x 16진수 형식으로 변환하는 것입니다.

하한을 사용하는 경우 응용 프로그램을 철저하게 테스트하십시오. .py 소스를 .pyc 파일로 미리 컴파일하기 위해 Python을 호출할 수 있는 모든 설치 단계와 시작 중에 적용되도록 환경 또는 플래그를 통해 초기에 설정된 제한으로 테스트를 실행해야 합니다.

Recommended configuration

기본 sys.int_info.default_max_str_digits는 대부분의 응용 프로그램에 적합할 것으로 예상됩니다. 애플리케이션에 다른 제한이 필요한 경우 이러한 API가 3.11 이전 버전의 보안 패치 릴리스에 추가되었으므로 Python 버전에 구애받지 않는 코드를 사용하여 기본 진입점에서 설정합니다.

예:

>>> import sys
>>> if hasattr(sys, "set_int_max_str_digits"):
...     upper_bound = 68000
...     lower_bound = 4004
...     current_limit = sys.get_int_max_str_digits()
...     if current_limit == 0 or current_limit > upper_bound:
...         sys.set_int_max_str_digits(upper_bound)
...     elif current_limit < lower_bound:
...         sys.set_int_max_str_digits(lower_bound)

완전히 비활성화해야 하는 경우 0으로 설정합니다.

Source: https://docs.python.org/3/library/stdtypes.html

Binary Sequence Types — bytes, bytearray, memoryview

Bytes Objects

class bytes([source[, encoding[, errors]]])

Bytearray Objects

class bytearray([source[, encoding[, errors]]])

Bytes and Bytearray Operations

bytes.count(sub[, start[, end]])bytearray.count(sub[, start[, end]])

bytes.removeprefix(prefix, /)bytearray.removeprefix(prefix, /)

bytes.removesuffix(suffix, /)bytearray.removesuffix(suffix, /)

bytes.decode(encoding=’utf-8′, errors=’strict’)bytearray.decode(encoding=’utf-8′, errors=’strict’)

bytes.endswith(suffix[, start[, end]])bytearray.endswith(suffix[, start[, end]])

bytes.find(sub[, start[, end]])bytearray.find(sub[, start[, end]])

bytes.index(sub[, start[, end]])bytearray.index(sub[, start[, end]])

bytes.join(iterable)bytearray.join(iterable)

static bytes.maketrans(from, to)static bytearray.maketrans(from, to)

bytes.partition(sep)bytearray.partition(sep)

bytes.replace(old, new[, count])bytearray.replace(old, new[, count])

bytes.rfind(sub[, start[, end]])bytearray.rfind(sub[, start[, end]]

bytes.rindex(sub[, start[, end]])bytearray.rindex(sub[, start[, end]])

bytes.rpartition(sep)bytearray.rpartition(sep)

bytes.startswith(prefix[, start[, end]])bytearray.startswith(prefix[, start[, end]])

bytes.translate(table, /, delete=b”)bytearray.translate(table, /, delete=b”)

bytes.center(width[, fillbyte])bytearray.center(width[, fillbyte])

bytes.ljust(width[, fillbyte])bytearray.ljust(width[, fillbyte])

bytes.lstrip([chars])bytearray.lstrip([chars])

bytes.rjust(width[, fillbyte])bytearray.rjust(width[, fillbyte])

bytes.rsplit(sep=None, maxsplit=- 1)bytearray.rsplit(sep=None, maxsplit=- 1)

bytes.rstrip([chars])bytearray.rstrip([chars])

bytes.split(sep=None, maxsplit=- 1)bytearray.split(sep=None, maxsplit=- 1)

bytes.strip([chars])bytearray.strip([chars])

bytes.capitalize()bytearray.capitalize()

bytes.expandtabs(tabsize=8)bytearray.expandtabs(tabsize=8)

bytes.isalnum()bytearray.isalnum()

bytes.isalpha()bytearray.isalpha()

bytes.isascii()bytearray.isascii()

bytes.isdigit()bytearray.isdigit()

bytes.islower()bytearray.islower()

bytes.isspace()bytearray.isspace()

bytes.istitle()bytearray.istitle()

bytes.isupper()bytearray.isupper()

bytes.lower()bytearray.lower()

bytes.splitlines(keepends=False)bytearray.splitlines(keepends=False)

bytes.swapcase()bytearray.swapcase()

bytes.title()bytearray.title()

bytes.upper()bytearray.upper()

bytes.zfill(width)bytearray.zfill(width)

printf-style Bytes Formatting

Memory Views

class memoryview(object)

Set Types — set, frozenset

class set([iterable])class frozenset([iterable])

Mapping Types — dict

class dict(**kwargs)class dict(mapping, **kwargs)class dict(iterable, **kwargs)

classmethod fromkeys(iterable[, value])

Dictionary view objects

Context Manager Types

contextmanager.__enter__()

contextmanager.__exit__(exc_type, exc_val, exc_tb)

Type Annotation Types — Generic Alias, Union

Generic Alias Type

Standard Generic Classes

Special Attributes of GenericAlias objects

Union Type

Other Built-in Types

Modules

Classes and Class Instances

Functions

Methods

Code Objects

Type Objects

The Null Object

The Ellipsis Object

The NotImplemented Object

Boolean Values

Internal Objects

Special Attributes

Integer string conversion length limitation

Affected APIs

Configuring the limit

Recommended configuration

Binary Sequence Types — `bytes`, `bytearray`, `memoryview`

bytes.count(sub[, start[, end]])
bytearray.count(sub[, start[, end]])

bytes.removeprefix(prefix, /)
bytearray.removeprefix(prefix, /)

bytes.removesuffix(suffix, /)
bytearray.removesuffix(suffix, /)

bytes.decode(encoding=’utf-8′, errors=’strict’)
bytearray.decode(encoding=’utf-8′, errors=’strict’)

bytes.endswith(suffix[, start[, end]])
bytearray.endswith(suffix[, start[, end]])

bytes.find(sub[, start[, end]])
bytearray.find(sub[, start[, end]])

bytes.index(sub[, start[, end]])
bytearray.index(sub[, start[, end]])

bytes.join(iterable)
bytearray.join(iterable)

static bytes.maketrans(from, to)
static bytearray.maketrans(from, to)

bytes.partition(sep)
bytearray.partition(sep)

bytes.replace(old, new[, count])
bytearray.replace(old, new[, count])

bytes.rfind(sub[, start[, end]])
bytearray.rfind(sub[, start[, end]]

bytes.rindex(sub[, start[, end]])
bytearray.rindex(sub[, start[, end]])

bytes.rpartition(sep)
bytearray.rpartition(sep)

bytes.startswith(prefix[, start[, end]])
bytearray.startswith(prefix[, start[, end]])

bytes.translate(table, /, delete=b”)
bytearray.translate(table, /, delete=b”)

bytes.center(width[, fillbyte])
bytearray.center(width[, fillbyte])

bytes.ljust(width[, fillbyte])
bytearray.ljust(width[, fillbyte])

bytes.lstrip([chars])
bytearray.lstrip([chars])

bytes.rjust(width[, fillbyte])
bytearray.rjust(width[, fillbyte])

bytes.rsplit(sep=None, maxsplit=- 1)
bytearray.rsplit(sep=None, maxsplit=- 1)

bytes.rstrip([chars])
bytearray.rstrip([chars])

bytes.split(sep=None, maxsplit=- 1)
bytearray.split(sep=None, maxsplit=- 1)

bytes.strip([chars])
bytearray.strip([chars])

bytes.capitalize()
bytearray.capitalize()

bytes.expandtabs(tabsize=8)
bytearray.expandtabs(tabsize=8)

bytes.isalnum()
bytearray.isalnum()

bytes.isalpha()
bytearray.isalpha()

bytes.isascii()
bytearray.isascii()

bytes.isdigit()
bytearray.isdigit()

bytes.islower()
bytearray.islower()

bytes.isspace()
bytearray.isspace()

bytes.istitle()
bytearray.istitle()

bytes.isupper()
bytearray.isupper()

bytes.lower()
bytearray.lower()

bytes.splitlines(keepends=False)
bytearray.splitlines(keepends=False)

bytes.swapcase()
bytearray.swapcase()

bytes.title()
bytearray.title()

bytes.upper()
bytearray.upper()

bytes.zfill(width)
bytearray.zfill(width)

`printf`-style Bytes Formatting

Set Types — `set`, `frozenset`

class set([iterable])
class frozenset([iterable])

Mapping Types — `dict`

class dict(kwargs)
class dict(mapping, kwargs)
class dict(iterable, **kwargs)

contextmanager.enter()

contextmanager.exit(exc_type, exc_val, exc_tb)

Special Attributes of `GenericAlias` objects