내장 함수
*********

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

+---------------------+-------------------+--------------------+--------------------+----------------------+
|                     |                   | 내장 함수          |                    |                      |
|=====================|===================|====================|====================|======================|
| "abs()"             | "delattr()"       | "hash()"           | "memoryview()"     | "set()"              |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "all()"             | "dict()"          | "help()"           | "min()"            | "setattr()"          |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "any()"             | "dir()"           | "hex()"            | "next()"           | "slice()"            |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "ascii()"           | "divmod()"        | "id()"             | "object()"         | "sorted()"           |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "bin()"             | "enumerate()"     | "input()"          | "oct()"            | "staticmethod()"     |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "bool()"            | "eval()"          | "int()"            | "open()"           | "str()"              |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "breakpoint()"      | "exec()"          | "isinstance()"     | "ord()"            | "sum()"              |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "bytearray()"       | "filter()"        | "issubclass()"     | "pow()"            | "super()"            |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "bytes()"           | "float()"         | "iter()"           | "print()"          | "tuple()"            |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "callable()"        | "format()"        | "len()"            | "property()"       | "type()"             |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "chr()"             | "frozenset()"     | "list()"           | "range()"          | "vars()"             |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "classmethod()"     | "getattr()"       | "locals()"         | "repr()"           | "zip()"              |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "compile()"         | "globals()"       | "map()"            | "reversed()"       | "__import__()"       |
+---------------------+-------------------+--------------------+--------------------+----------------------+
| "complex()"         | "hasattr()"       | "max()"            | "round()"          |                      |
+---------------------+-------------------+--------------------+--------------------+----------------------+

abs(x)

   숫자의 절댓값을 돌려줍니다. 인자는 정수 또는 실수입니다. 인자가 복
   소수면 그 크기가 반환됩니다. *x*가 "__abs__()"를 정의하면, "abs(x)"
   는 "x.__abs__()"를 반환합니다.

all(iterable)

   *iterable* 의 모든 요소가 참이면 (또는 iterable 이 비어있으면)
   "True" 를 돌려줍니다. 다음과 동등합니다:

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

any(iterable)

   *iterable* 의 요소 중 어느 하나라도 참이면 "True" 를 돌려줍니다.
   iterable이 비어 있으면 "False" 를 돌려줍니다. 다음과 동등합니다:

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

ascii(object)

   "repr()" 처럼, 객체의 인쇄 가능한 표현을 포함하는 문자열을 반환하지
   만, "\x" 나 "\u" 또는 "\U" 이스케이프를 사용하여 "repr()" 이 돌려주
   는 문자열에 포함된 비 ASCII 문자를 이스케이프 합니다. 이것은 파이썬
   2의 "repr()" 이 돌려주는 것과 비슷한 문자열을 만듭니다.

bin(x)

   정수를 "0b" 가 앞에 붙은 이진 문자열로 변환합니다. 결과는 올바른 파
   이썬 표현식입니다. *x* 가 파이썬 "int" 객체가 아니라면, 정수를 돌려
   주는 "__index__()" 메서드를 정의해야 합니다. 몇 가지 예를 들면:

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

   접두어 "0b" 가 필요할 수도, 필요 없을 수도 있다면, 다음 방법의 하나
   를 사용할 수 있습니다.

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

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

class bool([x])

   논리값, 즉 "True" 또는 "False" 중 하나를 돌려줍니다. *x* 표준 논리
   값 검사 절차 를 사용하여 변환됩니다. *x* 가 거짓이거나 생략되면
   "False" 를 돌려줍니다. 그렇지 않으면 "True" 를 돌려줍니다. "bool"
   클래스는 "int" (숫자 형 --- int, float, complex 참조)의 서브 클래스
   입니다. 서브 클래스를 더 만들 수 없습니다. 이것의 유일한 인스턴스는
   "False" 와 "True" 입니다 (논리값를 보세요).

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

breakpoint(*args, **kws)

   이 함수는 호출 지점에서 디버거로 진입하게 만듭니다. 특히
   "sys.breakpointhook()" 을 호출하고 "args" 와 "kws" 를 그대로 전달합
   니다. 기본적으로, "sys.breakpointhook()" 은 인자를 기대하지 않고
   "pdb.set_trace()"를 호출합니다. 이 경우, 이것은 순전히 편의 기능이
   므로 "pdb"를 명시적으로 임포트하거나 디버거에 들어가기 위해 많은 코
   드를 입력할 필요가 없습니다. 그러나, "sys.breakpointhook()" 은 다른
   함수로 설정될 수 있고, "breakpoint()" 는 그것을 자동으로 호출하여,
   선택한 디버거에 들어갈 수 있도록 합니다.

   "breakpointhook"을 인자로 감사 이벤트(auditing event)
   "builtins.breakpoint"를 발생시킵니다.

   버전 3.7에 추가.

class bytearray([source[, encoding[, errors]]])

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

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

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

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

   * If it is an object conforming to the buffer interface, a read-
     only buffer of the object will be used to initialize the bytes
     array.

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

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

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

class bytes([source[, encoding[, errors]]])

   새로운 "바이트열" 객체를 돌려줍니다. 이 객체는 "0 <= x < 256" 범위
   에 있는 정수의 불변 시퀀스입니다. "bytes" 는 "bytearray" 의 불변 버
   전입니다 -- 같은 불변 메서드와 같은 인덱싱 및 슬라이싱 동작을 갖습
   니다.

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

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

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

callable(object)

   *object* 인자가 콜러블인 것처럼 보이면 "True"를, 그렇지 않으면
   "False" 를 돌려줍니다. 이것이 "True"를 돌려줘도 여전히 호출이 실패
   할 가능성이 있지만, "False"일 때 *object* 를 호출하면 반드시 실패합
   니다. 클래스가 콜러블 이라는 것에 유의하세요 (클래스를 호출하면 새
   인스턴스를 돌려줍니다); 클래스에 "__call__()" 메서드가 있으면 인스
   턴스도 콜러블입니다.

   버전 3.2에 추가: 이 함수는 파이썬 3.0에서 먼저 제거된 다음 파이썬
   3.2에서 다시 도입했습니다.

chr(i)

   유니코드 코드 포인트가 정수 *i* 인 문자를 나타내는 문자열을 돌려줍
   니다. 예를 들어, "chr(97)" 은 문자열 "'a'" 를 돌려주고, "chr(8364)"
   는 문자열 "'€'" 를 돌려줍니다. 이 것은 "ord()" 의 반대입니다.

   인자의 유효 범위는 0에서 1,114,111(16진수로 0x10FFFF)까지입니다.
   *i* 가 이 범위 밖에 있을 때 "ValueError" 가 발생합니다.

