내장 함수¶

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

내장 함수
A `abs()` `aiter()` `all()` `anext()` `any()` `ascii()` B `bin()` `bool()` `breakpoint()` `bytearray()` `bytes()` C `callable()` `chr()` `classmethod()` `compile()` `complex()` D `delattr()` `dict()` `dir()` `divmod()`	E `enumerate()` `eval()` `exec()` F `filter()` `float()` `format()` `frozendict()` `frozenset()` G `getattr()` `globals()` H `hasattr()` `hash()` `help()` `hex()` I `id()` `input()` `int()` `isinstance()` `issubclass()` `iter()`	L `len()` `list()` `locals()` M `map()` `max()` `memoryview()` `min()` N `next()` O `object()` `oct()` `open()` `ord()` P `pow()` `print()` `property()`	R `range()` `repr()` `reversed()` `round()` S `set()` `setattr()` `sentinel()` `slice()` `sorted()` `staticmethod()` `str()` `sum()` `super()` T `tuple()` `type()` V `vars()` Z `zip()` _ `__import__()`

abs(number, /)¶: 숫자의 절대값을 반환합니다. 인자는 정수, 부동 소수점 수 또는 __abs__() 를 구현하는 객체일 수 있습니다. 인자가 복소수인 경우 그 크기(magnitude)가 반환됩니다.

aiter(async_iterable, /)¶

aiter(callable, /, stop_value, *, stop_exception=StopAsyncIteration)

aiter(callable, /, *, stop_exception)

비동기 이터레이터 객체를 반환합니다. 첫 번째 인자는 다른 인자의 존재 여부에 따라 매우 다르게 해석됩니다. 다른 인자가 없는 경우, 단일 인자는 반드시 비동기 이터러블 이어야 하며, 결과는 x.__aiter__() 를 호출한 것과 동일합니다.

stop_value 또는 stop_exception 이 제공되면 첫 번째 인자는 호출 가능한 객체여야 합니다. 이 경우 생성된 비동기 이터레이터는 __anext__() 메서드를 호출할 때마다 인자 없이 callable 을 호출하고 그 결과를 대기(await)합니다. 만약 대기한 값이 stop_value 와 같거나, 호출 시 stop_exception 과 일치하는 예외가 발생하면 StopAsyncIteration 이 발생하며, 그렇지 않으면 해당 값이 반환됩니다. callable은 __anext__() 의 결과가 대기될 때만 호출됩니다.

stop_exception 은 예외 클래스 또는 예외 클래스들의 튜플입니다. stop_value 가 지정되지 않은 경우, callable이 예외를 발생시킬 때에만 반복이 중단됩니다. 만약 callable이 stop_exception 과 일치하지 않는 StopAsyncIteration 을 발생시키면, 비동기 제너레이터와 마찬가지로 RuntimeError 로 대체됩니다(see PEP 525).

예를 들어, 파일 끝에 도달할 때까지 비동기 스트림에서 고정된 크기의 청크를 읽어오는 경우:

from functools import partial
async for chunk in aiter(partial(reader.read, 1024), b''):
    process_chunk(chunk)

또는, 셧다운될 때까지 asyncio.Queue 를 소비하는 경우:

from asyncio import QueueShutDown
async for item in aiter(queue.get, stop_exception=QueueShutDown):
    process_item(item)

Added in version 3.10.

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

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

When awaited, return the next item from the given asynchronous iterator, or default if given and the iterator is exhausted.

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

이것은 async_iterator 의 __anext__() 메서드를 호출하여 어웨이터블 을 반환합니다. 이를 대기하면 이터레이터의 다음 값을 반환합니다. default 가 제공된 경우 이터레이터가 소진되면 해당 값을 반환하고, 그렇지 않으면 StopAsyncIteration 이 발생합니다.

Added in version 3.10.

any(iterable, /)¶

iterable 의 요소 중 어느 하나라도 참이면 True 를 반환합니다. iterable이 비어있으면 False 를 반환합니다. 다음과 동일합니다:

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

ascii(object, /)¶: repr() 과 마찬가지로 객체의 출력 가능한 표현을 포함하는 문자열을 반환하되, repr() 이 반환한 문자열 내의 비-ASCII 문자를 \x, \u 또는 \U 이스케이프를 사용하여 처리합니다. 이는 파이썬 2에서 repr() 이 반환하는 것과 유사한 문자열을 생성합니다.

bin(integer, /)¶

정수형 숫자를 “0b” 접두사가 붙은 이진수 문자열로 변환합니다. 결과는 유효한 파이썬 표현식입니다. integer 가 파이썬 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')

음수 값을 2의 보수 형태로 표현하려면 enum.bin() 을 참조하십시오.

더 자세한 정보는 format() 을 참조하십시오.

class bool(object=False, /)¶: Boolean 값, 즉 True 또는 False 중 하나를 반환합니다. 인자는 표준 진리 테스트 절차 를 사용하여 변환됩니다. 인자가 거짓이거나 생략된 경우 False 를 반환하고, 그렇지 않으면 True 를 반환합니다. bool 클래스는 int 의 하위 클래스이며(참조: 숫자 형 — int, float, complex), 더 이상 하위 클래스로 확장될 수 없습니다. 유일한 인스턴스는 False 와 True 입니다(참조: 불린(Boolean) 타입 - bool).

버전 3.7에서 변경: 해당 매개 변수는 이제 위치 전용(positional-only)입니다.

breakpoint(*args, **kws)¶

이 함수는 호출 시점에서 디버거를 실행합니다. 구체적으로, args 와 kws 를 그대로 전달하며 sys.breakpointhook() 를 호출합니다. 기본적으로 sys.breakpointhook() 는 인자가 없는 상태에서 pdb.set_trace() 를 호출합니다. 이 경우, 디버거에 진입하기 위해 pdb 를 명시적으로 임포트하거나 코드를 많이 작성할 필요가 없는 편의용 함수입니다. 하지만 sys.breakpointhook() 을 다른 함수로 설정하면 breakpoint() 가 이를 자동으로 호출하여 원하는 디버거를 선택할 수 있습니다. sys.breakpointhook() 에 접근할 수 없는 경우 이 함수는 RuntimeError 를 발생시킵니다.

기본적으로 breakpoint() 의 동작은 PYTHONBREAKPOINT 환경 변수로 변경할 수 있습니다. 사용에 관한 자세한 내용은 sys.breakpointhook() 을 참조하십시오.

sys.breakpointhook() 이 교체된 경우 동작이 보장되지 않을 수 있음에 유의하십시오.

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

Added in version 3.7.

class bytearray(source=b'')

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

새로운 바이트 배열을 반환합니다. bytearray 클래스는 0 <= x < 256 범위의 정수로 구성된 가변 시퀀스입니다. 이 클래스는 가변 시퀀스 유형 에 설명된 가변 시퀀스의 일반적인 메서드들과 Bytes 및 Bytearray 연산 에서 확인되는 bytes 타입의 대부분의 메서드를 보유합니다.

선택적 source 매개 변수는 배열을 다음과 같은 몇 가지 방식으로 초기화하는 데 사용될 수 있습니다:

이 값이 문자열 인 경우, encoding (그리고 선택적으로 errors) 매개 변수도 함께 제공해야 합니다. bytearray() 는 그 후 str.encode() 를 사용하여 문자열을 바이트로 변환합니다.
이 값이 정수 인 경우, 배열은 해당 크기를 가지며 널 바이트로 초기화됩니다.
이 값이 버퍼 프로토콜 을 따르는 객체인 경우, 해당 객체의 읽기 전용 버퍼가 바이트 배열을 초기화하는 데 사용됩니다.
이 값이 이터러블 인 경우, 반드시 0 <= x < 256 범위의 정수들로 구성된 이터러블이어야 하며, 이들은 배열의 초기 내용으로 사용됩니다.

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

바이트 시퀀스 타입 — bytes, bytearray, memoryview 및 bytearray 객체 도 참조하십시오.

class bytes(source=b'')

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

0 <= x < 256 범위의 정수로 구성된 불변 시퀀스인 새로운 “bytes” 객체를 반환합니다. bytes 는 bytearray 의 불변 버전이며, 동일한 비변이 메서드와 동일한 인덱싱 및 슬라이싱 동작을 가집니다.

이에 따라 생성자 인수는 bytearray() 용으로 해석됩니다.

바이트 객체는 리터럴로도 생성할 수 있으며, 문자열과 바이트열 리터럴 를 참조하십시오.

바이트 시퀀스 타입 — bytes, bytearray, memoryview, 바이트 객체, 그리고 Bytes 및 Bytearray 연산 도 참조하십시오.

callable(object, /)¶: Return True if the object argument appears callable, False if not. If this returns True, it is still possible that a call fails, but if it is False, calling object will never succeed. Note that classes are callable (calling a class returns a new instance); instances are callable if their class has a __call__() method.

Added in version 3.2: 이 함수는 파이썬 3.0에서 처음 삭제되었다가 파이썬 3.2에서 다시 도입되었습니다.

chr(codepoint, /)¶

지정된 유니코드 코드 포인트를 가진 문자를 나타내는 문자열을 반환합니다. 예를 들어, chr(97) 은 'a' 를 반환하고, chr(8364) 는 '€' 를 반환합니다. 이는 ord() 의 역연산입니다.

인자의 유효 범위는 0부터 1,114,111(16진수 0x10FFFF)까지입니다. 이 범위를 벗어나는 경우 ValueError 가 발생합니다.

@classmethod¶

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

클래스 메서드는 인스턴스 메서드가 인스턴스를 받는 것과 마찬가지로 클래스를 암시적인 첫 번째 인자로 받습니다. 클래스 메서드를 선언하려면 다음 관용구를 사용하십시오:

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

@classmethod 형태는 함수 데코레이터 입니다. 자세한 내용은 함수 정의 을 참조하십시오.

클래스 메서드는 클래스(예: C.f()) 또는 인스턴스(예: C().f())에서 호출할 수 있습니다. 인스턴스는 그 클래스 정보만 제외하고는 무시됩니다. 파생 클래스에서 클래스 메서드가 호출되면 파생 클래스 객체가 암시적인 첫 번째 인자로 전달됩니다.

클래스 메서드는 C++이나 Java의 static 메서드와는 다릅니다. 그것들을 원하신다면 이 섹션의 staticmethod() 를 참조하십시오. 클래스 메서드에 대한 더 자세한 정보는 표준형 계층 를 참조하십시오.

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

