Wie füge ich ein Element am Anfang eines OrderedDict hinzu?

90

Ich habe das:

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

Wenn ich das mache:

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

Dann bekomme ich folgendes:

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

aber ich will das:

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

ohne ein neues Wörterbuch zu erstellen.

user2392209
quelle
3
Ich denke, Sie sollten Ihr Programm neu gestalten
Dmitry Zagorulkin
2
"Ein OrderedDict ist ein Diktat, das sich an die Reihenfolge erinnert, in der die Schlüssel zuerst eingefügt wurden." @ ZagorulkinDmitry ist richtig :) ( docs.python.org/2/library/… )
Markon

Antworten:

82

In Python 2 gibt es dafür keine integrierte Methode. Wenn Sie dies benötigen, müssen Sie eine prepend()Methode / Funktion schreiben , die auf den OrderedDictInterna mit O (1) -Komplexität arbeitet.

Für Python 3.2 und höher, Sie sollten die Verwendung move_to_endMethode. Die Methode akzeptiert ein lastArgument, das angibt, ob das Element nach unten ( last=True) oder nach oben ( last=False) verschoben wird OrderedDict.

Wenn Sie eine schnelle, schmutzige und langsame Lösung wünschen , können Sie einfach eine neue erstellenOrderedDict von Grund auf neu .

Details zu den vier verschiedenen Lösungen:


Erweitern OrderedDictSie eine neue Instanzmethode und fügen Sie sie hinzu

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)

Demo:

>>> 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')])

Standalone-Funktion zum Bearbeiten von OrderedDictObjekten

Diese Funktion macht dasselbe, indem sie das diktierte Objekt, den Schlüssel und den Wert akzeptiert. Ich persönlich bevorzuge die Klasse:

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)

Demo:

>>> 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')])

Verwenden Sie OrderedDict.move_to_end()(Python> = 3.2)

Python 3.2 führte die OrderedDict.move_to_end()Methode ein. Mit dieser Funktion können wir einen vorhandenen Schlüssel in O (1) -Zeit an jedes Ende des Wörterbuchs verschieben.

>>> 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')])

Wenn wir ein Element einfügen und in einem Schritt nach oben verschieben müssen, können wir es direkt zum Erstellen eines prepend()Wrappers verwenden (hier nicht dargestellt).


Erstelle ein neues OrderedDict- langsam !!!

Wenn Sie dies nicht möchten und die Leistung kein Problem darstellt, können Sie am einfachsten ein neues Diktat erstellen:

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

Ausgabe:

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

Ashwini Chaudhary
quelle
Beachten Sie, wenn cbereits vorhanden, wird der alte Wert nicht aktualisiert
Jamylak
1
@IARI Wenn Sie sich beziehen, move_to_endgibt es kein Python 3-Tag in der Frage, move_to_endfunktioniert nur in Python 3.2+. Ich werde meine Antwort aktualisieren, um die Python 3-basierte Lösung einzuschließen. Vielen Dank für das Update!
Ashwini Chaudhary
1
@AshwiniChaudhary Da Python 3 bereits hinzugefügt wurde move_to_front, ist es vielleicht besser, eine move_to_frontMethode anstelle einer separaten prependMethode zu implementieren ? Dadurch wird Ihr Code portabler, wenn Sie jemals sowohl Python 2 als auch Python 3 von derselben Codebasis aus unterstützen müssen.
M000
1
Was ist der Grund dafür dict_setitem=dict.__setitem__als Parameter prepend? Warum sollte / sollte man einen anderen Setter passieren?
Jir
2
Es muss eine sein , Fehler in ordered_dict_prependoben. Wenn Sie ordered_dict_prepend(d, 'c', 100)zweimal aufrufen und versuchen, das resultierende Diktat zu drucken (indem Sie es einfach din die Python-Konsole eingeben), wird der Python-Prozess immer wieder gespeichert. Getestet mit Python 2.7.10
Piotr Dobrogost
15

BEARBEITEN (03.02.2019) Beachten Sie, dass die folgende Antwort nur bei älteren Versionen von Python funktioniert. In jüngerer Zeit wurde OrderedDictin C umgeschrieben. Außerdem berührt dies Attribute mit doppeltem Unterstrich, die verpönt sind.

Ich habe gerade eine Unterklasse von OrderedDictin einem meiner Projekte für einen ähnlichen Zweck geschrieben. Hier ist das Wesentliche .

Einfügevorgänge haben im O(1)Gegensatz zu den meisten dieser Lösungen auch eine konstante Zeit (Sie müssen die Datenstruktur nicht neu erstellen).

>>> d1 = ListDict([('a', '1'), ('b', '2')])
>>> d1.insert_before('a', ('c', 3))
>>> d1
ListDict([('c', 3), ('a', '1'), ('b', '2')])
Jared
quelle
Ich bekomme, TypeError: '_Link' object does not support indexingwenn ich dies auf Python 3.4 verwende.
RickardSjogren
1
Es funktioniert auch nicht mit Python 3.5: AttributeError: 'ListDict'-Objekt hat kein Attribut' _OrderedDict__map '
Maggie
2
Dies funktioniert nicht mehr, da OrderedDictes ab Python 3.5 in C neu geschrieben wurde und diese Unterklasse das Tabu begangen hat, mit Interna herumzuspielen (tatsächlich die Namensverknüpfung umzukehren, um auf __ Eigenschaften zuzugreifen).
Zwei-Bit-Alchemist
13

