☰ Menu Python

☰ Menu

내장 함수

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

내장 함수
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__() 를 구현하는 객체일 수 있습니다. 인자가 복소수이면 그 크기가 반환됩니다.

aiter(async_iterable, /)

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

참고: iter() 와 달리, aiter() 는 인자가 2개인 변형이 없습니다.

Added in version 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, /)

대기(await) 시, 주어진 비동적 이터레이터 에서 다음 항목을 반환하며, 인자가 제공되었고 이터레이터가 소진된 경우에는 *default*를 반환합니다.

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

이 함수는 async_iterator 의 __anext__() 메서드를 호출하여 어웨이터블 을 반환합니다. 이를 대기(await)하면 이터레이터의 다음 값을 반환하며, *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 이스케이프를 사용하여 처리합니다. 이는 Python 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 중 하나를 반환합니다. 인자는 표준 truth testing procedure 에 따라 변환됩니다. 인자가 거짓이거나 생략된 경우 False 를 반환하며, 그렇지 않으면 True 를 반환합니다. bool 클래스는 int 의 서브클래스이며(참조: 숫자 형 — int, float, complex), 더 이상 서브클래싱할 수 없습니다. 인스턴스는 False 와 True 뿐입니다(참조: 불린 타입 - 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을 인자로 감사 이벤트(auditing event) builtins.breakpoint를 발생시킵니다.

Added in version 3.7.

class bytearray(source=b'')

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

새로운 바이트 배열을 돌려줍니다. bytearray 클래스는 0 <= x < 256 범위에 있는 정수의 가변 시퀀스입니다. bytes 형이 가진 대부분의 메서드뿐만 아니라 (바이트열 과 바이트 배열 연산 를 보세요), 가변 시퀀스 형 에 기술된 가변 시퀀스의 일반적인 메서드 대부분을 갖고 있습니다.

선택적 source 매개변수는 몇 가지 다른 방법으로 배열을 초기화하는 데 사용할 수 있습니다:

• 문자열 이면, 반드시 encoding 매개변수도 제공해야 합니다 (그리고 선택적으로 errors 도); 그러면 bytearray() 는 str.encode() 를 사용하여 문자열을 바이트로 변환합니다.

• 정수 면, 배열은 그 크기를 갖고, 널 바이트로 초기화됩니다.

• 버퍼 인터페이스를 제공하는 객체면, 객체의 읽기 전용 버퍼가 바이트 배열을 초기화하는 데 사용됩니다.

• 이터러블 이면, 범위 0 <= x < 256 의 정수를 제공하는 이터러블이어야 하고, 그 값들이 배열의 초기 내용물로 사용됩니다.

인자가 없으면 크기 0의 배열이 만들어집니다.

바이너리 시퀀스 형 — bytes, bytearray, memoryview와 바이트 배열 객체 도 보세요.

class bytes(source=b'')

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

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

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

바이트열 객체는 리터럴을 사용하여 만들 수도 있습니다 (문자열과 바이트열 리터럴 를 보세요).

바이너리 시퀀스 형 — bytes, bytearray, memoryview, 바이트열 객체 및 바이트열 과 바이트 배열 연산 도 보세요.

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++ 또는 자바의 정적 메서드와 다릅니다. 그것들을 원하면, 이 섹션의 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 어트리뷰트로 찾을 수 있습니다. 컴파일러 플래그는 PyCF_ 접두사로 ast 모듈에서 찾을 수 있습니다.

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

선택적 인자 module 은 모듈 이름을 지정합니다. 이는 모듈 이름에 따라 filter 구문을 사용하여 경고를 명확하게 필터링하기 위해 필요합니다.

컴파일된 소스가 유효하지 않으면 이 함수는 SyntaxError 또는 ValueError 를 발생시킵니다.

파이썬 코드를 AST 표현으로 파싱하려면, ast.parse() 를 보세요.

source와 filename을 인자로 감사 이벤트(auditing event) compile을 발생시킵니다. 이 이벤트는 묵시적 컴파일로 인해 발생할 수도 있습니다.

참고

'single' 또는 'eval' mode로 여러 줄 코드를 가진 문자열을 컴파일할 때, 적어도 하나의 개행 문자로 입력을 끝내야 합니다. 이것은 code 모듈에서 문장이 불완전한지 완전한지를 쉽게 탐지하게 하기 위함입니다.

경고

파이썬의 AST 컴파일러에서 스택 깊이 제한으로 인해, AST 객체로 컴파일할 때 충분히 크고 복잡한 문자열로 파이썬 인터프리터가 크래시를 일으키도록 만들 수 있습니다.

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

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

Added in version 3.8: 이제 ast.PyCF_ALLOW_TOP_LEVEL_AWAIT를 flags로 전달하여 최상위 수준 await, async for 및 async with를 지원할 수 있습니다.

Added in version 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 과 같이 수치 변환 역할을 수행합니다. 일반적인 파이썬 객체 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, /)

