Python: built-in module __builtin_

__builtin__

index
(built-in)

Built-in functions, exceptions, and other objects. Noteworthy: None is the `nil' object; Ellipsis represents `...' in slices.

Classes



object

basestring

str
unicode

buffer
classmethod
complex
dict
enumerate
file
float
frozenset
int

bool

list
long
property
reversed
set
slice
staticmethod
super
tuple
type
xrange

class basestring(object)

    Type basestring cannot be instantiated; it is the base for str and unicode.

Data and other attributes defined here:

__new__ = <built-in method __new__ of type object at 0x812f120>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class bool(int)

    bool(x) -> bool Returns True when the argument x is true, False otherwise. The builtins True and False are the only two instances of the class bool. The class bool is a subclass of the class int, and cannot be subclassed.

Method resolution order:

bool

int

object

Methods defined here:

__and__(...)
x.__and__(y) <==> x&y

__or__(...)
x.__or__(y) <==> x|y

__rand__(...)
x.__rand__(y) <==> y&x

__repr__(...)
x.__repr__() <==> repr(x)

__ror__(...)
x.__ror__(y) <==> y|x

__rxor__(...)
x.__rxor__(y) <==> y^x

__str__(...)
x.__str__() <==> str(x)

__xor__(...)
x.__xor__(y) <==> x^y

Data and other attributes defined here:

__new__ = <built-in method __new__ of type object at 0x8124ac0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from int:

__abs__(...)
x.__abs__() <==> abs(x)

__add__(...)
x.__add__(y) <==> x+y

__cmp__(...)
x.__cmp__(y) <==> cmp(x,y)

__coerce__(...)
x.__coerce__(y) <==> coerce(x, y)

__div__(...)
x.__div__(y) <==> x/y

__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)

__float__(...)
x.__float__() <==> float(x)

__floordiv__(...)
x.__floordiv__(y) <==> x//y

__getattribute__(...)
x.__getattribute__('name') <==> x.name

__getnewargs__(...)

__hash__(...)
x.__hash__() <==> hash(x)

__hex__(...)
x.__hex__() <==> hex(x)

__index__(...)
x[y:z] <==> x[y.__index__():z.__index__()]

__int__(...)
x.__int__() <==> int(x)

__invert__(...)
x.__invert__() <==> ~x

__long__(...)
x.__long__() <==> long(x)

__lshift__(...)
x.__lshift__(y) <==> x<<y

__mod__(...)
x.__mod__(y) <==> x%y

__mul__(...)
x.__mul__(y) <==> x*y

__neg__(...)
x.__neg__() <==> -x

__nonzero__(...)
x.__nonzero__() <==> x != 0

__oct__(...)
x.__oct__() <==> oct(x)

__pos__(...)
x.__pos__() <==> +x

__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])

__radd__(...)
x.__radd__(y) <==> y+x

__rdiv__(...)
x.__rdiv__(y) <==> y/x

__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)

__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x

__rlshift__(...)
x.__rlshift__(y) <==> y<<x

__rmod__(...)
x.__rmod__(y) <==> y%x

__rmul__(...)
x.__rmul__(y) <==> y*x

__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])

__rrshift__(...)
x.__rrshift__(y) <==> y>>x

__rshift__(...)
x.__rshift__(y) <==> x>>y

__rsub__(...)
x.__rsub__(y) <==> y-x

__rtruediv__(...)
x.__rtruediv__(y) <==> y/x

__sub__(...)
x.__sub__(y) <==> x-y

__truediv__(...)
x.__truediv__(y) <==> x/y

class buffer(object)

    buffer(object [, offset[, size]]) Create 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).

Methods defined here:

__add__(...)
x.__add__(y) <==> x+y

__cmp__(...)
x.__cmp__(y) <==> cmp(x,y)

__delitem__(...)
x.__delitem__(y) <==> del x[y]

__delslice__(...)
x.__delslice__(i, j) <==> del x[i:j] Use of negative indices is not supported.

__getattribute__(...)
x.__getattribute__('name') <==> x.name

__getitem__(...)
x.__getitem__(y) <==> x[y]

__getslice__(...)
x.__getslice__(i, j) <==> x[i:j] Use of negative indices is not supported.

__hash__(...)
x.__hash__() <==> hash(x)

__len__(...)
x.__len__() <==> len(x)

__mul__(...)
x.__mul__(n) <==> x*n

__repr__(...)
x.__repr__() <==> repr(x)

__rmul__(...)
x.__rmul__(n) <==> n*x

__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y

__setslice__(...)
x.__setslice__(i, j, y) <==> x[i:j]=y Use  of negative indices is not supported.

__str__(...)
x.__str__() <==> str(x)

