2. 내장 함수
************

The Python interpreter has a number of functions built into it that
are always available.  They are listed here in alphabetical order.

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

In addition, there are other four built-in functions that are no
longer considered essential: "apply()", "buffer()", "coerce()", and
"intern()".  They are documented in the Non-essential Built-in
Functions section.

abs(x)

   Return the absolute value of a number.  The argument may be a plain
   or long integer or a floating point number.  If the argument is a
   complex number, its magnitude is returned.

all(iterable)

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

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

   버전 2.5에 추가.

any(iterable)

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

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

   버전 2.5에 추가.

basestring()

   This abstract type is the superclass for "str" and "unicode". It
   cannot be called or instantiated, but it can be used to test
   whether an object is an instance of "str" or "unicode".
   "isinstance(obj, basestring)" is equivalent to "isinstance(obj,
   (str, unicode))".

   버전 2.3에 추가.

bin(x)

   Convert an integer number to a binary string. The result is a valid
   Python expression.  If *x* is not a Python "int" object, it has to
   define an "__index__()" method that returns an integer.

   버전 2.6에 추가.

class bool([x])

   Return a Boolean value, i.e. one of "True" or "False".  *x* is
   converted using the standard truth testing procedure.  If *x* is
   false or omitted, this returns "False"; otherwise it returns
   "True". "bool" is also a class, which is a subclass of "int". Class
   "bool" cannot be subclassed further.  Its only instances are
   "False" and "True".

   버전 2.2.1에 추가.

   버전 2.3에서 변경: If no argument is given, this function returns
   "False".

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

   Return a new array of bytes.  The "bytearray" class is a mutable
   sequence of integers in the range 0 <= x < 256.  It has most of the
   usual methods of mutable sequences, described in 가변 시퀀스 형, as
   well as most methods that the "str" type has, see 문자열 메서드.

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

   * If it is *unicode*, you must also give the *encoding* (and
     optionally, *errors*) parameters; "bytearray()" then converts the
     unicode to bytes using "unicode.encode()".

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

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

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

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

   버전 2.6에 추가.

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);
   class instances are callable if they have a "__call__()" method.

chr(i)

   Return a string of one character whose ASCII code is the integer
   *i*.  For example, "chr(97)" returns the string "'a'". This is the
   inverse of "ord()".  The argument must be in the range [0..255],
   inclusive; "ValueError" will be raised if *i* is outside that
   range. See also "unichr()".

classmethod(function)

   Return a class method for *function*.

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

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

   The "@classmethod" form is a function *decorator* -- see 함수 정의
   for details.

   A class method can be called either on the class (such as "C.f()")
   or on an instance (such as "C().f()").  The instance is ignored
   except for its class. If a class method is called for a derived
   class, the derived class object is passed as the implied first
   argument.

   Class methods are different than C++ or Java static methods. If you
   want those, see "staticmethod()".

   For more information on class methods, see 표준형 계층.

   버전 2.2에 추가.

   버전 2.4에서 변경: Function decorator syntax added.

cmp(x, y)

   Compare the two objects *x* and *y* and return an integer according
   to the outcome.  The return value is negative if "x < y", zero if
   "x == y" and strictly positive if "x > y".

compile(source, filename, mode[, flags[, dont_inherit]])

   Compile the *source* into a code or AST object.  Code objects can
   be executed by an "exec" statement or evaluated by a call to
   "eval()". *source* can either be a Unicode string, a *Latin-1*
   encoded string or an AST object. Refer to the "ast" module
   documentation for information on how to work with AST objects.

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

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

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

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

   This function raises "SyntaxError" if the compiled source is
   invalid, and "TypeError" if the source contains null bytes.

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

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

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

   버전 2.3에서 변경: The *flags* and *dont_inherit* arguments were
   added.

   버전 2.6에서 변경: Support for compiling AST objects.

   버전 2.7에서 변경: Allowed use of Windows and Mac newlines.  Also
   input in "'exec'" mode does not have to end in a newline anymore.

class complex([real[, imag]])

   Return a complex number with the value *real* + *imag**1j or
   convert a string or number to a complex number.  If the first
   parameter is a string, it will be interpreted as a complex number
   and the function must be called without a second parameter.  The
   second parameter can never be a string. Each argument may be any
   numeric type (including complex). If *imag* is omitted, it defaults
   to zero and the function serves as a numeric conversion function
   like "int()", "long()" and "float()".  If both arguments are
   omitted, returns "0j".

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

   복소수 형은 Numeric Types --- int, float, long, complex 에서 설명합
   니다.

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__', '__doc__', '__name__', 'struct']
   >>> dir(struct)   # show the names in the struct module
   ['Struct', '__builtins__', '__doc__', '__file__', '__name__',
    '__package__', '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
    'unpack', 'unpack_from']
   >>> class Shape(object):
           def __dir__(self):
               return ['area', 'perimeter', 'location']
   >>> s = Shape()
   >>> dir(s)
   ['area', 'perimeter', 'location']

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

