내장 함수¶

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

내장 함수
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, /)¶: Return the absolute value of a number. The argument may be an integer, a floating-point number, or an object implementing __abs__(). If the argument is a complex number, its magnitude is returned.

aiter(async_iterable, /)¶

asynchronous iterable 에 대한 asynchronous iterator 를 반환합니다. 이는 x.__aiter__() 를 호출하는 것과 같습니다.

Note: Unlike iter(), aiter() has no 2-argument variant.

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

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

This is the async variant of the next() builtin, and behaves similarly.

This calls the __anext__() method of async_iterator, returning an awaitable. Awaiting this returns the next value of the iterator. If default is given, it is returned if the iterator is exhausted, otherwise StopAsyncIteration is raised.

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, /)¶: As repr(), return a string containing a printable representation of an object, but escape the non-ASCII characters in the string returned by repr() using \x, \u, or \U escapes. This generates a string similar to that returned by repr() in Python 2.

bin(integer, /)¶

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

See also enum.bin() to represent negative values as twos-complement.

자세한 내용은 format()을 보세요.

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

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

breakpoint(*args, **kws)¶

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

By default, the behavior of breakpoint() can be changed with the PYTHONBREAKPOINT environment variable. See sys.breakpointhook() for usage details.

Note that this is not guaranteed if sys.breakpointhook() has been replaced.

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

Return a new “bytes” object which is an immutable sequence of integers in the range 0 <= x < 256. bytes is an immutable version of bytearray – it has the same non-mutating methods and the same indexing and slicing behavior.

따라서 생성자 인자는 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() 의 역함수입니다.

The valid range for the argument is from 0 through 1,114,111 (0x10FFFF in base 16). ValueError will be raised if it is outside that range.

@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에서 폐지되었고, 버전 3.13에서 제거됩니다: Class methods can no longer wrap other descriptors such as 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 구문 문법이 필요할 때 사용됩니다.

This function raises SyntaxError or ValueError if the compiled source is invalid.

파이썬 코드를 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 number)로 변환하거나, 실수와 허수 부분으로부터 복소수를 생성합니다.

예제

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

If the argument is a number, the constructor serves as a numeric conversion like int and float. For a general Python object x, complex(x) delegates to x.__complex__(). If __complex__() is not defined then it falls back to __float__(). If __float__() is not defined then it falls back to __index__().

두 개의 인자가 제공되거나 키워드 인자가 사용되는 경우, 각 인자는 모든 숫자형(복소수 포함)이 될 수 있습니다. 두 인자 모두 실수인 경우, 실성분 real 과 허성분 imag 을 가진 복소수를 반환합니다. 두 인자 모두 복소수인 경우, 실성분 real.real-imag.imag 및 허성분 real.imag+imag.real 을 가진 복소수를 반환합니다. 인자 중 하나가 실수인 경우, 위 표현식에서는 오직 그 실성분만 사용됩니다.

See also complex.from_number() which only accepts a single numeric argument.

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

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

버전 3.6에서 변경: 코드 리터럴 처럼 숫자를 밑줄로 그룹화할 수 있습니다.

버전 3.8에서 변경: Falls back to __index__() if __complex__() and __float__() are not defined.

버전 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)

Create a new dictionary. The dict object is the dictionary class. See also 매핑 타입 — dict, frozendict for documentation about this class.

다른 컨테이너의 경우 내장된 frozendict, list, set, 및 tuple 클래스, 그리고 collections 모듈을 참고하세요.

dir()¶

dir(object, /)

인자가 없으면, 현재 지역 스코프에 있는 이름들의 리스트를 돌려줍니다. 인자가 있으면, 해당 객체에 유효한 어트리뷰트들의 리스트를 돌려주려고 시도합니다.

If the object has a method named __dir__(), this method will be called and must return the list of attributes. This allows objects that implement a custom __getattr__() or __getattribute__() function to customize the way dir() reports their attributes.

