From 87c730ad1856bf7ee964b26e0cc3987aa9198a9b Mon Sep 17 00:00:00 2001 From: Mark Pilgrim Date: Sun, 19 Jul 2009 14:12:33 -0400 Subject: [PATCH] not gonna use this --- examples/ordereddict.py | 157 ---------------------------------------- 1 file changed, 157 deletions(-) delete mode 100644 examples/ordereddict.py diff --git a/examples/ordereddict.py b/examples/ordereddict.py deleted file mode 100644 index 552c5e8..0000000 --- a/examples/ordereddict.py +++ /dev/null @@ -1,157 +0,0 @@ -# -# OrderedDict will be part of the collections module in Python 3.1. -# This is a standalone version for demonstration purposes only. -# If you're using Python 3.0, you should upgrade to Python 3.1, then -# >>> from collections import OrderedDict -# instead of using this version. -# -# Provenance: -# - PEP 372: OrderedDict http://www.python.org/dev/peps/pep-0372/ -# - Python bug 5397: implement PEP 372 http://bugs.python.org/issue5397 -# - Bug 5397 attachment: http://bugs.python.org/file13231/od7.diff -# - -from collections import MutableMapping - -class OrderedDict(dict, MutableMapping): - 'Dictionary that remembers insertion order' - # An inherited dict maps keys to values. - # The inherited dict provides __getitem__, __len__, __contains__, and get. - # The remaining methods are order-aware. - # Big-O running times for all methods are the same as for regular dictionaries. - - # The internal self.__map dictionary maps keys to links in a doubly linked list. - # The circular doubly linked list starts and ends with a sentinel element. - # The sentinel element never gets deleted (this simplifies the algorithm). - # The prev/next links are weakref proxies (to prevent circular references). - # Individual links are kept alive by the hard reference in self.__map. - # Those hard references disappear when a key is deleted from an OrderedDict. - - 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 {0}'.format(len(args))) - try: - self.__root - except AttributeError: - self.__root = root = _Link() # sentinel node for the doubly linked list - root.prev = root.next = root - self.__map = {} - self.update(*args, **kwds) - - def clear(self): - 'od.clear() -> None. Remove all items from od.' - root = self.__root - root.prev = root.next = root - self.__map.clear() - dict.clear(self) - - def __setitem__(self, key, value): - '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: - self.__map[key] = link = _Link() - root = self.__root - last = root.prev - link.prev, link.next, link.key = last, root, key - last.next = root.prev = _proxy(link) - dict.__setitem__(self, key, value) - - def __delitem__(self, key): - '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 = self.__map.pop(key) - link.prev.next = link.next - link.next.prev = link.prev - - def __iter__(self): - 'od.__iter__() <==> iter(od)' - # Traverse the linked list in order. - root = self.__root - curr = root.next - while curr is not root: - yield curr.key - curr = curr.next - - def __reversed__(self): - 'od.__reversed__() <==> reversed(od)' - # Traverse the linked list in reverse order. - root = self.__root - curr = root.prev - while curr is not root: - yield curr.key - curr = curr.prev - - def __reduce__(self): - 'Return state information for pickling' - items = [[k, self[k]] for k in self] - tmp = self.__map, self.__root - del self.__map, self.__root - inst_dict = vars(self).copy() - self.__map, self.__root = tmp - if inst_dict: - return (self.__class__, (items,), inst_dict) - return self.__class__, (items,) - - setdefault = MutableMapping.setdefault - update = MutableMapping.update - pop = MutableMapping.pop - keys = MutableMapping.keys - values = MutableMapping.values - items = MutableMapping.items - - 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') - key = next(reversed(self) if last else iter(self)) - value = self.pop(key) - return key, value - - def __repr__(self): - 'od.__repr__() <==> repr(od)' - if not self: - return '{0}()'.format(self.__class__.__name__) - return '{0}({1})'.format(self.__class__.__name__, repr(list(self.items()))) - - def copy(self): - 'od.copy() -> a shallow copy of od' - return self.__class__(self) - - @classmethod - 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 - - 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 \ - all(p==q for p, q in zip(self.items(), other.items())) - return dict.__eq__(self, other) - - def __ne__(self, other): - '''od.__ne__(y) <==> od!=y. Comparison to another OD is order-sensitive - while comparison to a regular mapping is order-insensitive. - - ''' - return not self == other