Jak dodać element na początek OrderedDict?

93

Mam to:

d1 = OrderedDict([('a', '1'), ('b', '2')])

Jeśli to zrobię:

d1.update({'c':'3'})

Wtedy rozumiem:

OrderedDict([('a', '1'), ('b', '2'), ('c', '3')])

ale chcę tego:

[('c', '3'), ('a', '1'), ('b', '2')]

bez tworzenia nowego słownika.

user2392209
źródło
3
Myślę, że powinieneś przeprojektować swój program
Dmitry Zagorulkin
2
„OrderedDict to dykt, który zapamiętuje kolejność wstawiania kluczy”. @ZagorulkinDmitry ma rację :) ( docs.python.org/2/library/… )
Markon

Odpowiedzi:

86

W Pythonie 2 nie ma wbudowanej metody, aby to zrobić. Jeśli tego potrzebujesz, musisz napisać prepend()metodę / funkcję, która operuje na elementach OrderedDictwewnętrznych ze złożonością O (1).

W przypadku języka Python 3.2 i nowszych należy użyć move_to_endmetody. Metoda przyjmuje lastargument wskazujący, czy element zostanie przeniesiony na dół ( last=True), czy na górę ( last=False) OrderedDict.

Wreszcie, jeśli chcesz szybkiego, brudnego i wolnego rozwiązania, możesz po prostu utworzyć nowe OrderedDictod podstaw.

Szczegóły dotyczące czterech różnych rozwiązań:


Rozszerz OrderedDicti dodaj nową metodę wystąpienia

from collections import OrderedDict

class MyOrderedDict(OrderedDict):

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

        root = self._OrderedDict__root
        first = root[1]

        if key in self:
            link = self._OrderedDict__map[key]
            link_prev, link_next, _ = link
            link_prev[1] = link_next
            link_next[0] = link_prev
            link[0] = root
            link[1] = first
            root[1] = first[0] = link
        else:
            root[1] = first[0] = self._OrderedDict__map[key] = [root, first, key]
            dict_setitem(self, key, value)

Próbny:

>>> d = MyOrderedDict([('a', '1'), ('b', '2')])
>>> d
MyOrderedDict([('a', '1'), ('b', '2')])
>>> d.prepend('c', 100)
>>> d
MyOrderedDict([('c', 100), ('a', '1'), ('b', '2')])
>>> d.prepend('a', d['a'])
>>> d
MyOrderedDict([('a', '1'), ('c', 100), ('b', '2')])
>>> d.prepend('d', 200)
>>> d
MyOrderedDict([('d', 200), ('a', '1'), ('c', 100), ('b', '2')])

Samodzielna funkcja manipulująca OrderedDictobiektami

Ta funkcja robi to samo, akceptując obiekt, klucz i wartość dict. Osobiście wolę zajęcia:

from collections import OrderedDict

def ordered_dict_prepend(dct, key, value, dict_setitem=dict.__setitem__):
    root = dct._OrderedDict__root
    first = root[1]

    if key in dct:
        link = dct._OrderedDict__map[key]
        link_prev, link_next, _ = link
        link_prev[1] = link_next
        link_next[0] = link_prev
        link[0] = root
        link[1] = first
        root[1] = first[0] = link
    else:
        root[1] = first[0] = dct._OrderedDict__map[key] = [root, first, key]
        dict_setitem(dct, key, value)

Próbny:

>>> d = OrderedDict([('a', '1'), ('b', '2')])
>>> ordered_dict_prepend(d, 'c', 100)
>>> d
OrderedDict([('c', 100), ('a', '1'), ('b', '2')])
>>> ordered_dict_prepend(d, 'a', d['a'])
>>> d
OrderedDict([('a', '1'), ('c', 100), ('b', '2')])
>>> ordered_dict_prepend(d, 'd', 500)
>>> d
OrderedDict([('d', 500), ('a', '1'), ('c', 100), ('b', '2')])

Użyj OrderedDict.move_to_end()(Python> = 3.2)

