- Built-in Types
- Truth Value Testing
- Boolean Operations —
and,or,not - Comparisons
- Numeric Types —
int,float,complex - Iterator Types
- Sequence Types —
list,tuple,range - Text Sequence Type —
str - Binary Sequence Types —
bytes,bytearray,memoryview - Set Types —
set,frozenset - Mapping Types —
dict - Context Manager Types
- Type Annotation Types — Generic Alias, Union
- Other Built-in Types
- Special Attributes
- Integer string conversion length limitation
다음 섹션에서는 인터프리터에 내장된 표준 유형에 대해 설명합니다.
주요 기본 제공 유형은 숫자, 시퀀스, 매핑, 클래스, 인스턴스 및 예외입니다.
일부 컬렉션 클래스는 변경 가능합니다. 멤버를 제자리에 추가, 빼기 또는 재정렬하고 특정 항목을 반환하지 않는 메서드는 컬렉션 인스턴스 자체를 반환하지 않고 None을 반환합니다.
일부 작업은 여러 개체 유형에서 지원됩니다. 특히 거의 모든 객체가 동일한지 비교하고, 진리값을 테스트하고, 문자열로 변환할 수 있습니다(repr() 함수 또는 약간 다른 str() 함수 사용). 후자의 함수는 객체가 print() 함수에 의해 기록될 때 암시적으로 사용됩니다.
Truth Value Testing
모든 개체는 if 또는 while 조건에서 사용하거나 아래 부울 연산의 피연산자로 사용하기 위해 진리값에 대해 테스트할 수 있습니다.
기본적으로 객체와 함께 호출될 때 해당 클래스가 False를 반환하는 __bool__() 메서드 또는 0을 반환하는 __len__() 메서드를 정의하지 않는 한 객체는 참으로 간주됩니다. 1 거짓으로 간주되는 대부분의 내장 개체는 다음과 같습니다.
- false로 정의된 상수: None 및 False.
- 모든 숫자 유형의 0: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
- 빈 시퀀스 및 컬렉션: ”, (), [], {}, set(), range(0)
부울 결과가 있는 연산 및 내장 함수는 달리 명시되지 않는 한 항상 거짓이면 0 또는 False, 참이면 1 또는 True를 반환합니다. (중요한 예외: 부울 연산 or and and는 항상 피연산자 중 하나를 반환합니다.)
Boolean Operations — and, or, not
우선 순위가 오름차순으로 정렬된 부울 연산은 다음과 같습니다.
| Operation | Result | Notes |
|---|---|---|
x or y | if x is false, then y, else x | (1) |
x and y | if x is false, then x, else y | (2) |
not x | if x is false, then True, else False | (3) |
노트:
- 이것은 단락 연산자이므로 첫 번째 인수가 거짓인 경우에만 두 번째 인수를 평가합니다.
- 이것은 단락 연산자이므로 첫 번째 인수가 참인 경우에만 두 번째 인수를 평가합니다.
- not은 부울이 아닌 연산자보다 우선 순위가 낮으므로 not a == b는 not(a == b)으로 해석되고 a == not b는 구문 오류입니다.
Comparisons
파이썬에는 8개의 비교 연산이 있습니다. 그것들은 모두 동일한 우선순위를 가집니다(부울 연산보다 높음). 비교는 임의로 연결할 수 있습니다. 예를 들어, x < y <= z는 y가 한 번만 평가된다는 점을 제외하고 x < y 및 y <= z와 동일합니다(그러나 두 경우 모두 x < y가 거짓인 경우 z는 전혀 평가되지 않습니다).
이 표에는 비교 작업이 요약되어 있습니다.
| Operation | Meaning |
|---|---|
< | strictly less than |
<= | less than or equal |
> | strictly greater than |
>= | greater than or equal |
== | equal |
!= | not equal |
is | object identity |
is not | negated object identity |
다른 숫자 유형을 제외하고 다른 유형의 객체는 결코 동일하게 비교되지 않습니다. == 연산자는 항상 정의되지만 일부 개체 유형(예: 클래스 개체)의 경우 is와 동일합니다. <, <=, > 및 >= 연산자는 의미가 있는 경우에만 정의됩니다. 예를 들어 인수 중 하나가 복소수일 때 TypeError 예외를 발생시킵니다.
클래스의 동일하지 않은 인스턴스는 클래스가 __eq__() 메서드를 정의하지 않는 한 일반적으로 같지 않은 것으로 비교됩니다.
클래스가 __lt__(), __le__(), __gt__() 및 __ge__() 메서드를 충분히 정의하지 않는 한 클래스의 인스턴스는 동일한 클래스의 다른 인스턴스 또는 다른 유형의 객체와 관련하여 순서를 지정할 수 없습니다(일반적으로 , __lt__() 및 __eq__()는 비교 연산자의 일반적인 의미를 원하는 경우 충분합니다.
is 및 is not 연산자의 동작은 사용자 정의할 수 없습니다. 또한 두 개체에 적용할 수 있으며 예외를 발생시키지 않습니다.
구문 우선 순위가 같은 in 및 in이 아닌 두 개의 추가 작업은 반복 가능하거나 __contains__() 메서드를 구현하는 유형에서 지원됩니다.
Numeric Types — int, float, complex
정수, 부동 소수점 숫자 및 복소수의 세 가지 숫자 유형이 있습니다. 또한 부울은 정수의 하위 유형입니다. 정수는 정밀도가 무제한입니다. 부동 소수점 숫자는 일반적으로 C에서 double을 사용하여 구현됩니다. 프로그램이 실행 중인 기계에 대한 부동 소수점 숫자의 정밀도 및 내부 표현에 대한 정보는 sys.float_info에서 사용할 수 있습니다. 복소수에는 각각 부동 소수점 숫자인 실수부와 허수부가 있습니다. 복소수 z에서 이러한 부분을 추출하려면 z.real 및 z.imag를 사용하십시오. (표준 라이브러리에는 추가 숫자 유형 fractions.Fraction(유리수용)과 decimal.Decimal(사용자 정의 정밀도가 있는 부동 소수점 숫자용)이 포함되어 있습니다.)
숫자는 숫자 리터럴에 의해 생성되거나 내장 함수 및 연산자의 결과로 생성됩니다. 장식되지 않은 정수 리터럴(16진수, 8진수 및 2진수 포함)은 정수를 산출합니다. 소수점 또는 지수 기호를 포함하는 숫자 리터럴은 부동 소수점 숫자를 생성합니다. 숫자 리터럴에 ‘j’ 또는 ‘J’를 추가하면 허수(실수 부분이 0인 복소수)가 생성되며 이를 정수 또는 float에 추가하여 실수 및 허수 부분이 있는 복소수를 얻을 수 있습니다.
Python은 혼합 산술을 완벽하게 지원합니다. 이진 산술 연산자에 다른 숫자 유형의 피연산자가 있는 경우 “좁은” 유형의 피연산자는 다른 피연산자로 확장됩니다. 여기서 정수는 부동 소수점보다 좁고 복소수보다 좁습니다. 서로 다른 유형의 숫자 간의 비교는 해당 숫자의 정확한 값이 비교되는 것처럼 동작합니다. 2
생성자 int(), float() 및 complex()를 사용하여 특정 유형의 숫자를 생성할 수 있습니다.
모든 숫자 유형(복소수 제외)은 다음 연산을 지원합니다(연산 우선 순위는 Operator precedence 참조).
| Operation | Result | Notes | Full documentation |
|---|---|---|---|
x + y | sum of x and y | ||
x - y | difference of x and y | ||
x * y | product of x and y | ||
x / y | quotient of x and y | ||
x // y | floored quotient of x and y | (1) | |
x % y | remainder of x / y | (2) | |
-x | x negated | ||
+x | x unchanged | ||
abs(x) | absolute value or magnitude of x | abs() | |
int(x) | x converted to integer | (3)(6) | int() |
float(x) | x converted to floating point | (4)(6) | float() |
complex(re, im) | a complex number with real part re, imaginary part im. im defaults to zero. | (6) | complex() |
c.conjugate() | conjugate of the complex number c | ||
divmod(x, y) | the pair (x // y, x % y) | (2) | divmod() |
pow(x, y) | x to the power y | (5) | pow() |
x ** y | x to the power y | (5) |
노트:
- 정수 나눗셈이라고도 합니다. 결과 값은 전체 정수이지만 결과 유형이 반드시 int일 필요는 없습니다. 결과는 항상 마이너스 무한대로 반올림됩니다. 1//2는 0, (-1)//2는 -1, 1//(-2)는 -1, (-1)//(-2)는 0.
- 복소수가 아닙니다. 대신 적절한 경우 abs()를 사용하여 부동 소수점으로 변환합니다.
- 부동 소수점에서 정수로의 변환은 C에서와 같이 반올림하거나 잘릴 수 있습니다. 잘 정의된 변환에 대해서는 math.floor() 및 math.ceil() 함수를 참조하십시오.
- float는 또한 NaN(Not a Number) 및 양수 또는 음수 무한대에 대한 선택적 접두사 “+” 또는 “-“가 있는 문자열 “nan” 및 “inf”를 허용합니다.
- Python은 pow(0, 0) 및 0 ** 0을 프로그래밍 언어에서 일반적으로 1로 정의합니다.
- 허용되는 숫자 리터럴에는 0에서 9까지의 숫자 또는 이에 상응하는 유니코드(Nd 속성이 있는 코드 포인트)가 포함됩니다.
Nd속성이 있는 코드 포인트의 전체 목록은 https://www.unicode.org/Public/14.0.0/ucd/extracted/DerivedNumericType.txt를 참조하십시오.
모든 numbers.Real 유형(int 및 float)에는 다음 작업도 포함됩니다.
| Operation | Result |
|---|---|
math.trunc(x) | x truncated to Integral |
round(x[, n]) | x rounded to n digits, rounding half to even. If n is omitted, it defaults to 0. |
math.floor(x) | the greatest Integral <= x |
math.ceil(x) | the least Integral >= x |
추가 숫자 연산에 대해서는 math 및 cmath 모듈을 참조하십시오.
Bitwise Operations on Integer Types
비트 연산은 정수에 대해서만 의미가 있습니다. 비트 연산의 결과는 무한한 수의 부호 비트로 2의 보수로 수행되는 것처럼 계산됩니다.
이진 비트 연산의 우선 순위는 모두 숫자 연산보다 낮고 비교보다 높습니다. 단항 연산 ~은 다른 단항 숫자 연산(+ 및 -)과 동일한 우선 순위를 갖습니다.
이 표는 오름차순 우선 순위로 정렬된 비트 연산을 나열합니다.
| Operation | Result | Notes |
|---|---|---|
x | y | bitwise or of x and y | (4) |
x ^ y | bitwise exclusive or of x and y | (4) |
x & y | bitwise and of x and y | (4) |
x << n | x shifted left by n bits | (1)(2) |
x >> n | x shifted right by n bits | (1)(3) |
~x | the bits of x inverted |
노트:
- 음수 이동 횟수는 불법이며 ValueError가 발생합니다.
- n 비트만큼 왼쪽으로 이동하는 것은 pow(2, n)을 곱하는 것과 같습니다.
- n 비트만큼 오른쪽으로 이동하는 것은 pow(2, n)으로 바닥을 나누는 것과 같습니다.
- 유한 2의 보수 표현(1 + max(x.bit_length(), y.bit_length()) 이상의 작업 비트 폭)에서 적어도 하나의 추가 부호 확장 비트로 이러한 계산을 수행하면 동일한 결과를 얻기에 충분합니다. 마치 무한한 수의 부호 비트가 있는 것처럼.
Additional Methods on Integer Types
int 유형은 numbers.Integral abstract base class를 구현합니다. 또한 다음과 같은 몇 가지 방법을 더 제공합니다.
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) # binary representation: bin(-37) --> '-0b100101'
s = s.lstrip('-0b') # remove leading zeros and minus sign
return len(s) # len('100101') --> 6버전 3.1의 새로운 기능.
int.bit_count()
정수 절대값의 이진 표현에서 1의 수를 반환합니다. 이것은 인구수라고도 합니다. 예:
>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3위의 코드는 다음과 동일함:
def bit_count(self):
return bin(self).count("1")버전 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'정수는 길이 바이트를 사용하여 표현되며 기본값은 1입니다. 주어진 바이트 수로 정수를 표현할 수 없으면 OverflowError가 발생합니다.
byteorder 인수는 정수를 나타내는 데 사용되는 바이트 순서를 결정하며 기본값은 “big”입니다. byteorder가 “big”이면 최상위 바이트는 바이트 배열의 시작 부분에 있습니다. byteorder가 “little”이면 최상위 바이트는 바이트 배열의 끝에 있습니다.
signed 인수는 2의 보수가 정수를 나타내는 데 사용되는지 여부를 결정합니다. signed가 False이고 음의 정수가 제공되면 OverflowError가 발생합니다. 서명된 기본값은 False입니다.
기본값은 정수를 단일 바이트 개체로 편리하게 변환하는 데 사용할 수 있습니다. 그러나 기본 인수를 사용할 때 255보다 큰 값을 변환하지 마십시오. 그렇지 않으면 OverflowError가 발생합니다.
>>> (65).to_bytes()
b'A'위의 코드는 다음과 동일합니다.
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)버전 3.2의 새로운 기능.
버전 3.11에서 변경: 길이 및 바이트 순서에 대한 기본 인수 값을 추가했습니다.
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버전 3.2의 새로운 기능.
버전 3.11에서 변경: 바이트 순서에 대한 기본 인수 값을 추가했습니다.
int.as_integer_ratio()
비율이 원래 정수와 정확히 같고 양의 분모를 갖는 정수 쌍을 반환합니다. 정수(정수)의 정수비는 항상 분자가 정수이고 분모가 1입니다.
버전 3.8의 새로운 기능.
Additional Methods on Float
float 유형은 numbers.Real 추상 기본 클래스를 구현합니다. float에는 다음과 같은 추가 메서드도 있습니다.
float.as_integer_ratio()
비율이 원래 float와 정확히 같고 양의 분모를 가진 정수 쌍을 반환합니다. 무한대에서는 OverflowError를, NaN에서는 ValueError를 발생시킵니다.
float.is_integer()
float 인스턴스가 정수 값으로 유한한 경우 True를 반환하고 그렇지 않은 경우 False를 반환합니다.
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False두 가지 방법이 16진수 문자열과의 변환을 지원합니다. 파이썬의 부동 소수점은 내부적으로 이진수로 저장되기 때문에 부동 소수점을 십진수 문자열로 변환하거나 반대로 변환하면 일반적으로 작은 반올림 오류가 발생합니다. 반대로 16진수 문자열을 사용하면 부동 소수점 숫자를 정확하게 표현하고 지정할 수 있습니다. 이는 디버깅 및 수치 작업 시 유용할 수 있습니다.
float.hex()
부동 소수점 숫자의 표현을 16진수 문자열로 반환합니다. 유한 부동 소수점 숫자의 경우 이 표현에는 항상 선행 0x와 후행 p 및 지수가 포함됩니다.
classmethod float.fromhex(s)
16진수 문자열 s로 표시되는 부동 소수점을 반환하는 클래스 메서드입니다. 문자열 s에는 선행 및 후행 공백이 있을 수 있습니다.
float.hex()는 인스턴스 메서드이고 float.fromhex()는 클래스 메서드입니다.
16진수 문자열은 다음 형식을 취합니다.
[sign] ['0x'] integer ['.' fraction] ['p' exponent]여기서 선택적 부호는 + 또는 -일 수 있고, 정수 및 분수는 16진수 문자열이고 지수는 선택적 선행 부호가 있는 10진수 정수입니다. 대소문자는 중요하지 않으며 정수 또는 분수에 적어도 하나의 16진수가 있어야 합니다. 이 구문은 C99 표준의 섹션 6.4.4.2에 지정된 구문 및 Java 1.5 이후에 사용되는 구문과 유사합니다. 특히 float.hex()의 출력은 C 또는 Java 코드에서 16진수 부동 소수점 리터럴로 사용할 수 있으며 C의 %a 형식 문자 또는 Java의 Double.toHexString에 의해 생성된 16진수 문자열은 float.fromhex()에서 허용됩니다.
지수는 16진수가 아닌 10진수로 작성되며 계수를 곱하기 위해 2의 거듭제곱을 제공합니다. 예를 들어, 16진수 문자열 0x3.a7p10은 부동 소수점 숫자(3 + 10./16 + 7./16**2) * 2.0**10 또는 3740.0을 나타냅니다.
>>> float.fromhex('0x3.a7p10')
3740.0역변환을 3740.0에 적용하면 동일한 숫자를 나타내는 다른 16진수 문자열이 제공됩니다.
>>> float.hex(3740.0)
'0x1.d380000000000p+11'Hashing of numeric types
다른 유형의 숫자 x와 y의 경우 x == y일 때마다 hash(x) == hash(y)가 되어야 합니다(자세한 내용은 __hash__() 메서드 문서 참조). 다양한 숫자 유형(int, float, decimal.Decimal 및 fractions.Fraction 포함)에서 구현의 용이성과 효율성을 위해 숫자 유형에 대한 Python의 해시는 유리수에 대해 정의된 단일 수학 함수를 기반으로 하므로 모든 유형에 적용됩니다. int 및 fractions.Fraction의 인스턴스, float 및 decimal.Decimal의 모든 유한 인스턴스. 기본적으로 이 함수는 고정된 소수 P에 대한 축소 모듈로 P에 의해 제공됩니다. P의 값은 sys.hash_info의 모듈러스 속성으로 Python에서 사용할 수 있습니다.
CPython 구현 세부 정보: 현재 사용되는 소수는 32비트 C long이 있는 컴퓨터에서 P = 2**31 – 1이고 64비트 C long이 있는 컴퓨터에서 P = 2**61 – 1입니다.
자세한 규칙은 다음과 같습니다.
- x = m / n이 음이 아닌 유리수이고 n을 P로 나눌 수 없는 경우 해시(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는 각각 양의 무한대 또는 음의 무한대에 대한 해시 값으로 사용됩니다.
- 복소수 z의 경우 실수부와 허수부의 해시 값은 hash(z.real) + sys.hash_info.imag * hash(z.imag), 축소 모듈로 2**sys.hash_info.width를 계산하여 결합됩니다. 범위(-2**(sys.hash_info.width – 1), 2**(sys.hash_info.width – 1))에 있습니다. 다시 말하지만 결과가 -1이면 -2로 대체됩니다.
위의 규칙을 명확히 하기 위해 다음은 유리수, 실수 또는 복소수의 해시를 계산하기 위한 내장 해시에 해당하는 Python 코드의 예입니다.
import sys, math
def hash_fraction(m, n):
"""Compute the hash of a rational number m / n.
Assumes m and n are integers, with n positive.
Equivalent to hash(fractions.Fraction(m, n)).
"""
P = sys.hash_info.modulus
# Remove common factors of P. (Unnecessary if m and n already coprime.)
while m % P == n % P == 0:
m, n = m // P, n // P
if n % P == 0:
hash_value = sys.hash_info.inf
else:
# Fermat's Little Theorem: pow(n, P-1, P) is 1, so
# pow(n, P-2, P) gives the inverse of n modulo P.
hash_value = (abs(m) % P) * pow(n, P - 2, P) % P
if m < 0:
hash_value = -hash_value
if hash_value == -1:
hash_value = -2
return hash_value
def hash_float(x):
"""Compute the hash of a float x."""
if math.isnan(x):
return object.__hash__(x)
elif math.isinf(x):
return sys.hash_info.inf if x > 0 else -sys.hash_info.inf
else:
return hash_fraction(*x.as_integer_ratio())
def hash_complex(z):
"""Compute the hash of a complex number z."""
hash_value = hash_float(z.real) + sys.hash_info.imag * hash_float(z.imag)
# do a signed reduction modulo 2**sys.hash_info.width
M = 2**(sys.hash_info.width - 1)
hash_value = (hash_value & (M - 1)) - (hash_value & M)
if hash_value == -1:
hash_value = -2
return hash_valueIterator Types
Python은 컨테이너에 대한 반복 개념을 지원합니다. 이는 두 가지 고유한 방법을 사용하여 구현됩니다. 이는 사용자 정의 클래스가 반복을 지원하도록 허용하는 데 사용됩니다. 아래에서 자세히 설명하는 시퀀스는 항상 반복 방법을 지원합니다.
반복 가능한 지원을 제공하려면 컨테이너 개체에 대해 한 가지 메서드를 정의해야 합니다.
container.__iter__()
반복자 객체를 반환합니다. 개체는 아래에 설명된 반복자 프로토콜을 지원하는 데 필요합니다. 컨테이너가 다른 유형의 반복을 지원하는 경우 해당 반복 유형에 대한 반복자를 구체적으로 요청하기 위해 추가 메서드를 제공할 수 있습니다. (여러 형식의 반복을 지원하는 개체의 예는 폭 우선 및 깊이 우선 순회를 모두 지원하는 트리 구조입니다.) 이 방법은 Python/C API에서 Python 개체에 대한 유형 구조의 tp_iter 슬롯에 해당합니다.
반복자 객체 자체는 함께 반복자 프로토콜을 형성하는 다음 두 가지 방법을 지원하는 데 필요합니다.
iterator.__iter__()
반복자 객체 자체를 반환합니다. for 및 in 문과 함께 컨테이너와 반복자를 모두 사용할 수 있도록 하려면 이 작업이 필요합니다. 이 메서드는 Python/C API에서 Python 개체에 대한 유형 구조의 tp_iter 슬롯에 해당합니다.
iterator.__next__()
반복자에서 다음 항목을 반환합니다. 더 이상 항목이 없으면 StopIteration 예외를 발생시킵니다. 이 메서드는 Python/C API에서 Python 객체에 대한 유형 구조의 tp_iternext 슬롯에 해당합니다.
Python은 일반 및 특정 시퀀스 유형, 사전 및 기타 보다 전문화된 형식에 대한 반복을 지원하기 위해 여러 반복자 개체를 정의합니다. 특정 유형은 반복자 프로토콜 구현 외에는 중요하지 않습니다.
이터레이터의 __next__() 메서드가 StopIteration을 일으키면 후속 호출에서 계속해서 그렇게 해야 합니다. 이 속성을 따르지 않는 구현은 손상된 것으로 간주됩니다.
Generator Types
Python의 생성기는 반복자 프로토콜을 구현하는 편리한 방법을 제공합니다. 컨테이너 객체의 __iter__() 메서드가 제너레이터로 구현되면 자동으로 __iter__() 및 __next__() 메서드를 제공하는 이터레이터 객체(기술적으로는 제너레이터 객체)를 반환합니다. 생성기에 대한 자세한 내용은 yield 표현식 문서에서 찾을 수 있습니다.
Sequence Types — list, tuple, range
목록, 튜플 및 범위 개체의 세 가지 기본 시퀀스 유형이 있습니다. 이진 데이터 및 텍스트 문자열 처리에 맞게 조정된 추가 시퀀스 유형은 전용 섹션에 설명되어 있습니다.
Common Sequence Operations
다음 표의 작업은 변경 가능 및 변경 불가능한 대부분의 시퀀스 유형에서 지원됩니다. collections.abc.Sequence ABC는 사용자 지정 시퀀스 유형에서 이러한 작업을 보다 쉽게 올바르게 구현할 수 있도록 제공됩니다.
이 표는 오름차순 우선 순위로 정렬된 시퀀스 작업을 나열합니다. 테이블에서 s와 t는 동일한 유형의 시퀀스이고 n, i, j 및 k는 정수이고 x는 s에 의해 부과된 모든 유형 및 값 제한을 충족하는 임의의 개체입니다.
in 및 not in 작업은 비교 작업과 동일한 우선 순위를 갖습니다. +(연결) 및 *(반복) 연산은 해당 숫자 연산과 동일한 우선 순위를 갖습니다. 삼
| Operation | Result | Notes |
|---|---|---|
x in s | True if an item of s is equal to x, else False | (1) |
x not in s | False if an item of s is equal to x, else True | (1) |
s + t | the concatenation of s and t | (6)(7) |
s * n or n * s | equivalent to adding s to itself n times | (6)(7) |
s[i] | ith item of s, origin 0 | (3) |
s[i:j] | slice of s from i to j | (3)(4) |
s[i:j:k] | slice of s from i to j with step k | (3)(5) |
len(s) | length of s | |
min(s) | smallest item of s | |
max(s) | largest item of s | |
s.index(x[, i[, j]]) | index of the first occurrence of x in s (at or after index i and before index j) | (3)(5) |
s.count(x) | total number of occurrences of x in s |
동일한 유형의 시퀀스도 비교를 지원합니다. 특히 튜플과 목록은 해당 요소를 비교하여 사전순으로 비교됩니다. 이는 같음을 비교하려면 모든 요소가 같음을 비교해야 하고 두 시퀀스의 유형과 길이가 같아야 함을 의미합니다. (자세한 내용은 언어 참조의 비교를 참조하십시오.)
가변 시퀀스에 대한 정방향 및 역방향 반복기는 인덱스를 사용하여 값에 액세스합니다. 해당 인덱스는 기본 시퀀스가 변경되더라도 계속 앞으로(또는 뒤로) 행진합니다. Iterator는 IndexError 또는 StopIteration이 발생하는 경우(또는 인덱스가 0 아래로 떨어질 경우)에만 종료됩니다.
노트:
1. in 및 not in 작업은 일반적인 경우에 간단한 포함 테스트에만 사용되지만 일부 특수 시퀀스(예: str, bytes 및 bytearray)는 하위 시퀀스 테스트에도 사용합니다.
>> "gg" in "eggs"
True2. 0보다 작은 n 값은 0으로 처리됩니다(s와 동일한 유형의 빈 시퀀스 생성). 시퀀스 s의 항목은 복사되지 않습니다. 그들은 여러 번 참조됩니다. 이것은 종종 새로운 Python 프로그래머를 괴롭힙니다. 고려하다:
>>> lists = [[]] * 3
>>> lists
[[], [], []]
>>> lists[0].append(3)
>>> lists
[[3], [3], [3]]일어난 일은 [[]]가 빈 목록을 포함하는 단일 요소 목록이므로 [[]] * 3의 세 요소 모두 이 단일 빈 목록에 대한 참조입니다. 목록의 요소를 수정하면 이 단일 목록이 수정됩니다. 다음과 같은 방법으로 다양한 목록의 목록을 만들 수 있습니다.
>>> 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. i에서 j까지 s의 슬라이스는 i <= k < j인 인덱스 k를 갖는 항목의 시퀀스로 정의됩니다. i 또는 j가 len(s)보다 크면 len(s)를 사용합니다. i가 생략되거나 None이면 0을 사용합니다. j가 생략되거나 None이면 len(s)를 사용합니다. i가 j보다 크거나 같으면 슬라이스가 비어 있습니다.
5. k 단계에서 i에서 j로의 s 조각은 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. 불변 시퀀스를 연결하면 항상 새 개체가 생성됩니다. 즉, 반복 연결을 통해 시퀀스를 구축하면 전체 시퀀스 길이에서 2차 런타임 비용이 발생합니다. 선형 런타임 비용을 얻으려면 아래 대안 중 하나로 전환해야 합니다.
- str 객체를 연결하는 경우 목록을 만들고 마지막에 str.join()을 사용하거나 그렇지 않으면 io.StringIO 인스턴스에 쓰고 완료되면 해당 값을 검색할 수 있습니다.
- 바이트열 객체를 연결하는 경우 유사하게 bytes.join() 또는 io.BytesIO를 사용하거나 bytearray 객체로 내부 연결을 수행할 수 있습니다. bytearray 객체는 변경 가능하며 효율적인 초과 할당 메커니즘이 있습니다.
- 튜플 객체를 연결하는 경우 대신 목록을 확장하십시오.
- 다른 유형의 경우 관련 클래스 문서를 조사하십시오.
7. 일부 시퀀스 유형(예: 범위)은 특정 패턴을 따르는 항목 시퀀스만 지원하므로 시퀀스 연결 또는 반복을 지원하지 않습니다.
8. x가 s에서 발견되지 않으면 index는 ValueError를 발생시킵니다. 모든 구현이 추가 인수 i 및 j 전달을 지원하는 것은 아닙니다. 이러한 인수를 사용하면 시퀀스의 하위 섹션을 효율적으로 검색할 수 있습니다. 추가 인수를 전달하는 것은 s[i:j].index(x)를 사용하는 것과 대략 동일하지만 데이터를 복사하지 않고 반환된 인덱스가 슬라이스의 시작이 아닌 시퀀스의 시작에 상대적입니다.
Immutable Sequence Types
변경 불가능한 시퀀스 유형이 일반적으로 구현하지만 변경 가능한 시퀀스 유형에 의해서도 구현되지 않는 유일한 작업은 hash() 내장에 대한 지원입니다.
이 지원을 통해 튜플 인스턴스와 같은 불변 시퀀스를 사전 키로 사용하고 set 및 frozenset 인스턴스에 저장할 수 있습니다.
해시할 수 없는 값을 포함하는 변경할 수 없는 시퀀스를 해시하려고 하면 TypeError가 발생합니다.
Mutable Sequence Types
다음 표의 연산은 변경 가능한 시퀀스 유형에 대해 정의됩니다. collections.abc.MutableSequence ABC는 사용자 지정 시퀀스 유형에서 이러한 작업을 보다 쉽게 올바르게 구현할 수 있도록 제공됩니다.
표에서 s는 변경 가능한 시퀀스 유형의 인스턴스이고, t는 반복 가능한 객체이고 x는 s에 의해 부과된 모든 유형 및 값 제한을 충족하는 임의의 객체입니다(예: bytearray는 값 제한 0 <=을 충족하는 정수만 허용합니다). x <= 255).
| Operation | Result | Notes |
|---|---|---|
s[i] = x | s의 항목 i가 x로 대체됨 | |
s[i:j] = t | i에서 j까지의 s 슬라이스는 iterable t의 내용으로 대체됩니다. | |
del 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.append(x) | 시퀀스의 끝에 x를 추가합니다(s[len(s):len(s)] = [x]와 동일). | |
s.clear() | s에서 모든 항목을 제거합니다(del s[:]와 동일). | (5) |
s.copy() | s의 얕은 복사본을 만듭니다(s[:]와 동일). | (5) |
s.extend(t) or s += t | t의 내용으로 s를 확장합니다(대부분 s[len(s):len(s)] = t와 동일) | |
s *= n | 내용을 n번 반복하여 s를 업데이트합니다. | (6) |
s.insert(i, x) | i에 의해 주어진 인덱스에서 x를 s에 삽입합니다(s[i:i] = [x]와 동일). | |
s.pop() or s.pop(i) | i에서 항목을 검색하고 s에서도 제거합니다. | (2) |
s.remove(x) | s[i]가 x와 같은 s에서 첫 번째 항목을 제거합니다. | (3) |
s.reverse() | 제자리에 있는 s의 항목을 뒤집습니다. | (4) |
노트:
- t는 교체하는 슬라이스와 길이가 같아야 합니다.
- 선택적 인수 i의 기본값은 -1이므로 기본적으로 마지막 항목이 제거되고 반환됩니다.
- remove()는 s에서 x를 찾을 수 없을 때 ValueError를 발생시킵니다.
- reverse() 메서드는 큰 시퀀스를 뒤집을 때 공간 절약을 위해 시퀀스를 수정합니다. 부작용으로 작동한다는 것을 사용자에게 상기시키기 위해 역순으로 반환하지 않습니다.
- clear() 및 copy()는 슬라이싱 작업(예: dict 및 set)을 지원하지 않는 가변 컨테이너의 인터페이스와의 일관성을 위해 포함됩니다. copy()는 collections.abc.MutableSequence ABC의 일부가 아니지만 대부분의 구체적인 가변 시퀀스 클래스에서 제공합니다.
버전 3.3의 새로운 기능: clear() 및 copy() 메서드. - 값 n은 정수이거나 __index__()를 구현하는 객체입니다. n의 0 및 음수 값은 시퀀스를 지웁니다. 시퀀스의 항목은 복사되지 않습니다. Common Sequence Operations에서 s * n에 대해 설명한 것처럼 여러 번 참조됩니다.
Lists
목록은 일반적으로 동종 항목의 컬렉션을 저장하는 데 사용되는 변경 가능한 시퀀스입니다(정확한 유사성 정도는 응용 프로그램에 따라 다름).
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). 목록의 각 항목에 해당하는 키는 한 번 계산된 다음 전체 정렬 프로세스에 사용됩니다. 기본값 없음은 목록 항목이 별도의 키 값을 계산하지 않고 직접 정렬됨을 의미합니다.
functools.cmp_to_key() 유틸리티를 사용하여 2.x 스타일 cmp 함수를 키 함수로 변환할 수 있습니다.
반전은 부울 값입니다. True로 설정하면 각 비교가 반대인 것처럼 목록 요소가 정렬됩니다.
이 방법은 큰 시퀀스를 정렬할 때 공간 절약을 위해 시퀀스를 수정합니다. 부작용으로 작동한다는 것을 사용자에게 상기시키기 위해 정렬된 시퀀스를 반환하지 않습니다(새로 정렬된 목록 인스턴스를 명시적으로 요청하려면 sorted() 사용).
sort() 메서드는 안정성이 보장됩니다. 동등하다고 비교되는 요소의 상대적인 순서를 변경하지 않는 경우 정렬이 안정적입니다. 이는 여러 단계에서 정렬하는 데 유용합니다(예: 부서별로 정렬한 다음 급여 등급별로 정렬).
정렬 예제와 간단한 정렬 튜토리얼은 Sorting HOW TO를 참조하십시오.
CPython 구현 세부 사항: 목록이 정렬되는 동안 목록을 변경하거나 검사하려는 시도의 효과는 정의되지 않습니다. Python의 C 구현은 목록이 기간 동안 비어 있는 것처럼 보이게 하고, 정렬 중에 목록이 변경된 것을 감지할 수 있으면 ValueError 를 발생시킵니다.
Tuples
튜플은 일반적으로 이기종 데이터 모음을 저장하는 데 사용되는 불변 시퀀스입니다(예: enumerate() 내장에 의해 생성된 2-튜플). 튜플은 동종 데이터의 불변 시퀀스가 필요한 경우에도 사용됩니다(예: set 또는 dict 인스턴스에 저장 허용).
class tuple([iterable])
튜플은 여러 가지 방법으로 구성할 수 있습니다.
- 한 쌍의 괄호를 사용하여 빈 튜플을 나타냅니다: ()
- 싱글톤 튜플에 후행 쉼표 사용: a, 또는 (a,)
- 쉼표로 항목 구분: a, b, c 또는 (a, b, c)
- 내장 tuple() 사용: tuple() 또는 tuple(iterable)
생성자는 항목이 iterable의 항목과 동일하고 동일한 순서로 있는 튜플을 빌드합니다. iterable은 시퀀스, 반복을 지원하는 컨테이너 또는 반복자 객체일 수 있습니다. iterable이 이미 튜플이면 변경되지 않고 반환됩니다. 예를 들어, tuple(‘abc’)는 (‘a’, ‘b’, ‘c’)를 반환하고 tuple( [1, 2, 3] )은 (1, 2, 3)을 반환합니다. 인수가 제공되지 않으면 생성자는 새로운 빈 튜플()을 만듭니다.
실제로 튜플을 만드는 것은 괄호가 아니라 쉼표입니다. 괄호는 빈 튜플의 경우나 구문 모호성을 피하기 위해 필요한 경우를 제외하고 선택 사항입니다. 예를 들어, f(a, b, c)는 세 개의 인수가 있는 함수 호출이고 f((a, b, c))는 3-튜플이 유일한 인수인 함수 호출입니다.
튜플은 모든 공통 시퀀스 작업을 구현합니다.
인덱스에 의한 액세스보다 이름에 의한 액세스가 더 명확한 이기종 데이터 컬렉션의 경우 collections.namedtuple()이 단순한 튜플 객체보다 더 적절한 선택일 수 있습니다.
Ranges
범위 유형은 불변의 숫자 시퀀스를 나타내며 일반적으로 for 루프에서 특정 횟수만큼 루핑하는 데 사용됩니다.
class range(stop)
class range(start, stop[, step])
범위 생성자에 대한 인수는 정수(내장 int 또는 __index__() 특수 메서드를 구현하는 객체)여야 합니다. 단계 인수가 생략되면 기본값은 1입니다. 시작 인수가 생략되면 기본값은 0입니다. 단계가 0이면 ValueError가 발생합니다.
양수 단계의 경우 범위 r의 내용은 공식 r[i] = start + step*i에 의해 결정됩니다. 여기서 i >= 0 및 r[i] < stop입니다.
음수 단계의 경우 범위의 내용은 여전히 공식 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
시작 매개변수의 값(또는 매개변수가 제공되지 않은 경우 0)
stop
중지 매개변수의 값
step
단계 매개변수의 값(또는 매개변수가 제공되지 않은 경우 1)
일반 목록이나 튜플에 비해 범위 유형의 장점은 범위 객체가 나타내는 범위의 크기에 관계없이 항상 동일한(작은) 양의 메모리를 사용한다는 것입니다(시작, 중지 및 단계 값만 저장하기 때문). , 필요에 따라 개별 항목 및 하위 범위 계산).
Range 개체는 collections.abc.Sequence ABC를 구현하고 포함 테스트, 요소 인덱스 조회, 슬라이싱 및 음수 인덱스 지원과 같은 기능을 제공합니다(시퀀스 유형 — 목록, 튜플, 범위 참조).
>>> 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== 및 != 와 동일한지 범위 객체를 테스트하여 시퀀스로 비교합니다. 즉, 두 개의 범위 개체가 동일한 값 시퀀스를 나타내는 경우 동일한 것으로 간주됩니다. (동일하다고 비교되는 두 범위 객체는 서로 다른 시작, 중지 및 단계 속성을 가질 수 있습니다. 예를 들어 range(0) == range(2, 1, 3) 또는 range(0, 3, 2) == range(0, 4, 2).)
버전 3.2에서 변경: 시퀀스 ABC를 구현합니다. 슬라이싱 및 음수 인덱스를 지원합니다. 모든 항목을 반복하는 대신 일정한 시간에 int 개체의 멤버십을 테스트합니다.
버전 3.3에서 변경: ‘==’ 및 ‘!=’를 정의하여 개체 ID를 기반으로 비교하는 대신 정의하는 값의 시퀀스를 기반으로 범위 개체를 비교합니다.
버전 3.3의 새로운 기능: 시작, 중지 및 단계 속성.
See also:
linspace recipe는 부동 소수점 응용 프로그램에 적합한 범위의 게으른 버전을 구현하는 방법을 보여줍니다.
Text Sequence Type — str
Python의 텍스트 데이터는 str 개체 또는 문자열로 처리됩니다. 문자열은 유니코드 코드 포인트의 불변 시퀀스입니다. 문자열 리터럴은 다양한 방법으로 작성됩니다.
- 작은따옴표: ‘”큰따옴표” 포함 허용’
- 큰따옴표: “삽입된 ‘작은따옴표’ 허용”
- 삼중 인용부호: ”’작은따옴표 세 개”’, “””큰따옴표 세 개”””
삼중 인용 문자열은 여러 줄에 걸쳐 있을 수 있습니다. 관련된 모든 공백은 문자열 리터럴에 포함됩니다.
단일 식의 일부이고 사이에 공백만 있는 문자열 리터럴은 암시적으로 단일 문자열 리터럴로 변환됩니다. 즉, (“스팸” “계란”) == “스팸계란”입니다.
지원되는 이스케이프 시퀀스 및 대부분의 이스케이프 시퀀스 처리를 비활성화하는 r(“원시”) 접두사를 포함하여 다양한 형태의 문자열 리터럴에 대한 자세한 내용은 문자열 및 바이트 리터럴을 참조하세요.
str 생성자를 사용하여 다른 개체에서 문자열을 만들 수도 있습니다.
별도의 “문자” 유형이 없기 때문에 문자열을 인덱싱하면 길이가 1인 문자열이 생성됩니다. 즉, 비어 있지 않은 문자열 s의 경우 s[0] == s[0:1]입니다.
변경 가능한 문자열 유형도 없지만 str.join() 또는 io.StringIO를 사용하여 여러 조각에서 문자열을 효율적으로 구성할 수 있습니다.
버전 3.3에서 변경: Python 2 시리즈와의 하위 호환성을 위해 문자열 리터럴에서 u 접두사가 다시 한 번 허용됩니다. 문자열 리터럴의 의미에는 영향을 미치지 않으며 r 접두사와 결합할 수 없습니다.
class str(object=”)
class str(object=b”, encoding=’utf-8′, errors=’strict’)
객체의 문자열 버전을 반환합니다. 객체가 제공되지 않으면 빈 문자열을 반환합니다. 그렇지 않으면 str()의 동작은 다음과 같이 인코딩 또는 오류가 제공되는지 여부에 따라 달라집니다.
인코딩도 오류도 지정되지 않은 경우 str(객체)는 type(객체).__str__(객체)를 반환하며, 이는 object의 “비공식” 또는 멋지게 인쇄 가능한 문자열 표현입니다. 문자열 개체의 경우 문자열 자체입니다. 객체에 __str__() 메서드가 없으면 str()은 repr(객체)를 반환합니다.
인코딩 또는 오류 중 적어도 하나가 제공되면 객체는 바이트열류 객체(예: bytes 또는 bytearray)여야 합니다. 이 경우 객체가 바이트열(또는 바이트 배열) 객체이면 str(bytes, encoding, errors)는 bytes.decode(encoding, errors)와 동일합니다. 그렇지 않으면 버퍼 객체의 기본이 되는 bytes 객체는 bytes.decode()를 호출하기 전에 가져옵니다. 버퍼 개체에 대한 정보는 바이너리 시퀀스 유형 — 바이트, 바이트 배열, 메모리 뷰 및 버퍼 프로토콜을 참조하십시오.
encoding 또는 errors 인수 없이 바이트 객체를 str()에 전달하는 것은 비공식 문자열 표현을 반환하는 첫 번째 경우에 해당합니다(Python에 대한 -b 명령줄 옵션 참조). 예를 들어:
>>> str(b'Zoot!')
"b'Zoot!'"str 클래스 및 해당 메서드에 대한 자세한 내용은 아래의 텍스트 시퀀스 유형 — str 및 문자열 메서드 섹션을 참조하십시오. 형식이 지정된 문자열을 출력하려면 형식이 지정된 문자열 리터럴 및 형식 문자열 구문 섹션을 참조하세요. 또한 텍스트 처리 서비스 섹션을 참조하십시오.
String Methods
문자열은 아래에 설명된 추가 메서드와 함께 모든 공통 시퀀스 작업을 구현합니다.
문자열은 또한 두 가지 스타일의 문자열 포매팅을 지원합니다. 하나는 상당한 수준의 유연성과 사용자 지정을 제공하고(str.format(), 포맷 문자열 구문 및 사용자 정의 문자열 포맷팅 참조) 다른 하나는 더 좁은 범위의 유형을 처리하는 C printf 스타일 포맷팅을 기반으로 합니다. 올바르게 사용하기는 약간 어렵지만 처리할 수 있는 경우에는 더 빠릅니다(printf 스타일 문자열 형식화).
표준 라이브러리의 텍스트 처리 서비스 섹션은 다양한 텍스트 관련 유틸리티(re 모듈의 정규식 지원 포함)를 제공하는 다른 여러 모듈을 다룹니다.
str.capitalize()
첫 번째 문자가 대문자이고 나머지는 소문자로 된 문자열의 복사본을 반환합니다.
버전 3.8에서 변경: 첫 번째 문자는 이제 대문자가 아닌 제목으로 입력됩니다. 즉, digraph와 같은 문자는 전체 문자가 아닌 첫 글자만 대문자로 표시됩니다.
str.casefold()
문자열의 케이스폴딩된 복사본을 반환합니다. 대소문자 구분 문자열은 대소문자 없는 일치에 사용할 수 있습니다.
Casefolding은 소문자와 유사하지만 문자열에서 모든 대소문자 구분을 제거하기 위한 것이기 때문에 더 공격적입니다. 예를 들어 독일어 소문자 ‘ß’는 “ss”와 같습니다. 이미 소문자이므로 lower()는 ‘ß’에 대해 아무 작업도 수행하지 않습니다. casefold()는 그것을 “ss”로 변환합니다.
케이스 폴딩 알고리즘은 유니코드 표준의 섹션 3.13에 설명되어 있습니다.
버전 3.3의 새로운 기능.
str.center(width[, fillchar])
길이 너비의 문자열 중앙에 반환합니다. 패딩은 지정된 fillchar(기본값은 ASCII 공간)를 사용하여 수행됩니다. 너비가 len(s)보다 작거나 같으면 원래 문자열이 반환됩니다.
str.count(sub[, start[, end]])
범위에서 하위 문자열 sub의 겹치지 않는 발생 횟수를 반환합니다. 선택적 인수 start 및 end는 슬라이스 표기법으로 해석됩니다.
sub가 비어 있으면 문자열 길이에 1을 더한 문자 사이의 빈 문자열 수를 반환합니다.
str.encode(encoding=’utf-8′, errors=’strict’)
바이트열로 인코딩된 문자열을 반환합니다.
인코딩 기본값은 ‘utf-8’입니다. 가능한 값은 표준 인코딩을 참조하십시오.
오류는 인코딩 오류를 처리하는 방법을 제어합니다. ‘strict'(기본값)이면 UnicodeError 예외가 발생합니다. 다른 가능한 값은 ‘ignore’, ‘replace’, ‘xmlcharrefreplace’, ‘backslashreplace’ 및 codecs.register_error()를 통해 등록된 다른 이름입니다. 자세한 내용은 오류 처리기를 참조하십시오.
성능상의 이유로 인코딩 오류가 실제로 발생하거나 Python 개발 모드가 활성화되거나 디버그 빌드가 사용되지 않는 한 오류 값의 유효성을 확인하지 않습니다.
버전 3.1에서 변경: 키워드 인수에 대한 지원이 추가되었습니다.
버전 3.9에서 변경: 이제 errors 인수의 값이 Python 개발 모드와 디버그 모드에서 확인됩니다.
str.endswith(suffix[, start[, end]])
문자열이 지정된 접미사로 끝나면 True를 반환하고 그렇지 않으면 False를 반환합니다. suffix는 찾을 접미사의 튜플일 수도 있습니다. 선택적 시작으로 해당 위치에서 테스트 시작. 옵션 끝으로 해당 위치에서 비교를 중지합니다.
str.expandtabs(tabsize=8)
현재 열과 지정된 탭 크기에 따라 모든 탭 문자가 하나 이상의 공백으로 대체된 문자열의 복사본을 반환합니다. 탭 위치는 탭 크기 문자마다 발생합니다(기본값은 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'str.find(sub[, start[, end]])
슬라이스 s[start:end] 내에서 부분 문자열 sub가 발견되는 문자열에서 가장 낮은 인덱스를 반환합니다. 선택적 인수 start 및 end는 슬라이스 표기법으로 해석됩니다. sub를 찾을 수 없으면 -1을 반환합니다.
참고: sub의 위치를 알아야 하는 경우에만 find() 메서드를 사용해야 합니다. sub가 하위 문자열인지 확인하려면 in 연산자를 사용하십시오.
>>> 'Py' in 'Python'
Truestr.format(*args, **kwargs)
문자열 형식 지정 작업을 수행합니다. 이 메서드가 호출되는 문자열에는 리터럴 텍스트 또는 중괄호 {}로 구분된 대체 필드가 포함될 수 있습니다. 각 대체 필드에는 위치 인수의 숫자 인덱스 또는 키워드 인수의 이름이 포함됩니다. 각 대체 필드가 해당 인수의 문자열 값으로 대체되는 문자열의 복사본을 반환합니다.
>>> "The sum of 1 + 2 is {0}".format(1+2)
'The sum of 1 + 2 is 3'형식 문자열에 지정할 수 있는 다양한 형식화 옵션에 대한 설명은 형식 문자열 구문을 참조하십시오.
참고 n 유형(예: ‘{:n}’.format(1234))으로 숫자(int, float, complex, decimal.Decimal 및 하위 클래스)를 포맷할 때 함수는 일시적으로 LC_CTYPE 로케일을 LC_NUMERIC 로케일로 설정합니다. ASCII가 아니거나 1바이트보다 길고 LC_NUMERIC 로케일이 LC_CTYPE 로케일과 다른 경우 localeconv()의 decimal_point 및 thousand_sep 필드를 디코딩합니다. 이 임시 변경은 다른 스레드에 영향을 미칩니다.
버전 3.7에서 변경: n 유형으로 숫자를 포맷할 때 함수는 경우에 따라 임시로 LC_CTYPE 로케일을 LC_NUMERIC 로케일로 설정합니다.
str.format_map(mapping)
str.format(**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'버전 3.2의 새로운 기능.
str.index(sub[, start[, end]])
find()와 비슷하지만 하위 문자열을 찾을 수 없으면 ValueError가 발생합니다.
str.isalnum()
문자열의 모든 문자가 영숫자(alphanumeric)이고 하나 이상의 문자가 있으면 True를 반환하고 그렇지 않으면 False를 반환합니다. c.isalpha(), c.isdecimal(), c.isdigit() 또는 c.isnumeric() 중 하나가 True를 반환하면 문자 c는 영숫자입니다.
str.isalpha()
문자열의 모든 문자가 알파벳이고 하나 이상의 문자가 있으면 True를 반환하고 그렇지 않으면 False를 반환합니다. 알파벳 문자는 유니코드 문자 데이터베이스에서 “Letter”로 정의된 문자, 즉 일반 범주 속성이 “Lm”, “Lt”, “Lu”, “Ll” 또는 “Lo” 중 하나인 문자입니다. 이는 유니코드 표준에서 정의된 “알파벳” 속성과 다릅니다.
str.isascii()
문자열이 비어 있거나 문자열의 모든 문자가 ASCII이면 True를 반환하고 그렇지 않으면 False를 반환합니다. ASCII 문자는 U+0000-U+007F 범위의 코드 포인트를 가집니다.
버전 3.7의 새로운 기능.
str.isdecimal()
문자열의 모든 문자가 십진수이고 적어도 하나의 문자가 있으면 True를 반환하고, 그렇지 않으면 False를 반환합니다. 10진수 문자는 10진법으로 숫자를 형성하는 데 사용할 수 있는 문자입니다. U+0660, 아랍어-인도 숫자 0. 공식적으로 10진수 문자는 유니코드 일반 범주 “Nd”의 문자입니다.
str.isdigit()
문자열의 모든 문자가 숫자이고 하나 이상의 문자가 있으면 True를 반환하고 그렇지 않으면 False를 반환합니다. 숫자에는 호환성 위 첨자 숫자와 같이 특별한 처리가 필요한 십진수 문자와 숫자가 포함됩니다. 여기에는 Kharosthi 숫자와 같이 10진법으로 숫자를 형성하는 데 사용할 수 없는 숫자가 포함됩니다. 공식적으로 숫자는 속성 값이 Numeric_Type=Digit 또는 Numeric_Type=Decimal인 문자입니다.
str.isidentifier()
언어 정의, 식별자 및 키워드 섹션에 따라 문자열이 유효한 식별자이면 True를 반환합니다.
string s가 def 및 class와 같은 예약된 식별자인지 테스트하려면 keyword.iskeyword()를 호출하십시오.
예:
>>> 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, 저속한 분수 1/5. 공식적으로 숫자 문자는 속성 값이 Numeric_Type=Digit, Numeric_Type=Decimal 또는 Numeric_Type=Numeric인 문자입니다.
str.isprintable()
문자열의 모든 문자가 인쇄 가능하거나 문자열이 비어 있으면 True를 반환하고 그렇지 않으면 False를 반환합니다. 인쇄할 수 없는 문자는 인쇄 가능한 것으로 간주되는 ASCII 공간(0x20)을 제외하고 유니코드 문자 데이터베이스에서 “기타” 또는 “구분 기호”로 정의된 문자입니다. (이 문맥에서 인쇄 가능한 문자는 문자열에서 repr()이 호출될 때 이스케이프되어서는 안 되는 문자입니다. sys.stdout 또는 sys.stderr에 기록된 문자열 처리와 관련이 없습니다.)
str.isspace()
문자열에 공백 문자만 있고 하나 이상의 문자가 있으면 True를 반환하고 그렇지 않으면 False를 반환합니다.
유니코드 문자 데이터베이스(unicodedata 참조)에서 일반 범주가 Zs(“구분 기호, 공백”)이거나 양방향 클래스가 WS, B 또는 S 중 하나인 경우 문자는 공백입니다.
str.istitle()
문자열이 제목이 있는 문자열이고 적어도 하나의 문자가 있으면 True를 반환합니다. 예를 들어 대문자는 대소문자가 없는 문자 뒤에만 올 수 있고 소문자는 대소문자만 뒤따를 수 있습니다. 그렇지 않으면 False를 반환합니다.
str.isupper()
문자열의 모든 케이스 문자 4가 대문자이고 적어도 하나의 케이스 문자가 있으면 True를 반환하고, 그렇지 않으면 False를 반환합니다.
>>> 'BANANA'.isupper()
True
>>> 'banana'.isupper()
False
>>> 'baNana'.isupper()
False
>>> ' '.isupper()
Falsestr.join(iterable)
iterable에서 문자열을 연결한 문자열을 반환합니다. 바이트 객체를 포함하여 iterable에 문자열이 아닌 값이 있으면 TypeError가 발생합니다. 요소 사이의 구분 기호는 이 메서드를 제공하는 문자열입니다.
str.ljust(width[, fillchar])
길이가 너비인 문자열에서 왼쪽 정렬된 문자열을 반환합니다. 패딩은 지정된 fillchar(기본값은 ASCII 공간)를 사용하여 수행됩니다. 너비가 len(s)보다 작거나 같으면 원래 문자열이 반환됩니다.
str.lower()
모든 케이스 문자 4가 소문자로 변환된 문자열의 복사본을 반환합니다.
사용된 소문자 알고리즘은 유니코드 표준의 섹션 3.13에 설명되어 있습니다.
str.lstrip([chars])
선행 문자가 제거된 문자열의 복사본을 반환합니다. chars 인수는 제거할 문자 집합을 지정하는 문자열입니다. 생략하거나 None인 경우 chars 인수는 기본적으로 공백을 제거합니다. 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(x[, y[, z]])
이 정적 메서드는 str.translate()에 사용할 수 있는 변환 테이블을 반환합니다.
인수가 하나만 있는 경우 유니코드 서수(정수) 또는 문자(길이 1의 문자열)를 유니코드 서수, 문자열(임의의 길이) 또는 없음으로 매핑하는 사전이어야 합니다. 그러면 문자 키가 서수로 변환됩니다.
두 개의 인수가 있는 경우 길이가 같은 문자열이어야 하며 결과 사전에서 x의 각 문자는 y의 동일한 위치에 있는 문자에 매핑됩니다. 세 번째 인수가 있는 경우 문자열이어야 하며 해당 문자는 결과에서 None으로 매핑됩니다.
str.partition(sep)
sep의 첫 번째 항목에서 문자열을 분할하고 구분 기호 앞 부분, 구분 기호 자체 및 구분 기호 뒤 부분을 포함하는 3-튜플을 반환합니다. 구분자가 없으면 문자열 자체를 포함하는 3-튜플을 반환하고 두 개의 빈 문자열을 반환합니다.
str.removeprefix(prefix, /)
문자열이 접두사 문자열로 시작하면 string[len(prefix):]를 반환합니다. 그렇지 않으면 원래 문자열의 복사본을 반환합니다.
>>> 'TestHook'.removeprefix('Test')
'Hook'
>>> 'BaseTestCase'.removeprefix('Test')
'BaseTestCase'버전 3.9의 새로운 기능.
str.removesuffix(suffix, /)
문자열이 접미사 문자열로 끝나고 해당 접미사가 비어 있지 않으면 string[:-len(suffix)]를 반환합니다. 그렇지 않으면 원래 문자열의 복사본을 반환합니다.
>>> 'MiscTests'.removesuffix('Tests')
'Misc'
>>> 'TmpDirMixin'.removesuffix('Tests')
'TmpDirMixin'버전 3.9의 새로운 기능.
str.replace(old, new[, count])
하위 문자열 old가 모두 new로 대체된 문자열의 복사본을 반환합니다. 선택적 인수 count가 제공되면 첫 번째 count 항목만 대체됩니다.
str.rfind(sub[, start[, end]])¶
sub가 s[start:end] 내에 포함되도록 하위 문자열 sub가 있는 문자열에서 가장 높은 인덱스를 반환합니다. 선택적 인수 start 및 end는 슬라이스 표기법으로 해석됩니다. 실패하면 -1을 반환합니다.
str.rindex(sub[, start[, end]])
rfind()와 비슷하지만 substring sub를 찾을 수 없을 때 ValueError를 발생시킵니다.
str.rjust(width[, fillchar])
길이 너비의 문자열에서 오른쪽 정렬된 문자열을 반환합니다. 패딩은 지정된 fillchar(기본값은 ASCII 공간)를 사용하여 수행됩니다. 너비가 len(s)보다 작거나 같으면 원래 문자열이 반환됩니다.
str.rpartition(sep)
sep의 마지막 항목에서 문자열을 분할하고 구분 기호 앞 부분, 구분 기호 자체 및 구분 기호 뒤 부분을 포함하는 3-튜플을 반환합니다. 구분 기호를 찾을 수 없으면 두 개의 빈 문자열과 문자열 자체를 포함하는 3-튜플을 반환합니다.
str.rsplit(sep=None, maxsplit=- 1)
구분 기호 문자열로 sep를 사용하여 문자열의 단어 목록을 반환합니다. maxsplit이 주어지면 최대 maxsplit 분할이 수행됩니다. sep가 지정되지 않았거나 None이면 모든 공백 문자열이 구분 기호입니다. 오른쪽에서 분할하는 것을 제외하고 rsplit()은 아래에서 자세히 설명하는 split()과 같이 동작합니다.
str.rstrip([chars])
후행 문자가 제거된 문자열의 복사본을 반환합니다. chars 인수는 제거할 문자 집합을 지정하는 문자열입니다. 생략하거나 None인 경우 chars 인수는 기본적으로 공백을 제거합니다. chars 인수는 접미사가 아닙니다. 오히려 해당 값의 모든 조합이 제거됩니다.
>>> ' spacious '.rstrip()
' spacious'
>>> 'mississippi'.rstrip('ipz')
'mississ'모든 문자 집합이 아닌 단일 접미사 문자열을 제거하는 메서드는 str.removesuffix()를 참조하십시오. 예를 들어:
>>> 'Monty Python'.rstrip(' Python')
'M'
>>> 'Monty Python'.removesuffix(' Python')
'Monty'str.split(sep=None, maxsplit=- 1)
구분 기호 문자열로 sep를 사용하여 문자열의 단어 목록을 반환합니다. maxsplit이 제공되면 최대 maxsplit 분할이 수행됩니다(따라서 목록에는 최대 maxsplit+1 요소가 포함됨). maxsplit이 지정되지 않았거나 -1이면 분할 수에 제한이 없습니다(가능한 모든 분할이 이루어짐).
sep가 제공되면 연속 구분 기호가 함께 그룹화되지 않고 빈 문자열을 구분하는 것으로 간주됩니다(예: ‘1,,2’.split(‘,’)는 [‘1’, ”, ‘2’]를 반환함). sep 인수는 여러 문자로 구성될 수 있습니다(예: ‘1<>2<>3’.split(‘<>’)는 [‘1’, ‘2’, ‘3’]을 반환함). 빈 문자열을 지정된 구분 기호로 나누면 [”]가 반환됩니다.
예를 들어
>>> '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이면 다른 분할 알고리즘이 적용됩니다. 연속된 공백 실행은 단일 구분 기호로 간주되며 문자열에 선행 또는 후행 공백이 있는 경우 결과의 시작 또는 끝에 빈 문자열이 포함되지 않습니다. 결과적으로 빈 문자열이나 없음 구분 기호가 있는 공백으로만 구성된 문자열을 분할하면 []가 반환됩니다.
예를 들어:
>>> '1 2 3'.split()
['1', '2', '3']
>>> '1 2 3'.split(maxsplit=1)
['1', '2 3']
>>> ' 1 2 3 '.split()
['1', '2', '3']str.splitlines(keepends=False)
줄 경계에서 끊어지는 문자열의 줄 목록을 반환합니다. keepends가 제공되고 true가 아니면 결과 목록에 줄바꿈이 포함되지 않습니다.
이 방법은 다음 라인 경계에서 분할합니다. 특히 경계는 범용 줄 바꿈의 상위 집합입니다.
| Representation | Description |
|---|---|
\n | 줄바꿈 |
\r | 줄바꿈 |
\r\n | 캐리지 리턴 + 라인 피드 |
\v or \x0b | 라인 표 |
\f or \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]])
문자열이 접두사로 시작하면 True를 반환하고 그렇지 않으면 False를 반환합니다. 접두사는 찾을 접두사의 튜플일 수도 있습니다. 선택적 시작을 사용하면 해당 위치에서 시작하는 테스트 문자열입니다. 선택적 끝으로 해당 위치에서 문자열 비교를 중지합니다.
str.strip([chars])
선행 및 후행 문자가 제거된 문자열의 복사본을 반환합니다. chars 인수는 제거할 문자 집합을 지정하는 문자열입니다. 생략하거나 None인 경우 chars 인수는 기본적으로 공백을 제거합니다. 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'str.swapcase()
대문자가 소문자로 또는 그 반대로 변환된 문자열의 복사본을 반환합니다. s.swapcase().swapcase() == s가 반드시 참인 것은 아닙니다.
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."str.translate(table)
주어진 번역표를 통해 각 문자가 매핑된 문자열의 복사본을 반환합니다. 테이블은 __getitem__(), 일반적으로 매핑 또는 시퀀스를 통해 인덱싱을 구현하는 객체여야 합니다. 유니코드 서수(정수)로 인덱싱할 때 테이블 개체는 다음 중 하나를 수행할 수 있습니다. 유니코드 서수 또는 문자열을 반환하여 문자를 하나 이상의 다른 문자에 매핑합니다. return None, 반환 문자열에서 문자를 삭제합니다. 또는 LookupError 예외를 발생시켜 문자를 자신에게 매핑합니다.
str.maketrans()를 사용하여 다양한 형식의 문자 간 매핑에서 변환 맵을 만들 수 있습니다.
사용자 지정 문자 매핑에 대한 보다 유연한 접근 방식은 codecs 모듈을 참조하십시오.
str.upper()
모든 케이스 문자 4를 대문자로 변환한 문자열의 복사본을 반환합니다. s.upper().isupper()는 s에 대소문자가 없는 문자가 포함되어 있거나 결과 문자의 유니코드 범주가 “Lu”(Letter, 대문자)가 아닌 경우 False일 수 있습니다. “Lt”(레터, 제목 케이스).
사용된 대문자 알고리즘은 유니코드 표준의 섹션 3.13에 설명되어 있습니다.
str.zfill(width)
길이 너비의 문자열을 만들기 위해 ASCII ‘0’ 숫자로 채워진 왼쪽 문자열의 복사본을 반환합니다. 선행 기호 접두사(‘+’/’-‘)는 패딩을 기호 문자 앞이 아닌 뒤에 삽입하여 처리됩니다. 너비가 len(s)보다 작거나 같으면 원래 문자열이 반환됩니다.
예를 들어:
>>> "42".zfill(5)
'00042'
>>> "-42".zfill(5)
'-0042'printf-style String Formatting
참고: 여기에 설명된 서식 지정 작업은 여러 일반적인 오류(예: 튜플 및 사전을 올바르게 표시하지 못함)로 이어지는 다양한 문제를 나타냅니다. 최신 형식의 문자열 리터럴, str.format() 인터페이스 또는 템플릿 문자열을 사용하면 이러한 오류를 방지하는 데 도움이 될 수 있습니다. 이러한 각 대안은 단순성, 유연성 및/또는 확장성이라는 장점과 절충점을 제공합니다.
문자열 개체에는 % 연산자(modulo)라는 고유한 내장 연산이 하나 있습니다. 이것은 문자열 포매팅 또는 보간 연산자라고도 합니다. 형식 % 값이 주어지면(여기서 형식은 문자열임), 형식의 % 변환 사양은 값의 0개 이상의 요소로 대체됩니다. 그 효과는 C 언어에서 sprintf()를 사용하는 것과 비슷합니다.
형식에 단일 인수가 필요한 경우 값은 튜플이 아닌 단일 객체일 수 있습니다. 5 그렇지 않으면 값은 형식 문자열 또는 단일 매핑 개체(예: 사전)에 의해 지정된 항목 수와 정확히 일치하는 튜플이어야 합니다.
변환 지정자는 두 개 이상의 문자를 포함하며 다음 구성 요소가 있으며 이 순서로 발생해야 합니다.
- 지정자의 시작을 표시하는 ‘%’ 문자.
- 괄호로 묶인 일련의 문자(예: (somename))로 구성된 매핑 키(선택 사항).
- 일부 변환 유형의 결과에 영향을 미치는 변환 플래그(선택 사항).
- 최소 필드 너비(선택 사항). ‘*'(별표)로 지정된 경우 값의 튜플의 다음 요소에서 실제 너비를 읽고 변환할 개체는 최소 필드 너비와 선택적 정밀도 뒤에 옵니다.
- 정밀도(선택 사항), ‘.’로 지정됨 (점) 다음에 정밀도가 옵니다. ‘*'(별표)로 지정된 경우 값의 튜플의 다음 요소에서 실제 정밀도를 읽고 변환할 값이 정밀도 뒤에 옵니다.
- 길이 수정자(선택 사항).
- 전환 유형.
올바른 인수가 사전(또는 다른 매핑 유형)인 경우 문자열의 형식에는 ‘%’ 문자 바로 뒤에 삽입된 해당 사전에 대한 괄호로 묶인 매핑 키가 포함되어야 합니다. 매핑 키는 매핑에서 형식화할 값을 선택합니다. 예를 들어:
>>> print('%(language)s has %(number)03d quote types.' %
... {'language': "Python", "number": 2})
Python has 002 quote types.이 경우 형식에 * 지정자가 없을 수 있습니다(순차 매개변수 목록이 필요하기 때문).
변환 플래그 문자는 다음과 같습니다.
| Flag | Meaning |
|---|---|
'#' | 값 변환은 “대체 형식”(아래에 정의됨)을 사용합니다. |
'0' | 변환은 숫자 값에 대해 0으로 채워집니다. |
'-' | 변환된 값은 왼쪽으로 조정됩니다(둘 다 제공되는 경우 ‘0’ 변환을 무시함). |
' ' | (공백) 부호 있는 변환으로 생성된 양수(또는 빈 문자열) 앞에는 공백이 있어야 합니다. |
'+' | 부호 문자(‘+’ 또는 ‘-‘)가 변환보다 우선합니다(“공백” 플래그를 재정의함). |
길이 수정자(h, l 또는 L)가 있을 수 있지만 Python에 필요하지 않으므로 무시됩니다. %ld은(는) %d와 동일합니다.
전환 유형은 다음과 같습니다.
| Conversion | Meaning | Notes |
|---|---|---|
'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보다 작거나 정밀도보다 작지 않으면 소문자 지수 형식을 사용하고 그렇지 않으면 십진수 형식을 사용합니다. | (4) |
'G' | 부동 소수점 형식. 지수가 -4보다 작거나 정밀도보다 작지 않으면 대문자 지수 형식을 사용하고 그렇지 않으면 십진수 형식을 사용합니다. | (4) |
'c' | 단일 문자(정수 또는 단일 문자열 허용). | |
'r' | 문자열(repr()을 사용하여 Python 객체를 변환함). | (5) |
's' | 문자열(str()을 사용하여 Python 객체를 변환함). | (5) |
'a' | 문자열(ascii()를 사용하여 Python 객체를 변환함). | (5) |
'%' | 인수가 변환되지 않고 결과에 ‘%’ 문자가 표시됩니다. |
노트:
- 대체 형식을 사용하면 선행 8진수 지정자(‘0o’)가 첫 번째 숫자 앞에 삽입됩니다.
- 대체 형식을 사용하면 선행 ‘0x’ 또는 ‘0X'(‘x’ 또는 ‘X’ 형식이 사용되었는지 여부에 따라 다름)가 첫 번째 숫자 앞에 삽입됩니다.
- 대체 형식을 사용하면 뒤에 숫자가 없더라도 결과에 항상 소수점이 포함됩니다.
- 정밀도는 소수점 이하 자릿수를 결정하며 기본값은 6입니다.
- 대체 형식을 사용하면 결과에 항상 소수점이 포함되며 후행 0은 제거되지 않습니다.
- 정밀도는 소수점 전후의 유효 자릿수를 결정하며 기본값은 6입니다.
- 정밀도가 N이면 출력이 N자로 잘립니다.
- PEP 237 참조.
Python 문자열에는 명시적인 길이가 있으므로 %s 변환은 ‘\0’이 문자열의 끝이라고 가정하지 않습니다.
버전 3.1에서 변경: 절대값이 1e50을 초과하는 숫자에 대한 %f 변환은 더 이상 %g 변환으로 대체되지 않습니다.