☰ Menu Python

☰ Menu

내장형

다음 섹션에서는 인터프리터에 내장된 표준형에 관해 설명합니다.

기본 내장 유형은 숫자, 시퀀스, 매핑, 클래스, 인스턴스 및 예외입니다.

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

일부 연산들은 여러 객체 형에서 지원됩니다; 특히 사실상 모든 객체를 동등 비교하고, 논리값을 검사하고, (repr() 함수 또는 약간 다른 str() 함수를 사용해서) 문자열로 변환할 수 있습니다. 두 번째 함수는 print() 함수로 객체를 쓸 때 묵시적으로 사용됩니다.

논리값 검사

모든 객체는 논리값을 검사할 수 있는데, if 또는 while 조건 또는 다음에 나오는 논리 연산의 피연산자로 사용될 수 있도록 합니다.

기본적으로 객체의 클래스가 False 를 반환하는 __bool__() 메서드를 정의하거나, 호출 시 0을 반환하는 __len__() 메서드를 정의하지 않는 한 해당 객체는 참(true)으로 간주됩니다. [1] 만약 이 중 하나 이상의 메서드가 호출될 때 예외를 발생시키면 그 예외가 전파되고 객체는 진릿값(예: NotImplemented)을 갖지 않게 됩니다. 다음은 거짓(false)으로 간주되는 대부분의 내장 객체입니다:

• 거짓으로 정의된 상수: None 및 False

• 모든 숫자 형들의 영: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)

• 빈 시퀀스와 컬렉션: '', (), [], {}, set(), range(0)

논리값을 돌려주는 연산과 내장 함수는 달리 명시하지 않는 한 항상 거짓의 경우 0 이나 False 를, 참이면 1 이나 True 를 돌려줍니다. (중요한 예외: 논리 연산 or 와 and 는 항상 피연산자 중 하나를 돌려줍니다.)

논리 연산 — and, or, not

이것들은 우선순위에 따라 오름차순으로 정렬된 논리 연산들입니다:

연산	결과	노트
x or y	x*가 참이면 *x, 그렇지 않으면 y	(1)
x and y	x*가 거짓이면 *x, 그렇지 않으면 y	(2)
not x	x 가 거짓이면 True, 그렇지 않으면 False	(3)

노트:

1. 이것은 단락-회로 연산자이므로 첫 번째 인자가 거짓일 때만 두 번째의 값을 구합니다.

2. 이것은 단락-회로 연산자이므로 첫 번째 인자가 참일 때만 두 번째의 값을 구합니다.

3. not 은 비논리 연산자들보다 낮은 우선순위를 갖습니다. 그래서, not a == b 는 not (a == b) 로 해석되고, a == not b 는 문법 오류입니다.

비교

파이썬에는 8가지 비교 연산이 있습니다. 이들 모두는 같은 우선순위를 가집니다 (논리 연산보다는 높습니다). 비교는 임의로 연결될 수 있습니다; 예를 들어 x < y <= z 는 y 의 값을 한 번만 구한다는 점을 제외하고는 x < y and y <= z 와 동등합니다 (하지만 두 경우 모두 x < y 가 거짓으로 밝혀지면 z 의 값을 구하지 않습니다).

이 표는 비교 연산을 요약합니다:

연산	뜻
<	엄격히 작다
<=	작거나 같다
>	엄격히 크다
>=	크거나 같다
==	같다
!=	같지 않다
is	객체 아이덴티티
is not	부정된 객체 아이덴티티

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

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

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

is 와 is not 연산자의 동작은 사용자 정의할 수 없습니다; 또한 임의의 두 객체에 적용할 수 있으며 예외를 발생시키지 않습니다.

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

숫자 형 — int, float, complex

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

숫자는 숫자 리터럴을 통해 또는 내장 함수 및 연산자의 결과로 생성됩니다. 아무런 장식도 없는 정수 리터럴(16진수, 8진수, 이진수를 포함)은 정수를 반환합니다. 소수점이나 지수 부호를 포함하는 숫자 리터럴은 부동 소수점을 반환합니다. 숫자 리터럴에 'j' 또는 'J' 를 추가하면 허수(실수 부분이 0인 복소수)가 반환되며, 이를 정수나 실수에 더하여 실수부와 허수부를 모두 갖는 복소수를 얻을 수 있습니다.

생성자 int(), float(), complex()를 특정 형의 숫자를 만드는데 사용할 수 있습니다.

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

• 두 인자 모두 복소수이면 변환이 수행되지 않으며;

• 어느 한쪽 인자가 복소수 또는 부동 소수점 수인 경우 다른 하나가 부동 소수점 수로 변환되며;

• 그렇지 않은 경우, 둘 다 정수여야 하며 변환이 필요하지 않습니다.

복소수 및 실수 피연산자를 이용한 산술 연산은 일반적인 수학 공식에 따라 정의됩니다. 예:

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

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

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

연산	결과	노트	전체 문서
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)

노트:

1. 정수 나눗셈이라고도 합니다. int 형의 피연산자의 경우 결과는 int 형이며, float 형의 피연산자의 경우 결과는 float 형입니다. 일반적으로 결과는 정수이지만, 결과의 형이 반드시 int 인 것은 아닙니다. 결과는 항상 마이너스 무한대 방향으로 반올림됩니다: 1//2 는 0, (-1)//2 는 -1, 1//(-2) 는 -1, (-1)//(-2) 는 0 입니다.

2. 복소수에는 사용할 수 없습니다. 적절한 경우 abs()를 사용하여 실수로 변환하십시오.

3. float 에서 int 로의 변환은 소수 부분을 버리고 절삭합니다. 다른 방식의 변환을 원하시면 math.floor() 및 math.ceil() 함수를 참조하십시오.

4. float는 또한 숫자가 아님(NaN)과 양 또는 음의 무한대를 나타내는 문자열 “nan”과 접두사 “+” 나 “-” 가 선택적으로 붙을 수 있는 “inf”를 받아들입니다.

5. 파이썬은 프로그래밍 언어들에서 흔히 그렇듯이, 있는 것처럼 pow(0, 0) 와 0 ** 0 이 1 이 되도록 정의합니다.

6. 받아들여지는 숫자 리터럴은 0 에서 9 까지 또는 모든 동등한 유니코드들을 (Nd 속성을 가진 코드 포인트들) 포함합니다.

   Nd 속성을 가진 코드 포인트의 전체 목록은 『Unicode 표준 <https://unicode.org/Public/UNIDATA/extracted/DerivedNumericType.txt>』을 참조하십시오.

모든 numbers.Real 형 (int 와 float) 은 또한 다음과 같은 연산들을 포함합니다:

연산	결과
math.trunc(x)	x 는 Integral 로 잘립니다
round(x[, n])	x 를 n 자리로 반올림하는데, 절반 값은 짝수로 반올림합니다. n 을 생략하면 기본값은 0입니다.
math.floor(x)	가장 큰 Integral <= x
math.ceil(x)	가장 작은 Integral >= x

추가적인 숫자 연산은 math와 cmath 모듈을 보십시오.

정수 형에 대한 비트 연산

비트 연산은 정수에 대해서만 의미가 있습니다. 비트 연산의 결과는 무한한 부호 비트를 갖는 2의 보수로 수행되는 것처럼 계산됩니다.

이진 비트 연산의 우선순위는 모두 숫자 연산보다 낮고 비교보다 높습니다; 일항 연산 ~ 은 다른 일항 연산들 (+ 와 -) 과 같은 우선순위를 가집니다.

이 표는 비트 연산을 나열하는데, 우선순위에 따라 오름차순으로 정렬되어 있습니다:

연산	결과	노트
x | y	x 와 y 의 비트별 or	(4)
x ^ y	x 와 y 의 비트별 배타적 or (exclusive or)	(4)
x & y	x 와 y 의 비트별 and	(4)
x << n	x 를 n 비트만큼 왼쪽으로 시프트	(1)(2)
x >> n	x 를 n 비트만큼 오른쪽으로 시프트	(1)(3)
~x	x 의 비트 반전

노트:

1. 음의 시프트 수는 허락되지 않고 ValueError 를 일으킵니다.

2. n 비트만큼의 왼쪽 시프트는 pow(2, n) 를 곱하는 것과 동등합니다.

3. n 비트만큼 오른쪽으로 시프트 하는 것은 pow(2, n) 로 정수 나눗셈(floor division)하는 것과 동등합니다.

4. 무한한 부호 비트가 있는 것과 같은 결과를 얻으려면, 유한한 2의 보수 표현으로 적어도 하나의 추가적인 부호 확장 비트를 사용하여 (1 + max(x.bit_length(), y.bit_length()) 이상의 작업 비트 폭) 이러한 계산을 수행하는 것으로 충분합니다.

정수 형에 대한 추가 메서드

int 형은 numbers.Integral 추상 베이스 클래스 를 구현합니다. 또한, 몇 가지 메서드를 더 제공합니다:

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') # 선행 영과 마이너스 기호 제거
    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" 이면 가장 중요한 바이트(most significant byte)가 바이트 배열의 시작 부분에 위치합니다. 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

인자 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() 와의 덕 타이핑(duck type) 호환성을 위해 존재합니다.

Added in version 3.12.

실수에 대한 추가 메서드

float 형은 numbers.Real 추상 베이스 클래스 를 구현합니다. 또한, float는 다음과 같은 추가 메서드를 갖습니다.

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

원래의 float와 정확히 동일한 비율을 가진 두 정수의 쌍을 반환합니다. 이 비율은 기약 분수로 표현되며 양의 분모를 갖습니다. 무한대(infinity)인 경우 OverflowError 를, NaN인 경우 ValueError 를 발생시킵니다.

float.is_integer()

float 인스턴스가 정숫값을 가진 유한이면 True 를, 그렇지 않으면 False 를 돌려줍니다:

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

두 가지 메서드가 16진수 문자열과의 변환을 지원합니다. 파이썬의 float는 내부적으로 이진수로 저장되기 때문에 float를 십진수 문자열로 또는 그 반대로 변환하는 것은 보통 반올림 오류를 수반합니다. 이에 반해, 16진수 문자열은 부동 소수점 숫자의 정확한 표현과 지정을 가능하게 합니다. 이것은 디버깅 및 수치 작업에 유용할 수 있습니다.

float.hex()

부동 소수점의 16진수 문자열 표현을 돌려줍니다. 유한 부동 소수점의 경우, 이 표현은 항상 선행하는 0x 와 후행하는 p 와 지수를 포함합니다.

classmethod float.fromhex(s)

16진수 문자열 s 로 표현되는 float를 돌려주는 클래스 메서드. 문자열 s 는 앞뒤 공백을 가질 수 있습니다.

float.hex() 는 인스턴스 메서드인 반면, float.fromhex() 는 클래스 메서드임에 주의하세요.

16진수 문자열은 다음과 같은 형식을 취합니다:

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

선택적인 sign 은 + 나 - 가 될 수 있고, integer 와 fraction 은 16진수 문자열이고, exponent 는 선택적인 선행 부호가 붙을 수 있는 십진수입니다. 대소 문자는 중요하지 않으며 integer 나 fraction 중 어느 하나에 적어도 하나의 16진수가 있어야 합니다. 이 문법은 C99 표준의 6.4.4.2 절에 지정된 문법과 비슷하며, 자바 1.5 이상에서 사용되는 문법과도 비슷합니다. 특히, float.hex() 의 출력은 C 또는 자바 코드에서 16진수의 부동 소수점 리터럴로 사용할 수 있으며, C의 %a 포맷 문자나 자바의 Double.toHexString 가 만들어내는 16진수 문자열은 float.fromhex() 가 받아들입니다.

지수는 16진수가 아닌 십진수로 쓰이고, 숫자에 곱해지는 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)

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

일반적인 Python 객체 x 에 대해, complex.from_number(x) 는 x.__complex__() 로 위임됩니다. 만약 __complex__() 가 정의되어 있지 않으면 __float__() 를 사용하며, 만약 __float__() 도 정의되어 있지 않으면 __index__() 를 사용합니다.

Added in version 3.14.

숫자 형의 해싱

