getattr()

Einleitung

getattr() ist eines der drei zentralen Reflection-Werkzeuge Pythons, gemeinsam mit setattr() und delattr(). Während der normale Point-Zugriff (obj.attr) den Attributnamen zur Schreibzeit kennt, erlaubt getattr(obj, name) den Zugriff über einen String — also über einen Wert, der erst zur Laufzeit feststeht.

Das macht getattr() zur idealen Wahl für Aufgaben wie Plugin-Architekturen, Strategy-Pattern, Konfigurations-Mappings oder beim Bauen von Tools, die fremden Code introspekt-basiert verwenden. Mit dem optionalen default-Argument lassen sich saubere „falls nicht vorhanden"-Defaults definieren — viel knapper als ein try/except AttributeError.

Intern nutzt getattr() denselben Lookup-Mechanismus wie der Point-Zugriff: erst die Instanz-__dict__, dann die Klassenhierarchie, dann __getattr__. Properties, Descriptors und __slots__ werden korrekt mitberücksichtigt.

Syntax

getattr(object, name)
getattr(object, name, default)

Rückgabewert

Den Wert des Attributs obj.name oder den default-Wert. Methoden werden ungebunden zurückgegeben (man kann sie speichern und später aufrufen).

Beispiele

Dynamischer Attributzugriff

class User:
    def __init__(self):
        self.name = "Michael"
        self.alter = 34

u = User()
feld = "name"
print(getattr(u, feld))

Michael

Mit Default statt AttributeError

u = User()
print(getattr(u, "email", "keine E-Mail"))

keine E-Mail

Methoden referenzieren

text = "Hallo Welt"
method = getattr(text, "upper")
print(method())

HALLO WELT

Plugin-/Strategy-Pattern

class Renderer:
    def render_html(self, data): return f"<p>{data}</p>"
    def render_md(self, data):   return f"**{data}**"

r = Renderer()
format = "md"
method = getattr(r, f"render_{format}", None)
if method:
    print(method("Hallo"))

**Hallo**

Praktische Beispiele

CLI-Befehle dynamisch dispatchen

class Commands:
    def cmd_help(self):  print("Hilfe wird angezeigt")
    def cmd_list(self):  print("Listing der Einträge")
    def cmd_clean(self): print("Cache wird geleert")

cli = Commands()
for arg in ["help", "clean", "unknown"]:
    handler = getattr(cli, f"cmd_{arg}", None)
    if handler:
        handler()
    else:
        print(f"Unbekanntes Kommando: {arg}")

Hilfe wird angezeigt
Cache wird geleert
Unbekanntes Kommando: unknown

Zugriff auf nested Attribute

class Config:
    db = type("DB", (), {"host": "localhost", "port": 5432})

def deep_get(obj, path, default=None):
    for part in path.split("."):
        obj = getattr(obj, part, default)
        if obj is default:
            return default
    return obj

print(deep_get(Config, "db.host"))
print(deep_get(Config, "db.user", "anonymous"))

localhost
anonymous

Lazy Attribute-Initialisierung

class Cache:
    def __init__(self):
        self._data = None

    @property
    def data(self):
        if getattr(self, "_loaded", False):
            return self._data
        print("Lade Daten ...")
        self._data = [1, 2, 3]
        self._loaded = True
        return self._data

c = Cache()
print(c.data)
print(c.data)  # nicht erneut geladen

Lade Daten ...
[1, 2, 3]
[1, 2, 3]

Praktische Hinweise

• obj.attr ist schneller als getattr(obj, "attr") — getattr() erst nutzen, wenn der Name dynamisch ist.
• Default vermeidet try/except AttributeError und ist idiomatisch für „optionale Attribute".
• Custom __getattr__ wird nur aufgerufen, wenn der reguläre Lookup fehlschlägt — getattr() triggert es korrekt.
• Verwandte Funktionen: setattr() (setzen), delattr() (löschen), hasattr() (prüfen).