Comment les collections.defaultdict travail?

Généralement, un dictionnaire Python jette un KeyError si vous essayez d'obtenir un produit avec une clé qui n'est pas actuellement dans le dictionnaire. Le defaultdict en revanche il suffit de créer tous les éléments que vous tentez d'accéder (à condition bien sûr qu'ils n'existent pas encore). Pour créer un tel "défaut" de l'élément, il appelle la fonction de l'objet que vous passer au constructeur (plus précisément, c'est l'arbitraire d'un "callable" objet, qui inclut la fonction et le type d'objets). Pour le premier exemple, par défaut, les éléments sont créés à l'aide de int(), qui sera de retour l'objet integer 0. Pour le deuxième exemple, par défaut, les éléments sont créés à l'aide de list(), qui renvoie une nouvelle liste vide de l'objet.

defaultdict

"Le dictionnaire standard comprend la méthode setdefault() pour récupérer une valeur et d'établir une valeur par défaut si la valeur n'existe pas. En revanche, defaultdict permet à l'appelant de spécifier la valeur par défaut(valeur renvoyée) à l'avant lorsque le conteneur est initialisé."

tel que défini par Doug Hellmann dans Le Python Standard Library par Exemple

Comment utiliser defaultdict

Importation defaultdict

>>> from collections import defaultdict

Initialiser defaultdict

Initialiser en passant

callable que son premier argument(obligatoire)

>>> d_int = defaultdict(int)
>>> d_list = defaultdict(list)
>>> def foo():
...     return 'default value'
... 
>>> d_foo = defaultdict(foo)
>>> d_int
defaultdict(<type 'int'>, {})
>>> d_list
defaultdict(<type 'list'>, {})
>>> d_foo
defaultdict(<function foo at 0x7f34a0a69578>, {})

**kwargs comme deuxième argument(facultatif)

>>> d_int = defaultdict(int, a=10, b=12, c=13)
>>> d_int
defaultdict(<type 'int'>, {'a': 10, 'c': 13, 'b': 12})

ou

>>> kwargs = {'a':10,'b':12,'c':13}
>>> d_int = defaultdict(int, **kwargs)
>>> d_int
defaultdict(<type 'int'>, {'a': 10, 'c': 13, 'b': 12})

Comment ça fonctionne

Comme c'est un enfant de la classe de dictionnaire standard, il peut effectuer les mêmes fonctions.

Mais en cas de passage d'un inconnu clé, il retourne la valeur par défaut au lieu de l'erreur. Ex:

>>> d_int['a']
10
>>> d_int['d']
0
>>> d_int
defaultdict(<type 'int'>, {'a': 10, 'c': 13, 'b': 12, 'd': 0})

Dans le cas où vous souhaitez modifier la valeur par défaut remplacer default_factory:

>>> d_int.default_factory = lambda: 1
>>> d_int['e']
1
>>> d_int
defaultdict(<function <lambda> at 0x7f34a0a91578>, {'a': 10, 'c': 13, 'b': 12, 'e': 1, 'd': 0})

ou

>>> def foo():
...     return 2
>>> d_int.default_factory = foo
>>> d_int['f']
2
>>> d_int
defaultdict(<function foo at 0x7f34a0a0a140>, {'a': 10, 'c': 13, 'b': 12, 'e': 1, 'd': 0, 'f': 2})

Exemples dans la Question

Exemple 1

Comme int a été adoptée comme default_factory, tout inconnu clé return 0 par défaut.

Maintenant que la chaîne est passée dans la boucle, il faudra augmenter le nombre de ces lettres de l'alphabet. d.

>>> s = 'mississippi'
>>> d = defaultdict(int)
>>> d.default_factory
<type 'int'>
>>> for k in s:
...     d[k] += 1
>>> d.items()
[('i', 4), ('p', 2), ('s', 4), ('m', 1)]
>>> d
defaultdict(<type 'int'>, {'i': 4, 'p': 2, 's': 4, 'm': 1})

Exemple 2

Qu'une liste a été adoptée comme default_factory, tout inconnu(inexistante) de la clé sera de retour [ ](ie. liste) par défaut.

Maintenant que la liste de tuples est passé dans la boucle, il va ajouter de la valeur dans le d[couleur]

>>> s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
>>> d = defaultdict(list)
>>> d.default_factory
<type 'list'>
>>> for k, v in s:
...     d[k].append(v)
>>> d.items()
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]
>>> d
defaultdict(<type 'list'>, {'blue': [2, 4], 'red': [1], 'yellow': [1, 3]})

