OrderedDict Class Reference

Inheritance diagram for OrderedDict:

Collaboration diagram for OrderedDict:

Public Member Functions
def	__delitem__ (self, key, dict_delitem=dict.__delitem__)
def	__eq__ (self, other)
def	__init__ (self, *args, **kwds)
def	__iter__ (self)
def	__ne__ (self, other)
def	__reduce__ (self)
def	__repr__ (self, _repr_running={})
def	__reversed__ (self)
def	__setitem__ (self, key, value, dict_setitem=dict.__setitem__)
def	clear (self)
def	copy (self)
def	fromkeys (cls, iterable, value=None)
def	items (self)
def	iteritems (self)
def	iterkeys (self)
def	itervalues (self)
def	keys (self)
def	pop (self, key, default=__marker)
def	popitem (self, last=True)
def	setdefault (self, key, default=None)
def	update (*args, **kwds)
def	values (self)
def	viewitems (self)
def	viewkeys (self)
def	viewvalues (self)

Detailed Description

Definition at line 18 of file astdicts.py.

Constructor & Destructor Documentation

__init__()

def __init__	(		self,
		*	args,
		**	kwds
	)

Initialize an ordered dictionary.  Signature is the same as for
regular dictionaries, but keyword arguments are not recommended
because their insertion order is arbitrary.

Reimplemented in MultiOrderedDict, and Section.

Definition at line 30 of file astdicts.py.

    def __init__(self, *args, **kwds):
        '''Initialize an ordered dictionary.  Signature is the same as for
        regular dictionaries, but keyword arguments are not recommended
        because their insertion order is arbitrary.
 
        '''
        if len(args) > 1:
            raise TypeError('expected at most 1 arguments, got %d' % len(args))
        try:
            self.__root
        except AttributeError:
            self.__root = root = []                     # sentinel node
            root[:] = [root, root, None]
            self.__map = {}
        self.__update(*args, **kwds)
 

References OrderedDict.__map, OrderedDict.__root, OrderedDict.__update, and len().

Member Function Documentation

__delitem__()

def __delitem__	(		self,
			key,
			dict_delitem = dict.__delitem__
	)

Definition at line 56 of file astdicts.py.

    def __delitem__(self, key, dict_delitem=dict.__delitem__):
        'od.__delitem__(y) <==> del od[y]'
        # Deleting an existing item uses self.__map to find the link which is
        # then removed by updating the links in the predecessor and successor nodes.
        dict_delitem(self, key)
        link_prev, link_next, key = self.__map.pop(key)
        link_prev[1] = link_next
        link_next[0] = link_prev
 

References OrderedDict.__map, and OrderedDict.pop().

__eq__()

def __eq__	(		self,
			other
	)

od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive
while comparison to a regular mapping is order-insensitive.

Reimplemented in Section.

Definition at line 237 of file astdicts.py.

    def __eq__(self, other):
        '''od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive
        while comparison to a regular mapping is order-insensitive.
 
        '''
        if isinstance(other, OrderedDict):
            return len(self)==len(other) and self.items() == other.items()
        return dict.__eq__(self, other)
 

References OrderedDict.items(), featuregroup.items, playtones_def.items, playtones_state.items, ewscal_pvt.items, notify_option.items, resource_list.items, test_config.items, and len().

__iter__()

def __iter__

(

self

)

Definition at line 65 of file astdicts.py.

    def __iter__(self):
        'od.__iter__() <==> iter(od)'
        root = self.__root
        curr = root[1]
        while curr is not root:
            yield curr[2]
            curr = curr[1]
 

References OrderedDict.__root.

__ne__()

def __ne__	(		self,
			other
	)

Definition at line 246 of file astdicts.py.

    def __ne__(self, other):
        return not self == other
 

__reduce__()

def __reduce__

(

self

)

Definition at line 212 of file astdicts.py.

    def __reduce__(self):
        'Return state information for pickling'
        items = [[k, self[k]] for k in self]
        inst_dict = vars(self).copy()
        for k in vars(OrderedDict()):
            inst_dict.pop(k, None)
        if inst_dict:
            return (self.__class__, (items,), inst_dict)
        return self.__class__, (items,)
 