Data and other attributes defined here:

__new__ = <built-in method __new__ of type object at 0x81482a0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class classmethod(object)

    classmethod(function) -> method Convert a function to be a class method. 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 (e.g. C.f()) or on an instance (e.g. 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 the staticmethod builtin.

Methods defined here:

__get__(...)
descr.__get__(obj[, type]) -> value

__getattribute__(...)
x.__getattribute__('name') <==> x.name

__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature

Data and other attributes defined here:

__new__ = <built-in method __new__ of type object at 0x814a5c0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class complex(object)

    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.

Methods defined here:

__abs__(...)
x.__abs__() <==> abs(x)

__add__(...)
x.__add__(y) <==> x+y

__coerce__(...)
x.__coerce__(y) <==> coerce(x, y)

__div__(...)
x.__div__(y) <==> x/y

__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)

__eq__(...)
x.__eq__(y) <==> x==y

__float__(...)
x.__float__() <==> float(x)

__floordiv__(...)
x.__floordiv__(y) <==> x//y

__ge__(...)
x.__ge__(y) <==> x>=y

__getattribute__(...)
x.__getattribute__('name') <==> x.name

__getnewargs__(...)

__gt__(...)
x.__gt__(y) <==> x>y

__hash__(...)
x.__hash__() <==> hash(x)

__int__(...)
x.__int__() <==> int(x)

__le__(...)
x.__le__(y) <==> x<=y

__long__(...)
x.__long__() <==> long(x)

__lt__(...)
x.__lt__(y) <==> x<y

__mod__(...)
x.__mod__(y) <==> x%y

__mul__(...)
x.__mul__(y) <==> x*y

__ne__(...)
x.__ne__(y) <==> x!=y

__neg__(...)
x.__neg__() <==> -x

__nonzero__(...)
x.__nonzero__() <==> x != 0

__pos__(...)
x.__pos__() <==> +x

__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])

__radd__(...)
x.__radd__(y) <==> y+x

__rdiv__(...)
x.__rdiv__(y) <==> y/x

__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)

__repr__(...)
x.__repr__() <==> repr(x)

__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x

__rmod__(...)
x.__rmod__(y) <==> y%x

__rmul__(...)
x.__rmul__(y) <==> y*x

__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])

__rsub__(...)
x.__rsub__(y) <==> y-x

__rtruediv__(...)
x.__rtruediv__(y) <==> y/x

__str__(...)
x.__str__() <==> str(x)

__sub__(...)
x.__sub__(y) <==> x-y

__truediv__(...)
x.__truediv__(y) <==> x/y

conjugate(...)

Data descriptors defined here:

imag

the imaginary part of a complex number

real

the real part of a complex number

Data and other attributes defined here:

__new__ = <built-in method __new__ of type object at 0x8148b80>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class dict(object)

    dict() -> new empty dictionary. dict(mapping) -> new dictionary initialized from a mapping object's     (key, value) pairs. dict(seq) -> new dictionary initialized as if via:     d = {}     for k, v in seq:         d[k] = v dict(**kwargs) -> new dictionary initialized with the name=value pairs     in the keyword argument list.  For example:  dict(one=1, two=2)

Methods defined here:

__cmp__(...)
x.__cmp__(y) <==> cmp(x,y)

__contains__(...)
D.__contains__(k) -> True if D has a key k, else False

__delitem__(...)
x.__delitem__(y) <==> del x[y]

__eq__(...)
x.__eq__(y) <==> x==y

__ge__(...)
x.__ge__(y) <==> x>=y

__getattribute__(...)
x.__getattribute__('name') <==> x.name

__getitem__(...)
x.__getitem__(y) <==> x[y]

__gt__(...)
x.__gt__(y) <==> x>y

__hash__(...)
x.__hash__() <==> hash(x)

__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature

__iter__(...)
x.__iter__() <==> iter(x)

__le__(...)
x.__le__(y) <==> x<=y

__len__(...)
x.__len__() <==> len(x)

__lt__(...)
x.__lt__(y) <==> x<y

__ne__(...)
x.__ne__(y) <==> x!=y

__repr__(...)
x.__repr__() <==> repr(x)

__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y

clear(...)
D.clear() -> None.  Remove all items from D.

copy(...)
D.copy() -> a shallow copy of D

get(...)
D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.

has_key(...)
D.has_key(k) -> True if D has a key k, else False

items(...)
D.items() -> list of D's (key, value) pairs, as 2-tuples

iteritems(...)
D.iteritems() -> an iterator over the (key, value) items of D

iterkeys(...)
D.iterkeys() -> an iterator over the keys of D

itervalues(...)
D.itervalues() -> an iterator over the values of D

