Unterschied zwischen Einheimischen() und Globals() und dir() in Python

Question

nehmen diesen Code:

>>> iterator=filter(lambda x: x % 3 == 0, [2, 18, 9, 22, 17, 24, 8, 12, 27]) 
>>> x=int() 
>>> locals() 
{'__package__': None, '__spec__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__name__': '__main__', '__builtins__': <module 'builtins' (built-in)>, 'iterator': <filter object at 0x02E732B0>, 'x': 0, '__doc__': None} 
>>> globals() 
{'__package__': None, '__spec__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__name__': '__main__', '__builtins__': <module 'builtins' (built-in)>, 'iterator': <filter object at 0x02E732B0>, 'x': 0, '__doc__': None} 
>>> dir() 
['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'iterator', 'x'] 
>>> 

was ist der Unterschied zwischen Einheimischen, Globals und dir? und was ist die Verwendung?

Answer 1

Im globalen Gültigkeitsbereich geben sowohl locals() als auch globals() dasselbe Wörterbuch in den globalen Namespace zurück. Innerhalb einer Funktion gibt locals() jedoch die Kopie an den lokalen Namespace zurück, während globals() den globalen Namespace (der die globalen Namen enthalten würde) zurückgeben würde. Der Unterschied zwischen ihnen ist also nur in einer Funktion sichtbar. Beispiel dies zeigen -

>>> locals() == globals() #global scope, that is directly within the script (not inside a function. 
True 
>>> def a(): 
...  l = 1 
...  print('locals() :',locals()) 
...  print('globals() :',globals()) 
... 
>>> a() 
locals() : {'l': 1} 
globals() : {'BOTTOM': 'bottom', 'PROJECTING': 'proj.... 

Von documentation of globals() -

Globals()

Return ein Wörterbuch, um die aktuelle globale Symboltabelle darstellt. Dies ist immer das Wörterbuch des aktuellen Moduls (innerhalb einer Funktion oder Methode ist dies das Modul, in dem es definiert ist, nicht das Modul, von dem es aufgerufen wird).

Von documentation of locals() -

Einheimischen()

Update und geben ein Wörterbuch, um die aktuellen lokalen Symboltabelle darstellt. Freie Variablen werden von Locals() zurückgegeben, wenn sie in Funktionsblöcken, aber nicht in Klassenblöcken aufgerufen werden.

Hinweis: Der Inhalt dieses Wörterbuchs sollte nicht geändert werden. Änderungen dürfen die Werte der vom Interpreter verwendeten lokalen und freien Variablen nicht beeinflussen.

die Frage nach Nutzung ist, eine Nutzung zu beantworten können Variablen/Namen für die Verwendung von String zuzugreifen.Zum Beispiel, wenn Sie eine Variable mit dem Namen a, und Sie wollen ihren Wert für den Zugriff auf die Zeichenfolge mit - 'a', Sie globals() oder locals() dafür als verwenden - globals()['a'], dies würde zurückkehren Sie den Wert der globalen Variablen a oder locals()['a'] würden Sie zurückkehren der Wert von a in aktuellem Namensraum (die, wenn sie direkt im Skript oder lokaler Namensraum, wenn innerhalb einer Funktion globalen Namensraum ist)

dir() zeigt eine Liste der Attribute für das Objekt als Argument übergeben, ohne dass es ein Argument gibt die Liste der Namen im aktuellen lokalen Namespace (ähnlich Locals(). keys()). Von documentation of dir() -

dir ([object])

Ohne Argumente gibt die Liste der Namen in dem aktuellen lokalen Bereich. Versuchen Sie mit einem Argument, eine Liste gültiger Attribute für dieses Objekt zurückzugeben.

Answer 2

Sie können den Unterschied zwischen locals und globals bemerken, wenn Sie versuchen, sie innerhalb einer Funktion auszuführen. Wenn Sie versuchen, sie über die Konsole auszuführen, ohne verschachtelte Bereiche zu erstellen, ist das offensichtliche Ergebnis, dass Sie keinen Unterschied feststellen können.

• locals kehren Sie ein Wörterbuch von Variablen im lokalen Bereich erklärt: https://docs.python.org/2/library/functions.html#locals
• globals kehren Sie ein Wörterbuch der Variablen im globalen Bereich erklärt: https://docs.python.org/2/library/functions.html#globals
• dir funktioniert auf ähnliche Weise, wenn Sie locals Geben Sie keine Argumente an, aber wenn Sie ein Objekt als Argument übergeben, gibt es eine Liste gültiger Attribute für dieses Objekt zurück: https://docs.python.org/2/library/functions.html#dir

Answer 3

Im globalen Bereich (z. B. bei der interaktiven Eingabeaufforderung) sind locals und globals identisch. Jedoch in einer Funktion, sie sind anders:

x = 'some' 
y = 'this' 

def foo(x): 
    y = 'that' 
    print "My locals: ", `locals()` 
    print "My globals: ", `globals()` 

# locals has x: other and y: that only 
# globals contains x: some, y: this and many more global names 
foo('other') 

Die globale Variable x mit dem Wert ‚einig‘ ist eine andere Variable aus den lokalen Variablen x mit dem Wert ‚andere‘ (und das gleiche gilt für die beiden Variablen genannt y).

Überprüfen Sie the builtins documentation für Details oder die Dokumentation zu Python-Bereichsregeln.

Und dir() ohne Argumente ist im Wesentlichen der gleiche wie locals().keys() (die documentation says: Ohne Argument, die Liste der Namen in dem aktuellen lokalen Bereich zurückkehren.)

Answer 4

globals() kehrt die Symbole in dem aktuellen globalen Namensraum (scope des aktuellen Moduls + Einbauten) in einem dict-Objekt mit (key, value) -Paaren. key ist eine Zeichenkette mit dem Namen des Symbols und value der Wert des Symbols selbst (zB die Anzahl 1, eine anderen dict, eine Funktion, eine Klasse, etc.)

locals() gibt die Symbole im aktuellen lokalen Namensraum (Umfang der Funktion). Dies ergibt das gleiche Ergebnis wie globals(), wenn auf Modulebene aufgerufen wird.

dir() (ohne Parameter) gibt eine Liste von Namen aus dem aktuellen lokalen Namespace zurück.

Wenn Sie die folgenden drei Befehle auf Modulebene laufen, haben sie die gleichen Werte:

>>> sorted(locals().keys()) 
['A', '__builtins__', '__doc__', '__name__', '__package__', 'a', 'loc'] 
>>> sorted(dir()) 
['A', '__builtins__', '__doc__', '__name__', '__package__', 'a', 'loc'] 
>>> sorted(globals().keys()) 
['A', '__builtins__', '__doc__', '__name__', '__package__', 'a', 'loc'] 

Wenn diese drei Anrufe sind eine Funktion locals().keys() und dir() die gleichen Werte haben, aber globals() unterscheidet.

>>> def A(): 
... print(sorted(locals().keys())) 
... print(sorted(dir())) 
... print(sorted(globals().keys())) 

>>> A() 
[] 
[] 
['A', 'B', '__builtins__', '__doc__', '__name__', '__package__', 'a', 'loc'] 

können Sie den Unterschied im Einsatz sehen die Verwendung von globals() und locals().

Aber was ist mit dir()?

Der Punkt von dir() ist, dass es ein Objekt als Parameter akzeptiert. Es wird eine Liste der Attributnamen dieses Objekts zurückgegeben. Sie können es z.B. um ein Objekt zur Laufzeit zu inspizieren.

Wenn wir das obige Beispiel mit der Funktion A() nehmen, könnten wir nennen:

>>> dir(A) 
['__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__doc__', '__format__', '__get__', '__getattribute__', '__globals__', '__hash__', '__init__', '__module__', '__name__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name'] 

und erhalten Sie alle Attribute des Funktionsobjekt A.

Es gibt einige weitere Details über dir() an: Difference between dir(…) and vars(…).keys() in Python?