References OrderedDict.copy().

__repr__()

def __repr__	(		self,
			_repr_running = {}
	)

Definition at line 199 of file astdicts.py.

    def __repr__(self, _repr_running={}):
        'od.__repr__() <==> repr(od)'
        call_key = id(self), _get_ident()
        if call_key in _repr_running:
            return '...'
        _repr_running[call_key] = 1
        try:
            if not self:
                return '%s()' % (self.__class__.__name__,)
            return '%s(%r)' % (self.__class__.__name__, self.items())
        finally:
            del _repr_running[call_key]
 

References id, OrderedDict.items(), featuregroup.items, playtones_def.items, playtones_state.items, ewscal_pvt.items, notify_option.items, resource_list.items, and test_config.items.

__reversed__()

def __reversed__

(

self

)

Definition at line 73 of file astdicts.py.

    def __reversed__(self):
        'od.__reversed__() <==> reversed(od)'
        root = self.__root
        curr = root[0]
        while curr is not root:
            yield curr[2]
            curr = curr[0]
 

References OrderedDict.__root.

__setitem__()

def __setitem__	(		self,
			key,
			value,
			dict_setitem = dict.__setitem__
	)

Reimplemented in MultiOrderedDict.

Definition at line 46 of file astdicts.py.

    def __setitem__(self, key, value, dict_setitem=dict.__setitem__):
        'od.__setitem__(i, y) <==> od[i]=y'
        # Setting a new item creates a new link which goes at the end of the linked
        # list, and the inherited dictionary is updated with the new key/value pair.
        if key not in self:
            root = self.__root
            last = root[0]
            last[1] = root[0] = self.__map[key] = [last, root, key]
        dict_setitem(self, key, value)
 

References OrderedDict.__map, and OrderedDict.__root.

Referenced by MultiOrderedDict.insert().

clear()

def clear

(

self

)

Definition at line 81 of file astdicts.py.

    def clear(self):
        'od.clear() -> None.  Remove all items from od.'
        try:
            for node in self.__map.itervalues():
                del node[:]
            root = self.__root
            root[:] = [root, root, None]
            self.__map.clear()
        except AttributeError:
            pass
        dict.clear(self)
 

References OrderedDict.__map, OrderedDict.__root, OrderedDict.clear(), and OrderedDict.itervalues().

Referenced by OrderedDict.clear().

copy()

def copy

(

self

)

Reimplemented in MultiOrderedDict.

Definition at line 222 of file astdicts.py.

    def copy(self):
        'od.copy() -> a shallow copy of od'
        return self.__class__(self)
 

Referenced by OrderedDict.__reduce__().

fromkeys()

def fromkeys	(		cls,
			iterable,
			value = None
	)

OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S
and values equal to v (which defaults to None).

