内建函数

内建函数如下：

FUNCTIONS
    __import__(...)
        __import__(name, globals={}, locals={}, fromlist=[], level=-1) -> module
        
        Import a module. Because this function is meant for use by the Python
        interpreter and not for general use it is better to use
        importlib.import_module() to programmatically import a module.
        
        The globals argument is only used to determine the context;
        they are not modified.  The locals argument is unused.  The fromlist
        should be a list of names to emulate ``from name import ...'', or an
        empty list to emulate ``import name''.
        When importing a module from a package, note that __import__('A.B', ...)
        returns package A when fromlist is empty, but its submodule B when
        fromlist is not empty.  Level is used to determine whether to perform 
        absolute or relative imports.  -1 is the original strategy of attempting
        both absolute and relative imports, 0 is absolute, a positive number
        is the number of parent directories to search relative to the current module.
    
    abs(...)
        abs(number) -> number
        
        Return the absolute value of the argument.
    
    all(...)
        all(iterable) -> bool
        
        Return True if bool(x) is True for all values x in the iterable.
        If the iterable is empty, return True.
    
    any(...)
        any(iterable) -> bool
        
        Return True if bool(x) is True for any x in the iterable.
        If the iterable is empty, return False.
    
    apply(...)
        apply(object[, args[, kwargs]]) -> value
        
        Call a callable object with positional arguments taken from the tuple args,
        and keyword arguments taken from the optional dictionary kwargs.
        Note that classes are callable, as are instances with a __call__() method.
        
        Deprecated since release 2.3. Instead, use the extended call syntax:
            function(*args, **keywords).
    
    bin(...)
        bin(number) -> string
        
        Return the binary representation of an integer or long integer.
    
    callable(...)
        callable(object) -> bool
        
        Return whether the object is callable (i.e., some kind of function).
        Note that classes are callable, as are instances with a __call__() method.
    
    chr(...)
        chr(i) -> character
        
        Return a string of one character with ordinal i; 0 <= i < 256.
    
    cmp(...)
        cmp(x, y) -> integer
        
        Return negative if x<y, zero if x==y, positive if x>y.
    
    coerce(...)
        coerce(x, y) -> (x1, y1)
        
        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.
    
    compile(...)
        compile(source, filename, mode[, flags[, dont_inherit]]) -> code object
        
        Compile the source string (a Python module, statement or expression)
        into a code object that can be executed by the exec statement or eval().
        The filename will be used for run-time error messages.
        The mode must be 'exec' to compile a module, 'single' to compile a
        single (interactive) statement, or 'eval' to compile an expression.
        The flags argument, if present, controls which future statements influence
        the compilation of the code.
        The dont_inherit argument, if non-zero, stops the compilation inheriting
        the effects of any future statements in effect in the code calling
        compile; if absent or zero these statements do influence the compilation,
        in addition to any features explicitly specified.
    
    delattr(...)
        delattr(object, name)
        
        Delete a named attribute on an object; delattr(x, 'y') is equivalent to
        ``del x.y''.
    
    dir(...)
        dir([object]) -> list of strings
        
        If called without an argument, return the names in the current scope.
        Else, return an alphabetized list of names comprising (some of) the attributes
        of the given object, and of attributes reachable from it.
        If the object supplies a method named __dir__, it will be used; otherwise
        the default dir() logic is used and returns:
          for a module object: the module's attributes.
          for a class object:  its attributes, and recursively the attributes
            of its bases.
          for any other object: its attributes, its class's attributes, and
            recursively the attributes of its class's base classes.
    
    divmod(...)
        divmod(x, y) -> (quotient, remainder)
        
        Return the tuple (x//y, x%y).  Invariant: div*y + mod == x.
    
    eval(...)
        eval(source[, globals[, locals]]) -> value
        
        Evaluate the source in the context of globals and locals.
        The source may be a string representing a Python expression
        or a code object as returned by compile().
        The globals must be a dictionary and locals can be any mapping,
        defaulting to the current globals and locals.
        If only globals is given, locals defaults to it.
    
    execfile(...)
        execfile(filename[, globals[, locals]])
        
        Read and execute a Python script from a file.
        The globals and locals are dictionaries, defaulting to the current
        globals and locals.  If only globals is given, locals defaults to it.
    
    filter(...)
        filter(function or None, sequence) -> list, tuple, or string
        
        Return those items of sequence for which function(item) is true.  If
        function is None, return the items that are true.  If sequence is a tuple
        or string, return the same type, else return a list.
    
    format(...)
        format(value[, format_spec]) -> string
        
        Returns value.__format__(format_spec)
        format_spec defaults to ""
    
    getattr(...)
        getattr(object, name[, default]) -> value
        
        Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
        When a default argument is given, it is returned when the attribute doesn't
        exist; without it, an exception is raised in that case.
    
    globals(...)
        globals() -> dictionary
        
        Return the dictionary containing the current scope's global variables.
    
    hasattr(...)
        hasattr(object, name) -> bool
        
        Return whether the object has an attribute with the given name.
        (This is done by calling getattr(object, name) and catching exceptions.)
    
    hash(...)
        hash(object) -> integer
        
        Return a hash value for the object.  Two objects with the same value have
        the same hash value.  The reverse is not necessarily true, but likely.
    
    hex(...)
        hex(number) -> string
        
        Return the hexadecimal representation of an integer or long integer.
    
    id(...)
        id(object) -> integer
        
        Return the identity of an object.  This is guaranteed to be unique among
        simultaneously existing objects.  (Hint: it's the object's memory address.)
    
    input(...)
        input([prompt]) -> value
        
        Equivalent to eval(raw_input(prompt)).
    
    intern(...)
        intern(string) -> string
        
        ``Intern'' the given string.  This enters the string in the (global)
        table of interned strings whose purpose is to speed up dictionary lookups.
        Return the string itself or the previously interned string object with the
        same value.
    
    isinstance(...)
        isinstance(object, class-or-type-or-tuple) -> bool
        
        Return whether an object is an instance of a class or of a subclass thereof.
        With a type as second argument, return whether that is the object's type.
        The form using a tuple, isinstance(x, (A, B, ...)), is a shortcut for
        isinstance(x, A) or isinstance(x, B) or ... (etc.).
    
    issubclass(...)
        issubclass(C, B) -> bool
        
        Return whether class C is a subclass (i.e., a derived class) of class B.
        When using a tuple as the second argument issubclass(X, (A, B, ...)),
        is a shortcut for issubclass(X, A) or issubclass(X, B) or ... (etc.).
    
    iter(...)
        iter(collection) -> iterator
        iter(callable, sentinel) -> iterator
        
        Get an iterator from an object.  In the first form, the argument must
        supply its own iterator, or be a sequence.
        In the second form, the callable is called until it returns the sentinel.
    
    len(...)
        len(object) -> integer
        
        Return the number of items of a sequence or collection.
    
    locals(...)
        locals() -> dictionary
        
        Update and return a dictionary containing the current scope's local variables.
    
    map(...)
        map(function, sequence[, sequence, ...]) -> list
        
        Return a list of the results of applying the function to the items of
        the argument sequence(s).  If more than one sequence is given, the
        function is called with an argument list consisting of the corresponding
        item of each sequence, substituting None for missing values when not all
        sequences have the same length.  If the function is None, return a list of
        the items of the sequence (or a list of tuples if more than one sequence).
    
    max(...)
        max(iterable[, key=func]) -> value
        max(a, b, c, ...[, key=func]) -> value
        
        With a single iterable argument, return its largest item.
        With two or more arguments, return the largest argument.
    
    min(...)
        min(iterable[, key=func]) -> value
        min(a, b, c, ...[, key=func]) -> value
        
        With a single iterable argument, return its smallest item.
        With two or more arguments, return the smallest argument.
    
    next(...)
        next(iterator[, default])
        
        Return the next item from the iterator. If default is given and the iterator
        is exhausted, it is returned instead of raising StopIteration.
    
    oct(...)
        oct(number) -> string
        
        Return the octal representation of an integer or long integer.
    
    open(...)
        open(name[, mode[, buffering]]) -> file object
        
        Open a file using the file() type, returns a file object.  This is the
        preferred way to open a file.  See file.__doc__ for further information.
    
    ord(...)
        ord(c) -> integer
        
        Return the integer ordinal of a one-character string.
    
    pow(...)
        pow(x, y[, z]) -> number
        
        With two arguments, equivalent to x**y.  With three arguments,
        equivalent to (x**y) % z, but may be more efficient (e.g. for longs).
    
    print(...)
        print(value, ..., sep=' ', end='
', file=sys.stdout)
        
        Prints the values to a stream, or to sys.stdout by default.
        Optional keyword arguments:
        file: a file-like object (stream); defaults to the current sys.stdout.
        sep:  string inserted between values, default a space.
        end:  string appended after the last value, default a newline.
    
    range(...)
        range(stop) -> list of integers
        range(start, stop[, step]) -> list of integers
        
        Return a list containing an arithmetic progression of integers.
        range(i, j) returns [i, i+1, i+2, ..., j-1]; start (!) defaults to 0.
        When step is given, it specifies the increment (or decrement).
        For example, range(4) returns [0, 1, 2, 3].  The end point is omitted!
        These are exactly the valid indices for a list of 4 elements.
    
    raw_input(...)
        raw_input([prompt]) -> string
        
        Read a string from standard input.  The trailing newline is stripped.
        If the user hits EOF (Unix: Ctl-D, Windows: Ctl-Z+Return), raise EOFError.
        On Unix, GNU readline is used if enabled.  The prompt string, if given,
        is printed without a trailing newline before reading.
    
    reduce(...)
        reduce(function, sequence[, initial]) -> value
        
        Apply a function of two arguments cumulatively to the items of a sequence,
        from left to right, so as to reduce the sequence to a single value.
        For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
        ((((1+2)+3)+4)+5).  If initial is present, it is placed before the items
        of the sequence in the calculation, and serves as a default when the
        sequence is empty.
    
    reload(...)
        reload(module) -> module
        
        Reload the module.  The module must have been successfully imported before.
    
    repr(...)
        repr(object) -> string
        
        Return the canonical string representation of the object.
        For most object types, eval(repr(object)) == object.
    
    round(...)
        round(number[, ndigits]) -> floating point number
        
        Round a number to a given precision in decimal digits (default 0 digits).
        This always returns a floating point number.  Precision may be negative.
    
    setattr(...)
        setattr(object, name, value)
        
        Set a named attribute on an object; setattr(x, 'y', v) is equivalent to
        ``x.y = v''.
    
    sorted(...)
        sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list
    
    sum(...)
        sum(sequence[, start]) -> value
        
        Return the sum of a sequence of numbers (NOT strings) plus the value
        of parameter 'start' (which defaults to 0).  When the sequence is
        empty, return start.
    
    unichr(...)
        unichr(i) -> Unicode character
        
        Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.
    
    vars(...)
        vars([object]) -> dictionary
        
        Without arguments, equivalent to locals().
        With an argument, equivalent to object.__dict__.
    
    zip(...)
        zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)]
        
        Return a list of tuples, where each tuple contains the i-th element
        from each of the argument sequences.  The returned list is truncated
        in length to the length of the shortest argument sequence.