Sie müssen eine neue Instanz von erstellen OrderedDict. Wenn Ihre Schlüssel eindeutig sind:

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

Wenn nicht, achten Sie darauf, dass dieses Verhalten für Sie möglicherweise nicht erwünscht ist oder nicht:

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
quelle
3
In Python3 gibt die Methode items keine Liste mehr zurück, sondern eine Ansicht, die sich wie eine Menge verhält. In diesem Fall müssen Sie die festgelegte Vereinigung übernehmen, da die Verkettung mit + nicht funktioniert: dict (x.items () | y.items ())
The Demz
1
@TheDemz Ich dachte, Set Union würde die Reihenfolge nicht beibehalten, wodurch die endgültige Reihenfolge der Elemente in der resultierenden OrderedDictinstabil wird?
Max
@max Ja, es ist instabil. Die von dict.keys (), dict.values ​​() und dict.items () zurückgegebenen Objekte werden als Wörterbuchansichten bezeichnet. Es sind faule Sequenzen, die Änderungen im zugrunde liegenden Wörterbuch sehen. Verwenden Sie die Liste (dictview), um zu erzwingen, dass die Wörterbuchansicht zu einer vollständigen Liste wird. Siehe Objekte der Wörterbuchansicht. docs.python.org/3.4/library/…
The Demz
6

Wenn Sie wissen, dass Sie einen 'c'-Schlüssel möchten, den Wert aber nicht kennen, fügen Sie beim Erstellen des Diktats' c 'mit einem Dummy-Wert ein.

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

und ändern Sie den Wert später.

d1['c'] = 3
Terry Jan Reedy
quelle
Gibt es eine Möglichkeit, in ein geordnetes Diktat einzufügen, sodass die Elemente noch sortiert sind (ansteigend / abnehmend)?
Eswar
Ein bestelltes Diktat wird nicht nach einer Eigenschaft der Artikel sortiert. Es wird nach Einfügereihenfolge bestellt, was nichts mit den Artikeln selbst zu tun hat. In CPthon 3.6 und in Python 3.7 sind alle Diktate so geordnet, und es gibt wenig Grund, ein OrderedDict zu verwenden.
Terry Jan Reedy
3

FWIW Hier ist ein Quick-n-Dirty-Code, den ich zum Einfügen in eine beliebige Indexposition geschrieben habe. Nicht unbedingt effizient, aber es funktioniert vor Ort.

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
quelle
3

Möglicherweise möchten Sie eine andere Struktur verwenden, aber es gibt Möglichkeiten, dies in Python 2.7 zu tun .

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

d2 wird dann enthalten

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

Wie bereits von anderen erwähnt, in 3.2 Python können Sie verwenden OrderedDict.move_to_end('c', last=False)einen bestimmten Schlüssel nach dem Einsetzen zu bewegen.

Hinweis: Beachten Sie, dass die erste Option für große Datenmengen langsamer ist, da ein neues OrderedDict erstellt und alte Werte kopiert werden.

wihlke
quelle
2

Wenn Sie Funktionen benötigen, die nicht vorhanden sind, erweitern Sie die Klasse einfach um Folgendes:

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)

Nicht besonders effizient, funktioniert aber:

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
quelle
1

Ich würde vorschlagen prepend(), diesem reinen Python ActiveState-Rezept eine Methode hinzuzufügen oder daraus eine Unterklasse abzuleiten. Der Code dafür könnte ziemlich effizient sein, da die zugrunde liegende Datenstruktur für die Bestellung eine verknüpfte Liste ist.

Aktualisieren

Um zu beweisen, dass dieser Ansatz machbar ist, finden Sie unten Code, der die vorgeschlagenen Aktionen ausführt. Als Bonus habe ich noch ein paar kleinere Änderungen vorgenommen, um sowohl in Python 2.7.15 als auch in 3.7.1 arbeiten zu können.

Eine prepend()Methode wurde der Klasse im Rezept hinzugefügt und in Bezug auf eine andere Methode implementiert, die mit dem Namen move_to_end()hinzugefügt wurde und die OrderedDictin Python 3.2 hinzugefügt wurde .

prepend()kann auch direkt implementiert werden, fast genau wie zu Beginn der Antwort von @Ashwini Chaudhary gezeigt - und dies würde wahrscheinlich dazu führen, dass es etwas schneller ist, aber das ist eine Übung für den motivierten Leser ...

# 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
quelle
@ LazyLeopard: Es ist nicht threadsicher. Möglicherweise finden Sie Informationen zum Gewinnen von Threads für integrierte Container (Sets, Dicts, Listen). von Interesse.
Martineau
1

Ich habe eine Endlosschleife erhalten, als ich versucht habe, das Wörterbuch mit der Antwort @Ashwini Chaudhary mit Python zu drucken oder zu speichern 2.7. Aber ich habe es geschafft, seinen Code ein wenig zu reduzieren und ihn hier zum Laufen zu bringen:

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 )
Benutzer
quelle
das ist brilliant! Hat für mich gearbeitet!
Souvik Ray
0

Dies ist ein standardmäßiges, geordnetes Diktat, mit dem Sie Elemente an einer beliebigen Position einfügen und die verwenden können. Operator zum Erstellen von Schlüsseln:

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
quelle