keys(...)
D.keys() -> list of D's keys

pop(...)
D.pop(k[,d]) -> v, remove specified key and return the corresponding value If key is not found, d is returned if given, otherwise KeyError is raised

popitem(...)
D.popitem() -> (k, v), remove and return some (key, value) pair as a 2-tuple; but raise KeyError if D is empty

setdefault(...)
D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D

update(...)
D.update(E, **F) -> None.  Update D from E and F: for k in E: D[k] = E[k] (if E has keys else: for (k, v) in E: D[k] = v) then: for k in F: D[k] = F[k]

values(...)
D.values() -> list of D's values

Data and other attributes defined here:

__new__ = <built-in method __new__ of type object at 0x812b5c0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

fromkeys = <built-in method fromkeys of type object at 0x812b5c0>
dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v. v defaults to None.

class enumerate(object)

    enumerate(iterable) -> iterator for index, value of iterable Return an enumerate object.  iterable must be an other object that supports iteration.  The enumerate object yields pairs containing a count (from zero) and a value yielded by the iterable argument.  enumerate is useful for obtaining an indexed list: (0, seq[0]), (1, seq[1]), (2, seq[2]), ...

Methods defined here:

__getattribute__(...)
x.__getattribute__('name') <==> x.name

__iter__(...)
x.__iter__() <==> iter(x)

next(...)
x.next() -> the next value, or raise StopIteration

Data and other attributes defined here:

__new__ = <built-in method __new__ of type object at 0x8149900>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class file(object)

    file(name[, 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. Add a 'U' to mode to open the file for input with universal newline support.  Any line ending in the input file will be seen as a '\n' in Python.  Also, a file so opened gains the attribute 'newlines'; the value for this attribute is one of None (no newline read yet), '\r', '\n', '\r\n' or a tuple containing all the newline types seen. 'U' cannot be combined with 'w' or '+' mode.

Methods defined here:

__delattr__(...)
x.__delattr__('name') <==> del x.name

__enter__(...)
__enter__() -> self.

__exit__(...)
__exit__(*excinfo) -> None.  Closes the file.

__getattribute__(...)
x.__getattribute__('name') <==> x.name

__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature

__iter__(...)
x.__iter__() <==> iter(x)

__repr__(...)
x.__repr__() <==> repr(x)

__setattr__(...)
x.__setattr__('name', value) <==> x.name = value

close(...)
close() -> None or (perhaps) an integer.  Close the file. Sets data attribute .closed to True.  A closed file cannot be used for further I/O operations.  close() may be called more than once without error.  Some kinds of file objects (for example, opened by popen()) may return an exit status upon closing.

fileno(...)
fileno() -> integer "file descriptor". This is needed for lower-level file interfaces, such os.read().

flush(...)
flush() -> None.  Flush the internal I/O buffer.

isatty(...)
isatty() -> true or false.  True if the file is connected to a tty device.

next(...)
x.next() -> the next value, or raise StopIteration

read(...)
read([size]) -> read at most size bytes, returned as a string. If the size argument is negative or omitted, read until EOF is reached. Notice that when in non-blocking mode, less data than what was requested may be returned, even if no size parameter was given.

readinto(...)
readinto() -> Undocumented.  Don't use this; it may go away.

readline(...)
readline([size]) -> next line from the file, as a string. Retain newline.  A non-negative size argument limits the maximum number of bytes to return (an incomplete line may be returned then). Return an empty string at EOF.

readlines(...)
readlines([size]) -> list of strings, each a line from the file. Call readline() repeatedly and return a list of the lines so read. The optional size argument, if given, is an approximate bound on the total number of bytes in the lines returned.

seek(...)
seek(offset[, whence]) -> None.  Move to new file position. Argument offset is a byte count.  Optional argument whence defaults to 0 (offset from start of file, offset should be >= 0); other values are 1 (move relative to current position, positive or negative), and 2 (move relative to end of file, usually negative, although many platforms allow seeking beyond the end of a file).  If the file is opened in text mode, only offsets returned by tell() are legal.  Use of other offsets causes undefined behavior. Note that not all file objects are seekable.

tell(...)
tell() -> current file position, an integer (may be a long integer).

truncate(...)
truncate([size]) -> None.  Truncate the file to at most size bytes. Size defaults to the current file position, as returned by tell().

write(...)
write(str) -> None.  Write string str to file. Note that due to buffering, flush() or close() may be needed before the file on disk reflects the data written.

writelines(...)
writelines(sequence_of_strings) -> None.  Write the strings to the file. Note that newlines are not added.  The sequence can be any iterable object producing strings. This is equivalent to calling write() for each string.

xreadlines(...)
xreadlines() -> returns self. For backward compatibility. File objects now include the performance optimizations previously implemented in the xreadlines module.

Data descriptors defined here:

closed

True if the file is closed

encoding

file encoding

mode

file mode ('r', 'U', 'w', 'a', possibly with 'b' or '+' added)

name

file name

newlines

end-of-line convention used in this file

softspace

flag indicating that a space needs to be printed; used by print

Data and other attributes defined here:

__new__ = <built-in method __new__ of type object at 0x8128ea0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class float(object)

    float(x) -> floating point number Convert a string or number to a floating point number, if possible.

Methods defined here:

__abs__(...)
x.__abs__() <==> abs(x)

__add__(...)
x.__add__(y) <==> x+y

__coerce__(...)
x.__coerce__(y) <==> coerce(x, y)

__div__(...)
x.__div__(y) <==> x/y

__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)

__eq__(...)
x.__eq__(y) <==> x==y

__float__(...)
x.__float__() <==> float(x)

__floordiv__(...)
x.__floordiv__(y) <==> x//y

__ge__(...)
x.__ge__(y) <==> x>=y

__getattribute__(...)
x.__getattribute__('name') <==> x.name

__getnewargs__(...)

__gt__(...)
x.__gt__(y) <==> x>y

__hash__(...)
x.__hash__() <==> hash(x)

__int__(...)
x.__int__() <==> int(x)

__le__(...)
x.__le__(y) <==> x<=y

__long__(...)
x.__long__() <==> long(x)

__lt__(...)
x.__lt__(y) <==> x<y

__mod__(...)
x.__mod__(y) <==> x%y

__mul__(...)
x.__mul__(y) <==> x*y

__ne__(...)
x.__ne__(y) <==> x!=y

__neg__(...)
x.__neg__() <==> -x

__nonzero__(...)
x.__nonzero__() <==> x != 0

__pos__(...)
x.__pos__() <==> +x

__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])