서로 다른 유형일 수 있는 숫자 x 와 y 에 대해, x == y 인 경우 항상 hash(x) == hash(y) 여야 한다는 요구사항이 있습니다(자세한 내용은 __hash__() 메서드 문서를 참조하십시오). 다양한 숫자 유형(int, float, decimal.Decimal, fractions.Fraction 포함)에서 구현의 용이성과 효율성을 위해, Python은 모든 유리수에 대해 정의되는 단일 수학적 함수를 기반으로 수치형 타입의 해시를 생성합니다. 따라서 이 함수는 int 및 fractions.Fraction 의 모든 인스턴스와 float 및 decimal.Decimal 의 모든 유한한 인스턴스에 적용됩니다. 기본적으로 이 함수는 고정된 소수 P 에 대한 모듈로 연산으로 주어집니다. P 의 값은 sys.hash_info 의 modulus 속성으로 제공됩니다.

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

다음은 규칙에 대한 세부 사항입니다:

• x = m / n 이 음이 아닌 유리수이고 n 이 P 로 나뉘지 않는다면, hash(x) 를 m * invmod(n, P) % P 로 정의합니다. 여기서 invmod(n, P) 는 n 의 모듈로 P 역수를 줍니다.

• x = m / n 이 음이 아닌 유리수이고 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 의 해시를 계산하는, 내장 해시와 동등한, 파이썬 코드를 예시합니다:

import sys, math