Python 3.2 wprowadziłOrderedDict.move_to_end()metodę. Używając go, możemy przenieść istniejący klucz na dowolny koniec słownika w czasie O (1).

>>> d1 = OrderedDict([('a', '1'), ('b', '2')])
>>> d1.update({'c':'3'})
>>> d1.move_to_end('c', last=False)
>>> d1
OrderedDict([('c', '3'), ('a', '1'), ('b', '2')])

Jeśli zajdzie potrzeba wstawienia elementu i przeniesienia go na górę, wszystko w jednym kroku, możemy bezpośrednio użyć go do stworzenia prepend()wrappera (nie prezentowanego tutaj).


Utwórz nowy OrderedDict- wolno !!!

Jeśli nie chcesz tego robić, a wydajność nie jest problemem, najłatwiej jest utworzyć nowy dykt:

from itertools import chain, ifilterfalse
from collections import OrderedDict


def unique_everseen(iterable, key=None):
    "List unique elements, preserving order. Remember all elements ever seen."
    # unique_everseen('AAAABBBCCDAABBB') --> A B C D
    # unique_everseen('ABBCcAD', str.lower) --> A B C D
    seen = set()
    seen_add = seen.add
    if key is None:
        for element in ifilterfalse(seen.__contains__, iterable):
            seen_add(element)
            yield element
    else:
        for element in iterable:
            k = key(element)
            if k not in seen:
                seen_add(k)
                yield element

d1 = OrderedDict([('a', '1'), ('b', '2'),('c', 4)])
d2 = OrderedDict([('c', 3), ('e', 5)])   #dict containing items to be added at the front
new_dic = OrderedDict((k, d2.get(k, d1.get(k))) for k in \
                                           unique_everseen(chain(d2, d1)))
print new_dic

wynik:

OrderedDict([('c', 3), ('e', 5), ('a', '1'), ('b', '2')])

Ashwini Chaudhary
źródło
Uwaga, jeśli cjuż istnieje, nie zaktualizuje to starej wartości
jamylak
1
@IARI Jeśli odnosisz się, to move_to_endpytanie nie zawiera znacznika Python 3, move_to_enddziała tylko w Pythonie 3.2+. Zaktualizuję swoją odpowiedź, aby zawierała rozwiązanie oparte na Pythonie 3. Wielkie dzięki za aktualizację!
Ashwini Chaudhary
1
@AshwiniChaudhary Skoro Python 3 już dodał move_to_front, może lepiej jest zaimplementować move_to_frontmetodę zamiast oddzielnej prependmetody? Dzięki temu Twój kod będzie bardziej przenośny, jeśli kiedykolwiek będziesz musiał obsługiwać zarówno Python 2, jak i Python 3 z tej samej bazy kodu.
m000
1
Jaki jest powód tego dict_setitem=dict.__setitem__jako parametru prepend? Dlaczego miałoby / powinno się przejść przez innego setera?
Jir,
2
Nie musi być błąd w ordered_dict_prependpowyżej. ordered_dict_prepend(d, 'c', 100)Dwukrotne wywołanie i próba wydrukowania wynikowego dyktowania (po prostu wpisując dw konsoli Pythona) powoduje, że proces Pythona nadal zajmuje pamięć. Testowane z Pythonem 2.7.10
Piotr Dobrogost
15

EDYCJA (2019-02-03) Pamiętaj, że następująca odpowiedź działa tylko w starszych wersjach Pythona. Niedawno OrderedDictzostał przepisany w C. Ponadto dotyczy to atrybutów podwójnego podkreślenia, na które źle się patrzy.

Właśnie napisałem podklasę OrderedDict w moim projekcie w podobnym celu. Oto sedno .

Operacje wstawiania są również stałe w czasie O(1)(nie wymagają przebudowy struktury danych), w przeciwieństwie do większości tych rozwiązań.