__radd__(...)
x.__radd__(y) <==> y+x

__rdiv__(...)
x.__rdiv__(y) <==> y/x

__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)

__repr__(...)
x.__repr__() <==> repr(x)

__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x

__rmod__(...)
x.__rmod__(y) <==> y%x

__rmul__(...)
x.__rmul__(y) <==> y*x

__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])

__rsub__(...)
x.__rsub__(y) <==> y-x

__rtruediv__(...)
x.__rtruediv__(y) <==> y/x

__str__(...)
x.__str__() <==> str(x)

__sub__(...)
x.__sub__(y) <==> x-y

__truediv__(...)
x.__truediv__(y) <==> x/y

Data and other attributes defined here:

__getformat__ = <built-in method __getformat__ of type object at 0x8129460>
float.__getformat__(typestr) -> string You probably don't want to use this function.  It exists mainly to be used in Python's test suite. typestr must be 'double' or 'float'.  This function returns whichever of 'unknown', 'IEEE, big-endian' or 'IEEE, little-endian' best describes the format of floating point numbers used by the C type named by typestr.

__new__ = <built-in method __new__ of type object at 0x8129460>
T.__new__(S, ...) -> a new object with type S, a subtype of T

__setformat__ = <built-in method __setformat__ of type object at 0x8129460>
float.__setformat__(typestr, fmt) -> None You probably don't want to use this function.  It exists mainly to be used in Python's test suite. typestr must be 'double' or 'float'.  fmt must be one of 'unknown', 'IEEE, big-endian' or 'IEEE, little-endian', and in addition can only be one of the latter two if it appears to match the underlying C reality. Overrides the automatic determination of C-level floating point type. This affects how floats are converted to and from binary strings.

class frozenset(object)

    frozenset(iterable) --> frozenset object Build an immutable unordered collection of unique elements.

Methods defined here:

__and__(...)
x.__and__(y) <==> x&y

__cmp__(...)
x.__cmp__(y) <==> cmp(x,y)

__contains__(...)
x.__contains__(y) <==> y in x.

__eq__(...)
x.__eq__(y) <==> x==y

__ge__(...)
x.__ge__(y) <==> x>=y

__getattribute__(...)
x.__getattribute__('name') <==> x.name

__gt__(...)
x.__gt__(y) <==> x>y

__hash__(...)
x.__hash__() <==> hash(x)

__iter__(...)
x.__iter__() <==> iter(x)

__le__(...)
x.__le__(y) <==> x<=y

__len__(...)
x.__len__() <==> len(x)

__lt__(...)
x.__lt__(y) <==> x<y

__ne__(...)
x.__ne__(y) <==> x!=y

__or__(...)
x.__or__(y) <==> x|y

__rand__(...)
x.__rand__(y) <==> y&x

__reduce__(...)
Return state information for pickling.