버전 3.10에서 변경: 클래스 메서드는 이제 메서드 어트리뷰트(__module__, __name__, __qualname__, __doc__ 및 __annotations__)를 상속받으며 새로운 __wrapped__ 어트리뷰트를 가집니다.

버전 3.11부터 사용 지원 중단(deprecated), 버전 3.13에서 제거됨: 클래스 메서드는 이제 property() 와 같은 다른 디스크립터 를 래핑할 수 없습니다.

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1, *, module=None)¶

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

filename 인자는 코드가 읽힌 파일을 지정해야 합니다. 파일에서 읽히지 않은 경우 인식 가능한 값(일반적으로 '<string>')을 전달하십시오.

mode 인자는 어떤 종류의 코드가 컴파일되어야 하는지 지정합니다. source 가 문장 시퀀스로 구성된 경우 'exec', 단일 표현식으로 구성된 경우 'eval', 단일 대화형 문장으로 구성된 경우 'single' (이 경우, None 이외의 값으로 평가되는 표현식 문장이 출력됨)이 될 수 있습니다.

선택적 인자인 flags 와 dont_inherit 는 어떤 컴파일러 옵션 이 활성화되고 어떤 미래 기능 이 허용될지 제어합니다. 둘 중 어느 것도 없거나(또는 둘 다 0인 경우) 코드는 compile() 을 호출하는 코드를 영향을 미치는 것과 동일한 플래그로 컴파일됩니다. flags 인자가 제공되고 dont_inherit 이 없거나 0인 경우, 기본적으로 사용될 것들에 더해 flags 인자가 지정한 컴파일러 옵션과 미래 문들이 사용됩니다. dont_inherit 이 0이 아닌 정수이면, flags 인자의 값은 그것이며, 주변 코드의 플래그(미래 기능 및 컴파일러 옵션)는 무시됩니다.

컴파일러 옵션과 미래 문은 비트 단위 OR 연산으로 결합하여 여러 옵션을 지정할 수 있는 비트로 명시됩니다. 특정 미래 기능을 지정하는 데 필요한 비트 필드는 __future__ 모듈의 _Feature 인스턴스에 있는 compiler_flag 어트리뷰트에서 찾을 수 있습니다. 컴파일러 플래그 는 ast 모듈에서 PyCF_ 접두사로 찾을 수 있습니다.

optimize 인자는 컴파일러의 최적화 수준을 지정합니다. 기본값인 -1 은 -O 옵션에 의해 제공되는 인터프리터의 최적화 수준을 선택합니다. 명시적인 수준은 0 (최적화 없음; __debug__ 가 True), 1 (assert 제거, __debug__ 가 False), 또는 2 (docstring도 제거)입니다.

선택적 인자인 module 은 모듈 이름을 지정합니다. 이는 모듈 이름에 의한 필터 구문 경고를 명확하게 구분하기 위해 필요합니다.

이 함수는 컴파일된 소스가 올바르지 않은 경우(Null 문자가 포함되거나 디코딩할 수 없는 source 포함) SyntaxError 를 발생시키고, mode 또는 flags 가 유효하지 않거나 문자열 source 에 surrogate 문자가 포함된 경우 ValueError 를 발생시킵니다. 또한 source 가 파싱하거나 컴파일하기에 너무 복잡한 경우(예: 수천 개의 중첩된 연산자가 포함된 표현식) MemoryError 또는 RecursionError 를 발생시키며, source 가 너무 큰 경우 OverflowError 를 발생시킵니다.

Python 코드를 AST 표현으로 파싱하려면 ast.parse() 를 참조하십시오.

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

참고

'single' 또는 'eval' 모드에서 여러 줄의 코드가 포함된 문자열을 컴파일할 때, 입력은 최소 하나의 줄 바꿈 문자로 끝나야 합니다. 이는 code 모듈에서 불완전한 문장과 완료된 문장을 감지하기 용이하도록 하기 위함입니다.

경고

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

버전 3.2에서 변경: Windows 및 Mac의 줄 바꿈을 허용합니다. 또한, 'exec' 모드에서 입력이 더 이상 줄 바꿈으로 끝나지 않아도 됩니다. optimize 매개변수가 추가되었습니다.

버전 3.5에서 변경: 이전에는 source 에서 널 바이트를 발견할 때 TypeError 가 발생했습니다.

버전 3.8에서 변경: 이제 플래그에 ast.PyCF_ALLOW_TOP_LEVEL_AWAIT``를 전달하여 최상위 수준의 ``await, async for, async with 지원을 활성화할 수 있습니다.

버전 3.12에서 변경: source 에서 null 바이트가 발견될 경우 ValueError 대신 SyntaxError 가 발생합니다.

버전 3.15에서 변경: module 매개변수가 추가되었습니다.

class complex(number=0, /)¶

class complex(string, /)

class complex(real=0, imag=0)

단일 문자열이나 숫자를 복소수로 변환하거나, 실수부와 허수부로부터 복소수를 생성합니다.

예제:

>>> complex('+1.23')
(1.23+0j)
>>> complex('-4.5j')
-4.5j
>>> complex('-1.23+4.5j')
(-1.23+4.5j)
>>> complex('\t( -1.23+4.5J )\n')
(-1.23+4.5j)
>>> complex('-Infinity+NaNj')
(-inf+nanj)
>>> complex(1.23)
(1.23+0j)
>>> complex(imag=-4.5)
-4.5j
>>> complex(-1.23, 4.5)
(-1.23+4.5j)

인자가 문자열인 경우, 이 문자열은 실수부(float() 와 동일한 형식), 허부(동일한 형식이되 'j'' 또는 'J'' 접미사가 붙음), 또는 둘 다를 포함해야 합니다(이 경우 허부의 부호는 필수입니다). 문자열은 선택적으로 공백과 둥근 괄호 '(' 및 ')' 로 둘러싸일 수 있으며, 이들은 무시됩니다. 문자열은 '+', '-', 'j'' 또는 'J'' 접미사, 그리고 십진수 사이의 공백을 포함해서는 안 됩니다. 예를 들어, complex('1+2j') 는 허용되지만 complex('1 + 2j') 는 ValueError 를 발생시킵니다. 더 정확하게는, 입력은 괄호와 앞뒤 공백이 제거된 후 다음 문법의 complexvalue 생성 규칙을 따라야 합니다:

complexvalue: floatvalue |
              floatvalue ("j" | "J") |
              floatvalue sign absfloatvalue ("j" | "J")

인자가 숫자라면, 이 생성자는 int 및 float 와 같은 숫자 변환으로 작동합니다. 일반적인 Python 객체 x 에 대해 complex(x) 는 x.__complex__() 를 호출합니다. 만약 __complex__() 가 정의되어 있지 않으면 __float__() 를 호출합니다. 만약 __float__() 도 정의되어 있지 않으면 __index__() 를 호출합니다.

두 개의 인자가 제공되거나 키워드 인자가 사용되는 경우, 각 인자는 임의의 숫자 타입(복소수 포함)이 될 수 있습니다. 두 인자가 모두 실수인 경우, 실수 성분이 real 이고 허수 성분이 imag 인 복소수를 반환합니다. 두 인자가 모두 복소수이면, 실수 성분이 real.real-imag.imag 이고 허수 성분이 real.imag+imag.real 인 복소수를 반환합니다. 인자 중 하나가 실수인 경우, 위의 표현식에서 해당 인자의 실수 성분만 사용됩니다.

단일 숫자 인자만 수락하는 complex.from_number() 도 참조하십시오.

모든 인자가 생략되면 0j 를 반환합니다.

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

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

버전 3.8에서 변경: __complex__() 및 __float__() 가 정의되어 있지 않으면 __index__() 를 사용합니다.

버전 3.14부터 폐지됨: 복소수를 real 또는 imag 인자로 전달하는 방식은 이제 더 이상 권장되지 않습니다. 복소수는 단일 위치 인자로만 전달해야 합니다.

delattr(object, name, /)¶: This is a relative of setattr(). The arguments are an object and a string. The string must be the name of one of the object’s attributes. The function deletes the named attribute, provided the object allows it. For example, delattr(x, 'foobar') is equivalent to del x.foobar. name need not be a Python identifier (see setattr()).

class dict(**kwargs)

class dict(mapping, /, **kwargs)

class dict(iterable, /, **kwargs)

새 딕셔너리를 생성합니다. dict 객체는 딕셔너리 클래스입니다. 이 클래스에 대한 설명은 매핑 형 — dict, frozendict 을 참조하십시오.

다른 컨테이너의 경우 내장된 frozendict, list, set, tuple 클래스 및 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__', '__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 객체를 반환합니다. iterable 은 시퀀스, iterator, 또는 다른 반복을 지원하는 객체여야 합니다. 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(source, /, globals=None, locals=None)¶

매개변수:

source (str | code object) – 파이썬 표현식.
globals (dict | frozendict | None) – 전역 네임스페이스 (기본값: None).
locals (mapping | None) – 지역 네임스페이스 (기본값: None).

반환:

평가된 표현식의 결과.

raised:

구문 오류는 예외로 보고됩니다.

경고

이 함수는 임의의 코드를 실행합니다. 신뢰할 수 없는 사용자 입력으로 이 함수를 호출하면 보안 취약점이 발생할 수 있습니다.

The source argument is parsed and evaluated as a Python expression (technically speaking, an expression list) using the globals and locals mappings as global and local namespace. If the globals dictionary is present and does not contain a value for the key __builtins__, a reference to the dictionary of the built-in module builtins is inserted under that key before source is parsed. Overriding __builtins__ can be used to restrict or change the available names, but this is not a security mechanism: the executed code can still access all builtins. If the locals mapping is omitted it defaults to the globals dictionary. If both mappings are omitted, the source is executed with the globals and locals in the environment where eval() is called. Note, eval() will only have access to the nested scopes (non-locals) in the enclosing environment if they are already referenced in the scope that is calling eval() (e.g. via a nonlocal statement).

예제:

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

>>> eval("1, 2")
(1, 2)

이 함수는 임의의 코드 객체(예를 들어 compile() 에 의해 생성된 객체)를 실행하는 데에도 사용될 수 있습니다. 이 경우, 문자열 대신 코드 객체를 전달하십시오. 코드 객체가 mode 인자로 'exec' 를 사용하여 컴파일된 경우, eval() 의 반환값은 None 이 됩니다.