이 함수는 setattr() 와 관련이 있습니다. 인자는 객체와 문자열입니다. 문자열은 객체의 속성 중 하나의 이름이어야 합니다. 이 함수는 객체가 허용하는 경우 명명된 속성을 삭제합니다. 예를 들어, delattr(x, 'foobar') 는 del x.foobar 와 동일합니다. name 은 파이썬 식별자일 필요가 없습니다(참조: 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)

열거 객체를 돌려줍니다. 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(source, /, globals=None, locals=None)

매개변수:

• source (str | code object) – 파이썬 표현식.

• globals (dict | frozendict | None) – 전역 네임스페이스(기본값: None).

• locals (mapping | None) – 지역 네임스페이스(기본값: None).

반환:

평가된 표현식의 결과.

발생:

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

경고

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

The source argument is parsed and evaluated as a Python expression (technically speaking, a condition 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

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

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

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

리터럴만 포함된 표현식이 있는 문자열을 평가하는 함수는 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] 코드 객체인 경우 그대로 실행됩니다. 모든 경우에 실행되는 코드는 파일 입력으로서 유효해야 합니다(참조 설명서의 파일 입력 섹션 참조). exec() 함수에 전달된 코드 내에서도 함수 정의 밖에서는 nonlocal, yield, 그리고 return 문을 사용할 수 없다는 점에 유의하십시오. 반환값은 None 입니다.

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

참고

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

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

closure 인자는 클로저(cellvar의 튜플)를 지정합니다. 이는 object 가 자유 (클로저) 변수 를 포함하는 코드 객체인 경우에만 유효합니다. 튜플의 길이는 코드 객체의 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 이 참인 iterable 의 요소들로부터 반복자를 생성합니다. iterable 은 시퀀스, 반복을 지원하는 컨테이너 또는 반복자일 수 있습니다. function 이 None 인 경우 항등 함수가 가정되며, 즉 iterable 에서 거짓인 모든 요소가 제거됩니다.

filter(function, iterable) 는 function이 None 이 아닐 때 제너레이터 표현식 (item for item in iterable if function(item)) 과, None 일 때 (item for item in iterable if item) 와 동등함에 유의하세요.

function 이 거짓을 반환하는 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=(), /)