__repr__(...)
x.__repr__() <==> repr(x)

__ror__(...)
x.__ror__(y) <==> y|x

__rsub__(...)
x.__rsub__(y) <==> y-x

__rxor__(...)
x.__rxor__(y) <==> y^x

__sub__(...)
x.__sub__(y) <==> x-y

__xor__(...)
x.__xor__(y) <==> x^y

copy(...)
Return a shallow copy of a set.

difference(...)
Return the difference of two sets as a new set. (i.e. all elements that are in this set but not the other.)

intersection(...)
Return the intersection of two sets as a new set. (i.e. all elements that are in both sets.)

issubset(...)
Report whether another set contains this set.

issuperset(...)
Report whether this set contains another set.

symmetric_difference(...)
Return the symmetric difference of two sets as a new set. (i.e. all elements that are in exactly one of the sets.)

union(...)
Return the union of two sets as a new set. (i.e. all elements that are in either set.)

Data and other attributes defined here:

__new__ = <built-in method __new__ of type object at 0x812c9c0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class int(object)

    int(x[, base]) -> integer Convert a string or number to an integer, if possible.  A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!)  When converting a string, use the optional base.  It is an error to supply a base when converting a non-string. If the argument is outside the integer range a long object will be returned instead.

Methods defined here:

__abs__(...)
x.__abs__() <==> abs(x)

__add__(...)
x.__add__(y) <==> x+y

__and__(...)
x.__and__(y) <==> x&y

__cmp__(...)
x.__cmp__(y) <==> cmp(x,y)

__coerce__(...)
x.__coerce__(y) <==> coerce(x, y)

__div__(...)
x.__div__(y) <==> x/y

__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)

__float__(...)
x.__float__() <==> float(x)

__floordiv__(...)
x.__floordiv__(y) <==> x//y

__getattribute__(...)
x.__getattribute__('name') <==> x.name

__getnewargs__(...)

__hash__(...)
x.__hash__() <==> hash(x)

__hex__(...)
x.__hex__() <==> hex(x)

__index__(...)
x[y:z] <==> x[y.__index__():z.__index__()]

__int__(...)
x.__int__() <==> int(x)

__invert__(...)
x.__invert__() <==> ~x

__long__(...)
x.__long__() <==> long(x)

__lshift__(...)
x.__lshift__(y) <==> x<<y

__mod__(...)
x.__mod__(y) <==> x%y

__mul__(...)
x.__mul__(y) <==> x*y

__neg__(...)
x.__neg__() <==> -x

__nonzero__(...)
x.__nonzero__() <==> x != 0

__oct__(...)
x.__oct__() <==> oct(x)

__or__(...)
x.__or__(y) <==> x|y

__pos__(...)
x.__pos__() <==> +x

__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])

__radd__(...)
x.__radd__(y) <==> y+x

__rand__(...)
x.__rand__(y) <==> y&x

__rdiv__(...)
x.__rdiv__(y) <==> y/x

__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)

__repr__(...)
x.__repr__() <==> repr(x)

__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x

__rlshift__(...)
x.__rlshift__(y) <==> y<<x

__rmod__(...)
x.__rmod__(y) <==> y%x

__rmul__(...)
x.__rmul__(y) <==> y*x

__ror__(...)
x.__ror__(y) <==> y|x

__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])

__rrshift__(...)
x.__rrshift__(y) <==> y>>x

__rshift__(...)
x.__rshift__(y) <==> x>>y

__rsub__(...)
x.__rsub__(y) <==> y-x

__rtruediv__(...)
x.__rtruediv__(y) <==> y/x

__rxor__(...)
x.__rxor__(y) <==> y^x

__str__(...)
x.__str__() <==> str(x)

__sub__(...)
x.__sub__(y) <==> x-y

__truediv__(...)
x.__truediv__(y) <==> x/y

__xor__(...)
x.__xor__(y) <==> x^y

Data and other attributes defined here:

__new__ = <built-in method __new__ of type object at 0x81297c0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class list(object)

    list() -> new list list(sequence) -> new list initialized from sequence's items

Methods defined here:

__add__(...)
x.__add__(y) <==> x+y

__contains__(...)
x.__contains__(y) <==> y in x

__delitem__(...)
x.__delitem__(y) <==> del x[y]

__delslice__(...)
x.__delslice__(i, j) <==> del x[i:j] Use of negative indices is not supported.

__eq__(...)
x.__eq__(y) <==> x==y

__ge__(...)
x.__ge__(y) <==> x>=y

__getattribute__(...)
x.__getattribute__('name') <==> x.name

__getitem__(...)
x.__getitem__(y) <==> x[y]