divmod(a, b)

   Take two (non complex) numbers as arguments and return a pair of
   numbers consisting of their quotient and remainder when using long
   division.  With mixed operand types, the rules for binary
   arithmetic operators apply.  For plain and long integers, the
   result is the same as "(a // b, a % b)". For floating point numbers
   the result is "(q, a % b)", where *q* is usually "math.floor(a /
   b)" but may be 1 less than that.  In any case "q * b + a % b" is
   very close to *a*, if "a % b" is non-zero it has the same sign as
   *b*, and "0 <= abs(a % b) < abs(b)".

   버전 2.3에서 변경: Using "divmod()" with complex numbers is
   deprecated.

enumerate(sequence, start=0)

   Return an enumerate object. *sequence* must be a sequence, an
   *iterator*, or some other object which supports iteration.  The
   "next()" method of the iterator returned by "enumerate()" returns a
   tuple containing a count (from *start* which defaults to 0) and the
   values obtained from iterating over *sequence*:

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

   버전 2.3에 추가.

   버전 2.6에서 변경: The *start* parameter was added.

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

   The arguments are a Unicode or *Latin-1* encoded string and
   optional globals and locals.  If provided, *globals* must be a
   dictionary. If provided, *locals* can be any mapping object.

   버전 2.4에서 변경: formerly *locals* was required to be a
   dictionary.

   The *expression* argument is parsed and evaluated as a Python
   expression (technically speaking, a condition list) using the
   *globals* and *locals* dictionaries as global and local namespace.
   If the *globals* dictionary is present and lacks '__builtins__',
   the current globals are copied into *globals* before *expression*
   is parsed.  This means that *expression* normally has full access
   to the standard "__builtin__" module and restricted environments
   are propagated.  If the *locals* dictionary is omitted it defaults
   to the *globals* dictionary.  If both dictionaries are omitted, the
   expression is executed in the environment where "eval()" is called.
   The return value is the result of the evaluated expression. Syntax
   errors are reported as exceptions.  Example:

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

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

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

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

execfile(filename[, globals[, locals]])

   This function is similar to the "exec" statement, but parses a file
   instead of a string.  It is different from the "import" statement
   in that it does not use the module administration --- it reads the
   file unconditionally and does not create a new module. [1]

   The arguments are a file name and two optional dictionaries.  The
   file is parsed and evaluated as a sequence of Python statements
   (similarly to a module) using the *globals* and *locals*
   dictionaries as global and local namespace. If provided, *locals*
   can be any mapping object.  Remember that at module level, globals
   and locals are the same dictionary. If two separate objects are
   passed as *globals* and *locals*, the code will be executed as if
   it were embedded in a class definition.

   버전 2.4에서 변경: formerly *locals* was required to be a
   dictionary.

   If the *locals* dictionary is omitted it defaults to the *globals*
   dictionary. If both dictionaries are omitted, the expression is
   executed in the environment where "execfile()" is called.  The
   return value is "None".

   참고: The default *locals* act as described for function
     "locals()" below: modifications to the default *locals*
     dictionary should not be attempted.  Pass an explicit *locals*
     dictionary if you need to see effects of the code on *locals*
     after function "execfile()" returns.  "execfile()" cannot be used
     reliably to modify a function's locals.

file(name[, mode[, buffering]])

   Constructor function for the "file" type, described further in
   section File Objects.  The constructor's arguments are the same as
   those of the "open()" built-in function described below.

   When opening a file, it's preferable to use "open()" instead of
   invoking this constructor directly.  "file" is more suited to type
   testing (for example, writing "isinstance(f, file)").

   버전 2.2에 추가.

filter(function, iterable)

   Construct a list from those elements of *iterable* for which
   *function* returns true.  *iterable* may be either a sequence, a
   container which supports iteration, or an iterator.  If *iterable*
   is a string or a tuple, the result also has that type; otherwise it
   is always a list.  If *function* is "None", the identity function
   is assumed, that is, all elements of *iterable* that are false are
   removed.

   Note that "filter(function, iterable)" is equivalent to "[item for
   item in iterable if function(item)]" if function is not "None" and
   "[item for item in iterable if item]" if function is "None".

   See "itertools.ifilter()" and "itertools.ifilterfalse()" for
   iterator versions of this function, including a variation that
   filters for elements where the *function* returns false.

class float([x])

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

   If the argument is a string, it must contain a possibly signed
   decimal or floating point number, possibly embedded in whitespace.
   The argument may also be [+|-]nan or [+|-]inf. Otherwise, the
   argument may be a plain or long integer or a floating point number,
   and a floating point number with the same value (within Python's
   floating point precision) is returned.  If no argument is given,
   returns "0.0".

   참고: When passing in a string, values for NaN and Infinity may
     be returned, depending on the underlying C library.  Float
     accepts the strings nan, inf and -inf for NaN and positive or
     negative infinity. The case and a leading + are ignored as well
     as a leading - is ignored for NaN. Float always represents NaN
     and infinity as nan, inf or -inf.

   float 형은 Numeric Types --- int, float, long, complex 에 설명되어
   있습니다.

format(value[, format_spec])

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

   참고: "format(value, format_spec)" merely calls
     "value.__format__(format_spec)".

   버전 2.6에 추가.

class frozenset([iterable])

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

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

   버전 2.4에 추가.

getattr(object, name[, default])

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

globals()

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

