Cas d'utilisation de la méthode dict 'setdefault'

L'ajout de collections.defaultdictPython 2.5 a considérablement réduit le besoin de dictla setdefaultméthode de. Cette question s'adresse à notre éducation collective:

1. À quoi sert setdefaultencore aujourd'hui Python 2.6 / 2.7?
2. Quels cas d'utilisation populaires de setdefaultont été remplacés collections.defaultdict?

Vous pourriez dire que defaultdictc'est utile pour les paramètres par défaut avant de remplir le dict et setdefaultest utile pour définir les valeurs par défaut pendant ou après le remplissage du dict .

Probablement le cas d'utilisation le plus courant: regrouper des éléments (dans des données non triées, sinon utiliser itertools.groupby)

# really verbose
new = {}
for (key, value) in data:
    if key in new:
        new[key].append( value )
    else:
        new[key] = [value]


# easy with setdefault
new = {}
for (key, value) in data:
    group = new.setdefault(key, []) # key might exist already
    group.append( value )


# even simpler with defaultdict 
from collections import defaultdict
new = defaultdict(list)
for (key, value) in data:
    new[key].append( value ) # all keys have a default already

Parfois, vous voulez vous assurer que des clés spécifiques existent après la création d'un dict. defaultdictne fonctionne pas dans ce cas, car il crée uniquement des clés sur un accès explicite. Pensez que vous utilisez quelque chose de HTTP-ish avec de nombreux en-têtes - certains sont facultatifs, mais vous voulez des valeurs par défaut pour eux:

headers = parse_headers( msg ) # parse the message, get a dict
# now add all the optional headers
for headername, defaultvalue in optional_headers:
    headers.setdefault( headername, defaultvalue )

J'utilise couramment setdefaultpour les dictées d'argument de mot-clé, comme dans cette fonction:

def notify(self, level, *pargs, **kwargs):
    kwargs.setdefault("persist", level >= DANGER)
    self.__defcon.set(level, **kwargs)
    try:
        kwargs.setdefault("name", self.client.player_entity().name)
    except pytibia.PlayerEntityNotFound:
        pass
    return _notify(level, *pargs, **kwargs)

C'est idéal pour peaufiner les arguments dans les wrappers autour des fonctions qui acceptent des arguments de mot-clé.

defaultdict est génial lorsque la valeur par défaut est statique, comme une nouvelle liste, mais pas tellement si elle est dynamique.

Par exemple, j'ai besoin d'un dictionnaire pour mapper des chaînes sur des entiers uniques. defaultdict(int)utilisera toujours 0 comme valeur par défaut. De même, defaultdict(intGen())produit toujours 1.

Au lieu de cela, j'ai utilisé un dict régulier:

nextID = intGen()
myDict = {}
for lots of complicated stuff:
    #stuff that generates unpredictable, possibly already seen str
    strID = myDict.setdefault(myStr, nextID())

Notez que dict.get(key, nextID())c'est insuffisant car je dois également pouvoir me référer à ces valeurs plus tard.

intGen est une petite classe que je construis qui incrémente automatiquement un int et renvoie sa valeur:

class intGen:
    def __init__(self):
        self.i = 0

    def __call__(self):
        self.i += 1
    return self.i

Si quelqu'un a un moyen de faire cela avec, defaultdictj'aimerais le voir.

Comme la plupart des réponses indiquent setdefaultou defaultdictvous permet de définir une valeur par défaut lorsqu'une clé n'existe pas. Cependant, je voudrais signaler une petite mise en garde concernant les cas d'utilisation de setdefault. Lorsque l'interpréteur Python s'exécute, setdefaultil évaluera toujours le deuxième argument de la fonction même si la clé existe dans le dictionnaire. Par exemple:

In: d = {1:5, 2:6}

In: d
Out: {1: 5, 2: 6}

In: d.setdefault(2, 0)
Out: 6

In: d.setdefault(2, print('test'))
test
Out: 6

Comme vous pouvez le voir, printa également été exécuté même si 2 existait déjà dans le dictionnaire. Cela devient particulièrement important si vous prévoyez d'utiliser setdefaultpar exemple pour une optimisation comme memoization. Si vous ajoutez un appel de fonction récursive comme deuxième argument à setdefault, vous n'obtiendrez aucune performance car Python appellerait toujours la fonction de manière récursive.

Puisque la mémorisation a été mentionnée, une meilleure alternative est d'utiliser le décorateur functools.lru_cache si vous envisagez d'améliorer une fonction avec la mémorisation. lru_cache gère mieux les exigences de mise en cache pour une fonction récursive.