Les dictionnaires sont un moyen pratique pour stocker des données pour une récupération ultérieure par nom (clé). Les clés doivent être uniques, des objets immuables, et sont généralement des chaînes. Les valeurs dans un dictionnaire peut être n'importe quoi. Pour de nombreuses applications, les valeurs sont des types simples comme des entiers et des chaînes de caractères.

Il devient plus intéressant lorsque les valeurs dans un dictionnaire sont des collections (listes, dicts, etc.) Dans ce cas, la valeur (une liste vide ou dict) doit être initialisé la première fois qu'une clé est utilisée. Tout cela est relativement facile de le faire manuellement, le defaultdict type automatise et simplifie ces types d'opérations.
Un defaultdict fonctionne exactement comme un normal dict, mais il est initialisé avec une fonction (“par défaut”) qui ne prend pas d'arguments et fournit la valeur par défaut pour une clé inexistante.

Un defaultdict ne suscitera jamais un KeyError. Une touche qui n'existe pas obtient la valeur retournée par la valeur par défaut d'usine.

from collections import defaultdict
ice_cream = defaultdict(lambda: 'Vanilla')

ice_cream['Sarah'] = 'Chunky Monkey'
ice_cream['Abdul'] = 'Butter Pecan'

print(ice_cream['Sarah'])
>>>Chunky Monkey

print(ice_cream['Joe'])
>>>Vanilla

Voici un autre exemple sur la Façon dont l'aide defaultdict, nous pouvons réduire la complexité

from collections import defaultdict
# Time complexity O(n^2)
def delete_nth_naive(array, n):
    ans = []
    for num in array:
        if ans.count(num) < n:
            ans.append(num)
    return ans

# Time Complexity O(n), using hash tables.
def delete_nth(array,n):
    result = []
    counts = defaultdict(int)

    for i in array:
        if counts[i] < n:
            result.append(i)
            counts[i] += 1
    return result


x = [1,2,3,1,2,1,2,3]
print(delete_nth(x, n=2))
print(delete_nth_naive(x, n=2))

En conclusion, toutes les fois que vous besoin d'un dictionnaire, et chaque valeur de l'élément doit commencer avec une valeur par défaut, utilisez un defaultdict.

Mon propre 2¢: vous pouvez également sous-classe defaultdict:

class MyDict(defaultdict):
    def __missing__(self, key):
        value = [None, None]
        self[key] = value
        return value

Cela pourrait venir dans maniable pour les cas très complexes.

Je pense que c'est mieux utilisé à la place d'un interrupteur de cas. Imaginez si nous avons un interrupteur cas énoncé ci-dessous:

option = 1

switch(option) {
    case 1: print '1st option'
    case 2: print '2nd option'
    case 3: print '3rd option'
    default: return 'No such option'
}

Il n'y a pas de switch cas relevés disponibles en python. Nous pouvons réaliser la même chose en utilisant defaultdict.

from collections import defaultdict

def default_value(): return "Default Value"
dd = defaultdict(default_value)

dd[1] = '1st option'
dd[2] = '2nd option'
dd[3] = '3rd option'

print(dd[4])    
print(dd[5])    
print(dd[3])

Il imprime:

Default Value
Default Value
3rd option

Dans l'extrait ci-dessus dd n'a pas de touches 4 ou 5, et donc il imprime une valeur par défaut qui nous avons configuré dans une fonction d'assistance. C'est bien plus agréable que les raw d'un dictionnaire où un KeyError est levée si la clé n'est pas présente. De ce fait, il est évident que defaultdict plus comme un commutateur de cas où l'on peut éviter pas compliqué if-elif-elif-else blocs.

Un bon exemple qui m'a beaucoup impressionné de ce site est:

>>> from collections import defaultdict
>>> food_list = 'spam spam spam spam spam spam eggs spam'.split()
>>> food_count = defaultdict(int) # default value of int is 0
>>> for food in food_list:
...     food_count[food] += 1 # increment element's value by 1
...
defaultdict(<type 'int'>, {'eggs': 1, 'spam': 7})
>>>

Si nous essayons d'accéder à tous les éléments autres que eggs et spam nous aurons un nombre de 0.

Bien, defaultdict peut aussi soulever des keyerror dans le cas suivant:

    from collections import defaultdict
    d = defaultdict()
    print(d[3]) #raises keyerror

Toujours n'oubliez pas de donner des arguments à la defaultdict comme defaultdict(int).

En bref:

defaultdict(int) - l'argument de type int indique que les valeurs de type int.

defaultdict(list) - la liste des arguments indique que les valeurs sont de type liste.

La documentation et les explications sont assez explicites:

http://docs.python.org/library/collections.html#collections.defaultdict

Le type de la fonction(int/str etc.) passée en argument est utilisé pour initialiser une valeur par défaut pour chaque clé où la clé n'est pas présente dans le dict.