hasattr(object, name)

   The arguments are an object and a string.  The result is "True" if
   the string is the name of one of the object's attributes, "False"
   if not. (This is implemented by calling "getattr(object, name)" and
   seeing whether it raises an exception or not.)

hash(object)

   Return the hash value of the object (if it has one).  Hash values
   are integers. They are used to quickly compare dictionary keys
   during a dictionary lookup. Numeric values that compare equal have
   the same hash value (even if they are of different types, as is the
   case for 1 and 1.0).

help([object])

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

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

   버전 2.2에 추가.

hex(x)

   Convert an integer number (of any size) to a lowercase hexadecimal
   string prefixed with "0x", for example:

   >>> hex(255)
   '0xff'
   >>> hex(-42)
   '-0x2a'
   >>> hex(1L)
   '0x1L'

   If x is not a Python "int" or "long" object, it has to define a
   __hex__() method that returns a string.

   16진수 문자열을 진수 16을 사용해서 정수로 변환하려면 "int()" 도 보
   세요.

   참고: float에 대한 16진수 문자열 표현을 얻으려면, "float.hex()"
     메서드 를 사용하세요.

   버전 2.4에서 변경: Formerly only returned an unsigned literal.

id(object)

   Return the "identity" of an object.  This is an integer (or long
   integer) which is guaranteed to be unique and constant for this
   object during its lifetime. Two objects with non-overlapping
   lifetimes may have the same "id()" value.

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

input([prompt])

   Equivalent to "eval(raw_input(prompt))".

   This function does not catch user errors. If the input is not
   syntactically valid, a "SyntaxError" will be raised. Other
   exceptions may be raised if there is an error during evaluation.

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

   Consider using the "raw_input()" function for general input from
   users.

class int(x=0)
class int(x, base=10)

   Return an integer object constructed from a number or string *x*,
   or return "0" if no arguments are given.  If *x* is a number, it
   can be a plain integer, a long integer, or a floating point number.
   If *x* is floating point, the conversion truncates towards zero.
   If the argument is outside the integer range, the function returns
   a long object instead.

   If *x* is not a number or if *base* is given, then *x* must be a
   string or Unicode object representing an integer literal in radix
   *base*.  Optionally, the literal can be preceded by "+" or "-"
   (with no space in between) and surrounded by whitespace.  A base-n
   literal consists of the digits 0 to n-1, with "a" to "z" (or "A" to
   "Z") having values 10 to 35.  The default *base* is 10. The allowed
   values are 0 and 2--36. Base-2, -8, and -16 literals can be
   optionally prefixed with "0b"/"0B", "0o"/"0O"/"0", or "0x"/"0X", as
   with integer literals in code. Base 0 means to interpret the string
   exactly as an integer literal, so that the actual base is 2, 8, 10,
   or 16.

   정수 형은 Numeric Types --- int, float, long, complex 에 설명되어
   있습니다.

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.  Also return true if *classinfo* is a type object
   (new-style class) and *object* is an object of that type or of a
   (direct, indirect or *virtual*) subclass thereof.  If *object* is
   not a class instance or an object of the given type, the function
   always returns false. If *classinfo* is a tuple of class or type
   objects (or recursively, other such tuples), return true if
   *object* is an instance of any of the classes or types.  If
   *classinfo* is not a class, type, or tuple of classes, types, and
   such tuples, a "TypeError" exception is raised.

   버전 2.2에서 변경: Support for a tuple of type information was
   added.

issubclass(class, classinfo)

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

   버전 2.3에서 변경: Support for a tuple of type information was
   added.

iter(o[, sentinel])

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

   두 번째 형태의 "iter()" 의 유용한 응용은 특정 줄에 도달할 때까지 파
   일의 줄을 읽는 것입니다. 다음의 예는 "readline()" 메서드가 빈 문자
   열을 돌려줄 때까지 파일을 읽습니다:

      with open('mydata.txt') as fp:
          for line in iter(fp.readline, ''):
              process_line(line)

   버전 2.2에 추가.

len(s)

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

class list([iterable])

   Return a list whose items are the same and in the same order as
   *iterable*'s items.  *iterable* may be either a sequence, a
   container that supports iteration, or an iterator object.  If
   *iterable* is already a list, a copy is made and returned, similar
   to "iterable[:]".  For instance, "list('abc')" returns "['a', 'b',
   'c']" and "list( (1, 2, 3) )" returns "[1, 2, 3]".  If no argument
   is given, returns a new empty list, "[]".

   "list" is a mutable sequence type, as documented in Sequence Types
   --- str, unicode, list, tuple, bytearray, buffer, xrange. For other
   containers see the built in "dict", "set", and "tuple" classes, and
   the "collections" module.

locals()

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

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

class long(x=0)
class long(x, base=10)

   Return a long integer object constructed from a string or number
   *x*. If the argument is a string, it must contain a possibly signed
   number of arbitrary size, possibly embedded in whitespace. The
   *base* argument is interpreted in the same way as for "int()", and
   may only be given when *x* is a string. Otherwise, the argument may
   be a plain or long integer or a floating point number, and a long
   integer with the same value is returned.    Conversion of floating
   point numbers to integers truncates (towards zero).  If no
   arguments are given, returns "0L".

   The long type is described in Numeric Types --- int, float, long,
   complex.