@classmethod

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

   인스턴스 메서드가 인스턴스를 받는 것처럼, 클래스 메서드는 클래스를
   묵시적인 첫 번째 인자로 받습니다. 클래스 메서드를 선언하려면 이 관
   용구를 사용합니다:

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

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

   클래스 메서드는 클래스 ("C.f()" 처럼) 또는 인스턴스 ("C().f()" 처럼
   ) 를 통해 호출할 수 있습니다. 인스턴스는 클래스만 참조하고 무시됩니
   다. 파생 클래스에 대해 클래스 메서드가 호출되면, 파생 클래스 객체가
   묵시적인 첫 번째 인자로 전달됩니다.

   클래스 메서드는 C++ 또는 자바의 정적 메서드와 다릅니다. 그것들을 원
   하면, "staticmethod()"를 보세요.

   클래스 메서드에 대한 더 자세한 정보를 원하면, 표준형 계층을 참고하
   세요.

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

   *source* 를 코드 또는 AST 객체로 컴파일합니다. 코드 객체는 "exec()"
   또는 "eval()" 로 실행할 수 있습니다. *source* 는 일반 문자열, 바이
   트열 또는 AST 객체 일 수 있습니다. AST 객체로 작업하는 방법에 대한
   정보는 "ast" 모듈 문서를 참조하세요.

   *filename* 인자는 코드를 읽은 파일을 제공해야 합니다; 파일에서 읽지
   않으면 인식 가능한 값을 전달합니다 ("'<string>'" 이 일반적으로 사용
   됩니다).

   *mode* 인자는 컴파일해야 하는 코드 종류를 지정합니다; *source* 가
   문장의 시퀀스로 구성되어 있다면 "exec", 단일 표현식으로 구성되어 있
   다면 "'eval'", 단일 대화형 문장으로 구성되면 "'single'" 이 될 수 있
   습니다 (마지막의 경우 "None" 이외의 값으로 구해지는 표현식 문은 인
   쇄됩니다).

   선택적 인자 *flags* 와 *dont_inherit* 는 어떤 퓨처 문이 *source* 의
   컴파일에 영향을 미칠지 제어합니다. 둘 다 제공되지 않는 경우 (또는
   둘 다 0의 경우), 코드는 "compile()" 을 호출하는 코드에 적용되고 있
   는 퓨처 문으로 컴파일됩니다. *flags* 인자가 주어지고,
   *dont_inherit* 가 없으면 (또는 0) 원래 사용될 것에 더해 *flags* 인
   자로 지정된 퓨처 문이 사용됩니다. *dont_inherit* 가 0이 아닌 정수면
   *flags* 인자가 사용됩니다 -- compile을 호출하는 코드에 적용되는 퓨
   처 문은 무시됩니다.

   퓨처 문은 여러 개의 문장을 지정하기 위해 비트 OR 될 수 있는 비트에
   의해 지정됩니다. 주어진 기능을 지정하는 데 필요한 비트 필드는
   "__future__" 모듈의 "_Feature" 인스턴스에서 "compiler_flag" 어트리
   뷰트로 찾을 수 있습니다.

   선택적 인자 *flags*는 컴파일된 소스가 최상위 수준 "await", "async
   for" 및 "async with"를 포함할 수 있는지를 제어합니다. 비트
   "ast.PyCF_ALLOW_TOP_LEVEL_AWAIT"가 설정될 때, 반환 코드 객체는
   "co_code"에 "CO_COROUTINE"이 설정되고, "await eval(code_object)"를
   통해 대화식으로 실행될 수 있습니다.

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

   이 함수는 컴파일된 소스가 올바르지 않으면 "SyntaxError" 를 일으키고
   , 소스에 널 바이트가 들어있는 경우 "ValueError" 를 일으킵니다.

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

   "source", "filename" 인자로 감사 이벤트(auditing event) "compile"을
   발생시킵니다.

   참고:

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

   경고:

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

   버전 3.2에서 변경: 윈도우 및 맥의 줄 바꿈을 사용할 수 있습니다. 또
   한, 이제는 "'exec'" mode에서 입력이 줄 넘김 문자로 끝나지 않아도 됩
   니다. *optimize* 매개변수가 추가되었습니다.

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

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

class complex([real[, imag]])

   *real* + *imag**1j 값을 가진 복소수를 돌려주거나 문자열 또는 숫자를
   복소수로 변환합니다. 첫 번째 매개변수가 문자열이면 복소수로 해석되
   며, 두 번째 매개변수 없이 함수를 호출해야 합니다. 두 번째 매개변수
   는 결코 문자열 일 수 없습니다. 각 인자는 모든 (복소수를 포함한) 숫
   자 형이 될 수 있습니다. *imag* 가 생략되면 기본값은 0이고, 생성자는
   "int" 와 "float"와 같은 숫자 변환으로 사용됩니다. 두 인자가 모두 생
   략되면 "0j" 를 돌려줍니다.

   일반적인 파이썬 객체 "x"에서, "complex(x)"는 "x.__complex__()"로 위
   임합니다. "__complex__()"가 정의되어 있지 않으면, "__float__()"로
   대체합니다. "__float__()"가 정의되어 있지 않으면, "__index__()"로
   대체합니다.

   참고:

     문자열을 변환할 때, 문자열은 중앙의 "+" 또는 "-" 연산자 주위에 공
     백을 포함해서는 안 됩니다. 예를 들어, "complex('1+2j')" 는 괜찮지
     만 "complex('1 + 2j')" 는 "ValueError" 를 일으킵니다.

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

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

   버전 3.8에서 변경: "__complex__()"와 "__float__()"가 정의되지 않으
   면 "__index__()"로 대체합니다.

delattr(object, name)

   이것은 "setattr()" 의 친척뻘입니다. 인자는 객체와 문자열입니다. 문
   자열은 객체의 어트리뷰트 중 하나의 이름이어야 합니다. 이 함수는 객
   체가 허용하는 경우 명명된 어트리뷰트를 삭제합니다. 예를 들어,
   "delattr(x, 'foobar')" 는 "del x.foobar" 와 동등합니다.

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

   새 딕셔너리를 만듭니다. "dict" 객체는 딕셔너리 클래스입니다. 이 클
   래스에 대한 설명서는 "dict" 및 매핑 형 --- dict 을 보세요.

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