힌트: 문장의 동적 실행은 exec() 함수에 의해 지원됩니다. globals() 및 locals() 함수는 각각 현재의 전역 및 지역 딕셔너리를 반환하며, 이는 eval() 또는 exec() 에서 사용하기 위해 전달하는 데 유용할 수 있습니다.

제공된 source가 문자열인 경우, 앞뒤 공백과 탭이 제거됩니다.

리터럴만 포함된 표현이 포함된 문자열을 평가하는 함수를 보려면 ast.literal_eval() 을 참조하십시오.

코드 객체를 인자로 하여 auditing event exec 을 발생시킵니다. 코드 컴파일 이벤트도 발생할 수 있습니다.

버전 3.13에서 변경: globals*와 *locals 인자를 이제 키워드로 전달할 수 있습니다.

버전 3.13에서 변경: 기본 locals 네임스페이스의 의미가 locals() 내장 함수에 기술된 대로 조정되었습니다.

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

exec(source, /, globals=None, locals=None, *, closure=None)¶

경고

이 함수는 임의의 코드를 실행합니다. 신뢰할 수 없는 사용자 입력으로 이 함수를 호출하면 보안 취약점이 발생할 수 있습니다.

이 함수는 파이썬 코드의 동적 실행을 지원합니다. source 는 문자열 또는 코드 객체여야 합니다. 문자열인 경우, 해당 문자열은 파이썬 문장 세트로 파싱되어 실행됩니다(구문 오류가 발생하지 않는 한). [1] 코드 객체인 경우, 단순히 실행됩니다. 모든 경우에 실행되는 코드는 파일 입력으로서 유효해야 합니다(참조 매뉴얼의 파일 입력 섹션 참조). nonlocal, yield, 그리고 return 문은 exec() 함수에 전달된 코드의 문맥이라 하더라도 함수 정의 밖에서는 사용될 수 없음을 유의하십시오. 반환값은 None 입니다.

모든 경우에 선택적 부분이 생략되면 코드는 현재 범위에서 실행됩니다. globals 만 제공되는 경우, 이는 딕셔너리여야 하며(딕셔너리의 서브클래스가 아니어야 함), 전역 및 지역 변수 모두에 사용됩니다. globals 와 locals 가 모두 제공되는 경우, 각각 전역 및 지역 변수에 사용됩니다. 제공될 경우, locals 는 어떤 매핑 객체든 될 수 있습니다. 모듈 수준에서는 globals와 locals가 동일한 딕셔너리임을 기억하십시오.

참고

exec 가 globals 와 locals 로 두 개의 개별 객체를 받는 경우, 코드는 클래스 정의 내에 포함된 것처럼 실행됩니다. 이는 실행되는 코드에서 정의된 함수와 클래스가 최상위 수준에서 할당된 변수에 액세스할 수 없음을 의미합니다(클래스 정의에서 ‘최상위’ 변수는 클래스 변수로 취급되기 때문입니다).

globals 딕셔너리가 __builtins__ 키에 대한 값을 포함하지 않는 경우, 내장 모듈 builtins 의 딕셔너리 참조가 해당 키에 삽입됩니다. __builtins__ 를 재정의하여 사용 가능한 이름을 제한하거나 변경할 수 있지만, 이는 성능이나 보안 을 위한 기능이 아닙니다. 실행되는 코드는 여전히 모든 내장 기능을 접근할 수 있습니다.

closure 인자는 클로저(cellvars의 튜플)를 지정합니다. 이는 object 가 free (closure) variables 를 포함하는 코드 객체인 경우에만 유효합니다. 튜플의 길이는 코드 객체의 co_freevars 속성 길이와 정확히 일치해야 합니다.

코드 객체를 인자로 하여 auditing event exec 을 발생시킵니다. 코드 컴파일 이벤트도 발생할 수 있습니다.

참고

내장 함수 globals() 및 locals() 는 각각 현재의 전역 및 지역 네임스페이스를 반환하며, 이는 exec() 의 두 번째 및 세 번째 인자로 사용하기 위해 전달하는 데 유용할 수 있습니다.

참고

The default locals act as described for function locals() below. Pass an explicit locals dictionary if you need to see effects of the code on locals after function exec() returns.

버전 3.11에서 변경: closure 매개변수가 추가되었습니다.

버전 3.13에서 변경: globals*와 *locals 인자를 이제 키워드로 전달할 수 있습니다.

버전 3.13에서 변경: 기본 locals 네임스페이스의 의미가 locals() 내장 함수에 기술된 대로 조정되었습니다.

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

filter(function, iterable, /)¶

function 이 참(True)인 iterable 의 요소들로 이터레이터를 구성합니다. iterable 은 시퀀스, 반복을 지원하는 컨테이너 또는 이터레이터일 수 있습니다. function 이 None 인 경우, 항등 함수를 사용하는 것으로 간주하며, 즉 iterable 에서 거짓(False)인 모든 요소가 제거됩니다.

참고: function 이 None 이 아니면 filter(function, iterable) 은 제너레이터 표현식 (item for item in iterable if function(item)) 과 동등하며, function 이 None 이면 (item for item in_iterable if item) 과 동등합니다.

function 이 거짓(False)인 iterable 의 요소들을 반환하는 상보적 함수에 대해서는 itertools.filterfalse() 를 참조하십시오.

class float(number=0.0, /)¶

class float(string, /)

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

예제:

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

인자가 문자열인 경우, 소수점 숫자를 포함해야 하며, 선택적으로 부호가 앞에 붙거나 공백에 둘러싸일 수 있습니다. 선택적인 부호는 '+' 또는 '-'``일 수 있으며, ``'+' 부호는 생성되는 값에 영향을 주지 않습니다. 또한 인자는 NaN(not-a-number), 양의 무한대 또는 음의 무한대를 나타내는 문자열일 수 있습니다. 더 정확하게는, 입력은 앞뒤 공백을 제거한 후 다음 문법의 floatvalue 생성 규칙을 따라야 합니다.

sign:          "+" | "-"
infinity:      "Infinity" | "inf"
nan:           "nan"
digit:         <a Unicode decimal digit, i.e. characters in Unicode general category Nd>
digitpart:     digit (["_"] digit)*
number:        [digitpart] "." digitpart | digitpart ["."]
exponent:      ("e" | "E") [sign] digitpart
floatnumber:   number [exponent]
absfloatvalue: floatnumber | infinity | nan
floatvalue:    [sign] absfloatvalue

대소문자를 구분하지 않으므로, 예를 들어 “inf”, “Inf”, “INFINITY”, “iNfINity”는 모두 양의 무한대에 대한 허용되는 철자입니다.

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

일반 파이썬 객체 x 에 대해, float(x) 는 x.__float__() 를 호출합니다. __float__() 가 정의되어 있지 않으면 __index__() 를 호출합니다.

숫자 인자만 허용하는 float.from_number() 를 참고하십시오.

인자가 제공되지 않으면 0.0 이 반환됩니다.

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

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

버전 3.7에서 변경: 해당 매개 변수는 이제 위치 전용(positional-only)입니다.

버전 3.8에서 변경: 메서드 __float__() 가 정의되어 있지 않으면 __index__() 를 사용합니다.

format(value, format_spec='', /)¶

value*를 *format_spec*에 의해 제어되는 “포맷된” 표현으로 변환합니다. *format_spec*의 해석은 *value 인자의 타입에 따라 달라지지만, 대부분의 내장 타입에서 사용되는 표준 포맷팅 구문이 있습니다: 포맷 명세 미니 언어.

기본 format_spec 은 빈 문자열이며, 이는 보통 str(value) 를 호출하는 것과 동일한 효과를 줍니다.

format(value, format_spec) 호출은 type(value).__format__(value, format_spec) 으로 변환되며, 이는 값의 __format__() 메서드를 찾을 때 인스턴스 딕셔너리를 거치지 않습니다. 메서드 검색이 object 까지 도달했고 format_spec 이 비어 있지 않거나, format_spec 또는 반환 값이 문자열이 아닌 경우 TypeError 예외가 발생합니다.

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

class frozendict(**kwargs)

class frozendict(mapping, /, **kwargs)

class frozendict(iterable, /, **kwargs)

새로운 frozen 딕셔너리를 생성합니다. frozendict 객체는 내장 클래스입니다. 이 클래스에 대한 자세한 내용은 매핑 형 — dict, frozendict 을 참조하십시오.

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

Added in version 3.15.

class frozenset(iterable=(), /)

새로운 frozenset 객체를 반환하며, 선택적으로 iterable 에서 가져온 요소들을 포함합니다. frozenset 은 내장 클래스입니다. 이 클래스에 대한 자세한 내용은 집합 형 — set, frozenset 을 참조하십시오.

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

getattr(object, name, /)¶
getattr(object, name, default, /): object 의 이름이 지정된 속성(attribute)의 값을 반환합니다. name 은 문자열이어야 합니다. 문자열이 객체의 속성 이름 중 하나라면, 해당 속성의 값을 결과로 반환합니다. 예를 들어, getattr(x, 'foobar') 는 x.foobar 와 동일합니다. 이름이 지정된 속성이 존재하지 않으면, 제공된 경우 default 를 반환하고 그렇지 않으면 AttributeError 가 발생합니다. name 은 반드시 Python 식별자일 필요는 없습니다(참조: setattr()).

참고

어트리뷰트의 이름이 컴파일 시점에 private name mangling 과정을 거치므로, getattr() 으로 프라이빗 어트리뷰트(앞에 밑줄 두 개가 붙은 어트리뷰트)를 가져오려면 수동으로 이름을 꼬아줘야 합니다.

globals()¶: 현재 모듈의 네임스페이스를 구현하는 딕셔너리를 반환합니다. 함수 내부의 코드의 경우, 이는 함수가 정의될 때 설정되며 함수가 호출되는 위치와 상관없이 동일하게 유지됩니다.

hasattr(object, name, /)¶: 인자는 객체와 문자열입니다. 문자열이 객체의 속성 이름 중 하나이면 True 를, 아니면 False 를 반환합니다. (이는 getattr(object, name) 을 호출하여 AttributeError 가 발생하는지 여부를 확인하는 방식으로 구현됩니다.)

