Warum dict.get(key) statt dict[key]?

Heute bin ich auf die gestoßen dict Methode get die bei einem Schlüssel im Wörterbuch den zugehörigen Wert zurückgibt.

Für welchen Zweck ist diese Funktion sinnvoll? Wenn ich einen Wert finden möchte, der einem Schlüssel in einem Wörterbuch zugeordnet ist, kann ich das einfach tun dict[key]und es gibt dasselbe zurück:

dictionary = {"Name": "Harry", "Age": 17}
dictionary["Name"]
dictionary.get("Name")

Es ermöglicht Ihnen, einen Standardwert anzugeben, wenn der Schlüssel fehlt:

dictionary.get("bogus", default_value)

kehrt zurück default_value (was auch immer Sie wählen), während

dictionary["bogus"]

würde a erhöhen KeyError.

Wenn weggelassen, default_value ist Noneso dass

dictionary.get("bogus")  # <-- No default specified -- defaults to None

kehrt zurück None so wie

dictionary.get("bogus", None)

möchten.

Was ist der dict.get() Methode?

Wie bereits erwähnt die get -Methode enthält einen zusätzlichen Parameter, der den fehlenden Wert angibt. Aus der Dokumentation

get(key[, default])

Gibt den Wert für Schlüssel zurück, wenn Schlüssel im Wörterbuch ist, sonst Standard. Wenn default nicht angegeben ist, wird standardmäßig None verwendet, sodass diese Methode niemals a auslöst KeyError.

Ein Beispiel kann sein

>>> d = {1:2,2:3}
>>> d[1]
2
>>> d.get(1)
2
>>> d.get(3)
>>> repr(d.get(3))
'None'
>>> d.get(3,1)
1

Gibt es irgendwo Geschwindigkeitsverbesserungen?

Wie erwähnt hier,

Es scheint, dass alle drei Ansätze jetzt eine ähnliche Leistung aufweisen (innerhalb von etwa 10 % voneinander), mehr oder weniger unabhängig von den Eigenschaften der Wortliste.

Vorhin get war erheblich langsamer, aber jetzt ist die Geschwindigkeit fast vergleichbar mit dem zusätzlichen Vorteil, dass der Standardwert zurückgegeben wird. Aber um alle unsere Abfragen zu löschen, können wir mit einer ziemlich großen Liste testen (Beachten Sie, dass der Test nur das Nachschlagen aller gültigen Schlüssel umfasst).

def getway(d):
    for i in range(100):
        s = d.get(i)

def lookup(d):
    for i in range(100):
        s = d[i]

Verwenden Sie nun das Timing dieser beiden Funktionen timeit

>>> import timeit
>>> print(timeit.timeit("getway({i:i for i in range(100)})","from __main__ import getway"))
20.2124660015
>>> print(timeit.timeit("lookup({i:i for i in range(100)})","from __main__ import lookup"))
16.16223979

Wie wir sehen können, ist die Suche schneller als die Get-Funktion, da es keine Funktionssuche gibt. Das kann man durchschauen dis

>>> def lookup(d,val):
...     return d[val]
... 
>>> def getway(d,val):
...     return d.get(val)
... 
>>> dis.dis(getway)
  2           0 LOAD_FAST                0 (d)
              3 LOAD_ATTR                0 (get)
              6 LOAD_FAST                1 (val)
              9 CALL_FUNCTION            1
             12 RETURN_VALUE        
>>> dis.dis(lookup)
  2           0 LOAD_FAST                0 (d)
              3 LOAD_FAST                1 (val)
              6 BINARY_SUBSCR       
              7 RETURN_VALUE  

Wo wird es nützlich sein?

Es ist nützlich, wenn Sie beim Nachschlagen in einem Wörterbuch einen Standardwert angeben möchten. Dies reduziert

 if key in dic:
      val = dic[key]
 else:
      val = def_val

Zu einer einzigen Zeile, val = dic.get(key,def_val)

Wo wird es NICHT nützlich sein?

Wann immer Sie a zurückgeben möchten KeyError mit der Angabe, dass der bestimmte Schlüssel nicht verfügbar ist. Die Rückgabe eines Standardwerts birgt auch das Risiko, dass ein bestimmter Standardwert auch ein Schlüssel sein kann!

Ist es möglich zu haben get wie Funktion in dict['key']?

Ja! Wir müssen die umsetzen __missing__ in einer dict-Unterklasse.

Ein Beispielprogramm kann sein

class MyDict(dict):
    def __missing__(self, key):
        return None

Eine kleine Vorführung kann sein

>>> my_d = MyDict({1:2,2:3})
>>> my_d[1]
2
>>> my_d[3]
>>> repr(my_d[3])
'None'

