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

Definition at line 30 of file odict.py.

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

 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)

Member Function Documentation

__delitem__()

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

Definition at line 56 of file odict.py.

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

 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

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

Definition at line 237 of file odict.py.

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

 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)

__iter__()

def __iter__

(

self

)

Definition at line 65 of file odict.py.

References OrderedDict.__root.

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

__ne__()

def __ne__	(		self,
			other
	)

Definition at line 246 of file odict.py.

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

__reduce__()

def __reduce__

(

self

)

Definition at line 212 of file odict.py.

References OrderedDict.copy().

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

__repr__()

def __repr__	(		self,
			_repr_running = {}
	)

Definition at line 199 of file odict.py.

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

 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]

__reversed__()

def __reversed__

(

self

)

Definition at line 73 of file odict.py.

References OrderedDict.__root.

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

__setitem__()

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

Definition at line 46 of file odict.py.

References OrderedDict.__map, and OrderedDict.__root.

 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)

clear()

def clear

(

self

)

Definition at line 81 of file odict.py.

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

 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)

copy()

def copy

(

self

)

Definition at line 222 of file odict.py.

Referenced by OrderedDict.__reduce__().

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

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 odict.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 odict.py.

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

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

iteritems()

def iteritems

(

self

)

Definition at line 139 of file odict.py.

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

iterkeys()

def iterkeys

(

self

)

Definition at line 130 of file odict.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 odict.py.

Referenced by OrderedDict.clear().

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

keys()

def keys

(

self

)

Definition at line 118 of file odict.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 odict.py.

References OrderedDict.__marker.

Referenced by OrderedDict.__delitem__().

 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

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 odict.py.

References OrderedDict.__map, and OrderedDict.__root.

 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

setdefault()

def setdefault	(		self,
			key,
			default = None
	)

Definition at line 192 of file odict.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 odict.py.

References len().

 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

values()

def values

(

self

)

Definition at line 122 of file odict.py.

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

viewitems()

def viewitems

(

self

)

Definition at line 259 of file odict.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 odict.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 odict.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:

• odict.py

---

Generated on Sun Aug 8 2021 19:47:31 for Asterisk - The Open Source Telephony Project by   1.8.13