hash(object, /)¶: 객체의 해시 값을 반환합니다(해시 값이 있는 경우). 해시 값은 정수입니다. 이 값은 딕셔너리 검색 중 딕셔너리 키를 빠르게 비교하는 데 사용됩니다. 비교 결과가 동일한 수치 값은 동일한 해시 값을 가집니다(1과 1.0의 경우처럼 타입이 다르더라도 마찬가지입니다).

참고

사용자 정의 __hash__() 메서드가 있는 객체의 경우, hash() 가 호스트 머신의 비트 너비에 따라 반환 값을 절단(truncate)한다는 점에 유의하십시오.

help()¶

help(request)

내장 도움말 시스템을 호출합니다. (이 함수는 대화형 사용을 목적으로 합니다.) 인자가 제공되지 않으면 인터프리터 콘솔에서 대화형 도움말 시스템이 시작됩니다. 인자가 문자열인 경우, 해당 문자열을 모듈, 함수, 클래스, 메서드, 키워드 또는 문서 주제의 이름으로 검색하여 콘솔에 도움말 페이지를 출력합니다. 인자가 다른 종류의 객체인 경우, 해당 객체에 대한 도움말 페이지를 생성합니다.

help() 를 호출할 때 함수의 매개변수 목록에 슬래시(/)가 나타나면, 이는 슬래시 앞의 매개변수가 위치 전용(positional-only)임을 의미합니다. 자세한 내용은 the FAQ entry on positional-only parameters 를 참조하십시오.

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

버전 3.4에서 변경: pydoc 및 inspect 의 변경으로 인해 이제 호출 가능한 객체에 대해 보고되는 서명이 더 포괄적이고 일관되게 제공됩니다.

hex(integer, /)¶

정수 숫자를 “0x”로 시작하는 소문자 16진수 문자열로 변환합니다. integer 가 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, /)¶

객체의 “식별자(identity)”를 반환합니다. 이는 객체의 수명 동안 고유하고 일정한 정수입니다. 수명이 겹치지 않는 두 객체는 동일한 id() 값을 가질 수 있습니다.

이것은 메모리 내 객체의 주소입니다.

인수 id 를 사용하여 auditing event builtins.id 를 발생시킵니다.

input()¶

input(prompt, /)

prompt 인수가 있는 경우, 후행 줄 바꿈 없이 표준 출력에 작성됩니다. 그런 다음 함수는 입력에서 한 줄을 읽고, 이를 문자열로 변환(후행 줄 바꿈 제거)하여 반환합니다. EOF가 읽히면 EOFError 가 발생합니다. 예제:

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

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

입력을 읽기 전에 prompt 인자로 auditing event builtins.input 을 발생시킵니다.

입력을 성공적으로 읽은 후의 결과로 auditing event builtins.input/result 를 발생시킵니다.

class int(number=0, /)¶

class int(string, /, base=10)

숫자나 문자열로부터 생성된 정수 객체를 반환하며, 인자가 제공되지 않으면 0 을 반환합니다.

예제:

>>> int(123.45)
123
>>> int('123')
123
>>> int('   -12_345\n')
-12345
>>> int('FACE', 16)
64206
>>> int('0xface', 0)
64206
>>> int('01110011', base=2)
115

인자가 __int__() 를 정의하는 경우, int(x) 는 x.__int__() 를 반환합니다. 인자가 __index__() 를 정의하는 경우, x.__index__() 를 반환합니다. 부동 소수점 숫자의 경우, 0을 향해 절사됩니다.

인자가 숫자가 아니거나 base 가 제공된 경우, 인자는 base 진법에서 정수를 나타내는 문자열, bytes, 또는 bytearray 인스턴스여야 합니다. 선택적으로 문자열 앞에 + 또는 - 를 붙일 수 있으며(사이에 공백 없음), 앞부분에 0이 올 수 있고, 공백으로 둘러싸일 수 있으며, 숫자 사이에 밑줄이 포함될 수 있습니다.

진수-n 정수 문자열은 0에서 n-1까지의 값을 나타내는 숫자로 구성됩니다. 0-9는 임의의 유니코드 10진수 숫자로 표현될 수 있습니다. 10-35는 a 부터 z (또는 A 부터 Z)로 표현될 수 있습니다. 기본 base 는 10입니다. 허용되는 진수는 0 및 2-36입니다. 2진법, 8진법, 16진법 문자열은 코드의 정수 리터럴과 마찬가지로 선택적으로 0b/0B, 0o/0O, 또는 0x/0X 접두사를 붙일 수 있습니다. 진수 0의 경우, 문자열은 integer literal in code 와 유사하게 해석되며, 접두사에 따라 실제 진수가 2, 8, 10 또는 16로 결정됩니다. 진수 0은 또한 앞선 0을 허용하지 않습니다. 즉, int('010', 0) 은 허용되지 않지만, int('010') 와 int('010', 8) 은 허용됩니다.

정수 형은 숫자 형 — int, float, complex 에서 설명합니다.

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

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

버전 3.7에서 변경: 첫 번째 매개변수는 이제 위치 전용(positional-only)입니다.

버전 3.8에서 변경: 메서드 __int__() 가 정의되어 있지 않으면 __index__() 를 사용합니다.

버전 3.11에서 변경: int 문자열 입력 및 문자열 표현은 서비스 거부(DoS) 공격을 방지하기 위해 제한될 수 있습니다. 문자열을 int 로 변환할 때 제한을 초과하거나, int 를 문자열로 변환할 때 제한을 초과하면 ValueError 가 발생합니다. 자세한 내용은 integer string conversion length limitation 를 참조하십시오.

버전 3.14에서 변경: int() 는 더 이상 __trunc__() 메서드에 위임하지 않습니다.

isinstance(object, classinfo, /)¶: object 인자가 classinfo 인스턴스이거나, 해당 인스턴스의 (직접, 간접 또는 virtual) 하위 클래스 인스턴스인 경우 True 를 반환합니다. object 가 해당 타입의 객체가 아니면 항상 False 를 반환합니다. classinfo 가 타입 객체의 튜플(또는 재귀적으로 다른 그러한 튜플)이나 여러 타입의 Union Type 인 경우, object 가 그 중 어느 하나라도 해당 타입의 인스턴스이면 True 를 반환합니다. classinfo 가 타입이나 타입의 튜플이 아닌 경우 TypeError 예외가 발생합니다. 이전 확인이 성공한 경우 유효하지 않은 타입에 대해 TypeError 가 발생하지 않을 수도 있습니다.

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

issubclass(cls, classinfo, /)¶: cls 가 classinfo 의 하위 클래스(직접, 간접 또는 virtual)인 경우 True 를 반환합니다. 클래스는 자기 자신도 하위 클래스로 간주합니다. classinfo 는 클래스 객체들의 튜플(또는 재귀적으로 그러한 튜플들) 또는 Union Type 일 수 있으며, 이 경우 cls 가 classinfo 의 어떤 항목의 하위 클래스여도 True 를 반환합니다. 그 외의 경우에 TypeError 예외가 발생합니다.

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

iter(iterable, /)¶

iter(callable, /, stop_value, *, stop_exception=StopIteration)

iter(callable, /, *, stop_exception)

한 iterator 객체를 반환합니다. 첫 번째 인자는 다른 인자의 존재 여부에 따라 매우 다르게 해석됩니다. 다른 인자가 없는 경우, 단일 인자는 iterable 프로토콜(메서드 __iter__())을 지원하는 컬렉션 객체이거나, 시퀀스 프로토콜(인터페이스 __getitem__() 이며 인자로 0부터 시작하는 정수를 포함)을 지원해야 합니다. 두 프로토콜 중 어느 것도 지원하지 않는 경우 TypeError 가 발생합니다.

stop_value 또는 stop_exception 이 제공되면 첫 번째 인자는 호출 가능한(callable) 객체여야 합니다. 이 경우 생성된 이터레이터는 매 __next__() 메서드 호출 시 인자 없이 callable 을 호출합니다. 이때 반환된 값이 stop_value 와 같거나, 호출 시 stop_exception 과 일치하는 예외가 발생하면 StopIteration 이 발생하며, 그렇지 않으면 해당 값이 반환됩니다.

stop_exception 은 예외 클래스 또는 예외 클래스들의 튜플입니다. stop_value 가 지정되지 않은 경우, callable이 예외를 발생시킬 때만 반복이 중단됩니다. callable이 stop_exception 과 일치하지 않는 StopIteration 을 발생시키면, 제너레이터의 경우와 마찬가지로(참조: PEP 479) RuntimeError 로 대체됩니다.

이터레이션 관련 타입 도 참조하십시오.

iter() 의 두 번째 형태의 유용한 활용 사례 중 하나는 블록 읽기(block-reader)를 구축하는 것입니다. 예를 들어, 바이너리 데이터베이스 파일에서 파일 끝에 도달할 때까지 고정 너비의 블록을 읽는 경우입니다:

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

stop_exception 은 특수한 값을 반환하는 대신 예외를 발생시켜 exhaustion 를 알리는 callable의 경우에 유용합니다. 예를 들어, 큐를 비우는 경우입니다:

import queue
for item in iter(input_queue.get_nowait, stop_exception=queue.Empty):
    process_item(item)

버전 3.16.0a0 (unreleased)에서 변경: stop_exception 매개변수가 추가되었으며, stop_value 를 키워드로 전달할 수 있게 되었습니다.

len(object, /)¶: 객체의 길이(항목의 수)를 반환합니다. 인자는 시퀀스(문자열, bytes, 튜플, 리스트 또는 범위)나 컬렉션(딕셔너리, 세트 또는 프로즌 세트)일 수 있습니다.

len 은 range(2 ** 100) 와 같이 sys.maxsize 보다 큰 길이에 대해 OverflowError 를 발생시킵니다.

class list(iterable=(), /): list 는 함수가 아니라, 리스트 및 시퀀스 타입 — list, tuple, range 에 설명된 바와 같이 실제로 가변 시퀀스 타입입니다.

locals()¶

변수 이름을 키로, 현재 바인딩된 참조를 값으로 하여 현재 로컬 심볼 테이블을 나타내는 매핑 객체를 반환합니다.

모듈 범위에서, 그리고 단일 네임스페이스를 사용하여 exec() 또는 eval() 을 호출할 때, 이 함수는 globals() 와 동일한 네임스페이스를 반환합니다.

클래스 범위에서, 이 함수는 메타클래스 생성자에게 전달될 네임스페이스를 반환합니다.

