Beispiele für attrgetter

Das aktuelle Verhalten bleibt unverändert

>>> class C:
...   class D:
...     class X:
...       pass
...   class E:
...     pass
...
>>> attrgetter("D")(C)
<class '__main__.C.D'>
>>> attrgetter("badname")(C)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: type object 'C' has no attribute 'badname'
>>> attrgetter("D", "E")(C)
(<class '__main__.C.D'>, <class '__main__.C.E'>)
>>> attrgetter("D", "badname")(C)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: type object 'C' has no attribute 'badname'
>>> attrgetter("D.X")(C)
<class '__main__.C.D.X'>
>>> attrgetter("D.badname")(C)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: type object 'D' has no attribute 'badname'

Mit diesem PEP, unter Verwendung des vorgeschlagenen default-Schlüsselworts

>>> attrgetter("D", default="noclass")(C)
<class '__main__.C.D'>
>>> attrgetter("badname", default="noclass")(C)
'noclass'
>>> attrgetter("D", "E", default="noclass")(C)
(<class '__main__.C.D'>, <class '__main__.C.E'>)
>>> attrgetter("D", "badname", default="noclass")(C)
(<class '__main__.C.D'>, 'noclass')
>>> attrgetter("D.X", default="noclass")(C)
<class '__main__.C.D.X'>
>>> attrgetter("D.badname", default="noclass")(C)
'noclass'

Beispiele für itemgetter

Das aktuelle Verhalten bleibt unverändert

>>> obj = ["foo", "bar", "baz"]
>>> itemgetter(1)(obj)
'bar'
>>> itemgetter(5)(obj)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>> itemgetter(1, 0)(obj)
('bar', 'foo')
>>> itemgetter(1, 5)(obj)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

Mit diesem PEP, unter Verwendung des vorgeschlagenen default-Schlüsselworts

>>> itemgetter(1, default="XYZ")(obj)
'bar'
>>> itemgetter(5, default="XYZ")(obj)
'XYZ'
>>> itemgetter(1, 0, default="XYZ")(obj)
('bar', 'foo')
>>> itemgetter(1, 5, default="XYZ")(obj)
('bar', 'XYZ')

Beispiele für getitem

Das aktuelle Verhalten bleibt unverändert