iterable 에서 가져온 요소를 포함하는 새로운 frozenset 객체를 반환합니다. 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 은 반드시 파이썬 식별자일 필요는 없습니다(참고: 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 가 파이썬 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 인자로 감사 이벤트(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이 올 수 있고, 공백으로 둘러싸여 있을 수 있으며, 숫자 사이에 밑줄(_)이 포함될 수 있습니다.

base-n 정수 문자열은 각 요소가 0부터 n-1까지의 값을 나타내는 자릿수를 포함합니다. 값 0–9는 임의의 유니코드 숫자 십진 숫자로 표현할 수 있습니다. 값 10–35는 a 에서 z (또는 A 에서 Z)로 표현할 수 있습니다. 기본 base 는 10입니다. 허용되는 베이스는 0 및 2–36입니다. Base-2, -8, 및 -16 문자열은 코드 내 정수 리터럴과 마찬가지로 선택적으로 0b/0B, 0o/0O, 또는 0x/0X 접두사를 붙일 수 있습니다. base 0의 경우, 해당 문자열은 실제 베이스가 접두사에 의해 결정된 2, 8, 10 또는 16인 방식과 유사하게 integer literal in code 와 해석됩니다. 또한 Base 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에서 변경: 첫 번째 매개변수가 이제 위치 전용입니다.

버전 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 가 타입 객체들의 튜플(또는 재귀적으로 다른 그러한 튜플들)이나 여러 타입의 유니언 타입 인 경우, object 가 해당 타입 중 하나라도 인스턴스이면 True 를 반환합니다. classinfo 가 타입 또는 타입들의 튜플이 아닌 경우 TypeError 예외가 발생합니다. 이전 단계의 검사가 성공한 경우 잘못된 타입에 대해 TypeError 가 발생하지 않을 수 있습니다.

버전 3.10에서 변경: classinfo 는 유니언 타입 일 수 있습니다.

issubclass(cls, classinfo, /)

cls 가 classinfo 의 하위 클래스(직접, 간접 또는 virtual)인 경우 True 를 반환합니다. 클래스는 자기 자신의 하위 클래스로 간주됩니다. classinfo 는 클래스 객체들의 튜플(또는 재귀적으로 다른 그러한 튜플들)이나 유니언 타입 일 수 있으며, 이 경우 cls 가 classinfo 내의 어떤 항목이라도 하위 클래스인 경우 True 를 반환합니다. 그 외의 모든 경우에 TypeError 예외가 발생합니다.

버전 3.10에서 변경: classinfo 는 유니언 타입 일 수 있습니다.

iter(iterable, /)

iter(callable, sentinel, /)

어떤 iterator 객체를 반환합니다. 첫 번째 인자는 두 번째 인자의 유무에 따라 매우 다르게 해석됩니다. 두 번째 인자가 없는 경우, 단일 인자는 iterable 프로토콜(__iter__() 메서드)을 지원하는 컬렉션 객체이거나, 시퀀스 프로토콜(0부터 시작하는 정수 인자를 가진 __getitem__() 메서드)을 지원해야 합니다. 이 중 어느 것도 지원하지 않으면 TypeError 가 발생합니다. 두 번째 인자인 sentinel 이 주어진 경우, 첫 번째 인자는 호출 가능한 객체여야 합니다. 이 경우 생성된 이터레이터는 __next__() 메서드가 호출될 때마다 매개변수 없이 callable 을 호출하며, 반환된 값이 sentinel 과 같으면 StopIteration 이 발생하고 그렇지 않으면 해당 값이 반환됩니다.

이터레이터 형 도 보세요.

두 번째 형태의 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(object, /)

객체의 길이 (항목 수)를 돌려줍니다. 인자는 시퀀스 (문자열, 바이트열, 튜플, 리스트 또는 range 같은) 또는 컬렉션 (딕셔너리, 집합 또는 불변 집합 같은) 일 수 있습니다.

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

class list(iterable=(), /)

함수이기보다, 리스트 와 시퀀스 형 — list, tuple, range 에 문서화 된 것처럼, list 는 실제로는 가변 시퀀스 형입니다.

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 은 그만큼의 인자를 받아야 하며 모든 이터러블의 항목에 병렬로 적용됩니다. 여러 이터러블이 있는 경우, 이터레이터는 가장 짧은 이터러블이 소진될 때 중지됩니다. strict 가 True 이고 다른 이터러블보다 먼저 하나가 소진되면 ValueError 가 발생합니다. 함수 입력이 이미 인자 튜플로 구성된 경우, itertools.starmap() 을 참조하십시오.

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

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

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

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

iterable 에서 가장 큰 항목이나 두 개 이상의 인자 중 가장 큰 것을 돌려줍니다.

하나의 위치 인자가 제공되면, 그것은 이터러블 이어야 합니다. iterable에서 가장 큰 항목을 돌려줍니다. 두 개 이상의 위치 인자가 제공되면, 위치 인자 중 가장 큰 것을 돌려줍니다.

선택적 키워드-전용 인자가 두 개 있습니다. key 인자는 list.sort() 에 사용되는 것처럼 단일 인자 순서 함수를 지정합니다. default 인자는 제공된 iterable이 비어있는 경우 돌려줄 객체를 지정합니다. iterable이 비어 있고 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)

지정된 인자로부터 만들어진 “메모리 뷰” 객체를 돌려줍니다. 자세한 정보는 메모리 뷰 를 보세요.

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

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

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

iterable 에서 가장 작은 항목이나 두 개 이상의 인자 중 가장 작은 것을 돌려줍니다.

하나의 위치 인자가 제공되면, 그것은 이터러블 이어야 합니다. iterable에서 가장 작은 항목을 돌려줍니다. 두 개 이상의 위치 인자가 제공되면, 위치 인자 중 가장 작은 것을 돌려줍니다.

선택적 키워드-전용 인자가 두 개 있습니다. key 인자는 list.sort() 에 사용되는 것처럼 단일 인자 순서 함수를 지정합니다. default 인자는 제공된 iterable이 비어있는 경우 돌려줄 객체를 지정합니다. iterable이 비어 있고 default 가 제공되지 않으면 ValueError 가 발생합니다.

여러 항목이 최솟값이면, 함수는 처음 만난 항목을 돌려줍니다. 이것은 sorted(iterable, key=keyfunc)[0] 와 heapq.nsmallest(1, iterable, key=keyfunc) 같은 다른 정렬 안정성 보존 도구와 일관성을 유지합니다.

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

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

next(iterator, /)

next(iterator, default, /)

그의 __next__() 메서드를 호출하여 iterator 에서 다음 항목을 가져옵니다. default 가 제공된 경우, 이터레이터가 소진되면 해당 값이 반환되고 그렇지 않으면 StopIteration 이 발생합니다.

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)

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