>>> d1 = ListDict([('a', '1'), ('b', '2')])
>>> d1.insert_before('a', ('c', 3))
>>> d1
ListDict([('c', 3), ('a', '1'), ('b', '2')])
Jared
źródło
Otrzymuję TypeError: '_Link' object does not support indexing, używając tego w Pythonie 3.4.
RickardSjogren
1
Nie działa również z Pythonem 3.5: AttributeError: Obiekt „ListDict” nie ma atrybutu „_OrderedDict__map”
maggie
2
To już nie działa, ponieważ OrderedDictzostało przepisane w C od Pythona 3.5, a ta podklasa dopuściła się tabu majstrowania przy elementach wewnętrznych (w rzeczywistości odwracając zniekształcanie nazw, aby uzyskać dostęp do właściwości __).
Two-Bit Alchemist
13

Musisz utworzyć nową instancję OrderedDict. Jeśli Twoje klucze są unikalne:

d1=OrderedDict([("a",1),("b",2)])
d2=OrderedDict([("c",3),("d",99)])
both=OrderedDict(list(d2.items()) + list(d1.items()))
print(both)

#OrderedDict([('c', 3), ('d', 99), ('a', 1), ('b', 2)])

Ale jeśli nie, uważaj, ponieważ takie zachowanie może być dla Ciebie pożądane lub nie:

d1=OrderedDict([("a",1),("b",2)])
d2=OrderedDict([("c",3),("b",99)])
both=OrderedDict(list(d2.items()) + list(d1.items()))
print(both)

#OrderedDict([('c', 3), ('b', 2), ('a', 1)])
delfin
źródło
3
W pythonie3 metoda items nie zwraca już listy, ale raczej widok, który działa jak zestaw. W takim przypadku musisz wziąć set union, ponieważ konkatenacja z + nie zadziała: dict (x.items () | y.items ())
The Demz
1
@TheDemz Myślałem, że set union nie zachowa kolejności, przez co ostateczna kolejność elementów w wynikowej OrderedDictniestabilności?
max
@max Tak, jest niestabilny. Obiekty zwrócone przez dict.keys (), dict.values ​​() i dict.items () nazywane są widokami słownikowymi. Są to leniwe sekwencje, które zobaczą zmiany w podstawowym słowniku. Aby wymusić, aby widok słownika stał się pełną listą, użyj listy (dictview). Zobacz Obiekty widoku słownika. docs.python.org/3.4/library/…
The Demz
6

Jeśli wiesz, że będziesz potrzebować klucza „c”, ale nie znasz wartości, wstaw „c” z wartością fikcyjną podczas tworzenia dict.

d1 = OrderedDict([('c', None), ('a', '1'), ('b', '2')])

i zmień wartość później.

d1['c'] = 3
Terry Jan Reedy
źródło
Czy istnieje sposób, aby wstawić do uporządkowanego słowa, tak aby elementy były nadal posortowane (rosnące / malejące).
Eswar
Uporządkowany dykt nie jest sortowany według żadnej właściwości elementów. Jest uporządkowana według kolejności reklamowej, która nie ma nic wspólnego z samymi elementami. W CPthon 3.6 i Python 3.7 wszystkie dykty są tak uporządkowane i nie ma powodu, aby używać OrderedDict.
Terry Jan Reedy
3

FWIW Oto szybki kod, który napisałem, aby wstawić do dowolnej pozycji indeksu. Niekoniecznie wydajne, ale działa na miejscu.

class OrderedDictInsert(OrderedDict):
    def insert(self, index, key, value):
        self[key] = value
        for ii, k in enumerate(list(self.keys())):
            if ii >= index and k != key:
                self.move_to_end(k)
Tom Aldcroft
źródło
3

Możesz chcieć użyć zupełnie innej struktury, ale są na to sposoby w Pythonie 2.7 .

d1 = OrderedDict([('a', '1'), ('b', '2')])
d2 = OrderedDict(c='3')
d2.update(d1)

d2 będzie wtedy zawierać

>>> d2
OrderedDict([('c', '3'), ('a', '1'), ('b', '2')])

Jak wspominali inni, w Pythonie 3.2 możesz użyć OrderedDict.move_to_end('c', last=False)do przeniesienia danego klucza po wstawieniu.