dir([object])

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

   객체에 "__dir__()" 메서드가 있으면, 이 메서드가 호출되는데, 반드시
   어트리뷰트 리스트를 돌려줘야 합니다. 이렇게 하면 커스텀
   "__getattr__()" 또는 "__getattribute__()" 함수를 구현하는 객체가
   "dir()" 이 어트리뷰트들을 보고하는 방법을 커스터마이즈할 수 있습니
   다.

   객체가 "__dir__()" 을 제공하지 않으면, 함수는 (정의되었다면) 객체의
   "__ dict__" 어트리뷰트와 형 객체로부터 정보를 수집하기 위해 최선을
   다합니다. 결과로 얻어지는 리스트는 반드시 완전하지는 않으며, 객체가
   커스텀 "__getattr__()" 을 가질 때 부정확할 수도 있습니다.

   기본 "dir()" 메커니즘은 다른 형의 객체에 대해서 다르게 동작하는데,
   완전한 정보보다는 가장 적절한 정보를 만들려고 시도하기 때문입니다:

   * 객체가 모듈 객체면, 리스트에는 모듈 어트리뷰트의 이름이 포함됩니
     다.

   * 객체가 형 또는 클래스 객체면, 리스트에는 그것의 어트리뷰트 이름과
     베이스의 어트리뷰트 이름들이 재귀적으로 포함됩니다.

   * 그 밖의 경우, 리스트에는 객체의 어트리뷰트 이름, 해당 클래스의 어
     트리뷰트 이름 및 해당 클래스의 베이스 클래스들의 어트리뷰트 이름
     을 재귀적으로 포함합니다.

   결과 리스트는 알파벳 순으로 정렬됩니다. 예를 들어:

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

   참고:

     "dir()" 은 주로 대화형 프롬프트에서의 사용 편의를 위해 제공되기
     때문에, 엄격하거나 일관되게 정의된 이름 집합을 제공하기보다 흥미
     로운 이름 집합을 제공하려고 시도하며, 상세한 동작은 배포마다 변경
     될 수 있습니다. 예를 들어, 인자가 클래스면 메타 클래스 어트리뷰트
     는 결과 리스트에 없습니다.

divmod(a, b)

   두 개의 (복소수가 아닌) 숫자를 인자로 취하고 정수 나누기를 사용할
   때의 몫과 나머지로 구성된 한 쌍의 숫자를 돌려줍니다. 두 인자의 형이
   다른 경우, 이 항 산술 연산자에 대한 규칙이 적용됩니다. 정수의 경우,
   결과는 "(a // b, a % b)" 와 같습니다. 부동 소수점 숫자의 경우 결과
   는 "(q, a % b)" 인데, *q* 는 보통 "math.floor(a / b)" 이지만, 이보
   다 1작을 수 있습니다. 어떤 경우건 "q * b + a % b" 는 *a* 에 매우 가
   깝습니다. "a % b" 는 0이 아닐 때 *b* 와 같은 부호를 가지며, "0 <=
   abs(a % b) < abs(b)" 가 성립합니다.

enumerate(iterable, start=0)

   열거 객체를 돌려줍니다. *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(sequence, start=0):
          n = start
          for elem in sequence:
              yield n, elem
              n += 1

eval(expression[, globals[, locals]])

   인자는 문자열 및 선택적 globals 및 locals다. 제공된 경우, *globals*
   는 딕셔너리여야 합니다. 제공되는 경우, *locals* 는 모든 매핑 객체가
   될 수 있습니다.

   *expression* 인자는 전역 및 지역 이름 공간으로 *globals* 및
   *locals* 딕셔너리를 사용하여 파이썬 표현식(기술적으로 말하면, 조건
   목록)으로 파싱 되고 값이 구해집니다. *globals* 사전이 제공되고 키
   '__builtins__'의 값을 담고 있지 않으면, *expression*를 구문 분석하
   기 전에 내장 모듈 "builtins"의 딕셔너리에 대한 참조를 그 키로 삽입
   합니다. 이는 *expression* 이 일반적으로 표준 "builtins" 모듈에 대한
   모든 액세스 권한을 가지며 제한된 환경이 전파됨을 뜻합니다. *locals*
   딕셔너리를 생략하면 기본적으로 *globals* 딕셔너리가 사용됩니다. 두
   딕셔너리가 모두 생략되면, 표현식은 "eval()" 이 호출되는 환경에의
   *globals*와 *locals*로 실행됩니다. *eval()*은 둘러싸는 환경에 있는
   *중첩된 스코프*(nonlocal)에 액세스할 수 없습니다.

   반환 값은 계산된 표현식의 결과입니다. 문법 에러는 예외로 보고됩니다
   . 예:

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

   이 함수는 임의의 코드 객체 ("compile()"로 만든 것과 같은)를 실행하
   는 데에도 사용할 수 있습니다. 이 경우 문자열 대신 코드 객체를 전달
   합니다. 코드 객체가 mode 인자 "'exec'" 로 컴파일되었다면, "eval()"
   의 반환 값은 "None" 입니다.

   힌트: 문장의 동적 실행은 "exec()" 함수에 의해 지원됩니다.
   "globals()"와 "locals()" 함수는 각각 현재의 전역과 지역 딕셔너리를
   반환하는데, "eval()" 또는 "exec()" 에 전달하는 데 유용합니다.

   리터럴 만 포함 된 표현식의 값을 안전하게 구할 수 있는 함수
   "ast.literal_eval()" 를 보세요.

   "code_object" 인자로 감사 이벤트(auditing event) "exec"를 발생시킵
   니다.

