Built-in Types¶

다음 섹션에서는 인터프리터에 내장된 표준 타입을 설명합니다.

주요 내장 타입은 숫자, 시퀀스, 매핑, 클래스, 인스턴스 및 예외입니다.

일부 컬렉션 클래스는 가변(mutable)입니다. 멤버를 제자리에서 추가, 제거 또는 재배치하며 특정 항목을 반환하지 않는 메서드는 컬렉션 인스턴스 자체가 아니라 None 을 반환합니다.

일부 연산은 여러 객체 유형에서 지원됩니다. 특히, 거의 모든 객체는 동일성 비교가 가능하고, 참 값(truth value)을 확인할 수 있으며, 문자열로 변환될 수 있습니다(이때 repr() 함수 또는 약간 다른 str() 함수가 사용됩니다). 후자는 print() 함수에 의해 객체가 출력될 때 암시적으로 사용됩니다.

Truth Value Testing¶

모든 객체는 if 또는 while 조건에서 사용하거나 아래의 Boolean 연산의 피연산자로 사용하기 위해 참 값(truth value)을 테스트할 수 있습니다.

By default, an object is considered true unless its class defines either a __bool__() method that returns False or a __len__() method that returns zero, when called with the object. [1] If one of the methods raises an exception when called, the exception is propagated and the object does not have a truth value (for example, NotImplemented). Here are most of the built-in objects considered false:

거짓으로 정의된 상수: None 및 False
모든 숫자 유형의 0: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
빈 시퀀스 및 컬렉션: '', (), [], {}, set(), range(0)

Boolean 결과를 갖는 연산 및 내장 함수는 별도의 언급이 없는 한 거짓일 때 0 또는 False 를, 참일 때 1 또는 True 를 항상 반환합니다. (중요한 예외: Boolean 연산인 or 와 and 는 항상 두 피연산자 중 하나를 반환합니다.)

Boolean Operations — `and`, `or`, `not`¶

이것은 오름차순 우선순위에 따른 Boolean 연산입니다:

Operation	Result	Notes
`x or y`	만약 x가 참이면 x, 아니면 y	(1)
`x and y`	만약 x가 거짓이면 x, 아니면 y	(2)
`not x`	만약 x 가 거짓이면 `True`, 아니면 `False`	(3)

Notes:

이것은 단락 회로(short-circuit) 연산자이므로 첫 번째 인자가 거짓인 경우에만 두 번째 인자를 평가합니다.
이것은 단락 회로(short-circuit) 연산자이므로 첫 번째 인자가 참인 경우에만 두 번째 인자를 평가합니다.
not 은 비-Boolean(non-Boolean) 연산자보다 우선순위가 낮으므로, not a == b 는 not (a == b) 로 해석되며, a == not b 는 구문 오류(syntax error)가 발생합니다.

Comparisons¶

Python에는 여덟 개의 비교 연산이 있습니다. 이들은 모두 동일한 우선순위를 가지며, 이는 Boolean 연산보다 높습니다. 비교는 임의로 체이닝될 수 있습니다. 예를 들어, x < y <= z 는 x < y and y <= z 와 동일하게 해석되지만, 이때 y 는 한 번만 평가됩니다. (두 경우 모두 x < y 가 거짓으로 판명되면 z 는 전혀 평가되지 않습니다.)

이 표는 비교 연산의 요약을 보여줍니다:

Operation	Meaning
`<`	strictly less than
`<=`	작거나 같은
`>`	엄격히 큰
`>=`	크거나 같은
`==`	같은
`!=`	다르거나
`is`	객체 아이덴티티
`is not`	부정된 객체 아이덴티티

별도의 설명이 없는 한, 서로 다른 형의 객체는 결코 같다고 비교되지 않습니다. == 연산자는 항상 정의되지만, 일부 객체 형(예를 들어, 클래스 객체)의 경우 is`와 동등합니다. ``<`, <=, > 및 >= 연산자는 의미가 있는 경우에만 정의됩니다. 예를 들어, 인자 중 하나가 복소수이면 TypeError 예외가 발생합니다.

클래스의 서로 다른 인스턴스는 해당 클래스가 __eq__() 메서드를 정의하지 않는 한 일반적으로 다르다고 비교됩니다.

클래스의 인스턴스는 해당 클래스가 __lt__(), __le__(), __gt__(), 그리고 __ge__() 메서드 중 충분한 수를 정의하지 않는 한, 동일한 클래스의 다른 인스턴스나 다른 형의 객체와 비교할 수 없습니다(일반적으로 비교 연산자의 통상적인 의미를 원한다면 __lt__() 와 __eq__() 만으로도 충분합니다).

is 및 is not 연산자의 동작은 커스터마이징할 수 없으며, 어떤 두 객체에 대해서도 적용 가능하며 결코 예외를 발생시키지 않습니다.

동일한 구문 우선순위를 갖는 두 연산인 in 과 not in 은 iterable 인 형이나 __contains__() 메서드를 구현하는 형에서 지원됩니다.

숫자 형 — `int`, `float`, `complex`¶

세 가지 뚜렷한 숫자 형이 있습니다: 정수, 부동 소수점 수, 그리고 복소수 입니다. 또한, Boolean은 정수의 하위 형입니다. 정수는 제한 없는 정밀도를 가집니다. 부동 소수점 수는 일반적으로 C 언어에서 double 을 사용하여 구현됩니다. 프로그램이 실행되는 머신에서 부동 소수점 수의 정밀도 및 내부 표현에 대한 정보는 sys.float_info 에서 확인할 수 있습니다. 복소수는 실수부와 허수부로 구성되며, 각각은 부동 소수점 수입니다. 복소수 z 에서 이 부분들을 추출하려면 z.real 과 z.imag 을 사용하십시오. (표준 라이브러리에는 유리수를 위한 fractions.Fraction 과 사용자가 정의할 수 있는 정밀도의 부동 소수점을 위한 decimal.Decimal 과 같은 추가적인 숫자 형이 포함되어 있습니다.)

Numbers are created by numeric literals or as the result of built-in functions and operators. Unadorned integer literals (including hex, octal and binary numbers) yield integers. Numeric literals containing a decimal point or an exponent sign yield floating-point numbers. Appending 'j' or 'J' to a numeric literal yields an imaginary number (a complex number with a zero real part) which you can add to an integer or float to get a complex number with real and imaginary parts.

특정 형의 숫자를 생성하려면 int(), float(), complex() 생성자를 사용할 수 있습니다.

Python은 혼합 연산을 완전히 지원합니다. 이항 산술 연산자의 피연산자가 서로 다른 내장 숫자 형일 때, 더 ‘좁은’ 형의 피연산자가 다른 쪽의 형으로 확장됩니다.

두 인자가 모두 복소수이면 변환이 수행되지 않으며;
인자 중 하나가 복소수 또는 부동 소수점 수인 경우, 다른 하나가 부동 소수점 수로 변환되며;
그렇지 않으면 두 인자 모두 정수여야 하며 변환이 필요하지 않습니다.

복소수와 실수 피연산자를 사용하는 산술 연산은 일반적인 수학 공식에 따라 정의됩니다. 예를 들면:

x + complex(u, v) = complex(x + u, v)
x * complex(u, v) = complex(x * u, x * v)

서로 다른 형의 숫자 간 비교는 해당 숫자들의 정확한 값이 비교되는 것처럼 동작합니다. [2]

모든 숫자 형(복소수 제외)은 다음 연산들을 지원합니다(연산의 우선순위는 연산자 우선순위 를 참조하십시오):

Operation	Result	Notes	전체 문서
`x + y`	x 와 y 의 합
`x - y`	x 와 y 의 차
`x * y`	x 와 y 의 곱
`x / y`	x 와 y 의 몫
`x // y`	x 와 y 의 내림한 몫	(1)(2)
`x % y`	`x / y` 의 나머지	(2)
`-x`	부호가 반전된 x
`+x`	변하지 않은 x
`abs(x)`	x 의 절댓값 또는 크기		`abs()`
`int(x)`	정수로 변환된 x	(3)(6)	`int()`
`float(x)`	부동 소수점으로 변환된 x	(4)(6)	`float()`
`complex(re, im)`	실수부 re, 허수부 im 을 가진 복소수입니다. im 의 기본값은 0입니다.	(6)	`complex()`
`c.conjugate()`	복소수 c 의 켤레 복소수
`divmod(x, y)`	쌍 `(x // y, x % y)`	(2)	`divmod()`
`pow(x, y)`	x의 y 거듭제곱	(5)	`pow()`
`x ** y`	x의 y 거듭제곱	(5)

Notes:

정수 나눗셈이라고도 불립니다. int 형 피연산자의 경우 결과값은 int 형이며, float 형 피연산자의 경우 결과값은 float 형입니다. 일반적으로 결과는 정수이지만, 결과의 형이 반드시 int 인 것은 아닙니다. 결과는 항상 음의 무한대 방향으로 반올림됩니다. 예를 들어, 1//2 는 0, (-1)//2 는 -1, 1//(-2) 는 -1, (-1)//(-2) 는 0 입니다.
복소수에는 적용되지 않습니다. 필요한 경우 abs() 를 사용하여 부동 소수점으로 변환하십시오.
float 에서 int 로 변환할 때는 소수 부분을 버리고 절사합니다. 다른 방식의 변환을 원하시면 math.floor() 와 math.ceil() 함수를 참조하십시오.
float은 또한
Python은 프로그래밍 언어에서 일반적인 방식과 마찬가지로 pow(0, 0) 과 0 ** 0 을 1 로 정의합니다.
허용되는 숫자 리터럴은 0``부터 ``9``까지의 숫자 또는 그에 해당하는 유니코드(``Nd 속성을 가진 코드 포인트)를 포함합니다.

Nd 속성을 가진 코드 포인트의 전체 목록은 the Unicode Standard 를 참조하십시오.

모든 numbers.Real 유형(int 및 float)은 다음과 같은 연산도 포함합니다:

Operation	Result
`math.trunc(x)`	`Integral` 로 절사된 x
`round(x[, n])`	x 를 n 자리까지 반올림하며, 5를 짝수로 반올림합니다. n 이 생략되면 기본값은 0입니다.
`math.floor(x)`	x 보다 작거나 같은 가장 큰 `Integral`
`math.ceil(x)`	x 보다 크거나 같은 가장 작은 `Integral`

추가적인 수치 연산은 math 및 cmath 모듈을 참조하십시오.

정수형에 대한 비트 연산¶

비트 연산은 정수형에서만 의미가 있습니다. 비트 연산의 결과는 무한한 수의 부호 비트를 가진 2의 보수 방식에서 수행된 것처럼 계산됩니다.

이항 비트 연산의 우선순위는 모두 수치 연산보다 낮고 비교 연산보다 높습니다. 단항 연산 ~``은 다른 단항 수치 연산(``+ 및 -)과 동일한 우선순위를 가집니다.

이 표는 비트 연산을 우선순위 오름차순으로 나열한 것입니다:

Operation	Result	Notes
`x \| y`	x 와 y 의 비트별 or	(4)
`x ^ y`	x 와 y 의 비트별 exclusive or	(4)
`x & y`	x 와 y 의 비트별 and	(4)
`x << n`	x를 n 비트만큼 왼쪽으로 시프트	(1)(2)
`x >> n`	x를 n 비트만큼 오른쪽으로 시프트	(1)(3)
`~x`	x 의 비트 반전

Notes:

음수의 시프트 횟수는 허용되지 않으며 ValueError 를 발생시킵니다.
n 비트만큼의 왼쪽 시프트는 pow(2, n) 을 곱하는 것과 동일합니다.
n 비트만큼의 오른쪽 시프트는 pow(2, n) 으로 나눈 몫(floor division)을 구하는 것과 동일합니다.
유한한 2의 보수 표현(작동 비트 너비가 1 + max(x.bit_length(), y.bit_length()) 이상)에서 최소 하나 이상의 추가 부호 확장 비트를 사용하여 계산하면 무한한 수의 부호 비트가 있는 경우와 동일한 결과를 얻을 수 있습니다.

정수형에 대한 추가 메서드¶

The int type implements the numbers.Integral abstract base class. In addition, it provides a few more methods:

int.bit_length()¶

부호와 선행 0을 제외하고 정수를 이진수로 표현하는 데 필요한 비트 수를 반환합니다:

>>> n = -37
>>> bin(n)
'-0b100101'
>>> n.bit_length()
6

더 정확하게는, x 가 0이 아니면 x.bit_length() 는 2**(k-1) <= abs(x) < 2**k 를 만족하는 유일한 양의 정수 k 입니다. 마찬가지로, abs(x) 가 정확하게 반올림된 로그를 가질 만큼 충분히 작을 때 k = 1 + int(log(abs(x), 2)) 입니다. x 가 0이면 x.bit_length() 는 0 을 반환합니다.

다음과 동일합니다:

def bit_length(self):
    s = bin(self)       # 이진 표현:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # 선행 0과 마이너스 기호 제거
    return len(s)       # len('100101') --> 6

Added in version 3.1.

int.bit_count()¶

정수의 절대값을 이진수로 표현했을 때 포함된 1의 개수를 반환합니다. 이는 팝업 카운트(population count)라고도 알려져 있습니다. 예제:

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3

다음과 동일합니다:

def bit_count(self):
    return bin(self).count("1")

Added in version 3.10.

int.to_bytes(length=1, byteorder='big', *, signed=False)¶

정수를 나타내는 바이트 배열을 반환합니다.

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'

정수는 length 바이트를 사용하여 표현되며, 기본값은 1입니다. 정수를 주어진 바이트 수로 표현할 수 없는 경우 OverflowError 가 발생합니다.

byteorder 인자는 정수를 표현하는 데 사용되는 바이트 순서를 결정하며, 기본값은 "big" 입니다. byteorder 가 "big" 이면 가장 중요한 바이트가 바이트 배열의 시작 부분에 위치합니다. byteorder 가 "little" 이면 가장 중요한 바이트가 바이트 배열의 끝에 위치합니다.

signed 인자는 정수를 표현할 때 2의 보수를 사용하는지 여부를 결정합니다. signed 가 False 이고 음의 정수가 주어지면 OverflowError 가 발생합니다. signed 의 기본값은 False 입니다.

기본값들을 사용하여 정수를 단일 바이트 객체로 간편하게 변환할 수 있습니다:

>>> (65).to_bytes()
b'A'

그러나, 기본 인수를 사용할 때 255보다 큰 값을 변환하려고 하면 OverflowError 가 발생하므로 주의하십시오.

다음과 동일합니다:

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)

Added in version 3.2.

버전 3.11에서 변경: length 와 byteorder 에 대한 기본 인자 값을 추가했습니다.

classmethod int.from_bytes(bytes, byteorder='big', *, signed=False)¶

주어진 바이트 배열로 표현되는 정수를 반환합니다.

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680

The argument bytes must either be a bytes-like object or an iterable producing bytes.

byteorder 인자는 정수를 표현하는 데 사용되는 바이트 순서를 결정하며, 기본값은 "big" 입니다. byteorder 가 "big" 이면 가장 중요한 바이트가 바이트 배열의 시작 부분에 위치합니다. byteorder 가 "little" 이면 가장 중요한 바이트가 바이트 배열의 끝에 위치합니다. 호스트 시스템의 네이티브 바이트 순서를 요청하려면 바이트 순서 값으로 sys.byteorder 를 사용하십시오.

signed 인자는 정수를 표현할 때 2의 보수를 사용하는지 여부를 나타냅니다.

다음과 동일합니다:

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n

Added in version 3.2.

버전 3.11에서 변경: byteorder 에 대한 기본 인자 값을 추가했습니다.

int.as_integer_ratio()¶: 원본 정수와 비율이 같고 분모가 양수인 두 정수의 쌍을 반환합니다. 정수들(정수 값)의 정수 비율은 항상 분자가 해당 정수이고 분모가 1 인 상태입니다.

Added in version 3.8.

int.is_integer()¶: True 를 반환합니다. float.is_integer() 와의 덕 타입 호환성을 위해 존재합니다.

Added in version 3.12.

부동소수점(Float)에 대한 추가 메서드¶

The float type implements the numbers.Real abstract base class. float also has the following additional methods.

classmethod float.from_number(x)¶

수치 x 로부터 생성된 부동소수점 수를 반환하는 클래스 메서드입니다.

인자가 정수 또는 부동소수점 수인 경우, 동일한 값을 가진 부동소수점 수(Python의 부동소수점 정밀도 범위 내)를 반환합니다. 인자가 Python float의 범위를 벗어나는 경우 OverflowError 가 발생합니다.

일반적인 Python 객체 x 에 대해, float.from_number(x) 는 x.__float__() 를 호출합니다. 만약 __float__() 이 정의되어 있지 않으면 __index__() 로 대체합니다.

Added in version 3.14.

float.as_integer_ratio()¶: 원본 부동소수점과 정확히 일치하는 비율을 가진 두 정수의 쌍을 반환합니다. 비율은 기약 분수로 표현되며 분모는 양수입니다. 무한대인 경우 OverflowError 를, NaN인 경우 ValueError 를 발생시킵니다.

float.is_integer()¶

부동소수점 인스턴스가 정수 값을 가진 유한한 수이면 True 를, 그렇지 않으면 False 를 반환합니다:

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False

두 메서드는 16진수 문자열과의 변환을 지원합니다. Python의 부동소수점은 내부적으로 이진수로 저장되기 때문에, 부동소수점을 10진 문자열로 변환하거나 그 반대로 변환하는 과정에서 작은 반올림 오차가 발생할 수 있습니다. 반면, 16진수 문자열은 부동소수점의 정확한 표현과 명시를 가능하게 합니다. 이는 디버깅이나 수치 계산 작업에서 유용할 수 있습니다.

float.hex()¶: 부동소수점의 표현을 16진수 문자열로 반환합니다. 유한한 부동소수점의 경우, 이 표현은 항상 앞에 0x 가 붙고 뒤에 p 와 지수가 포함됩니다.

classmethod float.fromhex(s)¶: 16진수 문자열 s 로 표현된 부동소수점을 반환하는 클래스 메서드입니다. 문자열 s 는 앞뒤에 공백이 포함될 수 있습니다.

float.hex() 은 인스턴스 메서드인 반면, float.fromhex() 는 클래스 메서드임을 유의하십시오.

16진수 문자열은 다음과 같은 형태를 가집니다:

[부호] ['0x'] 정수 ['.' 분수] ['p' 지수]

선택적인 sign 은 + 또는 - 일 수 있으며, integer 와 fraction 은 16진수 디지털 문자열이고, exponent 는 선택적인 선행 부호가 있는 10진수 정수입니다. 대소문자는 구분하지 않으며, integer 또는 fraction 중 어느 하나에 적어도 하나의 16진수 자리가 있어야 합니다. 이 구문은 C99 표준의 6.4.4.2 절에 명시된 구문 및 Java 1.5 이후에 사용되는 구문과 유사합니다. 특히, float.hex() 의 출력값은 C 또는 Java 코드에서 16진수 부동 소수점 리터럴로 사용할 수 있으며, C의 %a 형식 문자 또는 Java의 Double.toHexString 에서 생성된 16진수 문자열은 float.fromhex() 에서 수용됩니다.

지수(exponent)는 16진수가 아닌 10진수로 작성되며, 계수에 곱할 2의 거듭제곱을 나타낸다는 점에 유의하십시오. 예를 들어, 16진수 문자열 0x3.a7p10 은 부동 소수점 수 (3 + 10./16 + 7./16**2) * 2.0**10, 즉 3740.0 을 나타냅니다:

>>> float.fromhex('0x3.a7p10')
3740.0

3740.0 에 역변환을 적용하면 동일한 숫자를 나타내는 다른 16진수 문자열이 생성됩니다:

>>> float.hex(3740.0)
'0x1.d380000000000p+11'

Complex에 대한 추가 메서드¶

The complex type implements the numbers.Complex abstract base class. complex also has the following additional methods.

classmethod complex.from_number(x)¶

숫자를 복소수로 변환하는 클래스 메서드.

For a general Python object x, complex.from_number(x) delegates to x.__complex__(). If __complex__() is not defined then it falls back to __float__(). If __float__() is not defined then it falls back to __index__().

Added in version 3.14.

수치 타입의 해싱¶

For numbers x and y, possibly of different types, it’s a requirement that hash(x) == hash(y) whenever x == y (see the __hash__() method documentation for more details). For ease of implementation and efficiency across a variety of numeric types (including int, float, decimal.Decimal and fractions.Fraction) Python’s hash for numeric types is based on a single mathematical function that’s defined for any rational number, and hence applies to all instances of int and fractions.Fraction, and all finite instances of float and decimal.Decimal. Essentially, this function is given by reduction modulo P for a fixed prime P. The value of P is made available to Python as the modulus attribute of sys.hash_info.

현재 사용되는 소수는 32비트 C long을 사용하는 머신에서는 P = 2**31 - 1 이고, 64비트 C long을 사용하는 머신에서는 P = 2**61 - 1 입니다.

상세 규칙은 다음과 같습니다:

x = m / n 이 0 이상의 유리수이고 n 이 P 로 나누어지지 않는 경우, hash(x) 를 m * invmod(n, P) % P 로 정의합니다. 여기서 invmod(n, P) 는 모듈로 P 에 대한 n 의 역수를 구합니다.
x = m / n 이 0 이상의 유리수이고 n 이 P 로 나누어지지만 m 은 나누어지지 않는 경우, n 은 모듈로 P 에 대한 역수를 가지지 않으므로 위의 규칙이 적용되지 않습니다. 이 경우 hash(x) 를 상수 값 sys.hash_info.inf 로 정의합니다.
x = m / n 이 음의 유리수인 경우 hash(x) 를 -hash(-x) 로 정의합니다. 결과 해시가 -1 인 경우 -2 로 대체합니다.
특정 값인 sys.hash_info.inf 와 -sys.hash_info.inf 는 각각 양의 무한대 또는 음의 무한대에 대한 해시 값으로 사용됩니다.
complex 수 z 의 경우, 실수부와 허수부의 해시 값을 계산하여 hash(z.real) + sys.hash_info.imag * hash(z.imag) 로 결합하고, 2**sys.hash_info.width 로 나머지 연산을 수행하여 range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - 1)) 범위에 들어오도록 합니다. 다시 한번, 결과가 -1 인 경우 -2 로 대체합니다.

위 규칙을 명확히 하기 위해, 유리수, float, 또는 complex 의 해시를 계산하는 내장 hash와 동등한 Python 예제 코드를 제공합니다:

import sys, math

def hash_fraction(m, n):
    """Compute the hash of a rational number m / n.

    Assumes m and n are integers, with n positive.
    Equivalent to hash(fractions.Fraction(m, n)).

    """
    P = sys.hash_info.modulus
    # Remove common factors of P.  (Unnecessary if m and n already coprime.)
    while m % P == n % P == 0:
        m, n = m // P, n // P

    if n % P == 0:
        hash_value = sys.hash_info.inf
    else:
        # Fermat's Little Theorem: pow(n, P-1, P) is 1, so
        # pow(n, P-2, P) gives the inverse of n modulo P.
        hash_value = (abs(m) % P) * pow(n, P - 2, P) % P
    if m < 0:
        hash_value = -hash_value
    if hash_value == -1:
        hash_value = -2
    return hash_value

def hash_float(x):
    """Compute the hash of a float x."""

    if math.isnan(x):
        return object.__hash__(x)
    elif math.isinf(x):
        return sys.hash_info.inf if x > 0 else -sys.hash_info.inf
    else:
        return hash_fraction(*x.as_integer_ratio())

def hash_complex(z):
    """Compute the hash of a complex number z."""

    hash_value = hash_float(z.real) + sys.hash_info.imag * hash_float(z.imag)
    # do a signed reduction modulo 2**sys.hash_info.width
    M = 2**(sys.hash_info.width - 1)
    hash_value = (hash_value & (M - 1)) - (hash_value & M)
    if hash_value == -1:
        hash_value = -2
    return hash_value

불린(Boolean) 타입 - `bool`¶

불린(Boolean)은 참/거짓 값을 나타냅니다. bool 타입은 True 와 False 라는 정확히 두 개의 상수 인스턴스를 가집니다.

내장 함수 bool() 은 어떤 값이 참/거짓 값으로 해석될 수 있는 경우(위의 Truth Value Testing 절 참조) 해당 값을 불린으로 변환합니다.

논리 연산의 경우, boolean operators and, or, not 을 사용하십시오. 두 개의 불린에 비트 연산자 &, |, ^ 를 적용하면 각각 논리 연산 “and”, “or”, “xor”에 해당하는 불린 값을 반환합니다. 그러나 &, |, ^ 보다는 논리 연산자 and, or 및 != 를 사용하는 것이 권장됩니다.

