Die Python-Funktion locals() liefert das Dict des aktuellen lokalen Namespaces. Auf Modul-Ebene ist sie identisch mit globals(). Innerhalb von Funktionen liefert sie eine Momentaufnahme der lokalen Variablen — mit der wichtigen Einschränkung, dass Schreib-Zugriff im Allgemeinen keine Wirkung auf die echten lokalen Variablen hat.

01 · Abschnitt

Einleitung

locals() macht den lokalen Scope sichtbar. Anwendungsfälle:

  • Debug-Ausgabe: schnell alle lokalen Variablen einer Funktion ausgeben.
  • Template-Rendering: template.format(**locals()) setzt alle lokalen Werte ein.
  • Inspection: prüfen, was im aktuellen Frame definiert ist.

Wichtig zu verstehen: In CPython werden Funktionen-Locals in einem Array gespeichert (nicht in einem Dict). locals() baut bei Aufruf einen Snapshot dieses Arrays als Dict. Schreib-Operationen auf das zurückgegebene Dict werden NICHT in das Array zurück synchronisiert — die Variablen bleiben unverändert.

In Modul-Scope und Klassen-Body ist locals() allerdings das echte Dict — Schreib-Zugriff funktioniert dort.

02 · Abschnitt

Syntax

Python Syntax 
locals()
03 · Abschnitt

Rückgabewert

Ein Dict mit den lokalen Namen und ihren aktuellen Werten.

04 · Abschnitt

Beispiele

In einer Funktion

locals() zeigt alle bisher definierten Parameter und lokalen Variablen:

Python Beispiel 
def example(a, b):
    x = a + b
    y = a * b
    print(locals())

example(3, 4)
Output 
{'a': 3, 'b': 4, 'x': 7, 'y': 12}

Schreib-Zugriff in Funktion ist wirkungslos

In Funktionen liefert locals() einen Snapshot — Schreiben darauf hat keine Wirkung auf die echten Variablen:

Python Beispiel 
def attempt():
    x = 10
    locals()["x"] = 999
    print(x)        # immer noch 10

attempt()
Output 
10

Auf Modul-Ebene = globals()

Außerhalb von Funktionen ist locals() identisch mit globals():

Python Beispiel 
x = 1
print(locals() is globals())
Output 
True
05 · Abschnitt

Praktische Beispiele

Template-Rendering mit Format

format_map(locals()) ist eine elegante Form, lokale Variablen in einen String einzusetzen — bei vielen Werten kompakter als f-Strings:

Python Beispiel 
def report(name, age, city):
    template = "Hallo, {name}! Du bist {age} und lebst in {city}."
    return template.format_map(locals())

print(report("Michael", 34, "Berlin"))
Output 
Hallo, Michael! Du bist 34 und lebst in Berlin.

Debug-Ausgabe der Funktions-Variablen

Eine Mini-Debug-Helper-Funktion: pprint(locals()) an strategischer Stelle zeigt alle aktuellen Variablen:

Python Beispiel 
from pprint import pprint

def calculate(items):
    total = sum(items)
    avg = total / len(items)
    max_v = max(items)
    min_v = min(items)
    pprint(locals())
    return avg

calculate([10, 20, 30])
Output 
{'avg': 20.0,
 'items': [10, 20, 30],
 'max_v': 30,
 'min_v': 10,
 'total': 60}
06 · Abschnitt

Praktische Hinweise

  • In Funktionen ist Schreib-Zugriff wirkungslos — versucht nicht, Variablen über locals()["x"] = ... zu setzen.
  • Performance: locals() baut bei jedem Aufruf einen neuen Dict-Snapshot — nicht in heißen Schleifen aufrufen.
  • format_map(locals()) ist eine sehr saubere Template-Form — nutzt nur die Werte, die im Template referenziert werden.
  • inspect.currentframe().f_locals ist die Low-Level-Form — selbe Limitierung wie locals().
  • Verwandte Funktionen: globals(), vars(), dir(), inspect-Modul.
/ Weiter

Zurück zu Builtin Functions

Zur Übersicht