exec(object[, globals[, locals]])

   This function supports dynamic execution of Python code. *object*
   must be either a string or a code object.  If it is a string, the
   string is parsed as a suite of Python statements which is then
   executed (unless a syntax error occurs). [1] If it is a code
   object, it is simply executed.  In all cases, the code that's
   executed is expected to be valid as file input (see the section
   "File input" in the Reference Manual). Be aware that the
   "nonlocal", "yield",  and "return" statements may not be used
   outside of function definitions even within the context of code
   passed to the "exec()" function. The return value is "None".

   모든 경우에, 선택적 부분을 생략하면, 현재 스코프에서 코드가 실행됩
   니다. *globals* 만 제공된 경우, (딕셔너리의 서브 클래스가 아닌) 딕
   셔너리여야 하며, 전역과 지역 변수 모두에 사용됩니다. *globals* 및
   *locals* 가 주어지면, 전역과 지역 변수에 각각 사용됩니다. 제공되는
   경우, *locals* 는 모든 매핑 객체가 될 수 있습니다. 모듈 수준에서,
   전역과 지역은 같은 딕셔너리임을 기억하세요. exec 가 *globals* 와
   *locals* 로 별도의 객체를 받으면, 코드는 클래스 정의에 포함된 것처
   럼 실행됩니다.

   *globals* 딕셔너리가 "__builtins__" 를 키로 하는 값을 갖고 있지 않
   으면, 그 키로 내장 모듈 "builtins" 에 대한 참조가 삽입됩니다. 이런
   식으로 "exec()" 에 전달하기 전에 *globals* 에 여러분 자신의
   "__builtins__" 딕셔너리를 삽입함으로써, 실행되는 코드에 어떤 내장
   객체들이 제공될지를 제어할 수 있습니다.

   "code_object" 인자로 감사 이벤트(auditing event) "exec"를 발생시킵
   니다.

   참고:

     내장 함수 "globals()"와 "locals()" 는 각각 현재 전역 및 지역 딕셔
     너리를 돌려주는데, "exec()" 로 전달되는 두 번째 및 세 번째 인자로
     사용하는 데 유용합니다.

   참고:

     기본 *locals* 는 아래 함수 "locals()" 에 설명된 대로 작동합니다:
     기본 *locals* 사전에 대해 수정이 시도되어서는 안 됩니다. 함수
     "exec()" 가 돌아온 후에 *locals* 에 코드가 만든 효과를 보려면 명
     시적으로 *locals* 딕셔너리를 전달해야 합니다.

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([x])

   숫자 또는 문자열 *x* 로 부터 실수를 만들어 돌려줍니다.

   인자가 문자열이면, 십진수를 포함해야 하고, 선택적으로 부호가 앞에
   오며 선택적으로 공백으로 둘러싸일 수 있습니다. 선택적 부호는 "'+'"
   또는 "'-'" 일 수 있습니다; "'+'" 부호는 생성되는 값에 아무런 영향을
   주지 않습니다. 인자는 NaN (not-a-number) 또는 양 또는 음의 무한대를
   나타내는 문자열 일 수도 있습니다. 더욱 정확하게, 입력은 앞과 뒤의
   공백 문자를 제거한 후 다음 문법을 따라야 합니다:

      sign           ::= "+" | "-"
      infinity       ::= "Infinity" | "inf"
      nan            ::= "nan"
      numeric_value  ::= floatnumber | infinity | nan
      numeric_string ::= [sign] numeric_value

   여기서 "floatnumber" 는 실수 리터럴 에 설명된 파이썬 실수 리터럴의
   형식입니다. 대/소문자는 중요하지 않아서, 예를 들면, "inf", "Inf",
   "INFINITY" 및 "iNfINity"는 모두 양의 무한대에 대해 허용되는 철자입
   니다.

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

   일반적인 파이썬 객체 "x" 의 경우, "float(x)" 는 "x.__float__()" 로
   위임합니다. "__float__()"가 정의되지 않았으면, "__index__()"로 대체
   합니다.

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

   예:

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

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

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

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

   버전 3.8에서 변경: "__float__()"가 정의되지 않으면 "__index__()"로
   대체합니다.

format(value[, format_spec])

   *format_spec* 의 제어에 따라, *value* 를 "포맷된" 표현으로 변환합니
   다. *format_spec* 의 해석은 *value* 인자의 형에 의존하지만, 대부분
   의 내장형에 의해 사용되는 표준 포매팅 문법이 있습니다: 포맷 명세 미
   니 언어.

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

   "format(value, format_spec)" 에 대한 호출은
   "type(value).__format__(value, format_spec)" 로 번역되는데, value의
   "__format__()" 메서드를 검색할 때 인스턴스 딕셔너리를 건너뜁니다.
   메서드 검색이 "object" 에 도달하고 *format_spec* 이 비어 있지 않거
   나, *format_spec* 또는 반환 값이 문자열이 아닌 경우 "TypeError" 예
   외가 발생합니다.

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

class frozenset([iterable])

   새 "frozenset" 객체를 돌려주는데, 선택적으로 *iterable* 에서 가져온
   요소를 포함합니다. "frozenset" 은 내장 클래스입니다. 이 클래스에 대
   한 설명서는 "frozenset" 과 집합 형 --- set, frozenset을 보세요.

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

getattr(object, name[, default])

   주어진 이름의 *object* 어트리뷰트를 돌려줍니다. *name* 은 문자열이
   어야 합니다. 문자열이 객체의 어트리뷰트 중 하나의 이름이면, 결과는
   그 어트리뷰트의 값입니다. 예를 들어, "getattr(x, 'foobar')" 는
   "x.foobar" 와 동등합니다. 명명된 어트리뷰트가 없으면, *default* 가
   제공되는 경우 그 값이 반환되고, 그렇지 않으면 "AttributeError" 가
   발생합니다.

globals()

   현재 전역 심볼 테이블을 나타내는 딕셔너리를 돌려줍니다. 이것은 항상
   현재 모듈의 딕셔너리입니다 (함수 또는 메서드 내에서, 이 모듈은 그것
   들을 호출하는 모듈이 아니라, 그것들이 정의된 모듈입니다).

hasattr(object, name)

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

hash(object)

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

   참고:

     커스텀 "__hash__()" 메서드를 가진 객체의 경우, "hash()" 는 호스트
     기계의 비트 폭을 기준으로 반환 값을 잘라 버리는 것에 주의하세요.
     자세한 내용은 "__hash__()" 를 보세요.

help([object])

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

   "help()"를 호출할 때, 함수의 매개 변수 목록에 슬래시(/)가 표시되면,
   슬래시 이전 매개 변수는 위치 전용이라는 것을 의미합니다. 자세한 내
   용은, 위치 전용 매개 변수에 대한 FAQ 항목을 참조하십시오.

   이 함수는 "site" 모듈에 의해 내장 이름 공간에 추가됩니다.

   버전 3.4에서 변경: "pydoc" 과 "inspect" 의 변경 사항은 콜러블의 시
   그니처가 이제 더 포괄적이고 일관성이 있음을 의미합니다.

hex(x)

   정수를 "0x" 접두사가 붙은 소문자 16진수 문자열로 변환합니다. *x* 가
   파이썬 "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()" 값을 가질 수 있습니다.

   **CPython implementation detail:** This is the address of the
   object in memory.

   Raises an auditing event "builtins.id" with argument "id".

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"을 발생
   시킵니다.

   "result" 인자로 감사 이벤트(auditing event) "builtins.input/result"
   를 발생시킵니다.