If the object does not provide __dir__(), the function tries its best to gather information from the object’s __dict__ attribute, if defined, and from its type object. The resulting list is not necessarily complete and may be inaccurate when the object has a custom __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) – Python 표현식입니다.
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 이 됩니다.

Hints: dynamic execution of statements is supported by the exec() function. The globals() and locals() functions return the current global and local dictionary, respectively, which may be useful to pass around for use by eval() or exec().

제공된 소스가 문자열인 경우, 선행 및 후행 공백과 탭은 제거됩니다.

See ast.literal_eval() for a function to evaluate strings with expressions containing only literals.

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

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

버전 3.13에서 변경: The semantics of the default locals namespace have been adjusted as described for the locals() builtin.

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

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

경고

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

이 함수는 Python 코드의 동적 실행을 지원합니다. source 는 문자열 또는 코드 객체 중 하나여야 합니다. 만약 문자열이라면, 해당 문자열은 일련의 Python 문장으로 파싱된 다음 실행됩니다(구문 오류가 발생하지 않는 한). [1] 이것이 코드 객체라면, 단순히 실행됩니다. 모든 경우에 대해 실행되는 코드는 파일 입력으로서 유효할 것으로 예상되어야 합니다(참조 설명서의 파일 입력 섹션을 참조하십시오). nonlocal, yield, 및 return 문은 exec() 함수에 전달된 코드 컨텍스트 내에서도 함수 정의 외부에서는 사용될 수 없다는 점을 유념하십시오. 반환 값은 None 입니다.

모든 경우에 대해, 선택적 부분이 생략되면 코드는 현재 스코프에서 실행됩니다. globals 만 제공된 경우에는 딕셔너리여야 합니다(그리고 딕셔너리의 하위 클래스가 아니어야 함). 이 딕셔너리는 전역 및 지역 변수 모두로 사용됩니다. globals 와 locals 가 주어진 경우, 각각 전역 및 지역 변수로 사용됩니다. locals 를 제공할 수 있으며, 이는 모든 매핑 객체가 될 수 있습니다. 모듈 레벨에서는 globals와 locals가 같은 딕셔너리임을 기억하십시오.

참고

exec 가 globals 및 locals 로 두 개의 별도 객체를 받으면, 코드는 클래스 정의 내부에 포함된 것처럼 실행됩니다. 이는 해당 코드에서 정의된 함수와 클래스가 최상위 레벨에 할당된 변수에 액세스할 수 없다는 것을 의미합니다(왜냐하면 “최상위” 변수는 클래스 정의에서 클래스 변수로 처리되기 때문입니다).

만약 globals 딕셔너리가 키 __builtins__ 에 대한 값이 없다면, 내장 모듈 builtins 의 딕셔너리에 대한 참조가 해당 키 아래에 삽입됩니다. __builtins__ 를 재정의하는 것은 사용 가능한 이름을 제한하거나 변경하는 데 사용될 수 있지만, 이것은 보안 메커니즘이 아닙니다: 실행된 코드는 여전히 모든 내장 객체에 액세스할 수 있습니다.

The closure argument specifies a closure–a tuple of cellvars. It’s only valid when the object is a code object containing free (closure) variables. The length of the tuple must exactly match the length of the code object’s co_freevars attribute.

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

참고

The built-in functions globals() and locals() return the current global and local namespace, respectively, which may be useful to pass around for use as the second and third argument to 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에서 변경: The semantics of the default locals namespace have been adjusted as described for the locals() builtin.

버전 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”는 모두 양의 무한대를 나타내는 허용 가능한 표기법입니다.

Otherwise, if the argument is an integer or a floating-point number, a floating-point number with the same value (within Python’s floating-point precision) is returned. If the argument is outside the range of a Python float, an OverflowError will be raised.

일반 파이썬 객체 x 에 대해, float(x) 는 x.__float__() 으로 위임됩니다. 만약 __float__() 가 정의되지 않았다면 __index__() 로 대체됩니다.