map(function, iterable, ...)

   Apply *function* to every item of *iterable* and return a list of
   the results. If additional *iterable* arguments are passed,
   *function* must take that many arguments and is applied to the
   items from all iterables in parallel.  If one iterable is shorter
   than another it is assumed to be extended with "None" items.  If
   *function* is "None", the identity function is assumed; if there
   are multiple arguments, "map()" returns a list consisting of tuples
   containing the corresponding items from all iterables (a kind of
   transpose operation).  The *iterable* arguments may be a sequence
   or any iterable object; the result is always a list.

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

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

   If one positional argument is provided, *iterable* must be a non-
   empty iterable (such as a non-empty string, tuple or list).  The
   largest item in the iterable is returned.  If two or more
   positional arguments are provided, the largest of the positional
   arguments is returned.

   The optional *key* argument specifies a one-argument ordering
   function like that used for "list.sort()".  The *key* argument, if
   supplied, must be in keyword form (for example,
   "max(a,b,c,key=func)").

   버전 2.5에서 변경: Added support for the optional *key* argument.

memoryview(obj)

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

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

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

   If one positional argument is provided, *iterable* must be a non-
   empty iterable (such as a non-empty string, tuple or list).  The
   smallest item in the iterable is returned.  If two or more
   positional arguments are provided, the smallest of the positional
   arguments is returned.

   The optional *key* argument specifies a one-argument ordering
   function like that used for "list.sort()".  The *key* argument, if
   supplied, must be in keyword form (for example,
   "min(a,b,c,key=func)").

   버전 2.5에서 변경: Added support for the optional *key* argument.

next(iterator[, default])

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

   버전 2.6에 추가.

class object

   Return a new featureless object.  "object" is a base for all new
   style classes.  It has the methods that are common to all instances
   of new style classes.

   버전 2.2에 추가.

   버전 2.3에서 변경: This function does not accept any arguments.
   Formerly, it accepted arguments but ignored them.

oct(x)

   Convert an integer number (of any size) to an octal string.  The
   result is a valid Python expression.

   버전 2.4에서 변경: Formerly only returned an unsigned literal.

open(name[, mode[, buffering]])

   Open a file, returning an object of the "file" type described in
   section File Objects.  If the file cannot be opened, "IOError" is
   raised.  When opening a file, it's preferable to use "open()"
   instead of invoking the "file" constructor directly.

   The first two arguments are the same as for "stdio"'s "fopen()":
   *name* is the file name to be opened, and *mode* is a string
   indicating how the file is to be opened.

   The most commonly-used values of *mode* are "'r'" for reading,
   "'w'" for writing (truncating the file if it already exists), and
   "'a'" for appending (which on *some* Unix systems means that *all*
   writes append to the end of the file regardless of the current seek
   position).  If *mode* is omitted, it defaults to "'r'".  The
   default is to use text mode, which may convert "'\n'" characters to
   a platform-specific representation on writing and back on reading.
   Thus, when opening a binary file, you should append "'b'" to the
   *mode* value to open the file in binary mode, which will improve
   portability.  (Appending "'b'" is useful even on systems that don't
   treat binary and text files differently, where it serves as
   documentation.)  See below for more possible values of *mode*.

   The optional *buffering* argument specifies the file's desired
   buffer size: 0 means unbuffered, 1 means line buffered, any other
   positive value means use a buffer of (approximately) that size (in
   bytes).  A negative *buffering* means to use the system default,
   which is usually line buffered for tty devices and fully buffered
   for other files.  If omitted, the system default is used. [2]

   Modes "'r+'", "'w+'" and "'a+'" open the file for updating (reading
   and writing); note that "'w+'" truncates the file.  Append "'b'" to
   the mode to open the file in binary mode, on systems that
   differentiate between binary and text files; on systems that don't
   have this distinction, adding the "'b'" has no effect.

   In addition to the standard "fopen()" values *mode* may be "'U'" or
   "'rU'".  Python is usually built with *universal newlines* support;
   supplying "'U'" opens the file as a text file, but lines may be
   terminated by any of the following: the Unix end-of-line convention
   "'\n'",  the Macintosh convention "'\r'", or the Windows convention
   "'\r\n'". All of these external representations are seen as "'\n'"
   by the Python program. If Python is built without universal
   newlines support a *mode* with "'U'" is the same as normal text
   mode.  Note that file objects so opened also have an attribute
   called "newlines" which has a value of "None" (if no newlines have
   yet been seen), "'\n'", "'\r'", "'\r\n'", or a tuple containing all
   the newline types seen.

   Python enforces that the mode, after stripping "'U'", begins with
   "'r'", "'w'" or "'a'".

   Python provides many file handling modules including "fileinput",
   "os", "os.path", "tempfile", and "shutil".

   버전 2.5에서 변경: Restriction on first letter of mode string
   introduced.

ord(c)

   Given a string of length one, return an integer representing the
   Unicode code point of the character when the argument is a unicode
   object, or the value of the byte when the argument is an 8-bit
   string. For example, "ord('a')" returns the integer "97",
   "ord(u'\u2020')" returns "8224".  This is the inverse of "chr()"
   for 8-bit strings and of "unichr()" for unicode objects.  If a
   unicode argument is given and Python was built with UCS2 Unicode,
   then the character's code point must be in the range [0..65535]
   inclusive; otherwise the string length is two, and a "TypeError"
   will be raised.

