Python Built-in Functions – 엔지니어 대한민국

Python 인터프리터에는 항상 사용할 수 있는 여러 함수와 유형이 내장되어 있습니다. 여기에는 알파벳순으로 나열되어 있습니다.

내장 함수:

abs(x)

숫자의 절대값을 반환합니다. 인수는 정수, 부동 소수점 숫자 또는 __abs__()를 구현하는 객체일 수 있습니다. 인수가 복소수이면 크기가 반환됩니다.

aiter(async_iterable)

비동기 이터러블에 대한 비동기 이터레이터를 반환합니다. x.__aiter__()를 호출하는 것과 같습니다.

참고: iter()와 달리 aiter()에는 2인수 변형이 없습니다.
버전 3.10의 새로운 기능.

all(iterable)

iterable의 모든 요소가 참이면(또는 iterable이 비어 있으면) True를 반환합니다. 다음과 같음:

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

awaitable anext(async_iterator)
awaitable anext(async_iterator, default)

기다리면 주어진 비동기 이터레이터에서 다음 항목을 반환하거나, 주어진 경우 기본값을 반환하고 이터레이터가 소진되었습니다.

이것은 next() 내장 함수의 비동기 변형이며 유사하게 동작합니다.

이는 awaitable을 반환하는 async_iterator의 __anext__() 메서드를 호출합니다. 이것을 기다리면 반복자의 다음 값이 반환됩니다. 기본값이 주어지면 반복자가 소진되면 반환되고, 그렇지 않으면 StopAsyncIteration이 발생합니다.

버전 3.10의 새로운 기능.

any(iterable)

iterable의 요소가 참이면 True를 반환합니다. iterable이 비어 있으면 False를 반환합니다. 다음과 같음:

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

ascii(object)

repr()로 객체의 인쇄 가능한 표현을 포함하는 문자열을 반환하지만 \x, \u 또는 \U 이스케이프를 사용하여 repr()이 반환하는 문자열에서 ASCII가 아닌 문자를 이스케이프합니다. 이것은 Python 2에서 repr()이 반환한 것과 유사한 문자열을 생성합니다.

bin(x)

정수를 “0b” 접두사가 붙은 이진 문자열로 변환합니다. 결과는 유효한 Python 표현식입니다. x가 Python int 객체가 아니면 정수를 반환하는 __index__() 메서드를 정의해야 합니다. 몇 가지 예:

>>> bin(3)
'0b11'
>>> bin(-10)
'-0b1010'

접두사 “0b”가 필요한 경우 다음 방법 중 하나를 사용할 수 있습니다.

>>> format(14, '#b'), format(14, 'b')
('0b1110', '1110')
>>> f'{14:#b}', f'{14:b}'
('0b1110', '1110')

자세한 내용은 format()도 참조하십시오.

class bool(x=False)

부울 값, 즉 True 또는 False 중 하나를 반환합니다. x는 표준 진리 테스트 절차를 사용하여 변환됩니다. x가 false이거나 생략되면 False를 반환합니다. 그렇지 않으면 True를 반환합니다. bool 클래스는 int의 하위 클래스입니다(숫자 유형 — int, float, complex 참조). 더 이상 하위 클래스로 분류할 수 없습니다. 유일한 인스턴스는 False 및 True입니다(부울 값 참조).

버전 3.7에서 변경: x는 이제 위치 전용 매개변수입니다.

breakpoint(*args, **kws)

이 함수는 호출 사이트에서 디버거로 이동합니다. 특히 sys.breakpointhook()를 호출하여 args와 kws를 바로 전달합니다. 기본적으로 sys.breakpointhook()는 인수를 기대하지 않고 pdb.set_trace()를 호출합니다. 이 경우 순전히 편의 기능이므로 pdb를 명시적으로 가져오거나 디버거에 들어가기 위해 많은 코드를 입력할 필요가 없습니다. 그러나 sys.breakpointhook()는 다른 함수로 설정할 수 있으며 breakpoint()는 자동으로 해당 함수를 호출하여 선택한 디버거에 드롭할 수 있습니다. sys.breakpointhook()에 액세스할 수 없는 경우 이 함수는 RuntimeError를 발생시킵니다.

breakpointhook 인수를 사용하여 감사 이벤트 builtins.breakpoint를 발생시킵니다.

버전 3.7의 새로운 기능.

class bytearray(source=b”)
class bytearray(source, encoding)
class bytearray(source, encoding, errors)

새로운 바이트 배열을 반환합니다. bytearray 클래스는 0 <= x < 256 범위에 있는 정수의 변경 가능한 시퀀스입니다. 변경 가능한 시퀀스 유형에 설명된 변경 가능한 시퀀스의 일반적인 메서드와 바이트 유형이 갖는 대부분의 메서드가 있습니다. 바이트 및 바이트 배열 작업.

선택적 source 매개 변수를 사용하여 몇 가지 다른 방법으로 어레이를 초기화할 수 있습니다.

문자열인 경우 인코딩(및 선택적으로 오류) 매개변수도 제공해야 합니다. bytearray()는 str.encode()를 사용하여 문자열을 바이트로 변환합니다.
정수인 경우 배열은 해당 크기를 가지며 null 바이트로 초기화됩니다.
버퍼 인터페이스를 준수하는 객체인 경우 객체의 읽기 전용 버퍼가 바이트열 배열을 초기화하는 데 사용됩니다.
이터러블인 경우 배열의 초기 내용으로 사용되는 0 <= x < 256 범위의 정수로 구성된 이터러블이어야 합니다.

인수가 없으면 크기가 0인 배열이 생성됩니다.

Binary Sequence Types — bytes, bytearray, memoryview 및 Bytearray 객체도 참조하십시오.

class bytes(source=b”)
class bytes(source, encoding)
class bytes(source, encoding, errors)

0 <= x < 256 범위의 불변 정수 시퀀스인 새로운 “바이트” 객체를 반환합니다. 바이트는 바이트 배열의 불변 버전입니다. 동일한 비변형 메서드와 동일한 인덱싱 및 슬라이싱 동작을 가집니다.

따라서 생성자 인수는 bytearray()와 같이 해석됩니다.

바이트 개체는 리터럴을 사용하여 만들 수도 있습니다. 문자열 및 바이트 리터럴을 참조하십시오.

Binary Sequence Types — bytes, bytearray, memoryview, Bytes 객체, Bytes 및 Bytearray 연산도 참조하십시오.

callable(object)

객체 인수가 호출 가능한 것처럼 보이면 True를 반환하고 그렇지 않으면 False를 반환합니다. 이것이 True를 반환하면 여전히 호출이 실패할 가능성이 있지만 False이면 개체 호출이 성공하지 못합니다. 클래스는 호출 가능합니다(클래스를 호출하면 새 인스턴스가 반환됨). 클래스에 __call__() 메서드가 있으면 인스턴스를 호출할 수 있습니다.

버전 3.2의 새로운 기능: 이 함수는 Python 3.0에서 처음 제거된 다음 Python 3.2에서 다시 가져왔습니다.

chr(i)

유니코드 코드 포인트가 정수 i인 문자를 나타내는 문자열을 반환합니다. 예를 들어 chr(97)은 문자열 ‘a’를 반환하고 chr(8364)는 문자열 ‘€’를 반환합니다. 이것은 ord()의 반대입니다.

인수의 유효한 범위는 0에서 1,114,111까지입니다(16진수에서 0x10FFFF). i가 해당 범위를 벗어나면 ValueError가 발생합니다.

@classmethod

메서드를 클래스 메서드로 변환합니다.

인스턴스 메서드가 인스턴스를 받는 것처럼 클래스 메서드는 암시적 첫 번째 인수로 클래스를 받습니다. 클래스 메서드를 선언하려면 다음 관용구를 사용하세요.

class C:
    @classmethod
    def f(cls, arg1, arg2): ...

@classmethod 형식은 함수 데코레이터입니다. 자세한 내용은 함수 정의를 참조하세요.

클래스 메서드는 클래스(예: C.f()) 또는 인스턴스(예: C().f())에서 호출할 수 있습니다. 해당 클래스를 제외하고 인스턴스는 무시됩니다. 파생 클래스에 대해 클래스 메서드가 호출되면 파생 클래스 개체가 암시된 첫 번째 인수로 전달됩니다.

클래스 메서드는 C++ 또는 Java 정적 메서드와 다릅니다. 원하는 경우 이 섹션의 staticmethod()를 참조하십시오. 클래스 메서드에 대한 자세한 내용은 표준 유형 계층을 참조하세요.

버전 3.9에서 변경: 클래스 메서드는 이제 property()와 같은 다른 descriptors를 래핑할 수 있습니다.

버전 3.10에서 변경: 클래스 메서드는 이제 메서드 속성(__module__, __name__, __qualname__, __doc__ 및 __annotations__)을 상속하고 새로운 __wrapped__ 속성을 갖습니다.

버전 3.11에서 변경: 클래스 메서드는 더 이상 property()와 같은 다른 descriptors를 래핑할 수 없습니다.

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=- 1)

소스를 코드 또는 AST 개체로 컴파일합니다. 코드 객체는 exec() 또는 eval()에 의해 실행될 수 있습니다. source는 일반 문자열, 바이트 문자열 또는 AST 개체일 수 있습니다. AST 객체로 작업하는 방법에 대한 정보는 ast 모듈 설명서를 참조하십시오.

filename 인수는 코드를 읽은 파일을 제공해야 합니다. 파일에서 읽지 않은 경우 인식할 수 있는 값을 전달합니다(‘<문자열>’이 일반적으로 사용됨).

mode 인수는 어떤 종류의 코드를 컴파일해야 하는지 지정합니다. 소스가 일련의 명령문으로 구성된 경우 ‘exec’, 단일 표현식으로 구성된 경우 ‘eval’, 단일 대화식 명령문(후자의 경우 무언가로 평가되는 표현식 명령문)으로 구성된 경우 ‘single’이 될 수 있습니다. None 이외는 인쇄됩니다).

선택적 인수 flags 및 dont_inherit는 활성화되어야 하는 컴파일러 옵션과 허용되어야 하는 향후 기능을 제어합니다. 둘 다 존재하지 않거나 둘 다 0인 경우 코드는 compile()을 호출하는 코드에 영향을 주는 동일한 플래그로 컴파일됩니다. flags 인수가 제공되고 dont_inherit가 아닌 경우(또는 0인 경우) flags 인수로 지정된 퓨처 문과 컴파일러 옵션이 사용됩니다. dont_inherit가 0이 아닌 정수이면 flags 인수는 그것입니다. 주변 코드의 플래그(향후 기능 및 컴파일러 옵션)는 무시됩니다.

컴파일러 옵션과 퓨처 문은 여러 옵션을 지정하기 위해 함께 비트 OR로 연결될 수 있는 비트로 지정됩니다. 주어진 미래 기능을 지정하는 데 필요한 비트 필드는 __future__ 모듈의 _Feature 인스턴스에서 compiler_flag 속성으로 찾을 수 있습니다. 컴파일러 플래그는 PyCF_ 접두사와 함께 ast 모듈에서 찾을 수 있습니다.

