diff options
Diffstat (limited to 'Doc/lib/libfuncs.tex')
| -rw-r--r-- | Doc/lib/libfuncs.tex | 447 |
1 files changed, 226 insertions, 221 deletions
diff --git a/Doc/lib/libfuncs.tex b/Doc/lib/libfuncs.tex index acf1b09..0808761 100644 --- a/Doc/lib/libfuncs.tex +++ b/Doc/lib/libfuncs.tex @@ -7,44 +7,42 @@ are always available. They are listed here in alphabetical order. \setindexsubitem{(built-in function)} \begin{funcdesc}{__import__}{name\optional{, globals\optional{, locals\optional{, fromlist}}}} -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(), [])}; -the statement \samp{from spam.ham import eggs} results -in \samp{__import__('spam.ham', globals(), locals(), ['eggs'])}. -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 \code{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: + 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(), [])}; the statement \samp{from spam.ham import eggs} + results in \samp{__import__('spam.ham', globals(), locals(), + ['eggs'])}. 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 \code{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} import string @@ -56,7 +54,6 @@ def my_import(name): mod = getattr(mod, comp) return mod \end{verbatim} - \end{funcdesc} \begin{funcdesc}{abs}{x} @@ -66,35 +63,36 @@ def my_import(name): \end{funcdesc} \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 (if it is not a tuple, the sequence is -first converted to a tuple). The \var{function} is called with -\var{args} as the argument list; the number of arguments is the the length -of the tuple. (This is different from just calling -\code{\var{func}(\var{args})}, since in that case there is always -exactly one argument.) -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 the argument list. + 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 (if it is not a tuple, + the sequence is first converted to a tuple). The \var{function} is + called with \var{args} as the argument list; the number of arguments + is the the length of the tuple. (This is different from just + calling \code{\var{func}(\var{args})}, since in that case there is + always exactly one argument.) + 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 the argument list. \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). + 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}{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. + 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} @@ -258,12 +256,12 @@ class instances are callable if they have a \method{__call__()} method. environment where \function{execfile()} is called. The return value is \code{None}. - \strong{Warning:} The default \var{locals} act as described for function + \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. + be used reliably to modify a function's locals.} \end{funcdesc} \begin{funcdesc}{file}{filename\optional{, mode\optional{, bufsize}}} @@ -328,11 +326,11 @@ class instances are callable if they have a \method{__call__()} method. number with the same value (within Python's floating point precision) is returned. - \strong{Note:} When passing in a string, values for NaN\index{NaN} + \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. + and is known to vary.} \end{funcdesc} \begin{funcdesc}{getattr}{object, name\optional{, default}} @@ -345,10 +343,10 @@ class instances are callable if they have a \method{__call__()} method. \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). + 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} @@ -386,14 +384,14 @@ module from which it is called). \begin{funcdesc}{input}{\optional{prompt}} Equivalent to \code{eval(raw_input(\var{prompt}))}. - \strong{Warning:} This function is not safe from user errors! It + \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.) + need when writing a quick script for expert use.)} - If the \module{readline} module was loaded, then + If the \refmodule{readline} module was loaded, then \function{input()} will use it to provide elaborate line editing and history features. @@ -430,21 +428,26 @@ module from which it is called). garbage collected). \end{funcdesc} -\begin{funcdesc}{isinstance}{object, class} -Return true if the \var{object} argument is an instance of the -\var{class} argument, or of a (direct or indirect) subclass thereof. -Also return true if \var{class} is a type object and \var{object} is -an object of that type. If \var{object} is not a class instance or a -object of the given type, the function always returns false. If -\var{class} is neither a class object nor a type object, a -\exception{TypeError} exception is raised. +\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 and + \var{object} is an object of that type. If \var{object} is not a + class instance or a 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}{class1, class2} -Return true if \var{class1} is a subclass (direct or indirect) of -\var{class2}. A class is considered a subclass of itself. If either -argument is not a class object, a \exception{TypeError} exception is -raised. + Return true if \var{class1} is a subclass (direct or indirect) of + \var{class2}. A class is considered a subclass of itself. If + either argument is not a class object, a \exception{TypeError} + exception is raised. \end{funcdesc} \begin{funcdesc}{iter}{o\optional{, sentinel}} @@ -480,10 +483,10 @@ raised. \end{funcdesc} \begin{funcdesc}{locals}{} -Return a dictionary representing the current local symbol table. -\strong{Warning:} The contents of this dictionary should not be -modified; changes may not affect the values of local variables used by -the interpreter. + 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.} \end{funcdesc} \begin{funcdesc}{long}{x\optional{, radix}} @@ -612,74 +615,75 @@ the interpreter. "Monty Python's Flying Circus" \end{verbatim} -If the \module{readline} module was loaded, then -\function{raw_input()} will use it to provide elaborate -line editing and history features. + 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, sequence\optional{, initializer}} -Apply \var{function} of two arguments cumulatively to the items of -\var{sequence}, from left to right, so as to reduce the sequence 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)}. -If the optional \var{initializer} is present, it is placed before the -items of the sequence in the calculation, and serves as a default when -the sequence is empty. + Apply \var{function} of two arguments cumulatively to the items of + \var{sequence}, from left to right, so as to reduce the sequence 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)}. + If the optional \var{initializer} is present, it is placed before + the items of the sequence in the calculation, and serves as a + default when the sequence is empty. \end{funcdesc} \begin{funcdesc}{reload}{module} -Re-parse and re-initialize an already 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). - -There are a number of 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. - -It is legal though generally not very useful to reload built-in or -dynamically loaded modules, except for \module{sys}, \module{__main__} -and \module{__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. + Re-parse and re-initialize an already 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). + + There are a number of 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. + + 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()}. + 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}{round}{x\optional{, n}} @@ -701,42 +705,43 @@ when passed to \function{eval()}. \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 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]}. + 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 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}{str}{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. + 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. \end{funcdesc} \begin{funcdesc}{tuple}{sequence} -Return a tuple whose items are the same and in the same order as -\var{sequence}'s items. \var{sequence} may be a sequence, a -container that supports iteration, or an iterator object. -If \var{sequence} is already a tuple, it -is returned unchanged. For instance, \code{tuple('abc')} returns -returns \code{('a', 'b', 'c')} and \code{tuple([1, 2, 3])} returns -\code{(1, 2, 3)}. + Return a tuple whose items are the same and in the same order as + \var{sequence}'s items. \var{sequence} may be a sequence, a + container that supports iteration, or an iterator object. + If \var{sequence} is already a tuple, it + is returned unchanged. For instance, \code{tuple('abc')} returns + returns \code{('a', 'b', 'c')} and \code{tuple([1, 2, 3])} returns + \code{(1, 2, 3)}. \end{funcdesc} \begin{funcdesc}{type}{object} -Return the type of an \var{object}. The return value is a type -object. The standard module \module{types} defines names for all -built-in types. -\refstmodindex{types} -\obindex{type} -For instance: + Return the type of an \var{object}. The return value is a + type\obindex{type} object. The standard module + \module{types}\refstmodindex{types} defines names for all built-in + types. + For instance: \begin{verbatim} >>> import types @@ -745,62 +750,62 @@ For instance: \end{funcdesc} \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 argument must be in the range [0..65535], inclusive. -\exception{ValueError} is raised otherwise. -\versionadded{2.0} + 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 argument must be in the range [0..65535], inclusive. + \exception{ValueError} is raised otherwise. + \versionadded{2.0} \end{funcdesc} \begin{funcdesc}{unicode}{string\optional{, encoding\optional{, errors}}} -Create a Unicode string from an 8-bit string \var{string} using the -codec for \var{encoding}. The \var{encoding} parameter is a string -giving the name of an encoding. 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. The default behavior is to decode UTF-8 in strict -mode, meaning that encoding errors raise \exception{ValueError}. See -also the \refmodule{codecs} module. -\versionadded{2.0} + Create a Unicode string from an 8-bit string \var{string} using the + codec for \var{encoding}. The \var{encoding} parameter is a string + giving the name of an encoding. 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. The default behavior is to decode UTF-8 in + strict mode, meaning that encoding errors raise + \exception{ValueError}. See also the \refmodule{codecs} module. + \versionadded{2.0} \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.} + 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}). + 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}). \end{funcdesc} \begin{funcdesc}{zip}{seq1, \moreargs} -This function returns a list of tuples, where each tuple contains the -\var{i}-th element from each of the argument sequences. At least one -sequence is required, otherwise a \exception{TypeError} is raised. -The returned list is truncated in length to the length of the shortest -argument sequence. When there are multiple argument sequences 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. -\versionadded{2.0} + This function returns a list of tuples, where each tuple contains + the \var{i}-th element from each of the argument sequences. At + least one sequence is required, otherwise a \exception{TypeError} is + raised. The returned list is truncated in length to the length of + the shortest argument sequence. When there are multiple argument + sequences 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. + \versionadded{2.0} \end{funcdesc} |