See also float.from_number() which only accepts a numeric argument.

인자가 주어지지 않으면, 0.0 을 돌려줍니다.

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

버전 3.6에서 변경: 코드 리터럴 처럼 숫자를 밑줄로 그룹화할 수 있습니다.

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

버전 3.8에서 변경: Falls back to __index__() if __float__() is not defined.

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

Convert a value to a “formatted” representation, as controlled by format_spec. The interpretation of format_spec will depend on the type of the value argument; however, there is a standard formatting syntax that is used by most built-in types: 포맷 명세 미니 언어.

기본 format_spec 은 빈 문자열이며 일반적으로 str(value) 를 호출하는 것과 같은 효과를 줍니다.

A call to format(value, format_spec) is translated to type(value).__format__(value, format_spec) which bypasses the instance dictionary when searching for the value’s __format__() method. A TypeError exception is raised if the method search reaches object and the format_spec is non-empty, or if either the format_spec or the return value are not strings.

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

class frozendict(**kwargs)

class frozendict(mapping, /, **kwargs)

class frozendict(iterable, /, **kwargs)

Create a new frozen dictionary. The frozendict object is a built-in class. See also 매핑 타입 — dict, frozendict for documentation about this class.

다른 컨테이너의 경우 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, /): Return the value of the named attribute of object. name must be a string. If the string is the name of one of the object’s attributes, the result is the value of that attribute. For example, getattr(x, 'foobar') is equivalent to x.foobar. If the named attribute does not exist, default is returned if provided, otherwise AttributeError is raised. name need not be a Python identifier (see setattr()).

참고

private name mangling 이 컴파일 시간에 발생하기 때문에, getattr() 를 사용하여 검색하려면 사적 속성(두 개의 선행 밑줄을 가진 속성)의 이름에 수동으로 mangle(수정)해야 합니다.

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

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

hash(object, /)¶: 객체의 해시값을 돌려줍니다 (해시가 있는 경우). 해시값은 정수다. 딕셔너리 조회 중에 딕셔너리 키를 빨리 비교하는 데 사용됩니다. 같다고 비교되는 숫자 값은 같은 해시값을 갖습니다 (1과 1.0의 경우와 같이 형이 다른 경우조차도 그렇습니다).

참고

커스텀 __hash__() 메서드를 가진 객체의 경우, hash() 가 호스트 기계의 비트 폭을 기반으로 반환 값을 잘라낸다는 점에 유의하십시오.

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

객체의 “아이덴티티”를 돌려준다. 이것은 객체의 수명 동안 유일하고 바뀌지 않음이 보장되는 정수입니다. 수명이 겹치지 않는 두 개의 객체는 같은 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__() 를 반환합니다. 부동 소수점 숫자의 경우, 이는 영을 향해 절삭됩니다.

인자가 숫자가 아니거나 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 문자열 입력 및 문자열 표현은 서비스 거부 공격을 방지하는 데 도움이 되도록 제한될 수 있습니다. 문자열을 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, /)¶: Return True if cls is a subclass (direct, indirect, or virtual) of classinfo. A class is considered a subclass of itself. classinfo may be a tuple of class objects (or recursively, other such tuples) or a 합집합형 (Union Type), in which case return True if cls is a subclass of any entry in classinfo. In any other case, a TypeError exception is raised.

버전 3.10에서 변경: classinfo 는 합집합형 (Union Type) 일 수 있습니다.

iter(iterable, /)¶

iter(callable, sentinel, /)

Return an iterator object. The first argument is interpreted very differently depending on the presence of the second argument. Without a second argument, the single argument must be a collection object which supports the iterable protocol (the __iter__() method), or it must support the sequence protocol (the __getitem__() method with integer arguments starting at 0). If it does not support either of those protocols, TypeError is raised. If the second argument, sentinel, is given, then the first argument must be a callable object. The iterator created in this case will call callable with no arguments for each call to its __next__() method; if the value returned is equal to sentinel, StopIteration will be raised, otherwise the value will be returned.