pow(x, y[, z])

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

   The arguments must have numeric types.  With mixed operand types,
   the coercion rules for binary arithmetic operators apply.  For int
   and long int operands, the result has the same type as the operands
   (after coercion) unless the second argument is negative; in that
   case, all arguments are converted to float and a float result is
   delivered.  For example, "10**2" returns "100", but "10**-2"
   returns "0.01".  (This last feature was added in Python 2.2.  In
   Python 2.1 and before, if both arguments were of integer types and
   the second argument was negative, an exception was raised.) If the
   second argument is negative, the third argument must be omitted. If
   *z* is present, *x* and *y* must be of integer types, and *y* must
   be non-negative.  (This restriction was added in Python 2.2.  In
   Python 2.1 and before, floating 3-argument "pow()" returned
   platform-dependent results depending on floating-point rounding
   accidents.)

print(*objects, sep=' ', end='\n', file=sys.stdout)

   Print *objects* to the stream *file*, separated by *sep* and
   followed by *end*.  *sep*, *end* and *file*, if present, must be
   given as keyword arguments.

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

   The *file* argument must be an object with a "write(string)"
   method; if it is not present or "None", "sys.stdout" will be used.
   Output buffering is determined by *file*.  Use "file.flush()" to
   ensure, for instance, immediate appearance on a screen.

   참고: This function is not normally available as a built-in since
     the name "print" is recognized as the "print" statement.  To
     disable the statement and use the "print()" function, use this
     future statement at the top of your module:

        from __future__ import print_function

   버전 2.6에 추가.