분리된 로컬 및 전역 인자와 함께 exec() 또는 eval() 을 사용할 경우, 함수 호출 시 전달된 로컬 네임스페이스를 반환합니다.

위의 모든 경우에, 특정 실행 프레임에서 locals() 를 호출할 때마다 동일한 매핑 객체가 반환됩니다. locals() 에서 반환된 매핑 객체를 통해 수행된 변경 사항은 할당, 재할당 또는 삭제된 로컬 변수로 인식되며, 로컬 변수의 할당, 재할량 또는 삭제는 반환된 매핑 객체의 내용에 즉시 영향을 미칩니다.

optimized scope (함수, 제너레이터, 코루틴 포함)에서 locals() 를 호출할 때마다 함수 로컬 변수의 현재 바인딩과 모든 nonlocal 셀 참조를 포함하는 새로운 딕셔너리가 반환됩니다. 이 경우, 반환된 딕셔너리를 통해 수행된 이름 바인딩 변경은 해당 로컬 변수나 nonlocal 셀 참조에 반영되지 않으며, 로컬 변수 및 nonlocal 셀 참조의 할당, 재할당 또는 삭제는 이전에 반환된 딕셔너리의 내용에 영향을 주지 않습니다.

함수, 제너레이터 또는 코루틴의 일부로 컴프리헨션 내에서 locals() 를 호출하는 것은, 컴프리헨션의 초기화된 반복 변수가 포함된다는 점을 제외하고는 해당 스코프에서 호출하는 것과 동일합니다. 다른 스코프에서는 이 호출이 마치 컴프리헨션이 중첩된 함수로 실행되는 것처럼 동작합니다.

제너레이터 표현식의 일부로 locals() 를 호출하는 것은 중첩된 제너레이터 함수에서 호출하는 것과 동일합니다.

버전 3.12에서 변경: 컴프리헨션 내에서 locals() 의 동작이 PEP 709 에 기술된 바와 같이 업데이트되었습니다.

버전 3.13에서 변경: PEP 667 의 일환으로, 이 함수에서 반환되는 매핑 객체를 수정하는 의미가 정의되었습니다. optimized scopes 에서의 동작은 이제 위에서 설명한 바와 같습니다. 정의된 것 외에 다른 스코프에서의 동작은 이전 버전과 동일하게 유지됩니다.

map(function, iterable, /, *iterables, strict=False)¶: iterable 의 모든 항목에 function 을 적용하여 결과를 생성하는 이터레이터를 반환합니다. 추가적인 iterables 인자가 전달되면, function 은 그만큼의 인자를 받아야 하며 모든 이터러블의 항목에 병렬로 적용됩니다. 여러 이터러블이 있는 경우, 이터레이터는 가장 짧은 이터러블이 exhausted 가 되면 중단됩니다. strict 가 True 이고 다른 이터러블이 소진되기 전에 하나라도 소진되면 ValueError 가 발생합니다. 함수 입력이 이미 인자 튜플로 구성된 경우 itertools.starmap() 을 참조하십시오.

버전 3.14에서 변경: strict 매개변수가 추가되었습니다.

max(iterable, /, *, key=None)¶

max(iterable, /, *, default, key=None)

max(arg1, arg2, /, *args, key=None)

이터러블에서 가장 큰 항목을 반환하거나 두 개 이상의 인자 중 가장 큰 것을 반환합니다.

하나의 위치 인자가 제공되면, 그것은 iterable 이어야 합니다. 이 경우 이터러블 내의 가장 큰 항목을 반환합니다. 두 개 이상의 위치 인자가 제공되면, 위치 인자 중 가장 큰 것을 반환합니다.

두 개의 선택적 키워드 전용 인자가 있습니다. key 인자는 list.sort() 에서 사용되는 것과 같은 단일 인자 정렬 함수를 지정합니다. default 인자는 제공된 이터러블이 비어 있을 경우 반환할 객체를 지정합니다. 이터러블이 비어 있고 default 가 제공되지 않은 경우 ValueError 가 발생합니다.

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

버전 3.4에서 변경: default 키워드 전용 매개변수가 추가되었습니다.

버전 3.8에서 변경: key 는 None 일 수 있습니다.

class memoryview(object): 주어진 인자로부터 생성된 “메모리 뷰” 객체를 반환합니다. 더 자세한 내용은 Memory Views 를 참조하십시오.

min(iterable, /, *, key=None)¶

min(iterable, /, *, default, key=None)

min(arg1, arg2, /, *args, key=None)

이터러블에서 가장 작은 항목을 반환하거나 두 개 이상의 인자 중 가장 작은 것을 반환합니다.

하나의 위치 인자가 제공되면, 그것은 iterable 이어야 합니다. 이 경우 이터러블 내의 가장 작은 항목을 반환합니다. 두 개 이상의 위치 인자가 제공되면, 위치 인자 중 가장 작은 것을 반환합니다.

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

버전 3.4에서 변경: default 키워드 전용 매개변수가 추가되었습니다.

버전 3.8에서 변경: key 는 None 일 수 있습니다.

next(iterator, /)¶
next(iterator, default, /): Retrieve the next item from the iterator by calling its __next__() method. If default is given, it is returned if the iterator is exhausted, otherwise StopIteration is raised.

class object¶: 이것은 모든 다른 클래스의 최상위 기본 클래스입니다. 파이썬 클래스의 모든 인스턴스에 공통되는 메서드들을 가집니다. 생성자가 호출될 때 특징이 없는 새로운 객체를 반환하며, 생성자는 어떠한 인자도 허용하지 않습니다.

참고

object 인스턴스는 __dict__ 어트리뷰트가 없으므로, object 인스턴스에 임의의 어트리뷰트를 할당할 수 없습니다.

oct(integer, /)¶

정수 숫자를 “0o”가 접두사로 붙은 8진수 문자열로 변환합니다. 결과는 유효한 파이썬 표현식입니다. integer 가 파이썬 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)¶

Open file and return a corresponding file object. If the file cannot be opened, an OSError is raised. See 파일 읽기 및 쓰기 for more examples of how to use this function.

file is a path-like object giving the pathname (absolute or relative to the current working directory) of the file to be opened or an integer file descriptor of the file to be wrapped. (If a file descriptor is given, it is closed when the returned I/O object is closed unless closefd is set to False.)

mode 은 파일이 열리는 모드를 지정하는 선택적 문자열입니다. 기본값은 텍스트 모드에서 읽기용으로 여는 것을 의미하는 'r' 입니다. 다른 일반적인 값으로, 쓰기(이미 존재하면 파일을 잘라냄)를 위한 'w', 독점 생성을 위한 'x', 추가를 위한 'a' 가 있습니다(일부 Unix 시스템에서 'a' 는 현재 탐색 위치에 관계없이 모든 쓰기가 파일 끝에 추가됨을 의미합니다). 텍스트 모드에서 encoding 이 지정되지 않으면 기본으로 UTF-8이 사용됩니다. 만약 Python UTF-8 Mode 가 비활성화된 경우, 현재 로케일 인코딩을 가져오기 위해 locale.getencoding() 이 호출됩니다. (원시 바이트를 읽고 쓰려면 바이너리 모드를 사용하고 encoding 을 지정하지 마십시오.) 사용 가능한 모드는 다음과 같습니다.

문자	Meaning
`'r'`	읽기용으로 열기 (기본값)
`'w'`	쓰기용으로 열기, 파일 먼저 자르기
`'x'`	독점 생성용으로 열기, 파일이 이미 존재하면 실패
`'a'`	쓰기용으로 열기, 존재할 경우 파일 끝에 추가
`'b'`	바이너리 모드
`'t'`	텍스트 모드 (기본값)
`'+'`	갱신(읽기 및 쓰기)용으로 열기

The default mode is 'r' (open for reading text, a synonym of 'rt'). Modes 'w+' and 'w+b' open and truncate the file. Modes 'r+' and 'r+b' open the file with no truncation.

개요 에서 언급했듯이, 파이썬은 바이너리와 텍스트 I/O를 구분합니다. 바이너리 모드(mode 인자에 'b' 포함)로 열린 파일은 디코딩 없이 내용을 bytes 객체로 반환합니다. 텍스트 모드(기본값 또는 mode 인자에 't' 가 포함된 경우)에서는 파일의 내용이 str 로 반환되며, 바이트가 기본 인코딩 또는 지정된 encoding 을 사용하여 먼저 디코딩됩니다.

참고

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

buffering 은 버퍼링 정책을 설정하는 데 사용되는 선택적 정수입니다. 버퍼링을 끄려면 0을 전달하고(바이너리 모드에서만 허용), 줄 단위 버퍼링을 선택하려면 1을 전달하며(텍스트 모드에서 쓸 때만 사용 가능), 고정 크기 청크 버퍼의 바이트 크기를 지정하려면 1보다 큰 정수를 전달합니다. 이 방식으로 버퍼 크기를 지정하면 바이너리 모드에서 버퍼링된 I/O가 적용되지만, TextIOWrapper (즉, mode='r+'' 로 열린 파일)는 다른 버퍼링 방식을 사용합니다. TextIOWrapper 에서 버퍼링을 비활성화하려면 io.TextIOWrapper.reconfigure() 의 write_through 플래그를 사용하는 것을 고려하십시오. buffering 인수가 제공되지 않을 때 기본 버퍼링 정책은 다음과 같이 작동합니다:

바이너리 파일은 고정 크기 청크로 버퍼링됩니다. 장치 블록 크기를 사용할 수 있는 경우 버퍼 크기는 max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE) 가 됩니다. 대부분의 시스템에서 버퍼 크기는 보통 128킬로바이트입니다.
“대화형” 텍스트 파일(isatty() 가 True 를 반환하는 파일)은 줄 단위 버퍼링을 사용합니다. 다른 텍스트 파일은 위에 설명된 바이너리 파일용 정책을 사용합니다.

encoding 은 파일을 디코딩하거나 인코딩하는 데 사용되는 인코딩의 이름입니다. 이는 텍스트 모드에서만 사용해야 합니다. 기본 인코딩은 UTF-8이며, Python UTF-8 Mode 가 비활성화된 경우 기본값은 플랫폼에 따라 달라집니다(locale.getencoding() 이 반환하는 값). 파이썬이 지원하는 모든 text encoding 을 사용할 수 있으며, encoding="locale" 은 현재 로케일 인코딩을 명시적으로 지정합니다. 지원되는 인코딩 목록은 codecs 모듈을 참조하십시오.

