vars()

Einleitung

In Python speichern die meisten Objekte ihre Attribute in einem internen __dict__. vars(obj) liefert genau dieses Dictionary — Schlüssel sind Attribut-Namen, Werte die Attribut-Werte.

Drei Aufruf-Formen:

• vars() ohne Argument: identisch mit locals().
• vars(obj): obj.__dict__.
• vars(klasse): das __dict__ der Klasse — inkl. Methoden.

Nicht alle Objekte haben __dict__. Built-ins wie int, str, list und Klassen mit __slots__ haben keines — vars() wirft dann TypeError.

In Kombination mit setattr()/getattr() ist vars() die einfachste Form, ein Objekt zu „loggen": print(vars(obj)) gibt alle Attribute auf einmal aus.

Syntax

vars()           # = locals()
vars(object)     # = object.__dict__

Rückgabewert

Das __dict__ des Objekts (oder locals()-Snapshot ohne Argument).

Beispiele

Instanz-Attribute anzeigen

vars(instance) zeigt alle gesetzten Instanz-Attribute auf einen Blick — ideal zum Loggen:

class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age

u = User("Michael", 34)
print(vars(u))

{'name': 'Michael', 'age': 34}

Klassen-Attribute (inkl. Methoden)

vars(class) zeigt alle direkt auf der Klasse definierten Attribute — Methoden, Klassen-Variablen, Properties:

class User:
    count = 0

    def __init__(self, name):
        self.name = name

    def greet(self):
        return f"Hi, {self.name}"

own = {k: v for k, v in vars(User).items() if not k.startswith("_")}
print(sorted(own))

['count', 'greet']

Modul-Inhalt anzeigen

Auf Modul-Ebene zeigt vars(modul) alle exportierten Namen — wie dir(), aber mit Werten:

import math
own = {k: type(v).__name__ for k, v in vars(math).items() if not k.startswith("_")}
print(list(own.items())[:5])

[('acos', 'builtin_function_or_method'), ('acosh', 'builtin_function_or_method'), ('asin', 'builtin_function_or_method'), ('asinh', 'builtin_function_or_method'), ('atan', 'builtin_function_or_method')]

Praktische Beispiele

Debug-Repräsentation einer Instanz

Eine generische __repr__, die alle Attribute eines Objekts anzeigt — handsam für Debugging:

class AutoRepr:
    def __repr__(self):
        attrs = ", ".join(f"{k}={v!r}" for k, v in vars(self).items())
        return f"{type(self).__name__}({attrs})"

class Point(AutoRepr):
    def __init__(self, x, y):
        self.x = x
        self.y = y

print(Point(3, 4))

Point(x=3, y=4)

vars() ohne Argument = locals()

Auf Modul-Ebene und in Funktionen identisch mit locals() — Praxis siehe locals():

def example():
    x = 10
    y = 20
    print(vars() == locals())
    print(vars())

example()

True
{'x': 10, 'y': 20}

Slots-Klasse hat kein dict

Klassen mit __slots__ sparen Speicher, indem sie kein __dict__ haben — vars() schlägt fehl:

class Slim:
    __slots__ = ("x", "y")
    def __init__(self, x, y):
        self.x = x
        self.y = y

s = Slim(1, 2)
try:
    vars(s)
except TypeError as e:
    print(e)

vars() argument must have __dict__ attribute

Praktische Hinweise

• vars(obj) is obj.__dict__ — gleicher Inhalt, gleiches Objekt. Schreib-Zugriff auf das Dict ändert das Objekt.
• __slots__-Klassen haben kein __dict__ — vars() wirft TypeError.
• Modul-vars: vars(modul) ist identisch mit modul.__dict__ — alle Namen des Moduls.
• Builtin-Typen (int, str, ...) haben oft kein __dict__ — vars(42) schlägt fehl.
• Verwandte Funktionen: dir() (Namen-Liste), globals()/locals() (Scope-Dicts), inspect.getmembers() (komplettere Inspection).