>>> help(tuple)

Help on class tuple in module __builtin__:

class tuple(object)

│ tuple() -> empty tuple

│ tuple(iterable) -> tuple initialized from iterable‘s items

│

│ If the argument is a tuple, the return value is the same 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)

│

│ __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)

│

│ __rmul__(...)

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

│

│ __sizeof__(...)

│ T.__sizeof__() -- size of T in memory, in bytes

│

│ count(...)

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

│

│ index(...)

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

│ Raises ValueError if the value is not present.

│

│ ----------------------------------------------------------------------

│ Data and other attributes defined here:

│

│ __new__ = <built-in method __new__ of type object>

│ T.__new__(S, ...) -> a new object with type S, a subtype of T

>>> help(list)

Help on class list in module __builtin__:

class list(object)

│ list() -> new empty list

│ list(iterable) -> new list initialized from iterable‘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

│

│ __iadd__(...)

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

│

│ __imul__(...)

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

│

│ __init__(...)

│ x.__init__(...) initializes x; see help(type(x)) 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.

│

│ __sizeof__(...)

│ L.__sizeof__() -- size of L in memory, in bytes

│

│ 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.

│ Raises ValueError if the value is not present.

│

│ insert(...)

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

│

│ pop(...)

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

│ Raises IndexError if list is empty or index is out of range.

│

│ remove(...)

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

│ Raises ValueError if the value is not present.

│

│ 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:

│

│ __hash__ = None

│

│ __new__ = <built-in method __new__ of type object>

│ T.__new__(S, ...) -> a new object with type S, a subtype of T

>>> help(dict)

Help on class dict in module __builtin__:

class dict(object)

│ dict() -> new empty dictionary

│ dict(mapping) -> new dictionary initialized from a mapping object‘s

│ (key, value) pairs

│ dict(iterable) -> new dictionary initialized as if via:

│ d = {}

│ for k, v in iterable:

│ 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

│

│ __init__(...)

│ x.__init__(...) initializes x; see help(type(x)) 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

│

│ __sizeof__(...)

│ D.__sizeof__() -> size of D in memory, in bytes

│

│ clear(...)

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

│

│ copy(...)

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

│

│ fromkeys(...)

│ dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.

│ v defaults to None.

│

│ 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 dict/iterable E and F.

│ If E present and has a .keys() method, does: for k in E: D[k] = E[k]

│ If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v

│ In either case, this is followed by: for k in F: D[k] = F[k]

│

│ values(...)

│ D.values() -> list of D‘s values

│

│ viewitems(...)

│ D.viewitems() -> a set-like object providing a view on D‘s items

│

│ viewkeys(...)

│ D.viewkeys() -> a set-like object providing a view on D‘s keys

│

│ viewvalues(...)

│ D.viewvalues() -> an object providing a view on D‘s values

│

│ ----------------------------------------------------------------------

│ Data and other attributes defined here:

│

│ __hash__ = None

│

│ __new__ = <built-in method __new__ of type object>

│ T.__new__(S, ...) -> a new object with type S, a subtype of T