class property([fget[, fset[, fdel[, doc]]]])

   Return a property attribute for *new-style class*es (classes that
   derive from "object").

   *fget* 은 어트리뷰트 값을 얻는 함수입니다. *fset* 은 어트리뷰트 값
   을 설정하는 함수입니다. *fdel* 은 어트리뷰트 값을 삭제하는 함수입니
   다. 그리고 *doc* 은 어트리뷰트의 독스트링을 만듭니다.

   전형적인 사용은 관리되는 어트리뷰트 "x" 를 정의하는 것입니다:

      class C(object):
          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)를 호출하고, "cx =
   value" 는 세터(setter)를 호출하고, "del c.x" 는 딜리터(deleter)를
   호출합니다.

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

      class Parrot(object):
          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(object):
          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" 어트리뷰트를 가집니다.

   버전 2.2에 추가.

   버전 2.5에서 변경: Use *fget*'s docstring if no *doc* given.

   버전 2.6에서 변경: The "getter", "setter", and "deleter" attributes
   were added.

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

   This is a versatile function to create lists containing arithmetic
   progressions. It is most often used in "for" loops.  The arguments
   must be plain integers.  If the *step* argument is omitted, it
   defaults to "1".  If the *start* argument is omitted, it defaults
   to "0".  The full form returns a list of plain integers "[start,
   start + step, start + 2 * step, ...]".  If *step* is positive, the
   last element is the largest "start + i * step" less than *stop*; if
   *step* is negative, the last element is the smallest "start + i *
   step" greater than *stop*.  *step* must not be zero (or else
   "ValueError" is raised).  Example:

   >>> range(10)
   [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
   >>> range(1, 11)
   [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   >>> range(0, 30, 5)
   [0, 5, 10, 15, 20, 25]
   >>> range(0, 10, 3)
   [0, 3, 6, 9]
   >>> range(0, -10, -1)
   [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
   >>> range(0)
   []
   >>> range(1, 0)
   []

raw_input([prompt])

   If the *prompt* argument is present, it is written to standard
   output without a trailing newline.  The function then reads a line
   from input, converts it to a string (stripping a trailing newline),
   and returns that. When EOF is read, "EOFError" is raised. Example:

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

   If the "readline" module was loaded, then "raw_input()" will use it
   to provide elaborate line editing and history features.

reduce(function, iterable[, initializer])

   Apply *function* of two arguments cumulatively to the items of
   *iterable*, from left to right, so as to reduce the iterable to a
   single value.  For example, "reduce(lambda x, y: x+y, [1, 2, 3, 4,
   5])" calculates "((((1+2)+3)+4)+5)". The left argument, *x*, is the
   accumulated value and the right argument, *y*, is the update value
   from the *iterable*.  If the optional *initializer* is present, it
   is placed before the items of the iterable in the calculation, and
   serves as a default when the iterable is empty.  If *initializer*
   is not given and *iterable* contains only one item, the first item
   is returned. Roughly equivalent to:

      def reduce(function, iterable, initializer=None):
          it = iter(iterable)
          if initializer is None:
              try:
                  initializer = next(it)
              except StopIteration:
                  raise TypeError('reduce() of empty sequence with no initial value')
          accum_value = initializer
          for x in it:
              accum_value = function(accum_value, x)
          return accum_value

reload(module)

   Reload a previously imported *module*.  The argument must be a
   module object, so it must have been successfully imported before.
   This is useful if you have edited the module source file using an
   external editor and want to try out the new version without leaving
   the Python interpreter.  The return value is the module object (the
   same as the *module* argument).

   When "reload(module)" is executed:

   * Python modules' code is recompiled and the module-level code
     reexecuted, defining a new set of objects which are bound to
     names in the module's dictionary.  The "init" function of
     extension modules is not called a second time.

   * As with all other objects in Python the old objects are only
     reclaimed after their reference counts drop to zero.

   * The names in the module namespace are updated to point to any
     new or changed objects.

   * Other references to the old objects (such as names external to
     the module) are not rebound to refer to the new objects and must
     be updated in each namespace where they occur if that is desired.

   There are a number of other caveats:

   When a module is reloaded, its dictionary (containing the module's
   global variables) is retained.  Redefinitions of names will
   override the old definitions, so this is generally not a problem.
   If the new version of a module does not define a name that was
   defined by the old version, the old definition remains.  This
   feature can be used to the module's advantage if it maintains a
   global table or cache of objects --- with a "try" statement it can
   test for the table's presence and skip its initialization if
   desired:

      try:
          cache
      except NameError:
          cache = {}

   It is generally not very useful to reload built-in or dynamically
   loaded modules.  Reloading "sys", "__main__", "builtins" and other
   key modules is not recommended.  In many cases extension modules
   are not designed to be initialized more than once, and may fail in
   arbitrary ways when reloaded.

   If a module imports objects from another module using "from" ...
   "import" ..., calling "reload()" for the other module does not
   redefine the objects imported from it --- one way around this is to
   re-execute the "from" statement, another is to use "import" and
   qualified names (*module*.*name*) instead.

   If a module instantiates instances of a class, reloading the module
   that defines the class does not affect the method definitions of
   the instances --- they continue to use the old class definition.
   The same is true for derived classes.

repr(object)

   Return a string containing a printable representation of an object.
   This is the same value yielded by conversions (reverse quotes).  It
   is sometimes useful to be able to access this operation as an
   ordinary function.  For many types, this function makes an attempt
   to return a string that would yield an object with the same value
   when passed to "eval()", otherwise the representation is a string
   enclosed in angle brackets that contains the name of the type of
   the object together with additional information often including the
   name and address of the object.  A class can control what this
   function returns for its instances by defining a "__repr__()"
   method.

reversed(seq)

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

   버전 2.4에 추가.

   버전 2.6에서 변경: Added the possibility to write a custom
   "__reversed__()" method.

round(number[, ndigits])

   Return the floating point value *number* rounded to *ndigits*
   digits after the decimal point.  If *ndigits* is omitted, it
   defaults to zero. The result is a floating point number.  Values
   are rounded to the closest multiple of 10 to the power minus
   *ndigits*; if two multiples are equally close, rounding is done
   away from 0 (so, for example, "round(0.5)" is "1.0" and
   "round(-0.5)" is "-1.0").

   참고: 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" 모듈을 보세요.

   버전 2.4에 추가.

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[, cmp[, key[, reverse]]])

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

   The optional arguments *cmp*, *key*, and *reverse* have the same
   meaning as those for the "list.sort()" method (described in section
   가변 시퀀스 형).

   *cmp* specifies a custom comparison function of two arguments
   (iterable elements) which should return a negative, zero or
   positive number depending on whether the first argument is
   considered smaller than, equal to, or larger than the second
   argument: "cmp=lambda x,y: cmp(x.lower(), y.lower())".  The default
   value is "None".

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

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

   In general, the *key* and *reverse* conversion processes are much
   faster than specifying an equivalent *cmp* function.  This is
   because *cmp* is called multiple times for each list element while
   *key* and *reverse* touch each element only once.  Use
   "functools.cmp_to_key()" to convert an old-style *cmp* function to
   a *key* function.

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

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

   버전 2.4에 추가.

staticmethod(function)

   Return a static method for *function*.

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

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

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

   A static method can be called either on the class (such as "C.f()")
   or on an instance (such as "C().f()").

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

   For more information on static methods, see 표준형 계층.

   버전 2.2에 추가.

   버전 2.4에서 변경: Function decorator syntax added.

class str(object='')

   Return a string containing a nicely printable representation of an
   object.  For strings, this returns the string itself.  The
   difference with "repr(object)" is that "str(object)" does not
   always attempt to return a string that is acceptable to "eval()";
   its goal is to return a printable string.  If no argument is given,
   returns the empty string, "''".

   For more information on strings see Sequence Types --- str,
   unicode, list, tuple, bytearray, buffer, xrange which describes
   sequence functionality (strings are sequences), and also the
   string-specific methods described in the 문자열 메서드 section. To
   output formatted strings use template strings or the "%" operator
   described in the String Formatting Operations section. In addition
   see the String Services section. See also "unicode()".

sum(iterable[, start])

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

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

   버전 2.3에 추가.

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

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

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

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

   참고: "super()" only works for *new-style class*es.

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

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

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

      class C(B):
          def method(self, arg):
              super(C, self).method(arg)

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

   Also note that "super()" is not limited to use inside methods.  The
   two argument form specifies the arguments exactly and makes the
   appropriate references.

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

   버전 2.2에 추가.