Uwaga: weź pod uwagę, że pierwsza opcja jest wolniejsza w przypadku dużych zbiorów danych z powodu tworzenia nowego OrderedDict i kopiowania starych wartości.

wihlke
źródło
2

Jeśli potrzebujesz funkcji, której nie ma, po prostu rozszerz klasę o cokolwiek chcesz:

from collections import OrderedDict

class OrderedDictWithPrepend(OrderedDict):
    def prepend(self, other):
        ins = []
        if hasattr(other, 'viewitems'):
            other = other.viewitems()
        for key, val in other:
            if key in self:
                self[key] = val
            else:
                ins.append((key, val))
        if ins:
            items = self.items()
            self.clear()
            self.update(ins)
            self.update(items)

Niezbyt wydajne, ale działa:

o = OrderedDictWithPrepend()

o['a'] = 1
o['b'] = 2
print o
# OrderedDictWithPrepend([('a', 1), ('b', 2)])

o.prepend({'c': 3})
print o
# OrderedDictWithPrepend([('c', 3), ('a', 1), ('b', 2)])

o.prepend([('a',11),('d',55),('e',66)])
print o
# OrderedDictWithPrepend([('d', 55), ('e', 66), ('c', 3), ('a', 11), ('b', 2)])
Georg
źródło
1

Sugerowałbym dodanie prepend()metody do tej czystej receptury Pythona ActiveState lub wyprowadzenie z niej podklasy. Kod, który to zrobi, może być dość wydajny, biorąc pod uwagę, że podstawową strukturą danych do zamawiania jest lista połączona.

Aktualizacja

Aby udowodnić, że takie podejście jest wykonalne, poniżej znajduje się kod, który robi to, co zostało zasugerowane. Jako bonus wprowadziłem również kilka dodatkowych drobnych zmian, aby zabrać się do pracy zarówno w Pythonie 2.7.15, jak i 3.7.1.

prepend()Metoda została dodana do klasy w recepturze i został wdrożony w kategoriach innego sposobu, który został dodany nazwie move_to_end(), który został dodany do OrderedDictPythona 3.2.

prepend()mogą być również realizowane bezpośrednio, niemal dokładnie tak, jak pokazano na początku @Ashwini Chaudhary za odpowiedź -i robi tak prawdopodobnie spowodować, że był nieco szybciej, ale który został pozostawiony jako ćwiczenie dla czytelnika zmotywowany ...

# Ordered Dictionary for Py2.4 from https://code.activestate.com/recipes/576693

# Backport of OrderedDict() class that runs on Python 2.4, 2.5, 2.6, 2.7 and pypy.
# Passes Python2.7's test suite and incorporates all the latest updates.

try:
    from thread import get_ident as _get_ident
except ImportError:  # Python 3
#    from dummy_thread import get_ident as _get_ident
    from _thread import get_ident as _get_ident  # Changed - martineau

try:
    from _abcoll import KeysView, ValuesView, ItemsView
except ImportError:
    pass

class MyOrderedDict(dict):
    '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).
    # Each link is stored as a list of length three:  [PREV, NEXT, KEY].

    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)

    def prepend(self, key, value):  # Added to recipe.
        self.update({key: value})
        self.move_to_end(key, last=False)

    #### Derived from cpython 3.2 source code.
    def move_to_end(self, key, last=True):  # Added to recipe.
        '''Move an existing element to the end (or beginning if last==False).

        Raises KeyError if the element does not exist.
        When last=True, acts like a fast version of self[key]=self.pop(key).
        '''
        PREV, NEXT, KEY = 0, 1, 2

        link = self.__map[key]
        link_prev = link[PREV]
        link_next = link[NEXT]
        link_prev[NEXT] = link_next
        link_next[PREV] = link_prev
        root = self.__root

        if last:
            last = root[PREV]
            link[PREV] = last
            link[NEXT] = root
            last[NEXT] = root[PREV] = link
        else:
            first = root[NEXT]
            link[PREV] = root
            link[NEXT] = first
            root[NEXT] = first[PREV] = link
    ####

    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)

    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

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

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

    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)

    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

    # -- the following methods do not depend on the internal structure --

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

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

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

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

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

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

    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

    __update = update  # let subclasses override update without breaking __init__

    __marker = object()

    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

    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

    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]

    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(MyOrderedDict()):
            inst_dict.pop(k, None)
        if inst_dict:
            return (self.__class__, (items,), inst_dict)
        return self.__class__, (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, MyOrderedDict):
            return len(self)==len(other) and self.items() == other.items()
        return dict.__eq__(self, other)

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

    # -- the following methods are only used in Python 2.7 --

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

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

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