버전 3.12부터 폐지됨: 비트 반전 연산자 ~ 의 사용은 더 이상 권장되지 않으며, Python 3.16부터 에러를 발생시킵니다.

bool 은 int() 의 서브클래스입니다(참조: 숫자 형 — int, float, complex). 많은 수치적 문맥에서 False 와 True 는 각각 정수 0과 1처럼 동작합니다. 그러나 이에 의존하는 것은 권장되지 않으므로, 대신 int 를 사용하여 명시적으로 변환하십시오.

이터레이션 관련 타입¶

Python은 컨테이너에 대한 반복(iteration) 개념을 지원합니다. 이는 두 가지 별개의 방식을 통해 구현되며, 사용자 정의 클래스가 반복을 지원할 수 있도록 합니다. 아래에서 자세히 설명하는 시퀀스(Sequence)는 항상 이 반복 메서드들을 지원합니다.

이터러블(Iterables)¶

컨테이너 객체가 iterable 을 지원하기 위해서는 하나의 메서드가 정의되어야 합니다:

container.__iter__()¶: 한 개의 iterator 객체를 반환합니다. 이 객체는 아래에 설명된 이터레이터 프로토콜을 지원해야 합니다. 컨테이너가 서로 다른 유형의 반복을 지원하는 경우, 특정 반복 유형에 대한 이터레이터를 명시적으로 요청하기 위해 추가적인 메서드를 제공할 수 있습니다. (여러 형태의 반복을 지원하는 객체의 예로, 너비 우선 및 깊이 우선 탐색을 모두 지원하는 트리 구조가 있습니다.) 이 메서드는 Python/C API에서 Python 객체의 타입 구조에 있는 tp_iter 슬롯에 대응합니다.

이터레이터(Iterators)¶

이터레이터 객체 자체는 다음의 두 메서드를 지원해야 하며, 이 둘은 합쳐져서 iterator protocol 을 형성합니다:

iterator.__iter__()¶: 자기 자신인 iterator 객체를 반환합니다. 이는 컨테이너와 이터레이터가 모두 for 및 in 구문과 함께 사용될 수 있도록 하기 위해 필요합니다. 이 메서드는 Python/C API에서 Python 객체의 타입 구조에 있는 tp_iter 슬롯에 대응합니다.

iterator.__next__()¶: 다음 요소들을 iterator 에서 반환합니다. 더 이상의 항목이 없는 경우, StopIteration 예외를 발생시킵니다. 이 메서드는 Python/C API에서 Python 객체의 타입 구조에 있는 tp_iternext 슬롯에 대응합니다.

Python은 일반적 및 특정 시퀀스 유형, 딕셔너리 및 기타 더 특수한 형태들에 대한 이터레이션을 지원하기 위해 여러 이터레이터 객체를 정의합니다. 이러한 특정 타입들은 이터레이터 프로토콜을 구현하는 것 이상의 의미는 없습니다.

이터레이터의 __next__() 메서드가 StopIteration 을 발생시킨 후에는, 이후의 호출에서도 계속 발생시켜야 합니다. 이 특성을 따르지 않는 구현은 결함이 있는 것으로 간주됩니다.

제너레이터 유형¶

Python의 제너레이터 — 더 정확하게는, 제너레이터 함수 와 제너레이터 이터레이터 — 이터레이터 프로토콜을 구현하는 편리한 방법을 제공합니다.

A function that contains one or more yield expressions is a generator function. For example:

>>> def count_to_three():
...     yield 0
...     yield 1
...     yield 2
...     yield 3

Generator functions behave as regular user-defined functions (for example, they have the same attributes), except that calling a generator function returns a generator iterator:

>>> count_to_three()
<generator object count_to_three at 0x7f33a2305000>

제너레이터 이터레이터를 반복하면 기반이 되는 제너레이터 함수의 코드가 실행되며, 각각의 yield 된 값이 차례대로 생성됩니다:

>>> for number in count_to_three():
...     print(number)
0
1
2
3

>>> list(count_to_three())
[0, 1, 2, 3]

제너레이터 함수의 일반적인 용도 중 하나는 사용자 정의 반복 가능한(iterable) 객체의 __iter__() 메서드를 구현하는 것입니다. 예를 들어:

>>> class CardDeck:
...     def __iter__(self):
...         yield 'three of clubs'
...         yield 'ace of hearts'

>>> list(CardDeck())
['three of clubs', 'ace of hearts']

제너레이터 이터레이터¶

제너레이터 이터레이터는 이터레이터 프로토콜 을 구현합니다. 이를 반복하면 기반이 되는 제너레이터 함수의 실행이 진행됩니다.

generator.__next__()¶

제너레이터 함수의 실행을 시작하거나, 현재 일시 중단된 지점인 yield 표현식 에서 실행을 재개합니다. 제너레이터 함수가 __next__() 메서드로 재개될 때, 현재 yield 표현식은 항상 None 으로 평가됩니다. 그런 다음 실행은 다음 yield 표현식으로 이어지며, 해당 지점에서 제너레이터가 다시 일시 중단되고 yield 키워드 뒤의 표현식 값이 __next__() 의 호출자에게 반환됩니다. 제너레이터가 다른 값을 yield 하지 않고 종료되면, __next__() 는 반복이 완료되었음을 알리는 StopIteration 예외를 발생시킵니다.

이 메서드는 보통 묵시적으로 호출되며, 예를 들어 for 루프나 내장 next() 함수에 의해 호출됩니다.

제너레이터 이터레이터는 일반적인 이터레이터보다 몇 가지 메서드를 더 가지고 있으며, 이는 기반이 되는 제너레이터 함수의 실행을 제어하는 데 사용됩니다:

generator.send(value)¶

“제너레이터 함수로 값을 ‘보냅니다(send)’: value 인자가 현재 yield 표현식의 결과가 됩니다.”

그렇지 않은 경우, 이 메서드는 __next__() 와 동일하게 작동합니다. 즉, 기반이 되는 함수를 재개하고 다음 yield된 값을 반환하거나 StopIteration 을 발생시킵니다.

제너레이터를 시작하기 위해 send() 를 호출할 때는, 값을 수신할 수 있는 현재 yield 표현식이 없으므로 인자로 반드시 None 을 전달해야 합니다.

generator.throw(value)¶

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

제너레이터가 현재 일시 중단된 지점에서 예외를 발생시킵니다.

그렇지 않은 경우, 이 메서드는 __next__() 와 동일하게 작동합니다. 즉, 기반이 되는 함수를 재개하고 다음 yield된 값을 반환하거나 StopIteration 을 발생시킵니다. 만약 제너레이터 함수가 전달된 예외를 처리하지 않거나 다른 예외를 발생시키면, 해당 예외는 호출자에게 전파됩니다.

제너레이터를 시작하기 위해 throw() 를 호출하면 제너레이터는 즉시 종료되며(즉, 이후의 __next__() 호출은 StopIteration 을 발생시킵니다), 발생한 예외는 throw() 의 호출자에게 전파됩니다.

일반적인 사용 시, 이 메서드는 raise 키워드가 사용되는 방식과 유사하게 예외 인스턴스라는 단일 인자와 함께 호출됩니다.

그러나 하위 호환성을 위해 이전 버전의 파이썬 관례를 따르는 두 번째 시그니처도 지원됩니다. type 인자는 예외 클래스여야 하며, value 는 예외 인스턴스여야 합니다. value 가 제공되지 않으면 type 생성자가 호출되어 인스턴스를 가져옵니다. traceback 이 제공되면 예외에 설정되고, 그렇지 않으면 value 에 저장된 기존 __traceback__ 속성이 삭제될 수 있습니다.

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

generator.close()¶

제너레이터 함수가 현재 일시 중단된 지점에서 GeneratorExit 예외를 발생시킵니다(throw(GeneratorExit) 를 호출하는 것과 동일).

제너레이터 함수가 이미 종료되었거나(예외 또는 일반적인 return으로 인해), GeneratorExit 를 발생시킨 경우(예외를 잡지 않음), close() 는 None 을 반환합니다. 제너레이터가 값을 yield하는 경우 RuntimeError 가 발생합니다. 제너레이터가 다른 예외를 발생시키면 호출자에게 전파됩니다. 제너레이터가 닫힐 때 값을 반환하는 경우, 그 값이 close() 에 의해 반환됩니다.

제너레이터 이터레이터가 종료되기 전에 가비지 컬렉션이 수행되면, close() 가 자동으로 호출됩니다.

버전 3.13에서 변경: 제너레이터가 닫힐 때 값을 반환하는 경우, 해당 값이 close() 에 의해 반환됩니다. 이전에는 None 을 반환했습니다.

이 메서드 중 하나가 이미 실행 중일 때 다른 제너레이터 메서드(__next__(), send(), throw(), close())를 호출하면 ValueError 예외가 발생합니다.

비동기 제너레이터 이터레이터¶

이 서브섹션은 비동기 제너레이터 함수의 실행을 제어하는 데 사용되는 비동기 제너레이터 이터레이터의 메서드들을 설명합니다.

async agen.__anext__()¶

실행 시 비동기 제너레이터 함수를 실행하거나, 현재 일시 중단된 지점인 yield 표현식 에서 실행을 재개하는 어웨이터블 을 반환합니다. 비동기 제너레이터 함수가 __anext__() 메서드로 재개될 때, 반환된 어웨이터블 내의 현재 yield 표현식은 항상 None 으로 평가되며, 실행 시 다음 yield 표현식으로 이어집니다. yield 키워드 뒤의 표현식 값은 종료되는 코루틴에 의해 발생한 StopIteration 예외의 값입니다. 비동기 제너레이터가 다른 값을 yield하지 않고 종료되면, 어웨이터블은 대신 비동기 반복이 완료되었음을 알리는 StopAsyncIteration 예외를 발생시킵니다.

이 메서드는 보통 async for 루프나 내장 anext() 함수에 의해 묵시적으로 호출됩니다.

비동기 제너레이터-이터레이터는 일반적인 비동기 이터레이터보다 몇 가지 메서드를 더 가지고 있으며, 이는 기반이 되는 제너레이터 함수의 실행을 제어하는 데 사용됩니다:

async agen.asend(value)¶

실행 시 기반이 되는 비동기 제너레이터 함수로 값을 “보내는” 어웨이터블을 반환합니다. value 인자가 현재 yield 표현식의 결과가 됩니다.

그렇지 않은 경우, 이 메서드는 __anext__() 와 동일하게 작동합니다. 반환된 어웨이터블이 실행될 때 기반이 되는 함수를 재개하고, 다음 yield된 값을 발생한 StopIteration 의 값으로 반환하거나 StopAsyncIteration 을 발생시킵니다.

비동기 제너레이터를 시작하기 위해 asend() 를 호출할 때는, 값을 수신할 수 있는 yield 표현식이 없으므로 인자로 반드시 None 을 전달해야 합니다.

async agen.athrow(value)¶

async agen.athrow(type[, value[, traceback]])

실행 시 기반이 되는 비동기 제너레이터 함수가 현재 일시 중단된 지점에서 예외를 발생시키는 어웨이터블을 반환합니다.

그렇지 않은 경우, 이 메서드는 __anext__() 와 동일하게 동작합니다. 반환된 어웨이터블이 실행되면 기반 함수를 재개하고(예외가 발생할 수 있음), 다음 yield된 값을 발생한 StopIteration 의 값으로 반환하거나 StopAsyncIteration 을 발생시킵니다. 만약 기반 함수가 전달된 예외를 처리하지 않거나 다른 예외를 발생시키면, 어웨이터블이 실행될 때 해당 예외가 어웨이터블의 호출자에게 전달됩니다.

제너레이터를 시작하기 위해 athrow() 가 호출되면, 어웨이터블이 실행될 때 제너레이터가 종료되며(즉, 이후 __anext__() 의 결과는 실행 시 StopAsyncIteration 을 발생시킵니다), 던져진 예외는 어웨이터블의 호출자에게 전달됩니다.

일반적인 사용 시, 이 메서드는 raise 키워드가 사용되는 방식과 유사하게 예외 인스턴스라는 단일 인자와 함께 호출됩니다.

하지만 하위 호환성을 위해 두 번째 시그니처도 지원됩니다. 예외 인스턴스는 generator.throw() 와 동일한 방식으로 세 개의 인자로부터 생성됩니다.

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

async agen.aclose()¶

실행 시 현재 중단된 지점에서 비동기 제너레이터 함수에 GeneratorExit 를 던지는 어웨이터블을 반환합니다(athrow(GeneratorExit) 를 호출하는 것과 동일).

만약 비동기 제너레이터 함수가 성공적으로 종료되거나, 이미 닫혔거나, (예외를 잡지 않음으로써) GeneratorExit 를 발생시키면, 반환된 어웨이터블은 StopIteration 예외를 발생시킵니다. 비동기 제너레이터에 대한 후속 호출로 반환되는 모든 어웨이터블은 StopAsyncIteration 예외를 발생시킵니다.

비동기 제너레이터가 값을 yield하면 어웨이터블에 의해 RuntimeError 가 발생합니다. 비동기 제너레이터가 다른 예외를 발생시키면, 해당 예외는 어웨이터블의 호출자에게 전달됩니다.

비동기 제너레이터가 예외 또는 정상 종료로 인해 이미 종료된 경우, 이후의 aclose() 호출은 아무것도 하지 않는 어웨이터블을 반환합니다.

시퀀스 타입 — `list`, `tuple`, `range`¶

세 가지 기본 시퀀스 타입이 있습니다: 리스트(list), 튜플(tuple), 그리고 range 객체입니다. binary data 및 text strings 처리에 특화된 추가 시퀀스 타입은 전용 섹션에서 설명합니다.

공통 시퀀스 연산¶

다음 표의 연산들은 가변 및 불변을 포함한 대부분의 시퀀스 타입에서 지원됩니다. collections.abc.Sequence ABC는 사용자 정의 시퀀스 타입에서 이러한 연산을 정확하게 구현하기 쉽게 제공됩니다.

이 표는 시퀀스 연산을 오름차순 우선순위로 나열합니다. 표에서 s 와 t 는 동일한 타입의 시퀀스이며, n, i, j, k 는 정수이고 x 는 s 에 의해 부과된 모든 타입 및 값 제한을 충족하는 임의의 객체입니다.

in 및 not in 연산은 비교 연산과 동일한 우선순위를 가집니다. + (연결) 및 * (반복) 연산은 해당 숫자 연산과 동일한 우선순위를 가집니다. [3]

다양한 시퀀스 연산의 비용은 내장형 타입 연산의 시간 복잡도 를 참조하십시오.

Operation	Result	Notes
`x in s`	만약 s 의 항목이 x 와 같으면 `True`, 그렇지 않으면 `False`	(1)
`x not in s`	만약 s 의 항목이 x 와 같으면 `False`, 그렇지 않으면 `True`	(1)
`s + t`	s 와 t 의 연결	(6)(7)
`s * n` 또는 `n * s`	s 를 n 번 자신에게 더한 것과 동일	(2)(7)
`s[i]`	s 의 i 번째 항목, 인덱스 0부터 시작	(3)(8)
`s[i:j]`	s 의 i 부터 j 까지의 슬라이스	(3)(4)
`s[i:j:k]`	s 의 i 부터 j 까지 스텝 k 의 슬라이스	(3)(5)
`len(s)`	s 의 길이
`min(s)`	s 의 가장 작은 항목
`max(s)`	s 의 가장 큰 항목

동일한 타입의 시퀀스는 비교도 지원합니다. 특히 튜플과 리스트는 대응하는 요소를 비교하여 사전식으로 비교됩니다. 이는 모든 요소가 같고 두 시퀀스가 동일한 타입이며 길이가 같아야 같다고 판단됨을 의미합니다. (상세 정보는 언어 참조의 비교 를 참조하십시오.)

가변 시퀀스에 대한 전방 및 역방향 이터레이터는 인덱스를 사용하여 값에 접근합니다. 해당 인덱스는 기초 시퀀스가 변경되더라도 계속 앞으로(또는 뒤로) 진행합니다. 이터레이터는 IndexError 또는 StopIteration 이 발생하거나 인덱스가 0 미만으로 떨어질 때만 종료됩니다.

Notes:

일반적인 경우 in 및 not in 연산은 단순 포함 여부 테스트에만 사용되지만, 일부 특수한 시퀀스(str, bytes, bytearray 등)는 이를 부분 시퀀스 테스트에 사용하기도 합니다:
```
>>> "gg" in "eggs"
True
```
n 의 값이 0 미만인 경우 0 으로 처리됩니다(이 경우 s 와 동일한 타입의 빈 시퀀스가 생성됩니다). 시퀀스 s 의 항목은 복사되지 않고 여러 번 참조된다는 점에 주의하십시오. 이는 초보 Python 프로그래머들이 자주 실수하는 부분입니다. 다음을 고려하십시오:
```
>>> lists = [[]] * 3
>>> lists
[[], [], []]
>>> lists[0].append(3)
>>> lists
[[3], [3], [3]]
```
발생한 상황은 [[]] 가 빈 리스트를 포함하는 한 개의 요소를 가진 리스트이며, 따라서 [[]] * 3 의 세 요소 모두가 이 하나의 빈 리스트를 참조하고 있기 때문입니다. lists 의 어느 요소를 수정하더라도 이 단일 리스트가 수정됩니다. 다음과 같이 서로 다른 리스트들로 구성된 리스트를 만들 수 있습니다:
```
>>> lists = [[] for i in range(3)]
>>> lists[0].append(3)
>>> lists[1].append(5)
>>> lists[2].append(7)
>>> lists
[[3], [5], [7]]
```
자세한 설명은 FAQ 항목 다차원 리스트를 어떻게 만듭니까? 에서 확인할 수 있습니다.
i 또는 j 가 음수인 경우, 인덱스는 시퀀스 s 의 끝을 기준으로 합니다: len(s) + i 또는 len(s) + j 로 대체됩니다. 단, -0 은 여전히 0 임을 유의하십시오.
s 의 i 부터 j 까지의 슬라이스는 i <= k < j 를 만족하는 인덱스 k 를 가진 항목들의 시퀀스로 정의됩니다.
- i 가 생략되었거나 None 인 경우, 0 을 사용합니다.
- j 가 생략되었거나 None 인 경우, len(s) 를 사용합니다.
- i 또는 j 가 -len(s) 보다 작은 경우, 0 을 사용합니다.
- i 또는 j 가 len(s) 보다 큰 경우, len(s) 를 사용합니다.
- i 가 j 보다 크거나 같은 경우, 슬라이스는 비어 있습니다.
s 의 i 부터 j 까지 스텝 k 의 슬라이스는 0 <= n < (j-i)/k 를 만족하는 인덱스 x = i + n*k 의 항목들로 구성된 시퀀스로 정의됩니다. 다시 말해, 인덱스는 i, i+k, i+2*k, i+3*k 등이며 j 에 도달하면 멈춥니다(하지만 j 는 포함하지 않습니다). k 가 양수일 때 i 와 j 가 더 크면 len(s) 로 줄어듭니다. k 가 음수일 때 i 와 j 가 더 크면 len(s) - 1 로 줄어듭니다. i 또는 j 가 생략되었거나 None 이면, 각각의 끝(end) 값이 됩니다(끝의 위치는 k 의 부호에 따라 달라집니다). k 는 0이 될 수 없습니다. k 가 None 이면 1 과 동일하게 처리됩니다.

불변 시퀀스를 연결하면 항상 새 객체가 생성됩니다. 이는 반복적인 연결을 통해 시퀀스를 구축할 경우 전체 시퀀스 길이에 대해 이차 시간 복잡도(quadratic runtime cost)가 발생함을 의미합니다. 선형 시간 복잡도를 얻으려면 아래의 대안 중 하나를 사용해야 합니다:
- if concatenating str objects, you can build a list and use str.join() at the end or else write to an io.StringIO instance and retrieve its value when complete
- bytes 객체를 연결할 때는 이와 유사하게 bytes.join() 또는 io.BytesIO 를 사용할 수 있으며, bytearray 객체를 사용하여 제자리(in-place)에서 연결할 수도 있습니다. bytearray 객체는 가변적이며 효율적인 전체 할당(overallocation) 메커니즘을 갖추고 있습니다.
- tuple 객체를 연결하려면 대신 list 를 확장하십시오.
- 기타 유형의 경우 관련 클래스 문서를 확인하십시오.
일부 시퀀스 유형(예: range)은 특정 패턴을 따르는 항목 시퀀스만 지원하며, 따라서 시퀀스 연결이나 반복을 지원하지 않습니다.
i 가 시퀀스 범위를 벗어나면 IndexError 가 발생합니다.

시퀀스 메서드

시퀀스 유형은 다음 메서드도 지원합니다:

sequence.count(value, /)¶: sequence 에서 value 가 나타나는 총 횟수를 반환합니다.

sequence.index(value[, start[, stop]])¶

sequence 에서 value 가 처음 나타나는 인덱스를 반환합니다.

sequence 에서 value 를 찾을 수 없으면 ValueError 를 발생시킵니다.

start 또는 stop 인자는 start 에서 시작하여 stop 에서 끝나는 시퀀스의 부분 섹션을 효율적으로 검색할 수 있게 합니다. 이는 데이터를 복사하지 않으면서 start + sequence[start:stop].index(value) 와 거의 동일하게 동작합니다.

조심

모든 시퀀스 유형이 start 및 stop 인자 전달을 지원하는 것은 아닙니다.

불변 시퀀스 유형¶

불변 시퀀스 유형이 일반적으로 구현하지만 가변 시퀀스 유형은 구현하지 않는 유일한 연산은 hash() 내장 기능 지원입니다.

이 지원을 통해 tuple 인스턴스와 같은 불변 시퀀스를 dict 키로 사용하거나 set 및 frozenset 인스턴스에 저장할 수 있습니다.

해시 불가능한 값을 포함하는 불변 시퀀스를 해싱하려고 하면 TypeError 가 발생합니다.

가변 시퀀스 유형¶

다음 표의 연산들은 가변 시퀀스 유형에 정의되어 있습니다. 사용자 정의 시퀀스 유형에서 이러한 연산들을 올바르게 구현하기 쉽게 하기 위해 collections.abc.MutableSequence ABC가 제공됩니다.

표에서 s 는 가변 시퀀스 유형의 인스턴스이고, t 는 임의의 이터러블(iterable) 객체이며, x 는 s 에 의해 부과된 모든 유형 및 값 제한을 만족하는 임의의 객체입니다(예를 들어, bytearray 는 0 <= x <= 255 라는 값 제한을 충족하는 정수만 허용합니다).

Operation	Result	Notes
`s[i] = x`	s 의 항목 i 가 x 로 교체됩니다.
`del s[i]`	s 의 항목 i 를 제거합니다.
`s[i:j] = t`	s 의 i 에서 j 까지의 슬라이스가 이터러블 t 의 내용으로 교체됩니다.
`del s[i:j]`	리스트에서 `s[i:j]` 의 요소들을 제거합니다(`s[i:j] = []` 와 동일).
`s[i:j:k] = t`	`s[i:j:k]` 의 요소들이 t 의 요소들로 교체됩니다.	(1)
`del s[i:j:k]`	리스트에서 `s[i:j:k]` 의 요소들을 제거합니다.
`s += t`	s 를 t 의 내용으로 확장합니다(대부분 `s[len(s):len(s)] = t` 와 동일).
`s *= n`	s 의 내용을 n 번 반복하여 업데이트합니다.	(2)

Notes:

k 가 1 이 아닌 경우, t 는 대체되는 슬라이스와 동일한 길이를 가져야 합니다.
n 의 값은 정수이거나 __index__() 를 구현하는 객체입니다. n 이 0 또는 음수이면 시퀀스가 비워집니다. 시퀀스의 항목들은 복사되지 않으며, 공통 시퀀스 연산 의 s * n 설명과 같이 여러 번 참조됩니다.

가변 시퀀스 메서드

가변 시퀀스 유형은 다음 메서드도 지원합니다:

sequence.append(value, /)¶: 시퀀스의 끝에 value 를 추가합니다. 이는 seq[len(seq):len(seq)] = [value] 를 쓰는 것과 동일합니다.

sequence.clear()¶: Added in version 3.3.

sequence 의 모든 항목을 제거합니다. 이는 del sequence[:] 를 쓰는 것과 동일합니다.

sequence.copy()¶: Added in version 3.3.

