Diese beiden Funktionen bieten hauptsächlich einen wörterbuchbasierten Weg, auf lokale und globale Variablen zuzugreifen.

Beim Verständnis dieser beiden Funktionen sollten wir zuerst das Konzept der Namensräume in Python verstehen. Python verwendet etwas namens Namensraum, um die Spuren von Variablen aufzuzeichnen. Ein Namensraum ist einfach ein Wörterbuch; seine Schlüssel sind Variablennamen, und die Werte des Wörterbuchs sind die Werte dieser Variablen.

Tatsächlich kann auf Namensräume genauso wie auf Python-Wörterbücher zugegriffen werden.

Jede Funktion hat ihren eigenen Namensraum, lokaler Namensraum genannt, der die Variablen der Funktion aufzeichnet, einschließlich ihrer Parameter und lokal definierten Variablen. Jedes Modul hat seinen eigenen Namensraum, globaler Namensraum genannt, der die Variablen des Moduls aufzeichnet, einschließlich Funktionen, Klassen, anderer importierter Module, Variablen und Konstanten auf Modulebene. Es gibt auch den eingebauten Namensraum, auf den jedes Modul zugreifen kann; er speichert eingebaute Funktionen und Ausnahmen.

Wenn eine Codezeile den Wert der Variablen x verwenden muss, durchsucht Python alle verfügbaren Namensräume nach der Variablen in der folgenden Reihenfolge:

  • 1. Lokaler Namensraum- Genauer gesagt die aktuelle Funktion oder eine Methode der Klasse. Wenn die Funktion eine lokale Variable x definiert, verwendet Python diese Variable und beendet dann die Suche.
  • 2. Globaler Namensraum- Genauer gesagt das aktuelle Modul. Wenn das Modul eine Variable, Funktion oder Klasse mit dem Namen x definiert, verwendet Python diese Variable und beendet dann die Suche.
  • 3. Eingebauter Namensraum- Er ist für jedes Modul global. Als letzten Versuch nimmt Python an, dass x eine eingebaute Funktion oder Variable ist.

Wenn Python x in diesen Namensräumen nicht finden kann, gibt es die Suche auf und löst eine NameError-Ausnahme aus, während es eine Meldung wie diese ausgibt:Es gibt keine Variable mit dem Namen 'x'a message like this.

Beispiel für die Funktion der lokalen Variablen locals (locals gibt ein Wörterbuch von Name/Wert-Paaren zurück):

Beispiel

def foo(arg, a):
    x = 1
    y = 'xxxxxx'
    for i in range(10):
        j = 1
        k = i
    print(locals())
# Ergebnis des Aufrufs der Funktion ausgeben
foo(1,2)
#{'k': 9, 'j': 1, 'i': 9, 'y': 'xxxxxx', 'x': 1, 'a': 2, 'arg': 1}

from module importundimport moduleDer Unterschied zwischen ihnen. Bei import module wird das Modul selbst importiert, aber es behält seinen eigenen Namensraum bei, weshalb Sie den Modulnamen verwenden müssen, um auf seine Funktionen oder Attribute zuzugreifen (module.function). Bei from module import importieren Sie jedoch tatsächlich die angegebenen Funktionen und Attribute aus einem anderen Modul in Ihren eigenen Namensraum, weshalb Sie direkt auf sie zugreifen können, ohne das Modul referenzieren zu müssen, aus dem sie stammen.

locals ist schreibgeschützt, globals nicht.

locals kann nicht geändert werden, globals kann geändert werden, aus folgendem Grund:

  • locals()Tatsächlich gibt (locals) nicht den lokalen Namensraum zurück; es gibt eine Kopie zurück. Eine Änderung daran ändert also die Kopie und hat keine Auswirkung auf die tatsächlichen Variablenwerte im lokalen Namensraum.
  • globals() gibt den tatsächlichen globalen Namensraum zurück, keine Kopie, was dem Verhalten von locals völlig entgegengesetzt ist.

Daher wirkt sich jede Änderung am von globals zurückgegebenen Wörterbuch direkt auf die Werte globaler Variablen aus.

Beispiel

#!/usr/bin/env python    

z = 7 # Globale Variable definieren
def foo(arg):  
    x = 1  
    print( locals() )  
    print('x=',x)
    locals()['x'] = 2 # Was geändert wird, ist die Kopie des lokalen Namensraums, und es gibt keine Auswirkung auf die tatsächlichen Variablenwerte im lokalen Namensraum.
    print( locals() )
    print( "x=",x )
 
foo(3)  
print( globals() )
print( 'z=',z )
globals()["z"] = 8 # globals() gibt den tatsächlichen globalen Namensraum zurück, wodurch der Wert der Variablen z geändert wird
print( globals() )
print( "z=",z )

Das Ausgabeergebnis ist:

{'x': 1, 'arg': 3}
x= 1
{'x': 1, 'arg': 3}
x= 1
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x10b099358>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'test.py', '__cached__': None, 'z': 7, 'foo': <function foo at 0x10ae48e18>}
z= 7
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x10b099358>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'test.py', '__cached__': None, 'z': 8, 'foo': <function foo at 0x10ae48e18>}
z= 8

Referenzlink:

https://blog.csdn.net/scelong/article/details/6977867

https://blog.csdn.net/sxingming/article/details/52061630