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

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

+---------------------+-------------------+--------------------+--------------------+----------------------+
|                     |                   | 내장 함수          |                    |                      |
|=====================|===================|====================|====================|======================|
| "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)

   숫자의 절댓값을 돌려줍니다. 인자는 정수 또는 실수입니다. 인자가 복
   소수면 그 크기가 반환됩니다.

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()" 는 그것을 자동으로 호출하여,
   선택한 디버거에 들어갈 수 있도록 합니다.

   버전 3.7에 추가.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

callable(object)

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

   버전 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" 어트리
   뷰트로 찾을 수 있습니다.

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

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

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

   참고:

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

   경고:

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

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

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

class complex([real[, imag]])

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

   참고:

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

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

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

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()" 이 호출되는 환경에서 실
   행됩니다. 반환 값은 계산된 표현식의 결과입니다. 문법 에러는 예외로
   보고됩니다. 예:

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

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

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

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

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

   이 함수는 파이썬 코드의 동적 실행을 지원합니다. *object* 는 문자열
   또는 코드 객체여야 합니다. 문자열이면 문자열은 파이썬 문장들의 스위
   트로 파싱된 후 (문법 에러가 발생하지 않는 한) 실행됩니다. [1] 코드
   객체면, 단순히 실행됩니다. 모든 경우에, 실행되는 코드는 파일 입력으
   로 올바를 것이 기대됩니다 (레퍼런스 설명서의 "파일 입력" 섹션을 보
   세요). "return"과 "yield" 문은 "exec()" 함수에 전달 된 코드 문맥 안
   에서조차도 함수 정의 밖에서 사용될 수 없음에 유의하세요. 반환 값은
   "None" 입니다.

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

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

   참고:

     내장 함수 "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 __
   ()" 로 위임합니다.

   인자가 주어지지 않으면, "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*는 이제 위치 전용 매개 변수입니다.

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.

input([prompt])

   *prompt* 인자가 있으면, 끝에 개행 문자를 붙이지 않고 표준 출력에 씁
   니다. 그런 다음 함수는 입력에서 한 줄을 읽고, 문자열로 변환해서 (줄
   끝의 줄 바꿈 문자를 제거한다) 돌려줍니다. EOF를 읽으면 "EOFError"
   를 일으킵니다. 예:

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

   "readline" 모듈이 로드되었다면, "input()" 은 그것을 사용하여 정교한
   줄 편집과 히스토리 기능을 제공합니다.

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

   숫자 나 문자열 *x* 로 부터 만들어진 정수 객체를 돌려줍니다. 인자가
   주어지지 않으면 "0" 을 돌려줍니다. *x* 가 "__int__()" 를 정의하면,
   "int(x)" 는 "x.__int__()" 를 돌려줍니다. *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.7.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)

   Return "True" if the *object* argument is an instance of the
   *classinfo* argument, or of a (direct, indirect or *virtual*)
   subclass thereof.  If *object* is not an object of the given type,
   the function always returns "False". If *classinfo* is a tuple of
   type objects (or recursively, other such tuples), return "True" if
   *object* is an instance of any of the types. If *classinfo* is not
   a type or tuple of types and such tuples, a "TypeError" exception
   is raised.

issubclass(class, classinfo)

   Return "True" if *class* 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, in which case
   every entry in *classinfo* will be checked. In any other case, a
   "TypeError" exception is raised.

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* 키워드-전용 인자.

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* 키워드-전용 인자.

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+b'" 는 파일을
   열면서 0바이트로 자릅니다. "'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* 는 인코딩 및 디코딩 에러를 처리하는 방법을 지정하는 선택적
   문자열입니다. 바이너리 모드에서는 사용할 수 없습니다. 다양한 표준
   에러 처리기가 제공됩니다 (Error Handlers 에 나열됩니다). 하지만,
   "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" 와 같은 파일 처리 모듈들도 보세요.

      버전 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(x, y[, z])

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

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

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

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

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

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

   메서드 호출을 *type* 의 부모나 형제 클래스에 위임하는 프락시 객체를
   돌려줍니다. 이는 클래스에서 재정의된 상속 된 메서드를 액세스할 때
   유용합니다. 검색 순서는 *type* 자체를 건너뛰는 것을 제외하면,
   "getattr()" 에 의해 사용된 순서와 같습니다.

   *type* 의 "__mro__" 어트리뷰트는 메서드 결정 검색 순서를 나열하는데
   "getattr()" 과 "super()" 에서 사용됩니다. 이 어트리뷰트는 동적이며
   상속 계층 구조가 변경될 때마다 바뀔 수 있습니다.

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

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

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

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

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

   In addition to method lookups, "super()" also works for attribute
   lookups.  One possible use case for this is calling *descriptor*s
   in a parent or sibling class.

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

   인자 하나의 경우, *object* 의 형을 돌려줍니다. 반환 값은 형 객체며
   일반적으로 "object.__class__" 가 돌려주는 것과 같은 객체입니다.

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

   세 개의 인자를 주는 경우, 새 형 객체를 돌려줍니다. 이것은 본래
   "class" 문의 동적인 형태입니다. *name* 문자열은 클래스 이름이고
   "__name__" 어트리뷰트가 됩니다; *bases* 튜플은 베이스 클래스들을 항
   목화하고 "__bases__" 어트리뷰트가 됩니다; *dict* 딕셔너리는 클래스
   바디의 정의들이 들어있는 이름 공간이며 "__dict__" 어트리뷰트가 되도
   록 표준 딕셔너리에 복사됩니다. 예를 들어, 다음 두 문장은 같은
   "type" 객체를 만듭니다:

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

   형 객체를 보세요.

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

vars([object])

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

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

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

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