sequence 의 얕은 복사본을 생성합니다. 이는 sequence[:] 를 쓰는 것과 동일합니다.

힌트

copy() 메서드는 MutableSequence ABC 의 일부는 아니지만, 대부분의 구체적인 가변 시퀀스 유형은 이를 제공합니다.

sequence.extend(iterable, /)¶: sequence 를 iterable 의 내용으로 확장합니다. 대부분의 경우 이는 seq[len(seq):len(seq)] = iterable 을 쓰는 것과 동일합니다.

sequence.insert(index, value, /)¶: 주어진 index 에 value 를 sequence 에 삽입합니다. 이는 sequence[index:index] = [value] 를 쓰는 것과 동일합니다.

sequence.pop(index=-1, /)¶: index 에 있는 항목을 가져오고 sequence 에서 제거합니다. 기본적으로 sequence 의 마지막 항목이 제거되고 반환됩니다.

sequence.remove(value, /)¶

sequence[i] == value 를 만족하는 sequence 의 첫 번째 항목을 제거합니다.

sequence 에서 value 를 찾을 수 없으면 ValueError 를 발생시킵니다.

sequence.reverse()¶: sequence 의 항목들을 제자리에서 뒤집습니다. 이 메서드는 큰 시퀀스를 뒤집을 때 공간을 절약합니다. 부작용(side-effect)에 의해 작동함을 사용자에게 알리기 위해 None 을 반환합니다.

리스트¶

리스트는 가변 시퀀스로, 일반적으로 동질적인 항목의 모음(동질성의 정확한 정도는 애플리케이션마다 다름)을 저장하는 데 사용됩니다.

class list(iterable=(), /)¶

리스트는 여러 가지 방법으로 생성될 수 있습니다:

빈 리스트를 나타내기 위해 대괄이 한 쌍인 경우: []
대괄을 사용하고 항목을 쉼표로 구분하는 경우: [a], [a, b, c]
리스트 컴프리헨션을 사용하는 경우: [x for x in iterable]
타입 생성자를 사용하는 경우: list() 또는 list(iterable)

생성자는 iterable 의 항목들과 동일한 순서의 항목을 가진 리스트를 만듭니다. iterable 은 시퀀스, 이터레이션을 지원하는 컨테이너 또는 이터레이터 객체일 수 있습니다. iterable 이 이미 리스트인 경우, iterable[:] 와 유사하게 복사본을 만들어 반환합니다. 예를 들어, list('abc') 는 ['a', 'b', 'c'] 를 반환하고 list( (1, 2, 3) ) 는 [1, 2, 3] 을 반환합니다. 인자가 제공되지 않으면 생성자는 새로운 빈 리스트 [] 를 생성합니다.

sorted() 내장 함수를 포함하여 다른 많은 연산도 리스트를 생성합니다.

리스트는 항목 유형에 대한 제네릭 입니다.

리스트는 모든 공통 및 가변 시퀀스 연산을 구현합니다. 또한 리스트는 다음과 같은 추가 메서드를 제공합니다:

sort(*, key=None, reverse=False)¶

이 메서드는 항목 간의 < 비교만을 사용하여 리스트를 제자리에서 정렬합니다. 예외는 억제되지 않으며, 비교 연산 중 하나라도 실패하면 전체 정렬 연산이 실패하고(이때 리스트는 부분적으로 수정된 상태로 남을 가능성이 큽니다), 오류가 발생합니다.

sort() 는 키워드 인자로만 전달할 수 있는 두 개의 인자를 받습니다(키워드 전용 인자):

key 는 각 리스트 요소에서 비교 키를 추출하는 데 사용되는 하나의 인자를 받는 함수를 지정합니다(예: key=str.lower). 리스트의 각 항목에 해당하는 키는 한 번만 계산되어 전체 정렬 과정에 사용됩니다. 기본값 None 은 리스트 항목을 별도의 키 값을 계산하지 않고 직접 정렬함을 의미합니다.

2.x 스타일의 cmp 함수를 key 함수로 변환하려면 functools.cmp_to_key() 유틸리티를 사용할 수 있습니다.

reverse 는 불리언 값입니다. True 로 설정하면 리스트 요소들이 각 비교가 반전된 것처럼 정렬됩니다.

이 메서드는 큰 시퀀스를 정렬할 때 메모리 절약을 위해 시퀀스를 제자리(in place)에서 수정합니다. 부작용(side effect)으로 작동함을 사용자에게 알리기 위해, 정렬된 시퀀스를 반환하지 않습니다(새로운 정렬된 리스트 인스턴스를 명시적으로 요청하려면 sorted() 를 사용하십시오).

sort() 메서드는 안정적(stable)임이 보장됩니다. 정렬이 안정적이라는 것은 값이 같다고 비교되는 요소들의 상대적인 순서를 변경하지 않음을 보장한다는 의미이며, 이는 여러 번에 걸쳐 정렬할 때 유용합니다(예를 들어, 부서별로 정렬한 후 급여 등급별로 정렬하는 경우).

정렬 예제 및 간단한 정렬 튜토리얼은 정렬 기법 를 참조하십시오.

리스트를 정렬하는 동안 리스트를 수정하거나 검사하려고 시도하는 결과는 정의되지 않습니다. 파이썬의 C 구현은 정렬이 진행되는 동안 리스트를 비어 있는 것처럼 표시하며, 정렬 중에 리스트가 수정된 것을 감지하면 ValueError 를 발생시킵니다.

list 객체의 스레드 안전성(thread-safety) 보장에 대한 자세한 정보는 리스트 객체의 스레드 안전성 를 참조하십시오.

튜플¶

튜플은 불변(immutable) 시퀀스로, 일반적으로 이질적인 데이터의 모음을 저장하는 데 사용됩니다(예: 내장 기능인 enumerate() 가 생성하는 2-튜플). 또한 튜플은 동질적인 데이터의 불변 시퀀스가 필요한 경우에도 사용됩니다(예: set 또는 dict 인스턴스에 저장하기 위해).

class tuple(iterable=(), /)¶

튜플은 다음과 같은 여러 방법으로 생성할 수 있습니다.

빈 튜플을 나타내기 위해 괄호 쌍 사용: ()
단일 요소 튜플을 위해 뒤에 쉼표 추가: a, 또는 (a,)
쉼표로 항목 구분: a, b, c 또는 (a, b, c)
내장 tuple() 사용: tuple() 또는 tuple(iterable)

생성자는 iterable 의 항목들과 동일한 순서의 항목들을 가진 튜플을 만듭니다. iterable 은 시퀀스, 이터레이션을 지원하는 컨테이너 또는 이터레이터 객체일 수 있습니다. iterable 이 이미 튜플인 경우 변경 없이 그대로 반환됩니다. 예를 들어, tuple('abc') 는 ('a', 'b', 'c') 를 반환하고 tuple( [1, 2, 3] ) 는 (1, 2, 3) 을 반환합니다. 인자가 주어지지 않으면 생성자는 새로운 빈 튜플 () 를 생성합니다.

튜플을 만드는 것은 괄호가 아니라 실제로는 쉼표라는 점에 주의하십시오. 빈 튜플의 경우나 구문상의 모호성을 피해야 하는 경우를 제외하고 괄호는 선택 사항입니다. 예를 들어, f(a, b, c) 는 세 개의 인자를 가진 함수 호출인 반면, f((a, b, c)) 는 3-튜플을 단일 인자로 하는 함수 호출입니다.

튜플은 모든 common 시퀀스 연산을 구현합니다.

튜플은 내용물의 타입에 대한 generic 입니다. 더 자세한 정보는 the typing documentation on annotating tuples 를 참조하십시오.

인덱스로 접근하는 것보다 이름으로 접근하는 것이 더 명확한 이질적 데이터 모음의 경우, 단순한 튜플 객체보다 collections.namedtuple() 이 더 적절한 선택일 수 있습니다.

범위¶

range 타입은 불변의 숫자 시퀀스를 나타내며, 주로 for 루프에서 특정 횟수만큼 반복할 때 사용됩니다.

class range(stop, /)¶

class range(start, stop, step=1, /)

range 생성자의 인자는 정수여야 합니다(내장 int 또는 __index__() 특수 메서드를 구현하는 모든 객체). step 인자가 생략되면 기본값은 1 입니다. start 인자가 생략되면 기본값은 0 입니다. step 이 0이면 ValueError 가 발생합니다.

양수 step 의 경우, 범위 r 의 내용은 i >= 0 이고 r[i] < stop 인 조건에서 r[i] = start + step*i 라는 공식에 의해 결정됩니다.

음수 step 의 경우, 범위의 내용은 여전히 r[i] = start + step*i 라는 공식에 의해 결정되지만, 제약 조건은 i >= 0 및 r[i] > stop 입니다.

r[0] 이 값 제약 조건을 충족하지 않으면 범위 객체는 비게 됩니다. 범위는 음수 인덱스를 지원하지만, 이는 양수 인덱스에 의해 결정된 시퀀스의 끝에서부터 인덱싱하는 것으로 해석됩니다.

sys.maxsize 보다 큰 절대값을 포함하는 범위도 허용되지만 일부 기능(예: len())은 OverflowError 를 발생시킬 수 있습니다.