errors 는 인코딩 및 디코딩 오류를 처리하는 방법을 지정하는 선택적 문자열입니다. 바이너리 모드에서는 사용할 수 없습니다. 다양한 표준 오류 처리기가 제공되며, codecs.register_error() 로 등록된 모든 오류 처리기 이름도 유효합니다. 표준 이름은 에러 처리기 에서 확인할 수 있습니다.

newline 은 스트림에서 줄 바꿈 문자를 파싱하는 방법을 결정합니다. 이 값은 None, '', '\n', '\r', '\r\n' 가 될 수 있습니다. 작동 방식은 다음과 같습니다.

스트림에서 입력을 읽을 때 newline 이 None 이면 유니버설 줄 바꿈 모드가 활성화됩니다. 입력의 줄은 '\n', '\r' 또는 '\r\n' 로 끝날 수 있으며, 호출자에게 반환되기 전에 '\n' 로 변환됩니다. 값이 '' 이면 유니버설 줄 바꿈 모드가 활성화되지만 줄 끝이 변환되지 않은 상태로 호출자에게 반환됩니다. 다른 유효한 값이면 입력 줄은 주어진 문자열에 의해서만 종료되며, 줄 끝은 변환되지 않은 상태로 호출자에게 반환됩니다.
스트림에 출력을 쓸 때 newline 이 None 이면, 작성된 모든 '\n' 문자가 시스템 기본 줄 구분자인 os.linesep 으로 변환됩니다. newline 이 '' 또는 '\n' 이면 변환이 수행되지 않습니다. newline 이 다른 유효한 값이면, 작성된 모든 '\n' 문자가 주어진 문자열로 변환됩니다.

closefd 이 False 이고 파일 이름 대신 파일 기술자가 제공된 경우, 파일이 닫힐 때 하부 파일 기술자가 열린 상태로 유지됩니다. 파일 이름이 제공된 경우 closefd 는 반드시 True (기본값)여야 하며, 그렇지 않으면 오류가 발생합니다.

opener 로 호출 가능한 객체(callable)를 전달하여 사용자 정의 오프너를 사용할 수 있습니다. 파일 객체의 하부 파일 기술자는 opener 를 (file, flags)로 호출하여 얻습니다. 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)  # 파일 기술자가 누수되지 않도록 함

The type of file object returned by the open() function depends on the mode. When open() is used to open a file in a text mode ('w', 'r', 'wt', 'rt', etc.), it returns a subclass of io.TextIOBase (specifically io.TextIOWrapper). When used to open a file in a binary mode with buffering, the returned class is a subclass of io.BufferedIOBase. The exact class varies: in read binary mode, it returns an io.BufferedReader; in write binary and append binary modes, it returns an io.BufferedWriter, and in read/write mode, it returns an io.BufferedRandom. When buffering is disabled, the raw stream, a subclass of io.RawIOBase, io.FileIO, is returned.

다음과 같은 파일 처리 모듈을 참조하십시오: fileinput, io (여기에는 open() 이 정의되어 있습니다), os, os.path, tempfile, 그리고 shutil.

인자 path, mode, flags 를 사용하여 auditing event open 을 발생시킵니다.

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

버전 3.3에서 변경:

opener 매개 변수가 추가되었습니다.
'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' 모드가 제거되었습니다.

버전 3.15에서 변경: 이제 플랫폼 의존적인 로케일 인코딩 대신 UTF-8이 기본 인코딩으로 사용됩니다(PEP 686).

ord(character, /)¶

문자의 순서 값을 반환합니다.

인자가 한 문자짜리 문자열인 경우, 해당 문자의 유니코드 코드 포인트를 반환합니다. 예를 들어, ord('a') 는 정수 97 을 반환하고 ord('€') (유로 기호)는 8364 를 반환합니다. 이는 chr() 의 역연산입니다.

인자가 길이가 1인 bytes 또는 bytearray 객체인 경우, 그 단일 바이트 값을 반환합니다. 예를 들어, ord(b'a') 는 정수 97 을 반환합니다.

pow(base, exp, mod=None)¶

base 의 exp 거듭제곱을 반환합니다. mod 가 있는 경우, base 의 exp 거듭제곱을 mod 로 나눈 나머지 값을 반환합니다(pow(base, exp) % mod 보다 더 효율적으로 계산됩니다). 두 개의 인자를 사용하는 pow(base, exp) 형식은 거듭제곱 연산자 base**exp 를 사용하는 것과 동일합니다.

피연산자가 서로 다른 유형이 섞인 내장 숫자 타입인 경우, 이항 산술 연산자에 대한 강제 변환 규칙이 적용됩니다. int 피연산자의 경우, 두 번째 인자가 음수가 아니면 결과는 피연산자와 동일한 유형을 가지며, 두 번째 인자가 음수인 경우 모든 인자가 float으로 변환되어 float 결과가 제공됩니다. 예를 들어, pow(10, 2) 는 100 을 반환하지만, pow(10, -2) 는 0.01 을 반환합니다. int 또는 float 유형의 음수 밑(base)과 정수가 아닌 지수(exponent)의 경우, 복소수 결과가 제공됩니다. 예를 들어, pow(-9, 0.5) 는 3j 에 가까운 값을 반환합니다. 반면, int 또는 float 유형의 음수 밑과 정수 지수의 경우, float 결과가 제공됩니다. 예를 들어, pow(-9, 2.0) 은 81.0 을 반환합니다.

int 피연산자 base 와 exp 의 경우, mod 가 있다면 mod 도 정수 타입이어야 하며 mod 는 0이 아니어야 합니다. mod 가 있고 exp 가 음수인 경우, base 는 mod 와 서로소여야 합니다. 이 경우, base 가 mod 에 대한 역원인 inv_base 를 사용하여 pow(inv_base, -exp, mod) 이 반환됩니다.

다음은 38 을 모듈로 97 에 대한 역수로 계산하는 예시입니다:

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

버전 3.8에서 변경: int 피연산자의 경우, pow 의 세 인자 형식에서 두 번째 인자가 음수일 수 있도록 허용하여 모듈러 역수 계산이 가능해졌습니다.

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

print(*objects, sep=' ', end='\n', file=None, flush=False)¶

objects 를 텍스트 스트림 file 에 출력하며, sep 로 구분하고 end 를 뒤에 붙입니다. sep, end, file 및 flush 가 있는 경우 반드시 키워드 인자로 제공되어야 합니다.

모든 비키워드 인자는 str() 과 같이 문자열로 변환되어 sep 로 구분하고 end 를 뒤에 붙여 스트림에 기록됩니다. sep 와 end 는 모두 문자열이어야 하며, 기본값을 사용하려면 None 으로 지정할 수 있습니다. objects 가 제공되지 않으면, print() 는 단순히 end 만 기록합니다.

file 인자는 write(string) 메서드를 가진 객체여야 합니다. 이 인자가 없거나 None 인 경우, sys.stdout 이 사용됩니다. 출력되는 인자들은 텍스트 문자열로 변환되므로, print() 는 바이너리 모드 파일 객체와 함께 사용할 수 없습니다. 이러한 경우에는 대신 file.write(...) 를 사용하십시오.

출력 버퍼링은 대개 file 에 의해 결정됩니다. 그러나 flush 가 True이면 스트림이 강제로 플러시됩니다.

버전 3.3에서 변경: flush 키워드 인자가 추가되었습니다.

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

속성(property) 어트리뷰트를 반환합니다.

fget 은 어트리뷰트 값을 가져오는 함수입니다. fset 은 어트리뷰트 값을 설정하는 함수입니다. fdel 은 어트리뷰트 값을 삭제하는 함수입니다. 그리고 doc 은 어트리뷰트에 대한 독스트링을 생성합니다.

전형적인 사용 예는 관리되는 어트리뷰트 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 는 게터를 호출하고, c.x = value 는 세터를 호출하며, del c.x 는 삭제자를 호출합니다.

If given, doc will be the docstring of the property attribute. Otherwise, the property will copy fget’s docstring (if it exists). This makes it possible to create read-only properties easily using @property as a decorator:

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

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

@property 데코레이터는 voltage() 메서드를 동일한 이름을 가진 읽기 전용 어트리뷰트의 “게터”로 변환하며, voltage 의 독스트링을 “Get the current voltage.”로 설정합니다.

@getter¶

@setter¶

@deleter¶

프로퍼티 객체는 데코레이터로 사용할 수 있는 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에서 변경: 프로퍼티 객체의 독스트링이 이제 쓰기 가능해졌습니다.

__name__¶: 프로퍼티의 이름을 담고 있는 어트리뷰트입니다. 프로퍼티의 이름은 런타임에 변경될 수 있습니다.

Added in version 3.13.

class range(stop, /)
class range(start, stop, step=1, /): 함수가 아니라, range 는 실제로는 범위 및 시퀀스 타입 — list, tuple, range 에 명시된 대로 불변 시퀀스 타입입니다.

repr(object, /)¶

객체의 출력 가능한 표현을 포함하는 문자열을 반환합니다. 많은 타입의 경우, 이 함수는 eval() 에 전달되었을 때 동일한 값을 가진 객체를 생성할 수 있는 유효한 파이썬 표현식과 같은 문자열을 반환하려고 시도하며, 그렇지 않으면 객체의 유형과 추가 정보(종종 객체의 이름과 주소 포함)를 포함하여 괄호로 둘러싸인 형식을 반환합니다. 클래스는 __repr__() 메서드를 정의하여 인스턴스에 대한 이 함수의 반환 값을 제어할 수 있습니다. sys.displayhook() 에 접근할 수 없는 경우, 이 함수는 RuntimeError 를 발생시킵니다.

이 클래스는 다음과 같이 평가할 수 있는 사용자 정의 표현을 가집니다:

class Person:
   def __init__(self, name, age):
      self.name = name
      self.age = age

   def __repr__(self):
      return f"Person({self.name!r}, {self.age!r})"

reversed(object, /)¶: Return a reverse iterator. The argument must be an object which has a __reversed__() method or supports the sequence protocol (the __len__() method and the __getitem__() method with integer arguments starting at 0).

round(number, ndigits=None)¶

number 을 소수점 아래 ndigits 정밀도로 반올림한 값을 반환합니다. ndigits 가 생략되거나 None 인 경우, 입력값에 가장 가까운 정수를 반환합니다.

