OrderedDict Class Reference

Inheritance diagram for OrderedDict:

Collaboration diagram for OrderedDict:

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

Detailed Description

Definition at line 18 of file astdicts.py.

Constructor & Destructor Documentation

__init__()

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

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

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

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

__ne__	(		self,
			other
	)

Definition at line 246 of file astdicts.py.

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

__reduce__()

__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.__class__, Stringify.__class__, and OrderedDict.copy().

__repr__()

__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 OrderedDict.__class__, Stringify.__class__, 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__()

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

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

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()

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)
 

References OrderedDict.__class__, and Stringify.__class__.

Referenced by OrderedDict.__reduce__().

fromkeys()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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