file 은 열을 파일의 경로명(현재 작업 디렉터리에 대한 절대 또는 상대 경로)을 제공하거나 래핑될 파일의 정수 파일 디스크립터를 제공하는 path-like object 입니다. (파일 디스크립터가 제공된 경우, closefd 가 False 로 설정되지 않는 한 반환된 I/O 객체가 닫힐 때 해당 파일 디스크립터도 닫힙니다.)

mode 는 파일이 열리는 모드를 지정하는 선택적 문자열입니다. 기본값은 텍스트 모드에서 읽기 전용을 의미하는 'r' 입니다. 다른 일반적인 값은 쓰기를 위한 'w' (이미 존재하는 경우 파일을 절단), 독점 생성을 위한 'x', 추가를 위한 'a' (일부 유닉스 시스템에서는 현재 탐색 위치와 상관없이 모든 쓰기를 파일 끝에 추가)가 있습니다. 텍스트 모드에서 encoding 이 지정되지 않으면 사용되는 인코딩은 플랫폼에 따라 달라집니다. 현재 로컬 인코딩을 가져오기 위해 locale.getencoding() 이 호출됩니다. (원시 바이트를 읽고 쓰려면 바이너리 모드를 사용하고 encoding 을 지정하지 마십시오.) 사용 가능한 모드는 다음과 같습니다:

문자	의미
'r'	읽기용으로 엽니다 (기본값)
'w'	쓰기용으로 엽니다, 파일을 먼저 자릅니다.
'x'	독점적인 파일 만들기용으로 엽니다, 이미 존재하는 경우에는 실패합니다.
'a'	쓰기용으로 열기, 파일이 존재하는 경우 끝에 추가
'b'	바이너리 모드
't'	텍스트 모드 (기본값)
'+'	갱신(읽기 및 쓰기)용으로 엽니다

기본 모드는 'r'``입니다 (텍스트 읽기용이며, ``'rt'``의 동의어입니다). 모드 ``'w+'``와 ``'w+b'``는 파일을 열고 잘라냅니다. ``'r+'``와 ``'r+b' 모드는 파일 내용을 자르지 않고 엽니다.

개요 에서 언급했듯이, 파이썬은 바이너리와 텍스트 I/O를 구별합니다. 바이너리 모드 (mode 인자에 'b' 를 포함합니다)로 열린 파일은 내용을 디코딩 없이 bytes 객체로 돌려줍니다. 텍스트 모드 (기본값, 또는 mode 인자에 't' 가 포함될 때)에서는, 파일의 내용이 str로 반환되는데, 바이트열이 플랫폼 의존적인 인코딩이나 주어진 encoding 을 사용해서 먼저 디코드 됩니다.