round() 를 지원하는 내장 타입의 경우, 값은 소수점 아래 ndigits 만큼의 10의 거듭제곱에 가장 가까운 값으로 반올림됩니다. 두 배수가 똑같이 가까운 경우, 짝수 방향으로 반올림됩니다(예를 들어, round(0.5) 와 round(-0.5) 는 모두 0 이 되고, round(1.5) 는 2 가 됩니다). ndigits 에는 어떤 정수 값(양수, 0, 음수)도 올 수 있습니다. ndigits 가 생략되거나 None 인 경우 반환 값은 정수입니다. 그렇지 않은 경우, 반환 값은 number 와 동일한 유형을 가집니다.

일반 Python 객체 number 의 경우, round 는 number.__round__ 를 호출합니다.

참고

부동 소수점(float)에 대한 round() 의 동작은 예상과 다를 수 있습니다. 예를 들어, round(2.675, 2) 는 예상한 2.68 대신 2.67 을 반환합니다. 이는 버그가 아니라 대부분의 소수점이 부동 소수점(float)으로 정확하게 표현될 수 없기 때문에 발생하는 결과입니다. 자세한 내용은 부동 소수점 산술: 문제점 및 한계 를 참조하십시오.

class set(iterable=(), /)

새로운 set 객체를 반환하며, 선택적으로 iterable 에서 가져온 요소들을 포함할 수 있습니다. set 은 내장 클래스입니다. 이 클래스에 대한 설명은 집합 형 — set, frozenset 을 참조하십시오.

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

setattr(object, name, value, /)¶

이 함수는 getattr() 의 대응 함수입니다. 인자는 객체, 문자열, 임의의 값입니다. 문자열은 기존 어트리뷰트의 이름이거나 새로운 어트리뷰트의 이름이 될 수 있습니다. 이 함수는 객체가 허용하는 경우 해당 어트리뷰트에 값을 할당합니다. 예를 들어, setattr(x, 'foobar', 123) 은 x.foobar = 123 과 동일합니다.

name 은 객체가 별도로 강제하지 않는 한(예를 들어, 사용자 정의 __getattribute__() 또는 __slots__ 를 통한 경우), 이름(식별자 및 키워드) 에 정의된 Python 식별자일 필요가 없습니다. 식별자가 아닌 이름의 어트리뷰트는 점(.) 표기법을 사용하여 접근할 수 없지만, getattr() 등을 통해 접근할 수 있습니다.

참고

Since private name mangling happens at compilation time, one must manually mangle a private attribute’s (attributes with two leading underscores) name in order to set it with setattr().

class sentinel(name, /, *, repr=None)¶

새로운 고유한 sentinel 객체를 반환합니다. name 은 str 이어야 하며, 기본적으로 반환된 객체의 표현(representation)으로 사용됩니다.

>>> MISSING = sentinel("MISSING")
>>> MISSING
MISSING

선택적인 repr 인자를 사용하여 다른 표현을 지정할 수 있습니다.

>>> MISSING = sentinel("MISSING", repr="<MISSING>")
>>> MISSING
<MISSING>

sentinel 객체는 참(truthy)으로 평가되며 자기 자신과만 동일한 것으로 비교됩니다. 이 객체들은 is 연산자와 비교하도록 설계되었습니다.

sentinel 은 하위 클래스 생성을 지원하지 않습니다.

sentinel 객체의 얕은 복사(shallow copy)와 깊은 복사(deep copy)는 객체 자신을 반환합니다.

sentinel은 관례적으로 일치하는 이름의 변수에 할당됩니다. 이러한 방식으로 정의된 sentinel은 type hints 에서 사용할 수 있습니다.

MISSING = sentinel("MISSING")

def next_value(default: int | MISSING = MISSING):
    ...

sentinel 객체는 타입 표현식에서 사용되는 | 연산자를 지원합니다.

sentinel 객체가 모듈의 전역 범위에서 sentinel 이름과 일치하는 이름으로 배치되거나, 클래스 범위에서 sentinel의 qualified name 과 일치하는 이름으로 배치된 경우 Pickling 이 지원됩니다. 함수 범위 등 다른 위치에 정의된 sentinel은 pickle이 가능하지 않습니다. pickle 이후에도 sentinel의 정체성(identity)이 유지됩니다.

import pickle

PICKLABLE = sentinel("PICKLABLE")

assert pickle.loads(pickle.dumps(PICKLABLE)) is PICKLABLE

class Cls:
    PICKLABLE = sentinel("Cls.PICKLABLE")

assert pickle.loads(pickle.dumps(Cls.PICKLABLE)) is Cls.PICKLABLE

sentinel 객체는 다음과 같은 어트리뷰트를 가집니다:

__name__¶: sentinel의 이름.

__module__¶: sentinel이 생성된 모듈의 이름. 이 어트리뷰트는 쓰기가 가능합니다.

Added in version 3.15.

class slice(stop, /)¶

class slice(start, stop, step=None, /)

range(start, stop, step) 에 의해 지정된 인덱스 세트를 나타내는 slice 객체를 반환합니다. start 및 step 인자는 기본값이 None 입니다.

Slice objects are also generated when slicing syntax is used. For example: a[start:stop:step] or a[start:stop, i].

See itertools.islice() for an alternate version that returns an iterator.

start¶
stop¶
step¶: 이 읽기 전용 어트리뷰트들은 인자 값(또는 기본값)으로 설정됩니다. 특별한 기능은 없으나, NumPy 및 기타 제3자 패키지에서 사용됩니다.

버전 3.12에서 변경: 이제 slice 객체는 hashable 입니다(단, start, stop, step 이 hashable인 경우에 한함).

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

iterable 내의 항목들로부터 정렬된 새 리스트를 반환합니다.

두 개의 선택적 인자가 있으며, 반드시 키워드 인자로 지정해야 합니다.

key 는 iterable 의 각 요소에서 비교 키를 추출하는 데 사용되는 단일 인자의 함수를 지정합니다(예: key=str.lower). 기본값은 None 이며, 이 경우 요소를 직접 비교합니다.

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

구식 cmp 함수를 key 함수로 변환하려면 functools.cmp_to_key() 를 사용하십시오.

내장 sorted() 함수는 안정성(stable)이 보장됩니다. 정렬이 안정적이라는 것은 비교 결과가 같은 요소들의 상대적 순서를 변경하지 않음을 의미하며, 이는 여러 단계에 걸친 정렬(예: 부서별로 정렬한 후 급여 등급으로 정렬)에 유용합니다.

정렬 알고리즘은 항목 간 비교 시 < 만 사용합니다. __lt__() 메서드를 정의하는 것만으로도 정렬은 가능하지만, PEP 8 은 여섯 가지의 모든 rich comparisons 를 구현할 것을 권장합니다. 이는 다른 기초 메서드에 의존하는 max() 와 같은 다른 정렬 도구와 동일한 데이터를 사용할 때 발생할 수 있는 버그를 방지해 줍니다. 여섯 가지 비교를 모두 구현하면 반전된 __gt__() 메서드를 호출할 수 있는 혼합 타입 비교 시 발생할 수 있는 혼란을 방지하는 데도 도움이 됩니다.

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

@staticmethod¶

메서드를 정적 메서드(static method)로 변환합니다.

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

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

The @staticmethod form is a function decorator – see 함수 정의 for details.