def hash_fraction(m, n):
    """유리수 m / n의 해시를 계산합니다.

    m과 n은 정수이며, n은 양수라고 가정합니다.
    hash(fractions.Fraction(m, n))과 동일합니다.

    """
    P = sys.hash_info.modulus
    # P의 공약수를 제거합니다. (m과 n이 이미 서로소인 경우 불필요합니다.)
    while m % P == n % P == 0:
        m, n = m // P, n // P

    if n % P == 0:
        hash_value = sys.hash_info.inf
    else:
        # 페르마의 소정리: pow(n, P-1, P)은 1이므로,
        # pow(n, P-2, P)는 모듈로 P에 대한 n의 역원을 구합니다.
        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):
    """부동 소수점 수 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):
    """복소수 z의 해시를 계산합니다."""

    hash_value = hash_float(z.real) + sys.hash_info.imag * hash_float(z.imag)
    # 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

불린 타입 - bool

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

내장 함수 bool() 은 값이 참으로 해석될 수 있는 경우 모든 값을 불린으로 변환합니다(위의 논리값 검사 섹션을 참조하십시오).

논리 연산의 경우 boolean operators and, or, not 을 사용하십시오. 두 개의 불린에 비트 단위 연산자 &, |, ^ 를 적용하면 논리 연산 “and”, “or”, “xor”와 동일한 결과의 bool을 반환합니다. 하지만 일반적으로 &, |, ^ 보다는 논리 연산자인 and, or 및 != 를 사용하는 것이 권장됩니다.

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

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

이터레이터 형

파이썬은 컨테이너에 대한 이터레이션 개념을 지원합니다. 이것은 두 개의 메서드를 사용해서 구현됩니다; 이것들은 사용자 정의 클래스가 이터레이션을 지원할 수 있도록 하는 데 사용됩니다. 아래에서 더 자세히 설명할 시퀀스는 항상 이터레이션 메서드를 지원합니다.

컨테이너 객체가 iterable 지원을 제공하려면 하나 이상의 메서드를 정의해야 합니다:

container.__iter__()

iterator 객체를 반환합니다. 이 객체는 아래에 설명된 반복자 프로토콜(iterator protocol)을 지원해야 합니다. 만약 컨테이너가 여러 유형의 반복을 지원하는 경우, 해당 반복 유형에 대한 반복자를 특별히 요청할 수 있는 추가 메서드를 제공할 수 있습니다 (여러 형태의 반복을 지원하는 객체의 예는 광역 탐색과 깊이 우선 순회(depth-first traversal)를 모두 지원하는 트리 구조입니다). 이 메서드는 Python/C API에서 파이썬 객체에 대한 타입 구조의 tp_iter 슬롯에 해당합니다.

이터레이터 객체 자체는 다음과 같은 두 가지 메서드를 지원해야 하는데, 둘이 함께 이터레이터 프로토콜 (iterator protocol) 를 이룹니다.:

iterator.__iter__()

이터레이터 객체 자체를 반환합니다. 이는 컨테이너와 이터레이터를 모두 for 및 in 문과 함께 사용하기 위해 필요합니다. 이 메서드는 Python/C API의 파이썬 객체 타입 구조에 있는 tp_iter 슬롯에 해당합니다.

iterator.__next__()

Return the next item from the iterator. If there are no further items, raise the StopIteration exception. This method corresponds to the tp_iternext slot of the type structure for Python objects in the Python/C API.

파이썬은 일반적이거나 특정한 시퀀스 형, 딕셔너리, 기타 더 특화된 형태에 대한 이터레이션을 지원하기 위해 여러 이터레이터 객체를 정의합니다. 이터레이터 프로토콜의 구현을 넘어서 개별적인 형이 중요하지는 않습니다.

일단 이터레이터의 __next__() 메서드가 StopIteration 를 일으키면, 그 이후의 호출에 대해서도 같이 동작해야 합니다. 이 속성을 따르지 않는 구현은 망가진 것으로 간주합니다.

제너레이터 형

Python’s generators provide a convenient way to implement the iterator protocol. If a container object’s __iter__() method is implemented as a generator, it will automatically return an iterator object (technically, a generator object) supplying the __iter__() and __next__() methods. More information about generators can be found in the documentation for the yield expression.

시퀀스 형 — list, tuple, range

세 가지 기본 시퀀스 형이 있습니다: 리스트, 튜플, 범위 객체. 바이너리 데이터 와 텍스트 문자열 의 처리를 위해 추가된 시퀀스 형들은 별도의 섹션에서 설명합니다.

공통 시퀀스 연산

다음 표의 연산들은 대부분의 가변과 불변 시퀀스에서 지원됩니다. 사용자 정의 시퀀스에서 이 연산들을 올바르게 구현하기 쉽게 하려고 collections.abc.Sequence ABC가 제공됩니다.

이 표는 우선순위에 따라 오름차순으로 시퀀스 연산들을 나열합니다. 표에서, s 와 t 는 같은 형의 시퀀스고, n, i, j, k 는 정수이고, x 는 s 가 요구하는 형과 값 제한을 만족하는 임의의 객체입니다.

in 과 not in 연산은 비교 연산과 우선순위가 같습니다. + (이어 붙이기)와 * (반복) 연산은 대응하는 숫자 연산과 같은 우선순위를 갖습니다. [3]

연산	결과	노트
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 미만으로 떨어질 때에만 종료됩니다.

노트:

1. in 과 not in 연산은 일반적으로 단순한 포함 검사를 위해서만 사용되지만, 몇몇 특수한 시퀀스 (str, bytes, bytearray 같은) 들은 서브 시퀀스 검사에 사용하기도 합니다:

   >>> "gg" in "eggs"
   True
   

2. n 의 값이 0 보다 작으면 0 으로 처리됩니다 (s 와 같은 형의 빈 시퀀스가 됩니다). 시퀀스 s 의 항목들이 복사되지 않음에 주의해야 합니다; 그들은 여러 번 참조됩니다. 이것은 종종 새 파이썬 프로그래머들을 괴롭힙니다; 이 코드를 살펴보세요:

   >>> lists = [[]] * 3
   >>> lists
   [[], [], []]
   >>> lists[0].append(3)
   >>> lists
   [[3], [3], [3]]
   

   무슨 일이 일어났는가 하면, [[]] 는 빈 리스트를 포함하는 길이 1인 리스트인데, [[]] * 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 항목 다차원 리스트를 어떻게 만듭니까?에서 얻을 수 있습니다.

3. i 또는 j 가 음수인 경우, 인덱스는 시퀀스 s 의 끝에 상대적입니다: len(s) + i 이나 len(s) + j 로 치환됩니다. 하지만 -0 은 여전히 0 입니다.

4. 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 와 같거나 더 크면 슬라이스는 비어 있습니다.

5. 스텝 k 가 있는 i 에서 j 까지의 슬라이스는 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 이면, 그것들은 “끝” 값이 됩니다 (끝은 k 의 부호에 따라 달라집니다). k 는 0일 수 없음에 주의하세요. k 가 None 이면 1 로 취급됩니다.

6. 불변 시퀀스를 이어 붙이면 항상 새로운 객체가 생성됩니다. 이것은 반복적으로 이어붙이기를 해서 시퀀스를 만들 때 실행 시간이 시퀀스의 총 길이의 제곱에 비례한다는 뜻입니다. 선형 실행 시간 비용을 얻으려면 아래 대안 중 하나로 전환해야 합니다:

   • str 객체를 이어붙이기를 한다면, 리스트를 만들고 마지막에 str.join() 을 사용하거나 io.StringIO 인스턴스에 쓰고 완료될 때 값을 꺼낼 수 있습니다

   • bytes 객체를 연결하는 경우 비슷하게 bytes.join() 또는 io.BytesIO 를 사용하거나, bytearray 객체를 사용하여 제자리에서 이어붙이기를 할 수 있습니다. bytearray 객체는 가변이고 효율적인 과할당(overallocation) 메커니즘을 가지고 있습니다.

   • tuple 객체를 이어붙이기를 한다면, 대신 list를 extend 하십시오.

   • 다른 형의 경우 관련 클래스 문서를 조사하십시오.

7. 일부 시퀀스 형 (예를 들어 range)은 특정 패턴을 따르는 항목 시퀀스 만 지원하기 때문에 시퀀스 이어붙이기나 반복을 지원하지 않습니다.

8. 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 는 임의의 이터러블 객체이며, x 는 s 가 요구하는 형 및 값 제한을 충족시키는 임의의 객체입니다 (예를 들어, bytearray 는 값 제한 0 <= x <= 255 를 만족하는 정수만 받아들입니다.

연산	결과	노트
s[i] = x	s 의 항목 i 를 x 로 대체합니다
del s[i]	s 의 항목 i 를 제거합니다
s[i:j] = t	i 에서 j 까지의 s 슬라이스가 이터러블 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	t 의 내용으로 s 를 확장합니다 (대부분 s[len(s):len(s)] = t 와 같습니다)
s *= n	내용이 n 번 반복되도록 s 를 갱신합니다	(2)

노트:

1. k 가 1 과 같지 않으면, t 는 대체되는 슬라이스와 동일한 길이를 가져야 합니다.

2. 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, /)

iterable 의 내용으로 sequence 를 확장합니다. 대부분의 경우 이는 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 은 리스트 항목들이 별도의 키값을 계산하지 않고 직접 정렬된다는 것을 의미합니다.

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

reverse 는 논리값입니다. True 로 설정되면, 각 비교가 역전된 것처럼 리스트 요소들이 정렬됩니다.

이 메서드는 큰 시퀀스를 정렬할 때 공간 절약을 위해 시퀀스를 제자리에서 수정합니다. 부작용으로 작동한다는 것을 사용자에게 상기시키기 위해 정렬된 시퀀스를 돌려주지 않습니다 (새 정렬 된 리스트 인스턴스를 명시적으로 요청하려면 sorted()를 사용하십시오).

sort() 메서드는 안정적임이 보장됩니다. 정렬은 같다고 비교되는 요소들의 상대적 순서를 변경하지 않으면 안정적입니다 — 이는 여러 번 정렬하는 데 유용합니다 (예를 들어, 부서별로 정렬한 후에 급여 등급으로 정렬).

정렬 예제와 간단한 정렬 자습서는 정렬 기법를 참조하십시오.

리스트가 정렬되는 동안, 리스트를 변경하려고 할 때의, 또는 관찰하려고 할 때조차, 효과는 정의되지 않습니다. 파이썬의 C 구현은 그동안 리스트를 비어있는 것으로 보이게 하고, 정렬 중에 리스트가 변경되었음을 감지할 수 있다면 ValueError 를 일으킵니다.

더 보기

list 객체에 대한 스레드 안전성 보장에 관한 자세한 내용은 리스트 객체의 스레드 안전성 를 참조하십시오.

튜플

튜플은 불변 시퀀스인데, 보통 이질적인 데이터의 모음을 저장하는 데 사용됩니다 (예를 들어, 내장 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) 는 3개의 인자를 가진 함수 호출이지만, f((a, b, c)) 는 하나의 인자로 3-튜플을 갖는 함수 호출입니다.

튜플은 공통 시퀀스 연산을 모두 구현합니다.

튜플은 내용의 유형에 대한 제네릭 입니다. 자세한 내용은 튜플 어노테이션에 관한 타이핑 문서 를 참조하십시오.

이름에 의한 액세스가 인덱스에 의한 액세스보다 더 명확한 이질적 데이터 컬렉션의 경우, 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 의 내용은 식 r[i] = start + step*i 에 의해 결정됩니다. 이때 i >= 0 이고 r[i] < stop 입니다.

음수 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))
[]

범위는 이어 붙이기와 반복을 제외한 공통 시퀀스 연산을 모두 구현합니다 (범위 객체는 엄격한 패턴을 따르는 시퀀스 만 나타낼 수 있는데 반복과 이어 붙이기는 보통 그 패턴을 위반한다는 사실에 기인합니다).

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에서 변경: 시퀀스 ABC를 구현합니다. int 객체의 포함 검사는 모든 항목을 이터레이트하는 대신 상수 시간으로 수행됩니다.

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

start, stop, step 속성을 추가했습니다.

더 보기

• linspace 레시피 <https://code.activestate.com/recipes/579000-equally-spaced-numbers-linspace/> 는 부동 소수점 애플리케이션에 적합한 range의 지연(lazy) 버전을 구현하는 방법을 보여줍니다.

텍스트 및 바이너리 시퀀스 형 메서드 요약

다음 표는 카테고리에 따른 텍스트 및 바이너리 시퀀스 형의 메서드를 요약합니다.

카테고리	str 메서드				bytes 및 bytearray 메서드
포매팅	str.format()
	str.format_map()
	f-문자열
	기존 문자열 포매팅				printf 스타일 바이너리 포매팅
검색 및 치환	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.translate()				bytes.translate()
	str.maketrans()				bytes.maketrans()
	str.encode()
					bytes.decode()

텍스트 시퀀스 형 — str

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

• 작은따옴표: '"큰" 따옴표를 담을 수 있습니다'

• 쌍따옴표: "내부에 '홑따옴표'를 포함할 수 있음"

• 삼중 따옴표: '''세 개의 작은따옴표''', """세 개의 큰따옴표"""

삼중 따옴표로 묶인 문자열은 여러 줄에 걸쳐있을 수 있습니다 - 연관된 모든 공백이 문자열 리터럴에 포함됩니다.

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

지원되는 이스케이프 시퀀스 <escape-sequences>`와 대부분의 이스케이프 시퀀스 처리를 비활성화하는 ``r` (“raw”) 접두사를 포함하여 문자열 리터럴의 다양한 형식에 대해서는 문자열과 바이트열 리터럴 를 참조하십시오.

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

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

또한, 가변 문자열형은 없지만, 여러 단편으로부터 문자열을 효율적으로 구성하는데 str.join() 또는 io.StringIO 를 사용할 수 있습니다.

버전 3.3에서 변경: 파이썬 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) 는 object 의 “비형식적인” 또는 보기 좋게 출력 가능한 문자열 표현인 type(object).__str__(object) 를 반환합니다. 문자열 객체의 경우, 이는 해당 문자열 자체입니다. object 가 __str__() 메서드를 가지고 있지 않은 경우, str() 은 repr(object) 을 반환하는 것으로 대체됩니다.

encoding 또는 errors 중 적어도 하나가 주어지면, object 는 bytes-like object (예, bytes 또는 bytearray) 이어야 합니다. 이 경우, object 가 bytes (또는 bytearray) 객체이면, str(bytes, encoding, errors) 는 bytes.decode(encoding, errors) 와 동등합니다. 그 이외의 경우, bytes.decode() 호출 전에 버퍼 객체의 하부 바이트열 객체를 얻습니다. 버퍼 객체에 대한 정보는 바이너리 시퀀스 형 — bytes, bytearray, memoryview와 버퍼 프로토콜 를 보십시오.

encoding 또는 errors 인자 없이 bytes 객체를 str() 에 전달하는 것은 비형식적 문자열 표현을 반환하는 첫 번째 상황에 해당합니다 (파이썬 명령행 옵션 -b 도 보십시오). 예를 들면:

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

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

문자열 메서드

문자열은 공통 시퀀스 연산들을 모두 구현하고, 아래에 기술된 추가적인 메서드도 구현합니다.

문자열은 또한 두 가지 스타일의 문자열 포매팅을 지원합니다. 하나는 큰 폭의 유연성과 사용자 지정을 제공하고 (참조 str.format(), 포맷 문자열 문법, 사용자 정의 문자열 포매팅을 참조하세요) 다른 하나는 C printf 스타일에 기반을 두는데, 더 좁은 범위의 형을 처리하고 올바르게 사용하기는 다소 어렵지만, 처리할 수 있는 경우에는 종종 더 빠릅니다 (printf 스타일 문자열 포매팅).

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

str.capitalize()

첫 문자가 대문자이고 나머지가 소문자인 문자열의 복사본을 돌려줍니다.

버전 3.8에서 변경: 이제 첫 번째 문자는 대문자가 아닌 제목 케이스로 바뀝니다. 이는 이중 문자(digraph)와 같은 문자는 전체 문자 대신 첫 문자만 대문자로 표시된다는 뜻입니다.

str.casefold()

케이스 폴딩 된 문자열을 반환합니다. 케이스 폴딩 된 문자열은 대소문자를 무시한 매칭에 사용될 수 있습니다.

케이스 폴딩은 소문자 변환과 유사하지만 문자열 내의 모든 케이스 구분을 제거하기 위해 설계되었으므로 더 강력하게 동작합니다. 예를 들어, 독일어 소문자 'ß' 는 "ss" 와 동일합니다. 이미 소문자이므로 lower() 는 'ß' 에 아무런 변화를 주지 않지만, casefold() 는 이를 "ss" 로 변환합니다. 예시:

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

케이스 폴딩 알고리즘은 Unicode 표준의 3.13.3 ‘Default Case Folding’ 섹션 <https://www.unicode.org/versions/Unicode17.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() 를 통해 등록된 기타 이름이 있습니다. 자세한 내용은 에러 처리기 를 참조하십시오.

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

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

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

버전 3.9에서 변경: 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 형식으로 포매팅할 때 (예: '{:n}'.format(1234)), 이 함수는 일시적으로 LC_CTYPE 로케일을 LC_NUMERIC 로케일로 설정하여 localeconv() 의 decimal_point 와 thousands_sep 필드를 디코드하는데, 이 필드들이 ASCII가 아니거나 1바이트보다 길고, LC_NUMERIC 로케일이 LC_CTYPE 로케일과 다를 때만 그렇게 합니다. 이 임시 변경은 다른 스레드에 영향을 줍니다.

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

str.format_map(mapping, /)

str.format(**mapping) 과 비슷하지만, dict로 복사되지 않고 mapping 을 직접 사용합니다. 예를 들어 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``가 다음 중 하나라도 ``True``를 반환하면 알파벳 또는 숫자로 간주됩니다: ``c.isalpha(), c.isdecimal(), c.isdigit(), 또는 c.isnumeric(). 예시:

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

str.isalpha()

문자열의 모든 문자가 알파벳이고 적어도 하나의 문자가 있는 경우 True 를 반환하고, 그렇지 않으면 False 를 반환합니다. 알파벳 문자는 유니코드 문자 데이터베이스에서 “Letter”로 정의된 문자들(즉, 일반 범주 속성이 “Lm”, “Lt”, “Lu”, “Ll”, 또는 “Lo” 중 하나인 것)을 의미합니다. 이는 Unicode 표준 <https://www.unicode.org/versions/Unicode17.0.0/core-spec/chapter-4/#G91002>의 4.10절 ‘Letters, Alphabetic, and Ideographic’에 정의된 Alphabetic property 와는 다릅니다. 예시:

>>> 'Letters and spaces'.isalpha()
False
>>> 'LettersOnly'.isalpha()
True
>>> 'µ'.isalpha()  # non-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진법으로 숫자를 구성하는 데 사용될 수 있는 문자입니다. 형식적으로 십진수 문자는 유니코드 일반 범주 “Nd”에 속하는 문자입니다. 예시:

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

str.isdigit()

문자열의 모든 문자가 디짓이고 적어도 하나의 문자가 있는 경우 True 를 반환하고, 그렇지 않으면 False 를 반환합니다. 디짓은 십진수 문자와 호환성 위 첨자 숫자와 같이 특수한 처리가 필요한 숫자를 포함합니다. 여기에는 Kharosthi 숫자 <https://en.wikipedia.org/wiki/Kharosthi#Numerals> 처럼 10진법으로 숫자를 구성하는 데 사용될 수 없는 숫자들도 포함됩니다. 형식적으로 디짓은 속성 값이 Numeric_Type=Digit 또는 Numeric_Type=Decimal인 문자입니다.

예:

>>> '0123456789'.isdigit()
True
>>> '٠١٢٣٤٥٦٧٨٩'.isdigit()  # 아랍-인도 숫자 0에서 9까지
True
>>> '⅕'.isdigit()  # 기수분수 1/5
False
>>> '²'.isdecimal(), '²'.isdigit(),  '²'.isnumeric()
(False, True, True)

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

str.isidentifier()

문자열이 섹션 section 이름(식별자 및 키워드) 의 언어 정의에 따른 유효한 식별자면 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 를 반환합니다. 숫자는 디짓과 U+2155(VULGAR FRACTION ONE FIFTH)와 같이 유니코드 수치 값 속성을 가진 모든 문자를 포함합니다. 형식적으로 숫자는 속성 값이 Numeric_Type=Digit, Numeric_Type=Decimal 또는 Numeric_Type=Numeric인 문자입니다. 예시:

>>> '0123456789'.isnumeric()
True
>>> '٠١٢٣٤٥٦٧٨٩'.isnumeric()  # 아랍-인도 숫자 0에서 9까지
True
>>> '⅕'.isnumeric()  # 기수분수 1/5
True
>>> '²'.isdecimal(), '²'.isdigit(),  '²'.isnumeric()
(False, True, True)

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

str.isprintable()

문자열의 모든 문자가 인쇄 가능하면 True 를 반환하고, 최소 하나 이상의 인쇄할 수 없는 문자가 포함된 경우 False 를 반환합니다.

여기에서 “인쇄 가능(printable)”은 문자가 repr() 의 출력에 적합함을 의미하며, “인쇄할 수 없음(non-printable)”은 내장 타입에 대한 repr() 이 해당 문자를 16진수로 이스케이프 처리한다는 것을 의미합니다. 이는 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 및 줄 바꿈
True
>>> '\u3000'.isspace() # 전각 공백
True

유니코드 문자 데이터베이스(unicodedata를 참조하십시오)에서, 일반 범주(general category)가 Zs(“Separator, space”)이거나 양방향 클래스(bidirectional class)가 WS, B 또는 S 중 하나이면 문자는 공백(whitespace)입니다.

isprintable() 도 참조하십시오.

str.istitle()

문자열이 제목 케이스 문자열이고 하나 이상의 문자가 있는 경우 True를 돌려줍니다. 예를 들어 대문자 앞에는 케이스 없는 문자만 올 수 있고 소문자는 케이스 문자 뒤에만 올 수 있습니다. 그렇지 않은 경우는 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'

사용된 소문자 변환 알고리즘은 유니코드 표준의 섹션 3.13.2 ‘기본 케이스 변환’ <https://www.unicode.org/versions/Unicode17.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() 와 비슷하지만, 부분 문자열 10% 를 찾을 수 없는 경우 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", ' ', 'Circus')
>>> 'Monty Python'.rpartition('-')
('', '', 'Monty Python')

참고: partition().

str.rsplit(sep=None, maxsplit=-1)

sep 를 구분자 문자열로 사용하여 문자열에 있는 단어들의 리스트를 돌려줍니다. maxsplit 이 주어지면 가장 오른쪽에서 최대 maxsplit 번의 분할이 수행됩니다. sep 이 지정되지 않거나 None 이면, 구분자로 모든 공백 문자가 사용됩니다. 오른쪽에서 분리하는 것을 제외하면, 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 를 구분자 문자열로 사용하여 문자열에 있는 단어들의 리스트를 돌려줍니다. maxsplit 이 주어지면 최대 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 이면, 다른 분할 알고리즘이 적용됩니다: 연속된 공백 문자는 단일한 구분자로 간주하고, 문자열이 선행이나 후행 공백을 포함해도 결과는 시작과 끝에 빈 문자열을 포함하지 않습니다. 결과적으로, 빈 문자열이나 공백만으로 구성된 문자열을 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 가 참으로 주어지지 않는 한 결과 리스트에 줄 바꿈은 포함되지 않습니다.

이 메서드는 다음 줄 경계에서 나눕니다. 특히, 경계는 유니버설 줄 넘김 을 포함합니다.

표현	설명
\n	줄 넘김
\r	캐리지 리턴
\r\n	캐리지 리턴 + 줄 넘김
\v 또는 \x0b	수직 탭
\f 또는 \x0c	폼 피드
\x1c	파일 구분자
\x1d	그룹 구분자
\x1e	레코드 구분자
\x85	다음 줄 (C1 제어 코드)
\u2028	줄 구분자
\u2029	문단 구분자

버전 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, /)

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

예:

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

단어가 대문자로 시작하고 나머지 문자는 소문자가 되도록 문자열의 제목 케이스 버전을 돌려줍니다.

예를 들면:

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

제공된 변환 테이블을 통해 각 문자를 매핑한 문자열의 복사본을 반환합니다. 테이블은 __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, 대문자) 가 아닌 경우, 예를 들어 “Lt” (Letter, 제목 케이스), s.upper().isupper() 가 False 일 수 있음에 주의하십시오.

사용된 대문자 변환 알고리즘은 유니코드 표준 <https://www.unicode.org/versions/Unicode17.0.0/core-spec/chapter-3/#G34078>의 섹션 3.13.2 ‘기본 경우 변환(Default Case Conversion)’에 설명되어 있습니다.

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에서 변경: await 및 async for 를 f-strings 내의 표현식에서 사용할 수 있습니다.

버전 3.8에서 변경: 디버그 지정자(=)가 추가되었습니다.

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

f-string (공식적으로는 formatted string literal)은 f 또는 F``를 접두어로 하는 문자열 리터럴입니다. 이 유형의 문자열 리터럴은 중괄호(``{})로 구분되는 치환 필드 내에 임의의 Python 표현식 결과를 포함할 수 있습니다. 각 치환 필드는 반드시 표현식을 포함해야 하며, 선택적으로 다음이 올 수 있습니다:

• 한 개의 디버그 지정자 — 등호(=);

• 변환 지정자(conversion specifier) — !s, !r 또는 !a; 그리고/또는

• 콜론(:)으로 시작하는 포맷 지정자(format specifier).

이 필드들의 구문에 대한 자세한 내용은 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 {one_third!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)

t-string (공식적으로는 template string literal)은 t 또는 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 을 사용하면 이러한 오류를 피하는 데 도움이 될 수 있습니다. 이 대안들은 각각 단순성, 유연성, 확장성 면에서 고유한 장단점이 있습니다.

문자열 객체에는 독특한 내장 연산이 하나 있습니다. 바로 % 연산자(modulo)입니다. 이는 문자열 포매팅 또는 보간 연산자로도 알려져 있습니다. 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 는 format 문자열이 지정하는 항목의 수와 같은 튜플이거나 단일 매핑 객체 (예를 들어, 딕셔너리) 이어야 합니다.

변환 명세는 두 개 이상의 문자를 포함하며 다음과 같은 구성 요소들을 포함하는데, 반드시 이 순서대로 나와야 합니다:

1. '%' 문자: 명세의 시작을 나타냅니다.

2. 매핑 키 (선택 사항): 괄호로 둘러싸인 문자들의 시퀀스로 구성됩니다 (예를 들어, (somename)).

3. 변환 플래그 (선택 사항): 일부 변환 유형의 결과에 영향을 줍니다.

4. 최소 필드 폭 (선택 사항): '*' (애스터리스크) 로 지정하면, 실제 폭은 values 튜플의 다음 요소에서 읽히고, 변환할 객체는 최소 필드 폭과 선택적 정밀도 뒤에 옵니다.

5. 정밀도 (선택 사항): '.' (점) 다음에 정밀도가 옵니다. '*' (애스터리스크) 로 지정하면, 실제 정밀도는 values 튜플의 다음 요소에서 읽히고, 변환할 값은 정밀도 뒤에 옵니다.

6. 길이 수정자 (선택 사항).

7. 변환 유형.

오른쪽 인자가 딕셔너리 (또는 다른 매핑 형) 인 경우, 문자열에 있는 변환 명세는 반드시 '%' 문자 바로 뒤에 그 딕셔너리의 매핑 키를 괄호로 둘러싼 형태로 포함해야 합니다. 매핑 키는 포맷할 값을 매핑으로 부터 선택합니다. 예를 들어:

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

이 경우 * 지정자를 사용할 수 없습니다 (순차적인 매개변수 목록이 필요하기 때문입니다).

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

플래그	뜻
'#'	값 변환에 “대체 형식” (아래에 정의되어있습니다) 을 사용합니다.
'0'	변환은 숫자 값의 경우 0으로 채웁니다.
'-'	변환된 값은 왼쪽으로 정렬됩니다 (둘 다 주어지면 '0' 변환보다 우선 합니다).
' '	(스페이스) 부호 있는 변환 때문에 만들어진 양수 앞에 빈칸을 남겨둡니다 (음수면 빈 문자열입니다).
'+'	부호 문자 ('+' or '-') 가 변환 앞에 놓입니다 (' ' 플래그에 우선합니다).

길이 수정자 (h, l, L) 를 제공할 수는 있지만, 파이썬에서 필요하지 않기 때문에 무시됩니다 – 예를 들어 %ld 는 %d 와 같습니다.

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

변환	뜻	노트
'd'	부호 있는 정수 십진 표기.
'i'	부호 있는 정수 십진 표기.
'o'	부호 있는 8진수 값.	(1)
'u'	쓸데없는 유형 – 'd' 와 같습니다.	(6)
'x'	부호 있는 16진수 (소문자).	(2)
'X'	부호 있는 16진수 (대문자).	(2)
'e'	부동 소수점 지수 형식(소문자).	(3)
'E'	부동 소수점 지수 형식(대문자).	(3)
'f'	부동 소수점 10진수 형식.	(3)
'F'	부동 소수점 10진수 형식.	(3)
'g'	부동 소수점 포맷. 지수가 -4보다 작거나 정밀도보다 작지 않은 경우 소문자 지수 형식을 사용하고, 그렇지 않으면 10진수 형식을 사용합니다.	(4)
'G'	부동 소수점 포맷. 지수가 -4보다 작거나 정밀도보다 작지 않은 경우 대문자 지수 형식을 사용하고, 그렇지 않으면 10진수 형식을 사용합니다.	(4)
'c'	단일 문자 (정수 또는 길이 1인 문자열을 허용합니다).
'r'	문자열 (repr()을 사용하여 파이썬 객체를 변환합니다).	(5)
's'	문자열 (str() 을 사용하여 파이썬 객체를 변환합니다).	(5)
'a'	문자열 (ascii() 를 사용하여 파이썬 객체를 변환합니다).	(5)
'%'	인자는 변환되지 않고, 결과에 '%' 문자가 표시됩니다.

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

노트:

1. 대체 형식은 첫 번째 숫자 앞에 선행 8진수 지정자 ('0o')를 삽입합니다.

2. 대체 형식은 첫 번째 숫자 앞에 선행 '0x' 또는 '0X' ('x' 나 'X' 유형 중 어느 것을 사용하느냐에 따라 달라집니다) 를 삽입합니다.

3. 대체 형식은 그 뒤에 숫자가 나오지 않더라도 항상 소수점을 포함합니다.

   정밀도는 소수점 이하 자릿수를 결정하며 기본값은 6입니다.

4. 대체 형식은 결과에 항상 소수점을 포함하고 뒤에 오는 0은 제거되지 않습니다.

   정밀도는 소수점 앞뒤의 유효 자릿수를 결정하며 기본값은 6입니다.

5. 정밀도가 N 이라면, 출력은 N 문자로 잘립니다.

6. PEP 237을 참조하세요.

파이썬 문자열은 명시적인 길이를 가지고 있으므로, %s 변환은 문자열의 끝이 '\0' 이라고 가정하지 않습니다.

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

바이너리 시퀀스 형 — bytes, bytearray, memoryview

바이너리 데이터를 조작하기 위한 핵심 내장형은 bytes 와 bytearray 입니다. 이것들은 memoryview 에 의해 지원되는데, 다른 바이너리 객체들의 메모리에 복사 없이 접근하기 위해 버퍼 프로토콜 을 사용합니다.

array 모듈은 32-비트 정수와 IEEE754 배정도 부동 소수점 같은 기본 데이터형의 효율적인 저장을 지원합니다.

바이트열 객체

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

class bytes(source=b'')

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

첫째로, 바이트열 리터럴의 문법은 문자열 리터럴과 거의 같지만 b 접두사가 추가된다는 점이 다릅니다.:

• 작은따옴표: b'still allows embedded "double" quotes'

• 큰따옴표: b"여전히 포함된 '작은따옴표'를 허용함"

• 삼중 따옴표: 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진수는 정확히 하나의 바이트에 대응하기 때문에 16진수는 바이너리 데이터를 설명하는 데 일반적으로 사용되는 형식입니다. 따라서, 바이트열 형은 그 형식의 데이터를 읽는 추가의 클래스 메서드를 갖습니다:

classmethod fromhex(string, /)

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

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

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

버전 3.14에서 변경: bytes.fromhex() 는 이제 ASCII bytes 및 바이트와 유사한 객체 를 입력으로 받아들입니다.

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

hex(*, bytes_per_sep=1)

hex(sep, bytes_per_sep=1)

인스턴스의 바이트마다 2 자릿수의 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()는 16진수 출력의 바이트 사이에 구분 기호를 삽입하기 위해 선택적 sep과 bytes_per_sep 매개 변수를 지원합니다.

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

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

바이트 배열 객체

bytearray 객체는 bytes 객체의 가변형입니다.

class bytearray(source=b'')

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

바이트 배열 객체에 대한 전용 리터럴 문법은 없으며 항상 생성자를 호출하여 만듭니다:

• 빈 인스턴스 만들기: bytearray()

• 주어진 길이의 0으로 채워진 인스턴스 만들기: bytearray(10)

• 정수의 이터러블로부터: bytearray(range(20))

• 버퍼 프로토콜을 통해 기존 바이너리 데이터 복사: bytearray(b'Hi!')

바이트 배열 객체는 가변이기 때문에, 바이트열 과 바이트 배열 연산 에 설명되어있는 공통 바이트열과 바이트 배열 연산에 더해, 가변 시퀀스 연산도 지원합니다.

내장 bytearray 도 참조하세요.

2개의 16진수는 정확히 하나의 바이트에 대응하기 때문에 16진수는 바이너리 데이터를 설명하는 데 일반적으로 사용되는 형식입니다. 따라서, 바이트 배열형은 그 형식의 데이터를 읽는 추가의 클래스 메서드를 갖습니다:

classmethod fromhex(string, /)

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

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

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

버전 3.14에서 변경: bytearray.fromhex() 는 이제 ASCII bytes 및 바이트와 유사한 객체 를 입력으로 받아들입니다.

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

hex(*, bytes_per_sep=1)

hex(sep, bytes_per_sep=1)

인스턴스의 바이트마다 2 자릿수의 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, /)

bytearray 의 크기를 size 바이트로 조정합니다. size 는 0보다 크거나 같아야 합니다.

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

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

이는 다음과 같습니다:

>>> 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 바이트를 제거하고 이를 변경 불가능한 bytes 로 반환합니다. 기본값으로(n 이 None 인 경우), 모든 바이트를 반환하고 bytearray를 비웁니다.

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

전체 길이보다 적게 가져오면 남은 바이트가 bytearray 에 남아 있어 복사가 필요합니다. 남은 바이트를 버려야 하는 경우, resize() 또는 del 을 사용하여 자른 다음 크기 지정 없이 take_bytes() 를 사용하십시오.

모든 바이트를 가져오는 것은 제로 복사(zero-copy) 연산입니다.

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

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

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

더 보기

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

바이트열 과 바이트 배열 연산

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

참고

바이트열 및 바이트 배열 객체의 메서드는 인자로 문자열을 받아들이지 않습니다, 문자열의 메서드가 바이트열을 인자로 허용하지 않는 것과 마찬가지입니다. 예를 들어, 다음과 같이 작성해야 합니다:

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

그리고:

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

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

참고

이러한 ASCII 기반 연산을 사용하여 ASCII 기반 형식으로 저장되지 않은 바이너리 데이터를 조작하면 데이터가 손상될 수 있습니다.

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

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

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

범위 [start, end] 에서 서브 시퀀스 sub 가 중첩되지 않고 등장하는 횟수를 돌려줍니다. 선택적 인자 start 와 end 는 슬라이스 표기법으로 해석됩니다.

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

sub 이 비어 있는 경우, 문자 사이의 빈 슬라이스 개수인 바이트 객체의 길이에 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는 임의의 바이트열류 객체 일 수 있습니다.

참고

이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다.

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는 임의의 바이트열류 객체 일 수 있습니다.

참고

이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다.

Added in version 3.9.

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

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

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

encoding 의 기본값은 'utf-8' 입니다. 가능한 값에 대한 자세한 내용은 표준 인코딩 를 참조하십시오.

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

성능상의 이유로 디코딩 오류가 실제로 발생하거나, 개발자 모드 가 활성화되거나, 디버그 빌드 를 사용하는 경우가 아니면 errors 의 유효성을 확인하지 않습니다.

참고

Passing the encoding argument to str allows decoding any bytes-like object directly, without needing to make a temporary bytes or bytearray object.

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

버전 3.9에서 변경: errors 인자 값은 이제 파이썬 개발 모드 및 디버그 모드 에서 확인됩니다.

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

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

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

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

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

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

서브 시퀀스 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 의 바이너리 데이터 시퀀스들을 이어 붙이기 한 바이트열 또는 바이트 배열 객체를 돌려줍니다. iterable 에 str 객체나 기타 bytes-like object 가 아닌 값이 있으면 TypeError 를 일으킵니다. 요소들 사이의 구분자는 이 메서드를 제공하는 바이트열 이나 바이트 배열 객체입니다.

static bytes.maketrans(from, to, /)

static bytearray.maketrans(from, to, /)

이 정적 메서드는 bytes.translate() 에 사용할 수 있는 변환표를 돌려주는데, from 에 있는 문자를 to 의 같은 위치에 있는 문자로 매핑합니다; from 과 to 는 모두 bytes-like object 여야 하고 길이가 같아야 합니다.

Added in version 3.1.

bytes.partition(sep, /)

bytearray.partition(sep, /)

sep 가 처음 나타나는 위치에서 시퀀스를 나누고, 구분자 앞에 있는 부분, 구분자 자체, 구분자 뒤에 오는 부분으로 구성된 3-튜플을 돌려줍니다. 구분자가 발견되지 않으면, 원래 시퀀스의 복사본과 그 뒤를 따르는 두 개의 빈 바이트열 또는 바이트 배열 객체로 구성된 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 일 수 있습니다.

참고

이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다.

버전 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 가 마지막으로 나타나는 위치에서 시퀀스를 나누고, 구분자 앞에 있는 부분, 구분자 자체, 구분자 뒤에 오는 부분으로 구성된 3-튜플을 돌려줍니다. 구분자가 발견되지 않으면, 두 개의 빈 바이트열 또는 바이트 배열 객체와 그 뒤를 따르는 원래 시퀀스의 복사본으로 구성된 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 의 모든 바이트를 제거하고, 나머지 바이트들을 주어진 변환표로 매핑한 바이트열이나 바이트 배열 객체의 복사본을 돌려줍니다. table은 길이 256인 바이트열 객체이어야 합니다.

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

문자를 지우기만 하는 변환에는 table 인자를 None 으로 설정하십시오:

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

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

바이트열 및 바이트 배열 객체에 대한 다음 메서드는 ASCII 호환 바이너리 형식의 사용을 가정하는 기본 동작을 갖지만, 적절한 인자를 전달하여 임의의 바이너리 데이터와 함께 사용할 수 있습니다. 이 섹션의 바이트 배열 메서드는 모두 제자리에서 작동하지 않고 대신 새로운 객체를 생성함에 주의하십시오.

bytes.center(width, fillbyte=b' ', /)

bytearray.center(width, fillbyte=b' ', /)

길이 width 인 시퀀스의 가운데에 정렬한 객체의 복사본을 돌려줍니다. 지정된 fillbyte (기본값은 ASCII 스페이스)를 사용하여 채웁니다. bytes 객체의 경우, width 가 len(s) 보다 작거나 같은 경우 원래 시퀀스가 반환됩니다.

참고

이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다.

bytes.ljust(width, fillbyte=b' ', /)

bytearray.ljust(width, fillbyte=b' ', /)

왼쪽으로 정렬된 객체의 복사본을 길이 width 인 시퀀스로 돌려줍니다. 지정된 fillbyte (기본값은 ASCII 스페이스)을 사용하여 채웁니다. bytes 객체의 경우, width 가 len(s) 보다 작거나 같은 경우 원래 시퀀스가 반환됩니다.

참고

이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다.

bytes.lstrip(bytes=None, /)

bytearray.lstrip(bytes=None, /)

지정된 앞부분 바이트가 제거된 시퀀스의 복사본을 반환합니다. bytes 인자는 제거할 바이트 값의 집합을 지정하는 바이너리 시퀀스입니다. 생략되거나 None 인 경우, bytes 인자는 기본적으로 ASCII 공백을 제거합니다. bytes 인자는 접두사가 아니라, 그 값이 포함된 모든 조합이 제거됩니다:

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

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

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

참고

이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다.

bytes.rjust(width, fillbyte=b' ', /)

bytearray.rjust(width, fillbyte=b' ', /)

오른쪽으로 정렬된 객체의 복사본을 길이 width 인 시퀀스로 돌려줍니다. 지정된 fillbyte (기본값은 ASCII 스페이스)를 사용하여 채웁니다. bytes 객체의 경우, width 가 len(s) 보다 작거나 같은 경우 원래 시퀀스가 반환됩니다.

참고

이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다.

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

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

sep 을 구분자 시퀀스로 사용하여 바이너리 시퀀스를 같은 형의 서브 시퀀스로 나눕니다. maxsplit 이 주어지면 가장 오른쪽에서 최대 maxsplit 번의 분할이 수행됩니다. sep 이 지정되지 않거나 None 이면, ASCII 공백 문자만으로 이루어진 모든 서브 시퀀스는 구분자입니다. 오른쪽에서 분리하는 것을 제외하면, rsplit()는 아래에서 자세히 설명될 split()처럼 동작합니다.

bytes.rstrip(bytes=None, /)

bytearray.rstrip(bytes=None, /)

지정된 뒷부분 바이트가 제거된 시퀀스의 복사본을 반환합니다. bytes 인자는 제거할 바이트 값의 집합을 지정하는 바이너리 시퀀스입니다. 생략되거나 None 인 경우, bytes 인자는 기본적으로 ASCII 공백을 제거합니다. bytes 인자는 접미사가 아니라, 그 값이 포함된 모든 조합이 제거됩니다:

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

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

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

참고

이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다.

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

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

sep 를 구분자 시퀀스로 사용하여 바이너리 시퀀스를 같은 형의 서브 시퀀스로 나눕니다. maxsplit 이 지정되고 음수가 아닌 경우, 최대 maxsplit 분할이 수행됩니다 (따라서, 리스트는 최대 maxsplit+1 개의 요소를 가지게 됩니다). maxsplit 이 지정되지 않았거나 -1 이라면 분할 수에 제한이 없습니다 (가능한 모든 분할이 만들어집니다).

만약 sep 가 주어지면, 연속된 구분자는 그룹화되지 않으며 빈 하위 시퀀스를 경계 짓는 것으로 간주됩니다(예를 들어, b'1,,2'.split(b',') 은 [b'1', b'', b'2'] 을 반환합니다). sep 인자는 단일 구분자로 다중 바이트 시퀀스로 구성될 수 있습니다. 지정된 구분자로 빈 시퀀스를 나누면, 분할되는 객체의 유형에 따라 [b''] 또는 [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 공백 문자는 단일한 구분자로 간주하고, 시퀀스가 선행이나 후행 공백을 포함해도 결과는 시작과 끝에 빈 시퀀스를 포함하지 않습니다. 결과적으로, 빈 시퀀스나 ASCII 공백만으로 구성된 시퀀스를 None 구분자로 나누면 [] 를 돌려줍니다.

예를 들면:

>>> 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 공백을 제거합니다. bytes 인자는 접두사나 접미사가 아니라, 그 값이 포함된 모든 조합이 제거됩니다:

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

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

참고

이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다.

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

bytes.capitalize()

bytearray.capitalize()

각 바이트가 ASCII 문자로 해석되고 첫 번째 바이트는 대문자로, 나머지는 소문자로 만든 시퀀스의 복사본을 돌려줍니다. ASCII 바이트가 아닌 값들은 변경되지 않고 전달됩니다.

참고

이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다.

bytes.expandtabs(tabsize=8)

bytearray.expandtabs(tabsize=8)

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

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

참고

이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다.

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 제목 케이스고 시퀀스가 비어있지 않으면 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' 에 있는 바이트 값입니다.

참고

이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다.

bytes.splitlines(keepends=False)

bytearray.splitlines(keepends=False)

ASCII 줄 경계에서 나눈 바이너리 시퀀스의 줄 리스트를 돌려줍니다. 이 메서드는 줄을 나누는데 universal newlines 접근법을 사용합니다. keepends 가 참으로 주어지지 않는 한 결과 리스트에 줄 바꿈은 포함되지 않습니다.

예를 들면:

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

구분자 시퀀스 sep 이 주어졌을 때 split() 와 달리, 이 메서드는 빈 시퀀스에 대해서 빈 리스트를 돌려주고, 마지막 줄 바꿈은 새 줄을 만들지 않습니다:

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

bytes.swapcase()

bytearray.swapcase()

모든 ASCII 소문자를 해당 대문자로, 그 반대도 마찬가지로 변환한 시퀀스의 복사본을 돌려줍니다.

예를 들면:

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

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

str.swapcase() 와 달리, 바이너리 버전의 경우 bin.swapcase().swapcase() == bin 이 항상 성립합니다. 임의의 유니코드 코드 포인트에 대해 일반적으로 그렇지 않지만, ASCII에서는 대소문자 변환이 대칭적으로 이루어집니다.

참고

이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다.

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

참고

이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다.

bytes.upper()

bytearray.upper()

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

예를 들면:

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

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

참고

이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다.

bytes.zfill(width, /)

bytearray.zfill(width, /)

길이가 width 인 시퀀스를 만들기 위해 ASCII b'0' 문자를 왼쪽에 채운 시퀀스의 복사본을 돌려줍니다. 선행 부호 접두어(b'+'/b'-')는 부호 문자의 앞이 아니라 뒤 에 채우는 것으로 처리됩니다. bytes 객체의 경우, width 가 len(s) 보다 작거나 같은 경우 원래 시퀀스를 돌려줍니다.

예를 들면:

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

참고

이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다.

printf 스타일 바이너리 포매팅

참고

여기에 설명된 포맷 연산은 여러 가지 일반적인 오류를 (예를 들어 튜플과 딕셔너리를 올바르게 표시하지 못하는 것) 유발하는 다양한 문제점들이 있습니다. 인쇄될 값이 튜플 또는 딕셔너리일 경우 튜플로 감싸야 합니다.

바이너리 시퀀스 객체는 한가지 고유한 내장 연산을 갖고 있습니다: % 연산자 (모듈로). 이것은 바이너리 포매팅 또는 치환 연산자라고도 합니다. format % values 가 주어질 때 (format 은 바이너리 시퀀스입니다), format 내부의 % 변환 명세는 0개 이상의 values 의 요소로 대체됩니다. 이 효과는 C 언어에서 sprintf()를 사용하는 것과 비슷합니다.

format 이 하나의 인자를 요구하면, values 는 하나의 비 튜플 객체 일 수 있습니다. [5] 그렇지 않으면, values 는 format 바이너리 시퀀스 객체가 지정하는 항목의 수와 같은 튜플이거나 단일 매핑 객체 (예를 들어, 딕셔너리) 여야 합니다.

변환 명세는 두 개 이상의 문자를 포함하며 다음과 같은 구성 요소들을 포함하는데, 반드시 이 순서대로 나와야 합니다:

1. '%' 문자: 명세의 시작을 나타냅니다.

2. 매핑 키 (선택 사항): 괄호로 둘러싸인 문자들의 시퀀스로 구성됩니다 (예를 들어, (somename)).

3. 변환 플래그 (선택 사항): 일부 변환 유형의 결과에 영향을 줍니다.

4. 최소 필드 폭 (선택 사항): '*' (애스터리스크) 로 지정하면, 실제 폭은 values 튜플의 다음 요소에서 읽히고, 변환할 객체는 최소 필드 폭과 선택적 정밀도 뒤에 옵니다.

5. 정밀도 (선택 사항): '.' (점) 다음에 정밀도가 옵니다. '*' (애스터리스크) 로 지정하면, 실제 정밀도는 values 튜플의 다음 요소에서 읽히고, 변환할 값은 정밀도 뒤에 옵니다.

6. 길이 수정자 (선택 사항).

7. 변환 유형.

오른쪽 인자가 딕셔너리 (또는 다른 매핑 형) 인 경우, 바이너리 시퀀스 객체에 있는 변환 명세는 반드시 '%' 문자 바로 뒤에 그 딕셔너리의 매핑 키를 괄호로 둘러싼 형태로 포함해야 합니다. 매핑 키는 포맷할 값을 매핑으로 부터 선택합니다. 예를 들어:

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

이 경우 * 지정자를 사용할 수 없습니다 (순차적인 매개변수 목록이 필요하기 때문입니다).

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

플래그	뜻
'#'	값 변환에 “대체 형식” (아래에 정의되어있습니다) 을 사용합니다.
'0'	변환은 숫자 값의 경우 0으로 채웁니다.
'-'	변환된 값은 왼쪽으로 정렬됩니다 (둘 다 주어지면 '0' 변환보다 우선 합니다).
' '	(스페이스) 부호 있는 변환 때문에 만들어진 양수 앞에 빈칸을 남겨둡니다 (음수면 빈 문자열입니다).
'+'	부호 문자 ('+' or '-') 가 변환 앞에 놓입니다 (' ' 플래그에 우선합니다).

길이 수정자 (h, l, L) 를 제공할 수는 있지만, 파이썬에서 필요하지 않기 때문에 무시됩니다 – 예를 들어 %ld 는 %d 와 같습니다.

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

변환	뜻	노트
'd'	부호 있는 정수 십진 표기.
'i'	부호 있는 정수 십진 표기.
'o'	부호 있는 8진수 값.	(1)
'u'	쓸데없는 유형 – 'd' 와 같습니다.	(8)
'x'	부호 있는 16진수 (소문자).	(2)
'X'	부호 있는 16진수 (대문자).	(2)
'e'	부동 소수점 지수 형식(소문자).	(3)
'E'	부동 소수점 지수 형식(대문자).	(3)
'f'	부동 소수점 10진수 형식.	(3)
'F'	부동 소수점 10진수 형식.	(3)
'g'	부동 소수점 포맷. 지수가 -4보다 작거나 정밀도보다 작지 않은 경우 소문자 지수 형식을 사용하고, 그렇지 않으면 10진수 형식을 사용합니다.	(4)
'G'	부동 소수점 포맷. 지수가 -4보다 작거나 정밀도보다 작지 않은 경우 대문자 지수 형식을 사용하고, 그렇지 않으면 10진수 형식을 사용합니다.	(4)
'c'	단일 바이트 (정수 또는 길이 1인 바이너리 시퀀스를 허용합니다).
'b'	바이트(버퍼 프로토콜 를 따르거나 __bytes__() 가 있는 모든 객체).	(5)
's'	's' 는 'b' 의 별칭이고 파이썬 2/3에서만 사용되어야 합니다.	(6)
'a'	바이트(어떤 파이썬 객체든 repr(obj).encode('ascii', 'backslashreplace') 를 사용하여 변환)	(5)
'r'	'r' 는 'a' 의 별칭이고 파이썬 2/3에서만 사용되어야 합니다.	(7)
'%'	인자는 변환되지 않고, 결과에 '%' 문자가 표시됩니다.

노트:

1. 대체 형식은 첫 번째 숫자 앞에 선행 8진수 지정자 ('0o')를 삽입합니다.

2. 대체 형식은 첫 번째 숫자 앞에 선행 '0x' 또는 '0X' ('x' 나 'X' 유형 중 어느 것을 사용하느냐에 따라 달라집니다) 를 삽입합니다.

3. 대체 형식은 그 뒤에 숫자가 나오지 않더라도 항상 소수점을 포함합니다.

   정밀도는 소수점 이하 자릿수를 결정하며 기본값은 6입니다.

4. 대체 형식은 결과에 항상 소수점을 포함하고 뒤에 오는 0은 제거되지 않습니다.

   정밀도는 소수점 앞뒤의 유효 자릿수를 결정하며 기본값은 6입니다.

5. 정밀도가 N 이라면, 출력은 N 문자로 잘립니다.

6. b'%s' 는 폐지되었습니다. 하지만 3.x 시리즈에서는 제거되지 않습니다.

7. b'%r' 는 폐지되었습니다. 하지만 3.x 시리즈에서는 제거되지 않습니다.

8. PEP 237을 참조하세요.

참고

이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다.

더 보기

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

Added in version 3.5.

메모리 뷰

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

class memoryview(object)

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

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

memoryview 는 하부 데이터 유형에 대한 제네릭 입니다.

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 모듈의 네이티브 형식 지정자 중 하나인 경우, 정수 또는 정수의 튜플을 사용하는 인덱싱도 지원되며 올바른 형으로 하나의 요소를 돌려줍니다. 일차원 메모리 뷰는 정수 또는 하나의 정수를 갖는 튜플로 인덱싱 할 수 있습니다. 다차원 메모리 뷰는 정확히 ndim 개의 정수를 갖는 튜플로 인덱싱할 수 있습니다. 여기서 ndim 은 차원 수입니다. 영차원 메모리 뷰는 빈 튜플로 인덱싱할 수 있습니다.

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

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

하부 객체가 쓰기 가능하면, 메모리 뷰는 일차원 슬라이스 대입을 지원합니다. 크기 변경은 허용되지 않습니다:

>>> 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 (읽기 전용) 타입의 1차원 메모리 뷰도 해시 가능합니다. 이 해시는 hash(m) == hash(m.tobytes()) 로 정의됩니다:

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

버전 3.3에서 변경: One-dimensional memoryviews can now be sliced. One-dimensional memoryviews with formats ‘B’, ‘b’ or ‘c’ are now hashable.

버전 3.4에서 변경: 이제 메모리 뷰는 자동으로 collections.abc.Sequence 로 등록됩니다

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

버전 3.14에서 변경: memoryview is now a generic type.

memoryview 는 몇 가지 메서드를 가지고 있습니다:

__eq__(exporter)

메모리 뷰와 PEP 3118 제공자(exporter)는 다음과 같은 조건을 만족할 때 같다고 비교됩니다: 모양이 동등하고 피연산자의 각 형식 코드가 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, /)

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

대상 형식은 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에서 변경: 바이트 형식으로 변환할 때 소스 형식이 더는 제한되지 않습니다.

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

메모리 뷰의 하부 객체:

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

Added in version 3.3.

readonly

메모리가 읽기 전용인지 여부를 나타내는 논리값.

format

뷰의 각 요소에 대한 형식(struct 모듈 스타일)을 포함하는 문자열입니다. 메모리 뷰는 제공자로부터 임의의 형식 문자열로 만들어질 수 있지만, 일부 메서드(예, tolist())는 원시 네이티브 단일 요소 형식으로 제한됩니다.

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

itemsize

메모리 뷰 각 요소의 크기 (바이트):

>>> 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-연속 인지를 나타내는 논리값.

Added in version 3.3.

f_contiguous

메모리가 포트란 연속 인지를 나타내는 논리값.

Added in version 3.3.

contiguous

메모리가 연속 인지를 나타내는 논리값.

Added in version 3.3.

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

집합 형 — set, frozenset

집합 (set) 객체는 서로 다른 해시 가능 객체의 순서 없는 컬렉션입니다. 일반적인 용도는 멤버십 검사, 시퀀스에서 중복 제거와 교집합, 합집합, 차집합, 대칭 차집합과 같은 수학 연산을 계산하는 것입니다. (다른 컨테이너들은 내장 dict, list, tuple 클래스 및 collections 모듈을 참조하십시오.)

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

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

비어 있지 않은 set은 (frozenset 은 아닙니다) set 생성자뿐만 아니라 중괄호 안에 쉼표로 구분된 원소 목록을 넣어서 만들 수 있습니다, 예를 들어: {'jack', 'sjoerd'}.

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

class set(iterable=(), /)

class frozenset(iterable=(), /)

iterable 에서 요소를 취하는 새 set 또는 frozenset 객체를 돌려줍니다. 집합의 원소는 반드시 해시 가능 해야 합니다. 집합의 집합을 표현하려면, 포함되는 집합은 반드시 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 의 원소 수(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 | ...

집합과 모든 others에 있는 원소들로 구성된 새 집합을 돌려줍니다.

frozenset.intersection(*others)

set.intersection(*others)

set & other & ...

집합과 모든 others의 공통 원소들로 구성된 새 집합을 돌려줍니다.

frozenset.difference(*others)

set.difference(*others)

set - other - ...

집합에는 포함되었으나 others에는 포함되지 않은 원소들로 구성된 새 집합을 돌려줍니다.

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') & 'cbs' 와 같은 구성을 방지하고, 더 읽기 쉬운 set('abc').intersection('cbs') 를 사용하도록 권장합니다.

set과 frozenset 모두 집합 간의 비교를 지원합니다. 두 집합은 각 집합의 모든 원소가 다른 집합에 포함되어있는 경우에만 같습니다 (서로 다른 집합의 부분집합입니다). 집합이 다른 집합의 진부분집합(부분집합이지만 같지는 않은 경우)일 때만 첫 번째 집합이 두 번째 집합보다 작습니다. 집합이 다른 집합의 진상위집합(상위집합이지만 같지는 않은 경우)일 때만 첫 번째 집합이 두 번째 집합보다 큽니다.

set 의 인스턴스는 그 원소를 기반으로 frozenset 의 인스턴스와 비교됩니다. 예를 들어, set('abc') == frozenset('abc') 는 True 를 돌려주고 set('abc') in set([frozenset('abc')]) 도 마찬가지입니다.

부분 집합 및 동등 비교는 전 순서(total ordering) 함수로 일반화되지 않습니다. 예를 들어, 비어 있지 않은 두 개의 서로소인 집합은 같지 않고 서로의 부분 집합이 아닙니다, 그래서 다음은 모두 False 를 돌려줍니다: a<b, a==b, a>b.

집합은 부분 순서(부분 집합 관계)만 정의하기 때문에, 집합의 리스트에 대한 list.sort() 메서드의 결과는 정의되지 않습니다.

딕셔너리 키처럼, 집합의 원소는 반드시 해시 가능 해야 합니다.

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

다음 표는 frozenset 의 불변 인스턴스에는 적용되지 않고 set 에서만 사용할 수 있는 연산들을 나열합니다:

set.update(*others)

set |= other | ...

집합을 갱신해서, 모든 others의 원소들을 더합니다.

set.intersection_update(*others)

set &= other & ...

집합을 갱신해서, 그 집합과 others에 공통으로 포함된 원소들만 남깁니다.

set.difference_update(*others)

set -= other | ...

집합을 갱신해서, others에 있는 원소들을 제거합니다.

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() 메서드의 비 연산자 버전은 임의의 이터러블을 인자로 허용합니다.

참고로, __contains__(), remove(), 및 discard() 메서드의 elem 인자는 세트(set)일 수 있습니다. 동일한 frozenset을 찾는 기능을 지원하기 위해 elem 으로부터 임시 frozenset이 생성됩니다.

세트(set)와 frozenset은 요소의 형에 대한 제네릭 입니다.

더 보기

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

매핑 형 — dict, frozendict

매핑 객체는 해시 가능 값을 임의의 객체에 매핑합니다. 현재 두 가지 표준 매핑 형이 있으며, 이는 딕셔너리(dictionary) 와 frozendict 입니다. (다른 컨테이너들은 내장된 list, set, 및 tuple 클래스와 collections 모듈을 참조하십시오.)

딕셔너리의 키는 거의 모든 임의의 값입니다. 해시 가능 하지 않은 값, 즉 리스트, 딕셔너리 또는 기타 가변형(객체 아이덴티티가 아닌 값으로 비교되는)을 포함하는 값은 키로 사용할 수 없습니다. 값이 동일하게 비교되는 것들(예: 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'}

• 딕셔너리 컴프리헨션 사용하기: {}, {x: x ** 2 for x in range(10)}

• 형 생성자 사용하기: dict(), dict([('foo', 100), ('bar', 200)]), dict(foo=100, bar=200)

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

키워드 인자가 제공되면, 키워드 인자와 해당 값이 위치 인자로부터 만들어진 딕셔너리에 추가됩니다. 추가되는 키가 이미 존재하면, 키워드 인자에서 온 값이 위치 인자에게서 온 값을 대체합니다.

딕셔너리는 순서에 관계없이 동일한 (키, 값) 쌍을 가질 때만 서로 같다고 비교됩니다. 순서 비교(‘<’, ‘<=’, ‘>=’, ‘>’)는 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

첫 번째 예제에서와같이 키워드 인자는 유효한 파이썬 식별자인 키에 대해서만 작동합니다. 그 외의 경우는 모든 유효한 키를 사용할 수 있습니다.

딕셔너리는 삽입 순서를 유지합니다. 키를 갱신해도 순서에는 영향을 미치지 않습니다. 삭제 후에 추가된 키는 끝에 삽입됩니다.:

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

딕셔너리는 두 가지 형에 대한 제네릭 으로, 각각 딕셔너리의 키와 값의 형을 나타냅니다.

이것들은 딕셔너리가 지원하는 연산들입니다 (그러므로, 사용자 정의 매핑 형도 지원해야 합니다):

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가 빈 목록과 같은 가변 객체가 되는 것은 일반적으로 의미가 없습니다. 별개의 값을 얻으려면, 대신 딕셔너리 컴프리헨션을 사용하십시오.

get(key, default=None, /)

key 가 딕셔너리에 있는 경우 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 가 딕셔너리에 있으면 해당 값을 돌려줍니다. 그렇지 않으면, default 값을 갖는 key 를 삽입한 후 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의 키와 값으로 딕셔너리 d를 갱신합니다. other는 매핑이나 키/값 쌍의 이터러블일 수 있습니다. 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.

키 뷰(Keys views)는 항목이 고유하고 해시 가능 이므로 세트와 유사하게 동작합니다. 아이템 뷰(Items views) 또한 (키, 값) 쌍이 고유하고 키가 해시 가능하므로 세트와 유사한 연산을 지원합니다. 만약 아이템 뷰의 모든 값이 해시 가능할 경우, 아이템 뷰는 다른 세트들과 상호 운용될 수 있습니다. (값 뷰(Values views)는 항목이 일반적으로 고유하지 않으므로 세트처럼 취급되지 않습니다.) 세트와 유사한 뷰에 대해서는 추상 기본 클래스인 collections.abc.Set 에 정의된 모든 연산(예: ==, < 또는 ^)을 사용할 수 있습니다. 세트 연산자를 사용할 때, 세트가 입력으로 세트만 받는 것과 달리 세트와 유사한 뷰는 다른 피연산자로 어떤 이터러블도 허용합니다.

딕셔너리 뷰 사용의 예:

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

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

>>> # 키와 값은 동일한 순서(삽입 순서)로 반복됩니다
>>> list(keys)
['eggs', 'sausage', 'bacon', 'spam']
>>> list(values)
[2, 1, 1, 500]

>>> # 뷰 객체는 동적이며 딕셔너리의 변경 사항을 반영합니다
>>> del dishes['eggs']
>>> del items_count = 0
>>> del dishes['sausage']
>>> list(keys)
['bacon', 'spam']

>>> # 세트 연산
>>> keys & {'eggs', 'bacon', 'salad'}
{'bacon'}
>>> keys ^ {'sausage', 'juice'} == {'juice', 'sausage', 'bacon', 'spam'}
True
>>> keys | ['juice', 'juice', 'juice'] == {'bacon', 'spam', 'juice'}
True

>>> # 원본 딕셔너리에 대한 읽기 전용 프록시를 가져옵니다
>>> values.mapping
mappingproxy({'bacon': 1, 'spam': 500})
>>> values.mapping['spam']
500

동결된 딕셔너리 (Frozen dictionaries)

class frozendict(**kwargs)

class frozendict(mapping, /, **kwargs)

class frozendict(iterable, /, **kwargs)

선택적인 위치 인자와 비어 있을 수 있는 키워드 인자 집합을 통해 초기화된 새로운 동결 딕셔너리를 반환합니다.

frozendict 은 dict 와 유사한 API를 가지며, 다음과 같은 차이점이 있습니다.

• dict`은 :class:!frozendict`보다 더 많은 메서드를 가집니다.

  • __delitem__()

  • __setitem__()

  • clear()

  • pop()

  • popitem()

  • setdefault()

  • update()

• 모든 키와 값이 해시 가능할 경우, frozendict 은 hash(frozendict) 를 통해 해싱될 수 있습니다.

• frozendict |= other 는 frozendict 를 제자리(in-place)에서 수정하지 않고 새로운 동결 딕셔너리를 생성합니다.

frozendict 은 dict 의 서브 클래스가 아니며, object 로부터 직접 상속받습니다.

딕셔너리와 마찬가지로 frozendict는 두 가지 형에 대한 제네릭 이며, 각각 frozendict의 키와 값의 형을 나타냅니다.

classmethod fromkeys(iterable, value=None, /)

dict.fromkeys() 와 유사하지만, 타입이 frozendict 의 서브 클래스이거나 생성자가 frozendict 를 반환한 경우 초기화된 frozendict 로 타입 생성자를 다시 호출합니다.

Added in version 3.15.

컨텍스트 관리자 형

파이썬의 with 문은 컨텍스트 관리자가 정의한 실행 시간 컨텍스트 개념을 지원합니다. 이는 한 쌍의 메서드를 사용해서 구현되는데, 사용자 정의 클래스가 문장 바디가 실행되기 전에 진입하고, 문장이 끝날 때 탈출하는 실행 시간 컨텍스트를 정의할 수 있게 합니다:

contextmanager.__enter__()

실행시간 컨텍스트에 진입하고 이 객체 자신이나 실행 시간 컨텍스트와 관련된 다른 객체를 돌려줍니다. 이 메서드가 돌려주는 값은, 이 컨텍스트 관리자를 사용하는 with 문의 as 절의 식별자에 연결됩니다.

자신을 돌려주는 컨텍스트 관리자의 예는 파일 객체 입니다. 파일 객체는 __enter__() 에서 자기 자신을 돌려주는데 with 문의 컨텍스트 표현식으로 open() 을 사용할 수 있도록 하기 위함입니다.

관련 객체를 돌려주는 컨텍스트 관리자의 예는 decimal.localcontext() 가 돌려주는 것입니다. 이 관리자들은 활성 십진 소수 컨텍스트를 원래 십진 소수 컨텍스트의 복사본으로 설정한 다음 복사본을 돌려줍니다. 이것은 with 문 바깥의 코드에 영향을 주지 않으면서 with 문 바디에 있는 현재 십진 소수 컨텍스트를 변경할 수 있게 합니다.

contextmanager.__exit__(exc_type, exc_val, exc_tb)

실행 시간 컨텍스트를 탈출하고 발생한 예외를 막아야 하는지를 가리키는 논리 플래그를 돌려줍니다. with 문의 바디를 실행하는 동안 예외가 발생하면, 인자에 예외 형, 값 및 추적 정보가 포함됩니다. 그렇지 않으면, 세 가지 인자 모두 None 입니다.

이 메서드에서 참(True) 값을 반환하면 with 문이 예외를 억제하고 with 문 바로 다음에 오는 문장에서 실행을 이어갑니다. 그렇지 않으면 해당 메서드의 실행이 끝난 후 예외가 계속 전파됩니다.

with 블록에서 발생한 이전 예외를 처리하는 동안 이 메서드가 예외를 발생시키면, 새 예외가 발생하며 원래의 예외는 해당 예외의 __context__ 속성에 저장됩니다.

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

파이썬은 쉬운 스레드 동기화, 파일이나 다른 객체의 신속한 닫기, 그리고 활성 십진 소수 산술 컨텍스트의 보다 간단한 조작을 지원하기 위해 몇 가지 컨텍스트 관리자를 정의합니다. 컨텍스트 관리 프로토콜의 구현을 넘어 구체적인 형은 특별히 취급되지 않습니다. 몇 가지 예제는 contextlib 모듈을 보십시오.

Python’s generators and the contextlib.contextmanager decorator provide a convenient way to implement these protocols. If a generator function is decorated with the contextlib.contextmanager decorator, it will return a context manager implementing the necessary __enter__() and __exit__() methods, rather than the iterator produced by an undecorated generator function.

파이썬/C API의 파이썬 객체에 대한 형 구조체에는 이러한 메서드들을 위해 준비된 슬롯이 없다는 점에 유의하십시오. 이러한 메서드를 정의하고자 하는 확장형은 일반적인 파이썬 액세스가 가능한 메서드로 제공해야 합니다. 실행 시간 컨텍스트를 설정하는 오버헤드와 비교할 때 한 번의 클래스 딕셔너리 조회의 오버헤드는 무시할 수 있습니다.

형 어노테이션 형 ― Generic Alias, Union

형 어노테이션 을 위한 핵심 내장 형은 Generic Alias 와 Union 입니다.

제네릭 에일리어스 형

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__() 을 구현한 경우에만 일반적으로 클래스를 서브스크립트할 수 있습니다.

GenericAlias 객체는 매개변수화된 제네릭 을 구현하며, 제네릭 형 의 프록시 역할을 합니다.

컨테이너 클래스의 경우, 클래스의 서브스크립션 에 제공되는 인수는 객체가 포함하는 요소의 형을 나타낼 수 있습니다. 예를 들어, set[bytes] 는 모든 요소가 bytes 형인 set 임을 의미하기 위해 형 어노테이션에서 사용될 수 있습니다.

서브스크립션을 위해 __class_getitem__() 을 정의하지만 컨테이너는 아닌 클래스의 경우, 해당 클래스의 서브스크립션에 제공되는 인수는 종종 객체에 정의된 하나 이상의 메서드의 반환 형을 나타냅니다. 예를 들어, regular expressions 는 str 데이터 형과 bytes 데이터 형 모두에서 사용될 수 있습니다.

• 만약 x = re.search('foo', 'foo') 라면, x 는 x.group(0) 과 x[0] 의 반환값이 모두 str 형인 re.Match 객체가 됩니다. 우리는 이러한 유형의 객체를형 어노테이션에서 GenericAlias 인 re.Match[str] 으로 표현할 수 있습니다.

• 만약 y = re.search(b'bar', b'bar') 라면(여기서 b 는 bytes 를 의미함), 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 및 그 이상의 유형으로 매개 변수화된 형식의 GenericAlias 를 생성합니다. 예를 들어, float 요소들을 포함하는 list 를 기대하는 함수는 다음과 같습니다:

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

키 형과 값 형을 나타내는 두 개의 형 매개 변수를 기대하는 제네릭 형인 dict를 사용하는 매핑 객체의 또 다른 예. 이 예에서, 함수는 str 형의 키와 int 형의 값을 갖는 dict를 기대합니다:

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]

표준 제네릭 클래스

다음 표준 라이브러리 클래스들이 매개 변수화된 제네릭을 지원합니다. 이 목록은 전부가 아닙니다.

• tuple

• list

• dict

• set

• frozendict

• frozenset

• type

• asyncio.Future

• asyncio.Task

• collections.deque

• collections.defaultdict

• collections.OrderedDict

• collections.Counter

• collections.ChainMap

• collections.abc.Awaitable

• collections.abc.Coroutine

• collections.abc.AsyncIterable

• collections.abc.AsyncIterator

• collections.abc.AsyncGenerator

• collections.abc.Iterable

• collections.abc.Iterator

• collections.abc.Generator

• collections.abc.Reversible

• collections.abc.Container

• collections.abc.Collection

• collections.abc.Callable

• collections.abc.Set

• collections.abc.MutableSet

• collections.abc.Mapping

• collections.abc.MutableMapping

• collections.abc.Sequence

• collections.abc.MutableSequence

• collections.abc.ByteString

• collections.abc.MappingView

• collections.abc.KeysView

• collections.abc.ItemsView

• collections.abc.ValuesView

• contextlib.AbstractContextManager

• contextlib.AbstractAsyncContextManager

• dataclasses.Field

• functools.cached_property

• functools.partialmethod

• os.PathLike

• queue.LifoQueue

• queue.Queue

• queue.PriorityQueue

• queue.SimpleQueue

• re.Pattern

• re.Match

• shelve.BsdDbShelf

• shelve.DbfilenameShelf

• shelve.Shelf

• types.MappingProxyType

• weakref.WeakKeyDictionary

• weakref.WeakMethod

• weakref.WeakSet

• weakref.WeakValueDictionary

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__에서 발견된 고유한 형 변수의 게으르게(lazily) 계산된 튜플(비어있을 수 있습니다)입니다:

>>> from typing import TypeVar

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

참고

typing.ParamSpec 매개 변수를 가진 GenericAlias 객체는 치환 후에 올바른 __parameters__ 를 갖지 못할 수 있습니다. 이는 typing.ParamSpec 이 주로 정적 형 검사를 위해 설계되었기 때문입니다.

genericalias.__unpacked__

어일리어스가 * 연산자를 사용하여 언팩된 경우에만 참(True)이 되는 불리언 값입니다(참고: TypeVarTuple).

Added in version 3.11.

더 보기

PEP 484 - 형 힌트

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

PEP 585 - 표준 컬렉션의 제네릭 타입 힌트

특별한 클래스 메서드인 __class_getitem__() 을 구현하는 경우 표준 라이브러리 클래스를 네이티브하게 매개 변수화할 수 있는 기능 도입.

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

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

Added in version 3.9.

유니언 타입

유니언 객체는 여러 개의 타입 객체 에 대한 | (비트 단위 OR) 연산의 값을 가집니다. 이 타입들은 주로 형 어노테이션 을 위해 설계되었습니다. 유니언 타입 표현은 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

참고

하나 이상의 멤버가 포워드 레퍼런스인 경우, 런타임에서 유니언을 정의하기 위해 | 연산자를 사용할 수 없습니다. 예를 들어, 아직 정의되지 않은 클래스를 참조하는 "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

하지만 유니언 객체 내의 매개 변수화된 제네릭 은 검사할 수 없습니다:

>>> isinstance(1, int | list[int])  # 단락 평가
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

참고

유형 객체에 대해 X | Y 구문을 지원하기 위해 __or__() 메서드가 추가되었습니다. 메타클래스가 __or__() 을 구현하는 경우, 유니언이 이를 재정의할 수 있습니다:

>>> 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 구문과 유니언 타입을 제안하는 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).

함수 객체에는 내장 함수와 사용자 정의 함수라는 두 가지 종류가 있습니다. 두 함수 모두 같은 연산(함수 호출)을 지원하지만, 구현이 다르므로 서로 다른 객체 형입니다.

자세한 정보는 함수 정의을 보십시오.

메서드

메서드는 어트리뷰트 표기법을 사용하여 호출되는 함수입니다. 여기에는 두 가지 형태가 있습니다: 내장 메서드 (예를 들어, 리스트의 append()) 및 클래스 인스턴스 메서드. 내장 메서드는 이를 지원하는 타입과 함께 설명됩니다.

인스턴스를 통해 메서드(클래스 네임스페이스에 정의된 함수)에 접근하면 특별한 객체인 바인딩된 메서드 (또는 인스턴스 메서드) 객체를 얻게 됩니다. 이 객체가 호출되면 인자 목록에 self 가 추가됩니다. 바인딩된 메서드는 두 개의 특별한 읽기 전용 어트리뷰트를 가집니다: m.__self__ 는 메서드가 작동하는 대상 객체이고, m.__func__ 는 메서드를 구현하는 함수입니다. m(arg-1, arg-2, ..., arg-n) 을 호출하는 것은 m.__func__(m.__self__, arg-1, arg-2, ..., arg-n) 을 호출하는 것과 완전히 동일합니다.

함수 객체 와 마찬가지로 바인딩된 메서드 객체도 임의의 어트리뷰트를 가져올 수 있습니다. 하지만 메서드 어트리뷰트는 실제로는 기반이 되는 함수 객체(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'

더 자세한 내용은 인스턴스 메서드 를 참조하십시오.

코드 객체

코드 객체는 구현체에서 함수 본문과 같은 “의사 컴파일(pseudo-compiled)”된 실행 가능한 파이썬 코드를 나타내는 데 사용됩니다. 코드 객체는 전역 실행 환경에 대한 참조를 포함하지 않기 때문에 함수 객체와 다릅니다. 코드 객체는 내장 compile() 함수에 의해 반환되며, 함수 객체의 __code__ 어트리뷰스를 통해 추출할 수 있습니다. 또한 code 모듈도 참조하십시오.

__code__ 에 접근하면 인자 obj 와 "__code__" 를 사용하여 감사 이벤트 object.__getattr__ 를 발생시킵니다.

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

자세한 정보는 표준형 계층를 보십시오.

형 객체

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

형은 다음과 같이 쓰입니다: <class 'int'>.

널 객체

이 객체는 명시적으로 값을 돌려주지 않는 함수에 의해 반환됩니다. 특별한 연산을 지원하지 않습니다. 정확하게 하나의 널 객체가 있으며, 이름은 None(내장 이름)입니다. type(None)() 은 같은 싱글톤을 만듭니다.

None 이라고 쓰입니다.

Ellipsis 객체

이 객체는 일반적으로 무언가가 생략되었음을 나타내는 데 사용됩니다. 특별한 연산을 지원하지 않습니다. 정확히 하나뿐인 줄임표 객체가 있으며, 이름은 Ellipsis (내장 이름)입니다. type(Ellipsis)() 를 호출하면 Ellipsis 싱글톤이 생성됩니다.

Ellipsis 나 ... 로 쓰입니다.

일반적인 사용 사례에서, Ellipsis 객체로서의 ... 은 몇 가지 다른 위치에 등장합니다. 예시는 다음과 같습니다.

• 호출 가능 인자 또는 튜플 요소 와 같은 형 어노테이션에서 사용됩니다.

• pass 문 대신 함수의 본문으로 사용됩니다.

• Numpy의 슬라이싱 및 스트라이딩 <https://numpy.org/doc/stable/user/basics.indexing.html#slicing-and-striding> 과 같은 서드파티 라이브러리에서 사용됩니다.

또한 파이썬은 다음과 같이 Ellipsis 객체가 아닌 방식으로 세 점을 사용하는 경우도 있습니다.

• 누락된 콘텐츠에 대한 패턴으로서의 Doctest ELLIPSIS.

• 대화형 셸에서 부분적인 입력이 불완전할 때 표시되는 기본 파이썬 프롬프트입니다.

마지막으로, 파이썬 문서에서는 때때로 관습적인 영어 표현에서 생략된 내용을 의미하기 위해 세 점을 사용하며, 이는 같은 의미의 Ellipsis 로도 쓰이는 코드 예제에서도 마찬가지입니다.

NotImplemented 객체

이 객체는 지원하지 않는 타입에 대해 비교 및 이진 연산을 수행하려고 할 때 반환됩니다. 자세한 내용은 비교 를 참조하십시오. 정확히 하나의 NotImplemented 객체가 있으며, type(NotImplemented)() 을 통해 싱글톤 인스턴스를 생성할 수 있습니다.

NotImplemented 으로 표기됩니다.

내부 객체

이 정보는 표준형 계층 를 참조하십시오. 이 항목은 stack frame objects, traceback objects 및 슬라이스 객체에 대해 설명합니다.

특수 어트리뷰트

관련성이 있을 때, 구현은 몇 가지 객체 유형에 몇 가지 특수 읽기 전용 어트리뷰트를 추가합니다. 이 중 일부는 dir() 내장 함수에 의해 보고되지 않습니다.

definition.__name__

클래스, 함수, 메서드, 디스크립터 또는 제너레이터 인스턴스의 이름.

definition.__qualname__

클래스, 함수, 메서드, 디스크립터 또는 제너레이터 인스턴스의 정규화된 이름.

Added in version 3.3.

definition.__module__

클래스 또는 함수가 정의된 모듈의 이름입니다.

definition.__doc__

클래스 또는 함수의 문서화 문자열이며, 정의되지 않은 경우 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진법의 경우 가장 우수한 알고리즘조차 이차 이하(sub-quadratic)의 복잡도를 가집니다. 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).

• 예를 들어 f"{integer}", "{}".format(integer) 또는 b"%d" % integer 와 같은 10진법으로의 모든 다른 문자열 변환.

다음과 같은 선형 알고리즘을 사용하는 함수에는 제한이 적용되지 않습니다:

• 진법이 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 으로 변환하는 경우.

한계 설정

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

• PYTHONINTMAXSTRDIGITS`를 사용하여 한도를 640으로 설정하거나(예: ``PYTHONINTMAXSTRDIGITS=640 python3`), 제한을 해제할 수 있습니다(예: PYTHONINTMAXSTRDIGITS=0 python3).

• -X int_max_str_digits <-X>`를 사용하여 설정할 수 있습니다(예: ``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입니다. 서브인터프리터(Subinterpreters)는 자체 한도를 가집니다.

기본값 및 최소값에 대한 정보는 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진수 정수 리터럴을 포함하는 Python 소스 코드는 파싱 중에 오류가 발생하며, 이는 보통 시작 시점이나 임포트 시점, 또는 최신 .pyc 파일이 아직 존재하지 않는 설치 시점에 발생합니다. 이러한 큰 상수를 포함한 소스에 대한 해결 방법은 한도 제한이 없는 0x 16진수 형식으로 변형하는 것입니다.

낮은 한도를 사용하는 경우 애플리케이션을 철저히 테스트하십시오. 환경 변수나 플래그를 통해 초기 단계에서 한도를 설정하여, 시작 시점뿐만 아니라 .py 소스를 .pyc 파일로 미리 컴파일하기 위해 Python을 호출하는 모든 설치 단계에서도 적용되도록 하십시오.

권장 구성

기본값인 sys.int_info.default_max_str_digits 는 대부분의 애플리케이션에서 적절한 값입니다. 만약 애플리케이션에 다른 한도가 필요한 경우, 해당 API가 3.12 이전 버전의 보안 패치 릴리스에서 추가되었으므로 Python 버전에 구애받지 않는 코드를 사용하여 메인 진입점에서 설정하십시오.

예제:

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

완전히 비활성화하려면 0 으로 설정하십시오.

각주

[1]

이 특수 메서드에 대한 추가 정보는 파이썬 레퍼런스 설명서(기본적인 커스터마이제이션)에서 찾을 수 있습니다.

[2]

결과적으로, 리스트 [1, 2] 는 [1.0, 2.0] 과 같다고 취급되고, 튜플도 마찬가지입니다.

[3]

파서가 피연산자 유형을 알 수 없으므로 그럴 수밖에 없습니다.

[4] (1,2,3,4)

케이스 문자는 일반 범주 속성이 “Lu” (Letter, 대문자), “Ll” (Letter, 소문자), “Lt” (Letter, 제목 문자) 중 한 가지인 경우입니다.

[5] (1,2)

그래서, 튜플만을 포매팅하려면 포맷할 튜플 하나만을 포함하는 1-튜플을 제공해야 합니다.

분실물 보관소