참고

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

buffering is an optional integer used to set the buffering policy. Pass 0 to switch buffering off (only allowed in binary mode), 1 to select line buffering (only usable when writing in text mode), and an integer > 1 to indicate the size in bytes of a fixed-size chunk buffer. Note that specifying a buffer size this way applies for binary buffered I/O, but TextIOWrapper (i.e., files opened with mode='r+') would have another buffering. To disable buffering in TextIOWrapper, consider using the write_through flag for io.TextIOWrapper.reconfigure(). When no buffering argument is given, the default buffering policy works as follows:

• 바이너리 파일은 고정 크기 청크로 버퍼링됩니다. 장치 블록 크기를 사용할 수 있는 경우 버퍼의 크기는 max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE) 입니다. 대부분의 시스템에서 버퍼 길이는 일반적으로 128킬로바이트입니다.

• “대화형” 텍스트 파일 (isatty() 가 True 를 돌려주는 파일)은 줄 버퍼링을 사용합니다. 다른 텍스트 파일은 바이너리 파일에 대해 위에서 설명한 정책을 사용합니다.

encoding 은 파일을 디코딩하거나 인코딩하는 데 사용되는 인코딩 이름입니다. 이는 텍스트 모드에서만 사용해야 합니다. 기본 인코딩은 플랫폼 종속적이지만( locale.getencoding() 이 반환하는 것), 파이썬이 지원하는 모든 text encoding 을 사용할 수 있습니다. 지원되는 인코딩 목록은 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 로 전달하여 커스텀 오프너를 사용할 수 있습니다. 파일 객체를 위한 하위 파일 디스크립터는 opener 를 (file, flags) 로 호출해서 얻습니다. opener 는 열린 파일 디스크립터를 반환해야 합니다 (opener 에 os.open 을 전달하는 것은 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 과 같은 파일 처리 모듈을 참조하십시오.

인자 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 를 구현하는 객체를 받아들이도록 지원이 추가되었습니다.

• 윈도우에서, 콘솔 버퍼를 열면 io.FileIO 가 아닌 io.RawIOBase 의 서브 클래스가 반환될 수 있습니다.

버전 3.11에서 변경: 'U' 모드가 삭제되었습니다.

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)에 정수가 아닌 지수가 적용되면 복소수 결과가 반환됩니다. 예를 들어, 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와 서로 소(relatively prime)여야 합니다. 이 경우, pow(inv_base, -exp, mod)가 반환되며, 여기서 inv_base는 base 모듈로 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 를 뒤에 붙여 텍스트 스트림 file 에 출력합니다. 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)

프로퍼티 어트리뷰트를 돌려줍니다.

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 는 삭제자를 호출합니다.

제공된 경우, doc 은 프로퍼티 어트리뷰트의 독스트링이 됩니다. 그렇지 않으면 프로퍼티는 fget 의 독스트링(존재하는 경우)을 복사합니다. 이를 통해 @property 를 데코레이터 로 사용하여 읽기 전용 프로퍼티를 쉽게 생성할 수 있습니다:

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

    @property
    def voltage(self):
        """현재 전압을 가져옵니다."""
        return self._voltage

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

@getter

@setter

@deleter

프로퍼티 객체는 데코레이터로 사용할 수 있는 getter, setter, deleter 메서드를 가지며, 이는 데코레이트된 함수를 해당 액세서(accessor) 함수로 설정하여 프로퍼티의 복사본을 생성합니다. 이는 다음 예제로 가장 잘 설명할 수 있습니다:

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

    @property
    def x(self):
        """나는 'x' 프로퍼티입니다."""
        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, /)

반전된 이터레이터 를 반환합니다. 인자는 __reversed__() 메서드를 가지거나 시퀀스 프로토콜(0 부터 시작하는 정수 인자를 가진 __len__() 및 __getitem__() 메서드)을 지원하는 객체여야 합니다.

round(number, ndigits=None)

number 를 소수점 다음에 ndigits 정밀도로 반올림한 값을 돌려줍니다. ndigits 가 생략되거나 None 이면, 입력에 가장 가까운 정수를 돌려줍니다.