tuple([iterable])

   Return a tuple whose items are the same and in the same order as
   *iterable*'s items.  *iterable* may be a sequence, a container that
   supports iteration, or an iterator object. If *iterable* is already
   a tuple, it is returned unchanged. For instance, "tuple('abc')"
   returns "('a', 'b', 'c')" and "tuple([1, 2, 3])" returns "(1, 2,
   3)".  If no argument is given, returns a new empty tuple, "()".

   "tuple" is an immutable sequence type, as documented in Sequence
   Types --- str, unicode, list, tuple, bytearray, buffer, xrange. For
   other containers see the built in "dict", "list", and "set"
   classes, and the "collections" module.

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

   With one argument, return the type of an *object*.  The return
   value is a type object.  The "isinstance()" built-in function is
   recommended for testing the type of an object.

   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 itemizes the base classes and becomes the "__bases__"
   attribute; and the *dict* dictionary is the namespace containing
   definitions for class body and becomes the "__dict__"  attribute.
   For example, the following two statements create identical "type"
   objects:

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

   버전 2.2에 추가.

unichr(i)

   Return the Unicode string of one character whose Unicode code is
   the integer *i*.  For example, "unichr(97)" returns the string
   "u'a'".  This is the inverse of "ord()" for Unicode strings.  The
   valid range for the argument depends how Python was configured --
   it may be either UCS2 [0..0xFFFF] or UCS4 [0..0x10FFFF].
   "ValueError" is raised otherwise. For ASCII and 8-bit strings see
   "chr()".

   버전 2.0에 추가.

unicode(object='')
unicode(object[, encoding[, errors]])

   Return the Unicode string version of *object* using one of the
   following modes:

   If *encoding* and/or *errors* are given, "unicode()" will decode
   the object which can either be an 8-bit string or a character
   buffer using the codec for *encoding*. The *encoding* parameter is
   a string giving the name of an encoding; if the encoding is not
   known, "LookupError" is raised. Error handling is done according to
   *errors*; this specifies the treatment of characters which are
   invalid in the input encoding.  If *errors* is "'strict'" (the
   default), a "ValueError" is raised on errors, while a value of
   "'ignore'" causes errors to be silently ignored, and a value of
   "'replace'" causes the official Unicode replacement character,
   "U+FFFD", to be used to replace input characters which cannot be
   decoded.  See also the "codecs" module.

   If no optional parameters are given, "unicode()" will mimic the
   behaviour of "str()" except that it returns Unicode strings instead
   of 8-bit strings. More precisely, if *object* is a Unicode string
   or subclass it will return that Unicode string without any
   additional decoding applied.

   For objects which provide a "__unicode__()" method, it will call
   this method without arguments to create a Unicode string. For all
   other objects, the 8-bit string version or representation is
   requested and then converted to a Unicode string using the codec
   for the default encoding in "'strict'" mode.

   For more information on Unicode strings see Sequence Types --- str,
   unicode, list, tuple, bytearray, buffer, xrange which describes
   sequence functionality (Unicode strings are sequences), and also
   the string-specific methods described in the 문자열 메서드 section.
   To output formatted strings use template strings or the "%"
   operator described in the String Formatting Operations section. In
   addition see the String Services section. See also "str()".

   버전 2.0에 추가.

   버전 2.2에서 변경: Support for "__unicode__()" added.

vars([object])

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

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

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

xrange(stop)
xrange(start, stop[, step])

   This function is very similar to "range()", but returns an xrange
   object instead of a list.  This is an opaque sequence type which
   yields the same values as the corresponding list, without actually
   storing them all simultaneously. The advantage of "xrange()" over
   "range()" is minimal (since "xrange()" still has to create the
   values when asked for them) except when a very large range is used
   on a memory-starved machine or when all of the range's elements are
   never used (such as when the loop is usually terminated with
   "break").  For more information on xrange objects, see XRange Type
   and Sequence Types --- str, unicode, list, tuple, bytearray,
   buffer, xrange.

   **CPython implementation detail:** "xrange()" is intended to be
   simple and fast.  Implementations may impose restrictions to
   achieve this.  The C implementation of Python restricts all
   arguments to native C longs ("short" Python integers), and also
   requires that the number of elements fit in a native C long.  If a
   larger range is needed, an alternate version can be crafted using
   the "itertools" module: "islice(count(start, step), (stop-
   start+step-1+2*(step<0))//step)".

zip([iterable, ...])

   This function returns a list of tuples, where the *i*-th tuple
   contains the *i*-th element from each of the argument sequences or
   iterables. The returned list is truncated in length to the length
   of the shortest argument sequence. When there are multiple
   arguments which are all of the same length, "zip()" is similar to
   "map()" with an initial argument of "None". With a single sequence
   argument, it returns a list of 1-tuples. With no arguments, it
   returns an empty list.

   The left-to-right evaluation order of the iterables is guaranteed.
   This makes possible an idiom for clustering a data series into
   n-length groups using "zip(*[iter(s)]*n)".

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

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

   버전 2.0에 추가.

   버전 2.4에서 변경: Formerly, "zip()" required at least one argument
   and "zip()" raised a "TypeError" instead of returning an empty
   list.