class int([x])
class int(x, base=10)

   숫자 나 문자열 *x* 로 부터 만들어진 정수 객체를 돌려줍니다. 인자가
   주어지지 않으면 "0" 을 돌려줍니다. *x* 가 "__int__()" 를 정의하면,
   "int(x)" 는 "x.__int__()" 를 돌려줍니다. *x* 가 "__index__()" 를 정
   의하면, "x.__index__()" 를 돌려줍니다. *x* 가 "__trunc__()" 를 정의
   하면, "x.__trunc__()" 를 돌려줍니다. 실수의 경우 이 함수는 0 향해
   자릅니다.

   *x* 가 숫자가 아니거나 *base* 가 주어지면, *x* 는 문자열, "bytes",
   또는 "bytearray" 인스턴스여야 하는데, 진수 *base* 의 integer
   literal 을 나타내야 합니다. 선택적으로, 리터럴은 (사이에 공백 없이)
   "+" 또는 "-" 를 앞에 붙일 수 있고, 앞뒤로 공백에 둘러싸일 수 있습니
   다. 진수-n 리터럴은 0에서 n-1까지의 숫자로 구성되며, "a" 에서 "z" (
   또는 "A" 에서 "Z") 가 10에서 35 사이의 값을 가집니다. 기본 *base*
   는 10입니다. 허용되는 값은 0과 2--36입니다. 코드에서의 리터럴 처럼,
   진수-2, -8 및 -16 리터럴에는 선택적으로 "0b"/"0B", "0o"/"0O" 또는
   "0x"/"0X" 접두사가 붙을 수 있습니다. base 0은 코드 리터럴과 똑같이
   해석하라는 뜻이기 때문에, 실제 진수는 2, 8, 10 또는 16이고, 그래서
   "int('010', 0)" 는 올바르지 않지만 "int('010', 8)" 뿐만 아니라
   "int('010')" 도 올바릅니다.

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

   버전 3.4에서 변경: *base* 가 "int" 의 인스턴스가 아니고 *base* 객체
   가 "base.__index__" 메서드를 가지면, 그 진수로 쓸 정수를 얻기 위해
   그 메서드를 호출합니다. 예전 버전에서는 "base.__index__" 대신에
   "base.__int__" 가 사용되었습니다.

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

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

   버전 3.8에서 변경: "__int__()"가 정의되지 않으면, "__index__()"로
   대체합니다.

   버전 3.8.14에서 변경: "int" string inputs and string
   representations can be limited to help avoid denial of service
   attacks. A "ValueError" is raised when the limit is exceeded while
   converting a string *x* to an "int" or when converting an "int"
   into a string would exceed the limit. See the integer string
   conversion length limitation documentation.

isinstance(object, classinfo)

   *object* 인자가 *classinfo* 인자 또는 그것의 (직접, 간접 혹은 *가상
   *) 서브 클래스의 인스턴스면 "True"를 돌려줍니다. *object* 가 주어진
   형의 객체가 아니면, 함수는 항상 "False"를 돌려줍니다. *classinfo*
   가 형 객체들의 튜플 (또는 재귀적으로 이런 종류의 튜플이 중첩된 튜플
   ) 이면, *object* 가 그 형 중 어느 하나의 인스턴스일 때 "True"를 돌
   려줍니다. *classinfo* 가 형이나, 형들의 튜플이나, 이런 튜플들의 튜
   플이 아니면, "TypeError" 예외를 일으킵니다.

issubclass(class, classinfo)

   *class* 가 *classinfo* 의 서브 클래스 (직접, 간접 또는 *가상*)면
   "True"를 돌려줍니다. 클래스는 그 자체의 서브 클래스로 간주합니다.
   *classinfo* 는 클래스 객체의 튜플 일 수 있습니다. 이 경우
   *classinfo* 의 모든 항목이 검사됩니다. 다른 모든 경우에는,
   "TypeError" 예외가 발생합니다.

iter(object[, sentinel])

   *이터레이터* 객체를 돌려줍니다. 첫 번째 인자는 두 번째 인자의 존재
   여부에 따라 매우 다르게 해석됩니다. 두 번째 인자가 없으면, *object*
   는 이터레이션 프로토콜 ("__iter__()" 메서드)을 지원하는 컬렉션 객체
   이거나 시퀀스 프로토콜 (0에서 시작하는 정수 인자를 받는
   "__getitem__()" 메서드)을 지원해야 합니다. 이러한 프로토콜 중 아무
   것도 지원하지 않으면 "TypeError" 가 일어납니다. 두 번째 인자
   *sentinel* 이 주어지면, *object* 는 콜러블이어야 합니다. 이 경우 만
   들어지는 이터레이터는 "__next__()" 메서드가 호출될 때마다 인자 없이
   *object* 를 호출합니다; 반환된 값이 *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(s)

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

class list([iterable])

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

locals()

   현재 지역 심볼 테이블을 나타내는 딕셔너리를 갱신하고 돌려줍니다.
   "locals()" 이 함수 블록에서 호출될 때 자유 변수를 돌려주지만, 클래
   스 블록에서 호출할 때는 그렇지 않습니다. 모듈 수준에서 "locals()"와
   "globals()"는 같은 딕셔너리임에 유의하십시오.

   참고:

     이 딕셔너리의 내용은 수정해서는 안 됩니다. 변경 사항은 인터프리터
     가 사용하는 지역 및 자유 변수의 값에 영향을 미치지 않을 수 있습니
     다.

map(function, iterable, ...)

   *iterable* 의 모든 항목에 *function* 을 적용한 후 그 결과를 돌려주
   는 이터레이터를 돌려줍니다. 추가 *iterable* 인자가 전달되면,
   *function* 은 그 수 만큼의 인자를 받아들여야 하고 모든 이터러블에서
   병렬로 제공되는 항목들에 적용됩니다. 다중 이터러블의 경우, 이터레이
   터는 가장 짧은 이터러블이 모두 소모되면 멈춥니다. 함수 입력이 이미
   인자 튜플로 배치된 경우에는, "itertools.starmap()" 를 보세요.

max(iterable, *[, key, default])
max(arg1, arg2, *args[, key])

   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(obj)

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

min(iterable, *[, key, default])
min(arg1, arg2, *args[, key])

   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[, default])

   "__next__()" 메서드를 호출하여 *iterator* 에서 다음 항목을 꺼냅니다
   . *default* 가 주어지면, iterator가 고갈될 때 돌려주고, 그렇지 않으
   면 "StopIteration" 을 일으킵니다.

class object

   새 기능 없는 객체를 돌려줍니다. "object" 는 모든 클래스의 베이스 클
   래스입니다. 모든 파이썬 클래스의 인스턴스에 공통적인 메서드를 가지
   고 있습니다. 이 함수는 인자를 받아들이지 않습니다.

   참고:

     "object" 는 "__dict__" 을 가지지 *않습니다*. 그래서, "object" 클
     래스의 인스턴스에 임의의 어트리뷰트를 대입할 수 없습니다.