이터레이터 형 도 보세요.

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

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

At module scope, as well as when using exec() or eval() with a single namespace, this function returns the same namespace as globals().

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

별도의 지역 및 전역 인자를 사용하여 exec() 또는 eval() 을 사용할 때, 이 함수는 함수 호출에 전달된 지역 네임스페이스를 반환합니다.

위의 모든 경우에서, 주어진 실행 프레임 내의 locals() 호출은 항상 동일한 매핑 객체를 반환할 것입니다. locals() 로부터 반환된 매핑 객체를 통해 변경된 사항은 할당되거나 재할당되거나 삭제된 지역 변수로서 보일 것이며, 지역 변수를 할당, 재할당 또는 삭제하는 것은 즉시 반환됨 매핑 객체의 내용을 영향을 미칩니다.

In an optimized scope (including functions, generators, and coroutines), each call to locals() instead returns a fresh dictionary containing the current bindings of the function’s local variables and any nonlocal cell references. In this case, name binding changes made via the returned dict are not written back to the corresponding local variables or nonlocal cell references, and assigning, reassigning, or deleting local variables and nonlocal cell references does not affect the contents of previously returned dictionaries.

Calling locals() as part of a comprehension in a function, generator, or coroutine is equivalent to calling it in the containing scope, except that the comprehension’s initialised iteration variables will be included. In other scopes, it behaves as if the comprehension were running as a nested function.

Calling locals() as part of a generator expression is equivalent to calling it in a nested generator function.

버전 3.12에서 변경: The behaviour of locals() in a comprehension has been updated as described in PEP 709.

버전 3.13에서 변경: As part of PEP 667, the semantics of mutating the mapping objects returned from this function are now defined. The behavior in optimized scopes is now as described above. Aside from being defined, the behaviour in other scopes remains unchanged from previous versions.

map(function, iterable, /, *iterables, strict=False)¶: iterable 의 모든 항목에 function 을 적용하여 결과를 생성하는 이터레이터를 반환합니다. 추가적인 iterables 인자가 전달되면, function 은 그만큼의 인자를 받아들이야 하며 모든 iterable에서 받은 아이템들을 병렬로에 적용됩니다. 여러 iterables를 사용하는 경우, 가장 짧은 iterable이 소진될 때 이터레이터가 정지합니다. 만약 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에서 가장 작은 항목을 돌려줍니다. 두 개 이상의 위치 인자가 제공되면, 위치 인자 중 가장 작은 것을 돌려줍니다.

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

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

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

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

class object¶: 이것은 다른 모든 클래스의 궁극적인 기본 클래스입니다. Python 클래스의 모든 인스턴스에 공통되는 메서드를 가지고 있습니다. 생성자가 호출되면 새 기능이 없는 객체가 반환됩니다. 생성자는 인수를 받지 않습니다.

참고

object 인스턴스는 __dict__ 어트리뷰트를 가지고 있지 않으므로, object 인스턴스에 임의의 속성을 할당할 수 없습니다.

oct(integer, /)¶

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

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

정수형 숫자를 접두사 “0o”가 붙은 8진 문자열로 또는 붙이지 않은 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' 가 있습니다 (이는 일부 Unix 시스템에서 현재 탐색 위치와 관계없이 모든 쓰기가 파일 끝에 추가됨을 의미합니다). 텍스트 모드에서는 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:

Binary files are buffered in fixed-size chunks; the size of the buffer is max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE) when the device block size is available. On most systems, the buffer will typically be 128 kilobytes long.
“대화형” 텍스트 파일 (isatty() 가 True 를 돌려주는 파일)은 줄 버퍼링을 사용합니다. 다른 텍스트 파일은 바이너리 파일에 대해 위에서 설명한 정책을 사용합니다.

