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 den Python-Dokumenten

>>> from collections import defaultdict

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

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 intund listsind für was?

Normalerweise löst ein Python-Wörterbuch ein aus, KeyErrorwenn Sie versuchen, ein Element mit einem Schlüssel abzurufen, der sich derzeit nicht im Wörterbuch befindet. Im defaultdictGegensatz dazu werden einfach alle Elemente erstellt, auf die Sie zugreifen möchten (vorausgesetzt, sie sind natürlich noch nicht vorhanden). 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). Im ersten Beispiel werden Standardelemente mit erstellt int(), die das ganzzahlige Objekt zurückgeben 0. Im zweiten Beispiel werden Standardelemente mit erstellt list(), die ein neues leeres Listenobjekt zurückgeben.

defaultdictbedeutet, dass, wenn ein Schlüssel nicht im Wörterbuch gefunden wird, anstelle eines KeyErrorgeworfenen Schlüssels ein neuer Eintrag erstellt wird. Der Typ dieses neuen Eintrags wird durch das Argument defaultdict angegeben.

Zum Beispiel:

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

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

defaultdict

"Das Standardwörterbuch enthält die Methode setdefault () zum Abrufen eines Werts und zum Festlegen eines Standardwerts, wenn der Wert nicht vorhanden ist. Im Gegensatz dazu kann defaultdictder Aufrufer den Standardwert (den zurückzugebenden Wert) vorab angeben, wenn der Container initialisiert wird."

wie von Doug Hellmann in The Python Standard Library by Example definiert

Verwendung von defaultdict

Standarddict importieren

>>> from collections import defaultdict

Standarddict initialisieren

Initialisieren Sie es durch Übergeben

als erstes Argument aufrufbar (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

Wie eine untergeordnete Klasse des Standardwörterbuchs kann sie dieselben Funktionen ausführen.

Bei Übergabe eines unbekannten Schlüssels wird jedoch anstelle eines Fehlers der Standardwert 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})

Wenn 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 der String nun in der Schleife übergeben wird, erhöht sich die Anzahl dieser Alphabete in 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})

Beispiel 2

Da eine Liste als default_factory übergeben wurde, gibt jeder unbekannte (nicht vorhandene) Schlüssel standardmäßig [] (dh Liste) zurück.

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

>>> 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. Für viele Anwendungen sind die Werte einfache Typen wie Ganzzahlen und Zeichenfolgen.

Interessanter wird es, wenn die Werte in einem Wörterbuch Sammlungen (Listen, Diktate usw.) sind. In diesem Fall muss der Wert (eine leere Liste oder ein Diktat) bei der ersten Verwendung eines bestimmten Schlüssels initialisiert werden. Während dies manuell relativ einfach ist, automatisiert und vereinfacht der Standarddict-Typ diese Art von Vorgängen. Ein Standarddikt funktioniert genau wie ein normales Diktat, wird jedoch mit einer Funktion („Standardfactory“) initialisiert, die keine Argumente akzeptiert und den Standardwert für einen nicht vorhandenen Schlüssel bereitstellt.

Ein Standarddikt löst niemals einen KeyError aus. Jeder nicht vorhandene Schlüssel erhält den von der Standardfactory zurückgegebenen Wert.

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, 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 ein Wörterbuch benötigen und der Wert jedes Elements mit einem Standardwert beginnen sollte, verwenden Sie abschließend ein Standarddiktat.

Hier finden Sie eine gute Erklärung für Standardverbote: http://ludovf.net/blog/python-collections-defaultdict/

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

Wenn ich in normalen Wörterbüchern in Ihrem Beispiel versuche aufzurufen d[a], wird eine Fehlermeldung (KeyError) angezeigt, da nur die Schlüssel m, s, i und p vorhanden sind und der Schlüssel a nicht initialisiert wurde. In einem Standarddikt wird jedoch ein Funktionsname als Argument verwendet. Wenn Sie versuchen, einen Schlüssel zu verwenden, der nicht initialisiert wurde, ruft er einfach die übergebene Funktion auf und weist ihren Rückgabewert als Wert des neuen Schlüssels zu.

Da es um "wie es funktioniert" geht, möchten einige Leser vielleicht mehr Schrauben und Muttern sehen. Insbesondere ist die fragliche __missing__(key)Methode die Methode. Siehe: https://docs.python.org/2/library/collections.html#defaultdict-objects .

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

Um zu verdeutlichen, was "aufrufbar" bedeutet, folgt eine interaktive Sitzung (ab 2.7.6, sollte aber auch in Version 3 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})

Dies war die typischste Verwendung von defaultdict (mit Ausnahme der sinnlosen Verwendung der Variablen x). Sie können dasselbe mit 0 als expliziten Standardwert tun, jedoch 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 im laufenden Betrieb 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})
>>> 

