1 

     2 .. _built-in-funcs:

     3 

     4 Built-in Functions

     5 ==================

     6 

     7 The Python interpreter has a number of functions built into it that are always

     8 available.  They are listed here in alphabetical order.

     9 

    10 

    11 .. function:: __import__(name[, globals[, locals[, fromlist[, level]]]])

    12 

    13    .. index::

    14       statement: import

    15       module: ihooks

    16       module: rexec

    17       module: imp

    18 

    19    .. note::

    20 

    21       This is an advanced function that is not needed in everyday Python

    22       programming.

    23 

    24    The function is invoked by the :keyword:`import` statement.  It mainly exists

    25    so that you can replace it with another function that has a compatible

    26    interface, in order to change the semantics of the :keyword:`import` statement.

    27    See the built-in module :mod:`imp`, which defines some useful operations out

    28    of which you can build your own :func:`__import__` function.

    29 

    30    For example, the statement ``import spam`` results in the following call:

    31    ``__import__('spam', globals(), locals(), [], -1)``; the statement

    32    ``from spam.ham import eggs`` results in ``__import__('spam.ham', globals(),

    33    locals(), ['eggs'], -1)``.  Note that even though ``locals()`` and ``['eggs']``

    34    are passed in as arguments, the :func:`__import__` function does not set the

    35    local variable named ``eggs``; this is done by subsequent code that is generated

    36    for the import statement.  (In fact, the standard implementation does not use

    37    its *locals* argument at all, and uses its *globals* only to determine the

    38    package context of the :keyword:`import` statement.)

    39 

    40    When the *name* variable is of the form ``package.module``, normally, the

    41    top-level package (the name up till the first dot) is returned, *not* the

    42    module named by *name*.  However, when a non-empty *fromlist* argument is

    43    given, the module named by *name* is returned.  This is done for

    44    compatibility with the :term:`bytecode` generated for the different kinds of import

    45    statement; when using ``import spam.ham.eggs``, the top-level package

    46    :mod:`spam` must be placed in the importing namespace, but when using ``from

    47    spam.ham import eggs``, the ``spam.ham`` subpackage must be used to find the

    48    ``eggs`` variable.  As a workaround for this behavior, use :func:`getattr` to

    49    extract the desired components.  For example, you could define the following

    50    helper::

    51 

    52       def my_import(name):

    53           mod = __import__(name)

    54           components = name.split('.')

    55           for comp in components[1:]:

    56               mod = getattr(mod, comp)

    57           return mod

    58 

    59    *level* specifies whether to use absolute or relative imports. The default is

    60    ``-1`` which indicates both absolute and relative imports will be attempted.

    61    ``0`` means only perform absolute imports. Positive values for *level* indicate

    62    the number of parent directories to search relative to the directory of the

    63    module calling :func:`__import__`.

    64 

    65    .. versionchanged:: 2.5

    66       The level parameter was added.

    67 

    68    .. versionchanged:: 2.5

    69       Keyword support for parameters was added.

    70 

    71 

    72 .. function:: abs(x)

    73 

    74    Return the absolute value of a number.  The argument may be a plain or long

    75    integer or a floating point number.  If the argument is a complex number, its

    76    magnitude is returned.

    77 

    78 

    79 .. function:: all(iterable)

    80 

    81    Return True if all elements of the *iterable* are true. Equivalent to::

    82 

    83       def all(iterable):

    84           for element in iterable:

    85               if not element:

    86                   return False

    87           return True

    88 

    89    .. versionadded:: 2.5

    90 

    91 

    92 .. function:: any(iterable)

    93 

    94    Return True if any element of the *iterable* is true. Equivalent to::

    95 

    96       def any(iterable):

    97           for element in iterable:

    98               if element:

    99                   return True

   100           return False

   101 

   102    .. versionadded:: 2.5

   103 

   104 

   105 .. function:: basestring()

   106 

   107    This abstract type is the superclass for :class:`str` and :class:`unicode`. It

   108    cannot be called or instantiated, but it can be used to test whether an object

   109    is an instance of :class:`str` or :class:`unicode`. ``isinstance(obj,

   110    basestring)`` is equivalent to ``isinstance(obj, (str, unicode))``.

   111 

   112    .. versionadded:: 2.3

   113 

   114 

   115 .. function:: bin(x)

   116 

   117    Convert an integer number to a binary string. The result is a valid Python

   118    expression.  If *x* is not a Python :class:`int` object, it has to define an

   119    :meth:`__index__` method that returns an integer.

   120 

   121    .. versionadded:: 2.6

   122 

   123 

   124 .. function:: bool([x])

   125 

   126    Convert a value to a Boolean, using the standard truth testing procedure.  If

   127    *x* is false or omitted, this returns :const:`False`; otherwise it returns

   128    :const:`True`. :class:`bool` is also a class, which is a subclass of

   129    :class:`int`. Class :class:`bool` cannot be subclassed further.  Its only

   130    instances are :const:`False` and :const:`True`.

   131 

   132    .. index:: pair: Boolean; type

   133 

   134    .. versionadded:: 2.2.1

   135 

   136    .. versionchanged:: 2.3

   137       If no argument is given, this function returns :const:`False`.

   138 

   139 

   140 .. function:: callable(object)

   141 

   142    Return :const:`True` if the *object* argument appears callable,

   143    :const:`False` if not.  If this

   144    returns true, it is still possible that a call fails, but if it is false,

   145    calling *object* will never succeed.  Note that classes are callable (calling a

   146    class returns a new instance); class instances are callable if they have a

   147    :meth:`__call__` method.

   148 

   149 

   150 .. function:: chr(i)

   151 

   152    Return a string of one character whose ASCII code is the integer *i*.  For

   153    example, ``chr(97)`` returns the string ``'a'``. This is the inverse of

   154    :func:`ord`.  The argument must be in the range [0..255], inclusive;

   155    :exc:`ValueError` will be raised if *i* is outside that range. See

   156    also :func:`unichr`.

   157 

   158 

   159 .. function:: classmethod(function)

   160 

   161    Return a class method for *function*.

   162 

   163    A class method receives the class as implicit first argument, just like an

   164    instance method receives the instance. To declare a class method, use this

   165    idiom::

   166 

   167       class C:

   168           @classmethod

   169           def f(cls, arg1, arg2, ...): ...

   170 

   171    The ``@classmethod`` form is a function :term:`decorator` -- see the description

   172    of function definitions in :ref:`function` for details.

   173 

   174    It can be called either on the class (such as ``C.f()``) or on an instance (such

   175    as ``C().f()``).  The instance is ignored except for its class. If a class

   176    method is called for a derived class, the derived class object is passed as the

   177    implied first argument.

   178 

   179    Class methods are different than C++ or Java static methods. If you want those,

   180    see :func:`staticmethod` in this section.

   181 

   182    For more information on class methods, consult the documentation on the standard

   183    type hierarchy in :ref:`types`.

   184 

   185    .. versionadded:: 2.2

   186 

   187    .. versionchanged:: 2.4

   188       Function decorator syntax added.

   189 

   190 

   191 .. function:: cmp(x, y)

   192 

   193    Compare the two objects *x* and *y* and return an integer according to the

   194    outcome.  The return value is negative if ``x < y``, zero if ``x == y`` and

   195    strictly positive if ``x > y``.

   196 

   197 

   198 .. function:: compile(source, filename, mode[, flags[, dont_inherit]])

   199 

   200    Compile the *source* into a code or AST object.  Code objects can be executed

   201    by an :keyword:`exec` statement or evaluated by a call to :func:`eval`.

   202    *source* can either be a string or an AST object.  Refer to the :mod:`_ast`

   203    module documentation for information on how to compile into and from AST

   204    objects.

   205 

   206    When compiling a string with multi-line statements, two caveats apply: line

   207    endings must be represented by a single newline character (``'\n'``), and the

   208    input must be terminated by at least one newline character.  If line endings

   209    are represented by ``'\r\n'``, use the string :meth:`replace` method to

   210    change them into ``'\n'``.

   211 

   212    The *filename* argument should give the file from which the code was read;

   213    pass some recognizable value if it wasn't read from a file (``'<string>'`` is

   214    commonly used).

   215 

   216    The *mode* argument specifies what kind of code must be compiled; it can be

   217    ``'exec'`` if *source* consists of a sequence of statements, ``'eval'`` if it

   218    consists of a single expression, or ``'single'`` if it consists of a single

   219    interactive statement (in the latter case, expression statements that

   220    evaluate to something else than ``None`` will be printed).

   221 

   222    The optional arguments *flags* and *dont_inherit* (which are new in Python 2.2)

   223    control which future statements (see :pep:`236`) affect the compilation of

   224    *source*.  If neither is present (or both are zero) the code is compiled with

   225    those future statements that are in effect in the code that is calling compile.

   226    If the *flags* argument is given and *dont_inherit* is not (or is zero) then the

   227    future statements specified by the *flags* argument are used in addition to

   228    those that would be used anyway. If *dont_inherit* is a non-zero integer then

   229    the *flags* argument is it -- the future statements in effect around the call to

   230    compile are ignored.

   231 

   232    Future statements are specified by bits which can be bitwise ORed together to

   233    specify multiple statements.  The bitfield required to specify a given feature

   234    can be found as the :attr:`compiler_flag` attribute on the :class:`_Feature`

   235    instance in the :mod:`__future__` module.

   236 

   237    This function raises :exc:`SyntaxError` if the compiled source is invalid,

   238    and :exc:`TypeError` if the source contains null bytes.

   239 

   240    .. versionadded:: 2.6

   241       Support for compiling AST objects.

   242 

   243 

   244 .. function:: complex([real[, imag]])

   245 

   246    Create a complex number with the value *real* + *imag*\*j or convert a string or

   247    number to a complex number.  If the first parameter is a string, it will be

   248    interpreted as a complex number and the function must be called without a second

   249    parameter.  The second parameter can never be a string. Each argument may be any

   250    numeric type (including complex). If *imag* is omitted, it defaults to zero and

   251    the function serves as a numeric conversion function like :func:`int`,

   252    :func:`long` and :func:`float`.  If both arguments are omitted, returns ``0j``.

   253 

   254    The complex type is described in :ref:`typesnumeric`.

   255 

   256 

   257 .. function:: delattr(object, name)

   258 

   259    This is a relative of :func:`setattr`.  The arguments are an object and a

   260    string.  The string must be the name of one of the object's attributes.  The

   261    function deletes the named attribute, provided the object allows it.  For

   262    example, ``delattr(x, 'foobar')`` is equivalent to ``del x.foobar``.

   263 

   264 

   265 .. function:: dict([arg])

   266    :noindex:

   267 

   268    Create a new data dictionary, optionally with items taken from *arg*.

   269    The dictionary type is described in :ref:`typesmapping`.

   270 

   271    For other containers see the built in :class:`list`, :class:`set`, and

   272    :class:`tuple` classes, and the :mod:`collections` module.

   273 

   274 

   275 .. function:: dir([object])

   276 

   277    Without arguments, return the list of names in the current local scope.  With an

   278    argument, attempt to return a list of valid attributes for that object.

   279 

   280    If the object has a method named :meth:`__dir__`, this method will be called and

   281    must return the list of attributes. This allows objects that implement a custom

   282    :func:`__getattr__` or :func:`__getattribute__` function to customize the way

   283    :func:`dir` reports their attributes.

   284 

   285    If the object does not provide :meth:`__dir__`, the function tries its best to

   286    gather information from the object's :attr:`__dict__` attribute, if defined, and

   287    from its type object.  The resulting list is not necessarily complete, and may

   288    be inaccurate when the object has a custom :func:`__getattr__`.

   289 

   290    The default :func:`dir` mechanism behaves differently with different types of

   291    objects, as it attempts to produce the most relevant, rather than complete,

   292    information:

   293 

   294    * If the object is a module object, the list contains the names of the module's

   295      attributes.

   296 

   297    * If the object is a type or class object, the list contains the names of its

   298      attributes, and recursively of the attributes of its bases.

   299 

   300    * Otherwise, the list contains the object's attributes' names, the names of its

   301      class's attributes, and recursively of the attributes of its class's base

   302      classes.

   303 

   304    The resulting list is sorted alphabetically.  For example:

   305 

   306       >>> import struct

   307       >>> dir()   # doctest: +SKIP

   308       ['__builtins__', '__doc__', '__name__', 'struct']

   309       >>> dir(struct)   # doctest: +NORMALIZE_WHITESPACE

   310       ['Struct', '__builtins__', '__doc__', '__file__', '__name__',

   311        '__package__', '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',

   312        'unpack', 'unpack_from']

   313       >>> class Foo(object):

   314       ...     def __dir__(self):

   315       ...         return ["kan", "ga", "roo"]

   316       ...

   317       >>> f = Foo()

   318       >>> dir(f)

   319       ['ga', 'kan', 'roo']

   320 

   321    .. note::

   322 

   323       Because :func:`dir` is supplied primarily as a convenience for use at an

   324       interactive prompt, it tries to supply an interesting set of names more than it

   325       tries to supply a rigorously or consistently defined set of names, and its

   326       detailed behavior may change across releases.  For example, metaclass attributes

   327       are not in the result list when the argument is a class.

   328 

   329 

   330 .. function:: divmod(a, b)

   331 

   332    Take two (non complex) numbers as arguments and return a pair of numbers

   333    consisting of their quotient and remainder when using long division.  With mixed

   334    operand types, the rules for binary arithmetic operators apply.  For plain and

   335    long integers, the result is the same as ``(a // b, a % b)``. For floating point

   336    numbers the result is ``(q, a % b)``, where *q* is usually ``math.floor(a / b)``

   337    but may be 1 less than that.  In any case ``q * b + a % b`` is very close to

   338    *a*, if ``a % b`` is non-zero it has the same sign as *b*, and ``0 <= abs(a % b)

   339    < abs(b)``.

   340 

   341    .. versionchanged:: 2.3

   342       Using :func:`divmod` with complex numbers is deprecated.

   343 

   344 

   345 .. function:: enumerate(sequence[, start=0])

   346 

   347    Return an enumerate object. *sequence* must be a sequence, an

   348    :term:`iterator`, or some other object which supports iteration.  The

   349    :meth:`next` method of the iterator returned by :func:`enumerate` returns a

   350    tuple containing a count (from *start* which defaults to 0) and the

   351    corresponding value obtained from iterating over *iterable*.

   352    :func:`enumerate` is useful for obtaining an indexed series: ``(0, seq[0])``,

   353    ``(1, seq[1])``, ``(2, seq[2])``, .... For example:

   354 

   355       >>> for i, season in enumerate(['Spring', 'Summer', 'Fall', 'Winter']):

   356       ...     print i, season

   357       0 Spring

   358       1 Summer

   359       2 Fall

   360       3 Winter

   361 

   362    .. versionadded:: 2.3

   363    .. versionadded:: 2.6

   364       The *start* parameter.

   365 

   366 

   367 .. function:: eval(expression[, globals[, locals]])

   368 

   369    The arguments are a string and optional globals and locals.  If provided,

   370    *globals* must be a dictionary.  If provided, *locals* can be any mapping

   371    object.

   372 

   373    .. versionchanged:: 2.4

   374       formerly *locals* was required to be a dictionary.

   375 

   376    The *expression* argument is parsed and evaluated as a Python expression

   377    (technically speaking, a condition list) using the *globals* and *locals*

   378    dictionaries as global and local namespace.  If the *globals* dictionary is

   379    present and lacks '__builtins__', the current globals are copied into *globals*

   380    before *expression* is parsed.  This means that *expression* normally has full

   381    access to the standard :mod:`__builtin__` module and restricted environments are

   382    propagated.  If the *locals* dictionary is omitted it defaults to the *globals*

   383    dictionary.  If both dictionaries are omitted, the expression is executed in the

   384    environment where :func:`eval` is called.  The return value is the result of

   385    the evaluated expression. Syntax errors are reported as exceptions.  Example:

   386 

   387       >>> x = 1

   388       >>> print eval('x+1')

   389       2

   390 

   391    This function can also be used to execute arbitrary code objects (such as

   392    those created by :func:`compile`).  In this case pass a code object instead

   393    of a string.  If the code object has been compiled with ``'exec'`` as the

   394    *kind* argument, :func:`eval`\'s return value will be ``None``.

   395 

   396    Hints: dynamic execution of statements is supported by the :keyword:`exec`

   397    statement.  Execution of statements from a file is supported by the

   398    :func:`execfile` function.  The :func:`globals` and :func:`locals` functions

   399    returns the current global and local dictionary, respectively, which may be

   400    useful to pass around for use by :func:`eval` or :func:`execfile`.

   401 

   402 

   403 .. function:: execfile(filename[, globals[, locals]])

   404 

   405    This function is similar to the :keyword:`exec` statement, but parses a file

   406    instead of a string.  It is different from the :keyword:`import` statement in

   407    that it does not use the module administration --- it reads the file

   408    unconditionally and does not create a new module. [#]_

   409 

   410    The arguments are a file name and two optional dictionaries.  The file is parsed

   411    and evaluated as a sequence of Python statements (similarly to a module) using

   412    the *globals* and *locals* dictionaries as global and local namespace. If

   413    provided, *locals* can be any mapping object.

   414 

   415    .. versionchanged:: 2.4

   416       formerly *locals* was required to be a dictionary.

   417 

   418    If the *locals* dictionary is omitted it defaults to the *globals* dictionary.

   419    If both dictionaries are omitted, the expression is executed in the environment

   420    where :func:`execfile` is called.  The return value is ``None``.

   421 

   422    .. warning::

   423 

   424       The default *locals* act as described for function :func:`locals` below:

   425       modifications to the default *locals* dictionary should not be attempted.  Pass

   426       an explicit *locals* dictionary if you need to see effects of the code on

   427       *locals* after function :func:`execfile` returns.  :func:`execfile` cannot be

   428       used reliably to modify a function's locals.

   429 

   430 

   431 .. function:: file(filename[, mode[, bufsize]])

   432 

   433    Constructor function for the :class:`file` type, described further in section

   434    :ref:`bltin-file-objects`.  The constructor's arguments are the same as those

   435    of the :func:`open` built-in function described below.

   436 

   437    When opening a file, it's preferable to use :func:`open` instead of  invoking

   438    this constructor directly.  :class:`file` is more suited to type testing (for

   439    example, writing ``isinstance(f, file)``).

   440 

   441    .. versionadded:: 2.2

   442 

   443 

   444 .. function:: filter(function, iterable)

   445 

   446    Construct a list from those elements of *iterable* for which *function* returns

   447    true.  *iterable* may be either a sequence, a container which supports

   448    iteration, or an iterator.  If *iterable* is a string or a tuple, the result

   449    also has that type; otherwise it is always a list.  If *function* is ``None``,

   450    the identity function is assumed, that is, all elements of *iterable* that are

   451    false are removed.

   452 

   453    Note that ``filter(function, iterable)`` is equivalent to ``[item for item in

   454    iterable if function(item)]`` if function is not ``None`` and ``[item for item

   455    in iterable if item]`` if function is ``None``.

   456 

   457 

   458 .. function:: float([x])

   459 

   460    Convert a string or a number to floating point.  If the argument is a string, it

   461    must contain a possibly signed decimal or floating point number, possibly

   462    embedded in whitespace. The argument may also be [+|-]nan or [+|-]inf.

   463    Otherwise, the argument may be a plain or long integer

   464    or a floating point number, and a floating point number with the same value

   465    (within Python's floating point precision) is returned.  If no argument is

   466    given, returns ``0.0``.

   467 

   468    .. note::

   469 

   470       .. index::

   471          single: NaN

   472          single: Infinity

   473 

   474       When passing in a string, values for NaN and Infinity may be returned, depending

   475       on the underlying C library.  Float accepts the strings nan, inf and -inf for

   476       NaN and positive or negative infinity. The case and a leading + are ignored as

   477       well as a leading - is ignored for NaN. Float always represents NaN and infinity

   478       as nan, inf or -inf.

   479 

   480    The float type is described in :ref:`typesnumeric`.

   481 

   482 .. function:: frozenset([iterable])

   483    :noindex:

   484 

   485    Return a frozenset object, optionally with elements taken from *iterable*.

   486    The frozenset type is described in :ref:`types-set`.

   487 

   488    For other containers see the built in :class:`dict`, :class:`list`, and

   489    :class:`tuple` classes, and the :mod:`collections` module.

   490 

   491    .. versionadded:: 2.4

   492 

   493 

   494 .. function:: getattr(object, name[, default])

   495 

   496    Return the value of the named attributed of *object*.  *name* must be a string.

   497    If the string is the name of one of the object's attributes, the result is the

   498    value of that attribute.  For example, ``getattr(x, 'foobar')`` is equivalent to

   499    ``x.foobar``.  If the named attribute does not exist, *default* is returned if

   500    provided, otherwise :exc:`AttributeError` is raised.

   501 

   502 

   503 .. function:: globals()

   504 

   505    Return a dictionary representing the current global symbol table. This is always

   506    the dictionary of the current module (inside a function or method, this is the

   507    module where it is defined, not the module from which it is called).

   508 

   509 

   510 .. function:: hasattr(object, name)

   511 

   512    The arguments are an object and a string.  The result is ``True`` if the string

   513    is the name of one of the object's attributes, ``False`` if not. (This is

   514    implemented by calling ``getattr(object, name)`` and seeing whether it raises an

   515    exception or not.)

   516 

   517 

   518 .. function:: hash(object)

   519 

   520    Return the hash value of the object (if it has one).  Hash values are integers.

   521    They are used to quickly compare dictionary keys during a dictionary lookup.

   522    Numeric values that compare equal have the same hash value (even if they are of

   523    different types, as is the case for 1 and 1.0).

   524 

   525 

   526 .. function:: help([object])

   527 

   528    Invoke the built-in help system.  (This function is intended for interactive

   529    use.)  If no argument is given, the interactive help system starts on the

   530    interpreter console.  If the argument is a string, then the string is looked up

   531    as the name of a module, function, class, method, keyword, or documentation

   532    topic, and a help page is printed on the console.  If the argument is any other

   533    kind of object, a help page on the object is generated.

   534 

   535    This function is added to the built-in namespace by the :mod:`site` module.

   536 

   537    .. versionadded:: 2.2

   538 

   539 

   540 .. function:: hex(x)

   541 

   542    Convert an integer number (of any size) to a hexadecimal string. The result is a

   543    valid Python expression.

   544 

   545    .. versionchanged:: 2.4

   546       Formerly only returned an unsigned literal.

   547 

   548 

   549 .. function:: id(object)

   550 

   551    Return the "identity" of an object.  This is an integer (or long integer) which

   552    is guaranteed to be unique and constant for this object during its lifetime.

   553    Two objects with non-overlapping lifetimes may have the same :func:`id` value.

   554    (Implementation note: this is the address of the object.)

   555 

   556 

   557 .. function:: input([prompt])

   558 

   559    Equivalent to ``eval(raw_input(prompt))``.

   560 

   561    .. warning::

   562 

   563       This function is not safe from user errors!  It expects a valid Python

   564       expression as input; if the input is not syntactically valid, a

   565       :exc:`SyntaxError` will be raised. Other exceptions may be raised if there is an

   566       error during evaluation.  (On the other hand, sometimes this is exactly what you

   567       need when writing a quick script for expert use.)

   568 

   569    If the :mod:`readline` module was loaded, then :func:`input` will use it to

   570    provide elaborate line editing and history features.

   571 

   572    Consider using the :func:`raw_input` function for general input from users.

   573 

   574 

   575 .. function:: int([x[, radix]])

   576 

   577    Convert a string or number to a plain integer.  If the argument is a string,

   578    it must contain a possibly signed decimal number representable as a Python

   579    integer, possibly embedded in whitespace.  The *radix* parameter gives the

   580    base for the conversion (which is 10 by default) and may be any integer in

   581    the range [2, 36], or zero.  If *radix* is zero, the proper radix is

   582    determined based on the contents of string; the interpretation is the same as

   583    for integer literals.  (See :ref:`numbers`.)  If *radix* is specified and *x*

   584    is not a string, :exc:`TypeError` is raised. Otherwise, the argument may be a

   585    plain or long integer or a floating point number.  Conversion of floating

   586    point numbers to integers truncates (towards zero).  If the argument is

   587    outside the integer range a long object will be returned instead.  If no

   588    arguments are given, returns ``0``.

   589 

   590    The integer type is described in :ref:`typesnumeric`.

   591 

   592 

   593 .. function:: isinstance(object, classinfo)

   594 

   595    Return true if the *object* argument is an instance of the *classinfo* argument,

   596    or of a (direct or indirect) subclass thereof.  Also return true if *classinfo*

   597    is a type object (new-style class) and *object* is an object of that type or of

   598    a (direct or indirect) subclass thereof.  If *object* is not a class instance or

   599    an object of the given type, the function always returns false.  If *classinfo*

   600    is neither a class object nor a type object, it may be a tuple of class or type

   601    objects, or may recursively contain other such tuples (other sequence types are

   602    not accepted).  If *classinfo* is not a class, type, or tuple of classes, types,

   603    and such tuples, a :exc:`TypeError` exception is raised.

   604 

   605    .. versionchanged:: 2.2

   606       Support for a tuple of type information was added.

   607 

   608 

   609 .. function:: issubclass(class, classinfo)

   610 

   611    Return true if *class* is a subclass (direct or indirect) of *classinfo*.  A

   612    class is considered a subclass of itself. *classinfo* may be a tuple of class

   613    objects, in which case every entry in *classinfo* will be checked. In any other

   614    case, a :exc:`TypeError` exception is raised.

   615 

   616    .. versionchanged:: 2.3

   617       Support for a tuple of type information was added.

   618 

   619 

   620 .. function:: iter(o[, sentinel])

   621 

   622    Return an :term:`iterator` object.  The first argument is interpreted very differently

   623    depending on the presence of the second argument. Without a second argument, *o*

   624    must be a collection object which supports the iteration protocol (the

   625    :meth:`__iter__` method), or it must support the sequence protocol (the

   626    :meth:`__getitem__` method with integer arguments starting at ``0``).  If it

   627    does not support either of those protocols, :exc:`TypeError` is raised. If the

   628    second argument, *sentinel*, is given, then *o* must be a callable object.  The

   629    iterator created in this case will call *o* with no arguments for each call to

   630    its :meth:`next` method; if the value returned is equal to *sentinel*,

   631    :exc:`StopIteration` will be raised, otherwise the value will be returned.

   632 

   633    .. versionadded:: 2.2

   634 

   635 

   636 .. function:: len(s)

   637 

   638    Return the length (the number of items) of an object.  The argument may be a

   639    sequence (string, tuple or list) or a mapping (dictionary).

   640 

   641 

   642 .. function:: list([iterable])

   643 

   644    Return a list whose items are the same and in the same order as *iterable*'s

   645    items.  *iterable* may be either a sequence, a container that supports

   646    iteration, or an iterator object.  If *iterable* is already a list, a copy is

   647    made and returned, similar to ``iterable[:]``.  For instance, ``list('abc')``

   648    returns ``['a', 'b', 'c']`` and ``list( (1, 2, 3) )`` returns ``[1, 2, 3]``.  If

   649    no argument is given, returns a new empty list, ``[]``.

   650 

   651    :class:`list` is a mutable sequence type, as documented in

   652    :ref:`typesseq`. For other containers see the built in :class:`dict`,

   653    :class:`set`, and :class:`tuple` classes, and the :mod:`collections` module.

   654 

   655 

   656 .. function:: locals()

   657 

   658    Update and return a dictionary representing the current local symbol table.

   659 

   660    .. warning::

   661 

   662       The contents of this dictionary should not be modified; changes may not affect

   663       the values of local variables used by the interpreter.

   664 

   665    Free variables are returned by :func:`locals` when it is called in a function block.

   666    Modifications of free variables may not affect the values used by the

   667    interpreter.  Free variables are not returned in class blocks.

   668 

   669 

   670 .. function:: long([x[, radix]])

   671 

   672    Convert a string or number to a long integer.  If the argument is a string, it

   673    must contain a possibly signed number of arbitrary size, possibly embedded in

   674    whitespace. The *radix* argument is interpreted in the same way as for

   675    :func:`int`, and may only be given when *x* is a string. Otherwise, the argument

   676    may be a plain or long integer or a floating point number, and a long integer

   677    with the same value is returned.    Conversion of floating point numbers to

   678    integers truncates (towards zero).  If no arguments are given, returns ``0L``.

   679 

   680    The long type is described in :ref:`typesnumeric`.

   681 

   682 .. function:: map(function, iterable, ...)

   683 

   684    Apply *function* to every item of *iterable* and return a list of the results.

   685    If additional *iterable* arguments are passed, *function* must take that many

   686    arguments and is applied to the items from all iterables in parallel.  If one

   687    iterable is shorter than another it is assumed to be extended with ``None``

   688    items.  If *function* is ``None``, the identity function is assumed; if there

   689    are multiple arguments, :func:`map` returns a list consisting of tuples

   690    containing the corresponding items from all iterables (a kind of transpose

   691    operation).  The *iterable* arguments may be a sequence  or any iterable object;

   692    the result is always a list.

   693 

   694 

   695 .. function:: max(iterable[, args...][key])

   696 

   697    With a single argument *iterable*, return the largest item of a non-empty

   698    iterable (such as a string, tuple or list).  With more than one argument, return

   699    the largest of the arguments.

   700 

   701    The optional *key* argument specifies a one-argument ordering function like that

   702    used for :meth:`list.sort`.  The *key* argument, if supplied, must be in keyword

   703    form (for example, ``max(a,b,c,key=func)``).

   704 

   705    .. versionchanged:: 2.5

   706       Added support for the optional *key* argument.

   707 

   708 

   709 .. function:: min(iterable[, args...][key])

   710 

   711    With a single argument *iterable*, return the smallest item of a non-empty

   712    iterable (such as a string, tuple or list).  With more than one argument, return

   713    the smallest of the arguments.

   714 

   715    The optional *key* argument specifies a one-argument ordering function like that

   716    used for :meth:`list.sort`.  The *key* argument, if supplied, must be in keyword

   717    form (for example, ``min(a,b,c,key=func)``).

   718 

   719    .. versionchanged:: 2.5

   720       Added support for the optional *key* argument.

   721 

   722 

   723 .. function:: next(iterator[, default])

   724 

   725    Retrieve the next item from the *iterator* by calling its :meth:`next`

   726    method.  If *default* is given, it is returned if the iterator is exhausted,

   727    otherwise :exc:`StopIteration` is raised.

   728 

   729    .. versionadded:: 2.6

   730 

   731 

   732 .. function:: object()

   733 

   734    Return a new featureless object.  :class:`object` is a base for all new style

   735    classes.  It has the methods that are common to all instances of new style

   736    classes.

   737 

   738    .. versionadded:: 2.2

   739 

   740    .. versionchanged:: 2.3

   741       This function does not accept any arguments. Formerly, it accepted arguments but

   742       ignored them.

   743 

   744 

   745 .. function:: oct(x)

   746 

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

   748    valid Python expression.

   749 

   750    .. versionchanged:: 2.4

   751       Formerly only returned an unsigned literal.

   752 

   753 

   754 .. function:: open(filename[, mode[, bufsize]])

   755 

   756    Open a file, returning an object of the :class:`file` type described in

   757    section :ref:`bltin-file-objects`.  If the file cannot be opened,

   758    :exc:`IOError` is raised.  When opening a file, it's preferable to use

   759    :func:`open` instead of invoking the :class:`file` constructor directly.

   760 

   761    The first two arguments are the same as for ``stdio``'s :cfunc:`fopen`:

   762    *filename* is the file name to be opened, and *mode* is a string indicating how

   763    the file is to be opened.

   764 

   765    The most commonly-used values of *mode* are ``'r'`` for reading, ``'w'`` for

   766    writing (truncating the file if it already exists), and ``'a'`` for appending

   767    (which on *some* Unix systems means that *all* writes append to the end of the

   768    file regardless of the current seek position).  If *mode* is omitted, it

   769    defaults to ``'r'``.  The default is to use text mode, which may convert

   770    ``'\n'`` characters to a platform-specific representation on writing and back

   771    on reading.  Thus, when opening a binary file, you should append ``'b'`` to

   772    the *mode* value to open the file in binary mode, which will improve

   773    portability.  (Appending ``'b'`` is useful even on systems that don't treat

   774    binary and text files differently, where it serves as documentation.)  See below

   775    for more possible values of *mode*.

   776 

   777    .. index::

   778       single: line-buffered I/O

   779       single: unbuffered I/O

   780       single: buffer size, I/O

   781       single: I/O control; buffering

   782 

   783    The optional *bufsize* argument specifies the file's desired buffer size: 0

   784    means unbuffered, 1 means line buffered, any other positive value means use a

   785    buffer of (approximately) that size.  A negative *bufsize* means to use the

   786    system default, which is usually line buffered for tty devices and fully

   787    buffered for other files.  If omitted, the system default is used. [#]_

   788 

   789    Modes ``'r+'``, ``'w+'`` and ``'a+'`` open the file for updating (note that

   790    ``'w+'`` truncates the file).  Append ``'b'`` to the mode to open the file in

   791    binary mode, on systems that differentiate between binary and text files; on

   792    systems that don't have this distinction, adding the ``'b'`` has no effect.

   793 

   794    In addition to the standard :cfunc:`fopen` values *mode* may be ``'U'`` or

   795    ``'rU'``.  Python is usually built with universal newline support; supplying

   796    ``'U'`` opens the file as a text file, but lines may be terminated by any of the

   797    following: the Unix end-of-line convention ``'\n'``,  the Macintosh convention

   798    ``'\r'``, or the Windows convention ``'\r\n'``. All of these external

   799    representations are seen as ``'\n'`` by the Python program. If Python is built

   800    without universal newline support a *mode* with ``'U'`` is the same as normal

   801    text mode.  Note that file objects so opened also have an attribute called

   802    :attr:`newlines` which has a value of ``None`` (if no newlines have yet been

   803    seen), ``'\n'``, ``'\r'``, ``'\r\n'``, or a tuple containing all the newline

   804    types seen.

   805 

   806    Python enforces that the mode, after stripping ``'U'``, begins with ``'r'``,

   807    ``'w'`` or ``'a'``.

   808 

   809    Python provides many file handling modules including

   810    :mod:`fileinput`, :mod:`os`, :mod:`os.path`, :mod:`tempfile`, and

   811    :mod:`shutil`.

   812 

   813    .. versionchanged:: 2.5

   814       Restriction on first letter of mode string introduced.

   815 

   816 

   817 .. function:: ord(c)

   818 

   819    Given a string of length one, return an integer representing the Unicode code

   820    point of the character when the argument is a unicode object, or the value of

   821    the byte when the argument is an 8-bit string. For example, ``ord('a')`` returns

   822    the integer ``97``, ``ord(u'\u2020')`` returns ``8224``.  This is the inverse of

   823    :func:`chr` for 8-bit strings and of :func:`unichr` for unicode objects.  If a

   824    unicode argument is given and Python was built with UCS2 Unicode, then the

   825    character's code point must be in the range [0..65535] inclusive; otherwise the

   826    string length is two, and a :exc:`TypeError` will be raised.

   827 

   828 

   829 .. function:: pow(x, y[, z])

   830 

   831    Return *x* to the power *y*; if *z* is present, return *x* to the power *y*,

   832    modulo *z* (computed more efficiently than ``pow(x, y) % z``). The two-argument

   833    form ``pow(x, y)`` is equivalent to using the power operator: ``x**y``.

   834 

   835    The arguments must have numeric types.  With mixed operand types, the coercion

   836    rules for binary arithmetic operators apply.  For int and long int operands, the

   837    result has the same type as the operands (after coercion) unless the second

   838    argument is negative; in that case, all arguments are converted to float and a

   839    float result is delivered.  For example, ``10**2`` returns ``100``, but

   840    ``10**-2`` returns ``0.01``.  (This last feature was added in Python 2.2.  In

   841    Python 2.1 and before, if both arguments were of integer types and the second

   842    argument was negative, an exception was raised.) If the second argument is

   843    negative, the third argument must be omitted. If *z* is present, *x* and *y*

   844    must be of integer types, and *y* must be non-negative.  (This restriction was

   845    added in Python 2.2.  In Python 2.1 and before, floating 3-argument ``pow()``

   846    returned platform-dependent results depending on floating-point rounding

   847    accidents.)

   848 

   849 

   850 .. function:: print([object, ...][, sep=' '][, end='\n'][, file=sys.stdout])

   851 

   852    Print *object*\(s) to the stream *file*, separated by *sep* and followed by

   853    *end*.  *sep*, *end* and *file*, if present, must be given as keyword

   854    arguments.

   855 

   856    All non-keyword arguments are converted to strings like :func:`str` does and

   857    written to the stream, separated by *sep* and followed by *end*.  Both *sep*

   858    and *end* must be strings; they can also be ``None``, which means to use the

   859    default values.  If no *object* is given, :func:`print` will just write

   860    *end*.

   861 

   862    The *file* argument must be an object with a ``write(string)`` method; if it

   863    is not present or ``None``, :data:`sys.stdout` will be used.

   864 

   865    .. note::

   866 

   867       This function is not normally available as a builtin since the name

   868       ``print`` is recognized as the :keyword:`print` statement.  To disable the

   869       statement and use the :func:`print` function, use this future statement at

   870       the top of your module::

   871 

   872          from __future__ import print_function

   873 

   874    .. versionadded:: 2.6

   875 

   876 

   877 .. function:: property([fget[, fset[, fdel[, doc]]]])

   878 

   879    Return a property attribute for :term:`new-style class`\es (classes that

   880    derive from :class:`object`).

   881 

   882    *fget* is a function for getting an attribute value, likewise *fset* is a

   883    function for setting, and *fdel* a function for del'ing, an attribute.  Typical

   884    use is to define a managed attribute x::

   885 

   886       class C(object):

   887           def __init__(self):

   888               self._x = None

   889 

   890           def getx(self):

   891               return self._x

   892           def setx(self, value):

   893               self._x = value

   894           def delx(self):

   895               del self._x

   896           x = property(getx, setx, delx, "I'm the 'x' property.")

   897 

   898    If given, *doc* will be the docstring of the property attribute. Otherwise, the

   899    property will copy *fget*'s docstring (if it exists).  This makes it possible to

   900    create read-only properties easily using :func:`property` as a :term:`decorator`::

   901 

   902       class Parrot(object):

   903           def __init__(self):

   904               self._voltage = 100000

   905 

   906           @property

   907           def voltage(self):

   908               """Get the current voltage."""

   909               return self._voltage

   910 

   911    turns the :meth:`voltage` method into a "getter" for a read-only attribute

   912    with the same name.

   913 

   914    A property object has :attr:`getter`, :attr:`setter`, and :attr:`deleter`

   915    methods usable as decorators that create a copy of the property with the

   916    corresponding accessor function set to the decorated function.  This is

   917    best explained with an example::

   918 

   919       class C(object):

   920           def __init__(self):

   921               self._x = None

   922 

   923           @property

   924           def x(self):

   925               """I'm the 'x' property."""

   926               return self._x

   927 

   928           @x.setter

   929           def x(self, value):

   930               self._x = value

   931 

   932           @x.deleter

   933           def x(self):

   934               del self._x

   935 

   936    This code is exactly equivalent to the first example.  Be sure to give the

   937    additional functions the same name as the original property (``x`` in this

   938    case.)

   939 

   940    The returned property also has the attributes ``fget``, ``fset``, and

   941    ``fdel`` corresponding to the constructor arguments.

   942 

   943    .. versionadded:: 2.2

   944 

   945    .. versionchanged:: 2.5

   946       Use *fget*'s docstring if no *doc* given.

   947 

   948    .. versionchanged:: 2.6 

   949       The ``getter``, ``setter``, and ``deleter`` attributes were added.

   950 

   951 

   952 .. function:: range([start,] stop[, step])

   953 

   954    This is a versatile function to create lists containing arithmetic progressions.

   955    It is most often used in :keyword:`for` loops.  The arguments must be plain

   956    integers.  If the *step* argument is omitted, it defaults to ``1``.  If the

   957    *start* argument is omitted, it defaults to ``0``.  The full form returns a list

   958    of plain integers ``[start, start + step, start + 2 * step, ...]``.  If *step*

   959    is positive, the last element is the largest ``start + i * step`` less than

   960    *stop*; if *step* is negative, the last element is the smallest ``start + i *

   961    step`` greater than *stop*.  *step* must not be zero (or else :exc:`ValueError`

   962    is raised).  Example:

   963 

   964       >>> range(10)

   965       [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

   966       >>> range(1, 11)

   967       [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

   968       >>> range(0, 30, 5)

   969       [0, 5, 10, 15, 20, 25]

   970       >>> range(0, 10, 3)

   971       [0, 3, 6, 9]

   972       >>> range(0, -10, -1)

   973       [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

   974       >>> range(0)

   975       []

   976       >>> range(1, 0)

   977       []

   978 

   979 

   980 .. function:: raw_input([prompt])

   981 

   982    If the *prompt* argument is present, it is written to standard output without a

   983    trailing newline.  The function then reads a line from input, converts it to a

   984    string (stripping a trailing newline), and returns that. When EOF is read,

   985    :exc:`EOFError` is raised. Example::

   986 

   987       >>> s = raw_input('--> ')

   988       --> Monty Python's Flying Circus

   989       >>> s

   990       "Monty Python's Flying Circus"

   991 

   992    If the :mod:`readline` module was loaded, then :func:`raw_input` will use it to

   993    provide elaborate line editing and history features.

   994 

   995 

   996 .. function:: reduce(function, iterable[, initializer])

   997 

   998    Apply *function* of two arguments cumulatively to the items of *iterable*, from

   999    left to right, so as to reduce the iterable to a single value.  For example,

  1000    ``reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])`` calculates ``((((1+2)+3)+4)+5)``.

  1001    The left argument, *x*, is the accumulated value and the right argument, *y*, is

  1002    the update value from the *iterable*.  If the optional *initializer* is present,

  1003    it is placed before the items of the iterable in the calculation, and serves as

  1004    a default when the iterable is empty.  If *initializer* is not given and

  1005    *iterable* contains only one item, the first item is returned.

  1006 

  1007 

  1008 .. function:: reload(module)

  1009 

  1010    Reload a previously imported *module*.  The argument must be a module object, so

  1011    it must have been successfully imported before.  This is useful if you have

  1012    edited the module source file using an external editor and want to try out the

  1013    new version without leaving the Python interpreter.  The return value is the

  1014    module object (the same as the *module* argument).

  1015 

  1016    When ``reload(module)`` is executed:

  1017 

  1018    * Python modules' code is recompiled and the module-level code reexecuted,

  1019      defining a new set of objects which are bound to names in the module's

  1020      dictionary.  The ``init`` function of extension modules is not called a second

  1021      time.

  1022 

  1023    * As with all other objects in Python the old objects are only reclaimed after

  1024      their reference counts drop to zero.

  1025 

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

  1027      objects.

  1028 

  1029    * Other references to the old objects (such as names external to the module) are

  1030      not rebound to refer to the new objects and must be updated in each namespace

  1031      where they occur if that is desired.

  1032 

  1033    There are a number of other caveats:

  1034 

  1035    If a module is syntactically correct but its initialization fails, the first

  1036    :keyword:`import` statement for it does not bind its name locally, but does

  1037    store a (partially initialized) module object in ``sys.modules``.  To reload the

  1038    module you must first :keyword:`import` it again (this will bind the name to the

  1039    partially initialized module object) before you can :func:`reload` it.

  1040 

  1041    When a module is reloaded, its dictionary (containing the module's global

  1042    variables) is retained.  Redefinitions of names will override the old

  1043    definitions, so this is generally not a problem.  If the new version of a module

  1044    does not define a name that was defined by the old version, the old definition

  1045    remains.  This feature can be used to the module's advantage if it maintains a

  1046    global table or cache of objects --- with a :keyword:`try` statement it can test

  1047    for the table's presence and skip its initialization if desired::

  1048 

  1049       try:

  1050           cache

  1051       except NameError:

  1052           cache = {}

  1053 

  1054    It is legal though generally not very useful to reload built-in or dynamically

  1055    loaded modules, except for :mod:`sys`, :mod:`__main__` and :mod:`__builtin__`.

  1056    In many cases, however, extension modules are not designed to be initialized

  1057    more than once, and may fail in arbitrary ways when reloaded.

  1058 

  1059    If a module imports objects from another module using :keyword:`from` ...

  1060    :keyword:`import` ..., calling :func:`reload` for the other module does not

  1061    redefine the objects imported from it --- one way around this is to re-execute

  1062    the :keyword:`from` statement, another is to use :keyword:`import` and qualified

  1063    names (*module*.*name*) instead.

  1064 

  1065    If a module instantiates instances of a class, reloading the module that defines

  1066    the class does not affect the method definitions of the instances --- they

  1067    continue to use the old class definition.  The same is true for derived classes.

  1068 

  1069 

  1070 .. function:: repr(object)

  1071 

  1072    Return a string containing a printable representation of an object.  This is

  1073    the same value yielded by conversions (reverse quotes).  It is sometimes

  1074    useful to be able to access this operation as an ordinary function.  For many

  1075    types, this function makes an attempt to return a string that would yield an

  1076    object with the same value when passed to :func:`eval`, otherwise the

  1077    representation is a string enclosed in angle brackets that contains the name

  1078    of the type of the object together with additional information often

  1079    including the name and address of the object.  A class can control what this

  1080    function returns for its instances by defining a :meth:`__repr__` method.

  1081 

  1082 

  1083 .. function:: reversed(seq)

  1084 

  1085    Return a reverse :term:`iterator`.  *seq* must be an object which has

  1086    a :meth:`__reversed__` method or supports the sequence protocol (the

  1087    :meth:`__len__` method and the :meth:`__getitem__` method with integer

  1088    arguments starting at ``0``).

  1089 

  1090    .. versionadded:: 2.4

  1091 

  1092    .. versionchanged:: 2.6

  1093       Added the possibility to write a custom :meth:`__reversed__` method.

  1094 

  1095 

  1096 .. function:: round(x[, n])

  1097 

  1098    Return the floating point value *x* rounded to *n* digits after the decimal

  1099    point.  If *n* is omitted, it defaults to zero. The result is a floating point

  1100    number.  Values are rounded to the closest multiple of 10 to the power minus

  1101    *n*; if two multiples are equally close, rounding is done away from 0 (so. for

  1102    example, ``round(0.5)`` is ``1.0`` and ``round(-0.5)`` is ``-1.0``).

  1103 

  1104 

  1105 .. function:: set([iterable])

  1106    :noindex:

  1107 

  1108    Return a new set, optionally with elements are taken from *iterable*.

  1109    The set type is described in :ref:`types-set`.

  1110 

  1111    For other containers see the built in :class:`dict`, :class:`list`, and

  1112    :class:`tuple` classes, and the :mod:`collections` module.

  1113 

  1114    .. versionadded:: 2.4

  1115 

  1116 

  1117 .. function:: setattr(object, name, value)

  1118 

  1119    This is the counterpart of :func:`getattr`.  The arguments are an object, a

  1120    string and an arbitrary value.  The string may name an existing attribute or a

  1121    new attribute.  The function assigns the value to the attribute, provided the

  1122    object allows it.  For example, ``setattr(x, 'foobar', 123)`` is equivalent to

  1123    ``x.foobar = 123``.

  1124 

  1125 

  1126 .. function:: slice([start,] stop[, step])

  1127 

  1128    .. index:: single: Numerical Python

  1129 

  1130    Return a :term:`slice` object representing the set of indices specified by

  1131    ``range(start, stop, step)``.  The *start* and *step* arguments default to

  1132    ``None``.  Slice objects have read-only data attributes :attr:`start`,

  1133    :attr:`stop` and :attr:`step` which merely return the argument values (or their

  1134    default).  They have no other explicit functionality; however they are used by

  1135    Numerical Python and other third party extensions.  Slice objects are also