__import__(name[, globals[, locals[, fromlist[, level]]]])

   참고: 이것은 "importlib.import_module()" 과 달리 일상적인 파이썬
     프로그 래밍에서는 필요하지 않은 고급 함수입니다.

   This function is invoked by the "import" statement.  It can be
   replaced (by importing the "__builtin__" module and assigning to
   "__builtin__.__import__") in order to change semantics of the
   "import" statement, but nowadays it is usually simpler to use
   import hooks (see **PEP 302**).  Direct use of "__import__()" is
   rare, except in cases where you want to import a module whose name
   is only known at runtime.

   함수는 모듈 *name* 을 임포트 하는데, 잠재적으로 패키지 문맥에서 이
   름을 해석하는 방법을 결정하는데 주어진 *globals* 와 *locals* 를 사
   용합니다. *fromlist* 는 *name* 에 의해 주어진 모듈로부터 임포트 되
   어야 하는 객체 또는 서브 모듈의 이름을 제공합니다. 표준 구현은
   *locals* 인자를 전혀 사용하지 않고, "import" 문의 패키지 문맥을 결
   정할 때만 *globals* 를 사용합니다.

   *level* specifies whether to use absolute or relative imports.  The
   default is "-1" which indicates both absolute and relative imports
   will be attempted.  "0" means only perform absolute imports.
   Positive values for *level* indicate the number of parent
   directories to search relative to the directory of the module
   calling "__import__()".

   *name* 변수가 "package.module" 형식일 때, 일반적으로 *name* 에 의해
   명명된 모듈이 *아니라*, 최상위 패키지(첫 번째 점까지의 이름)가 반환
   됩니다. 그러나 비어 있지 않은 *fromlist* 인자가 주어지면 *name* 에
   의해 명명된 모듈이 반환됩니다.

   예를 들어, 문장 "import spam" 은 다음 코드를 닮은 바이트 코드를 생
   성합니다:

      spam = __import__('spam', globals(), locals(), [], -1)

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

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

   여기에서 "__import__()" 가 최상위 모듈을 돌려주는 것에 주목하세요.
   이것이 "import" 문에 의해 이름에 연결되는 객체이기 때문입니다.

   반면에, 문장 "from spam.ham import eggs, sausage as saus" 는 이런
   결과를 줍니다:

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

   여기서 "spam.ham" 모듈이 "__import__()" 에서 반환됩니다. 이 객체로
   부터, 임포트할 이름들을 가져온 후 해당 이름들로 대입됩니다.

   단순히 이름으로 모듈을 임포트 하기 원한다면 (잠재적으로 패키지 내에
   서), "importlib.import_module()" 을 사용하세요.

   버전 2.5에서 변경: The level parameter was added.

   버전 2.5에서 변경: Keyword support for parameters was added.


3. Non-essential Built-in Functions
***********************************

There are several built-in functions that are no longer essential to
learn, know or use in modern Python programming.  They have been kept
here to maintain backwards compatibility with programs written for
older versions of Python.

Python programmers, trainers, students and book writers should feel
free to bypass these functions without concerns about missing
something important.

apply(function, args[, keywords])

   The *function* argument must be a callable object (a user-defined
   or built-in function or method, or a class object) and the *args*
   argument must be a sequence.  The *function* is called with *args*
   as the argument list; the number of arguments is the length of the
   tuple. If the optional *keywords* argument is present, it must be a
   dictionary whose keys are strings.  It specifies keyword arguments
   to be added to the end of the argument list. Calling "apply()" is
   different from just calling "function(args)", since in that case
   there is always exactly one argument.  The use of "apply()" is
   equivalent to "function(*args, **keywords)".

   버전 2.3부터 폐지: Use "function(*args, **keywords)" instead of
   "apply(function, args, keywords)" (see 인자 목록 언 패킹).

buffer(object[, offset[, size]])

   The *object* argument must be an object that supports the buffer
   call interface (such as strings, arrays, and buffers).  A new
   buffer object will be created which references the *object*
   argument. The buffer object will be a slice from the beginning of
   *object* (or from the specified *offset*). The slice will extend to
   the end of *object* (or will have a length given by the *size*
   argument).

coerce(x, y)

   Return a tuple consisting of the two numeric arguments converted to
   a common type, using the same rules as used by arithmetic
   operations. If coercion is not possible, raise "TypeError".

intern(string)

   Enter *string* in the table of "interned" strings and return the
   interned string -- which is *string* itself or a copy. Interning
   strings is useful to gain a little performance on dictionary lookup
   -- if the keys in a dictionary are interned, and the lookup key is
   interned, the key comparisons (after hashing) can be done by a
   pointer compare instead of a string compare.  Normally, the names
   used in Python programs are automatically interned, and the
   dictionaries used to hold module, class or instance attributes have
   interned keys.

   버전 2.3에서 변경: Interned strings are not immortal (like they
   used to be in Python 2.2 and before); you must keep a reference to
   the return value of "intern()" around to benefit from it.

-[ 각주 ]-

[1] It is used relatively rarely so does not warrant being made
    into a statement.

[2] Specifying a buffer size currently has no effect on systems
    that don't have "setvbuf()".  The interface to specify the buffer
    size is not done using a method that calls "setvbuf()", because
    that may dump core when called after any I/O has been performed,
    and there's no reliable way to determine whether this is the case.

[3] In the current implementation, local variable bindings cannot
    normally be affected this way, but variables retrieved from other
    scopes (such as modules) can be.  This may change.
