Comment ajouter un élément au début d'un OrderedDict?


91

J'ai ceci:

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

Si je fais ceci:

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

Ensuite, je reçois ceci:

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

mais je veux ceci:

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

sans créer de nouveau dictionnaire.


3
Je pense que vous devriez repenser votre programme
Dmitry Zagorulkin

2
"Un OrderedDict est un dict qui se souvient de l'ordre dans lequel les clés ont été insérées pour la première fois." @ZagorulkinDmitry a raison :) ( docs.python.org/2/library/… )
Markon

Réponses:


83

Il n'y a pas de méthode intégrée pour faire cela dans Python 2. Si vous en avez besoin, vous devez écrire une prepend()méthode / fonction qui opère sur les OrderedDictinternes avec une complexité O (1).

Python 3.2 et versions ultérieures, vous devez utiliser la move_to_endméthode. La méthode accepte un lastargument qui indique si l'élément sera déplacé vers le bas ( last=True) ou vers le haut ( last=False) du OrderedDict.

Enfin, si vous voulez une solution rapide, sale et lente , vous pouvez simplement en créer une nouvelle à OrderedDictpartir de zéro.

Détails des quatre solutions différentes:


Étendre OrderedDictet ajouter une nouvelle méthode d'instance

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)

Démo:

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

Fonction autonome qui manipule les OrderedDictobjets

Cette fonction fait la même chose en acceptant l'objet, la clé et la valeur dict. Personnellement, je préfère la classe:

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)

Démo:

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

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

Python 3.2 a introduit la OrderedDict.move_to_end()méthode. En l'utilisant, nous pouvons déplacer une clé existante à l'une ou l'autre extrémité du dictionnaire en temps 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 nous avons besoin d'insérer un élément et de le déplacer vers le haut, le tout en une seule étape, nous pouvons directement l'utiliser pour créer un prepend()wrapper (non présenté ici).


Créez un nouveau OrderedDict- lent !!!

Si vous ne voulez pas faire cela et que les performances ne sont pas un problème, le moyen le plus simple est de créer un nouveau dict:

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

production:

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


Notez que s'il cexiste déjà, cela ne mettra pas à jour l'ancienne valeur
jamylak

1
@IARI Si vous faites référence à, move_to_endil n'y a pas de balise Python 3 sur la question, move_to_endne fonctionne que dans Python 3.2+. Je mettrai à jour ma réponse pour inclure la solution basée sur Python 3. Merci beaucoup pour la mise à jour!
Ashwini Chaudhary

1
@AshwiniChaudhary Puisque Python 3 a déjà été ajouté move_to_front, il vaut peut-être mieux implémenter une move_to_frontméthode au lieu d'une prependméthode séparée ? Cela rendra votre code plus portable si jamais vous avez besoin de prendre en charge à la fois Python 2 et Python 3 à partir de la même base de code.
m000 le

1
Quelle est la raison derrière en dict_setitem=dict.__setitem__tant que param prepend? Pourquoi passerait / devrait-on passer un passeur différent?
Jir du

2
Il doit y avoir un bug dans ordered_dict_prependci - dessus. Appeler ordered_dict_prepend(d, 'c', 100)deux fois et essayer d'imprimer le dict résultant (en entrant simplement dans dla console de Python) entraîne le processus Python qui continue à saisir la mémoire. Testé avec Python 2.7.10
Piotr Dobrogost

15

EDIT (2019-02-03) Notez que la réponse suivante ne fonctionne que sur les anciennes versions de Python. Plus récemment, OrderedDicta été réécrit en C. En outre, cela touche les attributs de double soulignement qui sont mal vus.

Je viens d'écrire une sous-classe de OrderedDictdans un de mes projets dans un but similaire. Voici l'essentiel .

Les opérations d'insertion sont également à temps constant O(1)(elles ne nécessitent pas de reconstruction de la structure de données), contrairement à la plupart de ces solutions.

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

Je reçois TypeError: '_Link' object does not support indexingen utilisant ceci sur Python 3.4.
RickardSjogren

1
Il ne fonctionne pas non plus avec python 3.5: AttributeError: l'objet 'ListDict' n'a pas d'attribut '_OrderedDict__map'
maggie

2
Cela ne fonctionne plus car OrderedDicta été réécrit en C à partir de Python 3.5, et cette sous-classe a commis le tabou de se débrouiller avec les internes (en fait, inverser la modification des noms pour accéder aux propriétés __).
Two-Bit Alchemist