인수 optimize는 컴파일러의 최적화 수준을 지정합니다. 기본값 -1은 -O 옵션으로 주어진 인터프리터의 최적화 수준을 선택합니다. 명시적 수준은 0(최적화 없음, __debug__가 참), 1(어설션이 제거됨, __debug__가 거짓임) 또는 2(독스트링도 제거됨)입니다.

이 함수는 컴파일된 소스가 유효하지 않으면 SyntaxError 를 발생시키고, 소스에 null 바이트가 포함되어 있으면 ValueError 를 발생시킵니다.

Python 코드를 AST 표현으로 구문 분석하려면 ast.parse()를 참조하십시오.

source 및 filename 인수를 사용하여 감사 이벤트 컴파일을 발생시킵니다. 이 이벤트는 암시적 컴파일에 의해 발생할 수도 있습니다.

참고: ‘single’ 또는 ‘eval’ 모드에서 여러 줄 코드로 문자열을 컴파일할 때 입력은 적어도 하나의 개행 문자로 종료되어야 합니다. 이는 code 모듈에서 불완전하고 완전한 문을 쉽게 감지하기 위한 것입니다.

경고: Python AST 컴파일러의 스택 깊이 제한으로 인해 AST 객체로 컴파일할 때 충분히 크고 복잡한 문자열로 Python 인터프리터를 충돌시킬 수 있습니다.

버전 3.2에서 변경: Windows 및 Mac 줄바꿈 사용이 허용되었습니다. 또한 ‘exec’ 모드의 입력은 더 이상 새 줄로 끝나지 않아도 됩니다. 최적화 매개변수를 추가했습니다.

버전 3.5에서 변경: 이전에는 소스에서 null 바이트가 발견되면 TypeError가 발생했습니다.

버전 3.8의 새로운 기능: 이제 ast.PyCF_ALLOW_TOP_LEVEL_AWAIT를 플래그로 전달하여 최상위 await, async for 및 async with를 지원할 수 있습니다.

class complex(real=0, imag=0)
class complex(string)

값이 real + imag*1j인 복소수를 반환하거나 문자열 또는 숫자를 복소수로 변환합니다. 첫 번째 매개변수가 문자열이면 복소수로 해석되며 두 번째 매개변수 없이 함수를 호출해야 합니다. 두 번째 매개변수는 문자열이 될 수 없습니다. 각 인수는 모든 숫자 유형(복소수 포함)일 수 있습니다. imag가 생략되면 기본값은 0이고 생성자는 int 및 float와 같은 숫자 변환 역할을 합니다. 두 인수가 모두 생략되면 0j를 반환합니다.

일반 파이썬 객체 x의 경우, complex(x)는 x.__complex__()에 위임합니다. __complex__()가 정의되어 있지 않으면 __float__()로 돌아갑니다. __float__()가 정의되지 않은 경우 __index__()로 돌아갑니다.

참고: 문자열에서 변환할 때 문자열은 중앙 + 또는 – 연산자 주위에 공백을 포함하지 않아야 합니다. 예를 들어, complex(‘1+2j’)는 괜찮지만 complex(‘1 + 2j’)는 ValueError를 발생시킵니다.

복잡한 유형은 숫자 유형 — int, float, complex에 설명되어 있습니다.

버전 3.6에서 변경: 코드 리터럴에서와 같이 밑줄로 숫자를 그룹화하는 것이 허용됩니다.

버전 3.8에서 변경: __complex__() 및 __float__()가 정의되지 않은 경우 __index__()로 돌아갑니다.

delattr(object, name)

이것은 setattr()의 친척입니다. 인수는 객체와 문자열입니다. 문자열은 객체 속성 중 하나의 이름이어야 합니다. 개체가 허용하는 경우 함수는 명명된 특성을 삭제합니다. 예를 들어, delattr(x, ‘foobar’)는 del x.foobar와 동일합니다. 이름은 파이썬 식별자일 필요가 없습니다(setattr() 참조).

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

새 dictionary를 만듭니다. dict 객체는 사전 클래스입니다. 이 클래스에 대한 문서는 dict 및 매핑 유형 — dict를 참조하십시오.

다른 컨테이너의 경우 내장 목록, 집합 및 튜플 클래스와 collections 모듈을 참조하십시오.

dir()
dir(object)

인수가 없으면 현재 로컬 범위의 이름 목록을 반환합니다. 인수를 사용하여 해당 개체에 대한 유효한 속성 목록을 반환하려고 시도합니다.

객체에 __dir__()이라는 메서드가 있으면 이 메서드가 호출되고 속성 목록을 반환해야 합니다. 이를 통해 사용자 정의 __getattr__() 또는 __getattribute__() 함수를 구현하는 객체가 dir()이 속성을 보고하는 방식을 사용자 정의할 수 있습니다.

객체가 __dir__()을 제공하지 않으면 함수는 객체의 __dict__ 어트리뷰트(정의된 경우)와 해당 유형 객체에서 정보를 수집하기 위해 최선을 다합니다. 결과 목록은 반드시 완전하지는 않으며 개체에 사용자 지정 __getattr__()이 있는 경우 정확하지 않을 수 있습니다.

기본 dir() 메커니즘은 완전한 정보가 아니라 가장 관련성이 높은 정보를 생성하려고 시도하므로 객체 유형에 따라 다르게 작동합니다.

객체가 모듈 객체인 경우 목록에는 모듈 속성의 이름이 포함됩니다.

객체가 유형 또는 클래스 객체인 경우 목록에는 해당 속성의 이름과 기본 속성의 재귀적 이름이 포함됩니다.

그렇지 않으면 목록에는 객체의 속성 이름, 해당 클래스의 속성 이름 및 재귀적으로 해당 클래스의 기본 클래스 속성이 포함됩니다.

결과 목록은 사전순으로 정렬됩니다. 예를 들어:

>>> import struct
>>> dir()   # show the names in the module namespace  
['__builtins__', '__name__', 'struct']
>>> dir(struct)   # show the names in the struct module 
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
 '__initializing__', '__loader__', '__name__', '__package__',
 '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Shape:
...     def __dir__(self):
...         return ['area', 'perimeter', 'location']
>>> s = Shape()
>>> dir(s)
['area', 'location', 'perimeter']

참고: dir()은 주로 대화식 프롬프트에서 사용하기 편리하도록 제공되기 때문에 엄격하거나 일관되게 정의된 이름 집합을 제공하려고 시도하는 것보다 흥미로운 이름 집합을 제공하려고 시도하며 자세한 동작은 릴리스 간에 변경될 수 있습니다. . 예를 들어 인수가 클래스인 경우 메타클래스 속성은 결과 목록에 없습니다.

divmod(a, b)

