¿Cómo agregar un elemento al comienzo de un OrderedDict?


93

Tengo esto:

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

Si hago esto:

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

Entonces me sale esto:

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

pero quiero esto:

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

sin crear un diccionario nuevo.


3
Creo que deberías rediseñar tu programa
Dmitry Zagorulkin

2
"Un OrderedDict es un dict que recuerda el orden en el que se insertaron las claves". @ZagorulkinDmitry tiene razón :) ( docs.python.org/2/library/… )
Markon

Respuestas:


86

No hay un método incorporado para hacer esto en Python 2. Si lo necesita, debe escribir un prepend()método / función que opere en las OrderedDictpartes internas con complejidad O (1).

Para Python 3.2 y posterior, debe usar el move_to_endmétodo. El método acepta un lastargumento que indica si el elemento se moverá al final ( last=True) o al principio ( last=False) del OrderedDict.

Finalmente, si desea una solución rápida, sucia y lenta , puede crear una nueva OrderedDictdesde cero.

Detalles de las cuatro soluciones diferentes:


Amplíe OrderedDicty agregue un nuevo método de instancia

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)

Manifestación:

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

Función autónoma que manipula OrderedDictobjetos.

Esta función hace lo mismo al aceptar el objeto dict, la clave y el valor. Yo personalmente prefiero la clase:

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)

Manifestación:

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

Utilice OrderedDict.move_to_end()(Python> = 3.2)

Python 3.2 introdujo el OrderedDict.move_to_end()método. Usándolo, podemos mover una clave existente a cualquier extremo del diccionario en tiempo 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')])

Si necesitamos insertar un elemento y moverlo hacia la parte superior, todo en un solo paso, podemos usarlo directamente para crear un prepend()contenedor (no se presenta aquí).


Crea un nuevo OrderedDict- ¡lento!

Si no desea hacer eso y el rendimiento no es un problema , la forma más fácil es crear un nuevo diccionario:

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

salida:

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


Tenga en cuenta que si cya existe, esto no actualizará el valor anterior
jamylak

1
@IARI Si se refiere a, move_to_endentonces no hay una etiqueta de Python 3 en la pregunta, move_to_endsolo funciona en Python 3.2+. Actualizaré mi respuesta para incluir la solución basada en Python 3. ¡Muchas gracias por la actualización!
Ashwini Chaudhary

1
@AshwiniChaudhary Dado que Python 3 ya se ha agregado move_to_front, ¿tal vez sea mejor implementar un move_to_frontmétodo en lugar de un prependmétodo separado ? Esto hará que su código sea más portátil si alguna vez necesita admitir Python 2 y Python 3 desde el mismo código base.
m000

1
¿Cuál es la razón detrás de dict_setitem=dict.__setitem__como parámetro prepend? ¿Por qué pasaría / debería uno pasar a un colocador diferente?
Jir

2
Tiene que haber un error en el ordered_dict_prependanterior. Llamar ordered_dict_prepend(d, 'c', 100)dos veces e intentar imprimir el dict resultante (simplemente ingresando den la consola de Python) da como resultado que el proceso de Python siga tomando memoria. Probado con Python 2.7.10
Piotr Dobrogost

15

EDITAR (2019-02-03) Tenga en cuenta que la siguiente respuesta solo funciona en versiones anteriores de Python. Más recientemente, OrderedDictse ha reescrito en C. Además, esto toca los atributos de doble subrayado que están mal vistos.

Acabo de escribir una subclase de OrderedDicten un proyecto mío con un propósito similar. Aquí está la esencia .

Las operaciones de inserción también son de tiempo constante O(1)(no requieren que reconstruya la estructura de datos), a diferencia de la mayoría de estas soluciones.

>>> d1 = ListDict([('a', '1'), ('b', '2')])
>>> d1.insert_before('a', ('c', 3))
>>> d1
ListDict([('c', 3), ('a', '1'), ('b', '2')])

Obtengo TypeError: '_Link' object does not support indexingal usar esto en Python 3.4.
RickardSjogren

1
Tampoco funciona con Python 3.5: AttributeError: el objeto 'ListDict' no tiene atributo '_OrderedDict__map'
maggie