Meine eigene 2 ¢: Sie können auch defaultdict unterordnen:

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

Dies kann in sehr komplexen Fällen nützlich sein.

Das Verhalten von defaultdictkann leicht nachgeahmt werden, dict.setdefaultanstatt 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 besteht darin, dass der Listenkonstruktor bei defaultdictVerwendung nur einmal aufgerufen wird und die Verwendung dict.setdefaultdes Listenkonstruktors häufiger aufgerufen wird (der Code kann jedoch möglicherweise neu geschrieben werden, um dies zu vermeiden, falls dies wirklich erforderlich ist).

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

IMO, defaultdict ist eine Sammlung, die dem Code mehr Verwirrung als Vorteile bringt. Für mich nutzlos, aber andere denken vielleicht anders.

Das defaultdict-Tool ist ein Container in der Sammlungsklasse von Python. Es ähnelt dem üblichen Wörterbuchcontainer (dict), hat jedoch einen Unterschied: Der Datentyp der Wertefelder wird bei der Initialisierung angegeben.

Zum Beispiel:

from collections import defaultdict

d = defaultdict(list)

d['python'].append("awesome")

d['something-else'].append("not relevant")

d['python'].append("language")

for i in d.items():

    print i

Dies druckt:

('python', ['awesome', 'language'])
('something-else', ['not relevant'])

Ich denke, es wird am besten anstelle einer switch case-Anweisung verwendet. Stellen Sie sich vor, wir haben eine Switch-Case-Anweisung wie folgt:

option = 1

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

switchIn Python sind keine case-Anweisungen verfügbar. Wir können das gleiche erreichen, indem wir verwenden 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])

Es druckt:

Default Value
Default Value
3rd option

Im obigen Snippet ddgibt es keine Tasten 4 oder 5 und daher wird ein Standardwert ausgedruckt, den wir in einer Hilfsfunktion konfiguriert haben. Dies ist viel schöner als ein Rohwörterbuch, bei dem a KeyErrorausgelöst wird, wenn der Schlüssel nicht vorhanden ist. Daraus ergibt sich, dass es sich defaultdicteher um eine Switch-Case-Anweisung handelt, bei der komplizierte if-elif-elif-elseBlöcke vermieden werden können.

Ein weiteres gutes Beispiel, das mich auf dieser Website sehr beeindruckt hat, ist:

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

Wenn wir versuchen , alle Elemente für den Zugriff auf andere als eggsund spamwir werden eine Anzahl von 0 erhalten.

Ohne defaultdictkönnen Sie möglicherweise unsichtbaren Schlüsseln neue Werte zuweisen, diese jedoch nicht ändern. Zum Beispiel:

import collections
d = collections.defaultdict(int)
for i in range(10):
  d[i] += i
print(d)
# Output: defaultdict(<class 'int'>, {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9})

import collections
d = {}
for i in range(10):
  d[i] += i
print(d)
# Output: Traceback (most recent call last): File "python", line 4, in <module> KeyError: 0

Nun, defaultdict kann im folgenden Fall auch den Schlüsselfehler erhöhen:

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

Denken Sie immer daran, dem defaultdict wie defaultdict (int) Argumente zu geben.

Das Standardwörterbuch enthält die Methode setdefault () zum Abrufen eines Werts und zum Festlegen eines Standards, wenn der Wert nicht vorhanden ist. Im Gegensatz dazu kann der Anrufer mit defaultdict die Standardeinstellung im Voraus festlegen, wenn der Container initialisiert wird.

import collections

def default_factory():
    return 'default value'

d = collections.defaultdict(default_factory, foo='bar')
print 'd:', d
print 'foo =>', d['foo']
print 'bar =>', d['bar']

Dies funktioniert gut, solange alle Schlüssel dieselbe Standardeinstellung haben. Dies kann besonders nützlich sein, wenn der Standard ein Typ ist, der zum Aggregieren oder Akkumulieren von Werten verwendet wird, z. B. eine Liste, eine Menge oder sogar int. Die Standardbibliotheksdokumentation enthält mehrere Beispiele für die Verwendung von defaultdict auf diese Weise.

$ python collections_defaultdict.py

d: defaultdict(<function default_factory at 0x100468c80>, {'foo': 'bar'})
foo => bar
bar => default value

Zusamenfassend:

defaultdict(int) - Das Argument int gibt an, dass die Werte vom Typ int sind.

defaultdict(list) - Die Argumentliste gibt an, dass die Werte vom Listentyp sind.

Die Dokumentation und die Erklärung sind ziemlich selbsterklärend:

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

Die als Argument übergebene Typfunktion (int / str usw.) wird verwendet, um einen Standardwert für einen bestimmten Schlüssel zu initialisieren, bei dem der Schlüssel im Diktat nicht vorhanden ist.