13

Vous devez créer une nouvelle instance de OrderedDict. Si vos clés sont uniques:

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

Mais sinon, méfiez-vous car ce comportement peut ou non être souhaité pour vous:

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, la méthode items ne renvoie plus une liste, mais plutôt une vue, qui agit comme un ensemble. Dans ce cas, vous devrez prendre l'union d'ensemble car la concaténation avec + ne fonctionnera pas: dict (x.items () | y.items ())
The Demz

1
@TheDemz Je pensais que l'union d'ensemble ne préserverait pas l'ordre, rendant ainsi l'ordre final des éléments dans le résultat OrderedDictinstable?
max

@max Oui, c'est instable. Les objets renvoyés par dict.keys (), dict.values ​​() et dict.items () sont appelés vues de dictionnaire. Ce sont des séquences paresseuses qui verront des changements dans le dictionnaire sous-jacent. Pour forcer la vue dictionnaire à devenir une liste complète, utilisez la liste (dictview). Voir Objets de vue Dictionnaire. docs.python.org/3.4/library/…
The Demz

6

Si vous savez que vous voudrez une clé «c», mais que vous ne connaissez pas la valeur, insérez «c» avec une valeur factice lorsque vous créez le dict.

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

et modifiez la valeur ultérieurement.

d1['c'] = 3

Existe-t-il un moyen d'insérer dans un ordonné de sorte que les éléments soient toujours triés (croissant / décroissant).
Eswar

Un dict ordonné n'est trié par aucune propriété des éléments. Il est ordonné par ordre d'insertion, qui n'a rien à voir avec les éléments eux-mêmes. Dans CPthon 3.6 et Python 3.7, tous les dictionnaires sont ainsi ordonnés et il y a peu de raisons d'utiliser un OrderedDict.
Terry Jan Reedy


3

FWIW Voici un code quick-n-dirty que j'ai écrit pour l'insertion dans une position d'index arbitraire. Pas nécessairement efficace mais cela fonctionne sur place.

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

Vous voudrez peut-être utiliser une structure complètement différente, mais il existe des moyens de le faire en python 2.7 .

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

d2 contiendra alors

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

Comme mentionné par d'autres, en python 3.2, vous pouvez utiliser OrderedDict.move_to_end('c', last=False)pour déplacer une clé donnée après l'insertion.

Remarque: Tenez compte du fait que la première option est plus lente pour les grands ensembles de données en raison de la création d'un nouveau OrderedDict et de la copie des anciennes valeurs.


2

Si vous avez besoin de fonctionnalités qui ne sont pas là, étendez simplement la classe avec ce que vous voulez:

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)

Pas très efficace, mais fonctionne:

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

Je suggérerais d'ajouter une prepend()méthode à cette pure recette Python ActiveState ou d'en dériver une sous-classe. Le code pour ce faire pourrait être assez efficace étant donné que la structure de données sous-jacente pour le classement est une liste chaînée.

Mettre à jour

Pour prouver que cette approche est faisable, vous trouverez ci-dessous un code qui fait ce qui est suggéré. En prime, j'ai également apporté quelques modifications mineures supplémentaires pour pouvoir travailler à la fois dans Python 2.7.15 et 3.7.1.

Une prepend()méthode a été ajoutée à la classe dans la recette et a été implémentée en termes d'une autre méthode qui a été ajoutée nommée move_to_end(), qui a été ajoutée OrderedDictdans Python 3.2.

prepend()peut également être implémenté directement, presque exactement comme indiqué au début de la réponse de @Ashwini Chaudhary - et cela entraînerait probablement une légère accélération, mais cela a été laissé comme un exercice pour le lecteur motivé ...

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

@LazyLeopard: Ce n'est pas thread-safe. Vous pouvez trouver Comment rendre les conteneurs intégrés (ensembles, dictionnaires, listes) thread-safe? d'intérêt.
martineau

1

J'ai eu une boucle à l'infini en essayant d'imprimer ou d'enregistrer le dictionnaire en utilisant la réponse @Ashwini Chaudhary avec Python 2.7. Mais j'ai réussi à réduire un peu son code et je l'ai fait fonctionner ici:

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 )

c'est génial! A travaillé pour moi!
Souvik Ray le

0

C'est un dict ordonné par défaut qui permet d'insérer des éléments dans n'importe quelle position et d'utiliser le. opérateur pour créer des clés:

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]
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.