두 개의 (비복소수) 숫자를 인수로 취하고 정수 나누기를 사용할 때 몫과 나머지로 구성된 숫자 쌍을 반환합니다. 혼합 피연산자 유형을 사용하면 이진 산술 연산자에 대한 규칙이 적용됩니다. 정수의 경우 결과는 (a // b, a % b)와 동일합니다. 부동 소수점 숫자의 경우 결과는 (q, a % b)입니다. 여기서 q는 일반적으로 math.floor(a / b)이지만 그보다 1이 작을 수 있습니다. 어쨌든 q * b + a % b는 a에 매우 가깝습니다. a % b가 0이 아니면 b와 동일한 부호를 가지며 0 <= abs(a % b) < abs(b)입니다.

enumerate(iterable, start=0)

enumerate object를 반환합니다. iterable은 시퀀스, 반복자 또는 반복을 지원하는 다른 객체여야 합니다. enumerate()에 의해 반환된 이터레이터의 __next__() 메서드는 카운트(기본값은 0인 start부터)와 iterable을 반복하여 얻은 값을 포함하는 튜플을 반환합니다.

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

다음과 같음:

def enumerate(iterable, start=0):
    n = start
    for elem in iterable:
        yield n, elem
        n += 1

eval(expression, globals=None, locals=None)

인수는 문자열과 선택적 전역 및 지역입니다. 제공되는 경우 globals는 사전이어야 합니다. 제공되는 경우 locals는 모든 매핑 개체가 될 수 있습니다.

표현식 인수는 전역 및 지역 네임스페이스로 globals 및 locals 사전을 사용하여 Python 표현식(기술적으로 말하면 조건 목록)으로 구문 분석되고 평가됩니다. globals 사전이 있고 __builtins__ 키에 대한 값을 포함하지 않는 경우 내장 모듈 builtins의 사전에 대한 참조가 표현식이 구문 분석되기 전에 해당 키 아래에 삽입됩니다. 그렇게 하면 자신의 __builtins__ 사전을 eval()에 전달하기 전에 전역에 삽입하여 실행된 코드에 사용할 수 있는 내장 항목을 제어할 수 있습니다. locals 사전이 생략되면 기본적으로 globals 사전이 됩니다. 두 사전을 모두 생략하면 eval()이 호출되는 환경에서 전역 및 지역으로 표현식이 실행됩니다. eval()은 둘러싸는 환경에서 중첩된 범위(비로컬)에 액세스할 수 없습니다.

반환 값은 평가된 식의 결과입니다. 구문 오류는 예외로 보고됩니다. 예:

>>> x = 1
>>> eval('x+1')
2

이 함수는 또한 임의의 코드 객체(예: compile()에 의해 생성된 객체)를 실행하는 데 사용할 수 있습니다. 이 경우 문자열 대신 코드 개체를 전달합니다. 코드 객체가 모드 인수로 ‘exec’로 컴파일된 경우 eval()의 반환 값은 None이 됩니다.

힌트: 명령문의 동적 실행은 exec() 함수에 의해 지원됩니다. globals() 및 locals() 함수는 각각 eval() 또는 exec()에서 사용하기 위해 전달하는 데 유용할 수 있는 현재 전역 및 로컬 사전을 반환합니다.

주어진 소스가 문자열이면 선행 및 후행 공백과 탭이 제거됩니다.

리터럴만 포함하는 표현식으로 문자열을 안전하게 평가할 수 있는 함수는 ast.literal_eval()을 참조하십시오.

코드 개체를 인수로 사용하여 감사 이벤트 exec를 발생시킵니다. 코드 컴파일 이벤트도 발생할 수 있습니다.

exec(object, globals=None, locals=None, /, *, closure=None)

이 함수는 Python 코드의 동적 실행을 지원합니다. 객체는 문자열 또는 코드 객체여야 합니다. 문자열인 경우 문자열은 Python 문 모음으로 구문 분석된 다음 실행됩니다(구문 오류가 발생하지 않는 한). 1 코드 객체라면 간단히 실행된다. 모든 경우에 실행되는 코드는 파일 입력으로 유효할 것으로 예상됩니다(참조 설명서의 파일 입력 섹션 참조). nonlocal, yield 및 return 문은 exec() 함수에 전달된 코드 컨텍스트 내에서도 함수 정의 외부에서 사용할 수 없습니다. 반환 값은 없음입니다.

모든 경우에 선택적 부분이 생략되면 현재 범위에서 코드가 실행됩니다. 전역만 제공되는 경우 전역 및 지역 변수 모두에 사용되는 사전이어야 합니다(사전의 하위 클래스가 아님). globals와 locals가 주어지면 각각 전역 변수와 지역 변수에 사용됩니다. 제공되는 경우 locals는 모든 매핑 개체가 될 수 있습니다. 모듈 수준에서 globals와 locals는 동일한 사전임을 기억하십시오. exec가 두 개의 개별 개체를 전역 및 지역으로 가져오면 코드가 클래스 정의에 포함된 것처럼 실행됩니다.

전역 사전에 __builtins__ 키에 대한 값이 없으면 내장 모듈 builtins의 사전에 대한 참조가 해당 키 아래에 삽입됩니다. 그렇게 하면 exec()에 전달하기 전에 자신의 __builtins__ 사전을 전역에 삽입하여 실행된 코드에 사용할 수 있는 내장 항목을 제어할 수 있습니다.

클로저 인수는 클로저(cellvars의 튜플)를 지정합니다. 개체가 자유 변수를 포함하는 코드 개체인 경우에만 유효합니다. 튜플의 길이는 코드 객체가 참조하는 자유 변수의 수와 정확히 일치해야 합니다.

코드 개체를 인수로 사용하여 감사 이벤트 exec를 발생시킵니다. 코드 컴파일 이벤트도 발생할 수 있습니다.

참고: 내장 함수 globals() 및 locals()는 각각 현재 전역 및 로컬 사전을 반환하며, 이는 exec()의 두 번째 및 세 번째 인수로 사용하기 위해 전달하는 데 유용할 수 있습니다.

참고: 기본 로컬은 아래의 locals() 함수에 대해 설명된 대로 작동합니다. 기본 로컬 사전에 대한 수정을 시도해서는 안 됩니다. 함수 exec()가 반환된 후 지역에 대한 코드의 효과를 확인해야 하는 경우 명시적 지역 사전을 전달합니다.

버전 3.11에서 변경: 클로저 매개변수를 추가했습니다.

filter(function, iterable)

함수가 true를 반환하는 iterable의 요소에서 반복자를 생성합니다. iterable은 시퀀스, 반복을 지원하는 컨테이너 또는 반복자일 수 있습니다. function이 None이면 항등 함수가 가정됩니다. 즉, false인 iterable의 모든 요소가 제거됩니다.

filter(function, iterable)은 function이 None이 아니면 (item for iterable if function(item)인 경우 item for iterable if function(item)) 제너레이터 표현식(item for iterable if item)과 동등하고 function이 None이면 (item for iterable if item)과 동일합니다.

function이 false를 반환하는 iterable의 요소를 반환하는 보완 함수는 itertools.filterfalse()를 참조하세요.

class float(x=0.0)

숫자 또는 문자열 x로 구성된 부동 소수점 숫자를 반환합니다.

인수가 문자열인 경우 십진수를 포함해야 하며 선택적으로 부호가 앞에 오고 선택적으로 공백에 포함되어야 합니다. 선택적 기호는 ‘+’ 또는 ‘-‘일 수 있습니다. ‘+’ 기호는 생성된 값에 영향을 주지 않습니다. 인수는 NaN(숫자가 아님) 또는 양수 또는 음수 무한대를 나타내는 문자열일 수도 있습니다. 보다 정확하게는 선행 및 후행 공백 문자가 제거된 후 입력이 다음 문법의 floatvalue 생성 규칙을 준수해야 합니다.

sign        ::=  "+" | "-"
infinity    ::=  "Infinity" | "inf"
nan         ::=  "nan"
digitpart   ::=  digit (["_"] digit)*
number      ::=  [digitpart] "." digitpart | digitpart ["."]
exponent    ::=  ("e" | "E") ["+" | "-"] digitpart
floatnumber ::=  number [exponent]
floatvalue  ::=  [sign] (floatnumber | infinity | nan)

여기서 숫자는 유니코드 십진수(유니코드 일반 범주 Nd의 문자)입니다. 대소문자는 중요하지 않으므로 예를 들어 “inf”, “Inf”, “INFINITY” 및 “iNfINity”는 모두 양의 무한대에 허용되는 철자입니다.

그렇지 않고 인수가 정수이거나 부동 소수점 숫자이면 동일한 값(파이썬의 부동 소수점 정밀도 내)을 가진 부동 소수점 숫자가 반환됩니다. 인수가 Python float의 범위를 벗어나면 OverflowError가 발생합니다.

일반 Python 객체 x의 경우 float(x)는 x.__float__()에 위임합니다. __float__()가 정의되지 않은 경우 __index__()로 돌아갑니다.

인수를 지정하지 않으면 0.0이 반환됩니다.

예:

>>> float('+1.23')
1.23
>>> float('   -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf

float 유형은 숫자 유형 — int, float, complex에 설명되어 있습니다.

버전 3.6에서 변경: 코드 리터럴에서와 같이 밑줄로 숫자를 그룹화하는 것이 허용됩니다.

버전 3.7에서 변경: x는 이제 위치 전용 매개변수입니다.

버전 3.8에서 변경: __float__()가 정의되지 않은 경우 __index__()로 돌아갑니다.

format(value, format_spec=”)

format_spec에 의해 제어되는 대로 값을 “포맷된” 표현으로 변환합니다. format_spec의 해석은 값 인수의 유형에 따라 다릅니다. 그러나 대부분의 기본 제공 유형에서 사용되는 표준 형식 지정 구문인 형식 사양 미니 언어가 있습니다.

기본 format_spec은 일반적으로 str(value)를 호출하는 것과 동일한 효과를 제공하는 빈 문자열입니다.

format(value, format_spec)에 대한 호출은 값의 __format__() 메서드를 검색할 때 인스턴스 사전을 우회하는 type(value).__format__(value, format_spec)으로 변환됩니다. 메서드 검색이 개체에 도달하고 format_spec이 비어 있지 않거나 format_spec 또는 반환 값이 문자열이 아닌 경우 TypeError 예외가 발생합니다.

버전 3.4에서 변경: object().__format__(format_spec)은 format_spec이 빈 문자열이 아니면 TypeError를 발생시킵니다.

class frozenset(iterable=set())

선택적으로 iterable에서 가져온 요소와 함께 새로운 frozenset 객체를 반환합니다. frozenset은 내장 클래스입니다. 이 클래스에 대한 문서는 frozenset 및 집합 유형 — set, frozenset을 참조하세요.

다른 컨테이너의 경우 내장된 set, list, tuple 및 dict 클래스와 collections 모듈을 참조하십시오.

getattr(object, name)
getattr(object, name, default)

객체의 명명된 속성 값을 반환합니다. 이름은 문자열이어야 합니다. 문자열이 객체 속성 중 하나의 이름인 경우 결과는 해당 속성의 값입니다. 예를 들어 getattr(x, ‘foobar’)는 x.foobar와 동일합니다. 명명된 속성이 존재하지 않는 경우 제공된 경우 기본값이 반환되고, 그렇지 않으면 AttributeError가 발생합니다. 이름은 파이썬 식별자일 필요가 없습니다(setattr() 참조).

참고: private name mangling은 컴파일 시간에 발생하므로 getattr()로 검색하려면 개인 속성(앞에 두 개의 밑줄이 있는 속성)의 이름을 수동으로 맹글링해야 합니다.

globals()

현재 모듈 네임스페이스를 구현하는 사전을 반환합니다. 함수 내 코드의 경우 함수가 정의될 때 설정되며 함수가 호출되는 위치에 관계없이 동일하게 유지됩니다.

hasattr(object, name)

인수는 객체와 문자열입니다. 문자열이 객체 속성 중 하나의 이름이면 결과는 True이고 그렇지 않으면 False입니다. (이것은 getattr(object, name)을 호출하고 AttributeError를 발생시키는지 여부를 확인하여 구현됩니다.)

hash(object)

객체의 해시 값을 반환합니다(해시 값이 있는 경우). 해시 값은 정수입니다. 사전 조회 중에 사전 키를 빠르게 비교하는 데 사용됩니다. 같다고 비교되는 숫자 값은 동일한 해시 값을 가집니다(1과 1.0의 경우처럼 유형이 다르더라도).

참고: 사용자 지정 __hash__() 메서드가 있는 객체의 경우 hash()는 호스트 시스템의 비트 너비를 기반으로 반환 값을 자릅니다. 자세한 내용은 __hash__()를 참조하십시오.

help()
help(request)

내장 도움말 시스템을 호출합니다. (이 기능은 대화식으로 사용하기 위한 것입니다.) 인수가 제공되지 않으면 인터프리터 콘솔에서 대화식 도움말 시스템이 시작됩니다. 인수가 문자열인 경우 문자열은 모듈, 함수, 클래스, 메서드, 키워드 또는 설명서 항목의 이름으로 조회되고 도움말 페이지가 콘솔에 인쇄됩니다. 인수가 다른 종류의 개체인 경우 개체에 대한 도움말 페이지가 생성됩니다.

help()를 호출할 때 함수의 매개변수 목록에 슬래시(/)가 나타나면 슬래시 앞의 매개변수가 위치 전용임을 의미합니다. 자세한 내용은 위치 전용 매개변수에 대한 FAQ 항목을 참조하세요.

이 함수는 사이트 모듈에 의해 내장 네임스페이스에 추가됩니다.

버전 3.4에서 변경: pydoc 및 inspect에 대한 변경은 콜러블에 대해 보고된 서명이 이제 더 포괄적이고 일관성이 있음을 의미합니다.

hex(x)

정수를 “0x” 접두사가 붙은 소문자 16진수 문자열로 변환합니다. x가 Python int 객체가 아니면 정수를 반환하는 __index__() 메서드를 정의해야 합니다. 몇 가지 예:

>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'

정수를 접두사가 있거나 없는 대문자 또는 소문자 16진수 문자열로 변환하려면 다음 방법 중 하나를 사용할 수 있습니다.

>>> '%#x' % 255, '%x' % 255, '%X' % 255
('0xff', 'ff', 'FF')
>>> format(255, '#x'), format(255, 'x'), format(255, 'X')
('0xff', 'ff', 'FF')
>>> f'{255:#x}', f'{255:x}', f'{255:X}'
('0xff', 'ff', 'FF')

자세한 내용은 format()을 참조하십시오.

16진법을 사용하여 16진수 문자열을 정수로 변환하려면 int()도 참조하십시오.

참고: float에 대한 16진수 문자열 표현을 얻으려면 float.hex() 메서드를 사용하십시오.

id(object)

객체의 “ID”를 반환합니다. 이것은 수명 동안 이 개체에 대해 고유하고 일정하도록 보장되는 정수입니다. 수명이 겹치지 않는 두 개체는 동일한 id() 값을 가질 수 있습니다.

CPython 구현 세부 정보: 메모리에 있는 개체의 주소입니다.

인수 id로 감사 이벤트 builtins.id를 발생시킵니다.

input()
input(prompt)

프롬프트 인수가 있으면 후행 개행 없이 표준 출력에 기록됩니다. 그런 다음 함수는 입력에서 한 줄을 읽고 문자열로 변환하고(후행 줄 바꿈 제거) 반환합니다. EOF를 읽으면 EOFError가 발생합니다. 예:

>>> s = input('--> ')  
 --> Monty Python's Flying Circus
>>>  s  
 "Monty Python's Flying Circus"

readline 모듈이 로드된 경우 input()은 이를 사용하여 정교한 줄 편집 및 히스토리 기능을 제공합니다.

입력을 읽기 전에 인수 프롬프트로 감사 이벤트 builtins.input을 발생시킵니다.

입력을 성공적으로 읽은 후 결과로 감사 이벤트 builtins.input/result를 발생시킵니다.

class int(x=0)
class int(x, base=10)

숫자 또는 문자열 x로 구성된 정수 객체를 반환하거나 인수가 제공되지 않으면 0을 반환합니다. x가 __int__()를 정의하면 int(x)는 x.__int__()를 반환합니다. x가 __index__()를 정의하면 x.__index__()를 반환합니다. x가 __trunc__()를 정의하면 x.__trunc__()를 반환합니다. 부동 소수점 숫자의 경우 0을 향해 잘립니다.

x가 숫자가 아니거나 base가 주어지면 x는 기수 base의 정수를 나타내는 문자열, 바이트 또는 바이트 배열 인스턴스여야 합니다. 선택적으로 문자열 앞에 + 또는 -(사이에 공백 없음)가 올 수 있고, 선행 0이 있고, 공백으로 둘러싸이고, 숫자 사이에 단일 밑줄이 산재되어 있습니다.

밑이 n인 정수 문자열에는 각각 0에서 n-1까지의 값을 나타내는 숫자가 포함됩니다. 값 0–9는 유니코드 십진수로 나타낼 수 있습니다. 값 10-35는 a에서 z까지(또는 A에서 Z까지)로 나타낼 수 있습니다. 기본 기준은 10입니다. 허용되는 기준은 0과 2–36입니다. Base-2, -8 및 -16 문자열은 코드의 정수 리터럴과 마찬가지로 선택적으로 0b/0B, 0o/0O 또는 0x/0X로 접두사를 붙일 수 있습니다. 밑이 0인 경우 문자열은 코드의 정수 리터럴과 유사한 방식으로 해석됩니다. 실제 밑은 접두사에 의해 결정되는 2, 8, 10 또는 16입니다. 기본 0은 선행 0도 허용하지 않습니다. int(‘010’, 0)은 올바르지 않은 반면 int(‘010’) 및 int(‘010’, 8)은 올바르습니다.

정수 유형은 숫자 유형 — int, float, complex에 설명되어 있습니다.

버전 3.4에서 변경: base가 int의 인스턴스가 아니고 기본 객체에 base.__index__ 메서드가 있는 경우, 해당 메서드는 기본에 대한 정수를 얻기 위해 호출됩니다. 이전 버전에서는 base.__index__ 대신 base.__int__를 사용했습니다.

버전 3.6에서 변경: 코드 리터럴에서와 같이 밑줄로 숫자를 그룹화하는 것이 허용됩니다.

버전 3.7에서 변경: x는 이제 위치 전용 매개변수입니다.

버전 3.8에서 변경: __int__()가 정의되지 않은 경우 __index__()로 돌아갑니다.

버전 3.11에서 변경: __trunc__()에 대한 위임은 더 이상 사용되지 않습니다.

버전 3.11에서 변경: 서비스 거부 공격을 방지하기 위해 int 문자열 입력 및 문자열 표현을 제한할 수 있습니다. 문자열 x를 int로 변환하는 동안 제한을 초과하거나 int를 문자열로 변환하는 것이 제한을 초과하면 ValueError가 발생합니다. integer string conversion length limitation문서를 참조하십시오.

isinstance(object, classinfo)¶

객체 인수가 classinfo 인수의 인스턴스이거나 그 (직접, 간접 또는 가상) 하위 클래스의 인스턴스이면 True를 반환합니다. object가 주어진 유형의 객체가 아닌 경우 함수는 항상 False를 반환합니다. classinfo가 유형 객체의 튜플(또는 재귀적으로 다른 튜플)이거나 여러 유형의 공용체 유형인 경우 객체가 유형의 인스턴스이면 True를 반환합니다. classinfo가 유형이나 유형의 튜플 및 그러한 튜플이 아닌 경우 TypeError 예외가 발생합니다. 이전 검사가 성공하면 잘못된 유형에 대해 TypeError가 발생하지 않을 수 있습니다.

버전 3.10에서 변경: classinfo는 Union Type이 될 수 있습니다.

issubclass(class, classinfo)

클래스가 classinfo의 하위 클래스(직접, 간접 또는 가상)이면 True를 반환합니다. 클래스는 자신의 하위 클래스로 간주됩니다. classinfo는 클래스 객체의 튜플(또는 재귀적으로 다른 튜플)이거나 Union Type일 수 있으며, 이 경우 class가 classinfo에 있는 항목의 하위 클래스이면 True를 반환합니다. 다른 경우에는 TypeError 예외가 발생합니다.

버전 3.10에서 변경: classinfo는 Union Type이 될 수 있습니다.

iter(object)
iter(object, sentinel)

반복자 객체를 반환합니다. 첫 번째 인수는 두 번째 인수의 존재 여부에 따라 매우 다르게 해석됩니다. 두 번째 인수가 없으면 object는 반복 가능한 프로토콜( __iter__() 메서드)을 지원하는 컬렉션 객체이거나 시퀀스 프로토콜(0에서 시작하는 정수 인수를 사용하는 __getitem__() 메서드)을 지원해야 합니다. 이러한 프로토콜 중 하나를 지원하지 않으면 TypeError가 발생합니다. 두 번째 인수 sentinel이 제공되면 object는 콜러블 객체여야 합니다. 이 경우에 생성된 이터레이터는 __next__() 메서드에 대한 각 호출에 대해 인수 없이 객체를 호출합니다; 반환된 값이 sentinel과 같으면 StopIteration이 발생하고 그렇지 않으면 값이 반환됩니다.

Iterator Types도 참조하십시오.

iter()의 두 번째 형식의 유용한 응용 프로그램 중 하나는 블록 판독기를 빌드하는 것입니다. 예를 들어 파일 끝에 도달할 때까지 이진 데이터베이스 파일에서 고정 너비 블록을 읽는 경우:

from functools import partial
with open('mydata.db', 'rb') as f:
    for block in iter(partial(f.read, 64), b''):
        process_block(block)

len(s)

객체의 길이(항목 수)를 반환합니다. 인수는 시퀀스(예: 문자열, 바이트, 튜플, 목록 또는 범위) 또는 컬렉션(예: 사전, 집합 또는 고정 집합)일 수 있습니다.

CPython 구현 세부 사항: len은 범위(2 ** 100)와 같이 sys.maxsize보다 긴 길이에서 OverflowError를 발생시킵니다.

class list
class list(iterable)

목록은 함수가 아니라 목록 및 시퀀스 유형 — 목록, 튜플, 범위에 설명된 대로 실제로 변경 가능한 시퀀스 유형입니다.

locals()

현재 로컬 심볼 테이블을 나타내는 사전을 업데이트하고 반환합니다. 자유 변수는 함수 블록에서 호출될 때 locals()에 의해 반환되지만 클래스 블록에서는 반환되지 않습니다. 모듈 수준에서 locals() 및 globals()는 동일한 사전입니다.

참고: 이 사전의 내용은 수정하면 안 됩니다. 변경 사항은 인터프리터가 사용하는 지역 및 자유 변수의 값에 영향을 미치지 않을 수 있습니다.

map(function, iterable, *iterables)

iterable의 모든 항목에 함수를 적용하여 결과를 산출하는 반복자를 반환합니다. 추가 iterables 인수가 전달되면 function은 많은 인수를 가져와야 하며 모든 iterables의 항목에 병렬로 적용됩니다. 반복 가능한 항목이 여러 개인 경우 가장 짧은 반복 가능한 항목이 소진되면 반복자가 중지됩니다. 함수 입력이 이미 인수 튜플로 배열된 경우 itertools.starmap()을 참조하세요.

max(iterable, , key=None)
max(iterable, , default, key=None)
max(arg1, arg2, *args, key=None)

iterable에서 가장 큰 항목 또는 두 개 이상의 인수 중 가장 큰 항목을 반환합니다.

하나의 위치 인수가 제공되면 iterable이어야 합니다. iterable에서 가장 큰 항목이 반환됩니다. 두 개 이상의 위치 인수가 제공되면 위치 인수 중 가장 큰 것이 반환됩니다.

두 가지 선택적인 키워드 전용 인수가 있습니다. key 인수는 list.sort()에 사용되는 것과 같은 단일 인수 순서 지정 함수를 지정합니다. 기본 인수는 제공된 iterable이 비어 있는 경우 반환할 객체를 지정합니다. iterable이 비어 있고 기본값이 제공되지 않으면 ValueError가 발생합니다.

여러 항목이 최대인 경우 함수는 처음 발견된 항목을 반환합니다. 이는 sorted(iterable, key=keyfunc, reverse=True)[0] 및 heapq.nlargest(1, iterable, key=keyfunc)와 같은 다른 정렬 안정성 보존 도구와 일치합니다.

버전 3.4의 새로운 기능: 기본 키워드 전용 인수입니다.

버전 3.8에서 변경: 키는 None이 될 수 있습니다.

class memoryview(object)

주어진 인자로 생성된 “메모리 뷰” 객체를 반환합니다. 자세한 내용은 메모리 보기를 참조하세요.

min(iterable, , key=None)
min(iterable, , default, key=None)
min(arg1, arg2, *args, key=None)

iterable에서 가장 작은 항목 또는 두 개 이상의 인수 중 가장 작은 항목을 반환합니다.

하나의 위치 인수가 제공되면 iterable이어야 합니다. iterable에서 가장 작은 항목이 반환됩니다. 두 개 이상의 위치 인수가 제공된 경우 가장 작은 위치 인수가 반환됩니다.

여러 항목이 최소인 경우 함수는 처음 발견된 항목을 반환합니다. 이는 sorted(iterable, key=keyfunc)[0] 및 heapq.nsmallest(1, iterable, key=keyfunc)와 같은 다른 정렬 안정성 보존 도구와 일치합니다.

버전 3.4의 새로운 기능: 기본 키워드 전용 인수입니다.

버전 3.8에서 변경: 키는 None이 될 수 있습니다.

next(iterator)
next(iterator, default)

__next__() 메서드를 호출하여 반복자에서 다음 항목을 검색합니다. 기본값이 주어지면 반복자가 소진되면 반환되고, 그렇지 않으면 StopIteration이 발생합니다.

class object

특징이 없는 새로운 객체를 반환합니다. object는 모든 클래스의 기반입니다. 여기에는 Python 클래스의 모든 인스턴스에 공통적인 메서드가 있습니다. 이 함수는 인수를 허용하지 않습니다.

참고: 개체에는 __dict__가 없으므로 개체 클래스의 인스턴스에 임의의 특성을 할당할 수 없습니다.

oct(x)

정수를 접두사 “0o”가 붙은 8진수 문자열로 변환합니다. 결과는 유효한 Python 표현식입니다. x가 Python int 객체가 아니면 정수를 반환하는 __index__() 메서드를 정의해야 합니다. 예를 들어:

>>> oct(8)
'0o10'
>>> oct(-56)
'-0o70'

정수를 접두사 “0o”를 사용하거나 사용하지 않고 8진수 문자열로 변환하려면 다음 방법 중 하나를 사용할 수 있습니다.

>>> '%#o' % 10, '%o' % 10
('0o12', '12')
>>> format(10, '#o'), format(10, 'o')
('0o12', '12')
>>> f'{10:#o}', f'{10:o}'
('0o12', '12')

자세한 내용은 format()도 참조하십시오.

open(file, mode=’r’, buffering=- 1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

파일을 열고 해당 파일 객체를 반환합니다. 파일을 열 수 없으면 OSError가 발생합니다. 이 기능을 사용하는 방법에 대한 더 많은 예제는 파일 읽기 및 쓰기를 참조하십시오.

file은 열 파일의 경로 이름(절대 또는 현재 작업 디렉터리에 대한 상대) 또는 래핑할 파일의 정수 파일 설명자를 제공하는 경로류 객체입니다. (파일 디스크립터가 주어지면 closefd가 False로 설정되지 않는 한 반환된 I/O 객체가 닫힐 때 파일 디스크립터가 닫힙니다.)

mode는 파일이 열리는 모드를 지정하는 선택적 문자열입니다. 기본적으로 ‘r’은 텍스트 모드에서 읽기 위해 열기를 의미합니다. 다른 일반적인 값은 쓰기(파일이 이미 있는 경우 파일 자르기)를 위한 ‘w’, 단독 생성을 위한 ‘x’, 추가를 위한 ‘a'(일부 Unix 시스템에서는 모든 쓰기가 파일 끝에 추가됨을 의미함)입니다. 현재 검색 위치에 관계없이). 텍스트 모드에서 인코딩이 지정되지 않은 경우 사용되는 인코딩은 플랫폼에 따라 다릅니다. 현재 로케일 인코딩을 가져오기 위해 locale.getencoding()이 호출됩니다. (원시 바이트를 읽고 쓰기 위해 이진 모드를 사용하고 인코딩을 지정하지 않은 상태로 둡니다.) 사용 가능한 모드는 다음과 같습니다.

Character	Meaning
`'r'`	읽기용으로 열기(기본값)
`'w'`	쓰기 위해 열기, 먼저 파일 자르기
`'x'`	독점 생성을 위해 열기, 파일이 이미 존재하는 경우 실패
`'a'`	쓰기용으로 열기, 파일이 있으면 파일 끝에 추가
`'b'`	바이너리 모드
`'t'`	텍스트 모드(기본값)
`'+'`	업데이트를 위해 열려 있음(읽기 및 쓰기)

기본 모드는 ‘r’입니다(텍스트 읽기용으로 열림, ‘rt’의 동의어). 모드 ‘w+’ 및 ‘w+b’는 파일을 열고 자릅니다. 모드 ‘r+’ 및 ‘r+b’는 잘림 없이 파일을 엽니다.

개요에서 언급했듯이 Python은 이진 I/O와 텍스트 I/O를 구분합니다. 바이너리 모드에서 열린 파일(mode 인수에 ‘b’ 포함)은 디코딩 없이 콘텐츠를 바이트열 객체로 반환합니다. 텍스트 모드(기본값 또는 mode 인수에 ‘t’가 포함된 경우)에서 파일의 내용은 str로 반환되며 바이트는 플랫폼 종속 인코딩을 사용하거나 주어진 경우 지정된 인코딩을 사용하여 먼저 디코딩되었습니다.

참고: Python은 기본 운영 체제의 텍스트 파일 개념에 의존하지 않습니다. 모든 처리는 Python 자체에서 수행되므로 플랫폼 독립적입니다.

buffering은 버퍼링 정책을 설정하는 데 사용되는 선택적 정수입니다. 버퍼링을 끄려면 0을 전달하고(바이너리 모드에서만 허용됨) 라인 버퍼링을 선택하려면 1을 전달하고(텍스트 모드에서만 사용 가능) 정수 > 1을 전달하여 고정 크기 청크 버퍼의 크기를 바이트 단위로 나타냅니다. 이 방법으로 버퍼 크기를 지정하는 것은 바이너리 버퍼 I/O에 적용되지만 TextIOWrapper(즉, mode=’r+’로 열린 파일)에는 또 다른 버퍼링이 있습니다. TextIOWrapper에서 버퍼링을 비활성화하려면 io.TextIOWrapper.reconfigure()에 대한 write_through 플래그 사용을 고려하십시오. 버퍼링 인수가 지정되지 않은 경우 기본 버퍼링 정책은 다음과 같이 작동합니다.

바이너리 파일은 고정 크기 청크로 버퍼링됩니다. 버퍼의 크기는 기본 장치의 “블록 크기”를 결정하고 io.DEFAULT_BUFFER_SIZE로 폴백하는 휴리스틱을 사용하여 선택됩니다. 많은 시스템에서 버퍼는 일반적으로 4096 또는 8192바이트 길이입니다.
“대화형” 텍스트 파일(isatty()가 True를 반환하는 파일)은 라인 버퍼링을 사용합니다. 다른 텍스트 파일은 이진 파일에 대해 위에서 설명한 정책을 사용합니다.

encoding은 파일을 디코딩하거나 인코딩하는 데 사용되는 인코딩의 이름입니다. 텍스트 모드에서만 사용해야 합니다. 기본 인코딩은 플랫폼에 따라 다르지만(locale.getencoding()이 반환하는 모든 항목) Python에서 지원하는 모든 텍스트 인코딩을 사용할 수 있습니다. 지원되는 인코딩 목록은 코덱 모듈을 참조하십시오.

errors는 인코딩 및 디코딩 오류를 처리하는 방법을 지정하는 선택적 문자열입니다. 바이너리 모드에서는 사용할 수 없습니다. codecs.register_error()로 등록된 모든 오류 처리 이름도 유효하지만 다양한 표준 오류 처리기를 사용할 수 있습니다(오류 처리기 아래에 나열됨). 표준 이름에는 다음이 포함됩니다.

인코딩 오류가 있는 경우 ValueError 예외를 발생시키려면 ‘strict’입니다. 기본값 없음은 동일한 효과를 가집니다.
‘무시’는 오류를 무시합니다. 인코딩 오류를 무시하면 데이터가 손실될 수 있습니다.
‘replace’는 형식이 잘못된 데이터가 있는 위치에 대체 마커(예: ‘?’)가 삽입되도록 합니다.
‘surrogateescape’는 잘못된 바이트를 U+DC80에서 U+DCFF까지의 하위 대리 코드 단위로 나타냅니다. 그런 다음 데이터를 쓸 때 surrogateescape 오류 처리기가 사용될 때 이러한 대리 코드 단위는 동일한 바이트로 다시 전환됩니다. 이는 알 수 없는 인코딩으로 파일을 처리하는 데 유용합니다.
‘xmlcharrefreplace’는 파일에 쓸 때만 지원됩니다. 인코딩에서 지원하지 않는 문자는 적절한 XML 문자 참조 &#nnn;으로 대체됩니다.
‘backslashreplace’는 형식이 잘못된 데이터를 Python의 백슬래시 이스케이프 시퀀스로 바꿉니다.
‘namereplace'(작성할 때만 지원됨)는 지원되지 않는 문자를 \N{…} 이스케이프 시퀀스로 바꿉니다.

newline은 스트림에서 줄 바꿈 문자를 구문 분석하는 방법을 결정합니다. 없음, ”, ‘\n’, ‘\r’ 및 ‘\r\n’일 수 있습니다. 다음과 같이 작동합니다.

스트림에서 입력을 읽을 때 newline이 None이면 범용 newlines 모드가 활성화됩니다. 입력의 라인은 ‘\n’, ‘\r’ 또는 ‘\r\n’으로 끝날 수 있으며 호출자에게 반환되기 전에 ‘\n’으로 변환됩니다. ”이면 범용 개행 모드가 활성화되지만 줄 끝이 번역되지 않은 상태로 호출자에게 반환됩니다. 다른 유효한 값이 있는 경우 입력 줄은 지정된 문자열에 의해서만 종료되며 줄 끝은 번역되지 않은 상태로 호출자에게 반환됩니다.
스트림에 출력을 쓸 때 newline이 None이면 작성된 모든 ‘\n’ 문자는 시스템 기본 줄 구분 기호인 os.linesep로 변환됩니다. newline이 ” 또는 ‘\n’이면 변환이 수행되지 않습니다. 줄 바꿈이 다른 유효한 값 중 하나인 경우 작성된 모든 ‘\n’ 문자는 지정된 문자열로 변환됩니다.

closefd가 False이고 파일 이름이 아닌 파일 설명자가 제공된 경우 파일이 닫힐 때 기본 파일 설명자가 열린 상태로 유지됩니다. 파일 이름이 주어지면 closefd는 True여야 합니다(기본값). 그렇지 않으면 오류가 발생합니다.

콜러블을 오프너로 전달하여 사용자 지정 오프너를 사용할 수 있습니다. 그런 다음 (file, flags)를 사용하여 opener를 호출하여 파일 개체에 대한 기본 파일 설명자를 얻습니다. opener는 열린 파일 디스크립터를 반환해야 합니다(os.open을 opener로 전달하면 None을 전달하는 것과 유사한 기능이 생성됨).

새로 만든 파일은 상속할 수 없습니다.

다음 예제에서는 os.open() 함수의 dir_fd 매개변수를 사용하여 지정된 디렉토리에 상대적인 파일을 엽니다.

>>> import os
>>> dir_fd = os.open('somedir', os.O_RDONLY)
>>> def opener(path, flags):
...     return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('spamspam.txt', 'w', opener=opener) as f:
...     print('This will be written to somedir/spamspam.txt', file=f)
... 
>>> os.close(dir_fd)  # don't leak a file descriptor

open() 함수가 반환하는 파일 객체의 유형은 모드에 따라 다릅니다. open()이 텍스트 모드(‘w’, ‘r’, ‘wt’, ‘rt’ 등)에서 파일을 여는 데 사용되면 io.TextIOBase(특히 io.TextIOWrapper)의 하위 클래스를 반환합니다. 버퍼링이 있는 바이너리 모드에서 파일을 여는 데 사용되는 경우 반환되는 클래스는 io.BufferedIOBase의 하위 클래스입니다. 정확한 클래스는 다양합니다. 읽기 바이너리 모드에서는 io.BufferedReader를 반환합니다. 쓰기 바이너리 및 추가 바이너리 모드에서는 io.BufferedWriter를 반환하고 읽기/쓰기 모드에서는 io.BufferedRandom을 반환합니다. 버퍼링이 비활성화되면 io.RawIOBase, io.FileIO의 하위 클래스인 원시 스트림이 반환됩니다.

fileinput, io(open()이 선언된 경우), os, os.path, tempfile 및 shutil과 같은 파일 처리 모듈도 참조하십시오.

파일, 모드, 플래그 인수를 사용하여 열린 감사 이벤트를 발생시킵니다.

mode 및 flags 인수는 수정되었거나 원래 호출에서 유추되었을 수 있습니다.

버전 3.3에서 변경:

오프너 매개변수가 추가되었습니다.
‘x’ 모드가 추가되었습니다.
IOError가 발생했지만 이제는 OSError의 별칭입니다.
독점 생성 모드(‘x’)에서 열린 파일이 이미 존재하는 경우 FileExistsError가 발생합니다.

버전 3.4에서 변경:

이제 파일을 상속할 수 없습니다.

버전 3.5에서 변경:

시스템 호출이 중단되고 신호 처리기가 예외를 발생시키지 않으면 함수는 이제 InterruptedError 예외를 발생시키는 대신 시스템 호출을 재시도합니다(이유는 PEP 475 참조).
‘namereplace’ 오류 처리기가 추가되었습니다.

버전 3.6에서 변경:

os.PathLike를 구현하는 개체를 허용하도록 지원이 추가되었습니다.
Windows에서 콘솔 버퍼를 열면 io.FileIO가 아닌 io.RawIOBase의 하위 클래스가 반환될 수 있습니다.

버전 3.11에서 변경: ‘U’ 모드가 제거되었습니다.

ord(c)

하나의 유니코드 문자를 나타내는 문자열이 주어지면 해당 문자의 유니코드 코드 포인트를 나타내는 정수를 반환합니다. 예를 들어, ord(‘a’)는 정수 97을 반환하고 ord(‘€’)(유로 기호)는 8364를 반환합니다. 이것은 chr()의 반대입니다.

pow(base, exp, mod=None)

기지를 전력 특급으로 되돌립니다. mod가 있으면 base를 power exp, modulo mod로 반환합니다(pow(base, exp) % mod보다 더 효율적으로 계산됨). 인수가 두 개인 형식 pow(base, exp)는 거듭제곱 연산자 base**exp를 사용하는 것과 같습니다.

인수에는 숫자 유형이 있어야 합니다. 혼합 피연산자 유형을 사용하면 이진 산술 연산자에 대한 강제 규칙이 적용됩니다. int 피연산자의 경우 결과는 두 번째 인수가 음수가 아닌 한 (강제 변환 후) 피연산자와 동일한 유형을 가집니다. 이 경우 모든 인수가 float로 변환되고 float 결과가 전달됩니다. 예를 들어 pow(10, 2)는 100을 반환하지만 pow(10, -2)는 0.01을 반환합니다. int 또는 float 유형의 음수 밑과 정수가 아닌 지수의 경우 복잡한 결과가 전달됩니다. 예를 들어 pow(-9, 0.5)는 3j에 가까운 값을 반환합니다.

int 피연산자 base 및 exp의 경우 mod가 있으면 mod도 정수 유형이어야 하고 mod는 0이 아니어야 합니다. mod가 있고 exp가 음수이면 base는 mod에 상대적으로 소수여야 합니다. 이 경우 pow(inv_base, -exp, mod)가 반환되며 여기서 inv_base는 base modulo mod의 반대입니다.

다음은 38 모듈로 97의 역수를 계산하는 예입니다.

>>> pow(38, -1, mod=97)
23
>>> 23 * 38 % 97 == 1
True

버전 3.8에서 변경: int 피연산자의 경우, pow의 3개 인수 형식은 이제 두 번째 인수가 음수가 되도록 허용하여 모듈러 역의 계산을 허용합니다.

버전 3.8에서 변경: 키워드 인수를 허용합니다. 이전에는 위치 인수만 지원되었습니다.

print(objects, sep=’ ‘, end=’\n’, file=None, flush=False*)

객체를 sep로 구분하고 end로 구분하여 텍스트 스트림 파일에 인쇄합니다. sep, end, file 및 flush(존재하는 경우)는 키워드 인수로 제공되어야 합니다.

키워드가 아닌 모든 인수는 str()과 같은 문자열로 변환되고 스트림에 기록되며 sep로 구분되고 뒤에 end가 옵니다. sep와 end는 모두 문자열이어야 합니다. 기본값을 사용한다는 의미인 None일 수도 있습니다. 객체가 주어지지 않으면 print()는 end를 씁니다.

file 인수는 write(string) 메서드가 있는 객체여야 합니다. 존재하지 않거나 None이면 sys.stdout이 사용됩니다. 인쇄된 인수는 텍스트 문자열로 변환되기 때문에 print()는 바이너리 모드 파일 객체와 함께 사용할 수 없습니다. 이를 위해 file.write(…)를 대신 사용하십시오.

출력이 버퍼링되는지 여부는 일반적으로 파일에 의해 결정되지만 flush 키워드 인수가 true이면 스트림이 강제로 플러시됩니다.

버전 3.3에서 변경: flush 키워드 인수를 추가했습니다.

class property(fget=None, fset=None, fdel=None, doc=None)

속성 속성을 반환합니다.

fget은 속성 값을 가져오는 함수입니다. fset은 속성 값을 설정하는 기능입니다. fdel은 속성 값을 삭제하는 함수입니다. 그리고 doc는 속성에 대한 docstring을 생성합니다.

일반적인 용도는 관리 속성 x를 정의하는 것입니다.

class C:
    def __init__(self):
        self._x = None

    def getx(self):
        return self._x

    def setx(self, value):
        self._x = value

    def delx(self):
        del self._x

    x = property(getx, setx, delx, "I'm the 'x' property.")

c가 C의 인스턴스이면 c.x는 getter를 호출하고 c.x = value는 setter를 호출하고 del c.x는 deleter를 호출합니다.

주어진 경우, doc는 속성 속성의 docstring이 됩니다. 그렇지 않으면 속성이 fget의 docstring(존재하는 경우)을 복사합니다. 따라서 property()를 데코레이터로 사용하여 읽기 전용 속성을 쉽게 만들 수 있습니다.

class Parrot:
    def __init__(self):
        self._voltage = 100000

    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage

@property 데코레이터는 voltage() 메서드를 같은 이름의 읽기 전용 속성에 대한 “getter”로 바꾸고 전압에 대한 독스트링을 “Get the current voltage”로 설정합니다.

속성 개체에는 장식된 함수로 설정된 해당 액세서 함수를 사용하여 속성의 복사본을 만드는 데코레이터로 사용할 수 있는 getter, setter 및 deleter 메서드가 있습니다. 예를 들면 다음과 같이 가장 잘 설명됩니다.

class C:
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

이 코드는 첫 번째 예제와 정확히 동일합니다. 추가 기능에 원래 속성과 동일한 이름을 지정해야 합니다(이 경우 x).

반환된 속성 개체에는 생성자 인수에 해당하는 속성 fget, fset 및 fdel도 있습니다.

버전 3.5에서 변경: 속성 객체의 독스트링은 이제 쓰기 가능합니다.

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

범위는 함수라기보다 범위 및 시퀀스 유형 — 목록, 튜플, 범위에 설명된 대로 실제로는 변경할 수 없는 시퀀스 유형입니다.

repr(object)

객체의 인쇄 가능한 표현을 포함하는 문자열을 반환합니다. 많은 유형의 경우 이 함수는 eval()에 전달될 때 동일한 값을 가진 객체를 생성하는 문자열을 반환하려고 시도합니다. 그렇지 않은 경우 표현은 종종 개체의 이름과 주소를 포함하는 추가 정보와 함께 개체 유형의 이름을 포함하는 꺾쇠 괄호로 묶인 문자열입니다. 클래스는 __repr__() 메서드를 정의하여 이 함수가 인스턴스에 대해 반환하는 것을 제어할 수 있습니다. sys.displayhook()에 액세스할 수 없는 경우 이 함수는 RuntimeError를 발생시킵니다.

reversed(seq)

역 반복자를 반환합니다. seq는 __reversed__() 메서드가 있거나 시퀀스 프로토콜(0에서 시작하는 정수 인수를 사용하는 __len__() 메서드 및 __getitem__() 메서드)을 지원하는 객체여야 합니다.

round(number, ndigits=None)

소수점 이하 ndigits 정밀도로 반올림된 숫자를 반환합니다. ndigits가 생략되거나 None이면 입력에 가장 가까운 정수를 반환합니다.

round()를 지원하는 기본 제공 유형의 경우 값은 10의 제곱에서 n자리를 뺀 가장 가까운 배수로 반올림됩니다. 두 배수가 똑같이 가까우면 짝수 선택 쪽으로 반올림됩니다(예를 들어 round(0.5)와 round(-0.5)는 모두 0이고 round(1.5)는 2입니다). 모든 정수 값은 ndigits(양수, 0 또는 음수)에 대해 유효합니다. 반환 값은 ndigits가 생략되거나 None인 경우 정수입니다. 그렇지 않으면 반환 값은 숫자와 동일한 유형입니다.

일반 Python 객체 번호의 경우 대리자를 number.__round__로 반올림합니다.

참고: float에 대한 round()의 동작은 놀랄 수 있습니다. 예를 들어 round(2.675, 2)는 예상되는 2.68 대신 2.67을 제공합니다. 이것은 버그가 아닙니다. 대부분의 소수점 이하 자릿수를 실수로 정확히 표현할 수 없기 때문입니다. 자세한 내용은 부동 소수점 산술: 문제 및 제한 사항을 참조하십시오.

class set
class set(iterable)

선택적으로 iterable에서 가져온 요소와 함께 새로운 집합 객체를 반환합니다. set은 내장 클래스입니다. 이 클래스에 대한 문서는 set 및 Set Types — set, frozenset을 참조하십시오.

다른 컨테이너의 경우 내장 frozenset, list, tuple 및 dict 클래스와 collections 모듈을 참조하세요.

setattr(object, name, value)

이것은 getattr()의 대응물입니다. 인수는 객체, 문자열 및 임의의 값입니다. 문자열은 기존 속성 또는 새 속성의 이름을 지정할 수 있습니다. 객체가 허용하는 경우 함수는 속성에 값을 할당합니다. 예를 들어 setattr(x, ‘foobar’, 123)은 x.foobar = 123과 동일합니다.

예를 들어 사용자 지정 __getattribute__()에서 또는 __slots__를 통해 객체가 이를 적용하도록 선택하지 않는 한 이름은 식별자 및 키워드에 정의된 Python 식별자일 필요가 없습니다. 이름이 식별자가 아닌 속성은 점 표기법을 사용하여 액세스할 수 없지만 getattr() 등을 통해 액세스할 수 있습니다.

참고 개인 이름 맹글링은 컴파일 시간에 발생하므로 setattr()로 설정하려면 개인 속성(앞에 두 개의 밑줄이 있는 속성) 이름을 수동으로 맹글링해야 합니다.

class slice(stop)
class slice(start, stop, step=1)

범위(시작, 중지, 단계)로 지정된 인덱스 집합을 나타내는 슬라이스 객체를 반환합니다. 시작 및 단계 인수의 기본값은 없음입니다. 슬라이스 개체에는 인수 값(또는 해당 기본값)만 반환하는 읽기 전용 데이터 속성인 start, stop 및 step이 있습니다. 다른 명시적인 기능은 없습니다. 그러나 NumPy 및 기타 타사 패키지에서 사용됩니다. 슬라이스 객체는 확장 인덱싱 구문을 사용할 때도 생성됩니다. 예: a[시작:중지:단계] 또는 a[시작:중지, i]. 반복자를 반환하는 대체 버전은 itertools.islice()를 참조하세요.

sorted(iterable, /, , key=None, reverse=False*)

iterable의 항목에서 새로 정렬된 목록을 반환합니다.

키워드 인수로 지정해야 하는 두 개의 선택적 인수가 있습니다.

key는 iterable의 각 요소에서 비교 키를 추출하는 데 사용되는 하나의 인수 함수를 지정합니다(예: key=str.lower). 기본값은 없음입니다(요소를 직접 비교).

반전은 부울 값입니다. True로 설정하면 각 비교가 반대인 것처럼 목록 요소가 정렬됩니다.

functools.cmp_to_key()를 사용하여 구식 cmp 함수를 키 함수로 변환합니다.

내장된 sorted() 함수는 안정적임을 보장합니다. 동등하다고 비교되는 요소의 상대적인 순서를 변경하지 않는 경우 정렬이 안정적입니다. 이는 여러 단계에서 정렬하는 데 유용합니다(예: 부서별로 정렬한 다음 급여 등급별로 정렬).

정렬 알고리즘은 항목 간의 < 비교만 사용합니다. __lt__() 메서드를 정의하면 정렬에 충분하지만 PEP 8은 6가지 rich comparisons를 모두 구현할 것을 권장합니다. 이렇게 하면 다른 기본 메서드에 의존하는 max()와 같은 다른 주문 도구와 동일한 데이터를 사용할 때 버그를 방지하는 데 도움이 됩니다. 여섯 가지 비교를 모두 구현하면 반영된 __gt__() 메서드를 호출할 수 있는 혼합 유형 비교에 대한 혼동을 피하는 데도 도움이 됩니다.

정렬 예제와 간단한 정렬 튜토리얼은 Sorting HOW TO를 참조하십시오.

@staticmethod

메서드를 정적 메서드로 변환합니다.

정적 메서드는 암시적 첫 번째 인수를 받지 않습니다. 정적 메소드를 선언하려면 이 관용구를 사용하십시오“`

class C:
    @staticmethod
    def f(arg1, arg2, ...): ...

@staticmethod 형식은 함수 데코레이터입니다. 자세한 내용은 함수 정의를 참조하세요.

정적 메서드는 클래스(예: C.f()) 또는 인스턴스(예: C().f())에서 호출할 수 있습니다. 또한 일반 함수(예: f())로 호출할 수 있습니다.

Python의 정적 메서드는 Java 또는 C++의 메서드와 유사합니다. 또한 대체 클래스 생성자를 만드는 데 유용한 변형에 대해서는 classmethod()를 참조하십시오.

모든 데코레이터와 마찬가지로 staticmethod를 일반 함수로 호출하고 그 결과로 무언가를 수행하는 것도 가능합니다. 이는 클래스 본문에서 함수에 대한 참조가 필요하고 인스턴스 메서드로의 자동 변환을 피하려는 경우에 필요합니다. 이러한 경우 다음 관용구를 사용하십시오.

def regular_function():
    ...

class C:
    method = staticmethod(regular_function)

정적 메서드에 대한 자세한 내용은 표준 형식 계층을 참조하세요.

버전 3.10에서 변경: 정적 메서드는 이제 메서드 속성(__module__, __name__, __qualname__, __doc__ 및 __annotations__)을 상속하고 새로운 __wrapped__ 속성을 가지며 이제 일반 함수로 호출할 수 있습니다.

class str(object=”)
class str(object=b”, encoding=’utf-8′, errors=’strict’)

객체의 str 버전을 반환합니다. 자세한 내용은 str()을 참조하십시오.

str은 내장 문자열 클래스입니다. 문자열에 대한 일반 정보는 텍스트 시퀀스 유형 — str을 참조하십시오.

sum(iterable, /, start=0)

합계는 왼쪽에서 오른쪽으로 iterable의 항목을 시작하고 합계를 반환합니다. iterable의 항목은 일반적으로 숫자이며 시작 값은 문자열이 될 수 없습니다.

일부 사용 사례의 경우 sum()에 대한 좋은 대안이 있습니다. 문자열 시퀀스를 연결하는 선호되는 빠른 방법은 ”.join(sequence)를 호출하는 것입니다. 확장된 정밀도로 부동 소수점 값을 추가하려면 math.fsum()을 참조하십시오. 일련의 iterable을 연결하려면 itertools.chain() 사용을 고려하십시오.

버전 3.8에서 변경: 시작 매개변수는 키워드 인수로 지정할 수 있습니다.

class super
class super(type, object_or_type=None)

메소드 호출을 유형의 부모 또는 형제 클래스에 위임하는 프록시 객체를 반환합니다. 이는 클래스에서 재정의된 상속된 메서드에 액세스하는 데 유용합니다.

object_or_type은 검색할 메서드 해결 순서를 결정합니다. 유형 바로 뒤에 있는 클래스부터 검색이 시작됩니다.

예를 들어 object_or_type의 __mro__가 D -> B -> C -> A -> object이고 type의 값이 B이면 super()는 C -> A -> object를 찾습니다.

object_or_type의 __mro__ 속성은 getattr() 및 super() 모두에서 사용되는 메서드 확인 검색 순서를 나열합니다. 속성은 동적이며 상속 계층 구조가 업데이트될 때마다 변경될 수 있습니다.

두 번째 인수가 생략되면 반환되는 슈퍼 개체는 바인딩되지 않습니다. 두 번째 인수가 객체이면 isinstance(obj, type)이 true여야 합니다. 두 번째 인수가 유형인 경우 issubclass(type2, type)은 true여야 합니다(클래스 메서드에 유용함).

슈퍼에는 두 가지 일반적인 사용 사례가 있습니다. 단일 상속이 있는 클래스 계층 구조에서 명시적으로 이름을 지정하지 않고 상위 클래스를 참조하는 데 super를 사용할 수 있으므로 코드를 보다 유지 관리하기 쉽게 만들 수 있습니다. 이 사용은 다른 프로그래밍 언어의 super 사용과 매우 유사합니다.

두 번째 사용 사례는 동적 실행 환경에서 협력적 다중 상속을 지원하는 것입니다. 이 사용 사례는 Python에 고유하며 정적으로 컴파일된 언어 또는 단일 상속만 지원하는 언어에서는 찾을 수 없습니다. 이를 통해 여러 기본 클래스가 동일한 메서드를 구현하는 “다이아몬드 다이어그램”을 구현할 수 있습니다. 좋은 설계는 그러한 구현이 모든 경우에 동일한 호출 서명을 갖도록 지시합니다(호출 순서는 런타임에 결정되기 때문에, 해당 순서는 클래스 계층 구조의 변경 사항에 적응하고 해당 순서에는 런타임 전에 알려지지 않은 형제 클래스가 포함될 수 있기 때문입니다. ).

두 사용 사례 모두에서 일반적인 슈퍼클래스 호출은 다음과 같습니다.

class C(B):
    def method(self, arg):
        super().method(arg)    # This does the same thing as:
                               # super(C, self).method(arg)

메소드 조회 외에도 super()는 속성 조회에도 작동합니다. 이에 대한 한 가지 가능한 사용 사례는 부모 또는 형제 클래스에서 설명자를 호출하는 것입니다.

super()는 super().__getitem__(name)과 같은 명시적인 점으로 구분된 속성 조회를 위한 바인딩 프로세스의 일부로 구현됩니다. 협동 다중 상속을 지원하는 예측 가능한 순서로 클래스를 검색하기 위한 자체 __getattribute__() 메서드를 구현하여 그렇게 합니다. 따라서 super()[이름]과 같은 명령문 또는 연산자를 사용하는 암시적 조회에 대해 super()는 정의되지 않습니다.

또한 인수가 0인 형식을 제외하고 super()는 내부 메서드를 사용하도록 제한되지 않습니다. 두 인수 형식은 인수를 정확하게 지정하고 적절한 참조를 만듭니다. 인수가 없는 형식은 컴파일러가 정의 중인 클래스를 올바르게 검색하고 일반적인 메서드에 대한 현재 인스턴스에 액세스하는 데 필요한 세부 정보를 채우므로 클래스 정의 내에서만 작동합니다.

super()를 사용하여 협력 클래스를 설계하는 방법에 대한 실용적인 제안은 super() 사용 가이드를 참조하세요.

class tuple
class tuple(iterable)

튜플은 함수가 아니라 실제로는 Tuples 및 Sequence Types — list, tuple, range에 설명된 대로 불변 시퀀스 유형입니다.

class type(object)
class type(name, bases, dict, **kwds)

하나의 인수로 객체의 유형을 반환합니다. 반환 값은 유형 개체이며 일반적으로 object.__class__가 반환하는 것과 동일한 개체입니다.

isinstance() 내장 함수는 하위 클래스를 고려하기 때문에 객체의 유형을 테스트하는 데 권장됩니다.

세 개의 인수를 사용하여 새 유형 객체를 반환합니다. 이것은 기본적으로 클래스 문의 동적 형식입니다. 이름 문자열은 클래스 이름이며 __name__ 속성이 됩니다. 기본 튜플은 기본 클래스를 포함하고 __bases__ 속성이 됩니다. 비어 있으면 모든 클래스의 최종 기반인 객체가 추가됩니다. dict 사전에는 클래스 본문에 대한 특성 및 메서드 정의가 포함되어 있습니다. __dict__ 속성이 되기 전에 복사하거나 래핑할 수 있습니다. 다음 두 문은 동일한 형식 개체를 만듭니다.

class X:
    a = 1

X = type('X', (), dict(a=1))

Type Objects도 참조하십시오.

세 개의 인수 형식에 제공된 키워드 인수는 클래스 정의(메타클래스 제외)의 키워드와 동일한 방식으로 적절한 메타클래스 기계(보통 __init_subclass__())로 전달됩니다.

Customizing class creation도 참조하십시오.

버전 3.6에서 변경: type.__new__ 를 재정의하지 않는 유형의 서브클래스는 더 이상 객체의 유형을 얻기 위해 하나의 인수 형식을 사용할 수 없습니다.

vars()
vars(object)

모듈, 클래스, 인스턴스 또는 __dict__ 속성이 있는 다른 객체에 대해 __dict__ 속성을 반환합니다.

모듈 및 인스턴스와 같은 객체에는 업데이트 가능한 __dict__ 속성이 있습니다. 그러나 다른 객체는 __dict__ 속성에 대한 쓰기 제한이 있을 수 있습니다(예: 클래스는 직접 사전 업데이트를 방지하기 위해 types.MappingProxyType 사용).

인수가 없으면 vars()는 locals()처럼 작동합니다. locals 사전에 대한 업데이트가 무시되기 때문에 locals 사전은 읽기에만 유용합니다.

객체가 지정되었지만 __dict__ 속성이 없는 경우 TypeError 예외가 발생합니다(예: 해당 클래스가 __slots__ 속성을 정의하는 경우).

zip(*iterables, strict=False)

여러 이터러블을 병렬로 반복하여 각각의 항목이 있는 튜플을 생성합니다.

예:

>>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):
...     print(item)
...
(1, 'sugar')
(2, 'spice')
(3, 'everything nice')

더 공식적으로: zip()은 튜플의 이터레이터를 반환합니다. 여기서 i번째 튜플은 각 인수 iterables의 i번째 요소를 포함합니다.

zip()을 생각하는 또 다른 방법은 행을 열로, 열을 행으로 바꾸는 것입니다. 이것은 행렬을 전치하는 것과 비슷합니다.

zip() is lazy: 요소는 iterable이 반복될 때까지 처리되지 않습니다. for 루프 또는 목록으로 래핑하여.

한 가지 고려해야 할 사항은 zip()에 전달된 반복 가능 항목의 길이가 다를 수 있다는 것입니다. 때로는 의도적으로, 때로는 이러한 이터러블을 준비한 코드의 버그로 인해. Python은 이 문제를 처리하기 위해 세 가지 접근 방식을 제공합니다.

기본적으로 zip()은 가장 짧은 iterable이 소진되면 중지됩니다. 더 긴 iterables의 나머지 항목을 무시하고 결과를 가장 짧은 iterable 길이로 잘라냅니다.

>>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum'])) 
[(0, 'fee'), (1, 'fi'), (2, 'fo')]

zip()은 iterables의 길이가 같다고 가정하는 경우에 자주 사용됩니다. 이러한 경우 strict=True 옵션을 사용하는 것이 좋습니다. 출력은 일반 zip()과 동일합니다.

>>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
[('a', 1), ('b', 2), ('c', 3)]

기본 동작과 달리 하나의 iterable이 다른 것보다 먼저 소진되면 ValueError가 발생합니다.

>>> for item in zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True):  
...     print(item)
...
(0, 'fee')
(1, 'fi')
(2, 'fo')
Traceback (most recent call last):
  ...
ValueError: zip() argument 2 is longer than argument 1

strict=True 인수가 없으면 다른 길이의 이터러블을 초래하는 모든 버그가 침묵하여 프로그램의 다른 부분에서 찾기 어려운 버그로 나타날 수 있습니다.

더 짧은 이터러블은 모든 이터러블의 길이를 동일하게 만들기 위해 상수 값으로 채워질 수 있습니다. 이것은 itertools.zip_longest()에 의해 수행됩니다.

극단적인 경우: 반복 가능한 단일 인수를 사용하면 zip()은 1-튜플의 반복자를 반환합니다. 인수가 없으면 빈 반복자를 반환합니다.

팁과 요령:

iterables의 왼쪽에서 오른쪽 평가 순서가 보장됩니다. 이는 zip(*[iter(s)]*n, strict=True)을 사용하여 데이터 계열을 n 길이 그룹으로 클러스터링하는 관용구를 가능하게 합니다. 이것은 각 출력 튜플이 반복자에 대한 n 호출의 결과를 갖도록 동일한 반복자를 n 번 반복합니다. 이는 입력을 n 길이 청크로 나누는 효과가 있습니다.

* 연산자와 함께 zip()을 사용하여 목록의 압축을 풀 수 있습니다.

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> list(zip(x, y))
[(1, 4), (2, 5), (3, 6)]
>>> x2, y2 = zip(*zip(x, y))
>>> x == list(x2) and y == list(y2)
True

버전 3.10에서 변경: strict 인수를 추가했습니다.

import(name, globals=None, locals=None, fromlist=(), level=0)

참고 이것은 importlib.import_module()과 달리 일상적인 Python 프로그래밍에 필요하지 않은 고급 기능입니다.
이 함수는 import 문에 의해 호출됩니다. import 문의 의미를 변경하기 위해 (builtins 모듈을 가져오고 builtins.__import__에 할당하여) 교체할 수 있지만 그렇게 하는 것은 일반적으로 가져오기 후크(PEP 302 참조)를 사용하는 것이 더 간단하기 때문에 강력히 권장하지 않습니다. 동일한 목표를 가지며 기본 가져오기 구현이 사용 중이라고 가정하는 코드에 문제를 일으키지 않습니다. importlib.import_module() 대신 __import__()를 직접 사용하는 것도 권장되지 않습니다.

이 함수는 패키지 컨텍스트에서 이름을 해석하는 방법을 결정하기 위해 잠재적으로 주어진 전역 및 지역을 사용하여 모듈 이름을 가져옵니다. fromlist는 이름으로 주어진 모듈에서 가져와야 하는 객체 또는 하위 모듈의 이름을 제공합니다. 표준 구현은 locals 인수를 전혀 사용하지 않고 import 문의 패키지 컨텍스트를 결정하기 위해서만 globals를 사용합니다.

level 절대 또는 상대 가져오기를 사용할지 여부를 지정합니다. 0(기본값)은 절대 가져오기만 수행함을 의미합니다. level의 양수 값은 __import__()를 호출하는 모듈의 디렉토리에 상대적으로 검색할 상위 디렉토리의 수를 나타냅니다(자세한 내용은 PEP 328 참조).

name 변수가 package.module 형식이면 일반적으로 이름으로 명명된 모듈이 아니라 최상위 패키지(첫 번째 점까지의 이름)가 반환됩니다. 그러나 비어 있지 않은 fromlist 인수가 제공되면 이름으로 명명된 모듈이 반환됩니다.

예를 들어 import spam 명령문은 다음 코드와 유사한 바이트코드를 생성합니다.

spam = __import__('spam', globals(), locals(), [], 0)

import spam.ham 명령문은 다음 호출을 생성합니다.

spam = __import__('spam.ham', globals(), locals(), [], 0)

여기서 __import__()가 최상위 모듈을 반환하는 방법에 주목하십시오. 이것이 import 문에 의해 이름에 바인딩된 객체이기 때문입니다.

반면에 spam.ham 수입 계란, 소시지를 소스로 사용한 진술은 다음과 같습니다.

_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
eggs = _temp.eggs
saus = _temp.sausage

여기서 spam.ham 모듈은 __import__()에서 반환됩니다. 이 개체에서 가져올 이름이 검색되어 해당 이름에 할당됩니다.

이름으로 모듈(잠재적으로 패키지 내)을 가져오려면 importlib.import_module()을 사용하십시오.

버전 3.3에서 변경: 수준에 대한 음수 값은 더 이상 지원되지 않습니다(기본값도 0으로 변경됨).

버전 3.9에서 변경: 명령줄 옵션 -E 또는 -I가 사용될 때 환경 변수 PYTHONCASEOK가 이제 무시됩니다.

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

abs(x)

aiter(async_iterable)

all(iterable)

awaitable anext(async_iterator)awaitable anext(async_iterator, default)

any(iterable)

ascii(object)

bin(x)

class bool(x=False)

breakpoint(*args, **kws)

class bytearray(source=b”)class bytearray(source, encoding)class bytearray(source, encoding, errors)

class bytes(source=b”)class bytes(source, encoding)class bytes(source, encoding, errors)

callable(object)

chr(i)

@classmethod

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=- 1)

class complex(real=0, imag=0)class complex(string)

delattr(object, name)

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

dir()dir(object)

divmod(a, b)

enumerate(iterable, start=0)

eval(expression, globals=None, locals=None)

exec(object, globals=None, locals=None, /, *, closure=None)

filter(function, iterable)

class float(x=0.0)

format(value, format_spec=”)

class frozenset(iterable=set())

getattr(object, name)getattr(object, name, default)

globals()

hasattr(object, name)

hash(object)

help()help(request)

hex(x)

id(object)

input()input(prompt)

class int(x=0)class int(x, base=10)

isinstance(object, classinfo)¶

issubclass(class, classinfo)

iter(object)iter(object, sentinel)

len(s)

class listclass list(iterable)

locals()

map(function, iterable, *iterables)

max(iterable, *, key=None)max(iterable, *, default, key=None)max(arg1, arg2, *args, key=None)

class memoryview(object)

min(iterable, *, key=None)min(iterable, *, default, key=None)min(arg1, arg2, *args, key=None)

next(iterator)next(iterator, default)

class object

oct(x)

open(file, mode=’r’, buffering=- 1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

ord(c)

pow(base, exp, mod=None)

print(*objects, sep=’ ‘, end=’\n’, file=None, flush=False)

class property(fget=None, fset=None, fdel=None, doc=None)

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

repr(object)

reversed(seq)

round(number, ndigits=None)

class setclass set(iterable)

setattr(object, name, value)

class slice(stop)class slice(start, stop, step=1)

sorted(iterable, /, *, key=None, reverse=False)

@staticmethod

class str(object=”)class str(object=b”, encoding=’utf-8′, errors=’strict’)

sum(iterable, /, start=0)

class superclass super(type, object_or_type=None)

class tupleclass tuple(iterable)

class type(object)class type(name, bases, dict, **kwds)

vars()vars(object)

zip(*iterables, strict=False)

__import__(name, globals=None, locals=None, fromlist=(), level=0)

awaitable anext(async_iterator)
awaitable anext(async_iterator, default)

class bytearray(source=b”)
class bytearray(source, encoding)
class bytearray(source, encoding, errors)

class bytes(source=b”)
class bytes(source, encoding)
class bytes(source, encoding, errors)

class complex(real=0, imag=0)
class complex(string)

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

dir()
dir(object)

getattr(object, name)
getattr(object, name, default)

help()
help(request)

input()
input(prompt)

class int(x=0)
class int(x, base=10)

iter(object)
iter(object, sentinel)

class list
class list(iterable)

max(iterable, , key=None)
max(iterable, , default, key=None)
max(arg1, arg2, *args, key=None)

min(iterable, , key=None)
min(iterable, , default, key=None)
min(arg1, arg2, *args, key=None)

next(iterator)
next(iterator, default)

print(objects, sep=’ ‘, end=’\n’, file=None, flush=False*)

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

class set
class set(iterable)

class slice(stop)
class slice(start, stop, step=1)

sorted(iterable, /, , key=None, reverse=False*)

class str(object=”)
class str(object=b”, encoding=’utf-8′, errors=’strict’)

class super
class super(type, object_or_type=None)

class tuple
class tuple(iterable)

class type(object)
class type(name, bases, dict, **kwds)

vars()
vars(object)

import(name, globals=None, locals=None, fromlist=(), level=0)