이 게시물은 구분된 문자열과 구분되지 않은 문자열을 Python에서 목록으로 분할하는 방법에 대해 설명합니다. Show
관련 게시물:
1. 사용 list() 건설자그만큼
다운로드 코드 실행 2. 사용 str.split() 기능당신은 사용할 수 있습니다 str.split(sep=None) 다음을 사용하여 문자열의 단어
목록을 반환하는 함수 예를 들어, 구분 기호로 문자열을 분할하려면
다운로드 코드 실행
다운로드 코드 실행 3. 사용 shlex.split() 기능그만큼 shlex 모듈 정의
다운로드 코드 실행 Python에서 문자열을 목록으로 나누는 것이 전부입니다. 읽어 주셔서 감사합니다. 우리의 온라인 컴파일러 C, C++, Java, Python, JavaScript, C#, PHP 및 기타 널리 사용되는 프로그래밍 언어를 사용하여 주석에 코드를 게시합니다. 우리처럼? 우리를 친구에게 소개하고 우리가 성장할 수 있도록 도와주세요. 행복한 코딩 :) 내장형¶다음 섹션에서는 인터프리터에 내장된 표준형에 관해 설명합니다. 기본 내장 유형은 숫자, 시퀀스, 매핑, 클래스, 인스턴스 및 예외입니다. 일부 컬렉션 클래스는 가변입니다. 제자리에서 멤버를 추가, 삭제 또는 재배치하고 특정 항목을 반환하지 않는 메서드는 컬렉션 인스턴스 자체를 반환하지 않고 일부 연산들은 여러 객체 형에서 지원됩니다; 특히 사실상 모든 객체를 동등 비교하고, 논리값을 검사하고,
( 논리값 검사¶모든 객체는 논리값을 검사할 수 있는데, 기본적으로 객체는 클래스가 그 객체에 대해 호출될 때
논리값을 돌려주는 연산과 내장 함수는 달리 명시하지 않는 한
항상 거짓의 경우 논리 연산 — and, or, not¶이것들은 우선순위에 따라 오름차순으로 정렬된 논리 연산들입니다:
노트:
비교¶파이썬에는
8가지 비교 연산이 있습니다. 이들 모두는 같은 우선순위를 가집니다 (논리 연산보다는 높습니다). 비교는 임의로 연결될 수 있습니다; 예를 들어 이 표는 비교 연산을 요약합니다:
서로 다른 숫자 형을 제외하고는 서로 다른 형의 객체들은 같다고 비교되지 않습니다. Non-identical instances
of a class normally compare as non-equal unless the class defines the Instances of a class cannot be ordered with respect to other instances of the same class, or other types of object, unless the class defines enough of the methods
같은 문법적 우선순위를 갖는 두 개의 연산, 숫자 형 — int, float, complex¶There are three distinct numeric types: integers, floating point numbers, and complex numbers. In addition, Booleans are a subtype of integers. Integers have unlimited precision. Floating point numbers are
usually implemented using double in C; information about the precision and internal representation of floating point numbers for the machine on which your program is running is available in 숫자는 숫자 리터럴 또는 내장 함수와 연산자의 결과로 만들어집니다. 꾸밈없는 정수 리터럴(16진수, 8진수, 2진수 포함)은
정수를 만듭니다. 소수점 또는 지수 기호가 포함된 숫자 리터럴은 실수를 만듭니다. 숫자 리터럴에 파이썬은 혼합 산술을 완벽하게 지원합니다: 이항 산술 연산자가 다른 숫자 형의 피연산자를 가질 때, “더 좁은” 형의 피연산자는 다른 피연산자의 형으로 넓혀집니다. 정수는 실수보다 좁고, 실수는 복소수보다 좁습니다. 다른 형 숫자 사이의 비교는 그 숫자들의 정확한 값들이 비교되는 것처럼 행동합니다. 2 생성자
(복소수를 제외한) 모든 숫자 형은 다음과 같은 연산들을 지원합니다 (연산의 우선순위는 연산자 우선순위를 참조하십시오):
노트:
모든
추가적인 숫자 연산은 정수 형에 대한 비트 연산¶비트 연산은 정수에 대해서만 의미가 있습니다. 비트 연산의 결과는 무한한 부호 비트를 갖는 2의 보수로 수행되는 것처럼 계산됩니다. 이진 비트 연산의 우선순위는 모두 숫자 연산보다 낮고 비교보다 높습니다; 일항 연산 이 표는 비트 연산을 나열하는데, 우선순위에 따라 오름차순으로 정렬되어 있습니다:
노트:
정수 형에 대한 추가 메서드¶int 형은 부호와 선행 0을 제외하고, 이진수로 정수를 나타내는 데 필요한 비트 수를 돌려줍니다: >>> n = -37 >>> bin(n) '-0b100101' >>> n.bit_length() 6 좀 더 정확하게 말하자면, 다음 코드와 동등합니다: 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()¶Return the number of ones in the binary representation of the absolute value of the integer. This is also known as the population count. Example: >>> 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' The integer is represented using length bytes, and defaults to 1. An The byteorder argument determines the byte order used to represent the integer, and defaults to signed 인자는 정수를 표현하는데 2의 보수가 사용되는지를 결정합니다. signed 가 The default values can be used to conveniently turn an integer into a single byte object. However, when using the default arguments, don’t try to convert a value greater than 255 or you’ll get an 다음 코드와 동등합니다: 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에서 변경: Added default argument values for 주어진 바이트 배열로 표현되는 정수를 돌려줍니다. >>> 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 는 바이트열류 객체 이거나 바이트를 생성하는 이터러블이어야 합니다. The
byteorder argument determines the byte order used to represent the integer, and defaults to 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에서 변경: Added default argument value for 비율이 원래
정수와 정확히 같고 양의 분모를 갖는 정수 쌍을 돌려줍니다. 정수(whole numbers)의 정수 비율은 항상 분자가 그 정수이고 분모는 버전 3.8에 추가. 실수에 대한 추가 메서드¶float 형은 비율이 원래 float와 정확히 같고 양의 분모를 갖는 정수 쌍을 돌려줍니다. 무한대에는
float 인스턴스가 정숫값을 가진 유한이면 >>> (-2.0).is_integer() True >>> (3.2).is_integer() False 두 가지 메서드가 16진수 문자열과의 변환을 지원합니다. 파이썬의 float는 내부적으로 이진수로 저장되기 때문에 float를 십진수 문자열로 또는 그 반대로 변환하는 것은 보통 반올림 오류를 수반합니다. 이에 반해, 16진수 문자열은 부동 소수점 숫자의 정확한 표현과 지정을 가능하게 합니다. 이것은 디버깅 및 수치 작업에 유용할 수 있습니다. float.hex()¶부동 소수점의 16진수 문자열 표현을 돌려줍니다. 유한 부동 소수점의 경우, 이 표현은 항상 선행하는 16진수 문자열 s 로 표현되는 float를 돌려주는 클래스 메서드. 문자열 s 는 앞뒤 공백을 가질 수 있습니다.
16진수 문자열은 다음과 같은 형식을 취합니다: [sign] ['0x'] integer ['.' fraction] ['p' exponent] 선택적인 지수는 16진수가 아닌 십진수로 쓰이고, 숫자에 곱해지는 2의 거듭제곱을 제공한다는 점에 유의하십시오. 예를 들어, 16진수 문자열 >>> float.fromhex('0x3.a7p10') 3740.0
>>> float.hex(3740.0) '0x1.d380000000000p+11' 숫자 형의 해싱¶For numbers CPython 구현 상세: 현재, 사용되는
소수는 32-비트 C long을 가진 기계에서는 다음은 규칙에 대한 세부 사항입니다:
위의 규칙을 명확히 하기 위해, 여기에 유리수,
import sys, math def hash_fraction(m, n): """Compute the hash of a rational number m / n. Assumes m and n are integers, with n positive. Equivalent to hash(fractions.Fraction(m, n)). """ P = sys.hash_info.modulus # Remove common factors of P. (Unnecessary if m and n already coprime.) while m % P == n % P == 0: m, n = m // P, n // P if n % P == 0: hash_value = sys.hash_info.inf else: # Fermat's Little Theorem: pow(n, P-1, P) is 1, so # pow(n, P-2, P) gives the inverse of n modulo P. hash_value = (abs(m) % P) * pow(n, P - 2, P) % P if m < 0: hash_value = -hash_value if hash_value == -1: hash_value = -2 return hash_value def hash_float(x): """Compute the hash of a float x.""" if math.isnan(x): return object.__hash__(x) elif math.isinf(x): return sys.hash_info.inf if x > 0 else -sys.hash_info.inf else: return hash_fraction(*x.as_integer_ratio()) def hash_complex(z): """Compute the hash of a complex number z.""" hash_value = hash_float(z.real) + sys.hash_info.imag * hash_float(z.imag) # do a signed reduction modulo 2**sys.hash_info.width M = 2**(sys.hash_info.width - 1) hash_value = (hash_value & (M - 1)) - (hash_value & M) if hash_value == -1: hash_value = -2 return hash_value 이터레이터 형¶파이썬은 컨테이너에 대한 이터레이션 개념을 지원합니다. 이것은 두 개의 메서드를 사용해서 구현됩니다; 이것들은 사용자 정의 클래스가 이터레이션을 지원할 수 있도록 하는 데 사용됩니다. 아래에서 더 자세히 설명할 시퀀스는 항상 이터레이션 메서드를 지원합니다. One method needs to be defined for container objects to provide iterable support: container.__iter__()¶Return an iterator object. The object is required to support the iterator protocol described below. If a container supports different types of iteration, additional methods
can be provided to specifically request iterators for those iteration types. (An example of an object supporting multiple forms of iteration would be a tree structure which supports both breadth-first and depth-first traversal.) This method corresponds to the 이터레이터 객체 자체는 다음과 같은 두 가지 메서드를 지원해야 하는데, 둘이 함께 이터레이터 프로토콜 (iterator protocol) 를 이룹니다.: iterator.__iter__()¶Return the iterator object itself. This is required to allow both
containers and iterators to be used with the Return the next item from the iterator. If there are no further items, raise the
파이썬은 일반적이거나 특정한 시퀀스 형, 딕셔너리, 기타 더 특화된 형태에 대한 이터레이션을 지원하기 위해 여러 이터레이터 객체를 정의합니다. 이터레이터 프로토콜의 구현을 넘어서 개별적인 형이 중요하지는 않습니다. 일단 이터레이터의 제너레이터 형¶파이썬의 제너레이터 는 이터레이터 프로토콜을 구현하는 편리한 방법을 제공합니다. 컨테이너 객체의 시퀀스 형 — list, tuple, range¶세 가지 기본 시퀀스 형이 있습니다: 리스트, 튜플, 범위 객체. 바이너리 데이터 와 텍스트 문자열 의 처리를 위해 추가된 시퀀스 형들은 별도의 섹션에서 설명합니다. 공통 시퀀스 연산¶다음 표의 연산들은 대부분의 가변과 불변 시퀀스에서 지원됩니다. 사용자 정의 시퀀스에서 이 연산들을 올바르게 구현하기 쉽게 하려고 이 표는 우선순위에 따라 오름차순으로 시퀀스 연산들을 나열합니다. 표에서, s 와 t 는 같은 형의 시퀀스고, n, i, j, k 는 정수이고, x 는 s 가 요구하는 형과 값 제한을 만족하는 임의의 객체입니다.
같은 형의 시퀀스는 비교를 지원합니다. 특히, 튜플과 리스트는 대응하는 항목들을 사전적으로 비교합니다. 이것은 같다고 비교되기 위해서는, 모든 항목이 같다고 비교되고, 두 시퀀스의 형과 길이가 같아야 함을 의미합니다. (자세한 내용은 언어 레퍼런스의 비교를 참조하십시오.) Forward and reversed iterators over mutable sequences access values using an index. That index will continue to march forward (or backward) even if the underlying sequence is mutated. The
iterator terminates only when an 노트:
불변 시퀀스 형¶불변 시퀀스 형이 일반적으로 구현하지만, 가변 시퀀스 형에서는 구현되지 않는 연산은 내장 이 지원은 해시 불가능 값을 포함하는 불변 시퀀스를 해시 하려고 하면
가변 시퀀스 형¶다음 표의 연산들은 가변 시퀀스 형에 정의되어 있습니다. 사용자 정의 시퀀스에서 이 연산들을 올바르게 구현하기 쉽게 하려고
표에서 s 는 가변 시퀀스 형의 인스턴스이고, t 는 임의의 이터러블 객체이며, x 는 s 가 요구하는 형 및 값 제한을 충족시키는 임의의 객체입니다 (예를 들어,
노트:
리스트¶리스트는 가변 시퀀스로, 일반적으로 등질 항목들의 모음을 저장하는 데 사용됩니다 (정확한 유사도는 응용 프로그램마다 다를 수 있습니다). class list([iterable])¶리스트는 여러 가지 방법으로 만들 수 있습니다:
생성자는
항목들과 그 순서가 iterable 과 같은 리스트를 만듭니다. iterable 은 시퀀스, 이터레이션을 지원하는 컨테이너, 이터레이터 객체가 될 수 있습니다. iterable 이 이미 리스트라면, 다른 많은 연산도 리스트를 만드는데, 내장 리스트는 공통 과 가변 시퀀스 연산들을 모두 구현합니다. 또한, 리스트는 다음과 같은 추가 메서드를 제공합니다: sort(*, key=None, reverse=False)¶이 메서드는 항목 간의
key 는 인자 하나를 받아들이는 함수를 지정하는데, 각 리스트 요소에서 비교 키를 추출하는 데 사용됩니다 (예를 들어,
reverse 는 논리값입니다. 이 메서드는 큰 시퀀스를 정렬할 때 공간 절약을 위해 시퀀스를 제자리에서 수정합니다. 부작용으로 작동한다는 것을 사용자에게 상기시키기 위해 정렬된 시퀀스를 돌려주지 않습니다 (새 정렬 된 리스트 인스턴스를 명시적으로 요청하려면
정렬 예제와 간단한 정렬 자습서는 정렬 HOW TO를 참조하십시오. CPython 구현 상세: 리스트가 정렬되는 동안, 리스트를 변경하려고 할 때의, 또는 관찰하려고 할 때조차, 효과는 정의되지 않습니다.
파이썬의 C 구현은 그동안 리스트를 비어있는 것으로 보이게 하고, 정렬 중에 리스트가 변경되었음을 감지할 수 있다면 튜플¶튜플은 불변 시퀀스인데, 보통 이질적인 데이터의 모음을 저장하는 데 사용됩니다 (예를 들어, 내장
튜플은 여러 가지 방법으로 만들 수 있습니다:
생성자는 항목들과 그 순서가 iterable 과 같은 튜플을 만듭니다. iterable 은 시퀀스, 이터레이션을 지원하는 컨테이너, 이터레이터 객체가 될 수 있습니다. iterable 이 이미 튜플이라면 변경되지 않은 상태로 반환됩니다. 예를 들어 튜플을 만드는 것은 실제로는 괄호가 아닌 쉼표임에 유의하십시오. 괄호는 빈 튜플의 경우를 제외하고는 선택적이거나 문법상의 모호함을
피하고자 필요합니다. 예를 들어, 튜플은 공통 시퀀스 연산을 모두 구현합니다. 이름에 의한 액세스가 인덱스에 의한 액세스보다 더 명확한 이질적 데이터 컬렉션의 경우, 범위¶
The
arguments to the range constructor must be integers (either built-in 양수 step 의 경우, 범위 음수 step 의 경우, 범위의 내용은 여전히 식
범위 예제: >>> 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 매개변수의 값 (또는 매개변수가 제공되지 않으면 stop 매개변수의 값 step¶step 매개변수의 값 (또는 매개변수가 제공되지 않으면 정규
범위 객체는 >>> 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
버전 3.2에서 변경: 시퀀스 ABC를 구현합니다. 버전 3.3에서 변경: (객체 아이덴티티에 기반을 두는 대신) 범위 객체가 정의하는 값들의 시퀀스에 기반을 둔 비교를 위해 ‘==’ 와 ‘!=’ 를 정의합니다. 더 보기
텍스트 시퀀스 형 — str¶파이썬의 텍스트 데이터는
삼중 따옴표로 묶인 문자열은 여러 줄에 걸쳐있을 수 있습니다 - 연관된 모든 공백이 문자열 리터럴에 포함됩니다. 단일 표현식의 일부이고 그 들 사이에 공백만 있는 문자열 리터럴은 묵시적으로 단일 문자열 리터럴로 변환됩니다. 즉, 지원되는 이스케이프 시퀀스와 대부분의 이스케이프 시퀀스 처리를 비활성화하는 문자열은 별도의 “문자” 형이 없으므로 문자열을 인덱싱하면 길이가 1인 문자열이 생성됩니다. 즉, 비어 있지 않은 문자열 s 의 경우, 또한, 가변 문자열형은 없지만, 여러 단편으로부터 문자열을 효율적으로 구성하는데
버전 3.3에서 변경: 파이썬 2시리즈와의 하위 호환성을 위해서, object 의 문자열 버전을 돌려줍니다. object 가 제공되지 않으면, 빈 문자열을 돌려줍니다. 그렇지 않으면, If neither encoding nor errors is given, encoding 또는 errors 중 적어도 하나가 주어지면, object 는
bytes-like object (예, encoding 또는 errors 인자 없이 >>> str(b'Zoot!') "b'Zoot!'"
문자열 메서드¶문자열은 공통 시퀀스 연산들을 모두 구현하고, 아래에 기술된 추가적인 메서드도 구현합니다. 문자열은 또한 두 가지 스타일의 문자열 포매팅을 지원합니다. 하나는 큰 폭의 유연성과 사용자 지정을 제공하고 (참조 표준 라이브러리의
텍스트 처리 서비스 섹션은 다양한 텍스트 관련 유틸리티를 ( 첫 문자가 대문자이고 나머지가 소문자인 문자열의 복사본을 돌려줍니다. 버전 3.8에서 변경: 이제 첫 번째 문자는 대문자가 아닌 제목 케이스로 바뀝니다. 이는 이중 문자(digraph)와 같은 문자는 전체 문자 대신 첫 문자만 대문자로 표시된다는 뜻입니다. str.casefold()¶케이스 폴딩 된 문자열을 반환합니다. 케이스 폴딩 된 문자열은 대소문자를 무시한 매칭에 사용될 수 있습니다. 케이스 폴딩은 소문자로 변환하는 것과 비슷하지만 문자열의 모든 케이스 구분을 제거하기 때문에 보다 공격적입니다. 예를 들어, 독일어 소문자 케이스 폴딩 알고리즘은 유니코드 표준의 섹션 3.13 에 설명되어 있습니다. 버전 3.3에 추가. str.center(width[, fillchar])¶길이 width 인 문자열의 가운데에 정렬한 값을 돌려줍니다. 지정된 fillchar (기본값은 ASCII 스페이스)을 사용하여 채웁니다. width 가 범위 [start, end] 에서 부분 문자열 sub 가 중첩되지 않고 등장하는 횟수를 돌려줍니다. 선택적 인자 start 와 end 는 슬라이스 표기법으로 해석됩니다. If sub is empty, returns the number of empty strings between characters which is the length of the string plus one. str.encode(encoding='utf-8', errors='strict')¶Return the string encoded to encoding defaults to errors controls how encoding errors are handled. If For performance reasons, the value of errors is not checked for validity unless an encoding error actually occurs, 파이썬 개발 모드 is enabled or a debug build is used. 버전 3.1에서 변경: 키워드 인자 지원이 추가되었습니다. 버전 3.9에서 변경: The value of the errors argument is now checked in 파이썬 개발 모드 and in debug mode. str.endswith(suffix[, start[, end]])¶문자열이 지정된 suffix 로 끝나면 모든 탭 문자들을 현재의 열과 주어진 탭 크기에 따라 하나나 그 이상의 스페이스로 치환한 문자열의 복사본을 돌려줍니다. 탭 위치는 tabsize 문자마다 발생합니다 (기본값은 8이고, 열 0, 8, 16 등에 탭 위치를 지정합니다). 문자열을 확장하기 위해 현재 열이 0으로 설정되고 문자열을 문자 단위로
검사합니다. 문자가 탭 ( >>> '01\t012\t0123\t01234'.expandtabs() '01 012 0123 01234' >>> '01\t012\t0123\t01234'.expandtabs(4) '01 012 0123 01234'str.find(sub[, start[, end]])¶ 부분 문자열 sub 가 슬라이스 참고
>>> 'Py' in 'Python' Truestr.format(*args, **kwargs)¶ 문자열 포맷 연산을 수행합니다. 이 메서드가 호출되는 문자열은 리터럴 텍스트나 중괄호 >>> "The sum of 1 + 2 is {0}".format(1+2) 'The sum of 1 + 2 is 3' 포맷 문자열에 지정할 수 있는 다양한 포맷 옵션에 대한 설명은 포맷 문자열 문법 을 참조하십시오. 참고 숫자( 버전 3.7에서 변경: 숫자를
>>> 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]])¶
문자열 내의 모든 문자가 알파벳과 숫자이고, 적어도 하나의 문자가 존재하는 경우 문자열 내의 모든 문자가 알파벳이고, 적어도 하나의 문자가 존재하는 경우 문자열이 비어 있거나 문자열의 모든 문자가 ASCII이면 버전 3.7에 추가. str.isdecimal()¶문자열 내의 모든 문자가 십진수 문자이고, 적어도 하나의 문자가 존재하는 경우 문자열 내의 모든 문자가 디짓이고, 적어도 하나의 문자가 존재하는 경우 문자열이 섹션 section 식별자와 키워드 의 언어 정의에 따른 유효한 식별자면 문자열 예제: >>> from keyword import iskeyword >>> 'hello'.isidentifier(), iskeyword('hello') (True, False) >>> 'def'.isidentifier(), iskeyword('def') (True, True)str.islower()¶ 문자열 내의 모든 케이스 문자가 4 소문자이고, 적어도 하나의 케이스 문자가 존재하는 경우 문자열 내의 모든 문자가 숫자이고, 적어도 하나의 문자가 존재하는 경우 문자열 내의 모든 문자가 인쇄할 수 있거나 문자열이 비어있으면 문자열 내에 공백 문자만 있고, 적어도 하나의 문자가 존재하는 경우 유니코드 문자 데이터베이스( 문자열이 제목 케이스 문자열이고 하나 이상의 문자가 있는 경우 문자열 내의 모든 케이스 문자가 4 대문자이고, 적어도 하나의 케이스 문자가 존재하는 경우 >>> 'BANANA'.isupper() True >>> 'banana'.isupper() False >>> 'baNana'.isupper() False >>> ' '.isupper() Falsestr.join(iterable)¶ iterable 의 문자열들을 이어 붙인 문자열을 돌려줍니다. iterable 에 왼쪽으로 정렬된 문자열을 길이 width 인 문자열로 돌려줍니다. 지정된 fillchar (기본값은 ASCII 스페이스)을 사용하여 채웁니다. width 가 모든 케이스 문자 4 가 소문자로 변환된 문자열의 복사본을 돌려줍니다. 사용되는 소문자 변환 알고리즘은 유니코드 표준의 섹션 3.13에 설명되어 있습니다. str.lstrip([chars])¶선행 문자가 제거된 문자열의 복사본을 돌려줍니다. chars 인자는 제거할 문자 집합을 지정하는 문자열입니다. 생략되거나 >>> ' spacious '.lstrip() 'spacious ' >>> 'www.example.com'.lstrip('cmowz.') 'example.com' 문자 집합의 모든 것이 아닌 단일
접두사 문자열을 제거하는 메서드는 >>> 'Arthur: three!'.lstrip('Arthur: ') 'ee!' >>> 'Arthur: three!'.removeprefix('Arthur: ') 'three!'staticstr.maketrans(x[, y[, z]])¶ 이 정적 메서드는 인자가 하나만 있으면 유니코드 포인트 (정수) 또는 문자 (길이가 1인 문자열)를 유니코드 포인트, 문자열 (임의 길이) 또는 인자가
두 개면 길이가 같은 문자열이어야 하며, 결과 딕셔너리에서, x의 각 문자는 y의 같은 위치에 있는 문자로 대응됩니다. 세 번째의 인자가 있는 경우, 문자열이어야 하는데 각 문자가 sep 가 처음 나타나는 위치에서 문자열을 나누고, 구분자 앞에 있는 부분, 구분자 자체, 구분자 뒤에 오는 부분으로 구성된 3-튜플을 돌려줍니다. 구분자가 발견되지 않으면, 문자열 자신과 그 뒤를 따르는 두 개의 빈 문자열로 구성된 3-튜플을 돌려줍니다. str.removeprefix(prefix, /)¶문자열이 prefix 문자열로 시작하면, >>> 'TestHook'.removeprefix('Test') 'Hook' >>> 'BaseTestCase'.removeprefix('Test') 'BaseTestCase' 버전 3.9에 추가. str.removesuffix(suffix, /)¶문자열이 suffix 문자열로 끝나고 해당 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 가
오른쪽으로 정렬된 문자열을 길이 width 인 문자열로 돌려줍니다. 지정된 fillchar (기본값은 ASCII 스페이스)을 사용하여 채웁니다. width 가 sep 가 마지막으로 나타나는 위치에서 문자열을 나누고, 구분자 앞에 있는 부분, 구분자 자체, 구분자 뒤에 오는 부분으로 구성된 3-튜플을 돌려줍니다. 구분자가 발견되지 않으면, 두 개의 빈 문자열과 그 뒤를 따르는 문자열 자신으로 구성된 3-튜플을 돌려줍니다. str.rsplit(sep=None, maxsplit=- 1)¶sep 를 구분자 문자열로 사용하여 문자열에 있는 단어들의 리스트를 돌려줍니다.
maxsplit 이 주어지면 가장 오른쪽에서 최대 maxsplit 번의 분할이 수행됩니다. sep 이 지정되지 않거나 후행 문자가 제거된 문자열의 복사본을 돌려줍니다. chars 인자는 제거할 문자 집합을 지정하는 문자열입니다. 생략되거나 >>> ' spacious '.rstrip() ' spacious' >>> 'mississippi'.rstrip('ipz') 'mississ' 문자 집합의 모든 것이 아닌 단일
접미사 문자열을 제거하는 메서드는 >>> 'Monty Python'.rstrip(' Python') 'M' >>> 'Monty Python'.removesuffix(' Python') 'Monty'str.split(sep=None, maxsplit=- 1)¶ sep 를 구분자 문자열로 사용하여 문자열에 있는 단어들의 리스트를 돌려줍니다. maxsplit 이 주어지면 최대 maxsplit 번의 분할이 수행됩니다 (따라서, 리스트는 최대 sep 이 주어지면, 연속된 구분자는 묶이지 않고 빈 문자열을 구분하는 것으로 간주합니다 (예를 들어, 예를 들면: >>> '1,2,3'.split(',') ['1', '2', '3'] >>> '1,2,3'.split(',', maxsplit=1) ['1', '2,3'] >>> '1,2,,3,'.split(',') ['1', '2', '', '3', ''] sep 이 지정되지 않거나 예를 들면: >>> '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 가 참으로 주어지지 않는 한 결과 리스트에 줄 바꿈은 포함되지 않습니다. 이 메서드는 다음 줄 경계에서 나눕니다. 특히, 경계는 유니버설 줄 넘김 을 포함합니다.
버전 3.2에서 변경: 예를 들면: >>> '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 이 주어졌을 때 >>> "".splitlines() [] >>> "One line\n".splitlines() ['One line'] 비교해 보면, >>> ''.split('\n') [''] >>> 'Two lines\n'.split('\n') ['Two lines', '']str.startswith(prefix[, start[, end]])¶ 문자열이 지정된 prefix 로 시작하면 선행과 후행 문자가 제거된 문자열의 복사본을 돌려줍니다. 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()¶ 대문자를 소문자로, 그 반대로 마찬가지로 변환 한 문자열의 복사본을 돌려줍니다. 단어가 대문자로 시작하고 나머지 문자는 소문자가 되도록 문자열의 제목 케이스 버전을 돌려줍니다. 예를 들면: >>> 'Hello world'.title() 'Hello World' 이 알고리즘은 단어를 글자들의 연속으로 보는 간단한 언어 독립적 정의를 사용합니다. 이 정의는 여러 상황에서 작동하지만, 축약과 소유의 아포스트로피가 단어 경계를 형성한다는 것을 의미하고, 이는 원하는 결과가 아닐 수도 있습니다: >>> "they're bill's friends from the UK".title() "They'Re Bill'S Friends From The Uk" The
Alternatively, a workaround for apostrophes can be constructed using regular expressions: >>> 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)¶ 각 문자를 지정된 변환표를 사용해 매핑한 문자열의 복사본을 돌려줍니다. table은
커스텀 문자 매핑에 대한 보다 유연한 접근법은 모든 케이스 문자 4 가 대문자로 변환된 문자열의 복사본을 돌려줍니다. 사용되는 대문자 변환 알고리즘은 유니코드 표준의 섹션 3.13에 설명되어 있습니다. str.zfill(width)¶길이가 width 인 문자열을 만들기 위해 ASCII 예를 들면: >>> "42".zfill(5) '00042' >>> "-42".zfill(5) '-0042' printf 스타일 문자열 포매팅¶참고 여기에 설명된 포맷 연산은 여러 가지 일반적인 오류를 (예를 들어 튜플과 딕셔너리를 올바르게 표시하지 못하는 것) 유발하는 다양한 문제점들이 있습니다. 새 포맷 문자열 리터럴 나
문자열 객체는 한가지 고유한 내장 연산을 갖고 있습니다: format 이 하나의 인자를 요구하면, values 는 하나의 비 튜플 객체 일 수 있습니다. 5 그렇지 않으면, values 는 format 문자열이 지정하는 항목의 수와 같은 튜플이거나 단일 매핑 객체 (예를 들어, 딕셔너리) 이어야 합니다. 변환 명세는 두 개 이상의 문자를 포함하며 다음과 같은 구성 요소들을 포함하는데, 반드시 이 순서대로 나와야 합니다:
오른쪽 인자가 딕셔너리 (또는 다른 매핑 형)
인 경우, 문자열에 있는 변환 명세는 반드시 >>> print('%(language)s has %(number)03d quote types.' % ... {'language': "Python", "number": 2}) Python has 002 quote types. 이 경우 변환 플래그 문자는 다음과 같습니다:
길이 수정자 ( 변환 유형은 다음과 같습니다:
노트:
파이썬 문자열은 명시적인 길이를 가지고 있으므로, 버전 3.1에서 변경: 절댓값이 1e50 을 넘는 숫자에 대한 바이너리 시퀀스 형 — bytes, bytearray, memoryview¶바이너리 데이터를 조작하기 위한 핵심 내장형은
바이트열 객체¶바이트열 객체는 단일 바이트들의 불변 시퀀스입니다. 많은 주요 바이너리 프로토콜이 ASCII 텍스트 인코딩을 기반으로 하므로, 바이트열 객체는 ASCII 호환 데이터로 작업 할 때만 유효한 여러 가지 메서드를 제공하며 다양한 다른 방법으로 문자열 객체와 밀접한 관련이 있습니다. classbytes([source[, encoding[, errors]]])¶첫째로, 바이트열 리터럴의 문법은 문자열 리터럴과 거의 같지만
바이트열 리터럴에는 ASCII 문자만 허용됩니다 (선언된 소스 코드 인코딩과 관계없습니다). 127 보다 큰 바이너리 값은 적절한 이스케이프 시퀀스를 사용하여 바이트열 리터럴에 입력해야 합니다. 문자열 리터럴의 경우와 마찬가지로 바이트열 리터럴은 이스케이프 시퀀스 처리를 비활성화하기 위해 바이트열 리터럴과 그 표현은 ASCII 텍스트를 기반으로 하지만, 바이트열 객체는 실제로는 정수의 불변 시퀀스처럼 동작하고, 시퀀스의 각 값은 리터럴 형식 외에도, 바이트열 객체는 여러 가지 다른 방법으로 만들 수 있습니다.:
내장 bytes 도 참조하세요. 2개의 16진수는 정확히 하나의 바이트에 대응하기 때문에 16진수는 바이너리 데이터를 설명하는 데 일반적으로 사용되는 형식입니다. 따라서, 바이트열 형은 그 형식의 데이터를 읽는 추가의 클래스 메서드를 갖습니다: classmethod fromhex(string)¶이 >>> bytes.fromhex('2Ef0 F1f2 ') b'.\xf0\xf1\xf2' 버전 3.7에서 변경: 이제
바이트열 객체를 16진수 표현으로 변환하기 위한 역변환 함수가 있습니다. hex([sep[, bytes_per_sep]])¶인스턴스의 바이트마다 2 자릿수의 16진수로 표현한 문자열 객체를 돌려줍니다. >>> b'\xf0\xf1\xf2'.hex() 'f0f1f2' If you want to make the hex string easier to read, you can specify a single character separator sep parameter to include in the output. By default, this separator will be included between each byte. A second optional bytes_per_sep parameter controls the spacing. Positive values calculate the separator position from the right, negative values from the left. >>> value = b'\xf0\xf1\xf2' >>> value.hex('-') 'f0-f1-f2' >>> value.hex('_', 2) 'f0_f1f2' >>> b'UUDDLRLRAB'.hex(' ', -4) '55554444 4c524c52 4142' 버전 3.5에 추가. 버전 3.8에서 변경: 이제 바이트열 객체는 정수의 시퀀스(튜플과 유사)이기
때문에, 바이트열 객체 b 에 대해서, 바이트열 객체의 표현은 리터럴 형식 ( 바이트 배열 객체¶
바이트 배열 객체에 대한 전용 리터럴 문법은 없으며 항상 생성자를 호출하여 만듭니다:
바이트 배열 객체는 가변이기 때문에, 바이트열 과 바이트 배열 연산 에 설명되어있는 공통 바이트열과 바이트 배열 연산에 더해, 가변 시퀀스 연산도 지원합니다. 내장 bytearray 도 참조하세요. 2개의 16진수는 정확히 하나의 바이트에 대응하기 때문에 16진수는 바이너리 데이터를 설명하는 데 일반적으로 사용되는 형식입니다. 따라서, 바이트 배열형은 그 형식의 데이터를 읽는 추가의 클래스 메서드를 갖습니다: classmethodfromhex(string)¶이 >>> bytearray.fromhex('2Ef0 F1f2 ') bytearray(b'.\xf0\xf1\xf2') 바이트 배열 객체를 16진수 표현으로 변환하기 위한 역변환 함수가 있습니다. hex([sep[, bytes_per_sep]])¶인스턴스의 바이트마다 2 자릿수의 16진수로 표현한 문자열 객체를 돌려줍니다. >>> bytearray(b'\xf0\xf1\xf2').hex() 'f0f1f2' 버전 3.5에 추가. 버전 3.8에서 변경: 바이트 배열 객체는
정수의 시퀀스(리스트와 유사)이기 때문에, 바이트 배열 객체 b 에 대해서, 바이트 배열 객체의 표현은 바이트열 리터럴 형식 ( 바이트열 과 바이트 배열 연산¶바이트열와 바이트 배열 객체는 공통 시퀀스 연산을 지원합니다. 이것들은 같은 형의 피연산자뿐만 아니라 모든 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 사이의 정수일 수 있습니다. If sub is empty, returns the number of empty slices between characters which is the length of the bytes object plus one. 버전 3.3에서 변경: 서브 시퀀스로 0에서 255 사이의 정수도 허용합니다. bytes.removeprefix(prefix, /)¶ bytearray.removeprefix(prefix, /)¶바이너리 데이터가 prefix 문자열로 시작하면, >>> b'TestHook'.removeprefix(b'Test') b'Hook' >>> b'BaseTestCase'.removeprefix(b'Test') b'BaseTestCase' prefix는 임의의 바이트열류 객체 일 수 있습니다. 참고 이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다. 버전 3.9에 추가. bytes.removesuffix(suffix, /)¶ bytearray.removesuffix(suffix, /)¶바이너리 데이터가 suffix 문자열로 끝나고 해당 suffix가 비어 있지 않으면 >>> b'MiscTests'.removesuffix(b'Tests') b'Misc' >>> b'TmpDirMixin'.removesuffix(b'Tests') b'TmpDirMixin' suffix는 임의의 바이트열류 객체 일 수 있습니다. 참고 이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다. 버전 3.9에 추가. bytes.decode(encoding='utf-8', errors='strict')¶ bytearray.decode(encoding='utf-8', errors='strict')¶Return the bytes decoded to a encoding defaults to errors controls how decoding errors are handled. If For performance reasons, the value of errors is not checked for validity unless a decoding error actually occurs, 파이썬 개발 모드 is enabled or a debug build is used. 참고 Passing the encoding argument to 버전 3.1에서 변경: 키워드 인자 지원이 추가되었습니다. 버전 3.9에서 변경: The value of the errors argument is now checked in 파이썬 개발 모드 and in debug mode. bytes.endswith(suffix[, start[, end]])¶ bytearray.endswith(suffix[, start[, end]])¶바이너리 데이터가 지정된 suffix 로 끝나면 검색할 접미사(들)는 임의의 bytes-like object 일 수 있습니다. bytes.find(sub[, start[, end]])¶ bytearray.find(sub[, start[, end]])¶서브 시퀀스 sub 가 슬라이스 검색할 서브 시퀀스는 임의의 bytes-like object 또는 0에서 255 사이의 정수일 수 있습니다. 참고
>>> b'Py' in b'Python' True 버전 3.3에서 변경: 서브 시퀀스로 0에서 255 사이의 정수도 허용합니다. bytes.index(sub[, start[, end]])¶ bytearray.index(sub[, start[, end]])¶
검색할 서브 시퀀스는 임의의 bytes-like object 또는 0에서 255 사이의 정수일 수 있습니다. 버전 3.3에서 변경: 서브 시퀀스로 0에서 255 사이의 정수도 허용합니다. bytes.join(iterable)¶ bytearray.join(iterable)¶iterable 의 바이너리 데이터 시퀀스들을 이어 붙이기 한 바이트열 또는 바이트 배열 객체를 돌려줍니다. iterable 에 이 정적 메서드는 버전 3.1에 추가. bytes.partition(sep)¶ bytearray.partition(sep)¶sep 가 처음 나타나는 위치에서 시퀀스를 나누고, 구분자 앞에 있는 부분, 구분자 자체, 구분자 뒤에 오는 부분으로 구성된 3-튜플을 돌려줍니다. 구분자가 발견되지 않으면, 원래 시퀀스의 복사본과 그 뒤를 따르는 두 개의 빈 바이트열 또는 바이트 배열 객체로 구성된 3-튜플을 돌려줍니다. 검색할 구분자는 임의의 bytes-like object 일 수 있습니다. bytes.replace(old, new[, count])¶ bytearray.replace(old, new[, count])¶모든 서브 시퀀스 old 가 new 로 치환된 시퀀스의 복사본을 돌려줍니다. 선택적 인자 count 가 주어지면, 앞의 count 개만 치환됩니다. 검색할 서브 시퀀스와 그 대체물은 임의의 bytes-like object 일 수 있습니다. 참고 이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다. bytes.rfind(sub[, start[, end]])¶ bytearray.rfind(sub[, start[, end]])¶서브 시퀀스 sub 가 검색할 서브 시퀀스는 임의의 bytes-like object 또는 0에서 255 사이의 정수일 수 있습니다. 버전 3.3에서 변경: 서브 시퀀스로 0에서 255 사이의 정수도 허용합니다. bytes.rindex(sub[, start[, end]])¶ bytearray.rindex(sub[, start[, end]])¶
검색할 서브 시퀀스는 임의의 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 로 시작하면 검색할 접두사(들)는 임의의 bytes-like object 일 수 있습니다. bytes.translate(table, /, delete=b'')¶ bytearray.translate(table, /, delete=b'')¶생략 가능한 인자 delete 의 모든 바이트를 제거하고, 나머지 바이트들을 주어진 변환표로 매핑한 바이트열이나 바이트 배열 객체의 복사본을 돌려줍니다. table은 길이 256인 바이트열 객체이어야 합니다.
문자를 지우기만 하는 변환에는 table 인자를 >>> b'read this short text'.translate(None, b'aeiou') b'rd ths shrt txt' 버전 3.6에서 변경: 이제 delete 는 키워드 인자로 지원됩니다. 바이트열 및 바이트 배열 객체에 대한 다음 메서드는 ASCII 호환 바이너리 형식의 사용을 가정하는 기본 동작을 갖지만, 적절한 인자를 전달하여 임의의 바이너리 데이터와 함께 사용할 수 있습니다. 이 섹션의 바이트 배열 메서드는 모두 제자리에서 작동하지 않고 대신 새로운 객체를 생성함에 주의하십시오. bytes.center(width[, fillbyte])¶ bytearray.center(width[, fillbyte])¶길이 width 인 시퀀스의 가운데에 정렬한 객체의 복사본을 돌려줍니다. 지정된 fillbyte (기본값은 ASCII 스페이스)를 사용하여 채웁니다.
참고 이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다. bytes.ljust(width[, fillbyte])¶ bytearray.ljust(width[, fillbyte])¶왼쪽으로 정렬된 객체의 복사본을 길이 width 인 시퀀스로 돌려줍니다. 지정된 fillbyte (기본값은 ASCII 스페이스)을 사용하여 채웁니다. 참고 이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다. bytes.lstrip([chars])¶ bytearray.lstrip([chars])¶선행 바이트가 제거된 시퀀스의 복사본을 돌려줍니다. chars 인자는 제거할 바이트 집합을 지정하는 바이너리 시퀀스입니다 - 이름은 이 메서드가 보통 ASCII 문자와 사용된다는 사실을 반영합니다. 생략되거나 >>> b' spacious '.lstrip() b'spacious ' >>> b'www.example.com'.lstrip(b'cmowz.') b'example.com' 제거할 바이트 값의 바이너리 시퀀스는 임의의 바이트열류 객체일 수 있습니다. 문자 집합의 모든 것이 아닌 단일 접두사 문자열을 제거하는 메서드는 >>> b'Arthur: three!'.lstrip(b'Arthur: ') b'ee!' >>> b'Arthur: three!'.removeprefix(b'Arthur: ') b'three!' 참고 이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다. bytes.rjust(width[, fillbyte])¶ bytearray.rjust(width[, fillbyte])¶오른쪽으로 정렬된 객체의 복사본을 길이 width 인 시퀀스로 돌려줍니다. 지정된 fillbyte (기본값은 ASCII 스페이스)를 사용하여 채웁니다.
참고 이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다. bytes.rsplit(sep=None, maxsplit=- 1)¶ bytearray.rsplit(sep=None, maxsplit=- 1)¶sep 을 구분자 시퀀스로 사용하여 바이너리 시퀀스를 같은 형의 서브 시퀀스로 나눕니다. maxsplit 이 주어지면 가장 오른쪽에서 최대 maxsplit 번의 분할이 수행됩니다. sep 이 지정되지 않거나 지정된 후행 바이트가 제거된 시퀀스의 복사본을 돌려줍니다. chars 인자는 제거할 바이트 집합을 지정하는 바이너리 시퀀스입니다 - 이름은 이 메서드가 보통 ASCII 문자와 사용된다는 사실을 반영합니다. 생략되거나 >>> b' spacious '.rstrip() b' spacious' >>> b'mississippi'.rstrip(b'ipz') b'mississ' 제거할 바이트 값의 바이너리 시퀀스는 임의의 바이트열류 객체일 수 있습니다. 문자 집합의 모든 것이 아닌 단일 접미사 문자열을 제거하는 메서드는 >>> 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 분할이 수행됩니다 (따라서, 리스트는 최대 sep 이 주어지면, 연속된 구분자는 묶이지 않고 빈 서브 시퀀스를 구분하는 것으로 간주합니다 (예를 들어, 예를 들면: >>> b'1,2,3'.split(b',') [b'1', b'2', b'3'] >>> b'1,2,3'.split(b',', maxsplit=1) [b'1', b'2,3'] >>> b'1,2,,3,'.split(b',') [b'1', b'2', b'', b'3', b''] sep 이 지정되지 않거나 예를 들면: >>> b'1 2 3'.split() [b'1', b'2', b'3'] >>> b'1 2 3'.split(maxsplit=1) [b'1', b'2 3'] >>> b' 1 2 3 '.split() [b'1', b'2', b'3']bytes.strip([chars])¶ bytearray.strip([chars])¶ 선행과 후행 바이트가 제거된 시퀀스의 복사본을 돌려줍니다. chars 인자는 제거할 바이트 집합을 지정하는 바이너리 시퀀스입니다 - 이름은 이 메서드가 보통 ASCII 문자와 사용된다는 사실을 반영합니다. 생략되거나 >>> 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'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 십진수이고 시퀀스가 비어 있지 않으면 예를 들면: >>> b'ABCabc1'.isalnum() True >>> b'ABC abc1'.isalnum() Falsebytes.isalpha()¶ bytearray.isalpha()¶ 시퀀스의 모든 바이트가 알파벳 ASCII 문자이고 시퀀스가 비어 있지 않으면 예를 들면: >>> b'ABCabc'.isalpha() True >>> b'ABCabc1'.isalpha() Falsebytes.isascii()¶ bytearray.isascii()¶ 시퀀스가 비어 있거나 시퀀스의 모든 바이트가 ASCII면
버전 3.7에 추가. bytes.isdigit()¶ bytearray.isdigit()¶시퀀스의 모든 바이트가 ASCII 십진수이며 시퀀스가 비어 있지 않으면 예를 들면: >>> b'1234'.isdigit() True >>> b'1.23'.isdigit() False 시퀀스에 적어도 하나의 ASCII 소문자가 있고,
ASCII 대문자가 없으면 예를 들면: >>> b'hello world'.islower() True >>> b'Hello world'.islower() False ASCII 소문자는 시퀀스 시퀀스의 모든 바이트가 ASCII 공백이고, 시퀀스가 비어 있지 않으면 시퀀스가 ASCII 제목 케이스고 시퀀스가 비어있지
않으면 예를 들면: >>> b'Hello World'.istitle() True >>> b'Hello world'.istitle() Falsebytes.isupper()¶ bytearray.isupper()¶ 시퀀스에 적어도 하나의 ASCII 대문자가 있고, ASCII 소문자가 없으면 예를 들면: >>> b'HELLO WORLD'.isupper() True >>> b'Hello world'.isupper() False ASCII 소문자는 시퀀스 모든 ASCII 대문자를 해당 소문자로 변환한 시퀀스의 복사본을 돌려줍니다. 예를 들면: >>> b'Hello World'.lower() b'hello world' ASCII 소문자는 시퀀스 참고 이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다. 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 이 주어졌을 때 >>> 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 소문자는 시퀀스
참고 이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다. bytes.title()¶ bytearray.title()¶단어가 ASCII 대문자로 시작하고 나머지 문자들은 소문자인 제목 케이스 버전의 바이너리 시퀀스를 돌려줍니다. 케이스 없는 바이트 값은 수정되지 않은 상태로 남습니다. 예를 들면: >>> b'Hello world'.title() b'Hello World' ASCII 소문자는 시퀀스 이 알고리즘은 단어를 글자들의 연속으로 보는 간단한 언어 독립적 정의를 사용합니다. 이 정의는 여러 상황에서 작동하지만, 축약과 소유의 아포스트로피가 단어 경계를 형성한다는 것을 의미하고, 이는 원하는 결과가 아닐 수도 있습니다: >>> 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 소문자는 시퀀스 참고 이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다. bytes.zfill(width)¶ bytearray.zfill(width)¶길이가 width 인 시퀀스를 만들기 위해 ASCII 예를 들면: >>> b"42".zfill(5) b'00042' >>> b"-42".zfill(5) b'-0042' 참고 이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다. printf 스타일 바이너리 포매팅¶참고 여기에 설명된 포맷 연산은 여러 가지 일반적인 오류를 (예를 들어 튜플과 딕셔너리를 올바르게 표시하지 못하는 것) 유발하는 다양한 문제점들이 있습니다. 인쇄될 값이 튜플 또는 딕셔너리일 경우 튜플로 감싸야 합니다. 바이너리 시퀀스 객체는 한가지 고유한 내장 연산을 갖고 있습니다: format 이 하나의 인자를 요구하면, values 는 하나의 비 튜플 객체 일 수 있습니다. 5 그렇지 않으면, values 는 format 바이너리 시퀀스 객체가 지정하는 항목의 수와 같은 튜플이거나 단일 매핑 객체 (예를 들어, 딕셔너리) 여야 합니다. 변환 명세는 두 개 이상의 문자를 포함하며 다음과 같은 구성 요소들을 포함하는데, 반드시 이 순서대로 나와야 합니다:
오른쪽 인자가 딕셔너리 (또는 다른 매핑 형) 인 경우, 바이너리 시퀀스 객체에 있는 변환 명세는
반드시 >>> print(b'%(language)s has %(number)03d quote types.' % ... {b'language': b"Python", b"number": 2}) b'Python has 002 quote types.' 이 경우 변환 플래그 문자는 다음과 같습니다:
길이 수정자 ( 변환 유형은 다음과 같습니다:
노트:
참고 이 메서드의 바이트 배열 버전은 제자리에서 동작하지 않습니다 - 변경되지 않는 경우조차 항상 새 객체를 만듭니다. 더 보기 PEP 461 - bytes와 bytearray에 % 포매팅 추가 버전 3.5에 추가. 메모리 뷰¶
Create a A
>>> v = memoryview(b'abcefg') >>> v[1] 98 >>> v[-1] 103 >>> v[1:4] <memory at 0x7f3ddc9f4350> >>> bytes(v[1:4]) b'bce'
다음은 바이트가 아닌 형식의 예입니다: >>> 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’ 형식의 해시 가능 (읽기 전용) 형의 일차원 메모리 뷰는 역시 해시 가능합니다. 해시는 >>> v = memoryview(b'abcefg') >>> hash(v) == hash(b'abcefg') True >>> hash(v[2:4]) == hash(b'ce') True >>> hash(v[::-2]) == hash(b'abcefg'[::-2]) True 버전 3.3에서 변경: 이제 일차원 메모리 뷰를 슬라이스할 수 있습니다. 이제 형식이 ‘B’, ‘b’, ‘c’ 인 일차원 메모리 뷰는 해시 가능합니다. 버전 3.5에서 변경: 이제 메모리 뷰는 정수의 튜플로 인덱싱될 수 있습니다.
메모리 뷰와 PEP 3118 제공자(exporter)는 다음과 같은 조건을 만족할 때 같다고 비교됩니다: 모양이 동등하고 피연산자의 각 형식 코드가
현재 >>> 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 형식 문자열이 >>> 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 부동 소수점 숫자와 마찬가지로, 메모리 뷰 객체의 경우 버전 3.3에서 변경: 이전 버전에서는 항목 형식과 논리 배열 구조를 무시하고 원시 메모리를 비교했습니다. tobytes(order='C')¶버퍼의 데이터를 바이트열로 돌려줍니다. 이는 메모리 뷰에 >>> m = memoryview(b"abc") >>> m.tobytes() b'abc' >>> bytes(m) b'abc' 불연속
배열의 경우 결과는 모든 요소를 바이트로 변환하여 평평한 리스트로 만든 것과 같습니다. 버전 3.8에 추가: order는 {‘C’, ‘F’, ‘A’} 일 수 있습니다. order가 ‘C’ 나 ‘F’ 이면, 원래 배열의 데이터가 C 나 포트란 순서로 변환됩니다. 연속 뷰의 경우, ‘A’ 는 물리적 메모리의 정확한 사본을 반환합니다. 특히, 메모리 내 포트란 순서가 보존됩니다. 연속적이지 않은 뷰의 경우, 데이터는 먼저 C로 변환됩니다. order=None은 order=’C’와 같습니다. hex([sep[, bytes_per_sep]])¶버퍼 내의 각 바이트를 두 개의 16진수로 표현한 문자열 객체를 돌려줍니다. >>> m = memoryview(b"abc") >>> m.hex() '616263' 버전 3.5에 추가. 버전 3.8에서 변경: 버퍼 내의 데이터를 요소들의 리스트로 돌려줍니다. >>> 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에서 변경: 메모리 뷰 객체의 읽기 전용 버전을 반환합니다. 원래 메모리 뷰 객체는 변경되지 않습니다. >>> m = memoryview(bytearray(b'abc')) >>> mm = m.toreadonly() >>> mm.tolist() [89, 98, 99] >>> mm[0] = 42 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: cannot modify read-only memory >>> m[0] = 43 >>> mm.tolist() [43, 98, 99] 버전 3.8에 추가. release()¶메모리 뷰 객체에 의해 노출된 하부 버퍼를 해제합니다. 많은 객체는 뷰가 그 객체에 연결될 때 특별한 조처를 합니다 (예를 들어, 이 메서드가 호출된 후, 뷰에 대한 더 이상의 연산은 >>> 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 memoryview(b'abc') as m: ... m[0] ... 97 >>> m[0] Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: operation forbidden on released memoryview object 버전 3.2에 추가. cast(format[, shape])¶메모리 뷰를 새로운 형식이나 모양으로 캐스팅합니다. shape 의 기본값은 목적 형식은
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): File "<stdin>", line 1, in <module> ValueError: memoryview: invalid value for format "B" >>> y = x.cast('c') >>> y[0] = b'a' >>> b bytearray(b'ayz') 1D/bytes 를 3D/ints 로 캐스트 한 후 다시 1D/signed char 로 캐스트: >>> import struct >>> buf = struct.pack("i"*12, *list(range(12))) >>> x = memoryview(buf) >>> y = x.cast('i', shape=[2,2,3]) >>> y.tolist() [[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]] >>> y.format 'i' >>> y.itemsize 4 >>> len(y) 2 >>> y.nbytes 48 >>> z = y.cast('b') >>> z.format 'b' >>> z.itemsize 1 >>> len(z) 48 >>> z.nbytes 48 1D/unsigned long 을 2D/unsigned long 으로 캐스트: >>> buf = struct.pack("L"*6, *list(range(6))) >>> x = memoryview(buf) >>> y = x.cast('L', shape=[2,3]) >>> len(y) 2 >>> y.nbytes 48 >>> y.tolist() [[0, 1, 2], [3, 4, 5]] 버전 3.3에 추가. 버전 3.5에서 변경: 바이트 형식으로 변환할 때 소스 형식이 더는 제한되지 않습니다. 몇 가지 읽기 전용 어트리뷰트도 사용할 수 있습니다: obj¶메모리 뷰의 하부 객체: >>> b = bytearray(b'xyz') >>> m = memoryview(b) >>> m.obj is b True 버전 3.3에 추가. nbytes¶
>>> import array >>> a = array.array('i', [1,2,3,4,5]) >>> m = memoryview(a) >>> len(m) 5 >>> m.nbytes 20 >>> y = m[::2] >>> len(y) 3 >>> y.nbytes 12 >>> len(y.tobytes()) 12 다차원 배열: >>> import struct >>> buf = struct.pack("d"*12, *[1.5*x for x in range(12)]) >>> x = memoryview(buf) >>> y = x.cast('d', shape=[3,4]) >>> y.tolist() [[0.0, 1.5, 3.0, 4.5], [6.0, 7.5, 9.0, 10.5], [12.0, 13.5, 15.0, 16.5]] >>> len(y) 3 >>> y.nbytes 96 버전 3.3에 추가. readonly¶메모리가 읽기 전용인지 여부를 나타내는 논리값. format¶뷰의 각 요소에 대한
형식( 버전 3.3에서 변경: 메모리 뷰 각 요소의 크기 (바이트): >>> import array, struct >>> m = memoryview(array.array('H', [32000, 32001, 32002])) >>> m.itemsize 2 >>> m[0] 32000 >>> struct.calcsize('H') == m.itemsize Truendim¶ 메모리가 나타내는 다차원 배열의 차원 수를 나타내는 정수. shape¶N-차원 배열로서의 메모리의 모양을 가리키는, 길이 버전 3.3에서 변경: ndim = 0 일 때 배열의 각 차원에 대해 각 요소를 참조하는데 필요한 바이트 수를 제공하는, 길이 버전 3.3에서 변경: ndim = 0 일 때 PIL 스타일 배열에 내부적으로 사용됩니다. 값은 정보 제공용입니다. c_contiguous¶메모리가 C-연속 인지를 나타내는 논리값. 버전 3.3에 추가. f_contiguous¶메모리가 포트란 연속 인지를 나타내는 논리값. 버전 3.3에 추가. contiguous¶메모리가 연속 인지를 나타내는 논리값. 버전 3.3에 추가. 집합 형 — set, frozenset¶집합 (set) 객체는 서로 다른
해시 가능 객체의 순서 없는 컬렉션입니다. 일반적인 용도는 멤버십 검사, 시퀀스에서 중복 제거와 교집합, 합집합, 차집합, 대칭 차집합과 같은 수학 연산을 계산하는 것입니다. (다른 컨테이너들은 내장 다른 컬렉션과 마찬가지로, 집합은 현재 두 가지 내장형이 있습니다,
비어 있지 않은 set은 (frozenset 은 아닙니다) 두 클래스의 생성자는 같게 작동합니다: classset([iterable])¶ class frozenset([iterable])¶iterable 에서 요소를 취하는 새 set 또는 frozenset 객체를 돌려줍니다. 집합의 원소는 반드시 해시 가능 해야 합니다. 집합의 집합을 표현하려면, 포함되는 집합은 반드시
집합은 여러 가지 방법으로 만들 수 있습니다:
집합 s 의 원소 수(s 의 크기)를 돌려줍니다. x in ss 에 대해 x 의 멤버십을 검사합니다. x not in ss 에 대해 x 의 비 멤버십을 검사합니다. isdisjoint(other)¶집합이 other 와 공통 원소를 갖지 않는 경우 집합의 모든 원소가 other 에 포함되는지 검사합니다. set < other집합이 other 의 진부분집합인지 검사합니다, 즉,
other 의 모든 원소가 집합에 포함되는지 검사합니다. set > other집합이 other 의 진상위집합인지 검사합니다, 즉, 집합과 모든 others에 있는 원소들로 구성된 새 집합을 돌려줍니다. intersection(*others)¶ set & other & ...집합과 모든 others의 공통 원소들로 구성된 새 집합을 돌려줍니다. difference(*others)¶ set - other - ...집합에는 포함되었으나 others에는 포함되지 않은 원소들로 구성된 새 집합을 돌려줍니다. symmetric_difference(other)¶ set ^ other집합이나 other에 포함되어 있으나 둘 모두에 포함되지는 않은 원소들로 구성된 새 집합을 돌려줍니다. copy()¶집합의 얕은 복사본을 돌려줍니다. Note, the non-operator versions of
부분 집합 및 동등 비교는 전 순서(total ordering) 함수로 일반화되지 않습니다. 예를 들어, 비어 있지 않은 두 개의 서로소인 집합은 같지 않고 서로의 부분 집합이 아닙니다, 그래서 다음은 모두 집합은 부분
순서(부분 집합 관계)만 정의하기 때문에, 집합의 리스트에 대한 딕셔너리 키처럼, 집합의 원소는 반드시 해시 가능 해야 합니다.
다음 표는 집합을 갱신해서, 모든 others의 원소들을 더합니다. intersection_update(*others)¶ set &= other & ...집합을 갱신해서, 그 집합과 others에 공통으로 포함된 원소들만 남깁니다. difference_update(*others)¶ set -= other | ...집합을 갱신해서, others에 있는 원소들을 제거합니다. symmetric_difference_update(other)¶ set ^= other집합을 갱신해서, 두 집합의 어느 한 곳에만 포함된 원소들만 남깁니다. add(elem)¶원소 elem 을 집합에 추가합니다. remove(elem)¶원소 elem 을 집합에서 제거합니다. elem 가 집합에 포함되어 있지 않으면 원소 elem 이 집합에 포함되어 있으면 제거합니다. pop()¶집합으로부터
임의의 원소를 제거해 돌려줍니다. 집합이 비어있는 경우 집합의 모든 원소를 제거합니다. 참고로,
참고로, 매핑 형 — dict¶매핑 객체는 해시 가능 값을 임의의 객체에 대응합니다. 매핑은 가변 객체입니다. 현재 오직 하나의 표준 매핑 형이 있습니다, 딕셔너리 (dictionary). (다른 컨테이너들은 내장 A dictionary’s keys are almost arbitrary values. Values that are not
hashable, that is, values containing lists, dictionaries or other mutable types (that are compared by value rather than by object identity) may not be used as keys. Values that compare equal (such as 선택적 위치 인자와 (비어있을 수 있는) 키워드 인자들의 집합으로부터 초기화된 새 딕셔너리를 돌려줍니다. 딕셔너리는 여러 가지 방법으로 만들 수 있습니다:
위치 인자가 제공되지 않으면 빈 딕셔너리가 만들어집니다. 위치 인자가 지정되고 매핑 객체인 경우, 매핑 객체와 같은 키-값 쌍을 갖는 딕셔너리가 만들어집니다. 그렇지 않으면, 위치 인자는 이터러블 객체여야 합니다. 이터러블의 각 항목은 그 자체로 정확하게 두 개의 객체가 있는 이터러블이어야 합니다. 각 항목의 첫 번째 객체는 새 딕셔너리의 키가 되고, 두 번째 객체는 해당 값이 됩니다. 키가 두 번 이상 나타나면, 그 키의 마지막 값이 새 딕셔너리의 해당 값이 됩니다. 키워드 인자가 제공되면, 키워드 인자와 해당 값이 위치 인자로부터 만들어진 딕셔너리에 추가됩니다. 추가되는 키가 이미 존재하면, 키워드 인자에서 온 값이 위치 인자에게서 온 값을 대체합니다. 예를 들어, 다음
예제는 모두 >>> 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 첫 번째 예제에서와같이 키워드 인자는 유효한 파이썬 식별자인 키에 대해서만 작동합니다. 그 외의 경우는 모든 유효한 키를 사용할 수 있습니다. 이것들은 딕셔너리가 지원하는 연산들입니다 (그러므로, 사용자 정의 매핑 형도 지원해야 합니다): list(d)딕셔너리 d 에 사용된 모든 키의 리스트를 돌려줍니다. len(d)딕셔너리 d 에 있는 항목의 수를 돌려줍니다. d[key]키 key 인 d 의 항목을
돌려줍니다. key 가 매핑에 없는 경우 dict 의 서브 클래스가 method >>> class Counter(dict): ... def __missing__(self, key): ... return 0 >>> c = Counter() >>> c['red'] 0 >>> c['red'] += 1 >>> c['red'] 1 위의 예는
d 에서 d 에 키 key 가 있으면
딕셔너리의 키에 대한 이터레이터를 돌려줍니다. 이것은 딕셔너리에서 모든 항목을 제거합니다. copy()¶딕셔너리의 얕은 복사본을 돌려줍니다. classmethodfromkeys(iterable[, value])¶iterable 이 제공하는 값들을 키로 사용하고 모든 값을 value 로 설정한 새 딕셔러리를 돌려줍니다.
key 가 딕셔너리에 있는 경우 key 에 대응하는 값을 돌려주고, 그렇지 않으면 default 를 돌려줍니다. default 가 주어지지 않으면 기본값 딕셔너리 항목들( 딕셔너리 키들의 새 뷰를 돌려줍니다. 뷰 객체의 설명서 을 참조하세요. pop(key[, default])¶key 가 딕셔너리에 있으면 제거하고 그 값을 돌려줍니다. 그렇지 않으면 default 를 돌려줍니다. default 가 주어지지 않고 key 가 딕셔너리에 없으면 딕셔너리에서
버전 3.7에서 변경: 이제 LIFO 순서가 보장됩니다. 이전 버전에서는, 딕셔너리의 키에 대한 역순 이터레이터를 돌려줍니다. 이것은 버전 3.8에 추가. setdefault(key[, default])¶key 가 딕셔너리에
있으면 해당 값을 돌려줍니다. 그렇지 않으면, default 값을 갖는 key 를 삽입한 후 default 를 돌려줍니다. default 의 기본값은 other 가 제공하는 키/값 쌍으로 사전을 갱신합니다. 기존 키는 덮어씁니다.
딕셔너리 값들의 새 뷰를 돌려줍니다. 뷰 객체의 설명서 을 참조하세요. 한 >>> d = {'a': 1} >>> d.values() == d.values() Falsed | other d와 other의 병합된 키와 값으로 새 딕셔너리를 만듭니다. 둘 다 딕셔너리이어야 합니다. d와 other가 키를 공유하면 other의 값이 우선합니다. 버전 3.9에 추가. d |= otherother의 키와 값으로 딕셔너리 d를 갱신합니다. other는 매핑이나 키/값 쌍의 이터러블일 수 있습니다. d와 other가 키를 공유하면 other의 값이 우선합니다. 버전 3.9에 추가. 딕셔너리는 (순서와 관계없이)
같은 딕셔너리는 삽입 순서를 유지합니다. 키를 갱신해도 순서에는 영향을 미치지 않습니다. 삭제 후에 추가된 키는 끝에 삽입됩니다.: >>> d = {"one": 1, "two": 2, "three": 3, "four": 4} >>> d {'one': 1, 'two': 2, 'three': 3, 'four': 4} >>> list(d) ['one', 'two', 'three', 'four'] >>> list(d.values()) [1, 2, 3, 4] >>> d["one"] = 42 >>> d {'one': 42, 'two': 2, 'three': 3, 'four': 4} >>> del d["two"] >>> d["two"] = None >>> d {'one': 42, 'three': 3, 'four': 4, 'two': None} 버전 3.7에서 변경: 딕셔너리 순서는 삽입 순서임이 보장됩니다. 이 동작은 3.6부터 CPython의 구현 세부 사항입니다. 딕셔너리와 딕셔너리 뷰는 뒤집을 수 있습니다. >>> d = {"one": 1, "two": 2, "three": 3, "four": 4} >>> d {'one': 1, 'two': 2, 'three': 3, 'four': 4} >>> list(reversed(d)) ['four', 'three', 'two', 'one'] >>> list(reversed(d.values())) [4, 3, 2, 1] >>> list(reversed(d.items())) [('four', 4), ('three', 3), ('two', 2), ('one', 1)] 버전 3.8에서 변경: 딕셔너리는 이제 뒤집을 수 있습니다. 딕셔너리 뷰 객체¶
딕셔너리 뷰는 이터레이션을 통해 각각의 데이터를 산출할 수 있고, 멤버십 검사를 지원합니다: len(dictview)딕셔너리에 있는 항목 수를 돌려줍니다. iter(dictview)딕셔너리에서 키, 값, 항목( 키와 값은 삽입 순서로
이터레이션 됩니다. 이 때문에 딕셔너리에 항목을 추가하거나 삭제하는 동안 뷰를 이터레이션 하면 버전 3.7에서 변경: 딕셔너리의 순서가 삽입 순서임이 보장됩니다. x in dictviewx 가 하부 딕셔너리의 키, 갑, 항목에 있는 경우 딕셔너리의 키, 값 또는 항목에 대한 역방향 이터레이터를 반환합니다. 뷰는 삽입의 역순으로 이터레이트됩니다. 버전 3.8에서 변경: 딕셔너리 뷰는 이제 역 탐색할 수 있습니다. dictview.mappingReturn a
버전 3.10에 추가. 키 뷰는 항목이 고유하고 해시 가능하므로 집합과 유사합니다. 모든 값이 해시 가능해서 딕셔너리 뷰 사용의 예: >>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500} >>> keys = dishes.keys() >>> values = dishes.values() >>> # iteration >>> n = 0 >>> for val in values: ... n += val >>> print(n) 504 >>> # keys and values are iterated over in the same order (insertion order) >>> list(keys) ['eggs', 'sausage', 'bacon', 'spam'] >>> list(values) [2, 1, 1, 500] >>> # view objects are dynamic and reflect dict changes >>> del dishes['eggs'] >>> del dishes['sausage'] >>> list(keys) ['bacon', 'spam'] >>> # set operations >>> keys & {'eggs', 'bacon', 'salad'} {'bacon'} >>> keys ^ {'sausage', 'juice'} {'juice', 'sausage', 'bacon', 'spam'} >>> # get back a read-only proxy for the original dictionary >>> values.mapping mappingproxy({'bacon': 1, 'spam': 500}) >>> values.mapping['spam'] 500 컨텍스트 관리자 형¶파이썬의
실행시간 컨텍스트에 진입하고 이 객체 자신이나 실행 시간 컨텍스트와 관련된 다른 객체를 돌려줍니다. 이 메서드가 돌려주는 값은, 이 컨텍스트 관리자를 사용하는 자신을 돌려주는 컨텍스트 관리자의 예는
파일 객체 입니다. 파일 객체는 __enter__() 에서 자기 자신을 돌려주는데 관련 객체를 돌려주는 컨텍스트 관리자의 예는
실행 시간 컨텍스트를 탈출하고 발생한 예외를 막아야 하는지를 가리키는 논리 플래그를 돌려줍니다.
이 메서드에서 참 값을 돌려주면 전달 된 예외를 명시적으로 다시 일으켜서는 안 됩니다 - 대신, 이
메서드가 성공적으로 완료되었으며 발생 된 예외를 막지 않겠다는 의미의 거짓을 돌려주어야 합니다. 이렇게 하면 컨텍스트 관리 코드가 파이썬은 쉬운 스레드 동기화, 파일이나 다른 객체의 신속한 닫기, 그리고 활성 십진 소수 산술 컨텍스트의 보다 간단한 조작을 지원하기 위해 몇 가지 컨텍스트 관리자를 정의합니다. 컨텍스트 관리 프로토콜의 구현을 넘어 구체적인 형은 특별히 취급되지 않습니다. 몇 가지 예제는
Python’s generators and the 파이썬/C API의 파이썬 객체에 대한 형 구조체에는 이러한 메서드들을 위해 준비된 슬롯이 없다는 점에 유의하십시오. 이러한 메서드를 정의하고자 하는 확장형은 일반적인 파이썬 액세스가 가능한 메서드로 제공해야 합니다. 실행 시간 컨텍스트를 설정하는 오버헤드와 비교할 때 한 번의 클래스 딕셔너리 조회의 오버헤드는 무시할 수 있습니다. Type Annotation Types — Generic Alias, Union¶The core built-in types for type annotations are Generic Alias and Union. 제네릭 에일리어스 형¶
참고 It is generally only possible to subscript a class if the class implements the special method A For a container class, the argument(s) supplied to a subscription of the class may indicate the type(s) of the elements an object contains. For example, For a class which defines
Creates a def average(values: list[float]) -> float: return sum(values) / len(values) 키 형과 값 형을 나타내는 두 개의 형 매개 변수를 기대하는 제네릭 형인 def send_post_request(url: str, body: dict[str, int]) -> None: ... 내장 함수
>>> 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 The Python runtime does not enforce type annotations. This extends to generic types and their type
parameters. When creating a container object from a >>> t = list[str] >>> t([1, 2, 3]) [1, 2, 3] 또한, 매개 변수화된 제네릭은 객체 생성 중에 형 매개 변수를 지웁니다: >>> t = list[str] >>> type(t) <class 'types.GenericAlias'> >>> l = t() >>> type(l) <class 'list'> 제네릭에서 >>> repr(list[int]) 'list[int]' >>> str(list[int]) 'list[int]' The >>> dict[str][str] Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: There are no type variables left in dict[str] However, such expressions are valid when
type variables are used. The index must have as many elements as there are type variable items in the >>> from typing import TypeVar >>> Y = TypeVar('Y') >>> dict[str, Y][int] dict[str, int] Standard Generic Classes¶The following standard library classes support parameterized generics. This list is non-exhaustive.
Special Attributes of |