__getslice__(...)
x.__getslice__(i, j) <==> x[i:j] Use of negative indices is not supported.

__gt__(...)
x.__gt__(y) <==> x>y

__hash__(...)
x.__hash__() <==> hash(x)

__iadd__(...)
x.__iadd__(y) <==> x+=y

__imul__(...)
x.__imul__(y) <==> x*=y

__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature

__iter__(...)
x.__iter__() <==> iter(x)

__le__(...)
x.__le__(y) <==> x<=y

__len__(...)
x.__len__() <==> len(x)

__lt__(...)
x.__lt__(y) <==> x<y

__mul__(...)
x.__mul__(n) <==> x*n

__ne__(...)
x.__ne__(y) <==> x!=y

__repr__(...)
x.__repr__() <==> repr(x)

__reversed__(...)
L.__reversed__() -- return a reverse iterator over the list

__rmul__(...)
x.__rmul__(n) <==> n*x

__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y

__setslice__(...)
x.__setslice__(i, j, y) <==> x[i:j]=y Use  of negative indices is not supported.

append(...)
L.append(object) -- append object to end

count(...)
L.count(value) -> integer -- return number of occurrences of value

extend(...)
L.extend(iterable) -- extend list by appending elements from the iterable

index(...)
L.index(value, [start, [stop]]) -> integer -- return first index of value

insert(...)
L.insert(index, object) -- insert object before index

pop(...)
L.pop([index]) -> item -- remove and return item at index (default last)

remove(...)
L.remove(value) -- remove first occurrence of value

reverse(...)
L.reverse() -- reverse *IN PLACE*

sort(...)
L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*; cmp(x, y) -> -1, 0, 1

Data and other attributes defined here:

__new__ = <built-in method __new__ of type object at 0x812a140>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class long(object)

    long(x[, base]) -> integer Convert a string or number to a long integer, if possible.  A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!)  When converting a string, use the optional base.  It is an error to supply a base when converting a non-string.

Methods defined here:

__abs__(...)
x.__abs__() <==> abs(x)

__add__(...)
x.__add__(y) <==> x+y

__and__(...)
x.__and__(y) <==> x&y

__cmp__(...)
x.__cmp__(y) <==> cmp(x,y)

__coerce__(...)
x.__coerce__(y) <==> coerce(x, y)

__div__(...)
x.__div__(y) <==> x/y

__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)

__float__(...)
x.__float__() <==> float(x)

__floordiv__(...)
x.__floordiv__(y) <==> x//y

__getattribute__(...)
x.__getattribute__('name') <==> x.name

__getnewargs__(...)

__hash__(...)
x.__hash__() <==> hash(x)

__hex__(...)
x.__hex__() <==> hex(x)

__index__(...)
x[y:z] <==> x[y.__index__():z.__index__()]

__int__(...)
x.__int__() <==> int(x)

__invert__(...)
x.__invert__() <==> ~x

__long__(...)
x.__long__() <==> long(x)

__lshift__(...)
x.__lshift__(y) <==> x<<y

__mod__(...)
x.__mod__(y) <==> x%y

__mul__(...)
x.__mul__(y) <==> x*y

__neg__(...)
x.__neg__() <==> -x

__nonzero__(...)
x.__nonzero__() <==> x != 0

__oct__(...)
x.__oct__() <==> oct(x)

__or__(...)
x.__or__(y) <==> x|y

__pos__(...)
x.__pos__() <==> +x

__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])

__radd__(...)
x.__radd__(y) <==> y+x

__rand__(...)
x.__rand__(y) <==> y&x

__rdiv__(...)
x.__rdiv__(y) <==> y/x

__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)

__repr__(...)
x.__repr__() <==> repr(x)

__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x

__rlshift__(...)
x.__rlshift__(y) <==> y<<x

__rmod__(...)
x.__rmod__(y) <==> y%x

__rmul__(...)
x.__rmul__(y) <==> y*x

__ror__(...)
x.__ror__(y) <==> y|x

__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])

__rrshift__(...)
x.__rrshift__(y) <==> y>>x

__rshift__(...)
x.__rshift__(y) <==> x>>y

__rsub__(...)
x.__rsub__(y) <==> y-x

__rtruediv__(...)
x.__rtruediv__(y) <==> y/x

__rxor__(...)
x.__rxor__(y) <==> y^x

__str__(...)
x.__str__() <==> str(x)

__sub__(...)
x.__sub__(y) <==> x-y

__truediv__(...)
x.__truediv__(y) <==> x/y

__xor__(...)
x.__xor__(y) <==> x^y

Data and other attributes defined here:

__new__ = <built-in method __new__ of type object at 0x812ace0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class object

    The most base type