2
Esto ya no funciona porque OrderedDictse ha reescrito en C a partir de Python 3.5, y esta subclase cometió el tabú de jugar con cosas internas (en realidad, invertir la manipulación de nombres para acceder a las propiedades de __).
Two-Bit Alchemist

13

Tienes que crear una nueva instancia de OrderedDict. Si sus claves son únicas:

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

Pero si no es así, tenga cuidado ya que este comportamiento puede o no ser el deseado para usted:

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

3
En python3, el método items ya no devuelve una lista, sino una vista, que actúa como un conjunto. En este caso, deberá tomar la unión de conjuntos ya que la concatenación con + no funcionará: dict (x.items () | y.items ())
The Demz

1
@TheDemz Pensé que la unión de conjuntos no preservaría el orden, lo que haría que el orden final de los elementos en el resultado fuera OrderedDictinestable.
máximo

@max Sí, es inestable. Los objetos devueltos por dict.keys (), dict.values ​​() y dict.items () se denominan vistas de diccionario. Son secuencias perezosas que verán cambios en el diccionario subyacente. Para forzar que la vista de diccionario se convierta en una lista completa, use list (dictview). Consulte Objetos de la vista Diccionario. docs.python.org/3.4/library/…
The Demz

6

Si sabe que querrá una tecla 'c', pero no conoce el valor, inserte 'c' con un valor ficticio cuando cree el dict.

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

y cambie el valor más tarde.

d1['c'] = 3

¿Hay alguna forma de insertar en un diccionario ordenado de manera que los elementos aún estén ordenados (aumentando / disminuyendo)?
Eswar

Un dict ordenado no se clasifica por ninguna propiedad de los elementos. Se ordena por orden de inserción, que no tiene nada que ver con los artículos en sí. En CPthon 3.6 y en Python 3.7, todos los dictados están ordenados y hay pocas razones para usar un OrderedDict.
Terry Jan Reedy


3

FWIW Aquí hay un código rápido y sucio que escribí para insertarlo en una posición de índice arbitraria. No es necesariamente eficiente, pero funciona en el lugar.

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)

3

Es posible que desee utilizar una estructura completamente diferente, pero hay formas de hacerlo en Python 2.7 .

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

d2 entonces contendrá

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

Como lo mencionaron otros, en Python 3.2 puede usar OrderedDict.move_to_end('c', last=False)para mover una clave determinada después de la inserción.

Nota: Tenga en cuenta que la primera opción es más lenta para grandes conjuntos de datos debido a la creación de un nuevo OrderedDict y la copia de valores antiguos.


2

Si necesita una funcionalidad que no existe, simplemente amplíe la clase con lo que desee:

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)

No es terriblemente eficiente, pero funciona:

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

1

Sugeriría agregar un prepend()método a esta receta pura de Python ActiveState o derivar una subclase de ella. El código para hacerlo podría ser bastante eficiente dado que la estructura de datos subyacente para ordenar es una lista vinculada.

Actualizar

Para demostrar que este enfoque es factible, a continuación se muestra un código que hace lo que se sugiere. Como beneficio adicional, también hice algunos cambios menores adicionales para comenzar a trabajar tanto en Python 2.7.15 como en 3.7.1.

Se prepend()ha agregado un método a la clase en la receta y se ha implementado en términos de otro método que se agregó con nombre move_to_end(), que se agregó aOrderedDict en Python 3.2.

prepend()también se puede implementar directamente, casi exactamente como se muestra al comienzo de la respuesta de @Ashwini Chaudhary, y hacerlo probablemente resultaría en que sea un poco más rápido, pero eso se dejó como un ejercicio para el lector motivado ...

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


1

Obtuve un bucle infinito mientras intentaba imprimir o guardar el diccionario usando la respuesta de @Ashwini Chaudhary con Python 2.7. Pero logré reducir un poco su código y lo hice funcionar aquí:

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 )

¡esto es brillante! ¡Trabajó para mi!
Souvik Ray

0

Este es un dictado ordenado por defecto que permite insertar elementos en cualquier posición y usar el. operador para crear claves:

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]
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.