 |
 |
 |
Python Library Reference |  |
 |
 |
|
|
|
Python Library Reference | |
|
|
The Python interpreter has a number of functions built into it that are always available. They are listed here in alphabetical order.
| name[, globals[, locals[, fromlist[, level]]]]) |
For example, the statement "import spam" results in the
following call: __import__('spam', globals(),
locals(), [], -1); the statement "from spam.ham import eggs" results in "__import__('spam.ham', globals(), locals(),
['eggs'], -1)". Note that even though locals() and
['eggs'] are passed in as arguments, the
__import__() function does not set the local variable
named eggs; this is done by subsequent code that is generated
for the import statement. (In fact, the standard implementation
does not use its locals argument at all, and uses its
globals only to determine the package context of the
import statement.)
When the name variable is of the form package.module,
normally, the top-level package (the name up till the first dot) is
returned, not the module named by name. However, when
a non-empty fromlist argument is given, the module named by
name is returned. This is done for compatibility with the
bytecode generated for the different kinds of import statement; when
using "import spam.ham.eggs", the top-level package spam
must be placed in the importing namespace, but when using "from
spam.ham import eggs", the spam.ham subpackage must be used
to find the eggs variable. As a workaround for this
behavior, use getattr() to extract the desired
components. For example, you could define the following helper:
def my_import(name):
mod = __import__(name)
components = name.split('.')
for comp in components[1:]:
mod = getattr(mod, comp)
return mod
level specifies whether to use absolute or relative imports.
The default is -1 which indicates both absolute and relative
imports will be attempted. 0 means only perform absolute imports.
Positive values for level indicate the number of parent directories
to search relative to the directory of the module calling
__import__.
Changed in version 2.5:
The level parameter was added.
Changed in version 2.5:
Keyword support for parameters was added.
| x) |
| iterable) |
def all(iterable):
for element in iterable:
if not element:
return False
return True
| iterable) |
def any(iterable):
for element in iterable:
if element:
return True
return False
| ) |
isinstance(obj, basestring) is equivalent to
isinstance(obj, (str, unicode)).
New in version 2.3.
| [x]) |
New in version 2.2.1. Changed in version 2.3: If no argument is given, this function returns False.
| object) |
| i) |
chr(97) returns the string 'a'.
This is the inverse of ord(). The argument must be in
the range [0..255], inclusive; ValueError will be raised
if i is outside that range.
| 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:
class C:
@classmethod
def f(cls, arg1, arg2, ...): ...
The @classmethod form is a function decorator - see the description
of function definitions in chapter 7 of the
Python Reference Manual for details.
It can be called either on the class (such as C.f()) or on an
instance (such as C().f()). The instance is ignored except for
its class.
If a class method is called for a derived class, the derived class
object is passed as the implied first argument.
Class methods are different than C++ or Java static methods. If you want those, see staticmethod() in this section.
For more information on class methods, consult the documentation on the standard type hierarchy in chapter 3 of the Python Reference Manual (at the bottom). New in version 2.2. Changed in version 2.4: Function decorator syntax added.
| x, y) |
x
< y, zero if x == y and strictly positive if
x > y.
| string, filename, kind[, flags[, dont_inherit]]) |
'<string>' is commonly used).
The kind argument specifies what kind of code must be
compiled; it can be 'exec' if string consists of a
sequence of statements, 'eval' if it consists of a single
expression, or 'single' if it consists of a single
interactive statement (in the latter case, expression statements
that evaluate to something else than None will be printed).
When compiling multi-line statements, two caveats apply: line
endings must be represented by a single newline character
('\n'), and the input must be terminated by at least one
newline character. If line endings are represented by
'\r\n', use the string replace() method to
change them into '\n'.
The optional arguments flags and dont_inherit (which are new in Python 2.2) control which future statements (see PEP 236) affect the compilation of string. 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 flags argument is given and dont_inherit is not (or is zero) then the future statements specified by the flags argument are used in addition to those that would be used anyway. If dont_inherit is a non-zero integer then the 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 compiler_flag attribute on the _Feature instance in the __future__ module.
| [real[, imag]]) |
0j.
| object, name) |
delattr(x, 'foobar') is equivalent to
del x.foobar.
| [mapping-or-sequence]) |
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
{"one": 2, "two": 3}:
dict({'one': 2, 'two': 3})
dict({'one': 2, 'two': 3}.items())
dict({'one': 2, 'two': 3}.iteritems())
dict(zip(('one', 'two'), (2, 3)))
dict([['two', 3], ['one', 2]])
dict(one=2, two=3)
dict([(['one', 'two'][i-2], i) for i in (2, 3)])
New in version 2.2. Changed in version 2.3: Support for building a dictionary from keyword arguments added.
| [object]) |
>>> import struct >>> dir() ['__builtins__', '__doc__', '__name__', 'struct'] >>> dir(struct) ['__doc__', '__name__', 'calcsize', 'error', 'pack', 'unpack']
Note: Because 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.
| a, b) |
(a // b, a % b).
For floating point numbers the result is (q, a %
b), where q is usually math.floor(a /
b) but may be 1 less than that. In any case q *
b + a % b is very close to a, if
a % b is non-zero it has the same sign as
b, and 0 <= abs(a % b) < abs(b).
Changed in version 2.3: Using divmod() with complex numbers is deprecated.
| iterable) |
(0, seq[0]), (1, seq[1]), (2,
seq[2]), ....
New in version 2.3.
| expression[, globals[, locals]]) |
The expression argument is parsed and evaluated as a Python expression (technically speaking, a condition list) using the globals and locals dictionaries as global and local name space. If the globals dictionary is present and lacks '__builtins__', the current globals are copied into globals before expression is parsed. This means that expression normally has full access to the standard __builtin__ module and restricted environments are propagated. If the locals dictionary is omitted it defaults to the globals dictionary. If both dictionaries are omitted, the expression is executed in the environment where eval is called. The return value is the result of the evaluated expression. Syntax errors are reported as exceptions. Example:
>>> x = 1
>>> print eval('x+1')
2
This function can also be used to execute arbitrary code objects
(such as those created by compile()). In this case pass
a code object instead of a string. The code object must have been
compiled passing 'eval' as the kind argument.
Hints: dynamic execution of statements is supported by the exec statement. Execution of statements from a file is supported by the execfile() function. The globals() and locals() functions returns the current global and local dictionary, respectively, which may be useful to pass around for use by eval() or execfile().
| filename[, globals[, locals]]) |
The arguments are a file name and two optional dictionaries. The file is
parsed and evaluated as a sequence of Python statements (similarly to a
module) using the globals and locals dictionaries as global and
local namespace. If provided, locals can be any mapping object.
Changed in version 2.4:
formerly locals was required to be a dictionary.
If the locals dictionary is omitted it defaults to the globals
dictionary. If both dictionaries are omitted, the expression is executed in
the environment where execfile() is called. The return value is
None.
Warning: The default locals act as described for function locals() below: modifications to the default locals dictionary should not be attempted. Pass an explicit locals dictionary if you need to see effects of the code on locals after function execfile() returns. execfile() cannot be used reliably to modify a function's locals.
| filename[, mode[, bufsize]]) |
When opening a file, it's preferable to use open() instead of invoking this constructor directly. file is more suited to type testing (for example, writing "isinstance(f, file)").
New in version 2.2.
| function, list) |
None, the identity function is assumed, that is, all elements of
list that are false are removed.
Note that filter(function, list) is equivalent to
[item for item in list if function(item)] if function is
not None and [item for item in list if item] if
function is None.
| [x]) |
0.0.
Note: When passing in a string, values for NaN and 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.
| [iterable]) |
frozenset([]).
New in version 2.4.
| object, name[, default]) |
getattr(x, 'foobar') is equivalent to x.foobar. If the
named attribute does not exist, default is returned if provided,
otherwise AttributeError is raised.
| ) |
| object, name) |
True if the
string is the name of one of the object's attributes, False if not.
(This is implemented by calling getattr(object,
name) and seeing whether it raises an exception or not.)
| object) |
| [object]) |
| x) |
| object) |
| [prompt]) |
eval(raw_input(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 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 readline module was loaded, then input() will use it to provide elaborate line editing and history features.
Consider using the raw_input() function for general input from users.
| [x[, radix]]) |
0.
| object, classinfo) |
| class, classinfo) |
| o[, sentinel]) |
0). If it does not
support either of those protocols, TypeError is raised.
If the second argument, sentinel, is given, then o must
be a callable object. The iterator created in this case will call
o with no arguments for each call to its next()
method; if the value returned is equal to sentinel,
StopIteration will be raised, otherwise the value will
be returned.
New in version 2.2.
| s) |
| [sequence]) |
sequence[:]. For instance,
list('abc') returns ['a', 'b', 'c'] and list(
(1, 2, 3) ) returns [1, 2, 3]. If no argument is given,
returns a new empty list, [].
| ) |
| [x[, radix]]) |
0L.
| function, list, ...) |
None items. If function
is None, the identity function is assumed; if there are
multiple list arguments, map() returns a list consisting
of tuples containing the corresponding items from all lists (a kind
of transpose operation). The list arguments may be any kind
of sequence; the result is always a list.
| s[, args...][key]) |
The optional key argument specifies a one-argument ordering function like that used for list.sort(). The key argument, if supplied, must be in keyword form (for example, "max(a,b,c,key=func)"). Changed in version 2.5: Added support for the optional key argument.
| s[, args...][key]) |
The optional key argument specifies a one-argument ordering function like that used for list.sort(). The key argument, if supplied, must be in keyword form (for example, "min(a,b,c,key=func)"). Changed in version 2.5: Added support for the optional key argument.
| ) |
Changed in version 2.3: This function does not accept any arguments. Formerly, it accepted arguments but ignored them.
| x) |
| filename[, mode[, bufsize]]) |
The first two arguments are the same as for stdio's
fopen(): filename is the file name to be opened,
and mode is a string indicating how the file is to be opened.
The most commonly-used values of mode are 'r' for
reading, 'w' for writing (truncating the file if it already
exists), and 'a' for appending (which on some Unix
systems means that all writes append to the end of the file
regardless of the current seek position). If mode is omitted,
it defaults to 'r'. When opening a binary file, you should
append 'b' to the mode value to open the file in binary
mode, which will improve portability. (Appending 'b' is
useful even on systems that don't treat binary and text files
differently, where it serves as documentation.) See below for more
possible values of mode.
The optional 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 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.2.3
Modes 'r+', 'w+' and 'a+' open the file for
updating (note that 'w+' truncates the file). Append
'b' to the mode to open the file in binary mode, on systems
that differentiate between binary and text files; on systems
that don't have this distinction, adding the 'b' has no effect.
In addition to the standard fopen() values mode
may be 'U' or 'rU'. Python is usually built with universal
newline support; supplying 'U' opens the file as a text file, but
lines may be terminated by any of the following: the Unix end-of-line
convention '\n',
the Macintosh convention '\r', or the Windows
convention '\r\n'. All of these external representations are seen as
'\n'
by the Python program. If Python is built without universal newline support
a mode with 'U' is the same as normal text mode. Note that
file objects so opened also have an attribute called
newlines which has a value of None (if no newlines
have yet been seen), '\n', '\r', '\r\n',
or a tuple containing all the newline types seen.
Python enforces that the mode, after stripping 'U', begins with
'r', 'w' or 'a'.
Changed in version 2.5: Restriction on first letter of mode string introduced.
| c) |
ord('a') returns the integer 97,
ord(u'\u2020') returns 8224. This is the inverse of
chr() for 8-bit strings and of unichr() for unicode
objects. If a unicode argument is given and Python was built with
UCS2 Unicode, then the character's code point must be in the range
[0..65535] inclusive; otherwise the string length is two, and a
TypeError will be raised.
| x, y[, z]) |
pow(x, y) % z).
The two-argument form pow(x, y) is equivalent to using
the power operator: x**y.
The arguments must have numeric types. With mixed operand types, the
coercion rules for binary arithmetic operators apply. For int and
long int operands, the result has the same type as the operands
(after coercion) unless the second argument is negative; in that
case, all arguments are converted to float and a float result is
delivered. For example, 10**2 returns 100, but
10**-2 returns 0.01. (This last feature was added in
Python 2.2. In Python 2.1 and before, if both arguments were of integer
types and the second argument was negative, an exception was raised.)
If the second argument is negative, the third argument must be omitted.
If z is present, x and y must be of integer types,
and y must be non-negative. (This restriction was added in
Python 2.2. In Python 2.1 and before, floating 3-argument pow()
returned platform-dependent results depending on floating-point
rounding accidents.)
| [fget[, fset[, fdel[, doc]]]]) |
fget is a function for getting an attribute value, likewise fset is a function for setting, and fdel a function for del'ing, an attribute. Typical use is to define a managed attribute x:
class C(object):
def __init__(self): self.__x = None
def getx(self): return self._x
def setx(self, value): self._x = value
def delx(self): del self._x
x = property(getx, setx, delx, "I'm the 'x' property.")
If given, doc will be the docstring of the property attribute. Otherwise, the property will copy fget's docstring (if it exists). This makes it possible to create read-only properties easily using property() as a decorator:
class Parrot(object):
def __init__(self):
self._voltage = 100000
@property
def voltage(self):
"""Get the current voltage."""
return self._voltage
turns the voltage() method into a ``getter'' for a read-only attribute with the same name.
New in version 2.2. Changed in version 2.5: Use fget's docstring if no doc given.
| [start,] stop[, step]) |
1. If the start argument is
omitted, it defaults to 0. The full form returns a list of
plain integers [start, start + step,
start + 2 * step, ...]. If step is positive,
the last element is the largest start + i *
step less than stop; if step is negative, the last
element is the smallest start + i * step
greater than stop. step must not be zero (or else
ValueError is raised). Example:
>>> range(10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> range(1, 11) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] >>> range(0, 30, 5) [0, 5, 10, 15, 20, 25] >>> range(0, 10, 3) [0, 3, 6, 9] >>> range(0, -10, -1) [0, -1, -2, -3, -4, -5, -6, -7, -8, -9] >>> range(0) [] >>> range(1, 0) []
| [prompt]) |
>>> s = raw_input('--> ')
--> Monty Python's Flying Circus
>>> s
"Monty Python's Flying Circus"
If the readline module was loaded, then raw_input() will use it to provide elaborate line editing and history features.
| function, sequence[, initializer]) |
reduce(lambda x, y: x+y, [1, 2,
3, 4, 5]) calculates ((((1+2)+3)+4)+5). The left argument,
x, is the accumulated value and the right argument, y,
is the update value from the sequence. If the optional
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. If initializer is not given and
sequence contains only one item, the first item is returned.
| module) |
When reload(module) is executed:
init function of extension
modules is not called a second time.
There are a number of other caveats:
If a module is syntactically correct but its initialization fails,
the first import statement for it does not bind its name
locally, but does store a (partially initialized) module object in
sys.modules. To reload the module you must first
import it again (this will bind the name to the partially
initialized module object) before you can 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 try statement it can test for the table's presence and skip its initialization if desired:
try:
cache
except NameError:
cache = {}
It is legal though generally not very useful to reload built-in or dynamically loaded modules, except for sys, __main__ and __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 from ... import ..., calling reload() for the other module does not redefine the objects imported from it -- one way around this is to re-execute the from statement, another is to use import and qualified names (module.name) instead.
If a module instantiates instances of a class, reloading the module that defines the class does not affect the method definitions of the instances -- they continue to use the old class definition. The same is true for derived classes.
| object) |
| seq) |
0).
New in version 2.4.
| x[, n]) |
round(0.5) is 1.0 and round(-0.5) is -1.0).
| [iterable]) |
set([]).
New in version 2.4.
| object, name, value) |
setattr(x, 'foobar', 123) is equivalent to
x.foobar = 123.
| [start,] stop[, step]) |
range(start, stop, step). The start
and step arguments default to None. Slice objects have
read-only data attributes start, stop and
step which merely return the argument values (or their
default). They have no other explicit functionality; however they
are used by Numerical Python and other third
party extensions. Slice objects are also generated when extended
indexing syntax is used. For example: "a[start:stop:step]" or
"a[start:stop, i]".
| iterable[, cmp[, key[, reverse]]]) |
The optional arguments cmp, key, and reverse have the same meaning as those for the list.sort() method (described in section 3.6.4).
cmp specifies a custom comparison function of two arguments (iterable elements) which should return a negative, zero or positive number depending on whether the first argument is considered smaller than, equal to, or larger than the second argument: "cmp=lambda x,y: cmp(x.lower(), y.lower())"
key specifies a function of one argument that is used to extract a comparison key from each list element: "key=str.lower"
reverse is a boolean value. If set to True, then the
list elements are sorted as if each comparison were reversed.
In general, the key and reverse conversion processes are much faster than specifying an equivalent cmp function. This is because cmp is called multiple times for each list element while key and reverse touch each element only once.
New in version 2.4.
| function) |
A static method does not receive an implicit first argument. To declare a static method, use this idiom:
class C:
@staticmethod
def f(arg1, arg2, ...): ...
The @staticmethod form is a function decorator - see the description
of function definitions in chapter 7 of the
Python Reference Manual for details.
It can be called either on the class (such as C.f()) or on an
instance (such as C().f()). The instance is ignored except
for its class.
Static methods in Python are similar to those found in Java or C++. For a more advanced concept, see classmethod() in this section.
For more information on static methods, consult the documentation on the standard type hierarchy in chapter 3 of the Python Reference Manual (at the bottom). New in version 2.2. Changed in version 2.4: Function decorator syntax added.
| [object]) |
repr(object) is that
str(object) does not always attempt to return a string
that is acceptable to eval(); its goal is to return a
printable string. If no argument is given, returns the empty
string, ''.
| sequence[, start]) |
0.
The sequence's items are normally numbers, and are not allowed
to be strings. The fast, correct way to concatenate sequence of
strings is by calling ''.join(sequence).
Note that sum(range(n), m) is equivalent to
reduce(operator.add, range(n), m)
New in version 2.3.
| type[, object-or-type]) |
isinstance(obj, type) must be true. If
the second argument is a type, issubclass(type2,
type) must be true.
super() only works for new-style classes.
A typical use for calling a cooperative superclass method is:
class C(B):
def meth(self, arg):
super(C, self).meth(arg)
Note that super is implemented as part of the binding process for explicit dotted attribute lookups such as "super(C, self).__getitem__(name)". Accordingly, super is undefined for implicit lookups using statements or operators such as "super(C, self)[name]". New in version 2.2.
| [sequence]) |
tuple('abc') returns
('a', 'b', 'c') and tuple([1, 2, 3]) returns
(1, 2, 3). If no argument is given, returns a new empty
tuple, ().
| object) |
With three arguments, type functions as a constructor as detailed below.
| name, bases, dict) |
>>> class X(object):
... a = 1
...
>>> X = type('X', (object,), dict(a=1))
| i) |
unichr(97) returns the string
u'a'. This is the inverse of ord() for Unicode
strings. The valid range for the argument depends how Python was
configured - it may be either UCS2 [0..0xFFFF] or UCS4 [0..0x10FFFF].
ValueError is raised otherwise.
New in version 2.0.
| [object[, encoding [, errors]]]) |
If encoding and/or errors are given, unicode()
will decode the object which can either be an 8-bit string or a
character buffer using the codec for encoding. The
encoding parameter is a string giving the name of an encoding;
if the encoding is not known, LookupError is raised.
Error handling is done according to errors; this specifies the
treatment of characters which are invalid in the input encoding. If
errors is 'strict' (the default), a
ValueError is raised on errors, while a value of
'ignore' causes errors to be silently ignored, and a value of
'replace' causes the official Unicode replacement character,
U+FFFD, to be used to replace input characters which cannot
be decoded. See also the codecs module.
If no optional parameters are given, unicode() will mimic the
behaviour of str() except that it returns Unicode strings
instead of 8-bit strings. More precisely, if object is a
Unicode string or subclass it will return that Unicode string without
any additional decoding applied.
For objects which provide a __unicode__() method, it will
call this method without arguments to create a Unicode string. For
all other objects, the 8-bit string version or representation is
requested and then converted to a Unicode string using the codec for
the default encoding in 'strict' mode.
New in version 2.0. Changed in version 2.2: Support for __unicode__() added.
| [object]) |
| [start,] stop[, step]) |
Note: 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.
| [iterable, ...]) |
None.
With a single sequence argument, it returns a list of 1-tuples.
With no arguments, it returns an empty list.
New in version 2.0.
Changed in version 2.4:
Formerly, zip() required at least one argument
and zip() raised a TypeError instead of returning
an empty list.
|
|
|
Python Library Reference | |
|
|