oct(x)

   정수를 "0o"로 시작하는 8진수 문자열로 변환합니다. 결과는 올바른 파
   이썬 표현식입니다. *x* 가 파이썬 "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* 은 열 파일의 경로명(절대 혹은 현재 작업 디렉터리에 상대적인)
   을 주는 *경로류 객체* 거나, 감쌀 파일의 정수 파일 디스크립터입니다.
   (파일 디스크립터가 주어지면, *closefd* 가 "False" 가 아닌 한, 반환
   된 I/O 객체가 닫힐 때 닫힙니다.)

   *mode* 는 파일이 열리는 모드를 지정하는 선택적 문자열입니다. 기본값
   은 "'r'" 인데, 텍스트 모드로 읽기 위해 여는 것을 뜻합니다. 다른 일
   반적인 값은 쓰기 위한 "'w'" (파일이 이미 존재하는 경우 파일을 자릅
   니다), 독점적 파일 만들기를 위한 "'x'" 및 덧붙이기를 위한 "'a'" (*
   일부* 유닉스 시스템에서, 현재 위치와 관계없이 *모든* 쓰기가 파일의
   끝에 덧붙여짐을 뜻합니다) 입니다. 텍스트 모드에서, *encoding* 을 지
   정하지 않으면 사용되는 인코딩은 플랫폼에 따라 다릅니다: 현재 로케일
   인코딩을 얻기 위해 "locale.getpreferredencoding(False)" 가 호출됩니
   다. (날 바이트열을 읽고 쓰려면 바이너리 모드를 사용하고 *encoding*
   을 지정하지 않습니다.) 사용 가능한 모드는 다음과 같습니다:

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

   기본 모드는 "'r'" 입니다 (텍스트를 읽는 용으로 엽니다, "'rt'" 의 동
   의어). 모드 "'w+'"와 "'w+b'" 는 파일을 열고 자릅니다(truncate). 모
   드 "'r+'"과 "'r+b'" 는 자르지 않고 파일을 엽니다.

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

   허용된 추가의 모드 문자 "'U'"가 있습니다. 이것은 더는 아무런 효과가
   없으며, 폐지된 것으로 간주합니다. 이전에는 텍스트 모드에서 *유니버
   설 줄 넘김*을 활성화했는데, 파이썬 3.0에서 기본 동작이 되었습니다.
   자세한 내용은 newline 매개 변수의 설명서를 참조하십시오.

   참고:

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

   *buffering* 은 버퍼링 정책을 설정하는 데 사용되는 선택적 정수입니다
   . 버퍼링을 끄려면 (바이너리 모드에서만 허용) 0을 전달하고, 줄 버퍼
   링 (텍스트 모드에서만 사용 가능)을 선택하려면 1을, 고정 크기 청크
   버퍼를 선택하려면 그 크기를 바이트 단위로 표시한 정수 > 1을 전달합
   니다. *buffering* 인자가 제공되지 않을 때, 기본 버퍼링 정책은 다음
   과 같이 작동합니다:

   * 바이너리 파일은 고정 크기 청크로 버퍼링 됩니다. 버퍼의 크기는 하
     부 장치의 "블록 크기"를 파악하려고 시도하는 경험적인 방법을 사용
     해서 선택되고 "io.DEFAULT_BUFFER_SIZE"로 폴 백 됩니다. 많은 시스
     템에서, 버퍼는 일반적으로 4096 또는 8192바이트 길이입니다.

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

   *encoding* 은 파일을 디코딩하거나 인코딩하는 데 사용되는 인코딩의
   이름입니다. 텍스트 모드에서만 사용해야 합니다. 기본 인코딩은 플랫폼
   에 따라 다르지만 ("locale.getpreferredencoding()" 이 돌려주는 값),
   파이썬에서 지원하는 *텍스트 인코딩* 은 모두 사용할 수 있습니다. 지
   원되는 인코딩 목록은 "codecs" 모듈을 보면 됩니다.

   *errors* 는 인코딩 및 디코딩 에러를 처리하는 방법을 지정하는 선택적
   문자열입니다. 바이너리 모드에서는 사용할 수 없습니다. 다양한 표준
   에러 처리기가 제공됩니다 (에러 처리기 에 나열됩니다). 하지만,
   "codecs.register_error()"로 등록된 에러 처리기 이름 역시 사용할 수
   있습니다. 표준 이름은 다음과 같습니다:

   * "'strict'" 는 인코딩 에러가 있는 경우 "ValueError" 예외를 발생시
     킵니다. 기본값 "None" 은 같은 효과를 냅니다.

   * "'ignore'" 는 에러를 무시합니다. 인코딩 에러를 무시하면 데이터가
     손실될 수 있음에 주의하세요.

   * "'replace'" 는 잘못된 데이터가 있는 자리에 대체 마커("'?'" 와 같
     은)를 삽입합니다.

   * "'surrogateescape'" 는 U+DC80에서 U+DCFF까지의 유니코드 개인 사용
     영역의 코드 포인트로 잘못된 바이트를 나타냅니다. 데이터를 쓸 때
     "surrogateescape" 에러 처리기가 사용되면, 이 개인 코드 포인트들은
     원래의 바이트로 되돌아갑니다. 알 수 없는 인코딩의 파일을 처리할
     때 유용합니다.

   * "'xmlcharrefreplace'" 는 파일에 쓸 때만 지원됩니다. 인코딩이 지원
     하지 않는 문자는 적절한 XML 문자 참조 "&#nnn;" 로 대체됩니다.

   * "'backslashreplace'" 는 잘못된 데이터를 파이썬의 역 슬래시 이스케
     이프 시퀀스로 대체합니다.

   * "'namereplace'" (역시 파일에 쓸 때만 지원됩니다)는 지원되지 않는
     문자를 "\N{...}" 이스케이프 시퀀스로 대체합니다.

   *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" 와 같은 파일 처리 모듈들도 보세요.

   "file", "mode", "flags" 인자로 감사 이벤트(auditing event) "open"을
   발생시킵니다.

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

      버전 3.3에서 변경:

      * *opener* 매개변수가 추가되었습니다.

      * "'x'" 모드가 추가되었습니다.

      * "IOError" 를 일으켜왔습니다. 이제는 "OSError" 의 별칭입니다.

      * 독점적 파일 만들기 모드("'x'")로 여는 파일이 이미 존재하면, 이
        제 "FileExistsError" 를 일으킵니다.

      버전 3.4에서 변경:

      * 파일은 이제 상속 불가능합니다.

   Deprecated since version 3.4, will be removed in version 3.9: "'U'"
   모드.

      버전 3.5에서 변경:

      * 시스템 호출이 인터럽트 되고 시그널 처리기가 예외를 발생시키지
        않으면, 이 함수는 이제 "InterruptedError" 예외를 일으키는 대신
        시스템 호출을 재시도합니다 (이유는 **PEP 475** 를 보세요).

      * "'namereplace'" 오류 처리기가 추가되었습니다.

      버전 3.6에서 변경:

      * "os.PathLike" 를 구현하는 객체를 받아들이도록 지원이 추가되었
        습니다.

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