class property(object)

    property(fget=None, fset=None, fdel=None, doc=None) -> property attribute fget is a function to be used for getting an attribute value, and 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.")

Methods defined here:

__delete__(...)
descr.__delete__(obj)

__get__(...)
descr.__get__(obj[, type]) -> value

__getattribute__(...)
x.__getattribute__('name') <==> x.name

__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature

__set__(...)
descr.__set__(obj, value)

Data descriptors defined here:

fdel

fget

fset

Data and other attributes defined here:

__new__ = <built-in method __new__ of type object at 0x81496c0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class reversed(object)

    reversed(sequence) -> reverse iterator over values of the sequence Return a reverse iterator

Methods defined here:

__getattribute__(...)
x.__getattribute__('name') <==> x.name

__iter__(...)
x.__iter__() <==> iter(x)

__length_hint__(...)
Private method returning an estimate of len(list(it)).

next(...)
x.next() -> the next value, or raise StopIteration

Data and other attributes defined here:

__new__ = <built-in method __new__ of type object at 0x8149a80>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class set(object)

    set(iterable) --> set object Build an unordered collection of unique elements.

Methods defined here:

__and__(...)
x.__and__(y) <==> x&y

__cmp__(...)
x.__cmp__(y) <==> cmp(x,y)

__contains__(...)
x.__contains__(y) <==> y in x.

__eq__(...)
x.__eq__(y) <==> x==y

__ge__(...)
x.__ge__(y) <==> x>=y

__getattribute__(...)
x.__getattribute__('name') <==> x.name

__gt__(...)
x.__gt__(y) <==> x>y

__hash__(...)
x.__hash__() <==> hash(x)

__iand__(...)
x.__iand__(y) <==> x&y

__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature

__ior__(...)
x.__ior__(y) <==> x|y

__isub__(...)
x.__isub__(y) <==> x-y

__iter__(...)
x.__iter__() <==> iter(x)

__ixor__(...)
x.__ixor__(y) <==> x^y

__le__(...)
x.__le__(y) <==> x<=y

__len__(...)
x.__len__() <==> len(x)

__lt__(...)
x.__lt__(y) <==> x<y

__ne__(...)
x.__ne__(y) <==> x!=y

__or__(...)
x.__or__(y) <==> x|y

__rand__(...)
x.__rand__(y) <==> y&x

__reduce__(...)
Return state information for pickling.

__repr__(...)
x.__repr__() <==> repr(x)

__ror__(...)
x.__ror__(y) <==> y|x

__rsub__(...)
x.__rsub__(y) <==> y-x

__rxor__(...)
x.__rxor__(y) <==> y^x

__sub__(...)
x.__sub__(y) <==> x-y

__xor__(...)
x.__xor__(y) <==> x^y

add(...)
Add an element to a set. This has no effect if the element is already present.

clear(...)
Remove all elements from this set.

copy(...)
Return a shallow copy of a set.

difference(...)
Return the difference of two sets as a new set. (i.e. all elements that are in this set but not the other.)

difference_update(...)
Remove all elements of another set from this set.

discard(...)
Remove an element from a set if it is a member. If the element is not a member, do nothing.

intersection(...)
Return the intersection of two sets as a new set. (i.e. all elements that are in both sets.)

intersection_update(...)
Update a set with the intersection of itself and another.

issubset(...)
Report whether another set contains this set.

issuperset(...)
Report whether this set contains another set.

pop(...)
Remove and return an arbitrary set element.

remove(...)
Remove an element from a set; it must be a member. If the element is not a member, raise a KeyError.

symmetric_difference(...)
Return the symmetric difference of two sets as a new set. (i.e. all elements that are in exactly one of the sets.)

symmetric_difference_update(...)
Update a set with the symmetric difference of itself and another.

union(...)
Return the union of two sets as a new set. (i.e. all elements that are in either set.)

update(...)
Update a set with the union of itself and another.

Data and other attributes defined here:

__new__ = <built-in method __new__ of type object at 0x812c740>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class slice(object)

    slice([start,] stop[, step]) Create a slice object.  This is used for extended slicing (e.g. a[0:10:2]).

Methods defined here:

__cmp__(...)
x.__cmp__(y) <==> cmp(x,y)

__getattribute__(...)
x.__getattribute__('name') <==> x.name

__hash__(...)
x.__hash__() <==> hash(x)

__repr__(...)
x.__repr__() <==> repr(x)

indices(...)
S.indices(len) -> (start, stop, stride) Assuming a sequence of length len, calculate the start and stop indices, and the stride length of the extended slice described by S. Out of bounds indices are clipped in a manner consistent with the handling of normal slices.

Data descriptors defined here:

start

step

stop

Data and other attributes defined here:

