Ich habe die Beispiele in Python-Dokumenten gelesen, kann aber immer noch nicht herausfinden, was diese Methode bedeutet. Kann jemand helfen? Hier sind zwei Beispiele aus der Python-Dokumentation

>>> from collections import defaultdict

>>> s="mississippi"
>>> d = defaultdict(int)
>>> for k in s:
...     d[k] += 1
...
>>> d.items()
dict_items([('m', 1), ('i', 4), ('s', 4), ('p', 2)])

Und

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

Die Parameter int Und list sind für was?

Normalerweise wirft ein Python-Wörterbuch a KeyError wenn Sie versuchen, ein Element mit einem Schlüssel abzurufen, der sich derzeit nicht im Wörterbuch befindet. Der defaultdict im Gegensatz dazu werden einfach alle Elemente erstellt, auf die Sie zugreifen möchten (vorausgesetzt natürlich, sie existieren noch nicht). Um ein solches “Standard”-Element zu erstellen, ruft es das Funktionsobjekt auf, das Sie an den Konstruktor übergeben (genauer gesagt, es ist ein beliebiges “aufrufbares” Objekt, das Funktions- und Typobjekte enthält). Für das erste Beispiel werden Standardelemente mit erstellt int()die das Integer-Objekt zurückgibt 0. Für das zweite Beispiel werden Standardelemente mit erstellt list()die ein neues leeres Listenobjekt zurückgibt.

defaultdict bedeutet, wenn ein Schlüssel nicht im Wörterbuch gefunden wird, dann statt a KeyError geworfen wird, wird ein neuer Eintrag erstellt. Der Typ dieses neuen Eintrags wird durch das Argument von defaultdict angegeben.

Zum Beispiel:

somedict = {}
print(somedict[3]) # KeyError

someddict = defaultdict(int)
print(someddict[3]) # print int(), thus 0

Versäumnis

“Das Standardwörterbuch enthält die Methode setdefault() zum Abrufen eines Werts und zum Festlegen eines Standardwerts, wenn der Wert nicht existiert. Im Gegensatz dazu defaultdict lässt den Aufrufer den Standardwert (zurückzugebender Wert) im Voraus angeben, wenn der Container initialisiert wird.”

wie definiert durch Doug Hellmann In Die Python-Standardbibliothek am Beispiel

So verwenden Sie defaultdict

defaultdict importieren

>>> from collections import defaultdict

defaultdict initialisieren

Initialisieren Sie es durch Übergeben

Callable als erstes Argument (obligatorisch)

>>> 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 als zweites Argument (optional)

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

oder

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

Wie funktioniert es

Da es sich um eine untergeordnete Klasse des Standardwörterbuchs handelt, kann es dieselben Funktionen ausführen.

Aber wenn ein unbekannter Schlüssel übergeben wird, wird der Standardwert anstelle eines Fehlers zurückgegeben. Zum Beispiel:

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

Falls Sie den Standardwert ändern möchten, überschreiben Sie 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})

oder

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

Beispiele in der Frage

Beispiel 1

Da int als default_factory übergeben wurde, gibt jeder unbekannte Schlüssel standardmäßig 0 zurück.

Wenn die Zeichenfolge nun in der Schleife übergeben wird, wird die Anzahl dieser Alphabete in d erhöht.

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

Beispiel 2

Da eine Liste als default_factory übergeben wurde, wird jeder unbekannte (nicht vorhandene) Schlüssel zurückgegeben [ ](d. h. Liste) standardmäßig.

Wenn nun die Liste der Tupel in der Schleife übergeben wird, wird der Wert in d angehängt[color]

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

Wörterbücher sind eine bequeme Möglichkeit, Daten für den späteren Abruf nach Namen (Schlüssel) zu speichern. Schlüssel müssen eindeutige, unveränderliche Objekte sein und sind normalerweise Zeichenfolgen. Die Werte in einem Wörterbuch können beliebig sein. Bei vielen Anwendungen handelt es sich bei den Werten um einfache Typen wie Ganzzahlen und Zeichenfolgen.

Interessanter wird es, wenn die Werte in einem Wörterbuch Sammlungen sind (Listen, Diktate usw.). In diesem Fall muss der Wert (eine leere Liste oder ein leeres Diktat) initialisiert werden, wenn ein bestimmter Schlüssel zum ersten Mal verwendet wird. Während dies manuell relativ einfach zu bewerkstelligen ist, automatisiert und vereinfacht der Typ defaultdict diese Art von Vorgängen. Ein defaultdict funktioniert genauso wie ein normales dict, aber es wird mit einer Funktion („default factory“) initialisiert, die keine Argumente akzeptiert und den Standardwert für einen nicht vorhandenen Schlüssel bereitstellt.

Ein Defaultdict wird niemals einen KeyError auslösen. Jeder Schlüssel, der nicht vorhanden ist, erhält den Wert, der von der Standardfabrik zurückgegeben wird.

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

