globals()

Einleitung

globals() öffnet das Innere eines Moduls als veränderbares Dictionary. Typische Anwendungsfälle:

• Inspection: Welche Funktionen/Klassen sind in diesem Modul definiert?
• Plugin-Loading: Klassen anhand ihres Namens dynamisch suchen.
• Generierte Symbole: Konstanten oder Funktionen zur Laufzeit ergänzen.
• Debugging: Schnell sehen, welche globalen Variablen gerade existieren.

Im Hauptskript ist globals() das __dict__ des __main__-Moduls. In jedem anderen Modul das __dict__ des jeweiligen Moduls.

Schreiben in globals() ist möglich, aber sollte mit Bedacht erfolgen — es macht Code schwer nachvollziehbar. In den meisten Fällen sind explizite Module, setattr() oder ein Registry-Pattern die bessere Wahl.

Syntax

globals()

Rückgabewert

Das Dict des Modul-Namespaces. Schreib-Zugriff wirkt direkt auf den globalen Scope.

Beispiele

Inhalt anzeigen

globals() zeigt alles, was auf Modul-Ebene definiert ist — typischerweise inkl. Dunder-Variablen wie __name__:

x = 42
def hello(): pass

# nur user-definierte Symbole
own = {k: v for k, v in globals().items() if not k.startswith("_")}
print(sorted(own))

['hello', 'x']

Funktion dynamisch finden

Mit globals() lassen sich Funktionen anhand ihres Namens als String aufrufen — Vorsicht mit User-Input:

def add(a, b): return a + b
def sub(a, b): return a - b

op = "add"
print(globals()[op](3, 4))

7

Globale Variable ergänzen

Schreiben in globals() definiert eine neue globale Variable — wirklich praktisch nur für Code-Generatoren:

for i in range(3):
    globals()[f"VAR_{i}"] = i * 10

print(VAR_0, VAR_1, VAR_2)

0 10 20

Praktische Beispiele

Plugin-System mit Klassen-Discovery

Ein einfaches Plugin-System kann alle Klassen, die von einer Basis erben, automatisch finden:

class Plugin: pass
class A(Plugin): name = "A"
class B(Plugin): name = "B"
class NotAPlugin: pass

plugins = [
    obj for obj in globals().values()
    if isinstance(obj, type) and issubclass(obj, Plugin) and obj is not Plugin
]
for p in plugins:
    print(p.name)

A
B

Konstanten-Block aus Konfig-Dict generieren

Wer viele ähnliche Konstanten braucht, kann sie aus einem Dict in den globalen Namespace kippen:

config = {
    "MAX_RETRIES": 3,
    "TIMEOUT": 30,
    "BUFFER_SIZE": 4096,
}
for key, value in config.items():
    globals()[key] = value

print(MAX_RETRIES, TIMEOUT, BUFFER_SIZE)

3 30 4096

Praktische Hinweise

• globals() schreibt direkt — anders als locals() in Funktionen.
• Code-Smell-Warnung: Dynamische Symbol-Erzeugung macht Tools (Linter, Type-Checker, IDE) blind. Sparsam nutzen.
• Module-__dict__: import sys; sys.modules[__name__].__dict__ ist exakt dasselbe wie globals().
• Bessere Alternativen: explizites Dict, enum.Enum, dataclasses, types.SimpleNamespace.
• Verwandte Funktionen: locals() (lokaler Scope), vars() (__dict__ eines Objekts), dir() (Namen-Liste).