diff options
Diffstat (limited to 'Doc/lib/libfuncs.tex')
| -rw-r--r-- | Doc/lib/libfuncs.tex | 1345 |
1 files changed, 0 insertions, 1345 deletions
diff --git a/Doc/lib/libfuncs.tex b/Doc/lib/libfuncs.tex deleted file mode 100644 index bff33aa..0000000 --- a/Doc/lib/libfuncs.tex +++ /dev/null @@ -1,1345 +0,0 @@ -\section{Built-in Functions \label{built-in-funcs}} - -The Python interpreter has a number of functions built into it that -are always available. They are listed here in alphabetical order. - - -\setindexsubitem{(built-in function)} - -\begin{funcdesc}{__import__}{name\optional{, globals\optional{, locals\optional{, fromlist\optional{, level}}}}} - This function is invoked by the \keyword{import}\stindex{import} - statement. It mainly exists so that you can replace it with another - function that has a compatible interface, in order to change the - semantics of the \keyword{import} statement. For examples of why - and how you would do this, see the standard library modules - \module{ihooks}\refstmodindex{ihooks} and - \refmodule{rexec}\refstmodindex{rexec}. See also the built-in - module \refmodule{imp}\refbimodindex{imp}, which defines some useful - operations out of which you can build your own - \function{__import__()} function. - - For example, the statement \samp{import spam} results in the - following call: \code{__import__('spam',} \code{globals(),} - \code{locals(), [], -1)}; the statement \samp{from spam.ham import eggs} - results in \samp{__import__('spam.ham', globals(), locals(), - ['eggs'], -1)}. Note that even though \code{locals()} and - \code{['eggs']} are passed in as arguments, the - \function{__import__()} function does not set the local variable - named \code{eggs}; this is done by subsequent code that is generated - for the import statement. (In fact, the standard implementation - does not use its \var{locals} argument at all, and uses its - \var{globals} only to determine the package context of the - \keyword{import} statement.) - - When the \var{name} variable is of the form \code{package.module}, - normally, the top-level package (the name up till the first dot) is - returned, \emph{not} the module named by \var{name}. However, when - a non-empty \var{fromlist} argument is given, the module named by - \var{name} is returned. This is done for compatibility with the - bytecode generated for the different kinds of import statement; when - using \samp{import spam.ham.eggs}, the top-level package \module{spam} - must be placed in the importing namespace, but when using \samp{from - spam.ham import eggs}, the \code{spam.ham} subpackage must be used - to find the \code{eggs} variable. As a workaround for this - behavior, use \function{getattr()} to extract the desired - components. For example, you could define the following helper: - -\begin{verbatim} -def my_import(name): - mod = __import__(name) - components = name.split('.') - for comp in components[1:]: - mod = getattr(mod, comp) - return mod -\end{verbatim} - - \var{level} specifies whether to use absolute or relative imports. - The default is \code{-1} which indicates both absolute and relative - imports will be attempted. \code{0} means only perform absolute imports. - Positive values for \var{level} indicate the number of parent directories - to search relative to the directory of the module calling - \function{__import__}. -\versionchanged[The level parameter was added]{2.5} -\versionchanged[Keyword support for parameters was added]{2.5} -\end{funcdesc} - -\begin{funcdesc}{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. -\end{funcdesc} - -\begin{funcdesc}{all}{iterable} - Return True if all elements of the \var{iterable} are true. - Equivalent to: - \begin{verbatim} - def all(iterable): - for element in iterable: - if not element: - return False - return True - \end{verbatim} - \versionadded{2.5} -\end{funcdesc} - -\begin{funcdesc}{any}{iterable} - Return True if any element of the \var{iterable} is true. - Equivalent to: - \begin{verbatim} - def any(iterable): - for element in iterable: - if element: - return True - return False - \end{verbatim} - \versionadded{2.5} -\end{funcdesc} - -\begin{funcdesc}{basestring}{} - This abstract type is the superclass for \class{str} and \class{unicode}. - It cannot be called or instantiated, but it can be used to test whether - an object is an instance of \class{str} or \class{unicode}. - \code{isinstance(obj, basestring)} is equivalent to - \code{isinstance(obj, (str, unicode))}. - \versionadded{2.3} -\end{funcdesc} - -\begin{funcdesc}{bool}{\optional{x}} - Convert a value to a Boolean, using the standard truth testing - procedure. If \var{x} is false or omitted, this returns - \constant{False}; otherwise it returns \constant{True}. - \class{bool} is also a class, which is a subclass of \class{int}. - Class \class{bool} cannot be subclassed further. Its only instances - are \constant{False} and \constant{True}. - - \indexii{Boolean}{type} - \versionadded{2.2.1} - \versionchanged[If no argument is given, this function returns - \constant{False}]{2.3} -\end{funcdesc} - -\begin{funcdesc}{callable}{object} - Return true if the \var{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 \var{object} will never succeed. Note - that classes are callable (calling a class returns a new instance); - class instances are callable if they have a \method{__call__()} - method. -\end{funcdesc} - -\begin{funcdesc}{chr}{i} - Return a string of one character whose \ASCII{} code is the integer - \var{i}. For example, \code{chr(97)} returns the string \code{'a'}. - This is the inverse of \function{ord()}. The argument must be in - the range [0..255], inclusive; \exception{ValueError} will be raised - if \var{i} is outside that range. -\end{funcdesc} - -\begin{funcdesc}{classmethod}{function} - Return a class method for \var{function}. - - A class method receives the class as implicit first argument, - just like an instance method receives the instance. - To declare a class method, use this idiom: - -\begin{verbatim} -class C: - @classmethod - def f(cls, arg1, arg2, ...): ... -\end{verbatim} - - The \code{@classmethod} form is a function decorator -- see the description - of function definitions in chapter 7 of the - \citetitle[../ref/ref.html]{Python Reference Manual} for details. - - It can be called either on the class (such as \code{C.f()}) or on an - instance (such as \code{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 \Cpp{} or Java static methods. - If you want those, see \function{staticmethod()} in this section. - - For more information on class methods, consult the documentation on the - standard type hierarchy in chapter 3 of the - \citetitle[../ref/types.html]{Python Reference Manual} (at the bottom). - \versionadded{2.2} - \versionchanged[Function decorator syntax added]{2.4} -\end{funcdesc} - -\begin{funcdesc}{cmp}{x, y} - Compare the two objects \var{x} and \var{y} and return an integer - according to the outcome. The return value is negative if \code{\var{x} - < \var{y}}, zero if \code{\var{x} == \var{y}} and strictly positive if - \code{\var{x} > \var{y}}. -\end{funcdesc} - -\begin{funcdesc}{compile}{source, filename, mode\optional{, - flags\optional{, dont_inherit}}} - Compile the \var{source} into a code object. Code objects can be - executed by an \keyword{exec} statement or evaluated by a call to - \function{eval()}. The \var{filename} argument should - give the file from which the code was read; pass some recognizable value - if it wasn't read from a file (\code{'<string>'} is commonly used). - The \var{mode} argument specifies what kind of code must be - compiled; it can be \code{'exec'} if \var{source} consists of a - sequence of statements, \code{'eval'} if it consists of a single - expression, or \code{'single'} if it consists of a single - interactive statement (in the latter case, expression statements - that evaluate to something else than \code{None} will be printed). - - When compiling multi-line statements, two caveats apply: line - endings must be represented by a single newline character - (\code{'\e n'}), and the input must be terminated by at least one - newline character. If line endings are represented by - \code{'\e r\e n'}, use the string \method{replace()} method to - change them into \code{'\e n'}. - - The optional arguments \var{flags} and \var{dont_inherit} - (which are new in Python 2.2) control which future statements (see - \pep{236}) affect the compilation of \var{source}. If neither is - present (or both are zero) the code is compiled with those future - statements that are in effect in the code that is calling compile. - If the \var{flags} argument is given and \var{dont_inherit} is not - (or is zero) then the future statements specified by the \var{flags} - argument are used in addition to those that would be used anyway. - If \var{dont_inherit} is a non-zero integer then the \var{flags} - argument is it -- the future statements in effect around the call to - compile are ignored. - - Future statements are specified by bits which can be bitwise or-ed - together to specify multiple statements. The bitfield required to - specify a given feature can be found as the \member{compiler_flag} - attribute on the \class{_Feature} instance in the - \module{__future__} module. -\end{funcdesc} - -\begin{funcdesc}{complex}{\optional{real\optional{, imag}}} - Create a complex number with the value \var{real} + \var{imag}*j 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 \var{imag} is omitted, it defaults to zero and the function - serves as a numeric conversion function like \function{int()}, - \function{long()} and \function{float()}. If both arguments - are omitted, returns \code{0j}. -\end{funcdesc} - -\begin{funcdesc}{delattr}{object, name} - This is a relative of \function{setattr()}. The arguments are an - object and a string. The string must be the name - of one of the object's attributes. The function deletes - the named attribute, provided the object allows it. For example, - \code{delattr(\var{x}, '\var{foobar}')} is equivalent to - \code{del \var{x}.\var{foobar}}. -\end{funcdesc} - -\begin{funcdesc}{dict}{\optional{arg}} - Return a new dictionary initialized from an optional positional - argument or from a set of keyword arguments. - If no arguments are given, return a new empty dictionary. - If the positional argument \var{arg} is a mapping object, return a dictionary - mapping the same keys to the same values as does the mapping object. - Otherwise the positional argument must be a sequence, a container that - supports iteration, or an iterator object. The elements of the argument - must each also be of one of those kinds, and each must in turn contain - exactly two objects. The first is used as a key in the new dictionary, - and the second as the key's value. If a given key is seen more than - once, the last value associated with it is retained in the new - dictionary. - - If keyword arguments are given, the keywords themselves with their - associated values are added as items to the dictionary. If a key - is specified both in the positional argument and as a keyword argument, - the value associated with the keyword is retained in the dictionary. - For example, these all return a dictionary equal to - \code{\{"one": 2, "two": 3\}}: - - \begin{itemize} - \item \code{dict(\{'one': 2, 'two': 3\})} - \item \code{dict(\{'one': 2, 'two': 3\}.items())} - \item \code{dict(\{'one': 2, 'two': 3\}.iteritems())} - \item \code{dict(zip(('one', 'two'), (2, 3)))} - \item \code{dict([['two', 3], ['one', 2]])} - \item \code{dict(one=2, two=3)} - \item \code{dict([(['one', 'two'][i-2], i) for i in (2, 3)])} - \end{itemize} - - \versionadded{2.2} - \versionchanged[Support for building a dictionary from keyword - arguments added]{2.3} -\end{funcdesc} - -\begin{funcdesc}{dir}{\optional{object}} - Without arguments, return the list of names in the current local scope. With - an argument, attempt to return a list of valid attributes for that object. - - If the object has a method named \method{__dir__()}, this method will be - called and must return the list of attributes. This allows objects that - implement a custom \function{__getattr__()} or \function{__getattribute__()} - function to customize the way \function{dir()} reports their attributes. - - If the object does not provide \method{__dir__()}, the function tries its best - to gather information from the object's \member{__dict__} attribute, if - defined, and from its type object. The resulting list is not necessarily - complete, and may be inaccurate when the object has a custom - \function{__getattr__()}. - - The default \function{dir()} mechanism behaves differently with different - types of objects, as it attempts to produce the most relevant, rather than - complete, information: - \begin{itemize} - \item If the object is a module object, the list contains the names of the - module's attributes. - \item If the object is a type or class object, the list contains the names of - its attributes, and recursively of the attributes of its bases. - \item Otherwise, the list contains the object's attributes' names, the names - of its class's attributes, and recursively of the attributes of its class's - base classes. - \end{itemize} - - The resulting list is sorted alphabetically. For example: - -\begin{verbatim} ->>> import struct ->>> dir() -['__builtins__', '__doc__', '__name__', 'struct'] ->>> dir(struct) -['__doc__', '__name__', 'calcsize', 'error', 'pack', 'unpack'] ->>> class Foo(object): -... def __dir__(self): -... return ["kan", "ga", "roo"] -... ->>> f = Foo() ->>> dir(f) -['ga', 'kan', 'roo'] -\end{verbatim} - - \note{Because \function{dir()} is supplied primarily as a convenience for use - at an interactive prompt, it tries to supply an interesting set of names - more than it tries to supply a rigorously or consistently defined set of - names, and its detailed behavior may change across releases.} -\end{funcdesc} - -\begin{funcdesc}{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 - \code{(\var{a} // \var{b}, \var{a} \%{} \var{b})}. - For floating point numbers the result is \code{(\var{q}, \var{a} \%{} - \var{b})}, where \var{q} is usually \code{math.floor(\var{a} / - \var{b})} but may be 1 less than that. In any case \code{\var{q} * - \var{b} + \var{a} \%{} \var{b}} is very close to \var{a}, if - \code{\var{a} \%{} \var{b}} is non-zero it has the same sign as - \var{b}, and \code{0 <= abs(\var{a} \%{} \var{b}) < abs(\var{b})}. - - \versionchanged[Using \function{divmod()} with complex numbers is - deprecated]{2.3} -\end{funcdesc} - -\begin{funcdesc}{enumerate}{iterable} - Return an enumerate object. \var{iterable} must be a sequence, an - iterator, or some other object which supports iteration. The - \method{next()} method of the iterator returned by - \function{enumerate()} returns a tuple containing a count (from - zero) and the corresponding value obtained from iterating over - \var{iterable}. \function{enumerate()} is useful for obtaining an - indexed series: \code{(0, seq[0])}, \code{(1, seq[1])}, \code{(2, - seq[2])}, \ldots. - \versionadded{2.3} -\end{funcdesc} - -\begin{funcdesc}{eval}{expression\optional{, globals\optional{, locals}}} - The arguments are a string and optional globals and locals. If provided, - \var{globals} must be a dictionary. If provided, \var{locals} can be - any mapping object. \versionchanged[formerly \var{locals} was required - to be a dictionary]{2.4} - - The \var{expression} argument is parsed and evaluated as a Python - expression (technically speaking, a condition list) using the - \var{globals} and \var{locals} dictionaries as global and local name - space. If the \var{globals} dictionary is present and lacks - '__builtins__', the current globals are copied into \var{globals} before - \var{expression} is parsed. This means that \var{expression} - normally has full access to the standard - \refmodule[builtin]{__builtin__} module and restricted environments - are propagated. If the \var{locals} dictionary is omitted it defaults to - the \var{globals} dictionary. If both dictionaries are omitted, the - expression is executed in the environment where \keyword{eval} is - called. The return value is the result of the evaluated expression. - Syntax errors are reported as exceptions. Example: - -\begin{verbatim} ->>> x = 1 ->>> print eval('x+1') -2 -\end{verbatim} - - This function can also be used to execute arbitrary code objects - (such as those created by \function{compile()}). In this case pass - a code object instead of a string. The code object must have been - compiled passing \code{'eval'} as the \var{kind} argument. - - Hints: dynamic execution of statements is supported by the - \keyword{exec} statement. Execution of statements from a file is - supported by the \function{execfile()} function. The - \function{globals()} and \function{locals()} functions returns the - current global and local dictionary, respectively, which may be - useful to pass around for use by \function{eval()} or - \function{execfile()}. -\end{funcdesc} - -\begin{funcdesc}{execfile}{filename\optional{, globals\optional{, locals}}} - This function is similar to the - \keyword{exec} statement, but parses a file instead of a string. It - is different from the \keyword{import} statement in that it does not - use the module administration --- it reads the file unconditionally - and does not create a new module.\footnote{It is used relatively - rarely so does not warrant being made into a statement.} - - 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 \var{globals} and \var{locals} dictionaries as global and - local namespace. If provided, \var{locals} can be any mapping object. - \versionchanged[formerly \var{locals} was required to be a dictionary]{2.4} - If the \var{locals} dictionary is omitted it defaults to the \var{globals} - dictionary. If both dictionaries are omitted, the expression is executed in - the environment where \function{execfile()} is called. The return value is - \code{None}. - - \warning{The default \var{locals} act as described for function - \function{locals()} below: modifications to the default \var{locals} - dictionary should not be attempted. Pass an explicit \var{locals} - dictionary if you need to see effects of the code on \var{locals} after - function \function{execfile()} returns. \function{execfile()} cannot - be used reliably to modify a function's locals.} -\end{funcdesc} - -\begin{funcdesc}{file}{filename\optional{, mode\optional{, bufsize}}} - Constructor function for the \class{file} type, described further - in section~\ref{bltin-file-objects}, ``\ulink{File - Objects}{bltin-file-objects.html}''. The constructor's arguments - are the same as those of the \function{open()} built-in function - described below. - - When opening a file, it's preferable to use \function{open()} instead of - invoking this constructor directly. \class{file} is more suited to - type testing (for example, writing \samp{isinstance(f, file)}). - - \versionadded{2.2} -\end{funcdesc} - -\begin{funcdesc}{filter}{function, iterable} - Construct a list from those elements of \var{iterable} for which - \var{function} returns true. \var{iterable} may be either a sequence, a - container which supports iteration, or an iterator, If \var{iterable} - is a string or a tuple, the result - also has that type; otherwise it is always a list. If \var{function} is - \code{None}, the identity function is assumed, that is, all elements of - \var{iterable} that are false are removed. - - Note that \code{filter(function, \var{iterable})} is equivalent to - \code{[item for item in \var{iterable} if function(item)]} if function is - not \code{None} and \code{[item for item in \var{iterable} if item]} if - function is \code{None}. -\end{funcdesc} - -\begin{funcdesc}{float}{\optional{x}} - Convert a string or a number to floating point. If the argument is a - string, it must contain a possibly signed decimal or floating point - number, possibly embedded in whitespace. 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 \code{0.0}. - - \note{When passing in a string, values for NaN\index{NaN} - and Infinity\index{Infinity} may be returned, depending on the - underlying C library. The specific set of strings accepted which - cause these values to be returned depends entirely on the C library - and is known to vary.} -\end{funcdesc} - -\begin{funcdesc}{frozenset}{\optional{iterable}} - Return a frozenset object whose elements are taken from \var{iterable}. - Frozensets are sets that have no update methods but can be hashed and - used as members of other sets or as dictionary keys. The elements of - a frozenset must be immutable themselves. To represent sets of sets, - the inner sets should also be \class{frozenset} objects. If - \var{iterable} is not specified, returns a new empty set, - \code{frozenset([])}. - \versionadded{2.4} -\end{funcdesc} - -\begin{funcdesc}{getattr}{object, name\optional{, default}} - Return the value of the named attributed of \var{object}. \var{name} - must be a string. If the string is the name of one of the object's - attributes, the result is the value of that attribute. For example, - \code{getattr(x, 'foobar')} is equivalent to \code{x.foobar}. If the - named attribute does not exist, \var{default} is returned if provided, - otherwise \exception{AttributeError} is raised. -\end{funcdesc} - -\begin{funcdesc}{globals}{} - Return a dictionary representing the current global symbol table. - This is always the dictionary of the current module (inside a - function or method, this is the module where it is defined, not the - module from which it is called). -\end{funcdesc} - -\begin{funcdesc}{hasattr}{object, name} - The arguments are an object and a string. The result is \code{True} if the - string is the name of one of the object's attributes, \code{False} if not. - (This is implemented by calling \code{getattr(\var{object}, - \var{name})} and seeing whether it raises an exception or not.) -\end{funcdesc} - -\begin{funcdesc}{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). -\end{funcdesc} - -\begin{funcdesc}{help}{\optional{object}} - Invoke the built-in help system. (This function is intended for - interactive use.) If no argument is given, the interactive help - system starts on the interpreter console. If the argument is a - string, then the string is looked up as the name of a module, - function, class, method, keyword, or documentation topic, and a - help page is printed on the console. If the argument is any other - kind of object, a help page on the object is generated. - \versionadded{2.2} -\end{funcdesc} - -\begin{funcdesc}{hex}{x} - Convert an integer number (of any size) to a hexadecimal string. - The result is a valid Python expression. - \versionchanged[Formerly only returned an unsigned literal]{2.4} -\end{funcdesc} - -\begin{funcdesc}{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 \function{id()} value. (Implementation - note: this is the address of the object.) -\end{funcdesc} - -\begin{funcdesc}{input}{\optional{prompt}} - Equivalent to \code{eval(raw_input(\var{prompt}))}. - \warning{This function is not safe from user errors! It - expects a valid Python expression as input; if the input is not - syntactically valid, a \exception{SyntaxError} will be raised. - Other exceptions may be raised if there is an error during - evaluation. (On the other hand, sometimes this is exactly what you - need when writing a quick script for expert use.)} - - If the \refmodule{readline} module was loaded, then - \function{input()} will use it to provide elaborate line editing and - history features. - - Consider using the \function{raw_input()} function for general input - from users. -\end{funcdesc} - -\begin{funcdesc}{int}{\optional{x\optional{, radix}}} - Convert a string or number to a plain integer. If the argument is a - string, it must contain a possibly signed decimal number - representable as a Python integer, possibly embedded in whitespace. - The \var{radix} parameter gives the base for the - conversion and may be any integer in the range [2, 36], or zero. If - \var{radix} is zero, the proper radix is guessed based on the - contents of string; the interpretation is the same as for integer - literals. If \var{radix} is specified and \var{x} is not a string, - \exception{TypeError} is raised. - Otherwise, the argument may be a plain or - long integer or a floating point number. Conversion of floating - point numbers to integers truncates (towards zero). - If the argument is outside the integer range a long object will - be returned instead. If no arguments are given, returns \code{0}. -\end{funcdesc} - -\begin{funcdesc}{isinstance}{object, classinfo} - Return true if the \var{object} argument is an instance of the - \var{classinfo} argument, or of a (direct or indirect) subclass - thereof. Also return true if \var{classinfo} is a type object - (new-style class) and \var{object} is an object of that type or of a - (direct or indirect) subclass thereof. If \var{object} is not a - class instance or an object of the given type, the function always - returns false. If \var{classinfo} is neither a class object nor a - type object, it may be a tuple of class or type objects, or may - recursively contain other such tuples (other sequence types are not - accepted). If \var{classinfo} is not a class, type, or tuple of - classes, types, and such tuples, a \exception{TypeError} exception - is raised. - \versionchanged[Support for a tuple of type information was added]{2.2} -\end{funcdesc} - -\begin{funcdesc}{issubclass}{class, classinfo} - Return true if \var{class} is a subclass (direct or indirect) of - \var{classinfo}. A class is considered a subclass of itself. - \var{classinfo} may be a tuple of class objects, in which case every - entry in \var{classinfo} will be checked. In any other case, a - \exception{TypeError} exception is raised. - \versionchanged[Support for a tuple of type information was added]{2.3} -\end{funcdesc} - -\begin{funcdesc}{iter}{o\optional{, sentinel}} - Return an iterator object. The first argument is interpreted very - differently depending on the presence of the second argument. - Without a second argument, \var{o} must be a collection object which - supports the iteration protocol (the \method{__iter__()} method), or - it must support the sequence protocol (the \method{__getitem__()} - method with integer arguments starting at \code{0}). If it does not - support either of those protocols, \exception{TypeError} is raised. - If the second argument, \var{sentinel}, is given, then \var{o} must - be a callable object. The iterator created in this case will call - \var{o} with no arguments for each call to its \method{next()} - method; if the value returned is equal to \var{sentinel}, - \exception{StopIteration} will be raised, otherwise the value will - be returned. - \versionadded{2.2} -\end{funcdesc} - -\begin{funcdesc}{len}{s} - Return the length (the number of items) of an object. The argument - may be a sequence (string, tuple or list) or a mapping (dictionary). -\end{funcdesc} - -\begin{funcdesc}{list}{\optional{iterable}} - Return a list whose items are the same and in the same order as - \var{iterable}'s items. \var{iterable} may be either a sequence, a - container that supports iteration, or an iterator object. If - \var{iterable} is already a list, a copy is made and returned, - similar to \code{\var{iterable}[:]}. For instance, - \code{list('abc')} returns \code{['a', 'b', 'c']} and \code{list( - (1, 2, 3) )} returns \code{[1, 2, 3]}. If no argument is given, - returns a new empty list, \code{[]}. -\end{funcdesc} - -\begin{funcdesc}{locals}{} - Update and return a dictionary representing the current local symbol table. - \warning{The contents of this dictionary should not be modified; - changes may not affect the values of local variables used by the - interpreter.} - - Free variables are returned by \var{locals} when it is called in - a function block. Modifications of free variables may not affect - the values used by the interpreter. Free variables are not - returned in class blocks. -\end{funcdesc} - -\begin{funcdesc}{long}{\optional{x\optional{, radix}}} - Convert a string or number to a long integer. If the argument is a - string, it must contain a possibly signed number of - arbitrary size, possibly embedded in whitespace. The - \var{radix} argument is interpreted in the same way as for - \function{int()}, and may only be given when \var{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 \code{0L}. -\end{funcdesc} - -\begin{funcdesc}{map}{function, iterable, ...} - Apply \var{function} to every item of \var{iterable} and return a list - of the results. If additional \var{iterable} arguments are passed, - \var{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 \code{None} items. If \var{function} - is \code{None}, the identity function is assumed; if there are - multiple arguments, \function{map()} returns a list consisting - of tuples containing the corresponding items from all iterables (a kind - of transpose operation). The \var{iterable} arguments may be a sequence - or any iterable object; the result is always a list. -\end{funcdesc} - -\begin{funcdesc}{max}{iterable\optional{, args...}\optional{key}} - With a single argument \var{iterable}, return the largest item of a - non-empty iterable (such as a string, tuple or list). With more - than one argument, return the largest of the arguments. - - The optional \var{key} argument specifies a one-argument ordering - function like that used for \method{list.sort()}. The \var{key} - argument, if supplied, must be in keyword form (for example, - \samp{max(a,b,c,key=func)}). - \versionchanged[Added support for the optional \var{key} argument]{2.5} -\end{funcdesc} - -\begin{funcdesc}{min}{iterable\optional{, args...}\optional{key}} - With a single argument \var{iterable}, return the smallest item of a - non-empty iterable (such as a string, tuple or list). With more - than one argument, return the smallest of the arguments. - - The optional \var{key} argument specifies a one-argument ordering - function like that used for \method{list.sort()}. The \var{key} - argument, if supplied, must be in keyword form (for example, - \samp{min(a,b,c,key=func)}). - \versionchanged[Added support for the optional \var{key} argument]{2.5} -\end{funcdesc} - -\begin{funcdesc}{object}{} - Return a new featureless object. \class{object} is a base - for all new style classes. It has the methods that are common - to all instances of new style classes. - \versionadded{2.2} - - \versionchanged[This function does not accept any arguments. - Formerly, it accepted arguments but ignored them]{2.3} -\end{funcdesc} - -\begin{funcdesc}{oct}{x} - Convert an integer number (of any size) to an octal string. The - result is a valid Python expression. - \versionchanged[Formerly only returned an unsigned literal]{2.4} -\end{funcdesc} - -\begin{funcdesc}{open}{filename\optional{, mode\optional{, bufsize}}} - Open a file, returning an object of the \class{file} type described - in section~\ref{bltin-file-objects}, ``\ulink{File - Objects}{bltin-file-objects.html}''. If the file cannot be opened, - \exception{IOError} is raised. When opening a file, it's - preferable to use \function{open()} instead of invoking the - \class{file} constructor directly. - - The first two arguments are the same as for \code{stdio}'s - \cfunction{fopen()}: \var{filename} is the file name to be opened, - and \var{mode} is a string indicating how the file is to be opened. - - The most commonly-used values of \var{mode} are \code{'r'} for - reading, \code{'w'} for writing (truncating the file if it already - exists), and \code{'a'} for appending (which on \emph{some} \UNIX{} - systems means that \emph{all} writes append to the end of the file - regardless of the current seek position). If \var{mode} is omitted, - it defaults to \code{'r'}. When opening a binary file, you should - append \code{'b'} to the \var{mode} value to open the file in binary - mode, which will improve portability. (Appending \code{'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 \var{mode}. - - \index{line-buffered I/O}\index{unbuffered I/O}\index{buffer size, I/O} - \index{I/O control!buffering} - The optional \var{bufsize} 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. A negative \var{bufsize} 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.\footnote{ - Specifying a buffer size currently has no effect on systems that - don't have \cfunction{setvbuf()}. The interface to specify the - buffer size is not done using a method that calls - \cfunction{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.} - - Modes \code{'r+'}, \code{'w+'} and \code{'a+'} open the file for - updating (note that \code{'w+'} truncates the file). Append - \code{'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 \code{'b'} has no effect. - - In addition to the standard \cfunction{fopen()} values \var{mode} - may be \code{'U'} or \code{'rU'}. Python is usually built with universal - newline support; supplying \code{'U'} opens the file as a text file, but - lines may be terminated by any of the following: the \UNIX{} end-of-line - convention \code{'\e n'}, - the Macintosh convention \code{'\e r'}, or the Windows - convention \code{'\e r\e n'}. All of these external representations are seen as - \code{'\e n'} - by the Python program. If Python is built without universal newline support - a \var{mode} with \code{'U'} is the same as normal text mode. Note that - file objects so opened also have an attribute called - \member{newlines} which has a value of \code{None} (if no newlines - have yet been seen), \code{'\e n'}, \code{'\e r'}, \code{'\e r\e n'}, - or a tuple containing all the newline types seen. - - Python enforces that the mode, after stripping \code{'U'}, begins with - \code{'r'}, \code{'w'} or \code{'a'}. - - \versionchanged[Restriction on first letter of mode string - introduced]{2.5} -\end{funcdesc} - -\begin{funcdesc}{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, \code{ord('a')} returns the integer \code{97}, - \code{ord(u'\e u2020')} returns \code{8224}. This is the inverse of - \function{chr()} for 8-bit strings and of \function{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 - \exception{TypeError} will be raised. -\end{funcdesc} - -\begin{funcdesc}{pow}{x, y\optional{, z}} - Return \var{x} to the power \var{y}; if \var{z} is present, return - \var{x} to the power \var{y}, modulo \var{z} (computed more - efficiently than \code{pow(\var{x}, \var{y}) \%\ \var{z}}). - The two-argument form \code{pow(\var{x}, \var{y})} is equivalent to using - the power operator: \code{\var{x}**\var{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, \code{10**2} returns \code{100}, but - \code{10**-2} returns \code{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 \var{z} is present, \var{x} and \var{y} must be of integer types, - and \var{y} must be non-negative. (This restriction was added in - Python 2.2. In Python 2.1 and before, floating 3-argument \code{pow()} - returned platform-dependent results depending on floating-point - rounding accidents.) -\end{funcdesc} - -\begin{funcdesc}{property}{\optional{fget\optional{, fset\optional{, - fdel\optional{, doc}}}}} - Return a property attribute for new-style classes (classes that - derive from \class{object}). - - \var{fget} is a function for getting an attribute value, likewise - \var{fset} is a function for setting, and \var{fdel} a function - for del'ing, an attribute. Typical use is to define a managed attribute x: - -\begin{verbatim} -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.") -\end{verbatim} - - If given, \var{doc} will be the docstring of the property attribute. - Otherwise, the property will copy \var{fget}'s docstring (if it - exists). This makes it possible to create read-only properties - easily using \function{property()} as a decorator: - -\begin{verbatim} -class Parrot(object): - def __init__(self): - self._voltage = 100000 - - @property - def voltage(self): - """Get the current voltage.""" - return self._voltage -\end{verbatim} - - turns the \method{voltage()} method into a ``getter'' for a read-only - attribute with the same name. - - \versionadded{2.2} - \versionchanged[Use \var{fget}'s docstring if no \var{doc} given]{2.5} -\end{funcdesc} - -\begin{funcdesc}{range}{\optional{start,} stop\optional{, step}} - This is a versatile function to create lists containing arithmetic - progressions. It is most often used in \keyword{for} loops. The - arguments must be plain integers. If the \var{step} argument is - omitted, it defaults to \code{1}. If the \var{start} argument is - omitted, it defaults to \code{0}. The full form returns a list of - plain integers \code{[\var{start}, \var{start} + \var{step}, - \var{start} + 2 * \var{step}, \ldots]}. If \var{step} is positive, - the last element is the largest \code{\var{start} + \var{i} * - \var{step}} less than \var{stop}; if \var{step} is negative, the last - element is the smallest \code{\var{start} + \var{i} * \var{step}} - greater than \var{stop}. \var{step} must not be zero (or else - \exception{ValueError} is raised). Example: - -\begin{verbatim} ->>> 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) -[] -\end{verbatim} -\end{funcdesc} - -\begin{funcdesc}{raw_input}{\optional{prompt}} - If the \var{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, \exception{EOFError} is raised. Example: - -\begin{verbatim} ->>> s = raw_input('--> ') ---> Monty Python's Flying Circus ->>> s -"Monty Python's Flying Circus" -\end{verbatim} - - If the \refmodule{readline} module was loaded, then - \function{raw_input()} will use it to provide elaborate - line editing and history features. -\end{funcdesc} - -\begin{funcdesc}{reduce}{function, iterable\optional{, initializer}} - Apply \var{function} of two arguments cumulatively to the items of - \var{iterable}, from left to right, so as to reduce the iterable to - a single value. For example, \code{reduce(lambda x, y: x+y, [1, 2, - 3, 4, 5])} calculates \code{((((1+2)+3)+4)+5)}. The left argument, - \var{x}, is the accumulated value and the right argument, \var{y}, - is the update value from the \var{iterable}. If the optional - \var{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 \var{initializer} is not given and - \var{iterable} contains only one item, the first item is returned. -\end{funcdesc} - -\begin{funcdesc}{reload}{module} - Reload a previously imported \var{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 \var{module} argument). - - When \code{reload(module)} is executed: - -\begin{itemize} - - \item 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 \code{init} function of extension - modules is not called a second time. - - \item As with all other objects in Python the old objects are only - reclaimed after their reference counts drop to zero. - - \item The names in the module namespace are updated to point to - any new or changed objects. - - \item 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. - -\end{itemize} - - There are a number of other caveats: - - If a module is syntactically correct but its initialization fails, - the first \keyword{import} statement for it does not bind its name - locally, but does store a (partially initialized) module object in - \code{sys.modules}. To reload the module you must first - \keyword{import} it again (this will bind the name to the partially - initialized module object) before you can \function{reload()} it. - - 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 \keyword{try} statement it can test for the - table's presence and skip its initialization if desired: - -\begin{verbatim} -try: - cache -except NameError: - cache = {} -\end{verbatim} - - - It is legal though generally not very useful to reload built-in or - dynamically loaded modules, except for \refmodule{sys}, - \refmodule[main]{__main__} and \refmodule[builtin]{__builtin__}. In - many cases, however, 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 \keyword{from} - \ldots{} \keyword{import} \ldots{}, calling \function{reload()} for - the other module does not redefine the objects imported from it --- - one way around this is to re-execute the \keyword{from} statement, - another is to use \keyword{import} and qualified names - (\var{module}.\var{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. -\end{funcdesc} - -\begin{funcdesc}{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 \function{eval()}. -\end{funcdesc} - -\begin{funcdesc}{reversed}{seq} - Return a reverse iterator. \var{seq} must be an object which - supports the sequence protocol (the \method{__len__()} method and the - \method{__getitem__()} method with integer arguments starting at - \code{0}). - \versionadded{2.4} -\end{funcdesc} - -\begin{funcdesc}{round}{x\optional{, n}} - Return the floating point value \var{x} rounded to \var{n} digits - after the decimal point. If \var{n} 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 \var{n}; if two multiples - are equally close, rounding is done away from 0 (so. for example, - \code{round(0.5)} is \code{1.0} and \code{round(-0.5)} is \code{-1.0}). -\end{funcdesc} - -\begin{funcdesc}{set}{\optional{iterable}} - Return a set whose elements are taken from \var{iterable}. The elements - must be immutable. To represent sets of sets, the inner sets should - be \class{frozenset} objects. If \var{iterable} is not specified, - returns a new empty set, \code{set([])}. - \versionadded{2.4} -\end{funcdesc} - -\begin{funcdesc}{setattr}{object, name, value} - This is the counterpart of \function{getattr()}. The arguments are an - object, a string and an arbitrary value. The string may name an - existing attribute or a new attribute. The function assigns the - value to the attribute, provided the object allows it. For example, - \code{setattr(\var{x}, '\var{foobar}', 123)} is equivalent to - \code{\var{x}.\var{foobar} = 123}. -\end{funcdesc} - -\begin{funcdesc}{slice}{\optional{start,} stop\optional{, step}} - Return a slice object representing the set of indices specified by - \code{range(\var{start}, \var{stop}, \var{step})}. The \var{start} - and \var{step} arguments default to \code{None}. Slice objects have - read-only data attributes \member{start}, \member{stop} and - \member{step} which merely return the argument values (or their - default). They have no other explicit functionality; however they - are used by Numerical Python\index{Numerical Python} and other third - party extensions. Slice objects are also generated when extended - indexing syntax is used. For example: \samp{a[start:stop:step]} or - \samp{a[start:stop, i]}. -\end{funcdesc} - -\begin{funcdesc}{sorted}{iterable\optional{, cmp\optional{, - key\optional{, reverse}}}} - Return a new sorted list from the items in \var{iterable}. - - The optional arguments \var{cmp}, \var{key}, and \var{reverse} have - the same meaning as those for the \method{list.sort()} method - (described in section~\ref{typesseq-mutable}). - - \var{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: - \samp{\var{cmp}=\keyword{lambda} \var{x},\var{y}: - \function{cmp}(x.lower(), y.lower())} - - \var{key} specifies a function of one argument that is used to - extract a comparison key from each list element: - \samp{\var{key}=\function{str.lower}} - - \var{reverse} is a boolean value. If set to \code{True}, then the - list elements are sorted as if each comparison were reversed. - - In general, the \var{key} and \var{reverse} conversion processes are - much faster than specifying an equivalent \var{cmp} function. This is - because \var{cmp} is called multiple times for each list element while - \var{key} and \var{reverse} touch each element only once. - - \versionadded{2.4} -\end{funcdesc} - -\begin{funcdesc}{staticmethod}{function} - Return a static method for \var{function}. - - A static method does not receive an implicit first argument. - To declare a static method, use this idiom: - -\begin{verbatim} -class C: - @staticmethod - def f(arg1, arg2, ...): ... -\end{verbatim} - - The \code{@staticmethod} form is a function decorator -- see the description - of function definitions in chapter 7 of the - \citetitle[../ref/function.html]{Python Reference Manual} for details. - - It can be called either on the class (such as \code{C.f()}) or on an - instance (such as \code{C().f()}). The instance is ignored except - for its class. - - Static methods in Python are similar to those found in Java or \Cpp. - For a more advanced concept, see \function{classmethod()} in this - section. - - For more information on static methods, consult the documentation on the - standard type hierarchy in chapter 3 of the - \citetitle[../ref/types.html]{Python Reference Manual} (at the bottom). - \versionadded{2.2} - \versionchanged[Function decorator syntax added]{2.4} -\end{funcdesc} - -\begin{funcdesc}{str}{\optional{object}} - Return a string containing a nicely printable representation of an - object. For strings, this returns the string itself. The - difference with \code{repr(\var{object})} is that - \code{str(\var{object})} does not always attempt to return a string - that is acceptable to \function{eval()}; its goal is to return a - printable string. If no argument is given, returns the empty - string, \code{''}. -\end{funcdesc} - -\begin{funcdesc}{sum}{iterable\optional{, start}} - Sums \var{start} and the items of an \var{iterable} from left to - right and returns the total. \var{start} defaults to \code{0}. - The \var{iterable}'s items are normally numbers, and are not allowed - to be strings. The fast, correct way to concatenate a sequence of - strings is by calling \code{''.join(\var{sequence})}. - Note that \code{sum(range(\var{n}), \var{m})} is equivalent to - \code{reduce(operator.add, range(\var{n}), \var{m})} - \versionadded{2.3} -\end{funcdesc} - -\begin{funcdesc}{super}{type\optional{, object-or-type}} - Return the superclass of \var{type}. If the second argument is omitted - the super object returned is unbound. If the second argument is an - object, \code{isinstance(\var{obj}, \var{type})} must be true. If - the second argument is a type, \code{issubclass(\var{type2}, - \var{type})} must be true. - \function{super()} only works for new-style classes. - - A typical use for calling a cooperative superclass method is: -\begin{verbatim} -class C(B): - def meth(self, arg): - super(C, self).meth(arg) -\end{verbatim} - - Note that \function{super} is implemented as part of the binding process for - explicit dotted attribute lookups such as - \samp{super(C, self).__getitem__(name)}. Accordingly, \function{super} is - undefined for implicit lookups using statements or operators such as - \samp{super(C, self)[name]}. -\versionadded{2.2} -\end{funcdesc} - -\begin{funcdesc}{tuple}{\optional{iterable}} - Return a tuple whose items are the same and in the same order as - \var{iterable}'s items. \var{iterable} may be a sequence, a - container that supports iteration, or an iterator object. - If \var{iterable} is already a tuple, it - is returned unchanged. For instance, \code{tuple('abc')} returns - \code{('a', 'b', 'c')} and \code{tuple([1, 2, 3])} returns - \code{(1, 2, 3)}. If no argument is given, returns a new empty - tuple, \code{()}. -\end{funcdesc} - -\begin{funcdesc}{type}{object} - Return the type of an \var{object}. The return value is a - type\obindex{type} object. The \function{isinstance()} built-in - function is recommended for testing the type of an object. - - With three arguments, \function{type} functions as a constructor - as detailed below. -\end{funcdesc} - -\begin{funcdescni}{type}{name, bases, dict} - Return a new type object. This is essentially a dynamic form of the - \keyword{class} statement. The \var{name} string is the class name - and becomes the \member{__name__} attribute; the \var{bases} tuple - itemizes the base classes and becomes the \member{__bases__} - attribute; and the \var{dict} dictionary is the namespace containing - definitions for class body and becomes the \member{__dict__} - attribute. For example, the following two statements create - identical \class{type} objects: - -\begin{verbatim} - >>> class X(object): - ... a = 1 - ... - >>> X = type('X', (object,), dict(a=1)) -\end{verbatim} -\versionadded{2.2} -\end{funcdescni} - -\begin{funcdesc}{unichr}{i} - Return the Unicode string of one character whose Unicode code is the - integer \var{i}. For example, \code{unichr(97)} returns the string - \code{u'a'}. This is the inverse of \function{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]. - \exception{ValueError} is raised otherwise. - \versionadded{2.0} -\end{funcdesc} - -\begin{funcdesc}{unicode}{\optional{object\optional{, encoding - \optional{, errors}}}} - Return the Unicode string version of \var{object} using one of the - following modes: - - If \var{encoding} and/or \var{errors} are given, \code{unicode()} - will decode the object which can either be an 8-bit string or a - character buffer using the codec for \var{encoding}. The - \var{encoding} parameter is a string giving the name of an encoding; - if the encoding is not known, \exception{LookupError} is raised. - Error handling is done according to \var{errors}; this specifies the - treatment of characters which are invalid in the input encoding. If - \var{errors} is \code{'strict'} (the default), a - \exception{ValueError} is raised on errors, while a value of - \code{'ignore'} causes errors to be silently ignored, and a value of - \code{'replace'} causes the official Unicode replacement character, - \code{U+FFFD}, to be used to replace input characters which cannot - be decoded. See also the \refmodule{codecs} module. - - If no optional parameters are given, \code{unicode()} will mimic the - behaviour of \code{str()} except that it returns Unicode strings - instead of 8-bit strings. More precisely, if \var{object} is a - Unicode string or subclass it will return that Unicode string without - any additional decoding applied. - - For objects which provide a \method{__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 \code{'strict'} mode. - - \versionadded{2.0} - \versionchanged[Support for \method{__unicode__()} added]{2.2} -\end{funcdesc} - -\begin{funcdesc}{vars}{\optional{object}} - Without arguments, return a dictionary corresponding to the current - local symbol table. With a module, class or class instance object - as argument (or anything else that has a \member{__dict__} - attribute), returns a dictionary corresponding to the object's - symbol table. The returned dictionary should not be modified: the - effects on the corresponding symbol table are undefined.\footnote{ - 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.} -\end{funcdesc} - -\begin{funcdesc}{xrange}{\optional{start,} stop\optional{, step}} - This function is very similar to \function{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 - \function{xrange()} over \function{range()} is minimal (since - \function{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 \keyword{break}). - - \note{\function{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.} -\end{funcdesc} - -\begin{funcdesc}{zip}{\optional{iterable, \moreargs}} - This function returns a list of tuples, where the \var{i}-th tuple contains - the \var{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, \function{zip()} is - similar to \function{map()} with an initial argument of \code{None}. - With a single sequence argument, it returns a list of 1-tuples. - With no arguments, it returns an empty list. - \versionadded{2.0} - - \versionchanged[Formerly, \function{zip()} required at least one argument - and \code{zip()} raised a \exception{TypeError} instead of returning - an empty list]{2.4} -\end{funcdesc} - - -% --------------------------------------------------------------------------- - - -\section{Non-essential Built-in Functions \label{non-essential-built-in-funcs}} - -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 bookwriters should feel free to -bypass these functions without concerns about missing something important. - - -\setindexsubitem{(non-essential built-in functions)} - -\begin{funcdesc}{apply}{function, args\optional{, keywords}} - The \var{function} argument must be a callable object (a - user-defined or built-in function or method, or a class object) and - the \var{args} argument must be a sequence. The \var{function} is - called with \var{args} as the argument list; the number of arguments - is the length of the tuple. - If the optional \var{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 \function{apply()} is different from just calling - \code{\var{function}(\var{args})}, since in that case there is always - exactly one argument. The use of \function{apply()} is equivalent - to \code{\var{function}(*\var{args}, **\var{keywords})}. - Use of \function{apply()} is not necessary since the ``extended call - syntax,'' as used in the last example, is completely equivalent. - - \deprecated{2.3}{Use the extended call syntax instead, as described - above.} -\end{funcdesc} - -\begin{funcdesc}{buffer}{object\optional{, offset\optional{, size}}} - The \var{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 \var{object} argument. - The buffer object will be a slice from the beginning of \var{object} - (or from the specified \var{offset}). The slice will extend to the - end of \var{object} (or will have a length given by the \var{size} - argument). -\end{funcdesc} - -\begin{funcdesc}{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 \exception{TypeError}. -\end{funcdesc} - -\begin{funcdesc}{intern}{string} - Enter \var{string} in the table of ``interned'' strings and return - the interned string -- which is \var{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. \versionchanged[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 \function{intern()} - around to benefit from it]{2.3} -\end{funcdesc} |