 |
 |
 |
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]]]) |
For example, the statement "import spam" results in the
following call: __import__('spam', globals(),
locals(), []); the statement "from spam.ham import eggs" results in "__import__('spam.ham', globals(), locals(),
['eggs'])". 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
| x) |
| ) |
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:
def f(cls, arg1, arg2, ...): ...
f = classmethod(f)
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. New in version 2.2.
| 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 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 statemants 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]]) |
>>> 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 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]]) |
stdio's
fopen(): filename is the file name to be opened,
mode indicates how the file is to be opened: 'r' for
reading, 'w' for writing (truncating an existing file), and
'a' opens it for appending (which on some Unix
systems means that all writes append to the end of the file,
regardless of the current seek position).
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 (else it is
ignored). If the file cannot be opened, IOError is
raised.
In addition to the standard fopen() values mode
may be 'U' or 'rU'. If Python is built with universal
newline support (the default) the file is opened as a text file, but
lines may be terminated by any of '\n', the Unix end-of-line
convention,
'\r', the Macintosh convention or '\r\n', the Windows
convention. All of these external representations are seen as
'\n'
by the Python program. If Python is built without universal newline support
mode '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.
If mode is omitted, it defaults to 'r'. When opening a
binary file, you should append 'b' to the mode value
for improved portability. (It's useful even on systems which don't
treat binary and text files differently, where it serves as
documentation.)
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
The file() constructor is new in Python 2.2. The previous spelling, open(), is retained for compatibility, and is an alias for file().
| function, list) |
None, the identity
function is assumed, that is, all elements of list that are false
(zero or empty) 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]) |
string.atof(x). 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 0.0.
Note: When passing in a string, values for NaN and Infinitymay 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.
| 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) |
getattr(object,
name) and seeing whether it raises an exception or not.)
| object) |
| [object]) |
| x) |
hex(-1) yields '0xffffffff'. When evaluated on a
machine with the same word size, this literal is evaluated as -1; at
a different word size, it may turn up as a large positive number or
raise an OverflowError exception.
| 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]]) |
string.atol(x). The
radix argument is interpreted in the same way as for
int(), and may only be given when 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 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...]) |
| s[, args...]) |
| ) |
Changed in version 2.3: This function does not accept any arguments. Formerly, it accepted arguments but ignored them.
| x) |
oct(-1)
yields '037777777777'. When evaluated on a machine with the
same word size, this literal is evaluated as -1; at a different word
size, it may turn up as a large positive number or raise an
OverflowError exception.
| filename[, mode[, bufsize]]) |
| c) |
ord('a') returns the integer 97,
ord(u'\u2020') returns 8224. This is the inverse of
chr() for strings and of unichr() for Unicode
characters.
| x, y[, z]) |
pow(x, y) % z). 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 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.")
New in version 2.2.
| [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 largest 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) |
There are a number of 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.
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) |
| x[, n]) |
round(0.5) is 1.0 and round(-0.5) is -1.0).
| 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 Pythonand 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]".
| function) |
A static method does not receive an implicit first argument. To declare a static method, use this idiom:
class C:
def f(arg1, arg2, ...): ...
f = staticmethod(f)
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. New in version 2.2.
| [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)
| [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) |
>>> import types >>> x = 'abc' >>> if type(x) is str: print "It's a string" ... It's a string >>> def f(): pass ... >>> if type(f) is types.FunctionType: print "It's a function" ... It's a function
The isinstance() built-in function is recommended for testing the type of an object.
| i) |
unichr(97) returns the string
u'a'. This is the inverse of ord() for Unicode
strings. The argument must be in the range [0..65535], inclusive.
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]) |
| seq1, ...) |
None.
With a single sequence argument, it returns a list of 1-tuples.
New in version 2.0.
|
|
|
Python Library Reference | |
|
|