collections
index
/usr/local/lib/python2.5/lib-dynload/collections.so
Module Docs

High performance data structures.
deque:        ordered collection accessible from endpoints only
defaultdict:  dict subclass with a default value factory

 
Classes
       
__builtin__.dict(__builtin__.object)
defaultdict
__builtin__.object
deque

 
class defaultdict(__builtin__.dict)
    defaultdict(default_factory) --> dict with default factory
 
The default factory is called without arguments to produce
a new value when a key is not present, in __getitem__ only.
defaultdict compares equal to a dict with the same items.
 
 
Method resolution order:
defaultdict
__builtin__.dict
__builtin__.object

Methods defined here:
__copy__(...)
D.copy() -> a shallow copy of D.
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature
__missing__(...)
__missing__(key) # Called by __getitem__ for missing key; pseudo-code:
if self.default_factory is None: raise KeyError((key,))
self[key] = value = default_factory()
return value
__reduce__(...)
Return state information for pickling.
__repr__(...)
x.__repr__() <==> repr(x)
copy(...)
D.copy() -> a shallow copy of D.

Data descriptors defined here:
default_factory
Factory for default value called by __missing__().

Methods inherited from __builtin__.dict:
__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
__getitem__(...)
x.__getitem__(y) <==> x[y]
__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
__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y
clear(...)
D.clear() -> None.  Remove all items from 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 inherited from __builtin__.dict:
__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 0x115ae0>
dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
v defaults to None.

 
class deque(__builtin__.object)
    deque(iterable) --> deque object
 
Build an ordered collection accessible from endpoints only.
 
  Methods defined here:
__copy__(...)
Return a shallow copy of a deque.
__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
__reduce__(...)
Return state information for pickling.
__repr__(...)
x.__repr__() <==> repr(x)
__reversed__(...)
D.__reversed__() -- return a reverse iterator over the deque
__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y
append(...)
Add an element to the right side of the deque.
appendleft(...)
Add an element to the left side of the deque.
clear(...)
Remove all elements from the deque.
extend(...)
Extend the right side of the deque with elements from the iterable
extendleft(...)
Extend the left side of the deque with elements from the iterable
pop(...)
Remove and return the rightmost element.
popleft(...)
Remove and return the leftmost element.
remove(...)
D.remove(value) -- remove first occurrence of value.
rotate(...)
Rotate the deque n steps to the right (default n=1).  If n is negative, rotates left.

Data and other attributes defined here:
__new__ = <built-in method __new__ of type object at 0x1158a0>
T.__new__(S, ...) -> a new object with type S, a subtype of T