>>> obj = ["foo", "bar", "baz"]
>>> getitem(obj, 1)
'bar'
>>> getitem(obj, 5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

Mit diesem PEP, unter Verwendung des vorgeschlagenen zusätzlichen Standardwerts, positionsgebunden oder mit einem Schlüsselwort

>>> getitem(obj, 1, "XYZ")
'bar'
>>> getitem(obj, 5, "XYZ")
'XYZ'
>>> getitem(obj, 1, default="XYZ")
'bar'
>>> getitem(obj, 5, default="XYZ")
'XYZ'

Über mögliche Implementierungen

Die Implementierung von attrgetter ist recht direkt: Sie beinhaltet die Verwendung von getattr und das Abfangen eines möglichen AttributeError. Daher wäre attrgetter("name", default=XYZ)(obj) so etwas wie

try:
    value = getattr(obj, "name")
except AttributeError:
    value = XYZ

Beachten Sie, dass wir uns nicht auf die Verwendung von getattr mit einem Standardwert verlassen können, da es unmöglich wäre zu unterscheiden, was bei jedem Schritt zurückgegeben wurde, wenn eine Attributkette angegeben ist (z. B. attrgetter("foo.bar.baz", default=XYZ)).

Die Implementierung für itemgetter und getitem ist nicht so einfach. Der einfachste Weg ist ebenfalls einfach zu definieren und zu verstehen: Versuchen Sie __getitem__ und fangen Sie eine mögliche Ausnahme ab (siehe unten). Auf diese Weise wäre itemgetter(123, default=XYZ)(obj) oder getitem(obj, 123, default=XYZ) gleichwertig mit

try:
    value = obj[123]
except (IndexError, KeyError):
    value = XYZ

Aus Leistungsgründen kann die Implementierung jedoch eher wie folgt aussehen, was das exakt gleiche Verhalten aufweist

if type(obj) == dict:
    value = obj.get(123, XYZ)
else:
    try:
        value = obj[123]
    except (IndexError, KeyError):
        value = XYZ

Beachten Sie, dass die Überprüfung sich auf den exakten Typ bezieht und nicht isinstance verwendet; dies dient der Sicherstellung des exakten Verhaltens, was unmöglich wäre, wenn das Objekt ein benutzerdefiniertes ist, das von dict erbt, aber get überschreibt (ähnlicher Grund, warum nicht geprüft wird, ob das Objekt eine get-Methode hat).

Auf diese Weise ist die Leistung besser, aber es handelt sich nur um ein Implementierungsdetail, sodass wir die ursprüngliche Erklärung, wie es sich verhält, beibehalten können.

Bezüglich der abzufangenden Ausnahme: Auch wenn __getitem__ IndexError, KeyError oder TypeError auslösen kann (siehe dessen Referenz), können nur die ersten beiden auftreten, wenn der Container den angegebenen Schlüssel oder Index nicht enthält, und letzteres signalisiert wahrscheinlich einen Fehler im Code, daher fangen wir ihn nicht ab, um das Standardverhalten auszulösen.

Grenzfälle

Die Bereitstellung einer default-Option würde nur funktionieren, wenn der Zugriff auf das Element/Attribut im Normalfall fehlschlägt. Mit anderen Worten, das zugegriffene Objekt sollte keine eigenen Standardwerte handhaben.

Zum Beispiel wäre Folgendes redundant/verwirrend, da defaultdict beim Zugriff auf das Element nie einen Fehler auslöst

>>> from collections import defaultdict
>>> from operator import itemgetter
>>> dd = defaultdict(int)
>>> itemgetter("foo", default=-1)(dd)
0

Dasselbe gilt für jedes benutzerdefinierte Objekt, das __getitem__ oder __getattr__ überschreibt und seine eigenen Fallbacks implementiert.

Mehrere Standardwerte

Die Idee, mehrere Standardwerte für mehrere Attribute oder Elemente zuzulassen, wurde in Betracht gezogen.

Es wurden zwei Alternativen diskutiert: die Verwendung eines Iterables, das die gleiche Anzahl von Elementen wie Parameter für attrgetter/itemgetter haben muss, oder die Verwendung eines Dictionaries mit Schlüsseln, die mit den an attrgetter/itemgetter übergebenen Namen übereinstimmen.

Das wirklich komplexe Problem hier (das die Funktion schwer zu erklären macht und verwirrende Grenzfälle aufweist), ist, was passieren würde, wenn ein Iterable oder Dictionary der *tatsächliche* gewünschte Standard für alle Elemente ist. Zum Beispiel

>>> itemgetter("a", default=(1, 2))({})
(1, 2)
>>> itemgetter("a", "b", default=(1, 2))({})
((1, 2), (1, 2))

Wenn wir „mehrere Standardwerte“ mit default zulassen, würde der erste Fall im obigen Beispiel eine Ausnahme auslösen, da es mehr Elemente als Namen im Standard gibt, und der zweite Fall würde (1, 2)) zurückgeben. Deshalb haben wir die Möglichkeit erwogen, einen anderen Namen für mehrere Standards zu verwenden (z. B. defaults, was ausdrucksstark, aber möglicherweise fehleranfällig ist, da es default zu ähnlich ist).

Ein weiterer Vorschlag, der mehrere Standardwerte ermöglichen würde, ist die Zulassung von Kombinationen von attrgetter und itemgetter, z. B.

>>> ig_a = itemgetter("a", default=1)
>>> ig_b = itemgetter("b", default=2)
>>> ig_combined = itemgetter(ig_a, ig_b)
>>> ig_combined({"a": 999})
(999, 2)
>>> ig_combined({})
(1, 2)

Das Kombinieren von itemgetter oder attrgetter ist jedoch ein völlig neues Verhalten und sehr komplex zu definieren. Obwohl nicht unmöglich, liegt es außerhalb des Rahmens dieses PEP.

Letztendlich wurde die Idee, mehrere Standardwerte zu haben, als zu komplex und potenziell verwirrend angesehen, und ein einzelner default-Parameter wurde aus Gründen der Einfachheit und Vorhersagbarkeit bevorzugt.

Konsistenz bei Tupelrückgaben

Ein weiterer abgelehnter Vorschlag war das Hinzufügen einer Flagge, um immer ein Tupel zurückzugeben, unabhängig davon, wie viele Schlüssel/Namen/Indizes angegeben wurden. Zum Beispiel

>>> letters = ["a", "b", "c"]
>>> itemgetter(1, return_tuple=True)(letters)
('b',)
>>> itemgetter(1, 2, return_tuple=True)(letters)
('b', 'c')

Dies wäre für die Konsistenz mehrerer Standardwerte von geringem Nutzen, erfordert weitere Diskussionen und liegt außerhalb des Rahmens dieses PEP.