encoding 은 파일을 디코딩하거나 인코딩하는 데 사용되는 인코딩 이름입니다. 이는 텍스트 모드에서만 사용해야 합니다. 기본 인코딩은 플랫폼에 따라 다르며 ( locale.getencoding() 가 반환하는 모든 것), Python이 지원하는 모든 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 매개변수를 사용합니다:

>>> 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('이 내용은 somedir/spamspam.txt에 기록됩니다.', file=f)
...
>>> os.close(dir_fd)  # 열린 파일 디스크립터를 누수시키지 않습니다

open() 함수에 의해 반환된 파일 객체 의 형은 모드에 의존합니다. open() 이 텍스트 모드('w', 'r', 'wt', 'rt', 등)로 파일을 여는 데 사용되면, io.TextIOBase 의 서브 클래스를 돌려줍니다 (구체적으로 io.TextIOWrapper). 버퍼링과 함께 바이너리 모드로 파일을 여는 데 사용되는 경우, 반환되는 클래스는 io.BufferedIOBase 의 서브 클래스입니다. 정확한 클래스는 다양합니다: 읽기 바이너리 모드에서는, io.BufferedReader 를 돌려줍니다; 쓰기 바이너리와 덧붙이기 바이너리 모드에서는, io.BufferedWriter 를 돌려주고, 읽기/쓰기 모드에서는, io.BufferedRandom 을 돌려줍니다. 버퍼링을 끄면, 날 스트림, io.RawIOBase 의 서브 클래스, io.FileIO, 을 돌려줍니다.

See also the file handling modules, such as fileinput, io (where open() is declared), os, os.path, tempfile, and shutil.

Raises an auditing event open with arguments path, mode, flags.

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 유형의 음수 밑과 비정수 지수는 복소수가 반환됩니다. 예를 들어, 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 에*를 파일 스트림으로 * objects*를 출력합니다. * 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 의 독스트링을 “현재 전압을 가져옵니다.”로 설정합니다.

@getter¶

@setter¶

@deleter¶

속성 객체는 데코레이터로 사용할 수 있는 getter, setter, 및 deleter 메서드를 가지고 있으며, 해당 접근자 함수를 데코레이트된 함수에 설정하여 속성의 복사본을 만듭니다. 이는 예시와 함께 설명하는 것이 가장 좋습니다:

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

Return a string containing a printable representation of an object. For many types, this function makes an attempt to return a string that would yield an object with the same value when passed to eval(); otherwise, the representation is a string enclosed in angle brackets that contains the name of the type of the object together with additional information often including the name and address of the object. A class can control what this function returns for its instances by defining a __repr__() method. If sys.displayhook() is not accessible, this function will raise 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__() 메서드를 가지고 있거나 시퀀스 프로토콜을 지원하는 객체여야 합니다 (즉, __len__() 메서드와 정수 인자 0부터 시작하는 __getitem__() 메서드를 지원해야 합니다).

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 와 같은 타입을 가집니다.

일반적인 파이썬 객체 number 의 경우, round 는 number.__round__ 에 위임합니다.

참고

float에 대한 round() 의 동작은 예상과 다를 수 있습니다: 예를 들어, round(2.675, 2) 는 2.68 대신에 2.67 을 제공합니다. 이것은 버그가 아닙니다: 대부분의 십진 소수가 float로 정확히 표현될 수 없다는 사실로부터 오는 결과입니다. 자세한 정보는 부동 소수점 산술: 문제점 및 한계 를 보세요.

class set(iterable=(), /)

Return a new set object, optionally with elements taken from iterable. set is a built-in class. See also 집합 형 — set, frozenset for documentation about this class.

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

setattr(object, name, value, /)¶

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

name need not be a Python identifier as defined in 이름 (식별자 및 키워드) unless the object chooses to enforce that, for example in a custom __getattribute__() or via __slots__. An attribute whose name is not an identifier will not be accessible using the dot notation, but is accessible through getattr() etc..

참고

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