ord(c)

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

pow(base, exp[, mod])

   *base* 의 *exp* 거듭제곱을 돌려줍니다; *mod* 가 있는 경우, *base*
   의 *exp* 거듭제곱의 모듈로 *mod* 를 돌려줍니다 ("pow(base, exp) %
   mod" 보다 더 빠르게 계산됩니다). 두 개의 인자 형식인 "pow(base,
   exp)" 는 거듭제곱 연산자를 사용하는 것과 동등합니다: "base**exp".

   인자는 숫자 형이어야 합니다. 피연산자들의 형이 다를 경우, 이 항 산
   술 연산자에 대한 코어션 규칙이 적용됩니다. "int" 피연산자들의 경우,
   결과는 두 번째 인자가 음수가 아닌 한 피연산자와 같은 형(코어션 후에
   )이 됩니다; 두 번째 인자가 음수면 모든 인자가 float로 변환되고
   float 결과가 전달됩니다. 예를 들어, "10**2" 는 "100" 을 반환하지만,
   "10**-2" 는 "0.01" 을 반환합니다.

   "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=sys.stdout, flush=False)

   *objects* 를 텍스트 스트림 *file* 로 인쇄하는데, *sep* 로 구분되고
   *end* 를 뒤에 붙입니다. 있다면, *sep*, *end*, *file* 및 *flush* 는
   반드시 키워드 인자로 제공해야 합니다.

   모든 비 키워드 인자는 "str()" 이 하듯이 문자열로 변환된 후 스트림에
   쓰이는데, *sep* 로 구분되고 *end* 를 뒤에 붙입니다. *sep* 과 *end*
   는 모두 문자열이어야 합니다; "None" 일 수도 있는데, 기본값을 사용한
   다는 뜻입니다. *objects* 가 주어지지 않으면 "print()" 는 *end* 만
   씁니다.

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

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

   버전 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" 는 게터(getter)를 호출하고, "c.x =
   value" 는 세터(setter)를 호출하고, "del c.x" 는 딜리터(deleter)를
   호출합니다.

   주어진 경우, *doc* 은 프로퍼티 어트리뷰트의 독스트링이 됩니다. 그렇
   지 않으면, *fget* 의 독스트링(있는 경우)이 복사됩니다. 이렇게 하면
   "property()" 를 *데코레이터* 로 사용하여 읽기 전용 프로퍼티를 쉽게
   만들 수 있습니다:

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

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

   "@property" 데코레이터는 "voltage()" 메서드를 같은 이름의 읽기 전용
   어트리뷰트에 대한 "게터"로 바꾸고, *voltage* 에 대한 독스트링을
   "Get the current voltage." 로 설정합니다.

   프로퍼티 객체는 데코레이터로 사용할 수 있는 "getter", "setter" 및
   "deleter" 메서드를 갖는데, 해당 접근자 함수를 데코레이트 된 함수로
   설정한 프로퍼티의 사본을 만듭니다. 이것은 예제로 가장 잘 설명됩니다
   :

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

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

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

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

   이 코드는 첫 번째 예제와 정확히 동등합니다. 추가적인 함수들에 원래
   프로퍼티(이 경우 "x")와 같은 이름을 사용해야 합니다.

   반환된 프로퍼티 객체는 생성자 인자에 해당하는 "fget", "fset" 및
   "fdel" 어트리뷰트를 가집니다.

   버전 3.5에서 변경: 이제 프로퍼티 개체의 독스트링이 쓰기 가능합니다.

class range(stop)
class range(start, stop[, step])

   함수라기보다, "range" 는 실제로는 범위 와 시퀀스 형 --- list,
   tuple, range 에 설명된 대로 불변 시퀀스 형입니다.

repr(object)

   객체의 인쇄 가능한 표현을 포함한 문자열을 돌려줍니다. 많은 형에서,
   이 함수는 "eval()" 에 전달 될 때 같은 값을 가진 객체를 생성하는 문
   자열을 반환하려고 시도합니다, 그렇지 않으면 표현은 객체의 형의 이름
   과 종종 객체의 이름과 주소를 포함하는 추가의 정보를 화살괄호로 묶은
   문자열입니다. 클래스는 "__repr__()" 메서드를 정의하여 이 함수가 인
   스턴스에 대해 돌려주는 것을 제어할 수 있습니다.

reversed(seq)

   역 *이터레이터* 를 돌려줍니다. *seq* 는 "__reversed__()" 메서드를
   가졌거나 시퀀스 프로토콜("__len__()" 메서드와 "0" 에서 시작하는 정
   수 인자를 받는 "__getitem__()" 메서드)을 지원하는 객체여야 합니다.

round(number[, ndigits])

   *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" 및 집합 형 --- set, frozenset 을 보세요.

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

setattr(object, name, value)

   이것은 "getattr()" 과 한 쌍입니다. 인자는 객체, 문자열 및 임의의 값
   입니다. 문자열은 기존 어트리뷰트 또는 새 어트리뷰트의 이름을 지정할
   수 있습니다. 이 함수는 객체가 허용하는 경우 값을 어트리뷰트에 대입
   합니다. 예를 들어, "setattr(x, 'foobar', 123)" 는 "x.foobar = 123"
   과 동등합니다.

class slice(stop)
class slice(start, stop[, step])

   "range(start, stop, step)" 에 의해 지정된 인덱스 세트를 나타내는 *
   슬라이스* 객체를 돌려줍니다. *start* 및 *step* 인자의 기본값은
   "None" 입니다. 슬라이스 객체는 단지 인자 값 (또는 기본값)을 돌려주
   는 "start", "stop" 및 "step" 의 읽기 전용 데이터 어트리뷰트를 갖습
   니다. 다른 명시적 기능은 없습니다; 그러나 Numerical Python과 다른
   제삼자 확장이 사용합니다. 슬라이스 객체는 확장 인덱싱 문법을 사용할
   때도 만들어집니다. 예를 들어: "a[start:stop:step]" 또는
   "a[start:stop, i]". 이터레이터를 돌려주는 대안 버전은
   "itertools.islice()" 를 보세요.

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

   *iterable* 의 항목들로 새 정렬된 리스트를 돌려줍니다.

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

   *key* 는 하나의 인자를 받는 함수를 지정하는데, *iterable*의 각 요소
   들로부터 비교 키를 추출하는 데 사용됩니다 (예를 들어, "key =
   str.lower"). 기본값은 "None" 입니다 (요소를 직접 비교합니다).

   *reverse* 는 논리값입니다. "True" 로 설정되면, 각 비교가 뒤집힌 것
   처럼 리스트 요소들이 정렬됩니다.

   예전 스타일의 *cmp* 함수를 *key* 함수로 변환하려면
   "functools.cmp_to_key()" 를 사용하세요.

   내장 "sorted()" 함수는 안정적(stable)임이 보장됩니다. 정렬은 같다고
   비교되는 요소의 상대적 순서를 변경하지 않으면 안정적입니다 --- 이는
   여러 번 정렬할 때 유용합니다 (예를 들어, 부서별로 정렬한 후에 급여
   등급별로 정렬하기).

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

@staticmethod

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

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

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

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

   정적 메서드는 클래스 ("C.f()" 처럼) 또는 인스턴스 ("C().f()" 처럼)
   에 대해 호출할 수 있습니다.

   파이썬의 정적 메서드는 자바 또는 C++ 에서 발견되는 정적 메서드와 비
   슷합니다. 대체 클래스 생성자를 만드는 데 유용한 변형을 보려면
   "classmethod()" 도 보세요.

   모든 데코레이터와 마찬가지로, "staticmethod" 를 정규 함수로 호출하
   여 그 결과로 어떤 일을 할 수도 있습니다. 이것은 클래스 바디에서 함
   수에 대한 참조가 필요하고 인스턴스 메서드로 자동 변환되는 것을 피하
   고자 할 때 필요합니다. 이 경우 다음 관용구를 사용하세요:

      class C:
          builtin_open = staticmethod(open)

   정적 메서드에 대한 더 자세한 정보는, 표준형 계층을 참조하세요.

class str(object='')
class str(object=b'', encoding='utf-8', errors='strict')

   *object* 의 "str" 버전을 돌려줍니다. 자세한 내용은 "str()" 을 보세
   요.

   "str" 은 내장 문자열 *클래스* 입니다. 문자열에 대한 일반적인 정보는
   텍스트 시퀀스 형 --- str 를 보세요.

sum(iterable, /, start=0)

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

   어떤 경우에는 "sum()" 에 대한 좋은 대안이 있습니다. 문자열의 시퀀스
   를 연결하는 가장 선호되고 빠른 방법은 "''.join(sequence)" 를 호출하
   는 것입니다. 확장된 정밀도로 부동 소수점 값을 더하려면
   "math.fsum()" 를 보세요. 일련의 이터러블들을 연결하려면
   "itertools.chain()" 를 고려해보세요.

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

super([type[, object-or-type]])

   메서드 호출을 *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* 에는 두 가지 일반적인 사용 사례가 있습니다. 단일 상속 클래
   스 계층 구조에서는, *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)    # This does the same thing as:
                                     # super(C, self).method(arg)

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

   "super()" 는 "super().__getitem__(name)" 과 같은 명시적인 점으로 구
   분된 어트리뷰트 조회를 위한 연결 절차의 일부로 구현됨에 주의하세요.
   이것은 협력적인 다중 상속을 지원하는 예측 가능한 순서로 클래스를 검
   색하기 위해 자체 "__getattribute__()" 메서드를 구현함으로써 그렇게
   합니다. 따라서, "super()" 는 "super()[name]" 과같이 문장이나 연산자
   를 사용하는 묵시적 조회에 대해서는 정의되지 않았습니다.

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

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

class tuple([iterable])

   함수이기보다, "tuple" 은 실제로 튜플 과 시퀀스 형 --- list, tuple,
   range 에 문서화 된 것처럼 불변 시퀀스 형입니다.

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

   인자 하나의 경우, *object* 의 형을 돌려줍니다. 반환 값은 형 객체며
   일반적으로 "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))

   형 객체를 보세요.

   Keyword arguments provided to the three argument form are passed to
   the appropriate metaclass machinery (usually "__init_subclass__()")
   in the same way that keywords in a class definition (besides
   *metaclass*) would.

   See also 클래스 생성 커스터마이제이션.

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

vars([object])

   모듈, 클래스, 인스턴스 또는 "__dict__" 어트리뷰트가 있는 다른 객체
   의 "__dict__" 어트리뷰트를 돌려줍니다.

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

   인자가 없으면, "vars()" 는 "locals()" 처럼 동작합니다. locals 딕셔
   너리에 대한 변경이 무시되기 때문에 locals 딕셔너리는 읽기에만 유용
   하다는 것에 주의하세요.

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

zip(*iterables)

   각 iterables 의 요소들을 모으는 이터레이터를 만듭니다.

   튜플의 이터레이터를 돌려주는데, *i* 번째 튜플은 각 인자로 전달된 시
   퀀스나 이터러블의 *i* 번째 요소를 포함합니다. 이터레이터는 가장 짧
   은 입력 이터러블이 모두 소모되면 멈춥니다. 하나의 이터러블 인자를
   사용하면, 1-튜플의 이터레이터를 돌려줍니다. 인자가 없으면, 빈 이터
   레이터를 돌려줍니다. 다음과 동등합니다:

      def zip(*iterables):
          # zip('ABCD', 'xy') --> Ax By
          sentinel = object()
          iterators = [iter(it) for it in iterables]
          while iterators:
              result = []
              for it in iterators:
                  elem = next(it, sentinel)
                  if elem is sentinel:
                      return
                  result.append(elem)
              yield tuple(result)

   iterables 를 왼쪽에서 오른쪽으로 값을 구하는 순서가 보장됩니다. 이
   것은 "zip(*[iter(s)]*n)" 을 사용하여 데이터 시리즈를 길이 n인 그룹
   으로 클러스터링하는 관용구를 가능하게 만듭니다. 이것은 *같은* 이터
   레이터를 "n" 번 반복해서, 각 출력 튜플이 이터레이터를 "n" 번 호출한
   결과를 갖게 됩니다. 입력을 길이 n인 묶음으로 나누는 효과를 줍니다.

   "zip()" 에 길이가 같지 않은 입력들을 제공하는 것은, 끝부분에서 매치
   되지 않고 남는 더 긴 이터러블들의 값들에 신경 쓰지 않는 경우로 제한
   해야 합니다. 그 값들이 중요하다면, 대신 "itertools.zip_longest()"
   를 사용하세요.

   "zip()"을 "*" 연산자와 함께 쓰면 리스트를 unzip 할 수 있습니다:

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

__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* 인자를 전혀 사용하지 않고, "import" 문의 패키지 문맥을 결
   정할 때만 *globals* 를 사용합니다.

   *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
   으로 변경합니다).

-[ 각주 ]-

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