Built-in functions, exceptions, and other objects.

Noteworthy: None is the `nil' object; Ellipsis represents `...' in slices.

__import__(no arg info)
__import__(name, globals, locals, fromlist) -> module
Import a module.  The globals are only used to determine the context;
they are not modified.  The locals are currently unused.  The fromlist
should be a list of names to emulate ``from name import ...'', or an
empty list to emulate ``import name''.
When importing a module from a package, note that __import__('A.B', ...)
returns package A when fromlist is empty, but its submodule B when
fromlist is not empty.
abs(no arg info)
abs(number) -> number
Return the absolute value of the argument.
apply(no arg info)
apply(function, args[, kwargs]) -> value
Call a function with positional arguments taken from the tuple args,
and keyword arguments taken from the optional dictionary kwargs.
buffer(no arg info)
buffer(object [, offset[, size]) -> object
Creates a new buffer object which references the given object.
The buffer will reference a slice of the target object from the
start of the object (or at the specified offset). The slice will
extend to the end of the target object (or with the specified size).
callable(no arg info)
callable(object) -> Boolean
Return whether the object is callable (i.e., some kind of function).
Note that classes are callable, as are instances with a __call__() method.
chr(no arg info)
chr(i) -> character
Return a string of one character with ordinal i; 0 <= i < 256.
cmp(no arg info)
cmp(x, y) -> integer
Return negative if x<y, zero if x==y, positive if x>y.
coerce(no arg info)
coerce(x, y) -> None or (x1, y1)
When x and y can be coerced to values of the same type, return a tuple
containing the coerced values.  When they can't be coerced, return None.
compile(no arg info)
compile(source, filename, mode) -> code object
Compile the source string (a Python module, statement or expression)
into a code object that can be executed by the exec statement or eval().
The filename will be used for run-time error messages.
The mode must be 'exec' to compile a module, 'single' to compile a
single (interactive) statement, or 'eval' to compile an expression.
complex(no arg info)
complex(real[, imag]) -> complex number
Create a complex number from a real part and an optional imaginary part.
This is equivalent to (real + imag*1j) where imag defaults to 0.
delattr(no arg info)
delattr(object, name)
Delete a named attribute on an object; delattr(x, 'y') is equivalent to
``del x.y''.
dir(no arg info)
dir([object]) -> list of strings
Return an alphabetized list of names comprising (some of) the attributes
of the given object.  Without an argument, the names in the current scope
are listed.  With an instance argument, only the instance attributes are
returned.  With a class argument, attributes of the base class are not
returned.  For other types or arguments, this may list members or methods.
divmod(no arg info)
divmod(x, y) -> (div, mod)
Return the tuple ((x-x%y)/y, x%y).  Invariant: div*y + mod == x.
eval(no arg info)
eval(source[, globals[, locals]]) -> value
Evaluate the source in the context of globals and locals.
The source may be a string representing a Python expression
or a code object as returned by compile().
The globals and locals are dictionaries, defaulting to the current
globals and locals.  If only globals is given, locals defaults to it.
execfile(no arg info)
execfile(filename[, globals[, locals]])
Read and execute a Python script from a file.
The globals and locals are dictionaries, defaulting to the current
globals and locals.  If only globals is given, locals defaults to it.
filter(no arg info)
filter(function, sequence) -> list
Return a list containing those items of sequence for which function(item)
is true.  If function is None, return a list of items that are true.
float(no arg info)
float(x) -> floating point number
Convert a string or number to a floating point number, if possible.
getattr(no arg info)
getattr(object, name[, default]) -> value
Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
When a default argument is given, it is returned when the attribute doesn't
exist; without it, an exception is raised in that case.
globals(no arg info)
globals() -> dictionary
Return the dictionary containing the current scope's global variables.
hasattr(no arg info)
hasattr(object, name) -> Boolean
Return whether the object has an attribute with the given name.
(This is done by calling getattr(object, name) and catching exceptions.)
hash(no arg info)
hash(object) -> integer
Return a hash value for the object.  Two objects with the same value have
the same hash value.  The reverse is not necessarily true, but likely.
hex(no arg info)
hex(number) -> string
Return the hexadecimal representation of an integer or long integer.
id(no arg info)
id(object) -> integer
Return the identity of an object.  This is guaranteed to be unique among
simultaneously existing objects.  (Hint: it's the object's memory address.)
input(no arg info)
input([prompt]) -> value
Equivalent to eval(raw_input(prompt)).
int(no arg info)
int(x) -> integer
Convert a string or number to an integer, if possible.
A floating point argument will be truncated towards zero.
intern(no arg info)
intern(string) -> string
``Intern'' the given string.  This enters the string in the (global)
table of interned strings whose purpose is to speed up dictionary lookups.
Return the string itself or the previously interned string object with the
same value.
isinstance(no arg info)
isinstance(object, class-or-type) -> Boolean
Return whether an object is an instance of a class or of a subclass thereof.
With a type as second argument, return whether that is the object's type.
issubclass(no arg info)
issubclass(C, B) -> Boolean
Return whether class C is a subclass (i.e., a derived class) of class B.
len(no arg info)
len(object) -> integer
Return the number of items of a sequence or mapping.
list(no arg info)
list(sequence) -> list
Return a new list whose items are the same as those of the argument sequence.
locals(no arg info)
locals() -> dictionary
Return the dictionary containing the current scope's local variables.
long(no arg info)
long(x) -> long integer
Convert a string or number to a long integer, if possible.
A floating point argument will be truncated towards zero.
map(no arg info)
map(function, sequence[, sequence, ...]) -> list
Return a list of the results of applying the function to the items of
the argument sequence(s).  If more than one sequence is given, the
function is called with an argument list consisting of the corresponding
item of each sequence, substituting None for missing values when not all
sequences have the same length.  If the function is None, return a list of
the items of the sequence (or a list of tuples if more than one sequence).
max(no arg info)
max(sequence) -> value
max(a, b, c, ...) -> value
With a single sequence argument, return its largest item.
With two or more arguments, return the largest argument.
min(no arg info)
min(sequence) -> value
min(a, b, c, ...) -> value
With a single sequence argument, return its smallest item.
With two or more arguments, return the smallest argument.
oct(no arg info)
oct(number) -> string
Return the octal representation of an integer or long integer.
open(no arg info)
open(filename[, mode[, buffering]]) -> file object
Open a file.  The mode can be 'r', 'w' or 'a' for reading (default),
writing or appending.  The file will be created if it doesn't exist
when opened for writing or appending; it will be truncated when
opened for writing.  Add a 'b' to the mode for binary files.
Add a '+' to the mode to allow simultaneous reading and writing.
If the buffering argument is given, 0 means unbuffered, 1 means line
buffered, and larger numbers specify the buffer size.
ord(no arg info)
ord(c) -> integer
Return the integer ordinal of a one character string.
pow(no arg info)
pow(x, y[, z]) -> number
With two arguments, equivalent to x**y.  With three arguments,
equivalent to (x**y) % z, but may be more efficient (e.g. for longs).
range(no arg info)
range([start,] stop[, step]) -> list of integers
Return a list containing an arithmetic progression of integers.
range(i, j) returns [i, i+1, i+2, ..., j-1]; start (!) defaults to 0.
When step is given, it specifies the increment (or decrement).
For example, range(4) returns [0, 1, 2, 3].  The end point is omitted!
These are exactly the valid indices for a list of 4 elements.
raw_input(no arg info)
raw_input([prompt]) -> string
Read a string from standard input.  The trailing newline is stripped.
If the user hits EOF (Unix: Ctl-D, Windows: Ctl-Z+Return), raise EOFError.
On Unix, GNU readline is used if enabled.  The prompt string, if given,
is printed without a trailing newline before reading.
reduce(no arg info)
reduce(function, sequence[, initial]) -> value
Apply a function of two arguments cumulatively to the items of a sequence,
from left to right, so as to reduce the sequence to a single value.
For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
((((1+2)+3)+4)+5).  If initial is present, it is placed before the items
of the sequence in the calculation, and serves as a default when the
sequence is empty.
reload(no arg info)
reload(module) -> module
Reload the module.  The module must have been successfully imported before.
repr(no arg info)
repr(object) -> string
Return the canonical string representation of the object.
For most object types, eval(repr(object)) == object.
round(no arg info)
round(number[, ndigits]) -> floating point number
Round a number to a given precision in decimal digits (default 0 digits).
This always returns a floating point number.  Precision may be negative.
setattr(no arg info)
setattr(object, name, value)
Set a named attribute on an object; setattr(x, 'y', v) is equivalent to
``x.y = v''.
slice(no arg info)
slice([start,] step[, stop]) -> slice object
Create a slice object.  This is used for slicing by the Numeric extensions.
str(no arg info)
str(object) -> string
Return a nice string representation of the object.
If the argument is a string, the return value is the same object.
tuple(no arg info)
tuple(sequence) -> list
Return a tuple whose items are the same as those of the argument sequence.
If the argument is a tuple, the return value is the same object.
type(no arg info)
type(object) -> type object
Return the type of the object.
vars(no arg info)
vars([object]) -> dictionary
Without arguments, equivalent to locals().
With an argument, equivalent to object.__dict__.
xrange(no arg info)
xrange([start,] stop[, step]) -> xrange object
Like range(), but instead of returning a list, returns an object that
generates the numbers in the range on demand.  This is slightly slower
than range() but more memory efficient.