범위 예제:

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list(range(0, 30, 5))
[0, 5, 10, 15, 20, 25]
>>> list(range(0, 10, 3))
[0, 3, 6, 9]
>>> list(range(0, -10, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> list(range(0))
[]
>>> list(range(1, 0))
[]

범위는 연결과 반복을 제외한 모든 common 시퀀스 연산을 구현합니다 (범위 객체는 엄격한 패턴을 따르는 시퀀스만 나타낼 수 있으며, 반복과 연결은 대개 그러한 패턴을 위반하기 때문입니다).

start¶: start 매개변수의 값 (매개변수가 제공되지 않은 경우 0)

stop¶: stop 매개변수의 값

step¶: step 매개변수의 값 (매개변수가 제공되지 않은 경우 1)

일반적인 list 또는 tuple 과 비교하여 range 형의 장점은 range 객체가 표현하는 범위의 크기에 관계없이 항상 동일한(적은) 양의 메모리를 사용한다는 점입니다(start, stop, step 값만 저장하고, 필요한 경우에만 개별 항목과 하위 범위를 계산하기 때문입니다).

범위 객체는 collections.abc.Sequence ABC를 구현하며, 포함 여부 테스트, 요소 인덱스 조회, 슬라이싱 및 음수 인덱스 지원과 같은 기능을 제공합니다(시퀀스 타입 — list, tuple, range 참조):

>>> r = range(0, 20, 2)
>>> r
range(0, 20, 2)
>>> 11 in r
False
>>> 10 in r
True
>>> r.index(10)
5
>>> r[5]
10
>>> r[:5]
range(0, 10, 2)
>>> r[-1]
18

== 및 != 를 사용하여 범위 객체의 동일성을 테스트하면 시퀀스로 비교합니다. 즉, 두 범위 객체가 동일한 값의 시퀀스를 나타내는 경우 같다고 간주됩니다. (동일하게 비교되는 두 범위 객체가 서로 다른 start, stop, step 어트리뷰트를 가질 수 있음에 주의하십시오. 예: range(0) == range(2, 1, 3) 또는 range(0, 3, 2) == range(0, 4, 2))

버전 3.2에서 변경: Sequence ABC를 구현합니다. 슬라이싱과 음수 인덱스를 지원합니다. 모든 항목을 순회하는 대신 상수 시간 내에 int 객체의 포함 여부를 확인합니다.

버전 3.3에서 변경: (객체 아이덴티티 기반 비교 대신) 범위 객체가 정의하는 값의 시퀀스에 기반하여 비교하도록 ‘==’와 ‘!=’를 정의합니다.

start, stop, step 어트리뷰트를 추가했습니다.

linspace recipe <https://code.activestate.com/recipes/579000-equally-spaced-numbers-linspace/> 은 부동 소수점 응용 프로그램에 적합한 범위(range)의 지연(lazy) 버전을 구현하는 방법을 보여줍니다.

텍스트 및 바이너리 시퀀스 타입 메서드 요약¶

다음 표는 카테고리별 텍스트 및 바이너리 시퀀스 타입 메서드를 요약한 것입니다.

카테고리	`str` 메서드				`bytes` 및 `bytearray` 메서드
포맷팅	`str.format()`
	`str.format_map()`
	포맷 문자열 리터럴
	printf 스타일 문자열 포매팅				printf 스타일의 Bytes 포매팅
검색 및 교체	`str.find()`	`str.rfind()`			`bytes.find()`	`bytes.rfind()`
	`str.index()`	`str.rindex()`			`bytes.index()`	`bytes.rindex()`
	`str.startswith()`				`bytes.startswith()`
	`str.endswith()`				`bytes.endswith()`
	`str.count()`				`bytes.count()`
	`str.replace()`				`bytes.replace()`
분할 및 결합	`str.split()`		`str.rsplit()`		`bytes.split()`		`bytes.rsplit()`
	`str.splitlines()`				`bytes.splitlines()`
	`str.partition()`				`bytes.partition()`
	`str.rpartition()`				`bytes.rpartition()`
	`str.join()`				`bytes.join()`
문자열 분류	`str.isalpha()`				`bytes.isalpha()`
	`str.isdecimal()`
	`str.isdigit()`				`bytes.isdigit()`
	`str.isnumeric()`
	`str.isalnum()`				`bytes.isalnum()`
	`str.isidentifier()`
	`str.islower()`				`bytes.islower()`
	`str.isupper()`				`bytes.isupper()`
	`str.istitle()`				`bytes.istitle()`
	`str.isspace()`				`bytes.isspace()`
	`str.isprintable()`
대소문자 변환	`str.lower()`				`bytes.lower()`
	`str.upper()`				`bytes.upper()`
	`str.casefold()`
	`str.capitalize()`				`bytes.capitalize()`
	`str.title()`				`bytes.title()`
	`str.swapcase()`				`bytes.swapcase()`
패딩 및 잘라내기	`str.ljust()`		`str.rjust()`		`bytes.ljust()`		`bytes.rjust()`
	`str.center()`				`bytes.center()`
	`str.expandtabs()`				`bytes.expandtabs()`
	`str.strip()`				`bytes.strip()`
	`str.lstrip()`			`str.rstrip()`	`bytes.lstrip()`			`bytes.rstrip()`
	`str.removeprefix()`				`bytes.removeprefix()`
	`str.removesuffix()`				`bytes.removesuffix()`
변환 및 인코딩	`str.translate()`				`bytes.translate()`
	`str.maketrans()`				`bytes.maketrans()`
	`str.encode()`
					`bytes.decode()`

텍스트 시퀀스 유형 — `str`¶

파이썬의 텍스트 데이터는 str 객체 또는 문자열(strings) 으로 처리됩니다. 문자열은 유니코드 코드 포인트의 불변 시퀀스 입니다. 문자열 리터럴은 다음과 같은 다양한 방식으로 작성됩니다:

작은따옴표: 'allows embedded "double" quotes'
큰따옴표: "allows embedded 'single' quotes"
삼중 따옴표: '''Three single quotes''', """Three double quotes"""

삼중 따옴표 문자열은 여러 줄에 걸쳐 작성될 수 있으며, 관련된 모든 공백이 문자열 리터럴에 포함됩니다.

단일 표현식의 일부이며 그 사이에 공백만 있는 문자열 리터럴은 하나의 문자열 리터럴로 암시적으로 변환됩니다. 즉, ("spam " "eggs") == "spam eggs" 와 같습니다.

See 문자열과 바이트열 리터럴 for more about the various forms of string literal, including supported escape sequences, and the r (“raw”) prefix that disables most escape sequence processing.

문자열은 str 생성자를 사용하여 다른 객체로부터 생성될 수도 있습니다.

별도의 “문자(character)” 타입이 없으므로, 문자열을 인덱싱하면 길이가 1인 문자열이 생성됩니다. 즉, 비어 있지 않은 문자열 s 에 대해 s[0] == s[0:1] 입니다.

가변 문자열 타입도 없지만, 여러 조각으로 구성된 문자열을 효율적으로 생성하기 위해 str.join() 또는 io.StringIO 를 사용할 수 있습니다.

버전 3.3에서 변경: Python 2 시리즈와의 하위 호환성을 위해 문자열 리터럴에 u 접두사가 다시 허용됩니다. 이는 문자열 리터럴의 의미에 영향을 주지 않으며 r 접두사와 함께 사용할 수 없습니다.

class str(*, encoding='utf-8', errors='strict')¶

class str(object)

class str(object, encoding, errors='strict')

class str(object, *, errors)

object 의 문자열 버전을 반환합니다. object 가 제공되지 않으면 빈 문자열을 반환합니다. 그 외의 경우, str() 의 동작은 encoding 또는 errors 가 제공되는지 여부에 따라 다음과 같이 결정됩니다.

encoding 과 errors 가 모두 제공되지 않으면, str(object) 는 type(object).__str__(object) 를 반환하며, 이는 object 의 “비형식적인(informal)” 또는 출력에 적합한 문자열 표현입니다. 문자열 객체의 경우 이는 문자열 자체입니다. 만약 object 가 __str__() 메서드를 정의하지 않으면, str() 은 repr(object) 를 반환하는 것으로 대체됩니다.

encoding 또는 errors 중 하나라도 제공되면, object 는 바이트열류 객체 (예: bytes 또는 bytearray)여야 합니다. 이 경우 object 가 bytes (또는 bytearray) 객체라면, str(bytes, encoding, errors) 는 bytes.decode(encoding, errors) 와 동일합니다. 그렇지 않은 경우, bytes.decode() 를 호출하기 전에 버퍼 객체의 기반이 되는 바이트 객체를 가져옵니다. 버퍼 객체에 대한 정보는 바이트 시퀀스 타입 — bytes, bytearray, memoryview 및 버퍼 프로토콜 를 참조하십시오.

encoding 이나 errors 인자 없이 str() 에 bytes 객체를 전달하는 것은 비형식적인 문자열 표현을 반환하는 첫 번째 경우에 해당합니다(Python의 -b 명령줄 옵션도 참조하십시오). 예시:

>>> str(b'Zoot!')
"b'Zoot!'"

str 클래스와 그 메서드에 대한 자세한 정보는 텍스트 시퀀스 유형 — str 및 아래의 문자열 메서드 섹션을 참조하십시오. 포맷된 문자열을 출력하려면 포맷 문자열 리터럴 및 포맷 문자열 문법 섹션을 참조하십시오. 또한, 텍스트 처리 서비스 섹션도 참조하십시오.

문자열 메서드¶

문자열은 아래에 기술된 추가 메서드와 함께 common 시퀀스 연산을 모두 구현합니다.

문자열은 두 가지 스타일의 문자열 포매팅을 지원합니다. 하나는 높은 유연성과 사용자 정의를 제공하고( str.format(), 포맷 문자열 문법, 사용자 정의 문자열 포매팅 참조), 다른 하나는 C printf 스타일 포매팅을 기반으로 하여 다루는 타입의 범위가 더 좁고 올바르게 사용하는 것이 다소 어렵지만, 처리 가능한 경우에 대해 더 빠른 경우가 많습니다(printf 스타일 문자열 포매팅).

표준 라이브러리의 텍스트 처리 서비스 섹션은 다양한 텍스트 관련 유틸리티를 제공하는 여러 다른 모듈을 다룹니다(re 모듈의 정규 표현식 지원 포함).

str.capitalize()¶: 첫 번째 문자는 대문자로, 나머지는 소문자로 변환된 문자열의 복사본을 반환합니다.

버전 3.8에서 변경: 첫 번째 문자는 이제 대문자가 아닌 제목 케이스(titlecase)로 변환됩니다. 이는 digraph와 같은 문자의 경우 전체 문자가 아닌 첫 번째 글자만 대문자로 변환됨을 의미합니다.

str.casefold()¶

대소문자 구분을 없앤(casefolded) 문자열의 복사본을 반환합니다. 케이스 폴딩된 문자열은 대소문자 구분 없는 매칭에 사용할 수 있습니다.

케이스 폴딩은 소문자 변환(lowercasing)과 유사하지만, 문자열 내의 모든 케이스 차이를 제거하는 것을 목표로 하므로 더 강력하게 동작합니다. 예를 들어, 독일어 소문자 'ß' 는 "ss" 와 동일합니다. 'ß' 는 이미 소문자이므로 lower() 를 호출하면 아무런 변화가 없지만, casefold() 를 호출하면 "ss" 로 변환됩니다. 예시:

>>> 'straße'.lower()
'straße'
>>> 'straße'.casefold()
'strasse'

케이스폴딩(casefolding) 알고리즘은 Unicode 표준의 3.13.3 ‘Default Case Folding’ 섹션 <https://www.unicode.org/versions/Unicode18.0.0/core-spec/chapter-3/#G53253> 에서 설명합니다.

Added in version 3.3.

str.center(width, fillchar=' ', /)¶

길이가 width 인 문자열 내에 가운데 정렬된 문자열을 반환합니다. 채우기는 지정된 fillchar 를 사용하여 수행하며, 기본값은 ASCII 공백입니다. width 가 len(s) 보다 작거나 같으면 원본 문자열을 반환합니다. 예시:

>>> 'Python'.center(10)
'  Python  '
>>> 'Python'.center(10, '-')
'--Python--'
>>> 'Python'.center(4)
'Python'

str.count(sub[, start[, end]])¶

범위 [start, end] 내에서 중첩되지 않는 부분 문자열 sub 의 발생 횟수를 반환합니다. 선택적 인자 start 와 end 는 슬라이스 표기법에 따라 해석됩니다.

sub 이 비어 있는 경우, 문자들 사이의 빈 문자열 개수(즉, 문자열 길이에 1을 더한 값)를 반환합니다. 예시:

>>> 'spam, spam, spam'.count('spam')
3
>>> 'spam, spam, spam'.count('spam', 5)
2
>>> 'spam, spam, spam'.count('spam', 5, 10)
1
>>> 'spam, spam, spam'.count('eggs')
0
>>> 'spam, spam, spam'.count('')
17

str.encode(encoding='utf-8', errors='strict')¶

문자열을 bytes 로 인코딩하여 반환합니다.

encoding 은 기본값으로 'utf-8' 을 사용합니다. 가능한 값은 표준 인코딩 를 참조하십시오.

errors 는 인코딩 오류를 처리하는 방식을 제어합니다. 'strict' (기본값)인 경우 UnicodeError 예외가 발생합니다. 그 외의 가능한 값은 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 및 codecs.register_error() 를 통해 등록된 다른 이름들입니다. 자세한 내용은 에러 처리기 를 참조하십시오.

성능상의 이유로, 인코딩 오류가 실제로 발생하거나, 파이썬 개발 모드 가 활성화되어 있거나, debug build 가 사용되는 경우가 아니면 errors 값의 유효성을 확인하지 않습니다. 예시:

>>> encoded_str_to_bytes = 'Python'.encode()
>>> type(encoded_str_to_bytes)
<class 'bytes'>
>>> encoded_str_to_bytes
b'Python'

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

버전 3.9에서 변경: 이제 파이썬 개발 모드 와 debug mode 에서 errors 인자의 값을 확인합니다.

str.endswith(suffix[, start[, end]])¶

문자열이 지정된 suffix 로 끝나면 True 를 반환하고, 그렇지 않으면 False 를 반환합니다. suffix 는 찾고자 하는 접미사들의 튜플일 수도 있습니다. 선택적 start 가 있으면 해당 위치부터 테스트를 시작하며, 선택적 end 가 있으면 해당 위치에서 비교를 중단합니다. start 와 end 를 사용하는 것은 str[start:end].endswith(suffix) 를 사용하는 것과 동일합니다. 예시:

>>> 'Python'.endswith('on')
True
>>> 'a tuple of suffixes'.endswith(('at', 'in'))
False
>>> 'a tuple of suffixes'.endswith(('at', 'es'))
True
>>> 'Python is amazing'.endswith('is', 0, 9)
True

startswith() 및 removesuffix() 도 확인하십시오.

str.expandtabs(tabsize=8)¶

현재 열과 주어진 탭 크기에 따라 모든 탭 문자를 하나 이상의 공백으로 교체한 문자열의 복사본을 반환합니다. 탭 위치는 tabsize 문자마다 발생하며(기본값은 8이며, 0, 8, 16 등의 열에 위치함), 문자열을 확장할 때 현재 열은 0으로 설정되고 문자열을 한 문자씩 검사합니다. 해당 문자가 탭(\t)인 경우, 현재 열이 다음 탭 위치와 같아질 때까지 결과에 하나 이상의 공백 문자를 삽입합니다. (탭 문자 자체는 복사되지 않습니다.) 문자가 개행(\n) 또는 리턴(\r)인 경우 복사하고 현재 열을 0으로 재설정합니다. 그 외의 문자는 출력 시 표현 방식과 관계없이 그대로 복사되고 현재 열이 1씩 증가합니다. 예시:

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

str.find(sub[, start[, end]])¶

문자열 s[start:end] 내에서 부분 문자열 sub 가 처음으로 발견되는 가장 낮은 인덱스를 반환합니다. 선택적 인자 start 와 end 는 슬라이스 표기법으로 해석됩니다. sub 을 찾을 수 없으면 -1 을 반환합니다. 예시:

>>> 'spam, spam, spam'.find('sp')
0
>>> 'spam, spam, spam'.find('sp', 5)
6

rfind() 및 index() 도 확인하십시오.

참고

find() 메서드는 sub 의 위치를 알아야 할 때만 사용해야 합니다. sub 이 부분 문자열인지 여부를 확인하려면 in 연산자를 사용하십시오.

>>> 'Py' in 'Python'
True

str.format(*args, **kwargs)¶

문자열 포매팅 연산을 수행합니다. 이 메서드가 호출되는 문자열은 리터럴 텍스트 또는 중괄호 {} 로 구분된 치환 필드를 포함할 수 있습니다. 각 치환 필드는 위치 인자의 숫자 인덱스 또는 키워드 인자의 이름을 포함합니다. 각 치환 필드를 해당 인자의 문자열 값으로 대체한 문자열의 복사본을 반환합니다. 예시:

>>> "The sum of 1 + 2 is {0}".format(1+2)
'The sum of 1 + 2 is 3'
>>> "The sum of {a} + {b} is {answer}".format(answer=1+2, a=1, b=2)
'The sum of 1 + 2 is 3'
>>> "{1} expects the {0} Inquisition!" .format("Spanish", "Nobody")
'Nobody expects the Spanish Inquisition!'

포맷 문자열에서 지정할 수 있는 다양한 포매팅 옵션에 대한 설명은 포맷 문자열 문법 를 참조하십시오.

참고

숫자(int, float, complex, decimal.Decimal 및 하위 클래스)를 n 유형으로 포매팅할 때, 함수는 decimal_point 및 thousands_sep 필드가 비-ASCII이거나 1바이트를 초과하는 경우 localeconv() 를 디코딩하기 위해 일시적으로 LC_CTYPE 로케일을 LC_NUMERIC 로케일로 설정합니다. 이때 LC_NUMERIC 로케일이 LC_CTYPE 로케일과 다른 경우 이 일시적인 변경은 다른 스레드에도 영향을 미칩니다.

버전 3.7에서 변경: 숫자를 n 유형으로 포매팅할 때, 일부 경우에 함수가 일시적으로 LC_CTYPE 로케일을 LC_NUMERIC 로케일로 설정합니다.

str.format_map(mapping, /)¶

str.format(**mapping) 와 유사하지만, mapping 이 직접 사용되며 dict 로 복사되지 않습니다. 이는 예를 들어 mapping 이 dict의 하위 클래스인 경우 유용합니다.

>>> class Default(dict):
...     def __missing__(self, key):
...         return key
...
>>> '{name} was born in {country}'.format_map(Default(name='Guido'))
'Guido was born in country'

Added in version 3.2.

str.index(sub[, start[, end]])¶

find() 와 유사하지만, 부분 문자열을 찾을 수 없는 경우 ValueError 를 발생시킵니다. 예시:

>>> 'spam, spam, spam'.index('spam')
0
>>> 'spam, spam, spam'.index('eggs')
Traceback (most recent call last):
  File "<python-input-0>", line 1, in <module>
    'spam, spam, spam'.index('eggs')
    ~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^
ValueError: substring not found

rindex() 도 확인하십시오.

str.isalnum()¶

문자열의 모든 문자가 알파벳과 숫자이며 적어도 하나 이상의 문자가 있는 경우 True 를 반환하고, 그렇지 않으면 False 를 반환합니다. 문자 c 는 c.isalpha(), c.isdecimal(), c.isdigit() 또는 c.isnumeric() 중 하나라도 True 를 반환하면 알파벳 또는 숫자 문자로 간주됩니다. 예시:

>>> 'abc123'.isalnum()
True
>>> 'abc123!@#'.isalnum()
False
>>> ''.isalnum()
False
>>> ' '.isalnum()
False

str.isalpha()¶

문자열의 모든 문자가 알파벳이고 최소 하나 이상의 문자가 포함되어 있으면 True 를 반환하고, 그렇지 않으면 False 를 반환합니다. 알파벳 문자는 Unicode 문자 데이터베이스에서 “Letter”로 정의된 문자들로, 즉 일반 카테고리 속성이 “Lm”, “Lt”, “Lu”, “Ll”, 또는 “Lo” 중 하나인 문자들입니다. 이는 Unicode 표준의 4.10 ‘Letters, Alphabetic, and Ideographic’ 섹션 <https://www.unicode.org/versions/Unicode18.0.0/core-spec/chapter-4/#G91002>에서 정의된 Alphabetic 속성과는 다릅니다. 예를 들면:

>>> 'Letters and spaces'.isalpha()
False
>>> 'LettersOnly'.isalpha()
True
>>> 'µ'.isalpha()  # 비-ASCII 문자도 알파벳으로 간주될 수 있습니다
True

유니코드 속성 를 참조하십시오.

str.isascii()¶

문자열이 비어 있거나 문자열의 모든 문자가 ASCII인 경우 True 를 반환하고, 그렇지 않으면 False 를 반환합니다. ASCII 문자는 U+0000-U+007F 범위의 코드 포인트를 가집니다. 예시:

>>> 'ASCII characters'.isascii()
True
>>> 'µ'.isascii()
False

Added in version 3.7.

str.isdecimal()¶

문자열의 모든 문자가 십진수 문자이고 적어도 하나 이상의 문자가 있는 경우 True 를 반환하고, 그렇지 않으면 False 를 반환합니다. 십진수 문자는 U+0660(ARABIC-INDIC DIGIT ZERO)과 같이 10진법의 숫자를 형성하는 데 사용될 수 있는 문자들입니다. 공식적으로 십진수 문자는 Unicode 일반 범주 “Nd”에 속하는 문자입니다. 예시:

>>> '0123456789'.isdecimal()
True
>>> '٠١٢٣٤٥٦٧٨٩'.isdecimal()  # 아랍어-인도 숫자 0부터 9까지
True
>>> 'alphabetic'.isdecimal()
False

str.isdigit()¶

문자열 내의 모든 문자가 디짓이고 적어도 하나의 문자가 있는 경우 True 를 돌려주고, 그렇지 않으면 False 를 돌려줍니다. 디짓에는 십진수 문자와 호환성 위 첨자 숫자와 같은 특수 처리가 필요한 숫자가 포함됩니다. 여기에는 카로슈티 숫자와 같이 십진법으로 숫자를 구성할 때 사용될 수 없는 것들이 포함됩니다. 형식적으로, 디짓은 속성값이 Numeric_Type=Digit 또는 Numeric_Type=Decimal인 문자입니다.

예:

>>> '0123456789'.isdigit()
True
>>> '٠١٢٣٤٥٦٧٨٩'.isdigit()  # Arabic-Indic digits zero to nine
True
>>> '⅕'.isdigit()  # Vulgar fraction one fifth
False
>>> '²'.isdecimal(), '²'.isdigit(),  '²'.isnumeric()
(False, True, True)

isdecimal() 및 isnumeric() 을(를) 참조하십시오.

str.isidentifier()¶

문자열이 언어 정의(섹션 이름(식별자 및 키워드))에 따라 유효한 식별자인 경우 True 를 돌려줍니다.

keyword.iskeyword() 을 사용하여 문자열 s 가 def 또는 class 와 같은 예약된 식별자인지 확인할 수 있습니다.

예제:

>>> from keyword import iskeyword

>>> 'hello'.isidentifier(), iskeyword('hello')
(True, False)
>>> 'def'.isidentifier(), iskeyword('def')
(True, True)

str.islower()¶: 문자열 내의 모든 케이스 문자가 [4] 소문자이고 적어도 하나의 케이스 문자가 있는 경우 True 를 반환하고, 그렇지 않으면 False 를 반환합니다.

str.isnumeric()¶

문자열의 모든 문자가 숫자 문자이고 적어도 하나의 문자가 있는 경우 True 를 반환하고, 그렇지 않으면 False 를 반환합니다. 숫자 문자는 디짓(digit) 문자와 유니코드 숫자 값 속성을 가진 모든 문자(예: U+2155, VULGAR FRACTION ONE FIFTH)를 포함합니다. 형식적으로, 숫자 문자는 속성 값이 Numeric_Type=Digit, Numeric_Type=Decimal 또는 Numeric_Type=Numeric인 문자를 말합니다. 예를 들어:

>>> '0123456789'.isnumeric()
True
>>> '٠١٢٣٤٥٦٧٨٩'.isnumeric()  # Arabic-Indic digits zero to nine
True
>>> '⅕'.isnumeric()  # Vulgar fraction one fifth
True
>>> '²'.isdecimal(), '²'.isdigit(),  '²'.isnumeric()
(False, True, True)

isdecimal() 및 isdigit() 도 참조하십시오.

str.isprintable()¶

문자열의 모든 문자가 인쇄 가능하면 True 를 반환하고, 하나 이상의 인쇄 불가능한 문자가 포함된 경우 False 를 반환합니다.

여기서 “인쇄 가능(printable)”은 해당 문자가 repr() 의 출력에 적합함을 의미하며, “인쇄 불가(non-printable)”는 내장 타입에 대한 repr() 이 해당 문자를 16진수 이스케이프(hex-escape)로 처리함을 의미합니다. 이는 sys.stdout 또는 sys.stderr 에 쓰이는 문자열의 처리와는 무관합니다.

인쇄 가능한 문자는 유니코드 문자 데이터베이스(unicodedata 참조)에서 Letter, Mark, Number, Punctuation, Symbol 그룹(L, M, N, P, S) 중 하나에 속하는 문자와 ASCII 스페이스 0x20입니다. 인쇄 불가능한 문자는 ASCII 스페이스를 제외하고 Separator 또는 Other(Z 또는 C) 그룹에 속하는 문자를 말합니다.

예:

>>> ''.isprintable(), ' '.isprintable()
(True, True)
>>> '\t'.isprintable(), '\n'.isprintable()
(False, False)

isspace() 도 참조하십시오.

str.isspace()¶

문자열 내에 공백 문자만 있고 적어도 하나의 문자가 있는 경우 True 를 반환하고, 그렇지 않으면 False 를 반환합니다.

예:

>>> ''.isspace()
False
>>> ' '.isspace()
True
>>> '\t\n'.isspace() # TAB and BREAK LINE
True
>>> '\u3000'.isspace() # IDEOGRAPHIC SPACE
True

유니코드 문자 데이터베이스(unicodedata 참조)에서 특정 문자의 일반 범주가 Zs (“Separator, space”)이거나, 양방향 클래스가 WS, B, 또는 S 중 하나인 경우 해당 문자를 공백(whitespace) 으로 간주합니다.

isprintable() 도 참조하십시오.

str.istitle()¶

문자열이 titlecase 상태이고 적어도 하나의 문자가 있는 경우 True 를 반환합니다. 예를 들어 대문자는 케이스가 없는(uncased) 문자 뒤에만 올 수 있고, 소문자는 케이스가 있는(cased) 문자 뒤에만 올 수 있습니다. 그렇지 않으면 False 를 반환합니다.

예:

>>> 'Spam, Spam, Spam'.istitle()
True
>>> 'spam, spam, spam'.istitle()
False
>>> 'SPAM, SPAM, SPAM'.istitle()
False

title() 도 참조하십시오.

str.isupper()¶

문자열 내의 모든 케이스 문자가 [4] 대문자이고 적어도 하나의 케이스 문자가 있는 경우 True 를 반환하고, 그렇지 않으면 False 를 반환합니다.

>>> 'BANANA'.isupper()
True
>>> 'banana'.isupper()
False
>>> 'baNana'.isupper()
False
>>> ' '.isupper()
False

str.join(iterable, /)¶

iterable 내의 문자열들을 이어 붙인 문자열을 반환합니다. iterable 에 bytes 객체를 포함한 문자열이 아닌 값이 있으면 TypeError 가 발생합니다. 요소 사이의 구분자는 이 메서드를 제공하는 문자열입니다. 예를 들어:

>>> ', '.join(['spam', 'spam', 'spam'])
'spam, spam, spam'
>>> '-'.join('Python')
'P-y-t-h-o-n'

split() 도 참조하십시오.

str.ljust(width, fillchar=' ', /)¶

왼쪽 정렬된 문자열을 길이 width 인 문자열로 반환합니다. 패딩은 지정된 fillchar (기본값은 ASCII 스페이스)를 사용하여 수행됩니다. width 가 len(s) 보다 작거나 같은 경우 원래 문자열이 반환됩니다.

예:

>>> 'Python'.ljust(10)
'Python    '
>>> 'Python'.ljust(10, '.')
'Python....'
>>> 'Monty Python'.ljust(10, '.')
'Monty Python'

rjust() 도 참조하십시오.

str.lower()¶

모든 케이스 문자 [4] 를 소문자로 변환한 문자열의 복사본을 반환합니다. 예를 들어:

>>> 'Lower Method Example'.lower()
'lower method example'

사용된 소문자 변환 알고리즘은 Unicode 표준의 3.13.2 ‘Default Case Conversion’ 섹션 <https://www.unicode.org/versions/Unicode18.0.0/core-spec/chapter-3/#G34078> 에서 설명합니다.

str.lstrip(chars=None, /)¶

선행 문자가 제거된 문자열의 복사본을 반환합니다. chars 인자는 제거할 문자 집합을 지정하는 문자열입니다. 생략되거나 None 인 경우 chars 인자는 공백(즉, str.isspace() 가 참인 문자)을 제거하는 것으로 기본 설정됩니다. chars 인자는 접두사가 아니며, 해당 문자들의 모든 조합이 제거됩니다:

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

문자 집합 전체가 아닌 단일 접두사 문자열을 제거하는 메서드는 str.removeprefix() 를 참조하십시오. 예를 들면:

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

static str.maketrans(dict, /)¶

static str.maketrans(from, to, remove='', /)

이 정적 메서드는 str.translate() 에서 사용할 수 있는 변환 표를 반환합니다.

인자가 하나만 있는 경우, 유니코드 코드 포인트(정수) 또는 문자(길이가 1인 문자열)를 유니코드 코드 포인트, 문자열(임의 길이) 또는 None 으로 매핑하는 딕셔너리여야 합니다. 문자 키는 코드 포인트로 변환됩니다.

인자가 두 개인 경우, 두 인자는 길이가 같은 문자열이어야 하며, 결과 딕셔너리에서 from 의 각 문자는 to 의 동일한 위치에 있는 문자로 매핑됩니다. 세 번째 인자가 있는 경우, 이는 문자열이어야 하며 그 문자들이 결과에서 None 으로 매핑됩니다.

버전 3.15에서 변경: dict 는 이제 frozendict 가 될 수 있습니다.

str.partition(sep, /)¶

sep 이 처음 나타나는 위치에서 문자열을 나누고, 구분자 앞부분, 구분자 자체, 구분자 뒷부분을 포함하는 3-튜플을 반환합니다. 구분자를 찾지 못한 경우, 원본 문자열과 뒤따르는 두 개의 빈 문자열을 포함하는 3-튜플을 반환합니다.

예:

>>> 'Monty Python'.partition(' ')
('Monty', ' ', 'Python')
>>> "Monty Python's Flying Circus".partition(' ')
('Monty', ' ', "Python's Flying Circus")
>>> 'Monty Python'.partition('-')
('Monty Python', '', '')

rpartition() 도 참조하십시오.

str.removeprefix(prefix, /)¶

문자열이 prefix 문자열로 시작하면 string[len(prefix):] 를 반환합니다. 그렇지 않으면 원본 문자열의 사본을 반환합니다:

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

Added in version 3.9.

removesuffix() 및 startswith() 도 참조하십시오.

str.removesuffix(suffix, /)¶

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

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

Added in version 3.9.

removeprefix() 및 endswith() 도 참조하십시오.

str.replace(old, new, /, count=-1)¶

부분 문자열 old 가 나타나는 모든 위치를 new 로 바꾼 문자열의 복사본을 반환합니다. count 가 제공된 경우, 처음 count 번만 바꿉니다. count 가 지정되지 않았거나 -1 인 경우 모든 위치를 바꿉니다. 예를 들어:

>>> 'spam, spam, spam'.replace('spam', 'eggs')
'eggs, eggs, eggs'
>>> 'spam, spam, spam'.replace('spam', 'eggs', 1)
'eggs, spam, spam'

버전 3.13에서 변경: count 가 이제 키워드 인자로 지원됩니다.

str.rfind(sub[, start[, end]])¶

부분 문자열 sub 이 s[start:end] 내에 포함된 위치 중 가장 큰 인덱스를 반환합니다. 선택적 인자 start 와 end 는 슬라이스 표기법으로 해석됩니다. 실패하면 -1 을 반환합니다. 예를 들어:

>>> 'spam, spam, spam'.rfind('sp')
12
>>> 'spam, spam, spam'.rfind('sp', 0, 10)
6

find() 및 rindex() 도 참조하십시오.

str.rindex(sub[, start[, end]])¶

rfind() 와 유사하지만, 부분 문자열 sub 을 찾을 수 없는 경우 ValueError 를 발생시킵니다. 예를 들어:

>>> 'spam, spam, spam'.rindex('spam')
12
>>> 'spam, spam, spam'.rindex('eggs')
Traceback (most recent call last):
  File "<stdin-0>", line 1, in <module>
    'spam, spam, spam'.rindex('eggs')
    ~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^
ValueError: substring not found

index() 및 find() 도 참조하십시오.

str.rjust(width, fillchar=' ', /)¶

오른쪽 정렬된 문자열을 길이 width 인 문자열로 반환합니다. 패딩은 지정된 fillchar (기본값은 ASCII 스페이스)를 사용하여 수행됩니다. width 가 len(s) 보다 작거나 같은 경우 원본 문자열을 반환합니다.

예:

>>> 'Python'.rjust(10)
'    Python'
>>> 'Python'.rjust(10, '.')
'....Python'
>>> 'Monty Python'.rjust(10, '.')
'Monty Python'

ljust() 및 zfill() 도 참조하십시오.

str.rpartition(sep, /)¶

sep 가 마지막으로 나타나는 위치에서 문자열을 나누고, 구분자 앞부분, 구분자 자체, 구분자 뒷부분을 포함하는 3-튜플을 반환합니다. 구분자를 찾을 수 없는 경우, 두 개의 빈 문자열과 문자열 자체를 포함하는 3-튜플을 반환합니다.

예:

>>> 'Monty Python'.rpartition(' ')
('Monty', ' ', 'Python')
>>> "Monty Python's Flying Circus".rpartition(' ')
("Monty Python's Flying", ' ', 'Circurs')
>>> 'Monty Python'.rpartition('-')
('', '', 'Monty Python')

참고: partition().

str.rsplit(sep=None, maxsplit=-1)¶: sep 를 구분자 문자열로 사용하여 문자열 내 단어들의 리스트를 반환합니다. maxsplit 이 지정된 경우, 가장 오른쪽에서 최대 maxsplit 번 분할을 수행합니다. sep 이 지정되지 않거나 None 인 경우, 모든 whitespace 문자열이 구분자로 사용됩니다. 오른쪽에서 분할하는 것을 제외하면, rsplit() 은 아래에서 자세히 설명하는 split() 과 동일하게 동작합니다.

str.rstrip(chars=None, /)¶

후행 문자가 제거된 문자열의 복사본을 반환합니다. chars 인자는 제거할 문자 집합을 지정하는 문자열입니다. 생략되거나 None 인 경우, chars 인자는 기본적으로 공백(즉, str.isspace() 가 참인 문자들)을 제거합니다. chars 인자는 접미사가 아니라, 그 값들의 모든 조합이 제거됩니다. 예시:

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

문자 집합의 모든 것이 아닌 단일 접미사 문자열을 제거하는 메서드는 removesuffix() 를 참조하십시오. 예시:

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

참고: strip().

str.split(sep=None, maxsplit=-1)¶

sep 를 구분자 문자열로 사용하여 문자열 내 단어들의 리스트를 반환합니다. 10:529c53 이 주어진 경우, 최대 maxsplit 번 분할이 수행됩니다(따라서 리스트는 최대 maxsplit+1 개의 요소를 갖습니다). maxsplit 이 지정되지 않거나 -1 인 경우, 분할 횟수에 제한이 없습니다(모든 가능한 분할이 수행됩니다).

sep 이 제공되면 연속된 구분자를 하나로 묶지 않고 빈 문자열을 구분하는 것으로 간주합니다(예: '1,,2'.split(',') 는 ['1', '', '2'] 를 반환). sep 인자는 단일 구분자로서 여러 문자로 구성될 수 있습니다(여러 구분자를 사용하여 분할하려면 re.split() 을 사용하십시오). 지정된 구분자를 사용하여 빈 문자열을 분할하면 [''] 를 반환합니다.

예:

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

sep 이 지정되지 않거나 None 인 경우, 다른 분할 알고리즘이 적용됩니다. 연속된 whitespace 를 단일 구분자로 간주하며, 문자열에 선행 또는 후행 공백이 있어도 결과에 빈 문자열이 포함되지 않습니다. 결과적으로, 빈 문자열이나 공백으로만 구성된 문자열을 None 구분자로 분할하면 [] 를 반환합니다.

예:

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

sep 이 지정되지 않거나 None 이고 maxsplit 이 0 인 경우, 선행 공백 뭉치만 고려됩니다.

예:

>>> "".split(None, 0)
[]
>>> "   ".split(None, 0)
[]
>>> "   foo   ".split(maxsplit=0)
['foo   ']

참고: join() 및 rsplit().

str.splitlines(keepends=False)¶

줄 바꿈에서 구분되는 문자열의 줄 리스트를 반환합니다. keepends 가 제공되고 참인 경우를 제외하고 결과 리스트에 줄 바꿈이 포함되지 않습니다.

이 메서드는 다음과 같은 줄 경계에서 분할을 수행합니다. 특히, 이 경계는 universal newlines 의 상위 집합입니다.

표현	설명
`\n`	Line Feed
`\r`	Carriage Return
`\r\n`	Carriage Return + Line Feed
`\v` 또는 `\x0b`	Line Tabulation
`\f` 또는 `\x0c`	Form Feed
`\x1c`	File Separator
`\x1d`	Group Separator
`\x1e`	Record Separator
`\x85`	Next Line (C1 Control Code)
`\u2028`	Line Separator
`\u2029`	Paragraph Separator

버전 3.2에서 변경: \v 및 \f 이 줄 경계 리스트에 추가됨.

예를 들어:

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

구분자 문자열 sep 이 주어지는 경우의 split() 과 달리, 이 메서드는 빈 문자열에 대해 빈 리스트를 반환하며, 마지막 줄 바꿈이 추가적인 줄을 생성하지 않습니다:

>>> "".splitlines()
[]
>>> "One line\n".splitlines()
['One line']

비교를 위해, split('\n') 은 다음과 같이 동작합니다:

>>> ''.split('\n')
['']
>>> 'Two lines\n'.split('\n')
['Two lines', '']

str.startswith(prefix[, start[, end]])¶

문자열이 prefix 로 시작하면 True 를, 그렇지 않으면 False 를 반환합니다. prefix 는 찾으려는 접두사들의 튜플이 될 수도 있습니다. 선택적 start 가 있으면 해당 위치부터 검사를 시작하고, 선택적 end 가 있으면 해당 위치에서 비교를 중단합니다.

예:

>>> 'Python'.startswith('Py')
True
>>> 'a tuple of prefixes'.startswith(('at', 'a'))
True
>>> 'Python is amazing'.startswith('is', 7)
True

참고: endswith() 및 removeprefix().

str.strip(chars=None, /)¶

Return a copy of the string with the leading and trailing characters removed. The chars argument is a string specifying the set of characters to be removed. If omitted or None, the chars argument defaults to removing whitespace, that is characters for which str.isspace() is true. The chars argument is not a prefix or suffix; rather, all combinations of its values are stripped.

예:

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

가장 바깥쪽의 선행 및 후행 chars 인자 값이 문자열에서 제거됩니다. 문자 집합 chars 에 포함되지 않은 문자에 도달할 때까지 선행 문자를 제거합니다. 후행 문자도 동일한 방식으로 제거됩니다.

예:

>>> comment_string = '#....... Section 3.2.1 Issue #32 .......'
>>> comment_string.strip('.#! ')
'Section 3.2.1 Issue #32'

참고: rstrip().

str.swapcase()¶

대문자를 소문자로, 소문자를 대문자로 변환한 문자열의 복사본을 반환합니다. 예시:

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

s.swapcase().swapcase() == s 가 반드시 성립하는 것은 아님에 주의하십시오. 예시:

>>> 'straße'.swapcase().swapcase()
'strasse'

참고: str.lower() 및 str.upper().

str.title()¶

각 단어의 첫 문자가 대문자이고 나머지 문자가 소문자인 문자열의 타이틀 케이스(titlecase) 버전을 반환합니다.

예를 들어:

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

이 알고리즘은 단어를 연속된 문자의 그룹으로 정의하는 단순한 언어 독립적 정의를 사용합니다. 이 정의는 많은 상황에서 작동하지만, 축약형이나 소유격에 포함된 아포스트로피를 단어 경계로 처리하므로 의도한 결과와 다를 수 있습니다:

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

string.capwords() 함수는 단어를 공백으로만 분리하므로 이 문제를 겪지 않습니다.

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

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

참고: istitle().

str.translate(table, /)¶

주어진 변환 표(translation table)를 통해 각 문자를 매핑한 문자열의 복사본을 반환합니다. 변환 표는 __getitem__() 을 통해 인덱싱이 가능한 객체여야 하며, 일반적으로 mapping 또는 sequence 입니다. 유니코드 서수(정수)로 인덱싱될 때, 변환 표 객체는 다음과 같은 동작을 수행할 수 있습니다. 문자를 하나 이상의 다른 문자로 매핑하기 위해 유니코드 서수나 문자열을 반환하거나, 결과 문자열에서 문자를 삭제하기 위해 None 을 반환하거나, 문자를 자기 자신으로 매핑하기 위해 LookupError 예외를 발생시킬 수 있습니다.

다양한 형식의 문자와 문자 간 매핑을 기반으로 변환 맵을 생성하려면 str.maketrans() 를 사용할 수 있습니다.

다음 예제는 매핑을 사용하여 'a' 를 'X' 로, 'b' 를 'Y' 로 교체하고 'c' 를 삭제하는 방법을 보여줍니다.

>>> 'abc123'.translate({ord('a'): 'X', ord('b'): 'Y', ord('c'): None})
'XY123'

사용자 정의 문자 매핑을 위한 보다 유연한 접근 방식에 대해서는 codecs 모듈을 참조하십시오.

str.upper()¶

모든 대소문자 구분 가능 문자 [4] 를 대문자로 변환한 문자열의 복사본을 반환합니다. `s 가 대소문자를 구분하지 않는 문자를 포함하거나, 결과 문자의 유니코드 카테고리가 “Lu”(Letter, uppercase)가 아니라 예를 들어 “Lt”(Letter, titlecase)인 경우 s.upper().isupper() 는 False 가 될 수 있음에 유의하십시오.

사용된 대문자 변환 알고리즘은 Unicode 표준의 3.13.2 ‘Default Case Conversion’ 섹션 <https://www.unicode.org/versions/Unicode18.0.0/core-spec/chapter-3/#G34078> 에서 설명합니다.

str.zfill(width, /)¶

문자열의 길이를 width 로 만들기 위해 왼쪽에 ASCII '0' 숫자를 채운 문자열의 복사본을 반환합니다. 선행 부호 접두어('+'/'-')는 부호 문자 앞이 아니라 뒤 에 채우기를 삽입하는 방식으로 처리됩니다. width 가 len(s) 보다 작거나 같은 경우 원래 문자열을 반환합니다.

예:

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

rjust() 도 참조하십시오.

포맷 문자열 리터럴 (f-strings)¶

Added in version 3.6.

버전 3.7에서 변경: f-strings 내의 표현식에서 await 및 async for 를 사용할 수 있습니다.

버전 3.8에서 변경: 디버그 지정자(=) 추가

버전 3.12에서 변경: f-strings 내 표현식에 대한 많은 제한이 제거되었습니다. 특히, 중첩된 문자열, 주석, 백슬래시가 이제 허용됩니다.

An f-string (formally a formatted string literal) is a string literal that is prefixed with f or F. This type of string literal allows embedding the results of arbitrary Python expressions within replacement fields, which are delimited by curly brackets ({}). Each replacement field must contain an expression, optionally followed by:

한 개의 디버그 지정자 – 등호(=);
한 개의 변환 지정자 – !s, !r 또는 !a; 그리고/또는
콜론(:)으로 시작하는 포맷 지정자.

이 필드들의 구문에 대한 자세한 내용은 f-strings의 구문 분석 섹션 을 참조하십시오.

디버그 지정자¶

Added in version 3.8.

치환 필드 표현식 뒤에 디버그 지정자(등호 =)가 나타나면, 결과 f-string에는 표현식의 소스, 등호, 그리고 표현식의 값이 포함됩니다. 이는 디버깅에 유용할 때가 많습니다:

>>> number = 14.3
>>> f'{number=}'
'number=14.3'

표현식의 앞, 안, 뒤의 공백과 등호 뒤의 공백은 의미를 가지며 결과에 그대로 유지됩니다:

>>> f'{ number  -  4  = }'
' number  -  4  = 10.3'

변환 지정자¶

기본적으로 치환 필드 표현식의 값은 str() 을 사용하여 문자열로 변환됩니다:

>>> from fractions import Fraction
>>> one_third = Fraction(1, 3)
>>> f'{one_third}'
'1/3'

디버그 지정자는 사용하고 포맷 지정자는 사용하지 않는 경우, 기본 변환 대신 repr() 을 사용합니다:

>>> f'{one_third = }'
'one_third = Fraction(1, 3)'

변환은 다음 중 하나를 사용하여 명시적으로 지정할 수 있습니다:

!s 는 str() 을 위해 사용됩니다.
!r 은 repr() 을 위해 사용됩니다.
!a 는 ascii() 를 위해 사용됩니다.

예를 들어:

>>> str(one_third)
'1/3'
>>> repr(one_third)
'Fraction(1, 3)'

>>> f'{one_third!s} is {1f_r}'
'1/3 is Fraction(1, 3)'

>>> string = "¡kočka 😸!"
>>> ascii(string)
"'\\xa1ko\\u010dka \\U0001f638!'"

>>> f'{string = !a}'
"string = '\\xa1ko\\u010dka \\U0001f638!'"

포맷 지정자¶

표현식이 평가된 후, 명시적인 변환 지정자를 사용하여 변환될 수도 있으며, format() 함수를 사용하여 포매팅됩니다. 치환 필드에 콜론(:)으로 시작하는 포맷 지정자 가 포함된 경우, 해당 지정자는 format() 의 두 번째 인자로 전달됩니다. 그 후 format() 의 결과가 치환 필드의 최종 값으로 사용됩니다. 예시:

>>> from fractions import Fraction
>>> one_third = Fraction(1, 3)
>>> f'{one_third:.6f}'
'0.333333'
>>> f'{one_third:_^+10}'
'___+1/3___'
>>> f'{one_third!r:_^20}'
'___Fraction(1, 3)___'
>>> f'{one_third = :~>10}~'
'one_third = ~~~~~~~1/3~'

템플릿 문자열 리터럴 (t-strings)¶

A t-string (formally a template string literal) is a string literal that is prefixed with t or T.

이 문자열들은 포맷 문자열 리터럴 과 동일한 구문 및 평가 규칙을 따르지만, 다음과 같은 차이점이 있습니다.

템플릿 문자열 리터럴은 str 객체로 평가되는 대신, string.templatelib.Template 객체로 평가됩니다.
여기서는 format() 프로토콜을 사용하지 않습니다. 대신, 포맷 지정자와 변환(있는 경우)은 각 평가된 표현물에 대해 생성된 새로운 Interpolation 객체로 전달됩니다. 결과로 생성된 Template 객체를 처리하는 코드에서 포맷 지정자와 변환을 처리하는 방식을 결정합니다.
중첩된 치환 필드를 포함하는 포맷 지정자는 Interpolation 객체로 전달되기 전에 즉시 평가됩니다. 예를 들어, {amount:.{precision}f} 형태의 인터폴레이션은 format_spec 속성의 값을 결정하기 위해 내부 표현식인 {precision} 을 평가합니다. 만약 precision 이 2 라면, 결과 포맷 지정자는 '.2f' 가 됩니다.
인터폴레이션 표현식에 등호 '=' 가 제공되면, 표현식의 텍스트가 관련 인터폴레이션 앞의 리터럴 문자열에 추가됩니다. 여기에는 등호와 주변의 공백이 포함됩니다. 해당 표현식에 대한 Interpolation 인스턴스는 정상적으로 생성되지만, conversion 은 기본적으로 'r' (repr())로 설정됩니다. 명시적인 변환이나 포맷 지정자가 제공되는 경우, 이 기본 동작이 덮어씌워집니다.

`printf` 스타일 문자열 포매팅¶

참고

여기에서 설명하는 포매팅 연산은 튜플과 딕셔너리를 올바르게 표시하지 못하는 것과 같은 몇 가지 흔한 오류를 유발하는 다양한 특징들이 있습니다.

포맷 문자열 리터럴, str.format() 인터페이스 또는 string.Template 을 사용하면 이러한 오류를 피하는 데 도움이 될 수 있습니다. 이들 대안은 각각의 장단점이 있으며, 단순성, 유연성 및/또는 확장성 면에서 이점이 있습니다.

문자열 객체에는 고유한 내장 연산이 하나 있습니다. 바로 % 연산자(모듈로)입니다. 이것은 문자열 포매팅 또는 보간(interpolation) 연산자로도 알려져 있습니다. format % values (여기서 format 은 문자열입니다)가 주어지면, format 내의 % 변환 명세가 values 의 0개 이상의 요소로 대체됩니다. 이 효과는 C 언어의 sprintf() 함수를 사용하는 것과 유사합니다. 예:

>>> print('%s has %d quote types.' % ('Python', 2))
Python has 2 quote types.

format 이 단일 인수를 요구하는 경우, values 는 단일 비 튜플 객체일 수 있습니다. [5] 그렇지 않으면, values 는 포맷 문자열에 의해 명시된 항목 수와 정확히 일치하는 튜플이거나 단일 매핑 객체(예를 들어, 딕셔너리)여야 합니다.

변환 지정자는 두 개 이상의 문자로 구성되며, 다음 순서대로 구성되는 요소를 포함합니다:

지정자의 시작을 표시하는 '%' 문자.
매핑 키 (선택 사항): 괄호로 둘러싸인 문자 시퀀스로 구성됩니다 (예를 들어, (somename)).
변환 플래그 (선택 사항): 일부 변환 유형의 결과에 영향을 줍니다.
최소 필드 폭 (선택 사항): '*' (애스터리스크)로 지정된 경우, 실제 폭은 values 튜플의 다음 요소에서 읽히며, 변환할 객체는 최소 필드 폭과 선택적 정밀도 뒤에 위치합니다.
정밀도 (선택 사항): '.' (점) 뒤에 정밀도가 옵니다. '*' (애스터리스크)로 지정된 경우, 실제 정밀도는 values 튜플의 다음 요소에서 읽히며, 변환할 값은 정밀도 뒤에 위치합니다.
길이 수정자 (선택 사항).
변환 유형.

오른쪽 인자가 딕셔너리(또는 다른 매핑 형식)인 경우, 문자열의 포맷은 반드시 '%' 문자 바로 뒤에 해당 딕셔너리의 매핑 키를 괄호로 묶은 형태로 포함해야 합니다. 매핑 키는 매핑에서 포맷할 값을 선택합니다. 예:

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

이 경우, 포맷에서 * 지정자는 나타날 수 없습니다(연속적인 매개변수 목록이 필요하기 때문입니다).

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

플래그	Meaning
`'#'`	값 변환 시 “대체 형식”(아래에 정의됨)을 사용합니다.
`'0'`	숫자 값에 대해서는 0으로 채워진(zero padded) 변환이 이루어집니다.
`'-'`	변환된 값은 왼쪽으로 정렬됩니다(두 옵션이 모두 주어질 경우 `'0'` 변환보다 우선합니다).
`' '`	(공백) 부호 있는 변환으로 생성된 양수(또는 빈 문자열) 앞에는 공백이 남겨져야 합니다.
`'+'`	부호 문자(`'+'` 또는 `'-'`)가 변환 앞에 위치합니다(“공백” 플래그에 우선합니다).

길이 수정자(h, l, 또는 L)가 포함될 수 있지만, Python에서는 필요하지 않으므로 무시됩니다. 예를 들어 %ld 는 %d 와 동일합니다.

변환 유형은 다음과 같습니다:

변환	Meaning	Notes
`'d'`	부호 있는 10진 정수.
`'i'`	부호 있는 10진 정수.
`'o'`	부호 있는 8진수.	(1)
`'u'`	더 이상 사용되지 않는 유형(deprecated)으로, `'d'` 와 동일합니다.	(6)
`'x'`	부호 있는 16진수(소문자).	(2)
`'X'`	부호 있는 16진수(대문자).	(2)
`'e'`	부동 소수점 지수 표기법(소문자).	(3)
`'E'`	부동 소수점 지수 표기법(대문자).	(3)
`'f'`	부동 소수점 10진수 표기법.	(3)
`'F'`	부동 소수점 10진수 표기법.	(3)
`'g'`	부동 소수점 표기법. 지수가 -4보다 작거나 정밀도(precision)보다 작지 않으면 소문자 지수 표기법을 사용하고, 그렇지 않으면 10진수 표기법을 사용합니다.	(4)
`'G'`	부동 소수점 표기법. 지수가 -4보다 작거나 정밀도(precision)보다 작지 않으면 대문자 지수 표기법을 사용하고, 그렇지 않으면 10진수 표기법을 사용합니다.	(4)
`'c'`	단일 문자(정수 또는 단일 문자 문자열을 수용).
`'r'`	문자열(`repr()` 을 사용하여 모든 Python 객체를 변환).	(5)
`'s'`	문자열(`str()` 을 사용하여 모든 Python 객체를 변환).	(5)
`'a'`	문자열(`ascii()` 를 사용하여 모든 Python 객체를 변환).	(5)
`'%'`	인수가 변환되지 않으며, 결과에 `'%'` 문자가 포함됩니다.

부동 소수점 형식의 경우, 결과는 소수점 뒤의 정밀도 p 에 맞춰 올바르게 반올림되어야 합니다. 반올림 방식은 내장 함수 round() 와 동일합니다.

Notes:

대체 형식을 사용하면 첫 번째 숫자 앞에 8진수 지정자('0o')가 삽입됩니다.
대체 형식을 사용하면 첫 번째 숫자 앞에 '0x' 또는 '0X'``(‘x’`` 또는 'X' 형식을 사용했는지에 따라 다름)가 삽입됩니다.
대체 형식을 사용하면 뒤에 숫자가 없더라도 결과에 항상 소수점이 포함됩니다.

정밀도는 소수점 뒤의 자릿수를 결정하며 기본값은 6입니다.
대체 형식을 사용하면 결과에 항상 소수점이 포함되며, 일반적으로 제거되는 마지막의 0이 제거되지 않습니다.

정밀도는 소수점 앞과 뒤의 유효 자릿수를 결정하며 기본값은 6입니다.
정밀도가 N 인 경우, 출력은 N 자로 절사됩니다.
자세한 내용은 PEP 237 을 참조하십시오.

Python 문자열은 명시적인 길이를 가지므로, %s 변환 시 '\0' 을 문자열의 끝으로 간주하지 않습니다.

버전 3.1에서 변경: 절대값이 1e50을 넘는 숫자에 대한 %f 변환이 더 이상 %g 변환으로 대체되지 않습니다.

바이트 시퀀스 타입 — `bytes`, `bytearray`, `memoryview`¶

바이너리 데이터를 조작하기 위한 핵심 내장 타입은 bytes 와 bytearray 입니다. 이들은 다른 바이너리 객체의 메모리에 접근할 때 복사본을 만들 필요가 없는 buffer protocol 를 사용하는 memoryview 에 의해 지원됩니다.

the array 모듈은 32비트 정수 및 IEEE754 배정밀도 부동 소수점 값과 같은 기본 데이터 유형을 효율적으로 저장하는 기능을 지원합니다.

바이트 객체¶

바이트 객체는 단일 바이트의 불변 시퀀스입니다. 많은 주요 바이너리 프로토콜이 ASCII 텍스트 인코딩을 기반으로 하기 때문에, 바이트 객체는 ASCII 호환 데이터와 작업할 때만 유효한 여러 메서드를 제공하며 여러 방식으로 문자열 객체와 밀접하게 관련되어 있습니다.

class bytes(source=b'')¶

class bytes(source, encoding, errors='strict')

먼저, 바이트 리터럴의 구문은 문자열 리터럴과 거의 동일하지만, b 접두사가 추가됩니다:

작은따옴표: b'still allows embedded "double" quotes'
큰따옴표: b"still allows embedded 'single' quotes"
삼중 따옴표: b'''3 single quotes''', b"""3 double quotes"""

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

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

바이트 리터럴과 표현은 ASCII 텍스트를 기반으로 하지만, 바이트 객체는 실제로 정수의 불변 시퀀스처럼 동작하며, 시퀀스의 각 값은 0 <= x < 256 범위로 제한됩니다(이 제한을 위반하려는 시도는 ValueError 를 발생시킵니다). 이는 많은 바이너리 형식이 ASCII 기반 요소를 포함하고 일부 텍스트 지향 알고리즘으로 유용하게 조작될 수 있지만, 임의의 바이너리 데이터의 경우 일반적으로 그렇지 않다는 점을 강조하기 위해 의도적으로 설계된 것입니다(ASCII 호환이 아닌 바이너리 데이터 형식에 텍스트 처리 알고리즘을 무분별하게 적용하면 대개 데이터 손상으로 이어집니다).

리터럴 형태 외에도 바이트 객체는 여러 가지 방법으로 생성될 수 있습니다:

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

또한 bytes 내장 함수도 참조하십시오.

2개의 16진수 자리가 정확히 1바이트에 대응하므로, 16진수는 바이너리 데이터를 기술하는 데 흔히 사용되는 형식입니다. 이에 따라, 바이트(bytes) 타입은 해당 형식으로 데이터를 읽는 추가 클래스 메서드를 제공합니다:

classmethod fromhex(string, /)¶

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

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

버전 3.7에서 변경: bytes.fromhex() now skips all ASCII whitespace in the string, not just spaces.

버전 3.14에서 변경: bytes.fromhex() now accepts ASCII bytes and bytes-like objects as input.

바이트 객체를 16진수 표현으로 변환하는 역변환 함수가 있습니다.

hex(*, bytes_per_sep=1)¶

hex(sep, bytes_per_sep=1)

인스턴스의 각 바이트에 대해 두 개의 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'

Added in version 3.5.

버전 3.8에서 변경: bytes.hex() now supports optional sep and bytes_per_sep parameters to insert separators between bytes in the hex output.

bytes 객체는 정수의 시퀀스(튜플과 유사)이기 때문에, bytes 객체 b 에 대해 b[0] 은 정수가 되고, b[0:1] 은 길이가 1인 bytes 객체가 됩니다. (이는 인덱싱과 슬라이싱 모두 길이가 1인 문자열을 생성하는 텍스트 문자열과 대조됩니다)

bytes 객체의 표현은 bytes([46, 46, 46]) 보다 종종 더 유용하기 때문에 리터럴 형식(b'...')을 사용합니다. list(b) 를 사용하여 bytes 객체를 정수 리스트로 항상 변환할 수 있습니다.

bytearray 객체¶

bytearray 객체는 bytes 객체의 가변(mutable)에 대응하는 객체입니다.

class bytearray(source=b'')¶

class bytearray(source, encoding, errors='strict')

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

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

As bytearray objects are mutable, they support the mutable sequence operations in addition to the common bytes and bytearray operations described in Bytes 및 Bytearray 연산.

또한 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 공백을 무시합니다.

버전 3.14에서 변경: bytearray.fromhex() 는 이제 ASCII bytes 및 bytes-like objects 를 입력으로 수용합니다.

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

hex(*, bytes_per_sep=1)¶

hex(sep, bytes_per_sep=1)

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

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

Added in version 3.5.

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

resize(size, /)¶

내부 버퍼를 size 바이트를 포함하도록 bytearray 크기를 조정합니다. size 는 0보다 크거나 같아야 합니다.

bytearray 의 크기를 줄여야 하는 경우, size 를 초과하는 바이트는 잘려 나갑니다.

bytearray 의 크기를 늘려야 하는 경우, size 를 초과하는 모든 새로운 바이트는 널 바이트(null bytes)로 설정됩니다.

이것은 다음 코드와 동일합니다:

>>> def resize(ba, size):
...     if len(ba) > size:
...         del ba[size:]
...     else:
...         ba += b'\0' * (size - len(ba))

예제:

>>> shrink = bytearray(b'abc')
>>> shrink.resize(1)
>>> (shrink, len(shrink))
(bytearray(b'a'), 1)
>>> grow = bytearray(b'abc')
>>> grow.resize(5)
>>> (grow, len(grow))
(bytearray(b'abc\x00\x00'), 5)

Added in version 3.14.

take_bytes(n=None, /)¶

bytearray에서 첫 n 바이트를 제거하고 이를 불변(immutable) bytes 로 반환합니다. 기본값으로(즉, n 이 None 인 경우), 모든 바이트를 반환하고 bytearray를 비웁니다.

n 이 음수이면 끝에서부터 인덱스를 계산하여 첫 len() + n 바이트를 가져옵니다. n 이 범위를 벗어나면 IndexError 를 발생시킵니다.

전체 길이보다 적게 가져올 경우 남은 바이트가 bytearray 에 남게 되며, 이를 처리하려면 복사가 필요합니다. 남은 바이트를 버려야 하는 경우, resize() 를 사용하거나 del 을 사용하여 크기를 줄인 후 인자 없는 take_bytes() 를 사용하십시오.

모든 바이트를 가져오는 것은 제로 카피(zero-copy) 작업입니다.

Added in version 3.15: bytearray.take_bytes() 를 사용하여 최적화할 수 있는 일반적인 코드 패턴은 What’s New 항목을 참조하십시오.

bytearray 객체는 정수의 시퀀스(리스트와 유사)이기 때문에, bytearray 객체 b 에 대해 b[0] 은 정수가 되고, b[0:1] 은 길이가 1인 bytearray 객체가 됩니다. (이것은 인덱싱과 슬라이싱 모두 길이가 1인 문자열을 생성하는 텍스트 문자열과 대조됩니다)

bytearray 객체의 표현은 bytearray([46, 46, 46]) 보다 종종 더 유용하기 때문에 바이트 리터럴 형식(bytearray(b'...'))을 사용합니다. list(b) 를 사용하면 bytearray 객체를 항상 정수 리스트로 변환할 수 있습니다.

bytearray 객체의 스레드 안전성 보장에 대한 자세한 정보는 bytearray 객체의 스레드 안전성 를 참조하십시오.

Bytes 및 Bytearray 연산¶

bytes와 bytearray 객체 모두 common 시퀀스 연산을 지원합니다. 이들은 동일한 유형의 피연산자뿐만 아니라 모든 bytes-like object 와도 상호 운용됩니다. 이러한 유연성 덕분에 오류 없이 연산에 자유롭게 혼합하여 사용할 수 있습니다. 다만, 결과의 반환 유형은 피연산자의 순서에 따라 달라질 수 있습니다.

참고

bytes 및 bytearray 객체의 메서드는 문자열을 인자로 받지 않으며, 이는 문자열 메서드가 bytes를 인자로 받지 않는 것과 같습니다. 예를 들어, 다음과 같이 작성해야 합니다.

a = "abc"
b = a.replace("a", "f")

그리고:

a = b"abc"
b = a.replace(b"a", b"f")

일부 bytes 및 bytearray 연산은 ASCII 호환 바이너리 형식을 사용하는 것을 가정하므로, 임의의 바이너리 데이터를 다룰 때는 피해야 합니다. 이러한 제한 사항은 아래에서 다룹니다.

참고

ASCII 기반 형식이 아닌 바이너리 데이터를 조작하기 위해 이러한 ASCII 기반 연산을 사용하면 데이터가 손상될 수 있습니다.

다음 bytes 및 bytearray 객체 메서드들은 임의의 바이너리 데이터와 함께 사용할 수 있습니다.

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

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

[start, end] 범위 내에서 중복되지 않는 하위 시퀀스 sub 의 발생 횟수를 반환합니다. 선택적 인자 start 및 end 는 슬라이스 표기법에 따라 해석됩니다.

검색할 하위 시퀀스는 임의의 bytes-like object 또는 0에서 255 사이의 정수일 수 있습니다.

sub 이 비어 있는 경우, 문자 사이의 빈 슬라이스 개수를 반환하며, 이는 bytes 객체의 길이에 1을 더한 값입니다.

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

bytes.removeprefix(prefix, /)¶

bytearray.removeprefix(prefix, /)¶

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

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

prefix 는 임의의 bytes-like object 일 수 있습니다.

참고

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

Added in version 3.9.

bytes.removesuffix(suffix, /)¶

bytearray.removesuffix(suffix, /)¶

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

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

suffix 는 임의의 bytes-like object 일 수 있습니다.

참고

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

Added in version 3.9.

bytes.decode(encoding='utf-8', errors='strict')¶

bytearray.decode(encoding='utf-8', errors='strict')¶

bytes를 str 로 디코딩하여 반환합니다.

encoding 은 기본값으로 'utf-8' 을 사용합니다. 가능한 값은 표준 인코딩 를 참조하십시오.

errors 는 디코딩 오류 발생 시 처리 방식을 제어합니다. 'strict' (기본값)인 경우 UnicodeError 예외가 발생합니다. 다른 가능한 값은 'ignore', 'replace', 그리고 codecs.register_error() 를 통해 등록된 다른 이름들입니다. 자세한 내용은 에러 처리기 를 참조하십시오.

성능상의 이유로, 실제 디코딩 오류가 발생하거나, 파이썬 개발 모드 가 활성화되어 있거나, debug build 를 사용하는 경우가 아니면 errors 값의 유효성을 검사하지 않습니다.

참고

str 에 encoding 인자를 전달하면 임시 bytes 또는 bytearray 객체를 생성할 필요 없이 임의의 bytes-like object 를 직접 디코딩할 수 있습니다.

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

버전 3.9에서 변경: 이제 파이썬 개발 모드 와 debug mode 에서 errors 인자의 값을 확인합니다.

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

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

바이너리 데이터가 지정된 suffix 로 끝나면 True 를 반환하고, 그렇지 않으면 False 를 반환합니다. suffix 는 찾고자 하는 접두사들의 튜플이 될 수도 있습니다. 선택적 start 가 있으면 해당 위치부터 검사를 시작하고, 선택적 end 가 있으면 해당 위치에서 비교를 중단합니다.

검색할 suffix(들)은 임의의 bytes-like object 일 수 있습니다.

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

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

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

검색할 하위 시퀀스는 임의의 bytes-like object 또는 0에서 255 사이의 정수일 수 있습니다.

참고

find() 메서드는 sub 의 위치를 알아야 할 경우에만 사용해야 합니다. sub 이 부분 문자열인지 확인하려면 in 연산자를 사용하십시오:

>>> b'Py' in b'Python'
True

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

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

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

find() 와 유사하지만, 하위 시퀀스를 찾을 수 없는 경우 ValueError 를 발생시킵니다.

검색할 하위 시퀀스는 임의의 bytes-like object 또는 0에서 255 사이의 정수일 수 있습니다.

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

bytes.join(iterable, /)¶
bytearray.join(iterable, /)¶: iterable 에 있는 바이너리 데이터 시퀀스들을 연결한 bytes 또는 bytearray 객체를 반환합니다. iterable 에 str 객체를 포함하여 bytes-like objects 가 아닌 값이 있으면 TypeError 가 발생합니다. 요소들 사이의 구분자는 이 메서드를 제공하는 bytes 또는 bytearray 객체의 내용입니다.

static bytes.maketrans(from, to, /)¶
static bytearray.maketrans(from, to, /)¶: 이 정적 메서드는 from 의 각 문자를 to 의 동일한 위치에 있는 문자로 매핑하는 bytes.translate() 에서 사용할 수 있는 변환 테이블을 반환합니다. from 과 to 는 모두 bytes-like objects 여야 하며 길이가 같아야 합니다.

Added in version 3.1.

bytes.partition(sep, /)¶

bytearray.partition(sep, /)¶

sep 이 처음 나타나는 위치에서 시퀀스를 분할하고, 구분자 앞의 부분, 구분자 자체 또는 그 bytearray 복사본, 구분자 뒤의 부분으로 구성된 3-튜플을 반환합니다. 구분자를 찾을 수 없으면 원본 시퀀스의 복사본과 두 개의 빈 bytes 또는 bytearray 객체로 구성된 3-튜플을 반환합니다.

검색할 구분자는 임의의 bytes-like object 일 수 있습니다.

bytes.replace(old, new, /, count=-1)¶

bytearray.replace(old, new, /, count=-1)¶

서브 시퀀스 old 를 new 로 치환한 시퀀스의 복사본을 반환합니다. count 가 제공되면 처음 count 개의 발생 사례만 치환됩니다. count 가 지정되지 않거나 -1 인 경우 모든 발생 사례가 치환됩니다.

검색할 서브 시퀀스와 치환될 시퀀스는 임의의 bytes-like object 일 수 있습니다.

참고

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

버전 3.15에서 변경: count 가 이제 키워드 인자로 지원됩니다.

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

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

서브 시퀀스 sub 이 s[start:end] 내에 포함되는 시퀀스 내의 가장 높은 인덱스를 반환합니다. 선택적 인자 start 와 end 는 슬라이스 표기법과 동일하게 해석됩니다. 실패 시 -1 을 반환합니다.

검색할 하위 시퀀스는 임의의 bytes-like object 또는 0에서 255 사이의 정수일 수 있습니다.

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

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

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

rfind() 와 유사하지만 서브 시퀀스 sub 을 찾을 수 없는 경우 ValueError 를 발생시킵니다.

검색할 하위 시퀀스는 임의의 bytes-like object 또는 0에서 255 사이의 정수일 수 있습니다.

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

bytes.rpartition(sep, /)¶

bytearray.rpartition(sep, /)¶

sep 이 마지막으로 나타나는 위치에서 시퀀스를 분할하고, 구분자 앞의 부분, 구분자 자체 또는 그 bytearray 복사본, 구분자 뒤의 부분으로 구성된 3-튜플을 반환합니다. 구분자를 찾을 수 없으면 두 개의 빈 bytes 또는 bytearray 객체와 그 뒤를 따르는 원본 시퀀스의 복사본으로 구성된 3-튜플을 반환합니다.

검색할 구분자는 임의의 bytes-like object 일 수 있습니다.

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

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

바이너리 데이터가 지정된 prefix 로 시작하면 True 를 반환하고, 그렇지 않으면 False 를 반환합니다. prefix 는 찾으려는 접두사들의 튜플이 될 수도 있습니다. 선택적 start 가 있으면 해당 위치부터 테스트하며, 선택적 end 가 있으면 해당 위치에서 비교를 중단합니다.

검색할 접두사(들)는 임의의 bytes-like object 일 수 있습니다.

bytes.translate(table, /, delete=b'')¶

bytearray.translate(table, /, delete=b'')¶

선택적 인자 delete 에 포함된 모든 바이트를 제거하고, 나머지 바이트를 길이가 256인 바이트 객체여야 하는 주어진 변환 테이블을 통해 매핑한 bytes 또는 bytearray 객체의 복사본을 반환합니다.

변환 테이블을 생성하려면 bytes.maketrans() 메서드를 사용할 수 있습니다.

문자만 삭제하는 변환의 경우 table 인자를 None 으로 설정하십시오:

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

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

bytes 및 bytearray 객체에 대한 다음 메서드들은 ASCII 호환 바이너리 형식을 사용하는 것을 가정하는 기본 동작을 가지지만, 적절한 인자를 전달하면 임의의 바이너리 데이터와 함께 사용할 수 있습니다. 이 섹션의 bytearray 메서드들은 모두 제자리(in-place)에서 작동하지 않고 대신 새로운 객체를 생성한다는 점에 유의하십시오.

bytes.center(width, fillbyte=b' ', /)¶
bytearray.center(width, fillbyte=b' ', /)¶: 길이 width 인 시퀀스의 중앙에 정렬된 객체의 복사본을 반환합니다. 여백은 지정된 fillbyte 를 사용하여 채웁니다(기본값은 ASCII 공백). bytes 객체의 경우, width 가 len(s) 보다 작거나 같으면 원래 시퀀스가 반환됩니다.

참고

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

bytes.ljust(width, fillbyte=b' ', /)¶
bytearray.ljust(width, fillbyte=b' ', /)¶: 길이 width 인 시퀀스에서 왼쪽으로 정렬된 객체의 복사본을 반환합니다. 여백은 지정된 fillbyte 를 사용하여 채웁니다(기본값은 ASCII 공백). bytes 객체의 경우, width 가 len(s) 보다 작거나 같으면 원래 시퀀스가 반환됩니다.

참고

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

bytes.lstrip(bytes=None, /)¶

bytearray.lstrip(bytes=None, /)¶

지정된 선행 바이트를 제거한 시퀀스의 복사본을 반환합니다. bytes 인자는 제거할 바이트 값의 집합을 지정하는 바이너리 시퀀스입니다. 생략하거나 None 인 경우, bytes 인자는 기본적으로 ASCII whitespace 를 제거합니다. bytes 인자는 접두사가 아니며, 대신 그 값들의 모든 조합이 제거됩니다:

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

제거할 바이트 값의 바이너리 시퀀스는 임의의 bytes-like object 일 수 있습니다. 문자 집합의 모든 값이 아닌 단일 접두사 문자열을 제거하는 메서드는 removeprefix() 를 참조하십시오. 예를 들면:

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

참고

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

bytes.rjust(width, fillbyte=b' ', /)¶
bytearray.rjust(width, fillbyte=b' ', /)¶: 길이 width 인 시퀀스에서 오른쪽으로 정렬된 객체의 복사본을 반환합니다. 여백은 지정된 fillbyte 를 사용하여 채웁니다(기본값은 ASCII 공백). bytes 객체의 경우, width 가 len(s) 보다 작거나 같으면 원래 시퀀스가 반환됩니다.

참고

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

bytes.rsplit(sep=None, maxsplit=-1)¶
bytearray.rsplit(sep=None, maxsplit=-1)¶: Split the binary sequence into subsequences of the same type, using sep as the delimiter string. If maxsplit is given, at most maxsplit splits are done, the rightmost ones. If sep is not specified or None, any subsequence consisting solely of ASCII whitespace is a separator. Except for splitting from the right, rsplit() behaves like split() which is described in detail below.

bytes.rstrip(bytes=None, /)¶

bytearray.rstrip(bytes=None, /)¶

지정된 후행 바이트를 제거한 시퀀스의 복사본을 반환합니다. bytes 인자는 제거할 바이트 값의 집합을 지정하는 바이너리 시퀀스입니다. 생략하거나 None 인 경우, bytes 인자는 기본적으로 ASCII whitespace 를 제거합니다. bytes 인자는 접미사가 아니며, 대신 그 값들의 모든 조합이 제거됩니다:

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

제거할 바이트 값의 바이너리 시퀀스는 임의의 bytes-like object 일 수 있습니다. 문자 집합의 모든 것이 아닌 단일 접미사 문자열을 제거하는 메서드는 removesuffix() 를 참조하십시오. 예를 들면:

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

참고

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

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

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

sep 을 구분자 시퀀스로 사용하여 바이너리 시퀀스를 동일한 유형의 서브 시퀀스로 분할합니다. maxsplit 이 제공되고 0이 아니면, 최대 maxsplit 번 분할이 수행됩니다(따라서 목록은 최대 maxsplit+1 개의 요소를 갖게 됩니다). maxsplit 이 지정되지 않거나 -1 인 경우, 분할 횟수에 제한이 없습니다(모든 가능한 분할이 수행됩니다).

sep 이 제공되면 연속된 구분자가 함께 묶이지 않고 빈 서브 시퀀스를 구분하는 것으로 간주됩니다(예를 들어, b'1,,2'.split(b',') 은 [b'1', b'', b'2'] 를 반환합니다). sep 인자는 단일 구분자로 구성된 멀티바이트 시퀀스일 수 있습니다. 지정된 구분자를 사용하여 빈 시퀀스를 분할하면, 분할되는 객체의 유형에 따라 [b''] 또는 [bytearray(b'')] 를 반환합니다. sep 인자는 임의의 bytes-like object 일 수 있습니다.

예를 들어:

>>> 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'']
>>> b'1<>2<>3<4'.split(b'<>')
[b'1', b'2', b'3<4']

sep 이 지정되지 않거나 None 인 경우, 다른 분할 알고리즘이 적용됩니다: 연속된 ASCII whitespace 를 단일 구분자로 간주하며, 시퀀스에 선행 또는 후행 공백이 있는 경우에도 결과에 빈 문자열이 포함되지 않습니다. 결과적으로, 구분자를 지정하지 않고 빈 시퀀스나 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(bytes=None, /)¶

bytearray.strip(bytes=None, /)¶

지정된 선행 및 후행 바이트를 제거한 시퀀스의 복사본을 반환합니다. bytes 인자는 제거할 바이트 값의 집합을 지정하는 바이너리 시퀀스입니다. 생략하거나 None 인 경우, bytes 인자는 기본적으로 ASCII whitespace 를 제거합니다. bytes 인자는 접두사나 접미사가 아니며, 대신 그 값들의 모든 조합이 제거됩니다:

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

제거할 바이트 값의 바이너리 시퀀스는 임의의 bytes-like object 일 수 있습니다.

참고

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

bytes 및 bytearray 객체에 대한 다음 메서드들은 ASCII 호환 바이너리 형식을 사용하는 것을 가정하며 임의의 바이너리 데이터에 적용해서는 안 됩니다. 이 섹션의 bytearray 메서드들은 모두 제자리(in-place)에서 작동하지 않고 대신 새로운 객체를 생성합니다.

bytes.capitalize()¶
bytearray.capitalize()¶: 각 바이트를 ASCII 문자로 해석하고, 첫 바이트는 대문자로, 나머지는 소문자로 변환한 시퀀스의 복사본을 반환합니다. ASCII가 아닌 바이트 값은 그대로 전달됩니다.

참고

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

bytes.expandtabs(tabsize=8)¶

bytearray.expandtabs(tabsize=8)¶

현재 열과 주어진 tab size에 따라 모든 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 버전은 제자리(in-place)에서 작동하지 않습니다. 변경 사항이 없더라도 항상 새 객체를 생성합니다.

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 범위에 있습니다.

Added in version 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 타이틀케이스(titlecase)이고 시퀀스가 비어 있지 않으면 True 를 돌려주고, 그렇지 않으면 False 를 돌려줍니다. “타이틀케이스”의 정의에 대한 자세한 내용은 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 버전은 제자리(in-place)에서 작동하지 않습니다. 변경 사항이 없더라도 항상 새 객체를 생성합니다.

bytes.splitlines(keepends=False)¶

bytearray.splitlines(keepends=False)¶

ASCII 줄 바꿈 경계에서 나눈 바이너리 시퀀스의 줄들을 리스트로 돌려줍니다. 이 메서드는 줄을 나누는 데 universal newlines 방식을 사용합니다. 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' 에 있는 바이트 값입니다.

Unlike str.swapcase(), it is always the case that bin.swapcase().swapcase() == bin for the binary versions. Case conversions are symmetrical in ASCII, even though that is not generally true for arbitrary Unicode code points.

참고

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

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 버전은 제자리(in-place)에서 작동하지 않습니다. 변경 사항이 없더라도 항상 새 객체를 생성합니다.

bytes.upper()¶

bytearray.upper()¶

모든 ASCII 소문자를 대응하는 대문자로 변환한 시퀀스의 복사본을 돌려줍니다.

예를 들어:

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

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

참고

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

bytes.zfill(width, /)¶

bytearray.zfill(width, /)¶

길이가 width 인 시퀀스를 만들기 위해 ASCII b'0' 숫자로 채워진 시퀀스의 복사본을 돌려줍니다. 선행 부호 접두어(b'+'/ b'-')는 부호 문자의 앞이 아니라 부호 문자 뒤 에 패딩을 삽입하여 처리합니다. bytes 객체의 경우, width 가 len(seq) 보다 작거나 같으면 원래 시퀀스를 돌려줍니다.

예를 들어:

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

참고

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

`printf` 스타일의 Bytes 포매팅¶

참고

여기에서 설명하는 포매팅 연산은 다양한 특이성으로 인해 여러 일반적인 오류(예: 튜플과 딕셔너리를 올바르게 표시하지 못하는 경우)를 발생시킬 수 있습니다. 출력하려는 값이 튜플이나 딕셔너리일 수 있는 경우 튜플로 감싸십시오.

Bytes 객체(bytes/bytearray)는 유일한 내장 연산인 % 연산자(modulo)를 가집니다. 이는 Bytes 포매팅 또는 인터폴레이션 연산자로도 알려져 있습니다. format % values (여기서 format 은 bytes 객체입니다)가 주어지면, format 내의 % 변환 명세가 values 의 0개 이상의 요소로 대체됩니다. 그 효과는 C 언어에서 sprintf() 함수를 사용하는 것과 유사합니다.

format 이 단일 인자를 요구하는 경우, values 는 단일 비 튜플 객체일 수 있습니다. [5] 그렇지 않으면, values 는 포맷 바이트 객체에 의해 지정된 항목 수와 정확히 일치하는 튜플이거나 단일 매핑 객체(예를 들어, 딕셔너리)여야 합니다.

변환 지정자는 두 개 이상의 문자로 구성되며, 다음 순서대로 구성되는 요소를 포함합니다:

지정자의 시작을 표시하는 '%' 문자.
매핑 키 (선택 사항): 괄호로 둘러싸인 문자 시퀀스로 구성됩니다 (예를 들어, (somename)).
변환 플래그 (선택 사항): 일부 변환 유형의 결과에 영향을 줍니다.
최소 필드 폭 (선택 사항): '*' (애스터리스크)로 지정된 경우, 실제 폭은 values 튜플의 다음 요소에서 읽히며, 변환할 객체는 최소 필드 폭과 선택적 정밀도 뒤에 위치합니다.
정밀도 (선택 사항): '.' (점) 뒤에 정밀도가 옵니다. '*' (애스터리스크)로 지정된 경우, 실제 정밀도는 values 튜플의 다음 요소에서 읽히며, 변환할 값은 정밀도 뒤에 위치합니다.
길이 수정자 (선택 사항).
변환 유형.

오른쪽 인자가 딕셔너리(또는 다른 매핑 유형)인 경우, 바이트 객체의 포맷은 '%' 문자 바로 뒤에 해당 딕셔너리로 삽입되는 괄호로 묶인 매핑 키를 포함해야 합니다. 매핑 키는 매핑에서 포맷할 값을 선택합니다. 예를 들어:

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

이 경우, 포맷에서 * 지정자는 나타날 수 없습니다(연속적인 매개변수 목록이 필요하기 때문입니다).

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

플래그	Meaning
`'#'`	값 변환 시 “대체 형식”(아래에 정의됨)을 사용합니다.
`'0'`	숫자 값에 대해서는 0으로 채워진(zero padded) 변환이 이루어집니다.
`'-'`	변환된 값은 왼쪽으로 정렬됩니다(두 옵션이 모두 주어질 경우 `'0'` 변환보다 우선합니다).
`' '`	(공백) 부호 있는 변환으로 생성된 양수(또는 빈 문자열) 앞에는 공백이 남겨져야 합니다.
`'+'`	부호 문자(`'+'` 또는 `'-'`)가 변환 앞에 위치합니다(“공백” 플래그에 우선합니다).

길이 수정자(h, l, 또는 L)가 포함될 수 있지만, Python에서는 필요하지 않으므로 무시됩니다. 예를 들어 %ld 는 %d 와 동일합니다.

변환 유형은 다음과 같습니다:

변환	Meaning	Notes
`'d'`	부호 있는 10진 정수.
`'i'`	부호 있는 10진 정수.
`'o'`	부호 있는 8진수.	(1)
`'u'`	더 이상 사용되지 않는 유형(deprecated)으로, `'d'` 와 동일합니다.	(8)
`'x'`	부호 있는 16진수(소문자).	(2)
`'X'`	부호 있는 16진수(대문자).	(2)
`'e'`	부동 소수점 지수 표기법(소문자).	(3)
`'E'`	부동 소수점 지수 표기법(대문자).	(3)
`'f'`	부동 소수점 10진수 표기법.	(3)
`'F'`	부동 소수점 10진수 표기법.	(3)
`'g'`	부동 소수점 표기법. 지수가 -4보다 작거나 정밀도(precision)보다 작지 않으면 소문자 지수 표기법을 사용하고, 그렇지 않으면 10진수 표기법을 사용합니다.	(4)
`'G'`	부동 소수점 표기법. 지수가 -4보다 작거나 정밀도(precision)보다 작지 않으면 대문자 지수 표기법을 사용하고, 그렇지 않으면 10진수 표기법을 사용합니다.	(4)
`'c'`	단일 바이트(정수 또는 단일 바이트 객체를 수용).
`'b'`	Bytes(버퍼 프로토콜 를 따르거나 `__bytes__()` 를 가진 모든 객체).	(5)
`'s'`	`'s'` 는 `'b'` 의 별칭이며 Python 2/3 코드 기반에서만 사용해야 합니다.	(6)
`'a'`	Bytes(모든 Python 객체를 `repr(obj).encode('ascii', 'backslashreplace')` 를 사용하여 변환).	(5)
`'r'`	`'r'` 는 `'a'` 의 별칭이며 Python 2/3 코드 기반에서만 사용해야 합니다.	(7)
`'%'`	인수가 변환되지 않으며, 결과에 `'%'` 문자가 포함됩니다.

Notes:

대체 형식을 사용하면 첫 번째 숫자 앞에 8진수 지정자('0o')가 삽입됩니다.
대체 형식을 사용하면 첫 번째 숫자 앞에 '0x' 또는 '0X'``(‘x’`` 또는 'X' 형식을 사용했는지에 따라 다름)가 삽입됩니다.
대체 형식을 사용하면 뒤에 숫자가 없더라도 결과에 항상 소수점이 포함됩니다.

정밀도는 소수점 뒤의 자릿수를 결정하며 기본값은 6입니다.
대체 형식을 사용하면 결과에 항상 소수점이 포함되며, 일반적으로 제거되는 마지막의 0이 제거되지 않습니다.

정밀도는 소수점 앞과 뒤의 유효 자릿수를 결정하며 기본값은 6입니다.
정밀도가 N 인 경우, 출력은 N 자로 절사됩니다.
b'%s' 는 권장되지 않지만(deprecated), 3.x 시리즈 동안 제거되지는 않습니다.
b'%r' 는 권장되지 않지만(deprecated), 3.x 시리즈 동안 제거되지는 않습니다.
자세한 내용은 PEP 237 을 참조하십시오.

참고

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

PEP 461 - bytes 및 bytearray에 % 포매팅 추가

Added in version 3.5.

Memory Views¶

memoryview 객체는 Python 코드가 복사 없이 버퍼 프로토콜 를 지원하는 객체의 내부 데이터에 접근할 수 있게 합니다.

class memoryview(object)¶

object 을 참조하는 memoryview 를 생성합니다. object 는 버퍼 프로토콜을 지원해야 합니다. 버퍼 프로토콜을 지원하는 내장 객체로는 bytes 와 bytearray 가 있습니다.

memoryview 는 원본 object 에 의해 처리되는 원자적 메모리 단위인 요소(element) 개념을 가집니다. bytes 및 bytearray 와 같은 많은 단순한 유형의 경우 요소는 단일 바이트이지만, array.array 와 같은 다른 유형은 더 큰 요소를 가질 수 있습니다.

memoryview s는 그들의 기초 데이터 유형에 대한 generic 입니다.

len(view) 는 tolist() 의 길이와 같으며, 이는 뷰의 중첩된 리스트 표현입니다. 만약 view.ndim == 1 이면, 이는 뷰에 포함된 요소의 수와 같습니다.

버전 3.12에서 변경: view.ndim == 0 인 경우, len(view) 는 이제 1을 반환하는 대신 TypeError 를 발생시킵니다.

itemsize 어트리뷰트는 단일 요소의 바이트 수를 반환합니다.

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

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

format 이 struct 모듈의 네이티브 형식 지정자 중 하나인 경우, 정수 또는 정수 튜플을 사용한 인덱싱도 지원되며 적절한 타입을 가진 단일 element 를 반환합니다. 일차원 메모리 뷰는 정수 또는 단일 정수 튜플로 인덱싱할 수 있습니다. 다차원 메모리 뷰는 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는 일차원 슬라이스 할당을 지원합니다. 크기 조정은 허용되지 않습니다:

>>> 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’인 hashable (읽기 전용) 타입의 일차원 메모리 뷰 또한 해시 가능합니다. 해시는 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에서 변경: 이제 일차원 메모리 뷰를 슬라이싱할 수 있습니다. 형식이 ‘B’, ‘b’ 또는 ‘c’인 일차원 메모리 뷰는 이제 hashable 입니다.

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

버전 3.5에서 변경: 이제 메모리 뷰를 정수의 튜플로 인덱싱할 수 있습니다.

버전 3.14에서 변경: memoryview는 이제 generic type 입니다.

memoryview 는 여러 메서드를 제공합니다:

__eq__(exporter)¶

메모리 뷰와 PEP 3118 익스포터는 모양이 동일하고, 피연산자의 각각의 포맷 코드를 struct 구문으로 해석했을 때 모든 대응하는 값이 같으면 같다고 판단합니다.

현재 tolist() 가 지원하는 struct 포맷 문자열의 부분 집합에 대해, 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 가 v == w 를 의미하지는 않는다는 점에 유의하십시오.

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

tobytes(order='C')¶

버퍼의 데이터를 바이트열로 반환합니다. 이는 메모리 뷰에 대해 bytes 생성자를 호출하는 것과 동일합니다.

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

불연속 배열의 경우 결과는 모든 요소를 바이트로 변환하여 평평하게 만든 리스트 표현과 같습니다. tobytes() 는 struct 모듈 문법이 아닌 것을 포함하여 모든 포맷 문자열을 지원합니다.

Added in version 3.8: order 는 {‘C’, ‘F’, ‘A’}가 될 수 있습니다. order 가 ‘C’ 또는 ‘F’인 경우, 원래 배열의 데이터가 C 또는 포트란 순서로 변환됩니다. 연속된 뷰의 경우, ‘A’는 물리적 메모리의 정확한 사본을 반환합니다. 특히, 메모리 내의 포트란 순서가 유지됩니다. 연속적이지 않은 뷰의 경우, 데이터가 먼저 C 순서로 변환됩니다. order=None 은 order=’C’ 와 동일합니다.

hex(*, bytes_per_sep=1)¶

hex(sep, bytes_per_sep=1)

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

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

Added in version 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() 는 이제 struct 모듈 문법의 모든 단일 문자 네이티브 형식을 비롯하여 다차원 표현도 지원합니다.

toreadonly()¶

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

>>> m = memoryview(bytearray(b'abc'))
>>> mm = m.toreadonly()
>>> mm.tolist()
[97, 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]

Added in version 3.8.

release()¶

메모리 뷰 객체에 의해 노출된 하부 버퍼를 해제합니다. 많은 객체가 뷰가 유지될 때 특별한 동작을 수행하는데(예를 들어, 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

Added in version 3.2.

cast(format, /)¶

cast(format, shape, /, *, order='C')

메모리 뷰를 새로운 형식이나 모양으로 캐스팅합니다. shape 의 기본값은 [byte_length//new_itemsize] 이며, 이는 결과 뷰가 일차원이 됨을 의미합니다. 반환 값은 새로운 메모리 뷰이지만 버퍼 자체는 복사되지 않습니다. 지원되는 캐스팅은 1D -> C-contiguous, C-연속 -> 1D, 그리고 F-연속 -> 1D입니다.

다차원 shape 의 경우, order 는 결과의 메모리 레이아웃을 선택합니다. C-연속(행 중심, 기본값)은 'C', 포트란-연속(열 중심)은 'F' 를 사용합니다. 버퍼는 여전히 복사되지 않으므로, order='F' 는 열 중심 데이터를 보유하는 버퍼에 대해 제로 카피 뷰를 제공합니다.

대상 형식은 struct 구문의 단일 요소 네이티브 형식으로 제한됩니다. 형식 중 하나는 반드시 바이트 형식(‘B’, ‘b’ 또는 ‘c’)이어야 합니다. 결과의 바이트 길이는 원래 길이와 동일해야 합니다. 모든 바이트 길이는 운영체제에 따라 다를 수 있습니다.

1D/long을 1D/unsigned bytes로 캐스팅:

>>> 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 bytes를 1D/char로 캐스팅:

>>> b = bytearray(b'zyz')
>>> x = memoryview(b)
>>> x[0] = b'a'
Traceback (most recent call last):
  ...
TypeError: memoryview: invalid type 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]]

Added in version 3.3.

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

버전 3.16.0a0 (unreleased)에서 변경: 다차원 F-연속 뷰를 일차원 뷰로 캐스팅하는 것이 이제 지원됩니다.

count(value, /)¶: value 의 발생 횟수를 세어줍니다.

Added in version 3.14.

index(value, start=0, stop=sys.maxsize, /)¶

value*가 처음으로 나타나는 인덱스를 반환합니다(인덱스 *start 이상, stop 미만).

value 를 찾을 수 없으면 ValueError 를 발생시킵니다.

Added in version 3.14.

다음과 같은 몇 가지 읽기 전용 속성도 사용할 수 있습니다:

obj¶

memoryview의 기초 객체:

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

Added in version 3.3.

nbytes¶

nbytes == product(shape) * itemsize == 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

평탄한 버퍼를 포트란-연속(열 중심) 배열로 해석:

>>> buf = bytes(range(6))
>>> y = memoryview(buf).cast('B', shape=[3, 2], order='F')
>>> y.f_contiguous
True
>>> y.tolist()
[[0, 3], [1, 4], [2, 5]]

Added in version 3.3.

버전 3.16.0a0 (unreleased)에서 변경: order 매개변수가 추가되었습니다.

readonly¶: 메모리가 읽기 전용인지 여부를 나타내는 논리값입니다.

format¶: 뷰의 각 요소에 대한 형식( struct 모듈 스타일)을 포함하는 문자열입니다. memoryview는 임의의 형식 문자열을 가진 내보내기(exporter)로부터 생성될 수 있지만, 일부 메서드(예: 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-contiguous 인지 여부를 나타내는 논리값입니다.

Added in version 3.3.

f_contiguous¶: 메모리가 Fortran contiguous 인지 여부를 나타내는 논리값입니다.

Added in version 3.3.

contiguous¶: 메모리가 contiguous 인지 여부를 나타내는 논리값입니다.

Added in version 3.3.

free-threaded build 에서 memoryview 객체의 스레드 안전성에 대한 정보는 memoryview 객체의 스레드 안전성 를 참조하십시오.

집합 형 — `set`, `frozenset`¶

set 객체는 서로 다른 hashable 객체들의 순서가 없는 컬렉션입니다. 일반적인 용도로는 멤버십 테스트, 시퀀스에서 중복 제거, 그리고 교집합, 합집합, 차집합, 대칭 차집합과 같은 수학적 연산이 있습니다. (다른 컨테이너는 내장된 dict, list, tuple 클래스와 collections 모듈을 참조하십시오.) 다양한 집합 연산의 비용에 대해서는 내장형 타입 연산의 시간 복잡도 를 참조하십시오.

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

현재 두 가지 내장 집합 형인 set 과 frozenset 이 있습니다. set 형은 가변이며, add() 및 remove() 와 같은 메서드를 사용하여 내용을 변경할 수 있습니다. 가변이기 때문에 해시 값이 없으며 딕셔너리 키나 다른 집합의 원소로 사용할 수 없습니다. frozenset 형은 불변이며 hashable 입니다. 생성된 후에는 내용을 변경할 수 없으므로 딕셔너리 키나 다른 집합의 원소로 사용할 수 있습니다.

비어 있지 않은 집합(frozenset 제외)은 set 생성자 외에도 중괄호 안에 쉼표로 구분된 요소 목록을 넣어 만들 수 있습니다. 예: {'jack', 'sjoerd'}

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

class set(iterable=(), /)¶
class frozenset(iterable=(), /)¶: iterable 에서 요소를 가져와 새로운 set 또는 frozenset 객체를 반환합니다. 집합의 요소는 반드시 hashable 이어야 합니다. 집합의 집합을 표현하려면 내부 집합이 frozenset 객체여야 합니다. iterable 이 지정되지 않으면 새 빈 집합이 반환됩니다.

집합은 여러 가지 방법으로 생성할 수 있습니다:

중괄호 안에 쉼표로 구분된 요소 목록을 사용합니다: {'jack', 'sjoerd'}
집합 컴프리헨션을 사용합니다: {c for c in 'abracadabra' if c not in 'abc'}
타입 생성자를 사용합니다: set(), set('foobar'), set(['a', 'b', 'foo'])

set 및 frozenset 인스턴스는 다음과 같은 연산을 제공합니다:

len(s): 집합 s*의 원소 개수(cardinality of *s)를 반환합니다.

x in s: s 내에 x 가 포함되어 있는지 확인합니다.

x not in s: s 내에 x 가 포함되어 있지 않은지 확인합니다.

frozenset.isdisjoint(other, /)¶
set.isdisjoint(other, /)¶: 집합이 other 와 공통 원소를 갖지 않으면 True 를 반환합니다. 집합은 교집합이 공집합일 때만 서로소(disjoint)입니다.

frozenset.issubset(other, /)¶
set.issubset(other, /)¶

set <= other: 집합의 모든 원소가 other 에 포함되어 있는지 확인합니다.

set < other: 집합이 other 의 진부분집합인지 확인합니다. 즉, set <= other and set != other 인 경우입니다.

frozenset.issuperset(other, /)¶
set.issuperset(other, /)¶

set >= other: 모든 원소가 other 에 포함되어 있는지 확인합니다.

set > other: 집합이 other 의 진부분집합인지 확인합니다. 즉, set >= other and set != other 인 경우입니다.

frozenset.union(*others)¶
set.union(*others)¶

set | other | ...: 집합과 다른 모든 요소들을 포함하는 새 집합을 반환합니다.

frozenset.intersection(*others)¶
set.intersection(*others)¶

set & other & ...: 집합과 다른 모든 것들의 공통 원소로 구성된 새 집합을 반환합니다.

frozenset.difference(*others)¶
set.difference(*others)¶

set - other - ...: 다른 것들에는 포함되지 않고 집합에만 포함된 원소들로 구성된 새 집합을 반환합니다.

frozenset.symmetric_difference(other, /)¶
set.symmetric_difference(other, /)¶

set ^ other: 집합 또는 other 중 한 곳에만 포함된 원소들로 구성된 새 집합을 반환합니다.

frozenset.copy()¶
set.copy()¶: 집합의 얕은 사본을 반환합니다.

참고: union(), intersection(), difference(), symmetric_difference(), issubset(), 및 issuperset() 의 비 연산자 버전은 인자로 모든 이터러블을 수용합니다. 반면, 연산자 기반의 대응 메서드들은 인자로 세트(set)를 요구합니다. 이는 가독성이 더 높은 set('abc').intersection('cbs') 를 사용하는 대신, 오류 발생 가능성이 있는 set('abc') & 'cbs' 와 같은 구성을 방지하기 위한 것입니다.

set 과 frozenset 모두 세트 간의 비교를 지원합니다. 두 세트가 같으려면 각 세트의 모든 원소가 다른 세트에 포함되어야 합니다(각각이 서로의 부분집합이어야 함). 한 세트가 다른 세트보다 작으려면 첫 번째 세트가 두 번째 세트의 진부분집합이어야 합니다(부분집합이지만 같지는 않아야 함). 한 세트가 다른 세트보다 크려면 첫 번째 세트가 두 번째 세트의 진상위집합이어야 합니다(상위집합이지만 같지는 않아야 함).

set 인스턴스는 그 원소를 기반으로 frozenset 인스턴스와 비교됩니다. 예를 들어, set('abc') == frozenset('abc') 는 True 를 반환하며, set('abc') in set([frozenset('abc')]) 도 True 를 반환합니다.

부분집합 및 동등성 비교는 전체 순서(total ordering) 함수로 일반화되지 않습니다. 예를 들어, 비어 있지 않은 임의의 두 서로소 집합은 서로 같지 않고 서로의 부분집합도 아니므로, 다음의 모든 연산은 False``를 반환합니다: ``a<b, a==b, 또는 a>b.

집합은 부분 순서(부분집합 관계)만을 정의하므로, 세트의 리스트에 대해 list.sort() 메서드의 결과는 정의되지 않습니다.

딕셔너리 키와 마찬가지로, 집합의 원소는 hashable 이어야 합니다.

set 인스턴스와 frozenset 인스턴스를 혼합한 이항 연산은 첫 번째 피연산자의 타입을 반환합니다. 예를 들어: frozenset('ab') | set('bc') 는 frozenset 인스턴스를 반환합니다.

다음 표는 set 에서 가능하지만 불변 인스턴스인 frozenset 에서는 적용되지 않는 연산들을 나열합니다:

set.update(*others)¶

set |= other | ...: 다른 모든 요소들을 추가하여 집합을 업데이트합니다.

set.intersection_update(*others)¶

set &= other & ...: 자기 자신과 다른 모든 것들에 공통으로 포함된 원소들만 남기며 집합을 업데이트합니다.

set.difference_update(*others)¶

set -= other | ...: 다른 것들에 포함된 원소들을 제거하며 집합을 업데이트합니다.

set.symmetric_difference_update(other, /)¶

set ^= other: 두 집합 중 한 곳에만 포함된 원소들만 남기며 집합을 업데이트합니다.

set.add(elem, /)¶: 원소 elem 을 집합에 추가합니다.

set.remove(elem, /)¶: 원소 elem 을 집합에서 제거합니다. elem 이 집합에 포함되어 있지 않으면 KeyError 가 발생합니다.

set.discard(elem, /)¶: 원소 elem 이 존재할 경우 집합에서 제거합니다.

set.pop()¶: 집합에서 임의의 원소를 제거하고 반환합니다. 집합이 비어있는 경우 KeyError 가 발생합니다.

set.clear()¶: 집합에서 모든 원소를 제거합니다.

참고로, update(), intersection_update(), difference_update(), symmetric_difference_update() 메서드의 비 연산자 버전은 임의의 이터러블을 인자로 받아들입니다.

Note, the elem argument to the __contains__(), remove(), and discard() methods may be a set. To support searching for an equivalent frozenset, a temporary one is created from elem.

Set과 frozenset은 요소의 타입에 대한 generic 입니다.

set 객체에 대한 스레드 안전성 보장에 대한 자세한 내용은 set 객체의 스레드 안전성 을 참조하십시오.

매핑 형 — `dict`, `frozendict`¶

mapping 객체는 hashable 값을 임의의 객체에 매핑합니다. 현재 두 가지 표준 매핑 형인 dictionary 와 frozendict 가 있습니다. (다른 컨테이너는 내장된 list, set, tuple 클래스 및 collections 모듈을 참조하십시오.) 다양한 딕셔너리 연산의 비용은 내장형 타입 연산의 시간 복잡도 를 참조하십시오.

딕셔너리의 키는 거의 모든 값을 가질 수 있습니다. hashable 이 아닌 값, 즉 리스트, 딕셔너리 또는 다른 가변 타입(객체 식별자가 아닌 값으로 비교되는 것)을 포함하는 값은 키로 사용할 수 없습니다. 서로 동일하게 비교되는 값들(예: 1, 1.0, True)은 동일한 딕셔너리 항목을 인덱싱하는 데 서로 교체하여 사용할 수 있습니다.

class dict(**kwargs)¶

class dict(mapping, /, **kwargs)

class dict(iterable, /, **kwargs)

선택적 위치 인자와 비어 있을 수 있는 키워드 인자 세트를 사용하여 초기화된 새 딕셔너리를 반환합니다.

딕셔너리는 다음과 같은 여러 방법으로 생성할 수 있습니다:

중괄호 내에 쉼표로 구분된 key: value 쌍의 리스트를 사용합니다: {'jack': 4098, 'sjoerd': 4127} 또는 {4098: 'jack', 4127: 'sjoerd'}
dict 컴프리헨션을 사용합니다: {}, {x: x ** 2 for x in range(10)}
타입 생성자를 사용합니다: dict(), dict([('foo', 100), ('bar', 200)]), dict(foo=100, bar=200)

위치 인자가 제공되지 않으면 빈 딕셔너리가 생성됩니다. 위치 인자가 제공되고 그 객체가 keys() 메서드를 정의하는 경우, 해당 메서드에서 반환된 각 키를 사용하여 인자에 대해 __getitem__() 을 호출함으로써 딕셔너리가 생성됩니다. 그렇지 않으면 위치 인자는 iterable 객체여야 합니다. 이터러블의 각 항목은 정확히 두 개의 요소를 가진 이터러블이어야 합니다. 각 항목의 첫 번째 요소는 새 딕셔너리의 키가 되고, 두 번째 요소는 해당 값이 됩니다. 키가 여러 번 나타나면, 해당 키에 대한 마지막 값이 새 딕셔너리에서 해당 값이 됩니다.

키워드 인자가 제공되면 키워드 인자와 그 값이 위치 인자로부터 생성된 딕셔너리에 추가됩니다. 추가하려는 키가 이미 존재하는 경우, 키워드 인자의 값이 위치 인자의 값을 대체합니다.

딕셔너리는 순서와 상관없이 동일한 (key, value) 쌍을 가질 때만 서로 같다고 비교됩니다. 순서 비교(‘<’, ‘<=’, ‘>=’, ‘>’)는 TypeError 를 발생시킵니다. 딕셔너리 생성 및 동등성을 보여주기 위해, 다음 예제들은 모두 {"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 식별자인 경우에만 작동합니다. 그렇지 않은 경우, 유효한 모든 키를 사용할 수 있습니다.

딕셔너리는 삽입 순서를 유지합니다. 키를 업데이트해도 순서에 영향을 주지 않음에 유의하십시오. 삭제 후 추가된 키는 끝에 삽입됩니다.

>>> 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의 구현 세부 사항이었습니다.

딕셔너리는 두 개의 타입에 대한 generic 이며, 각각 딕셔너리의 키와 값의 타입을 나타냅니다.

다음은 딕셔너리가 지원하는 연산입니다(따라서 커스텀 매핑 타입도 지원해야 합니다):

list(d): 딕셔너리 d 에서 사용된 모든 키의 리스트를 반환합니다.

len(d): 딕셔너리 d 에 포함된 항목의 수를 반환합니다.

d[key]

키 key 가 포함된 d 의 항목을 반환합니다. key 가 매핑에 없으면 KeyError 를 발생시킵니다.

dict의 서브클래스가 __missing__() 메서드를 정의하고 key 가 존재하지 않으면, d[key] 연산은 해당 메서드를 키 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 구현의 일부를 보여줍니다. collections.defaultdict`는 다른 :meth:!__missing__` 메서드를 사용합니다.

d[key] = value: d[key] 를 value 로 설정합니다.

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

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

key not in d: not key in d 와 동일합니다.

iter(d): 딕셔너리의 키에 대한 이터레이터를 반환합니다. 이것은 iter(d.keys()) 의 단축형입니다.

clear()¶: 딕셔너리에서 모든 항목을 제거합니다.

copy()¶: 딕셔너리의 얕은 복사본을 반환합니다.

classmethod fromkeys(iterable, value=None, /)¶

iterable 에서 가져온 키와 value 로 설정된 값들로 구성된 새 딕셔너리를 생성합니다.

fromkeys() 는 새 딕셔너리를 반환하는 클래스 메서드입니다. value 의 기본값은 None 입니다. 모든 값이 단일 인스턴스를 가리키므로, value 가 빈 리스트와 같은 가변 객체인 것은 일반적으로 적절하지 않습니다. 서로 다른 값을 얻으려면 대신 dict comprehension 를 사용하십시오.

get(key, default=None, /)¶: key 가 딕셔너리에 있으면 해당 값을, 그렇지 않으면 default 를 반환합니다. default 가 제공되지 않으면 기본값 None 이 적용되어 이 메서드는 절대로 KeyError 를 발생시키지 않습니다.

items()¶: 딕셔너리 항목((key, value) 쌍)의 새 뷰를 반환합니다. 뷰 객체의 설명서 를 참조하십시오.

keys()¶: 딕셔너리 키의 새 뷰를 반환합니다. 뷰 객체의 설명서 를 참조하십시오.

pop(key, /)¶
pop(key, default, /): key 가 딕셔너리에 있으면 제거하고 그 값을 반환하며, 그렇지 않으면 default 를 반환합니다. default 가 제공되지 않고 key 가 딕셔너리에 없으면 KeyError 를 발생시킵니다.

popitem()¶

딕셔너리에서 (key, value) 쌍을 제거하고 반환합니다. 쌍은 LIFO 순서로 반환됩니다.

popitem() 은 집합 알고리즘에서 자주 사용되듯 딕셔너리를 파괴적으로 순회할 때 유용합니다. 딕셔너리가 비어 있는 경우 popitem() 을 호출하면 KeyError 가 발생합니다.

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

reversed(d): 딕셔너리의 키에 대한 역순 이터레이터를 반환합니다. 이것은 reversed(d.keys()) 의 단축형입니다.

Added in version 3.8.

setdefault(key, default=None, /)¶: key 가 딕셔너리에 있으면 그 값을 반환합니다. 그렇지 않으면 key 를 default 값으로 삽입하고 default 를 반환합니다. default 의 기본값은 None 입니다.

update(**kwargs)¶

update(mapping, /, **kwargs)

update(iterable, /, **kwargs)

mapping 또는 iterable 및 kwargs 의 키/값 쌍으로 딕셔너리를 업데이트하며, 기존 키는 덮어씁니다. None 을 반환합니다.

update`는 ``keys()`() 메서드가 있는 다른 객체(이 경우 메서드에서 반환된 모든 키에 대해 update(red=1, blue=2)`().

values()¶

딕셔너리 값의 새 뷰를 반환합니다. 뷰 객체의 설명서 를 참조하십시오.

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

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

d | other: 둘 다 딕셔너리여야 하는 d 와 other 의 키와 값을 병합하여 새 딕셔너리를 만듭니다. d 와 other 가 키를 공유하는 경우 other 의 값이 우선합니다.

Added in version 3.9.

d |= other: other 가 mapping 또는 키/값 쌍의 iterable 일 수 있는 other 의 키와 값으로 딕셔너리 d 를 업데이트합니다. d 와 other 가 키를 공유하는 경우 other 의 값이 우선합니다.

Added in version 3.9.

딕셔너리와 딕셔너리 뷰는 역순으로 탐색할 수 있습니다.

>>> 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에서 변경: 딕셔너리가 이제 뒤집을 수 있습니다.

frozendict 와 types.MappingProxyType 을 사용하여 dict 의 읽기 전용 뷰를 만들 수 있습니다.

dict 객체에 대한 스레드 안전성 보장에 대한 자세한 내용은 dict 객체의 스레드 안전성 을(를) 참조하십시오.

딕셔너리 뷰 객체¶

dict.keys(), dict.values() 및 dict.items() 가 반환하는 객체는 뷰 객체 입니다. 이들은 딕셔너리 항목에 대한 동적 뷰를 제공하며, 이는 딕셔너리가 변경될 때 뷰가 이러한 변화를 반영함을 의미합니다.

딕셔너리 뷰를 반복하여 해당 데이터를 생성할 수 있으며, 멤버십 테스트를 지원합니다.

len(dictview): 딕셔너리의 항목 수를 반환합니다.

iter(dictview)

딕셔너리의 키, 값 또는 항목((key, value) 튜플로 표현됨)에 대한 이터레이터를 반환합니다.

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

딕셔너리에 항목을 추가하거나 삭제하면서 뷰를 반복하면 RuntimeError 가 발생하거나 모든 항목을 반복하지 못할 수 있습니다.

버전 3.7에서 변경: 딕셔너리 순서는 삽입 순서임이 보장됩니다.

x in dictview: x 가 기반 딕셔너리의 키, 값 또는 항목 중에 있으면 True 를 반환합니다(후자의 경우 x 는 (key, value) 튜플이어야 합니다).

reversed(dictview): 딕셔너리의 키, 값 또는 항목에 대한 역방향 이터레이터를 반환합니다. 뷰는 삽입된 역순으로 반복됩니다.

버전 3.8에서 변경: 딕셔너리 뷰가 이제 뒤집힐 수 있습니다.

dictview.mapping: 뷰가 참조하는 원본 딕셔너리를 감싸는 types.MappingProxyType 을 반환합니다.

Added in version 3.10.

키 뷰는 항목이 고유하고 hashable 이므로 집합과 유사하게 작동합니다. 아이템 뷰 역시 (key, value) 쌍이 고유하고 키가 hashable이므로 집합과 유사한 연산을 지원합니다. 아이템 뷰의 모든 값이 hashable인 경우, 아이템 뷰는 다른 집합과 상호 작용할 수 있습니다. (값 뷰는 항목이 일반적으로 고유하지 않으므로 집합과 유사하게 취급되지 않습니다.) 집합과 유사한 뷰의 경우, 추상 기본 클래스인 collections.abc.Set 에 정의된 모든 연산(예: ==, <, 또는 ^)을 사용할 수 있습니다. 집합 연산자를 사용할 때, 집합은 입력으로 집합만 허용하는 것과 달리, 집합과 유사한 뷰는 다른 피연산자로 어떤 반복 가능한(iterable) 객체도 허용합니다.

딕셔너리 뷰 사용 예시:

>>> 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'}
True
>>> keys | ['juice', 'juice', 'juice'] == {'bacon', 'spam', 'juice'}
True

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

고정된 딕셔너리¶

class frozendict(**kwargs)¶

class frozendict(mapping, /, **kwargs)

class frozendict(iterable, /, **kwargs)

선택적 위치 인자와 (비어있을 수 있는) 키워드 인자 집합으로부터 초기화된 새로운 고정 딕셔너리를 반환합니다.

frozendict 은 dict 와 유사한 API를 가지지만 다음과 같은 차이점이 있습니다:

dict`은 :class:!frozendict`보다 더 많은 메서드를 가집니다.
- __delitem__()
- __setitem__()
- clear()
- pop()
- popitem()
- setdefault()
- update()
모든 키와 값이 hashable인 경우, frozendict 은 hash(frozendict) 로 해싱할 수 있습니다.
frozendict |= other 은 frozendict 을(를) 제자리(in-place)에서 수정하지 않고 새로운 고정 딕셔너리를 생성합니다.

frozendict 은 dict 의 서브클래스가 아니며 object 를 직접 상속받습니다.

딕셔너리와 마찬가지로 frozendict는 두 가지 타입에 대한 generic 이며, 각각 frozendict의 키와 값의 타입을 나타냅니다.

classmethod fromkeys(iterable, value=None, /)¶: dict.fromkeys() 와 유사하지만, 타입이 frozendict 의 서브클래스이거나 생성자가 frozendict 를 반환한 경우 초기화된 frozendict 를 사용하여 타입 생성자를 다시 호출합니다.

Added in version 3.15.

컨텍스트 관리자 유형¶

파이썬의 with 문은 컨텍스트 관리자에 의해 정의되는 실행 시간 컨텍스트 개념을 지원합니다. 이는 사용자가 정의한 클래스가 문장 본문이 실행되기 전에 진입하고 문장이 끝날 때 종료되는 실행 시간 컨텍스트를 정의할 수 있게 하는 한 쌍의 메서드를 사용하여 구현됩니다.

contextmanager.__enter__()¶

실행 시간 컨텍스트에 진입하고 이 객체 또는 실행 시간 컨텍스트와 관련된 다른 객체를 반환합니다. 이 메서드에서 반환된 값은 이 컨텍스트 관리자를 사용하는 with 문의 as 절에 있는 식별자에 바인딩됩니다.

An example of a context manager that returns itself is a file object. File objects return themselves from __enter__() to allow open() to be used as the context expression in a with statement.

관련된 객체를 반환하는 컨텍스트 관리자의 예로 decimal.localcontext`가 반환하는 것이 있습니다. 이러한 매니저들은 활성 데시멀 컨텍스트를 원본 데시멀 컨텍스트의 복사본으로 설정한 후 복사본을 반환합니다. 이를 통해 :keyword:()!with` 문 외부의 코드에 영향을 주지 않으면서 with 문 본문 내에서 현재 데시멀 컨텍스트를 변경할 수 있습니다.

contextmanager.__exit__(exc_type, exc_val, exc_tb)¶

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

이 메서드에서 참 값을 반환하면 with 문이 예외를 억제하고 with 문 바로 다음에 오는 문장에서 실행을 계속합니다. 그렇지 않으면 이 메서드의 실행이 끝난 후 예시가 계속 전파됩니다.

이 메서드가 with 블록에서 발생한 이전 예외를 처리하는 동안 예외를 발생시키면, 새 예법이 발생하고 원래의 예외는 새 예외의 __context__ 속성에 저장됩니다.

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

파이썬은 쉬운 스레드 동기화, 파일 또는 다른 객체의 즉각적인 닫기, 활성 데시멀 산술 컨텍스트의 더 간단한 조작을 지원하기 위해 여러 컨텍스트 관리자를 정의합니다. 특정 유형들은 컨텍스트 관리 프로토콜 구현 외에 특별하게 취급되지 않습니다. 몇 가지 예시는 contextlib 모듈을 참조하십시오.

파이썬의 제너레이터 및 contextlib.contextmanager 데코레이터는 이러한 프로토콜을 구현하는 편리한 방법을 제공합니다. 제너레이터 함수가 contextlib.contextmanager 데코레이터로 장식되면, 장식되지 않은 제너레이터 함수가 생성하는 이터레이터 대신 필요한 __enter__() 및 __exit__() 메서드를 구현하는 컨텍스트 관리자를 반환합니다.

Python/C API에서 파이썬 객체의 타입 구조에 이러한 메서드들을 위한 특정 슬롯은 없다는 점에 유의하십시오. 이러한 메서드들을 정의하려는 확장 유형은 이를 파이썬에서 접근 가능한 일반적인 메서드로 제공해야 합니다. 실행 시간 컨텍스트를 설정하는 오버헤드에 비해 단일 클래스 딕셔너리 조회의 오버헤드는 무시할 수 있는 수준입니다.

타입 어노테이션 유형 — Generic Alias, Union ¶

타입 어노테이션 을 위한 핵심 내장 타입은 Generic Alias 와 Union 입니다.

Generic Alias 유형¶

GenericAlias objects are generally created by subscripting a class. They are most often used with container classes, such as list or dict. For example, list[int] is a GenericAlias object created by subscripting the list class with the argument int. GenericAlias objects are intended primarily for use with type annotations.

참고

일반적으로 클래스가 특수 메서드 __class_getitem__() 을 구현하는 경우에만 해당 클래스를 서브스크립트할 수 있습니다.

A GenericAlias object acts as a proxy for a generic type, implementing parameterized generics.

컨테이너 클래스의 경우, 클래스의 서브스크립션 에 전달되는 인수는 객체가 포함하는 요소의 유형을 나타낼 수 있습니다. 예를 들어, set[bytes] 는 모든 요소가 bytes 타입인 set 을 의미하기 위해 타입 어노테이션에서 사용될 수 있습니다.

__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') 인 경우(bytes 를 나타내는 b 에 유의하십시오), y 는 re.Match 의 인스턴스이기도 하지만 y.group(0) 과 y[0] 의 반환 값은 모두 bytes 타입입니다. 타입 어노테이션에서는 이러한 종류의 re.Match 객체를 re.Match[bytes] 로 표현합니다.

GenericAlias 객체는 types.GenericAlias 클래스의 인스턴스이며, 이를 사용하여 GenericAlias 객체를 직접 생성할 수도 있습니다. 사용자가 정의한 제네릭 클래스 의 특수화된 형태는 types.GenericAlias 의 인스턴스가 아닐 수도 있지만, 이와 유사한 기능을 제공합니다.

T[X, Y, ...]

사용된 T 에 따라 타입 X, Y 및 기타 타입으로 매개변수화된 타입 T 를 나타내는 GenericAlias 를 생성합니다. 예를 들어, float 요소로 구성된 list 를 기대하는 함수는 다음과 같습니다:

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

Another example for mapping objects, using a dict, which is a generic type expecting two type parameters representing the key type and the value type. In this example, the function expects a dict with keys of type str and values of type 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'>

GenericAlias 인스턴스는 런타임에서 클래스가 아니지만, 클래스처럼 동작합니다(인스턴스화 및 서브클래싱이 가능함):

>>> import inspect
>>> inspect.isclass(list[int])
False

이것은 사용자가 정의한 제네릭 의 경우에도 마찬가지입니다.

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

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

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

제네릭 컨테이너의 __getitem__() 메서드는 dict[str][str] 과 같은 실수를 방지하기 위해 예외를 발생시킵니다:

>>> dict[str][str]
Traceback (most recent call last):
  ...
TypeError: dict[str] is not a generic class

그러나 타입 변수 를 사용하는 경우에는 해당 표현식이 유효합니다. 인덱스는 GenericAlias 객체의 __args__ 에 있는 타입 변수 항목의 개수와 동일한 수의 요소를 가져야 합니다.

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

표준 제네릭 클래스¶

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

`GenericAlias` 객체의 특별한 어트리뷰트¶

모든 매개 변수화된 제네릭은 특별한 읽기 전용 어트리뷰트를 구현합니다.

genericalias.__origin__¶

이 어트리뷰트는 매개 변수화되지 않은 제네릭 클래스:

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

genericalias.__args__¶

이 어트리뷰트는 제네릭 클래스의 원본 __class_getitem__() 에 전달된 제네릭 타입들의 tuple (길이가 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 객체는 typing.ParamSpec 이 주로 정적 타입 검사용으로 설계되었기 때문에 치환 후에 올바른 __parameters__ 를 가질 수 없습니다.

genericalias.__unpacked__¶: 별칭(alias)이 * 연산자를 사용하여 언팩된 경우 참(True)이 되는 불리언입니다(참조: TypeVarTuple).

Added in version 3.11.

PEP 484 - Type Hints: 파이썬의 타입 어노테이션을 위한 프레임워크를 도입합니다.
PEP 585 - Type Hinting Generics In Standard Collections: 특수 클래스 메서드인 __class_getitem__() 을 구현하는 경우, 표준 라이브러리 클래스를 기본적으로 매개 변수화할 수 있는 기능을 도입합니다.
제네릭, user-defined generics 및 typing.Generic: 런타임에 매개 변수화될 수 있고 정적 타입 검사기에 의해 인식될 수 있는 제네릭 클래스를 구현하는 방법에 대한 문서입니다.

Added in version 3.9.

Union Type¶

유니언 객체는 여러 type objects 에 대한 | (비트 논리합) 연산의 값을 가집니다. 이러한 타입들은 주로 type annotations 용으로 설계되었습니다. 유니언 타입 표현은 typing.Union 을 인덱싱하는 것보다 더 깔끔한 타입 힌트 구문을 가능하게 합니다.

X | Y | ...

X, Y 등의 타입을 포함하는 유니언 객체를 정의합니다. X | Y 는 X 또는 Y를 의미하며, 이는 typing.Union[X, Y] 와 동일합니다. 예를 들어, 다음 함수는 int 또는 float 타입의 인자를 기대합니다:

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

참고

| 연산자는 하나 이상의 멤버가 전방 참조(forward reference)인 유니언을 런타임에 정의하는 데 사용할 수 없습니다. 예를 들어, 아직 정의되지 않은 클래스를 참조하는 "Foo"``가 포함된 ``int | "Foo"``는 런타임에 실패합니다. 전방 참조를 포함하는 유니언의 경우, 전체 표현을 문자열로 표시하십시오(예: ``"int | Foo").

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]
type(int | str) is typing.Union

Optional 타입은 None 을 포함하는 유니언으로 표기할 수 있습니다:
```
str | None == typing.Optional[str]
```

isinstance(obj, union_object)

issubclass(obj, union_object)

isinstance() 및 issubclass() 호출도 유니언 객체와 함께 지원됩니다:

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

그러나 유니언 객체 내의 parameterized generics 는 검사할 수 없습니다:

>>> isinstance(1, int | list[int])  # short-circuit evaluation
True
>>> isinstance([1], int | list[int])
Traceback (most recent call last):
  ...
TypeError: isinstance() argument 2 cannot be a parameterized generic

유니언 객체에 대한 사용자 노출 타입은 typing.Union 에서 접근할 수 있으며 isinstance() 검사에 사용될 수 있습니다:

>>> import typing
>>> isinstance(int | str, typing.Union)
True
>>> typing.Union()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot create 'typing.Union' 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 | C

PEP 604 – X | Y 구문과 Union 타입을 제안하는 PEP.

Added in version 3.10.

버전 3.14에서 변경: 유니언 객체는 이제 typing.Union 의 인스턴스입니다. 이전에는 types.UnionType 의 인스턴스였으며, 이는 여전히 typing.Union 의 에일리어스로 남아 있습니다.

기타 내장 타입¶

인터프리터는 다른 종류의 객체들을 지원합니다. 이 중 대부분은 하나 또는 두 개의 연산만 지원합니다.

모듈¶

모듈에 대한 유일한 특별한 연산은 어트리뷰트 접근입니다: m.name, 여기서 m 은 모듈이며 name 은 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'> 로 표시됩니다.

클래스 및 클래스 인스턴스¶

이들에 대해서는 객체, 값, 형 및 클래스 정의 를 참조하십시오.

함수¶

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

함수 객체에는 사실 두 가지 종류가 있습니다: 내장 함수와 사용자 정의 함수입니다. 둘 다 동일한 연산(함수 호출)을 지원하지만, 구현 방식이 다르기 때문에 서로 다른 객체 타입을 가집니다.

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

메서드¶

메서드는 어트리뷰트 표기법을 사용하여 호출되는 함수입니다. 두 가지 종류가 있습니다: built-in methods (예: 리스트의 append())와 class instance methods 입니다. 내장 메서드는 이를 지원하는 타입과 함께 설명됩니다.

인스턴스를 통해 메서드(클래스 네임스페이스에 정의된 함수)에 접근하면 특별한 객체인 bound method (또는 instance method 라고도 함)를 얻게 됩니다. 호출 시, 이 객체는 인자 목록에 self 를 추가합니다. 연결된 메서드는 두 개의 특별한 읽기 전용 어트리뷰트를 가집니다: m.__self__ 는 메서드가 작동하는 객체이고, m.__func__ 는 메서드를 구현하는 함수입니다. m(arg-1, arg-2, ..., arg-n) 을 호출하는 것은 m.__func__(m.__self__, arg-1, arg-2, ..., arg-n) 을 호출하는 것과 완전히 동일합니다.

function objects 와 마찬가지로, 연결된 메서드 객체도 임의의 어트리뷰트를 가져올 수 있습니다. 하지만 메서드 어트리뷰드는 실제로 기본 함수 객체(method.__func__)에 저장되므로, 연결된 메서드에서 메서드 어트리뷰트를 설정하는 것은 허용되지 않습니다. 메서드에 어트리뷰트를 설정하려고 하면 AttributeError 가 발생합니다. 메서드 어트리뷰트를 설정하려면 기본 함수 객체에서 명시적으로 설정해야 합니다.

>>> class C:
...     def method(self):
...         pass
...
>>> c = C()
>>> c.method.whoami = 'my name is 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'

자세한 내용은 인스턴스 메서드(Instance methods) 를 참조하십시오.

코드 객체¶

코드 객체는 구현체에서 함수 본체와 같은 “의사 컴파일”된 실행 가능한 파이썬 코드를 표현하는 데 사용됩니다. 이들은 전역 실행 환경에 대한 참조를 포함하지 않기 때문에 함수 객체와 다릅니다. 코드 객체는 내장 compile() 함수에 의해 반환되며, 함수 객체의 __code__ 어트리뷰트를 통해 추출할 수 있습니다. 또한 code 모듈을 참조하십시오.

__code__ 에 접근하면 인자 obj 와 "__code__" 를 사용하여 auditing event object.__getattr__ 를 발생시킵니다.

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

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

타입 객체¶

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

타입은 <class 'int'> 와 같이 쓰입니다.

Null 객체¶

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

이 객체는 None 으로 표기됩니다.

Ellipsis 객체¶

이 객체는 일반적으로 무언가가 생략되었음을 나타내는 데 사용됩니다. 특별한 연산을 지원하지 않습니다. 정확히 하나의 ellipsis 객체가 있으며, 이름은 Ellipsis (내장 이름)입니다. type(Ellipsis)() 는 Ellipsis 싱글톤을 생성합니다.

이 객체는 Ellipsis 또는 ... 로 표기됩니다.

일반적인 사용 사례에서, Ellipsis 객체로서의 ... 은 다음과 같은 몇 가지 다른 위치에 나타납니다:

callable arguments 또는 tuple elements 와 같은 타입 어노테이션에서 사용됩니다.
pass statement 대신 함수의 본문으로 사용됩니다.
Numpy’s slicing and striding 와 같은 서드파티 라이브러리에서 사용됩니다.

파이썬은 또한 다음과 같이 Ellipsis 객체가 아닌 방식으로 점 세 개를 사용하기도 합니다:

누락된 콘텐츠의 패턴으로서 사용되는 Doctest의 ELLIPSIS.
입력이 불완전할 때 interactive 셸의 기본 파이썬 프롬프트.

마지막으로, 파이썬 문서는 일반적인 영어 관습에 따라 생략된 내용을 의미하기 위해 점 세 개를 자주 사용하며, 여기에는 Ellipsis 로 사용된 코드 예제도 포함됩니다.

NotImplemented 객체¶

이 객체는 지원하지 않는 타입에 대해 연산을 수행하도록 요구받는 비교 및 이진 연산에서 반환됩니다. 자세한 내용은 비교 를 참조하십시오. 정확히 하나의 NotImplemented 객체가 있으며, type(NotImplemented)() 가 싱글톤 인스턴스를 생성합니다.

이 객체는 NotImplemented 로 표기됩니다.

내부 객체¶

이 정보는 표준형 계층 를 참조하십시오. 여기에는 stack frame objects, traceback objects, 그리고 slice 객체가 설명되어 있습니다.

특수 어트리뷰트¶

구현에서는 관련이 있는 여러 객체 타입에 몇 가지 특별한 읽기 전용 어트리뷰트를 추가합니다. 이 중 일부는 dir() 내장 함수에 의해 보고되지 않습니다.

definition.__name__¶: 클래스, 함수, 메서드, 디스크립터 또는 제너레이터 인스턴스의 이름.

definition.__qualname__¶: 클래스, 함수, 메서드, 디스크립터 또는 제너레이터 인스턴스의 qualified name.

Added in version 3.3.

definition.__module__¶: 클래스 또는 함수가 정의된 모듈의 이름.

definition.__doc__¶: 클래스나 함수의 문서화된 문자열(docstring), 또는 정의되지 않은 경우 None.

definition.__type_params__¶: 제네릭 클래스, 함수, 및 type aliases 의 type parameters 입니다. 제네릭이 아닌 클래스와 함수의 경우, 이는 빈 튜플이 됩니다.

Added in version 3.12.

정수 문자열 변환 길이 제한¶

CPython은 서비스 거부(DoS) 공격을 완화하기 위해 int 와 str 사이의 변환에 대한 전역 제한을 두고 있습니다. 이 제한은 십진법이나 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)  # 예시이며, 이는 기본값입니다.
>>> _ = 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; 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  # 16진법은 제한이 없습니다.

기본 제한은 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')
...

Added in version 3.11.

영향을 받는 API¶

이 제한은 int 와 str 또는 bytes 사이의 속도가 느려질 수 있는 변환에만 적용됩니다:

기본 10진법을 사용하는 int(string).
2의 거듭제곱이 아닌 모든 진법에 대한 int(string, base).
str(integer).
repr(integer).
any other string conversion to base 10, for example f"{integer}", "{}".format(integer), or b"%d" % integer.

다음과 같은 선형 알고리즘을 사용하는 함수에는 제한이 적용되지 않습니다:

진법이 2, 4, 8, 16 또는 32인 int(string, base).
int.from_bytes() 및 int.to_bytes().
hex(), oct(), bin().
16진수, 8진수, 2진수를 위한 포맷 명세 미니 언어.
str 에서 float 으로의 변환.
str 에서 decimal.Decimal 으로의 변환.

제한 설정¶

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

PYTHONINTMAXSTRDIGITS, 예: 제한을 640으로 설정하는 PYTHONINTMAXSTRDIGITS=640 python3 또는 제한을 비활성화하는 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 의 값을 포함합니다. 환경 변수와 -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 제외).