Return a new unique sentinel object. name must be a str, and is used by default as the returned object’s representation:

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

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

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

Sentinel 객체는 truthy하며 자기 자신과만 동등하게 비교됩니다. 이는 is 연산자와 비교하도록 의도되었습니다.

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

sentinel 객체의 얕은 복사와 깊은 복사 모두 해당 객체를 반환합니다.

Sentinels are conventionally assigned to a variable with a matching name. Sentinels defined in this way can be used in type hints:

MISSING = sentinel("MISSING")

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

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

Pickling is supported for sentinel objects that are placed in the global scope of a module under a name matching the sentinel’s name, and for sentinels placed in class scopes with a name matching the qualified name of the sentinel. Other sentinels, such as those defined in a function scope, are not picklable. The identity of the sentinel is preserved after 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

Sentinel 객체는 다음 속성을 가집니다:

__name__¶: sentinel의 이름입니다.

__module__¶: sentinel이 생성된 모듈의 이름입니다. 이 속성은 수정 가능합니다.

Added in version 3.15.

class slice(stop, /)¶

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

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

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

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

start¶
stop¶
step¶: 이 읽기 전용 속성들은 인자 값(또는 기본값)으로 설정됩니다. 다른 명시적인 기능은 없지만, NumPy 및 기타 제삼자 패키지에서 사용됩니다.

버전 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)임이 보장됩니다. 정렬은 같다고 비교되는 요소의 상대적 순서를 변경하지 않으면 안정적입니다 — 이는 여러 번 정렬할 때 유용합니다 (예를 들어, 부서별로 정렬한 후에 급여 등급별로 정렬하기).

The sort algorithm uses only < comparisons between items. While defining an __lt__() method will suffice for sorting, PEP 8 recommends that all six rich comparisons be implemented. This will help avoid bugs when using the same data with other ordering tools such as max() that rely on a different underlying method. Implementing all six comparisons also helps avoid confusion for mixed type comparisons which can call the reflected __gt__() method.

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

@staticmethod¶

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

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

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

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

A static method can be called either on the class (such as C.f()) or on an instance (such as C().f()). Moreover, the static method descriptor is also callable, so it can be used in the class definition (such as f()).

Static methods in Python are similar to those found in Java or C++. Also, see @classmethod for a variant that is useful for creating alternate class constructors.

모든 데코레이터와 마찬가지로, 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 의 항목은 일반적으로 숫자며 시작 값은 문자열이 될 수 없습니다.

For some use cases, there are good alternatives to sum(). The preferred, fast way to concatenate a sequence of strings is by calling ''.join(sequence). To add floating-point values with extended precision, see math.fsum(). To concatenate a series of iterables, consider using itertools.chain().

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

버전 3.12에서 변경: 부동 소수점 합계는 대부분 빌드에서 더 높은 정확성과 더 나은 교환 법칙성을 주는 알고리즘으로 전환되었습니다.

버전 3.14에서 변경: Float 합산에 사용되는 것과 동일한 알고리즘을 사용하여 복소수 합산을 위한 특수화가 추가되었습니다.

class super¶

class super(type, object_or_type=None, /)

메서드 호출을 type 의 부모나 형제 클래스에 위임하는 프락시 객체를 돌려줍니다. 이는 클래스에서 재정의된 상속 된 메서드를 액세스할 때 유용합니다.

The object_or_type determines the method resolution order to be searched. The search starts from the class right after the 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) 는 참이어야 합니다 (이것은 클래스 메서드에 유용합니다).

클래스의 일반 메서드 내에서 직접 호출된 경우, 양쪽 인자 모두를 생략할 수 있습니다(“zero-argument super() “). 이 경우, type 은 포함하는 클래스가 되고, obj 는 즉시 감싸고 있는 함수의 첫 번째 인자(일반적으로 self)가 됩니다. (이는 zero-argument super() 가 생성기식 표현식을 포함한 중첩 함수 내부에서는 예상대로 작동하지 않음을 의미합니다.)

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