round() 을 지원하는 내장 타입의 경우, 값이 10의 -(ndigits) 제곱에 가장 가까운 배수로 반올림됩니다. 두 배수가 동일하게 가깝다면 짝수 쪽으로 반올림됩니다(예를 들어, round(0.5) 와 round(-0.5) 는 모두 0 이며, round(1.5) 는 2 입니다). ndigits 에는 양수, 0, 음수를 포함한 모든 정수 값이 유효합니다. ndigits 가 생략되거나 None 인 경우 반환 값은 정수입니다. 그렇지 않은 경우, 반환 값은 number 와 동일한 형을 가집니다.

일반적인 파이썬 객체 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 과 동일합니다.

객체가 커스텀 __getattribute__() 또는 __slots__ 를 통해 해당 제약을 강제하지 않는 한, name 은 이름(식별자 및 키워드) 에 정의된 파이썬 식별자일 필요가 없습니다. 이름이 식별자가 아닌 어트리뷰트는 점(.) 표기법으로 접근할 수 없지만, getattr() 등을 통해 접근할 수 있습니다.

참고

비공개 이름 뒤섞기 가 컴파일 시간에 발생하기 때문에, setattr() 을 사용하여 비공개 어트리뷰트(앞에 밑줄 두 개가 붙은 어트리뷰트)의 이름을 설정하려면 수동으로 이름을 뒤섞어 주어야 합니다.

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

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

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

선택적 인자인 repr 은 다른 표현을 지정하는 데 사용할 수 있습니다:

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

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

sentinel 은 서브클래싱을 지원하지 않습니다.

센티널 객체의 얕은 복사 및 깊은 복사는 해당 객체 자신을 반환합니다.

센티널은 관례적으로 일치하는 이름을 가진 변수에 할당됩니다. 이러한 방식으로 정의된 센티널은 형 힌트 에서 사용할 수 있습니다:

MISSING = sentinel("MISSING")

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

Sentinel 객체는 타입 표현식에서 사용하기 위해 | 연산자를 지원합니다.

센티널의 이름과 일치하는 이름으로 모듈의 전역 범위에 배치된 센티널 객체와, 센티널의 한정 이름 과 일치하는 이름으로 클래스 범위에 배치된 센티널은 Pickling 이 지원됩니다. 함수 범위에서 정의된 센티널 등 다른 센티널은 피클링할 수 없습니다. 피클링 후에도 센티널의 정체성이 유지됩니다:

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

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

__name__

센티널의 이름입니다.

__module__

센티널이 생성된 모듈의 이름입니다. 이 어트리뷰트는 쓰기 가능합니다.

Added in version 3.15.

class slice(stop, /)

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

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

슬라이스 객체는 슬라이싱 문법 을 사용할 때도 생성됩니다. 예를 들어: a[start:stop:step] 또는 a[start:stop, i].

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

start

stop

step

이 읽기 전용 어트리뷰트들은 인자 값(또는 기본값)으로 설정됩니다. 다른 명시적인 기능은 없으나, NumPy 및 기타 제3자 패키지에서 사용됩니다.

