 |
 |
 |
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.
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:
import string
def my_import(name):
mod = __import__(name)
components = string.split(name, '.')
for comp in components[1:]:
mod = getattr(mod, comp)
return mod
function(args), since in that case there is always
exactly one argument. The use of apply() is equivalent
to function(*args, **keywords).
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.
x
< y, zero if x == y and strictly positive if
x > y.
'<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.
delattr(x, 'foobar') is equivalent to
del x.foobar.
{1: 2, 2: 3}:
dict({1: 2, 2: 3})
dict({1: 2, 2: 3}.items())
dict({1: 2, 2: 3}.iteritems())
dict(zip((1, 2), (2, 3)))
dict([[2, 3], [1, 2]])
dict([(i-1, i) for i in (2, 3)])
>>> import sys >>> dir() ['sys'] >>> dir(sys) ['argv', 'exit', 'modules', 'path', 'stderr', 'stdin', 'stdout']
(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).
>>> 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().
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.
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.
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 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().
None, the identity
function is assumed, that is, all elements of list that are false
(zero or empty) are removed.
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.
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.
getattr(x, 'foobar') is equivalent to x.foobar. If the
named attribute does not exist, default is returned if provided,
otherwise AttributeError is raised.
getattr(object,
name) and seeing whether it raises an exception or not.)
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.
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.
string.atoi(x[,
radix]). The radix parameter gives the base for the
conversion and may be any integer in the range [2, 36], or zero. If
radix is zero, the proper radix is guessed based on the
contents of string; the interpretation is the same as for integer
literals. If radix is specified and x is not a string,
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).
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.
sequence[:]. For instance,
list('abc') returns ['a', 'b', 'c'] and list(
(1, 2, 3) ) returns [1, 2, 3].
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).
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.
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.
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.
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.)
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) []
>>> 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.
reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
((((1+2)+3)+4)+5).
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.
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.
round(0.5) is 1.0 and round(-0.5) is -1.0).
setattr(x, 'foobar', 123) is equivalent to
x.foobar = 123.
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]".
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.
tuple('abc') returns
returns ('a', 'b', 'c') and tuple([1, 2, 3]) returns
(1, 2, 3).
>>> import types >>> if type(x) == types.StringType: print "It's a string"
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.
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.
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 an
Unicode string or subclass it will return a 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.
None.
With a single sequence argument, it returns a list of 1-tuples.
New in version 2.0.
|
|
|
Python Library Reference | |
|
|