The second use case is to support cooperative multiple inheritance in a dynamic execution environment. This use case is unique to Python and is not found in statically compiled languages or languages that only support single inheritance. This makes it possible to implement “diamond diagrams” where multiple base classes implement the same method. Good design dictates that such implementations have the same calling signature in every case (because the order of calls is determined at runtime, because that order adapts to changes in the class hierarchy, and because that order can include sibling classes that are unknown prior to runtime).

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

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

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

Note that super() is implemented as part of the binding process for explicit dotted attribute lookups such as super().__getitem__(name). It does so by implementing its own __getattribute__() method for searching classes in a predictable order that supports cooperative multiple inheritance. Accordingly, super() is undefined for implicit lookups using statements or operators such as super()[name].

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

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

버전 3.14에서 변경: super objects are now pickleable and copyable.

class tuple(iterable=(), /): 함수이기보다, tuple 은 실제로 튜플 과 시퀀스 형 — list, tuple, range 에 문서화 된 것처럼 불변 시퀀스 형입니다.

class type(object, /)¶

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

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

객체의 형을 검사하는 데는 isinstance() 내장 함수가 권장되는데, 서브 클래스를 고려하기 때문입니다.

With three arguments, return a new type object. This is essentially a dynamic form of the class statement. The name string is the class name and becomes the __name__ attribute. The bases tuple contains the base classes and becomes the __bases__ attribute; if empty, object, the ultimate base of all classes, is added. The dict dictionary contains attribute and method definitions for the class body; it may be copied or wrapped before becoming the __dict__ attribute. The following two statements create identical type objects:

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

참고 자료:

세 인자 형식에 제공된 키워드 인자는 클래스 정의의 (metaclass 를 제외한) 키워드와 같은 방식으로 적절한 메타 클래스 장치(일반적으로 __init_subclass__())에 전달됩니다.

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

버전 3.6에서 변경: Subclasses of type which don’t override type.__new__ may no longer use the one-argument form to get the type of an object.

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

vars()¶

vars(object, /)

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

Objects such as modules and instances have an updateable __dict__ attribute; however, other objects may have write restrictions on their __dict__ attributes (for example, classes use a types.MappingProxyType to prevent direct dictionary updates).

Without an argument, vars() acts like 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')

More formally: zip() returns an iterator of tuples, where the i-th tuple contains the i-th element from each of the argument iterables.

Another way to think of zip() is that it turns rows into columns, and columns into rows. This is similar to transposing a matrix.

zip() is lazy: The elements won’t be processed until the iterable is iterated on, e.g. by a for loop or by wrapping in a list.

One thing to consider is that the iterables passed to zip() could have different lengths; sometimes by design, and sometimes because of a bug in the code that prepared these iterables. Python offers three different approaches to dealing with this issue:

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() is often used in cases where the iterables are assumed to be of equal length. In such cases, it’s recommended to use the strict=True option. Its output is the same as regular 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 인자 없이, 길이가 다른 이터러블로 인해 발생하는 모든 버그는 무음 처리될 수 있으며, 이는 프로그램의 다른 부분에서 찾기 어려운 버그로 나타날 가능성이 있습니다.
Shorter iterables can be padded with a constant value to make all the iterables have the same length. This is done by itertools.zip_longest().

Edge cases: With a single iterable argument, zip() returns an iterator of 1-tuples. With no arguments, it returns an empty iterator.

팁 및 요령:

이터러블의 왼쪽에서 오른쪽 평가 순서가 보장됩니다. 이를 이용하여 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() 을 사용할 것을 권합니다.

The function imports the module name, potentially using the given globals and locals to determine how to interpret the name in a package context. The fromlist gives the names of objects or submodules that should be imported from the module given by name. The standard implementation does not use its locals argument at all and uses its globals only to determine the package context of the import statement.

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는 이제 무시됩니다.

각주

내장 함수¶

분실물 보관소