get nimmt einen zweiten optionalen Wert an. Wenn der angegebene Schlüssel in Ihrem Wörterbuch nicht vorhanden ist, wird dieser Wert zurückgegeben.

dictionary = {"Name": "Harry", "Age": 17}
dictionary.get('Year', 'No available data')
>> 'No available data'

Wenn Sie den zweiten Parameter nicht angeben, None Wird zurückgegeben.

Wenn Sie die Indizierung wie in verwenden dictionary['Year']werden nicht vorhandene Tasten ausgelöst KeyError.

Ein Fallstrick, den Sie bei der Verwendung beachten sollten .get():

Wenn das Wörterbuch den im Aufruf verwendeten Schlüssel enthält .get() und sein Wert ist Nonedas .get() Methode wird zurückgegeben None auch wenn ein Standardwert angegeben ist.

Beispielsweise werden die folgenden zurückgegeben Nonenicht 'alt_value' wie zu erwarten:

d = {'key': None}
assert None is d.get('key', 'alt_value')

.get()Der zweite Wert von wird nur zurückgegeben, wenn der angegebene Schlüssel NICHT im Wörterbuch enthalten ist, nicht, wenn der Rückgabewert dieses Aufrufs vorhanden ist None.

Ich werde ein praktisches Beispiel für das Scraping von Webdaten mit Python geben. Oftmals erhalten Sie Schlüssel ohne Werte, in diesen Fällen erhalten Sie Fehler, wenn Sie ein Wörterbuch verwenden[‘key’]während dictionary.get(‘key’, ‘return_otherwise’) keine Probleme hat.

Ebenso würde ich ”.join(list) im Gegensatz zu list verwenden[0] wenn Sie versuchen, einen einzelnen Wert aus einer Liste zu erfassen.

ich hoffe es hilft.

[Edit] Hier ein praktisches Beispiel:

Angenommen, Sie rufen eine API auf, die eine JOSN-Datei zurückgibt, die Sie analysieren müssen. Das erste JSON sieht wie folgt aus:

{"bids":{"id":16210506,"submitdate":"2011-10-16 15:53:25","submitdate_f":"10\/16\/2011 at 21:53 CEST","submitdate_f2":"p\u0159ed 2 lety","submitdate_ts":1318794805,"users_id":"2674360","project_id":"1250499"}}

Der zweite JOSN ist wie folgt:

{"bids":{"id":16210506,"submitdate":"2011-10-16 15:53:25","submitdate_f":"10\/16\/2011 at 21:53 CEST","submitdate_f2":"p\u0159ed 2 lety","users_id":"2674360","project_id":"1250499"}}

Beachten Sie, dass dem zweiten JSON der Schlüssel „submitdate_ts“ fehlt, was in jeder Datenstruktur ziemlich normal ist.

Wenn Sie also versuchen, auf den Wert dieses Schlüssels in einer Schleife zuzugreifen, können Sie ihn folgendermaßen aufrufen:

for item in API_call:
    submitdate_ts = item["bids"]["submitdate_ts"]

Sie könnten, aber es wird Ihnen einen Rückverfolgungsfehler für die zweite JSON-Zeile geben, weil der Schlüssel einfach nicht existiert.

Die geeignete Art, dies zu codieren, könnte die folgende sein:

for item in API_call:
    submitdate_ts = item.get("bids", {'x': None}).get("submitdate_ts")

{‘x’: None} ist da, um zu vermeiden, dass die zweite Ebene einen Fehler bekommt. Natürlich können Sie beim Scraping mehr Fehlertoleranz in den Code einbauen. Wie zuerst die Angabe einer if-Bedingung

Der Zweck ist, dass Sie einen Standardwert angeben können, wenn der Schlüssel nicht gefunden wird, was sehr nützlich ist

dictionary.get("Name",'harry')

Für welchen Zweck ist diese Funktion sinnvoll?

Eine besondere Verwendung ist das Zählen mit einem Wörterbuch. Nehmen wir an, Sie möchten die Anzahl der Vorkommen jedes Elements in einer gegebenen Liste zählen. Der übliche Weg, dies zu tun, besteht darin, ein Wörterbuch zu erstellen, in dem Schlüssel Elemente und Werte die Anzahl der Vorkommen sind.

fruits = ['apple', 'banana', 'peach', 'apple', 'pear']
d = {}
for fruit in fruits:
    if fruit not in d:
        d[fruit] = 0
    d[fruit] += 1

Verwendung der .get() -Methode können Sie diesen Code kompakter und übersichtlicher gestalten:

for fruit in fruits:
    d[fruit] = d.get(fruit, 0) + 1