differenza tra i locali() e globali() e dir() in python

Question

assumere questo codice:

>>> 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'] 
>>> 

qual è la differenza tra la gente del posto, globali e dir? e qual è l'utilizzo?

Answer 1

In ambito globale, sia locals() sia globals() restituiscono lo stesso dizionario allo spazio dei nomi globale. Ma all'interno di una funzione, locals() restituisce copia nello spazio dei nomi locale, mentre globals() restituisce lo spazio dei nomi globale (che conterrà i nomi globali). Quindi la differenza tra loro è visibile solo in una funzione. Esempio per mostrare questo -

>>> 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.... 

Da documentation of globals() -

globali()

restituisce un dizionario che rappresenta l'attuale tabella dei simboli globale. Questo è sempre il dizionario del modulo corrente (all'interno di una funzione o metodo, questo è il modulo in cui è definito, non il modulo da cui è chiamato).

Da documentation of locals() -

gente del posto()

Update e restituisce un dizionario rappresentante la corrente tabella dei simboli locale. Le variabili libere vengono restituite dai locals() quando vengono richiamate nei blocchi funzione, ma non nei blocchi di classe.

Nota: il contenuto di questo dizionario non deve essere modificato; le modifiche potrebbero non influire sui valori delle variabili locali e libere utilizzate dall'interprete.

Per rispondere alla domanda circa l'utilizzo , un utilizzo è quello di essere in grado di accedere le variabili/nomi utilizzando stringa per questo.Per esempio, se si dispone di una variabile denominata a, e si desidera accedere il suo valore utilizzando la stringa - 'a', è possibile utilizzare globals() o locals() anche per questo - globals()['a'], questo restituirebbe voi il valore della variabile globale a o locals()['a'] sarebbe tornato voi il valore di a nel namespace corrente (che è namespace globale quando direttamente all'interno dello script, o spazio locale se all'interno di una funzione)

dir() mostra un elenco di attributi per l'oggetto passato come argomento, senza argomento restituisce la elenco di nomi nello spazio dei nomi locale corrente (simile a locals(). keys()). Da documentation of dir() -

dir ([oggetto])

Senza argomenti, restituisce l'elenco dei nomi nel corrente ambito locale. Con un argomento, tenta di restituire un elenco di attributi validi per quell'oggetto.

Answer 2

È possibile notare la differenza tra locals e globals se si tenta di eseguirli all'interno di una funzione. Se si tenta di eseguirli dalla console senza creare ambiti nidificati, il risultato ovvio è che non si noterà alcuna differenza.

• locals si ritorna un dizionario di variabili dichiarate nel ambito locale: https://docs.python.org/2/library/functions.html#locals
• globals si ritorna un dizionario di variabili dichiarate nel campo di applicazione globale: https://docs.python.org/2/library/functions.html#globals
• dir funziona in modo simile a locals se si non fornire argomenti, ma se si passa un oggetto come argomento, quindi si restituisce un elenco di attributi validi per quell'oggetto: https://docs.python.org/2/library/functions.html#dir

Answer 3

In ambito globale (ad esempio nel prompt interattivo), il tuo locals e globals sono gli stessi. Tuttavia, all'interno di una funzione, sono diversi:

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') 

La variabile globale x con il valore 'po' è una variabile diversa dalla variabile locale x con il valore 'altra' (e lo stesso per i due variabili chiamato).

Controllare the builtins documentation per i dettagli o la documentazione sulle regole di ambito Python.

E dir() senza argomenti è essenzialmente lo stesso di locals().keys() (il documentation says: Senza argomenti, restituisce l'elenco dei nomi nel corrente ambito locale.)

Answer 4

globals() rendimenti dei simboli nella corrente namespace globale (portata del modulo corrente + built-in) in un oggetto dict con (key, value) -pairs. key è una stringa con il nome del simbolo e value è il valore del simbolo stesso (ad esempio, il numero 1, un altro dict, una funzione, una classe, ecc)

locals() restituisce i simboli nella corrente namespace locale (ambito della funzione). Questo darà lo stesso risultato di globals() quando viene chiamato a livello di modulo.

dir() (senza parametri) restituisce un elenco di nomi dallo spazio dei nomi locale corrente.

Quando si eseguono i seguenti tre comandi sul livello di modulo, che hanno gli stessi valori:

>>> 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'] 

Se queste tre chiamate sono effettuate una funzione locals().keys() e dir() hanno gli stessi valori ma globals() differisce.

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

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

Si può vedere la differenza in uso l'uso di globals() e locals().

Ma che dire di dir()?

Il punto di dir() è che accetta un oggetto come parametro. Restituirà una lista di nomi di attributi di quell'oggetto. Puoi usarlo, ad es. per ispezionare un oggetto in fase di esecuzione.

Se prendiamo l'esempio di cui sopra con la funzione A(), che potremmo chiamare:

>>> 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'] 

e ottenere tutti gli attributi dell'oggetto funzione di A.

Ci sono alcuni ulteriori dettagli sul dir() a: Difference between dir(…) and vars(…).keys() in Python?