J'utilise setdefault()quand je veux une valeur par défaut dans un fichier OrderedDict. Il n'existe pas de collection Python standard qui fasse les deux, mais il existe des moyens d'implémenter une telle collection.

Comme l'a dit Muhammad, il existe des situations dans lesquelles vous ne souhaitez parfois définir une valeur par défaut. Un bon exemple de ceci est une structure de données qui est d'abord remplie, puis interrogée.

Considérez un trie. Lors de l'ajout d'un mot, si un sous-nœud est nécessaire mais pas présent, il doit être créé pour étendre le trie. Lors de l'interrogation de la présence d'un mot, un sous-nœud manquant indique que le mot n'est pas présent et qu'il ne doit pas être créé.

Un defaultdict ne peut pas faire cela. Au lieu de cela, un dict régulier avec les méthodes get et setdefault doit être utilisé.

Théoriquement parlant, cela setdefaultserait toujours pratique si vous souhaitez parfois définir une valeur par défaut et parfois non. Dans la vraie vie, je n'ai pas rencontré un tel cas d'utilisation.

Cependant, un cas d'utilisation intéressant provient de la bibliothèque standard (Python 2.6, _threadinglocal.py):

>>> mydata = local()
>>> mydata.__dict__
{'number': 42}
>>> mydata.__dict__.setdefault('widgets', [])
[]
>>> mydata.widgets
[]

Je dirais que l'utilisation __dict__.setdefaultest un cas assez utile.

Edit : En l'occurrence, c'est le seul exemple de la bibliothèque standard et c'est dans un commentaire. Il se peut donc que ce ne soit pas suffisant pour justifier l’existence de setdefault. Pourtant, voici une explication:

Les objets stockent leurs attributs dans l' __dict__attribut. En l'occurrence, l' __dict__attribut est accessible en écriture à tout moment après la création de l'objet. C'est aussi un dictionnaire pas un defaultdict. Il n'est pas judicieux pour les objets dans le cas général d'avoir __dict__comme un defaultdictcar cela rendrait chaque objet ayant tous les identifiants légaux comme attributs. Je ne peux donc pas prévoir de changement dans la __dict__.setdefaultsuppression des objets Python , à part de les supprimer complètement si cela n'a pas été jugé utile.

J'ai réécrit la réponse acceptée et la facilité pour les débutants.

#break it down and understand it intuitively.
new = {}
for (key, value) in data:
    if key not in new:
        new[key] = [] # this is core of setdefault equals to new.setdefault(key, [])
        new[key].append(value)
    else:
        new[key].append(value)


# easy with setdefault
new = {}
for (key, value) in data:
    group = new.setdefault(key, []) # it is new[key] = []
    group.append(value)



# even simpler with defaultdict
new = defaultdict(list)
for (key, value) in data:
    new[key].append(value) # all keys have a default value of empty list []

De plus, j'ai classé les méthodes comme référence:

dict_methods_11 = {
            'views':['keys', 'values', 'items'],
            'add':['update','setdefault'],
            'remove':['pop', 'popitem','clear'],
            'retrieve':['get',],
            'copy':['copy','fromkeys'],}

Un inconvénient de defaultdictover dict( dict.setdefault) est qu'un defaultdictobjet crée un nouvel élément CHAQUE FOIS, une clé non existante est donnée (par exemple avec ==, print). De plus, la defaultdictclasse est généralement beaucoup moins courante que la dictclasse, il est plus difficile de la sérialiser IME.

Fonctions PS IMO | méthodes non destinées à muter un objet, ne doivent pas muter un objet.

Voici quelques exemples de setdefault pour montrer son utilité:

"""
d = {}
# To add a key->value pair, do the following:
d.setdefault(key, []).append(value)

# To retrieve a list of the values for a key
list_of_values = d[key]

# To remove a key->value pair is still easy, if
# you don't mind leaving empty lists behind when
# the last value for a given key is removed:
d[key].remove(value)

# Despite the empty lists, it's still possible to 
# test for the existance of values easily:
if d.has_key(key) and d[key]:
    pass # d has some values for key

# Note: Each value can exist multiple times!
"""
e = {}
print e
e.setdefault('Cars', []).append('Toyota')
print e
e.setdefault('Motorcycles', []).append('Yamaha')
print e
e.setdefault('Airplanes', []).append('Boeing')
print e
e.setdefault('Cars', []).append('Honda')
print e
e.setdefault('Cars', []).append('BMW')
print e
e.setdefault('Cars', []).append('Toyota')
print e