if __name__ == '__main__':

    d1 = MyOrderedDict([('a', '1'), ('b', '2')])
    d1.update({'c':'3'})
    print(d1)  # -> MyOrderedDict([('a', '1'), ('b', '2'), ('c', '3')])

    d2 = MyOrderedDict([('a', '1'), ('b', '2')])
    d2.prepend('c', 100)
    print(d2)  # -> MyOrderedDict([('c', 100), ('a', '1'), ('b', '2')])
martineau
źródło
@LazyLeopard: To nie jest bezpieczne dla wątków. Możesz znaleźć Jak sprawić, by wbudowane kontenery (zestawy, dykty, listy) były bezpieczne dla wątków? zainteresowań.
martineau
1

Otrzymałem pętlę nieskończoności podczas próby wydrukowania lub zapisania słownika przy użyciu odpowiedzi @Ashwini Chaudhary w Pythonie 2.7. Ale udało mi się trochę zmniejszyć jego kod i uruchomiłem go tutaj:

def move_to_dict_beginning(dictionary, key):
    """
        Move a OrderedDict item to its beginning, or add it to its beginning.
        Compatible with Python 2.7
    """

    if sys.version_info[0] < 3:
        value = dictionary[key]
        del dictionary[key]
        root = dictionary._OrderedDict__root

        first = root[1]
        root[1] = first[0] = dictionary._OrderedDict__map[key] = [root, first, key]
        dict.__setitem__(dictionary, key, value)

    else:
        dictionary.move_to_end( key, last=False )
użytkownik
źródło
To jest genialne! Pracował dla mnie!
Souvik Ray
0

Jest to domyślny, uporządkowany dykt, który pozwala wstawiać elementy w dowolnej pozycji i używać rozszerzenia. operator do tworzenia kluczy:

from collections import OrderedDict

class defdict(OrderedDict):

    _protected = ["_OrderedDict__root", "_OrderedDict__map", "_cb"]    
    _cb = None

    def __init__(self, cb=None):
        super(defdict, self).__init__()
        self._cb = cb

    def __setattr__(self, name, value):
        # if the attr is not in self._protected set a key
        if name in self._protected:
            OrderedDict.__setattr__(self, name, value)
        else:
            OrderedDict.__setitem__(self, name, value)

    def __getattr__(self, name):
        if name in self._protected:
            return OrderedDict.__getattr__(self, name)
        else:
            # implements missing keys
            # if there is a callable _cb, create a key with its value
            try:
                return OrderedDict.__getitem__(self, name)
            except KeyError as e:
                if callable(self._cb):
                    value = self[name] = self._cb()
                    return value
                raise e

    def insert(self, index, name, value):
        items = [(k, v) for k, v in self.items()]
        items.insert(index, (name, value))
        self.clear()
        for k, v in items:
            self[k] = v


asd = defdict(lambda: 10)
asd.k1 = "Hey"
asd.k3 = "Bye"
asd.k4 = "Hello"
asd.insert(1, "k2", "New item")
print asd.k5 # access a missing key will create one when there is a callback
# 10
asd.k6 += 5  # adding to a missing key
print asd.k6
# 15
print asd.keys()
# ['k1', 'k2', 'k3', 'k4', 'k5', 'k6']
print asd.values()
# ['Hey', 'New item', 'Bye', 'Hello', 10, 15]
Mackraken
źródło