버전 3.12에서 변경: Slice objects are now hashable (provided start, stop, and step are 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 에서는 여섯 가지의 모든 풍부한 비교 를 구현할 것을 권장합니다. 이는 다른 기본 방식을 사용하는 max() 와 같은 다른 순서 도구에 동일한 데이터를 사용할 때 발생할 수 있는 버그를 방지하는 데 도움이 됩니다. 여섯 가지 비교를 모두 구현하면, 반영된 __gt__() 메서드를 호출할 수 있는 혼합형 타입 비교에서 발생할 수 있는 혼란도 방지할 수 있습니다.

정렬 예제와 간단한 정렬 자습서는 정렬 기법 를 보세요.

@staticmethod

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

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

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

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

정적 메서드는 클래스(예: C.f()) 또는 인스턴스(예: C().f())에서 호출할 수 있습니다. 또한 정적 메서드 디스크립터 도 호출 가능하므로, 클래스 정의 내에서 사용할 수 있습니다(예: f()).

파이썬의 정적 메서드는 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 은 내장 문자열 클래스 입니다. 문자열에 대한 일반적인 정보는 텍스트 시퀀스 형 — str 를 보세요.

sum(iterable, /, start=0)

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

일부 사용 사례에서는 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 은 검색할 메서드 결정 순서 를 결정합니다. 탐색은 type 바로 뒤의 클래스부터 시작됩니다.

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

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

두 번째 인자가 생략되면, 반환되는 슈퍼 객체는 연결되지 않았습니다(unbound). 두 번째 인자가 객체면, isinstance(obj, type) 는 참이어야 합니다. 두 번째 인자가 형이면, issubclass(type2, type) 는 참이어야 합니다 (이것은 클래스 메서드에 유용합니다).

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

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

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

두 경우 모두, 일반적인 슈퍼 클래스 호출은 이런 식입니다:

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

메서드 조회 외에, super()는 어트리뷰트 조회에도 작동합니다. 한가지 가능한 사용 사례는 부모나 형제 클래스에 있는 디스크립터를 호출하는 것입니다.

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

또한, 인자가 없는 형식을 제외하고는, super() 는 메서드 내부에서만 사용하도록 제한되지 않는다는 점에 유의하세요. 두 개의 인자 형식은 인자를 정확하게 지정하고 적절한 참조를 만듭니다. 인자가 없는 형식은 클래스 정의 내에서만 작동하는데, 컴파일러가 정의되고 있는 클래스를 올바르게 가져오고 일반 메서드에서 현재 인스턴스에 액세스하는 데 필요한 세부 정보를 채우기 때문입니다.

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

버전 3.14에서 변경: super 객체는 이제 피클 가능 및 복사 가능 입니다.

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__())에 전달됩니다.

클래스 생성 커스터마이제이션 도 보세요.

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

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

vars()

vars(object, /)

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

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

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

객체가 지정되었지만 __dict__ 어트리뷰트가 없으면 TypeError 예외가 발생합니다 (예를 들어, 해당 클래스가 __slots__ 어트리뷰트를 정의하면).

버전 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() 을 생각하는 또 다른 방법은 행을 열로, 열을 행으로 바꾸는 것입니다. 이는 행렬의 전치 와 유사합니다.

zip() 은 게으른(lazy) 방식입니다: 요소들은 ;예를 들어, for 루프에 의해 또는 list 로 래핑되는 등; 이터러블이 반복될 때까지 처리되지 않습니다.

고려해야 할 한 가지는 zip() 에 전달되는 이터러블의 길이가 다를 수 있다는 점입니다. 이는 때로는 설계상으로, 때로는 이러한 이터러블을 준비한 코드의 버그로 인해 발생할 수 있습니다. 파이썬은 이 문제를 해결하기 위한 세 가지 다른 접근 방식을 제공합니다:

• 기본적으로, zip() 은 가장 짧은 이터러블이 소진되면 멈춥니다. 더 긴 이터러블의 남은 항목들은 무시되며, 결과는 가장 짧은 이터러블의 길이만큼 잘립니다:

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

  기본 동작과 달리, 다른 이터러블보다 하나가 먼저 소진되면 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-튜플의 이터레이터를 반환합니다. 인자가 없는 경우, 빈 이터레이터를 반환합니다.

팁과 요령:

• 이터러블의 왼쪽에서 오른쪽으로 평가되는 순서가 보장됩니다. 이를 통해 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() 과 달리 일상적인 파이썬 프로그래밍에서는 필요하지 않은 고급 함수입니다.

이 함수는 import 문에 의해 호출됩니다. import 문의 의미를 변경하기 위해 대체할 수 있습니다 (builtins 모듈을 임포트하고 builtins .__ import__ 에 대입합니다). 그러나 그렇게 하지 말 것을 강하게 권고하는데, 보통 같은 목적을 달성하는데 임포트 훅(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는 이제 무시됩니다.

각주

[1]

파서는 유닉스 스타일의 줄 종료 규칙만 받아들이는 것에 주의하세요. 파일에서 코드를 읽는 경우, 줄 넘김 변환 모드를 사용해서 윈도우나 맥 스타일 줄 넘김을 변환해야 합니다.

분실물 보관소