정적 메서드는 클래스(예: C.f()) 또는 인스턴스(예: C().f())에서 모두 호출할 수 있습니다. 또한, 정적 메서드 descriptor 도 호출 가능하므로 클래스 정의 내에서(예: 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(*, encoding='utf-8', errors='strict')

class str(object)

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

class str(object, *, errors)

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

str is the built-in string class. For general information about strings, see 텍스트 시퀀스 유형 — str.

sum(iterable, /, start=0)¶

start*와 *iterable*의 요소들을 왼쪽에서 오른쪽으로 합산하여 합계를 반환합니다. *iterable*의 요소는 일반적으로 숫자이며, *start 값은 문자열이 될 수 없습니다.

일부 사례에서는 sum() 의 좋은 대안이 있습니다. 여러 문자열을 연결하는 권장되는 빠른 방법은 ''.join(sequence) 를 호출하는 것입니다. 확장된 정밀도를 가진 부동 소수점 값을 더하려면 math.fsum() 을 참조하십시오. 일련의 이터러블을 연결하려면 itertools.chain() 사용을 고려하십시오.

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

버전 3.12에서 변경: 부동 소수점 합산이 대부분의 빌드에서 더 높은 정확도와 더 나은 교환법을 제공하는 알고리즘으로 변경되었습니다.

버전 3.14에서 변경: 복소수 합산을 위한 특화 기능이 추가되었으며, 부동 소수점 합산과 동일한 알고리즘을 사용합니다.

class super¶

class super(type, object_or_type=None, /)

type 의 부모 또는 형제 클래스에 메서드 호출을 위임하는 프록시 객체를 반환합니다. 이는 클래스에서 오버라이드된 상속 메서스에 접근할 때 유용합니다.

object_or_type 은 검색할 method resolution order 를 결정합니다. 검색은 type 바로 뒤의 클래스부터 시작됩니다.

예를 들어, object_or_type 의 __mro__ 가 D -> B -> C -> A -> object 이고 type 의 값이 B 라면, super() 는 C -> A -> object 를 검색합니다.

object_or_type 에 해당하는 클래스의 __mro__ 어트리뷰트는 getattr() 와 super() 모두에서 사용되는 메서드 결정 순서를 나열합니다. 이 어트리뷰트는 동적이며 상속 계층이 업데이트될 때마다 변경될 수 있습니다.

두 번째 인자가 생략되면 반환되는 super 객체는 바인딩되지 않습니다. 두 번째 인자가 객체인 경우, isinstance(obj, type) 이 참이어야 합니다. 두 번째 인자가 타입인 경우, issubclass(type2, type) 이 참이어야 합니다(이 기능은 classmethod에서 유용합니다).

클래스의 일반적인 메서드 내에서 직접 호출될 때, 두 인자 모두 생략할 수 있습니다(“인자가 없는 super() “). 이 경우, type 은 둘러싸고 있는 클래스가 되고, obj 는 바로 인접한 함수(일반적으로 self)의 첫 번째 인자가 됩니다. (이 의미는 제너레이터 표현식을 포함하여 내포된 함수 내에서는 인자 없는 super() 가 예상대로 작동하지 않을 수 있다는 것입니다. 제너레이터 표현식은 내포된 함수를 암시적으로 생성합니다.)

super 에는 두 가지 전형적인 사용 사례가 있습니다. 단일 상속을 사용하는 클래스 계층 구조에서 super 를 사용하면 부모 클래스를 명시적으로 이름 지어 언급하지 않고 참조할 수 있어 코드를 더 유지 관리하기 쉽게 만듭니다. 이 사용법은 다른 프로그래밍 언어에서 super 를 사용하는 방식과 매우 유사합니다.

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

두 경우 모두, 일반적인 superclass 호출은 다음과 같은 형태입니다:

class C(B):
    def method(self, arg):
        super().method(arg)    # 이는 다음 내용과 동일하게 동작합니다:
                               # super(C, self).method(arg)

메서드 조회뿐만 아니라, super() 는 어트리뷰트 조회에도 작동합니다. 이를 활용하는 한 가지 사례는 부모 또는 형제 클래스에 있는 descriptors 를 호출하는 것입니다.

주의할 점은 super() 가 super().__getitem__(name) 과 같은 명시적인 점(dotted) 어트리뷰트 조회의 바인딩 과정의 일부로 구현되었다는 것입니다. 협력적 다중 상속을 지원하는 예측 가능한 순서로 클래스를 검색하기 위해 자체적인 __getattribute__() 메서드를 구현합니다. 따라서 super()[name] 과 같은 문장이나 연산자를 사용하는 암시적 조회에 대해서는 super() 가 정의되지 않습니다.

또한 인자가 없는 형식을 제외하면, super() 가 메서드 내에서만 사용되는 것은 아닙니다. 두 개의 인자를 사용하는 형식은 인자를 정확하게 지정하고 적절한 참조를 생성합니다. 인자가 없는 형식은 클래스 정의 내에서만 작동하는데, 이는 컴파일러가 정의 중인 클래스를 올바르게 가져오고 일반 메서드의 경우 현재 인스턴스에 접근하는 데 필요한 세부 정보를 채워주기 때문입니다.

super() 를 사용하여 협력적인 클래스를 설계하는 방법에 대한 실질적인 권장 사항은 guide to using super() 를 참조하십시오.

버전 3.14에서 변경: super 객체는 이제 pickleable 및 copyable 가능합니다.

class tuple(iterable=(), /): 함수가 아니라, tuple 은 실제로 튜플 및 시퀀스 타입 — list, tuple, range 에 명시된 것과 같이 불변 시퀀스 타입입니다.

class type(object, /)¶

class type(name, bases, dict, /, **kwargs)

인자가 하나인 경우, 객체 의 타입을 반환합니다. 반환값은 타입 객체이며 일반적으로 object.__class__ 가 반환하는 것과 동일한 객체입니다.

객체의 타입을 확인하는 데는 isinstance() 내장 함수를 사용하는 것이 권장됩니다. 이 함수는 서브클래스를 고려하기 때문입니다.

인자가 세 개인 경우, 새로운 타입 객체를 반환합니다. 이는 기본적으로 class 문의 동적 형태입니다. name 문자열은 클래스 이름이며 __name__ 어트리뷰트가 됩니다. bases 튜플은 베이스 클래스들을 포함하며 __bases__ 어트리뷰트가 됩니다. 만약 비어 있다면 모든 클래스의 최종 베이스인 object 가 추가됩니다. dict 딕셔너리는 클래스 본문의 어트리뷰트 및 메서드 정의를 포함하며, __dict__ 어트리뷰트가 되기 전에 복사되거나 래핑될 수 있습니다. 다음 두 문장은 동일한 type 객체를 생성합니다:

>>> class X:
...     a = 1
...
>>> X = type('X', (), dict(a=1))

참고:

세 개의 인자를 사용하는 형식에 제공되는 키워드 인자는 클래스 정의(metaclass 제외)에서 키워드가 사용되는 것과 동일한 방식으로 적절한 메타클래스 기구(일반적으로 __init_subclass__())에 전달됩니다.

class 문과 달리, 세 개의 인자를 사용하는 형식은 메타클래스의 __prepare__ 메서드를 호출하지 않습니다(참조: 클래스 이름 공간 준비하기). 적절한 메타클래스를 사용하여 동적으로 클래스를 생성하려면 types.new_class() 를 사용하십시오.

참고: 클래스 생성 커스터마이제이션.

버전 3.6에서 변경: type.__new__ 를 재정의하지 않는 type 의 서브클래스는 이제 객체의 형을 가져오기 위해 단일 인자 형식을 사용할 수 없습니다.

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

vars()¶

vars(object, /)

모듈, 클래스, 인스턴스 또는 __dict__ 어트리뷰트가 있는 기타 모든 객체에 대해 __dict__ 어트리뷰트를 반환합니다.

모듈 및 인스턴스와 같은 객체는 업데이트 가능한 __dict__ 어트리뷰스를 가집니다. 하지만 다른 객체들은 __dict__ 어트리뷰트에 대해 쓰기 제한이 있을 수 있습니다(예를 들어, 클래스는 직접적인 딕셔너리 업데이트를 방지하기 위해 types.MappingProxyType 을 사용합니다).

인자가 없는 경우, vars() 는 locals() 와 같이 작동합니다.

객체가 지정되었으나 __dict__ 어트리뷰트가 없는 경우(예를 들어, 그 클래스에서 __slots__ 어트리뷰트를 정의한 경우) TypeError 가 발생합니다.

버전 3.13에서 변경: 인자 없이 이 함수를 호출했을 때의 결과가 locals() 내장 함수에 설명된 대로 업데이트되었습니다.

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 번째 튜플은 인자로 전달된 각 이터러블의 i 번째 요소를 포함합니다.

zip() 을 생각하는 또 다른 방법은 행을 열로, 열을 행으로 바꾸는 것입니다. 이는 matrix transposition 와 유사합니다.

zip() 은 게으른(lazy) 방식입니다. 요소들은 이터러블이 순회될 때까지(예를 들어, for 루프나 list 로 감싸는 경우 등) 처리되지 않습니다.

고려해야 할 점 중 하나는 zip() 에 전달되는 이터러블들의 길이가 다를 수 있다는 것입니다. 때로는 설계에 의해, 때로는 이러한 이터러블을 준비하는 코드의 오류로 인해 발생합니다. Python은 이 문제를 처리하기 위한 세 가지 다른 접근 방식을 제공합니다.

By default, zip() stops when the shortest iterable is exhausted. It will ignore the remaining items in the longer iterables, cutting off the result to the length of the shortest iterable:
```
>>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))
[(0, 'fee'), (1, 'fi'), (2, 'fo')]
```
zip() 은 이터러블들이 동일한 길이를 가진다고 가정되는 경우에 자주 사용됩니다. 이러한 경우 strict=True 옵션을 사용하는 것이 권장됩니다. 출력 결과는 일반적인 zip() 과 동일합니다:
```
>>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
[('a', 1), ('b', 2), ('c', 3)]
```
Unlike the default behavior, it raises a ValueError if one iterable is exhausted before the others:
```
>>> 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-튜플의 이터레이터를 반환합니다. 인자가 없는 경우 빈 이터레이터를 반환합니다.

팁과 요령:

이터러블의 왼쪽에서 오른쪽으로의 평가 순서가 보장됩니다. 이를 통해 zip(*[iter(s)]*n, strict=True) 를 사용하여 데이터 시리즈를 n개 길이의 그룹으로 묶는 관용구를 사용할 수 있습니다. 이는 동일한 이터레이터를 n 번 반복하여 각 결과 튜플이 이터레이터에 대한 n 번의 호출 결과를 포함하도록 합니다. 이는 입력을 n 길이의 청크로 나누는 효과가 있습니다.

zip`은 ``*`() 연산자와 함께 리스트를 언팩(unzip)하는 데 사용될 수 있습니다:

>>> 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__ 에 할당함으로써) 교체할 수 있지만, 동일한 목적을 달성하기 위해 임포트 훅(import hooks, PEP 302 참조)을 사용하는 것이 훨씬 간단하며, 기본 임포트 구현을 사용한다고 가정하는 코드에 문제를 일으키지 않기 때문에 이렇게 하는 것은 강력히 권장되지 않습니다. __import__() 의 직접적인 사용 또한 importlib.import_module() 을 사용하는 것을 권장합니다.

이 함수는 모듈 name 을 임포트하며, 패키지 컨텍스트에서 해당 이름을 해석하는 방법을 결정하기 위해 주어진 globals 와 locals 를 활용할 수 있습니다. fromlist 는 name 으로 지정된 모듈에서 임포트해야 하는 객체나 하위 모듈의 이름을 제공합니다. 표준 구현은 locals 인자를 전혀 사용하지 않으며, globals 는 단지 import 문의 패키지 컨텍스트를 결정하는 데에만 사용합니다.

level 은 절대 경로 임포트 또는 상대 경로 임포트 중 어느 것을 사용할지 지정합니다. 0 (기본값)은 절대 임포트만 수행함을 의미합니다. level 의 양수 값은 __import__() 를 호출하는 모듈의 디렉토리를 기준으로 탐색할 상위 디렉토리의 수를 나타냅니다(자세한 내용은 PEP 328 을 참조하십시오).

name 변수가 package.module 형태일 때, 일반적으로 name 에 의해 명명된 모듈이 아니라 최상위 패키지(첫 번째 마침표 이전의 이름)가 반환됩니다. 그러나 비어 있지 않은 fromlist 인자가 제공되는 경우에는 name 에 의해 명명된 모듈이 반환됩니다.

예를 들어, import spam 문장은 다음과 유사한 바이트코드로 결과가 나옵니다:

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

import spam.ham 문장은 다음 호출로 이어집니다:

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

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

반면에, from spam.ham import eggs, sausage as saus 문장은 다음을 결과로 나타냅니다:

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

여기서 spam.ham 모듈이 __import__() 에서 반환됩니다. 이 객체로부터 임포트할 이름들을 가져와 각각의 이름에 할당합니다.

단순히 이름을 통해 모듈(패키지 내부에 있을 수 있음)을 임포트하려면 importlib.import_module() 을 사용하십시오.

버전 3.3에서 변경: level 의 음수 값은 더 이상 지원되지 않습니다(이로 인해 기본값이 0으로 변경되었습니다).

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

각주

내장 함수¶

분실물 보관소