Advanced Classes

❝ FIXME ❞
— FIXME

Diving In

FIXME

Ordered Dictionary: Not An Oxymoron

[FIXME here's why ordered dicts are useful: http://www.gossamer-threads.com/lists/python/dev/656556 ]

[download ordereddict.py]

import collections
import itertools
 
class OrderedDict(dict, collections.MutableMapping):

    def __init__(self, *args, **kwds):
        if len(args) > 1:
            raise TypeError('expected at most 1 arguments')
        if not hasattr(self, '_keys'):
            self._keys = []
        self.update(*args, **kwds)

    def clear(self):
        del self._keys[:]
        dict.clear(self)

    def __setitem__(self, key, value):
        if key not in self:
            self._keys.append(key)
        dict.__setitem__(self, key, value)

    def __delitem__(self, key):
        dict.__delitem__(self, key)
        self._keys.remove(key)

    def __iter__(self):
        return iter(self._keys)

    def __reversed__(self):
        return reversed(self._keys)

    def popitem(self):
        if not self:
            raise KeyError('dictionary is empty')
        key = self._keys.pop()
        value = dict.pop(self, key)
        return key, value

    def __reduce__(self):
        items = [[k, self[k]] for k in self]
        inst_dict = vars(self).copy()
        inst_dict.pop('_keys', None)
        return (self.__class__, (items,), inst_dict)

    setdefault = MutableMapping.setdefault
    update = MutableMapping.update
    pop = MutableMapping.pop
    keys = MutableMapping.keys
    values = MutableMapping.values
    items = MutableMapping.items

    def __repr__(self):
        if not self:
            return '{0}()'.format(self.__class__.__name__,)
        return '{0}({1})'.format(self.__class__.__name__, repr(list(self.items())))

    def copy(self):
        return self.__class__(self)

    @classmethod
    def fromkeys(cls, iterable, value=None):
        d = cls()
        for key in iterable:
            d[key] = value
        return d

    def __eq__(self, other):
        if isinstance(other, OrderedDict):
            return all(p==q for p, q in itertools.zip_longest(self.items(), other.items()))
        return dict.__eq__(self, other)

⁂

Attributes of a Class Object

FIXME

>>> import ordereddict
>>> od = ordereddict.OrderedDict()
>>> klass = od.__class__
>>> type(klass)
<class 'abc.ABCMeta'>
>>> klass.__name__
'OrderedDict'

>>> klass.__module__
'ordereddict'
>>> klass.__bases__
(<class 'dict'>, <class '_abcoll.MutableMapping'>)

FIXME

# continued from previous example
>>> klass.__dict__
{'__abstractmethods__': frozenset(),
 '__delitem__': <function __delitem__ at 0x00DCB6A8>,
 '__dict__': <attribute '__dict__' of 'OrderedDict' objects>,
 '__doc__': None,
 '__eq__': <function __eq__ at 0x00DD2930>,
 '__hash__': None,
 '__init__': <function __init__ at 0x00DC41E0>,
 '__iter__': <function __iter__ at 0x00DCB618>,
 '__module__': 'ordereddict',
 '__reduce__': <function __reduce__ at 0x00DCB6F0>,
 '__repr__': <function __repr__ at 0x00DCB8E8>,
 '__reversed__': <function __reversed__ at 0x00DCB660>,
 '__setitem__': <function __setitem__ at 0x00DCB5D0>,
 '__weakref__': <attribute '__weakref__' of 'OrderedDict' objects>,
 '_abc_cache': <_weakrefset.WeakSet object at 0x00DCF950>,
 '_abc_negative_cache': <_weakrefset.WeakSet object at 0x00DCF990>,
 '_abc_negative_cache_version': 12,
 '_abc_registry': <_weakrefset.WeakSet object at 0x00DCF910>,
 'clear': <function clear at 0x00DCB7C8>,
 'copy': <function copy at 0x00DD28A0>,
 'fromkeys': <classmethod object at 0x00DCF8F0>,
 'items': <function items at 0x00D60150>,
 'keys': <function keys at 0x00D60108>,
 'pop': <function pop at 0x00D60978>,
 'popitem': <function popitem at 0x00DCB780>,
 'setdefault': <function setdefault at 0x00D60A98>,
 'update': <function update at 0x00D60A50>,
 'values': <function values at 0x00D60198>}

FIXME

⁂

Implementing Fractions

☜ ☞