__new__ = <built-in method __new__ of type object at 0x812cd80>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class staticmethod(object)

    staticmethod(function) -> method Convert a function to be a static method. 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 (e.g. C.f()) or on an instance (e.g. 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 the classmethod builtin.

Methods defined here:

__get__(...)
descr.__get__(obj[, type]) -> value

__getattribute__(...)
x.__getattribute__('name') <==> x.name

__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature

Data and other attributes defined here:

__new__ = <built-in method __new__ of type object at 0x814a8a0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class str(basestring)

    str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.

Method resolution order:

str

basestring

object

Methods defined here:

__add__(...)
x.__add__(y) <==> x+y

__contains__(...)
x.__contains__(y) <==> y in x

__eq__(...)
x.__eq__(y) <==> x==y

__ge__(...)
x.__ge__(y) <==> x>=y

__getattribute__(...)
x.__getattribute__('name') <==> x.name

__getitem__(...)
x.__getitem__(y) <==> x[y]

__getnewargs__(...)

__getslice__(...)
x.__getslice__(i, j) <==> x[i:j] Use of negative indices is not supported.

__gt__(...)
x.__gt__(y) <==> x>y

__hash__(...)
x.__hash__() <==> hash(x)

__le__(...)
x.__le__(y) <==> x<=y

__len__(...)
x.__len__() <==> len(x)

__lt__(...)
x.__lt__(y) <==> x<y

__mod__(...)
x.__mod__(y) <==> x%y

__mul__(...)
x.__mul__(n) <==> x*n

__ne__(...)
x.__ne__(y) <==> x!=y

__repr__(...)
x.__repr__() <==> repr(x)

__rmod__(...)
x.__rmod__(y) <==> y%x

__rmul__(...)
x.__rmul__(n) <==> n*x

__str__(...)
x.__str__() <==> str(x)

capitalize(...)
S.capitalize() -> string Return a copy of the string S with only its first character capitalized.

center(...)
S.center(width[, fillchar]) -> string Return S centered in a string of length width. Padding is done using the specified fill character (default is a space)

count(...)
S.count(sub[, start[, end]]) -> int Return the number of non-overlapping occurrences of substring sub in string S[start:end].  Optional arguments start and end are interpreted as in slice notation.

decode(...)
S.decode([encoding[,errors]]) -> object Decodes S using the codec registered for encoding. encoding defaults to the default encoding. errors may be given to set a different error handling scheme. Default is 'strict' meaning that encoding errors raise a UnicodeDecodeError. Other possible values are 'ignore' and 'replace' as well as any other name registerd with codecs.register_error that is able to handle UnicodeDecodeErrors.

encode(...)
S.encode([encoding[,errors]]) -> object Encodes S using the codec registered for encoding. encoding defaults to the default encoding. errors may be given to set a different error handling scheme. Default is 'strict' meaning that encoding errors raise a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and 'xmlcharrefreplace' as well as any other name registered with codecs.register_error that is able to handle UnicodeEncodeErrors.

endswith(...)
S.endswith(suffix[, start[, end]]) -> bool Return True if S ends with the specified suffix, False otherwise. With optional start, test S beginning at that position. With optional end, stop comparing S at that position. suffix can also be a tuple of strings to try.

expandtabs(...)
S.expandtabs([tabsize]) -> string Return a copy of S where all tab characters are expanded using spaces. If tabsize is not given, a tab size of 8 characters is assumed.

find(...)
S.find(sub [,start [,end]]) -> int Return the lowest index in S where substring sub is found, such that sub is contained within s[start,end].  Optional arguments start and end are interpreted as in slice notation. Return -1 on failure.

index(...)
S.index(sub [,start [,end]]) -> int Like S.find() but raise ValueError when the substring is not found.

isalnum(...)
S.isalnum() -> bool Return True if all characters in S are alphanumeric and there is at least one character in S, False otherwise.

isalpha(...)
S.isalpha() -> bool Return True if all characters in S are alphabetic and there is at least one character in S, False otherwise.

isdigit(...)
S.isdigit() -> bool Return True if all characters in S are digits and there is at least one character in S, False otherwise.

islower(...)
S.islower() -> bool Return True if all cased characters in S are lowercase and there is at least one cased character in S, False otherwise.

isspace(...)
S.isspace() -> bool Return True if all characters in S are whitespace and there is at least one character in S, False otherwise.

istitle(...)
S.istitle() -> bool Return True if S is a titlecased string and there is at least one character in S, i.e. uppercase characters may only follow uncased characters and lowercase characters only cased ones. Return False otherwise.

isupper(...)
S.isupper() -> bool Return True if all cased characters in S are uppercase and there is at least&nbs