Definition at line 227 of file astdicts.py.

    def fromkeys(cls, iterable, value=None):
        '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S
        and values equal to v (which defaults to None).
 
        '''
        d = cls()
        for key in iterable:
            d[key] = value
        return d
 

items()

def items

(

self

)

Definition at line 126 of file astdicts.py.

    def items(self):
        'od.items() -> list of (key, value) pairs in od'
        return [(key, self[key]) for key in self]
 

Referenced by OrderedDict.__eq__(), and OrderedDict.__repr__().

iteritems()

def iteritems

(

self

)

Definition at line 139 of file astdicts.py.

    def iteritems(self):
        'od.iteritems -> an iterator over the (key, value) items in od'
        for k in self:
            yield (k, self[k])
 

Referenced by MultiOrderedDict.copy().

iterkeys()

def iterkeys

(

self

)

Definition at line 130 of file astdicts.py.

    def iterkeys(self):
        'od.iterkeys() -> an iterator over the keys in od'
        return iter(self)
 

itervalues()

def itervalues

(

self

)

Definition at line 134 of file astdicts.py.

    def itervalues(self):
        'od.itervalues -> an iterator over the values in od'
        for k in self:
            yield self[k]
 

Referenced by OrderedDict.clear().

keys()

def keys

(

self

)

Reimplemented in Section.

Definition at line 118 of file astdicts.py.

    def keys(self):
        'od.keys() -> list of keys in od'
        return list(self)
 

pop()

def pop	(		self,
			key,
			default = __marker
	)

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

Definition at line 179 of file astdicts.py.

    def pop(self, key, default=__marker):
        '''od.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.
 
        '''
        if key in self:
            result = self[key]
            del self[key]
            return result
        if default is self.__marker:
            raise KeyError(key)
        return default
 

References OrderedDict.__marker.

Referenced by OrderedDict.__delitem__().

popitem()

def popitem	(		self,
			last = True
	)

od.popitem() -> (k, v), return and remove a (key, value) pair.
Pairs are returned in LIFO order if last is true or FIFO order if false.

Definition at line 93 of file astdicts.py.

    def popitem(self, last=True):
        '''od.popitem() -> (k, v), return and remove a (key, value) pair.
        Pairs are returned in LIFO order if last is true or FIFO order if false.
 
        '''
        if not self:
            raise KeyError('dictionary is empty')
        root = self.__root
        if last:
            link = root[0]
            link_prev = link[0]
            link_prev[1] = root
            root[0] = link_prev
        else:
            link = root[1]
            link_next = link[1]
            root[1] = link_next
            link_next[0] = root
        key = link[2]
        del self.__map[key]
        value = dict.pop(self, key)
        return key, value
 

References OrderedDict.__map, and OrderedDict.__root.

setdefault()

def setdefault	(		self,
			key,
			default = None
	)

Definition at line 192 of file astdicts.py.

    def setdefault(self, key, default=None):
        'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od'
        if key in self:
            return self[key]
        self[key] = default
        return default
 

update()

def update	(	*	args,
		**	kwds
	)

od.update(E, **F) -> None.  Update od from dict/iterable E and F.

If E is a dict instance, does:           for k in E: od[k] = E[k]
If E has a .keys() method, does:         for k in E.keys(): od[k] = E[k]
Or if E is an iterable of items, does:   for k, v in E: od[k] = v
In either case, this is followed by:     for k, v in F.items(): od[k] = v

Definition at line 144 of file astdicts.py.

    def update(*args, **kwds):
        '''od.update(E, **F) -> None.  Update od from dict/iterable E and F.
 
        If E is a dict instance, does:           for k in E: od[k] = E[k]
        If E has a .keys() method, does:         for k in E.keys(): od[k] = E[k]
        Or if E is an iterable of items, does:   for k, v in E: od[k] = v
        In either case, this is followed by:     for k, v in F.items(): od[k] = v
 
        '''
        if len(args) > 2:
            raise TypeError('update() takes at most 2 positional '
                            'arguments (%d given)' % (len(args),))
        elif not args:
            raise TypeError('update() takes at least 1 argument (0 given)')
        self = args[0]
        # Make progressively weaker assumptions about "other"
        other = ()
        if len(args) == 2:
            other = args[1]
        if isinstance(other, dict):
            for key in other:
                self[key] = other[key]
        elif hasattr(other, 'keys'):
            for key in other.keys():
                self[key] = other[key]
        else:
            for key, value in other:
                self[key] = value
        for key, value in kwds.items():
            self[key] = value
 

References len().

values()

def values

(

self

)

Definition at line 122 of file astdicts.py.

    def values(self):
        'od.values() -> list of values in od'
        return [self[key] for key in self]
 

Referenced by AllowableList.to_wiki().

viewitems()

def viewitems

(

self

)

Definition at line 259 of file astdicts.py.

    def viewitems(self):
        "od.viewitems() -> a set-like object providing a view on od's items"
        return ItemsView(self)
 

viewkeys()

def viewkeys

(

self

)

Definition at line 251 of file astdicts.py.

    def viewkeys(self):
        "od.viewkeys() -> a set-like object providing a view on od's keys"
        return KeysView(self)
 

viewvalues()

def viewvalues

(

self

)

Definition at line 255 of file astdicts.py.

    def viewvalues(self):
        "od.viewvalues() -> an object providing a view on od's values"
        return ValuesView(self)
 

---

The documentation for this class was generated from the following file:

• astdicts.py