Added in version 3.11.

조심

낮은 제한을 설정하면 문제가 발생할 수 있습니다. 드문 경우이긴 하지만, 소스 코드에 최소 임계값을 초과하는 10진수 정수 상수가 포함된 코드가 존재하기 때문입니다. 제한을 설정하면, 파이썬 소스 코드에 제한보다 긴 10진수 정수 리터럴이 포함된 경우 파싱 중에 오류가 발생하게 됩니다. 이는 보통 시작 시점, 가져오기 시점, 또는 최신 .pyc 파일이 아직 존재하지 않는 설치 시점에 발생합니다. 이러한 큰 상수를 포함하는 소스에 대한 해결 방법은 제한이 없는 0x 16진수 형식으로 변환하는 것입니다.

낮은 제한을 사용하는 경우 애플리케이션을 철저히 테스트하십시오. 파이썬이 .py 소스를 .pyc 파일로 사전 컴파일하기 위해 실행될 수 있는 설치 단계나 시작 시점에도 적용되도록 환경 변수나 플래그를 통해 미리 제한을 설정하고 테스트를 수행하십시오.

권장 구성¶

기본값인 sys.int_info.default_max_str_digits 는 대부분의 애플리케이션에서 적절할 것으로 예상됩니다. 애플리케이션에서 다른 제한이 필요한 경우, 3.12 이전 버전의 보안 패치 릴리스에서 추가된 이러한 API들을 고려하여 파이썬 버전에 구애받지 않는 코드를 사용하여 메인 진입점에서 설정하십시오.