Hier ist ein weiteres Beispiel dafür, wie wir mit defaultdict die Komplexität reduzieren können

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

Wenn Sie also ein Wörterbuch benötigen und der Wert jedes Elements mit einem Standardwert beginnen sollte, verwenden Sie ein defaultdict.

Hier gibt es eine großartige Erklärung für defaultdicts: http://ludovf.net/blog/python-collections-defaultdict/

Grundsätzlich die Parameter int Und Liste sind Funktionen, die Sie übergeben. Denken Sie daran, dass Python Funktionsnamen als Argumente akzeptiert. int gibt standardmäßig 0 zurück und Liste gibt eine leere Liste zurück, wenn sie mit Klammern aufgerufen wird.

In normalen Wörterbüchern, wenn ich in Ihrem Beispiel versuche, anzurufen d[a], erhalte ich einen Fehler (KeyError), da nur die Schlüssel m, s, i und p existieren und der Schlüssel a nicht initialisiert wurde. Aber in einem Defaultdict nimmt es einen Funktionsnamen als Argument, wenn Sie versuchen, eine Taste zu verwenden, die nicht initialisiert wurde, ruft es einfach die übergebene Funktion auf und weist ihren Rückgabewert als Wert der neuen Taste zu.

Das Verhalten von defaultdict kann leicht nachgeahmt werden dict.setdefault anstatt d[key] bei jedem Anruf.

Mit anderen Worten, der Code:

from collections import defaultdict

d = defaultdict(list)

print(d['key'])                        # empty list []
d['key'].append(1)                     # adding constant 1 to the list
print(d['key'])                        # list containing the constant [1]

ist äquivalent zu:

d = dict()

print(d.setdefault('key', list()))     # empty list []
d.setdefault('key', list()).append(1)  # adding constant 1 to the list
print(d.setdefault('key', list()))     # list containing the constant [1]

Der einzige Unterschied ist, dass mit defaultdictder Listenkonstruktor wird nur einmal aufgerufen und mit dict.setdefault Der Listenkonstruktor wird häufiger aufgerufen (aber der Code kann umgeschrieben werden, um dies zu vermeiden, falls dies wirklich erforderlich ist).

Einige mögen argumentieren, dass es eine Leistungsbetrachtung gibt, aber dieses Thema ist ein Minenfeld. Dieser Beitrag zeigt, dass beispielsweise die Verwendung von defaultdict keinen großen Leistungsgewinn bringt.

IMO, defaultdict ist eine Sammlung, die dem Code mehr Verwirrung als Nutzen bringt. Für mich unbrauchbar, aber andere mögen das anders sehen.

Da es um die Frage geht, “wie es funktioniert”, möchten einige Leser vielleicht mehr Schrauben und Muttern sehen. Konkret handelt es sich um die fragliche Methode __missing__(key) Methode. Sehen: https://docs.python.org/2/library/collections.html#defaultdict-objects .

Konkret zeigt diese Antwort, wie man sie nutzt __missing__(key) auf praktische Weise: https://stackoverflow.com/a/17956989/1593924

Um zu verdeutlichen, was „aufrufbar“ bedeutet, hier eine interaktive Sitzung (ab 2.7.6, sollte aber auch in v3 funktionieren):

>>> x = int
>>> x
<type 'int'>
>>> y = int(5)
>>> y
5
>>> z = x(5)
>>> z
5

>>> from collections import defaultdict
>>> dd = defaultdict(int)
>>> dd
defaultdict(<type 'int'>, {})
>>> dd = defaultdict(x)
>>> dd
defaultdict(<type 'int'>, {})
>>> dd['a']
0
>>> dd
defaultdict(<type 'int'>, {'a': 0})

Das war die typischste Verwendung von defaultdict (abgesehen von der sinnlosen Verwendung der x-Variablen). Sie können dasselbe mit 0 als explizitem Standardwert tun, aber nicht mit einem einfachen Wert:

>>> dd2 = defaultdict(0)

Traceback (most recent call last):
  File "<pyshell#7>", line 1, in <module>
    dd2 = defaultdict(0)
TypeError: first argument must be callable

Stattdessen funktioniert Folgendes, weil es eine einfache Funktion übergibt (es erstellt spontan eine namenlose Funktion, die keine Argumente akzeptiert und immer 0 zurückgibt):

>>> dd2 = defaultdict(lambda: 0)
>>> dd2
defaultdict(<function <lambda> at 0x02C4C130>, {})
>>> dd2['a']
0
>>> dd2
defaultdict(<function <lambda> at 0x02C4C130>, {'a': 0})
>>> 

Und mit einem anderen Standardwert:

>>> dd3 = defaultdict(lambda: 1)
>>> dd3
defaultdict(<function <lambda> at 0x02C4C170>, {})
>>> dd3['a']
1
>>> dd3
defaultdict(<function <lambda> at 0x02C4C170>, {'a': 1})
>>>