# NOTE: now e['Cars'] == ['Toyota', 'Honda', 'BMW', 'Toyota']
e['Cars'].remove('Toyota')
print e
# NOTE: it's still true that ('Toyota' in e['Cars'])

J'utilise fréquemment setdefault quand, obtenez ceci, en définissant une valeur par défaut (!!!) dans un dictionnaire; un peu communément le dictionnaire os.environ:

# Set the venv dir if it isn't already overridden:
os.environ.setdefault('VENV_DIR', '/my/default/path')

Moins succinctement, cela ressemble à ceci:

# Set the venv dir if it isn't already overridden:
if 'VENV_DIR' not in os.environ:
    os.environ['VENV_DIR'] = '/my/default/path')

Il est à noter que vous pouvez également utiliser la variable résultante:

venv_dir = os.environ.setdefault('VENV_DIR', '/my/default/path')

Mais c'est moins nécessaire qu'avant l'existence des defaultdicts.

Un autre cas d'utilisation que je ne pense pas a été mentionné ci-dessus. Parfois, vous gardez un cache des objets par leur identifiant où l'instance principale est dans le cache et vous voulez définir le cache en cas d'absence.

return self.objects_by_id.setdefault(obj.id, obj)

C'est utile lorsque vous souhaitez toujours conserver une seule instance par identifiant distinct, quelle que soit la manière dont vous obtenez un objet à chaque fois. Par exemple, lorsque les attributs d'objet sont mis à jour en mémoire et que l'enregistrement dans le stockage est différé.

Un cas d'utilisation très important sur dict.setdefault()lequel je viens de tomber: il est idéal pour le code multi-thread lorsque vous ne voulez qu'un seul objet canonique (par opposition à plusieurs objets qui se trouvent être égaux).

Par exemple, (Int)FlagEnum dans Python 3.6.0 a un bogue : si plusieurs threads sont en concurrence pour un (Int)Flagmembre composite , il peut y en avoir plus d'un:

from enum import IntFlag, auto
import threading

class TestFlag(IntFlag):
    one = auto()
    two = auto()
    three = auto()
    four = auto()
    five = auto()
    six = auto()
    seven = auto()
    eight = auto()

    def __eq__(self, other):
        return self is other

    def __hash__(self):
        return hash(self.value)

seen = set()

class cycle_enum(threading.Thread):
    def run(self):
        for i in range(256):
            seen.add(TestFlag(i))

threads = []
for i in range(8):
    threads.append(cycle_enum())

for t in threads:
    t.start()

for t in threads:
    t.join()

len(seen)
# 272  (should be 256)

La solution consiste à utiliser setdefault()comme dernière étape de sauvegarde du membre composite calculé - si un autre a déjà été enregistré, il est utilisé à la place du nouveau, garantissant des membres Enum uniques.

[Modifier] Très faux! Le setdefault déclencherait toujours long_computation, Python étant impatient.

Développant la réponse de Tuttle. Pour moi, le meilleur cas d'utilisation est le mécanisme de cache. Au lieu de:

if x not in memo:
   memo[x]=long_computation(x)
return memo[x]

qui consomme 3 lignes et 2 ou 3 recherches, j'écrirais volontiers :

return memo.setdefault(x, long_computation(x))

J'aime la réponse donnée ici:

http://stupidpythonideas.blogspot.com/2013/08/defaultdict-vs-setdefault.html

En bref, la décision (dans les applications non critiques pour les performances) doit être prise en fonction de la manière dont vous souhaitez gérer la recherche de clés vides en aval (à savoir KeyError par rapport à la valeur par défaut).

Le cas d'utilisation différent setdefault()est celui où vous ne souhaitez pas écraser la valeur d'une clé déjà définie. defaultdictécrase, alors que setdefault()ne le fait pas. Pour les dictionnaires imbriqués, il est plus fréquent que vous souhaitiez définir une valeur par défaut uniquement si la clé n'est pas encore définie, car vous ne souhaitez pas supprimer le sous-dictionnaire actuel. C'est à ce moment que vous utilisez setdefault().

Exemple avec defaultdict:

>>> from collection import defaultdict()
>>> foo = defaultdict()
>>> foo['a'] = 4
>>> foo['a'] = 2
>>> print(foo)
defaultdict(None, {'a': 2})

setdefault n'écrase pas:

>>> bar = dict()
>>> bar.setdefault('a', 4)
>>> bar.setdefault('a', 2)
>>> print(bar)
{'a': 4}