예제:

>>> 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 으로 설정하십시오.

각주

Built-in Types¶

Truth Value Testing¶

Boolean Operations — and, or, not¶

Comparisons¶

숫자 형 — int, float, complex¶

정수형에 대한 비트 연산¶

정수형에 대한 추가 메서드¶

부동소수점(Float)에 대한 추가 메서드¶

Complex에 대한 추가 메서드¶

수치 타입의 해싱¶

불린(Boolean) 타입 - bool¶

이터레이션 관련 타입¶

이터러블(Iterables)¶

이터레이터(Iterators)¶

제너레이터 유형¶

제너레이터 이터레이터¶

비동기 제너레이터 이터레이터¶

시퀀스 타입 — list, tuple, range¶

공통 시퀀스 연산¶

불변 시퀀스 유형¶

가변 시퀀스 유형¶

리스트¶

튜플¶

범위¶

텍스트 및 바이너리 시퀀스 타입 메서드 요약¶

텍스트 시퀀스 유형 — str¶

문자열 메서드¶

포맷 문자열 리터럴 (f-strings)¶

디버그 지정자¶

변환 지정자¶

포맷 지정자¶

템플릿 문자열 리터럴 (t-strings)¶

printf 스타일 문자열 포매팅¶

바이트 시퀀스 타입 — bytes, bytearray, memoryview¶

바이트 객체¶

bytearray 객체¶

Bytes 및 Bytearray 연산¶

printf 스타일의 Bytes 포매팅¶

Memory Views¶

집합 형 — set, frozenset¶

매핑 형 — dict, frozendict¶

딕셔너리 뷰 객체¶

고정된 딕셔너리¶

컨텍스트 관리자 유형¶

타입 어노테이션 유형 — Generic Alias, Union¶

Generic Alias 유형¶

표준 제네릭 클래스¶

GenericAlias 객체의 특별한 어트리뷰트¶

Union Type¶

기타 내장 타입¶

모듈¶

클래스 및 클래스 인스턴스¶

함수¶

메서드¶

코드 객체¶

타입 객체¶

Null 객체¶

Ellipsis 객체¶

NotImplemented 객체¶

내부 객체¶

특수 어트리뷰트¶

정수 문자열 변환 길이 제한¶

영향을 받는 API¶

제한 설정¶

권장 구성¶

분실물 보관소

Boolean Operations — `and`, `or`, `not`¶

숫자 형 — `int`, `float`, `complex`¶

불린(Boolean) 타입 - `bool`¶

시퀀스 타입 — `list`, `tuple`, `range`¶

텍스트 시퀀스 유형 — `str`¶

`printf` 스타일 문자열 포매팅¶

바이트 시퀀스 타입 — `bytes`, `bytearray`, `memoryview`¶

`printf` 스타일의 Bytes 포매팅¶

집합 형 — `set`, `frozenset`¶

매핑 형 — `dict`, `frozendict`¶

타입 어노테이션 유형 — Generic Alias, Union ¶

`GenericAlias` 객체의 특별한 어트리뷰트¶