Raison pour globals() en Python?

Quelle est la raison d'avoir globals() fonction en Python? Il ne renvoie dictionnaire des variables globales qui sont déjà mondial, de sorte qu'ils peuvent être utilisés n'importe où... je vous demande seulement de la curiosité, en essayant d'apprendre le langage python.

def F():
    global x
    x = 1

def G():
    print(globals()["x"]) #will return value of global 'x', which is 1

def H():
    print(x) #will also return value of global 'x', which, also, is 1

F()
G()
H()

Je ne vois pas vraiment le point ici? Seul le temps j'en aurais besoin, si j'avais des variables locales et globales, avec le même nom pour les deux

def F():
    global x
    x = 1

def G():
    x = 5
    print(x) #5
    print(globals()["x"]) #1

F()
G()

Mais vous ne devriez jamais vous rencontrez un problème d'avoir deux variables avec le même nom, et qui ont besoin d'utiliser les deux dans le même champ d'application.

"Mais vous ne devriez jamais vous rencontrez un problème d'avoir deux variables avec le même nom, et qui ont besoin d'utiliser les deux dans le même champ d'application." Je ne peux pas suivre cette pensée. C'est la raison pour séparer les espaces de noms, que vous avez variables avec le même nom dans différents champs d'application. Lorsque vous travaillez avec deux d'entre eux, des noms en double sont une chose naturelle, mais pas un problème, comme vous pouvez le préfixe eux.
Eh bien, je viens de la famille C++, donc je ne suis pas sûr à propos de Python personnes, mais aussi loin que je peux penser, vous ne devriez pas avoir de global variable qui n'a pas un nom unique. Sûr qu'il y aura des variables avec le même nom, dans le même contexte, que c'était stupide phrase de moi, mais pas de variables globales avec les mêmes noms que ceux des locaux. C'est quand je l'avais utiliser des espaces de noms pour les locaux... Mais vous ne savez pas, si vous le dis.
globals est peut-être un peu trompeur. globals() est essentiellement le locals() d'un module. Le plus proche de Python vient de variables globales qui sont véritablement mondiale à tous de votre programme est le __builtin__ module; tout ce que vous ajoutez à ce module est disponible dans tous les espaces de noms partout.
Hmm, bien plus, non pas que j'en aurais besoin en ce moment, mais peut-être un jour... Merci 🙂

InformationsquelleAutor | 2012-10-02

79

Python donne au programmeur un grand nombre d'outils pour l'introspection de l'environnement en cours d'exécution. globals() est juste un de ceux, et il peut être très utile dans une session de débogage pour voir ce que les objets de la portée mondiale contient en fait.

Le raisonnement derrière elle, je suis sûr, c'est le même que celui de l'aide locals() pour voir les variables définies dans une fonction, ou à l'aide de dir pour voir le contenu d'un module, ou les attributs d'un objet.

À venir à partir d'un C++ fond, je peux comprendre que ces choses semblent inutiles. Dans un liés statiquement typé statiquement environnement, ils doivent absolument l'être. Dans ce cas, il est connu au moment de la compilation exactement ce que les variables sont globales, et ce que les membres d'un objet, et même ce que les noms sont exportées par une autre unité de compilation.

Dans un langage dynamique, cependant, ces choses ne sont pas fixes; elles peuvent changer en fonction de la façon dont le code est importé, ou même lors de l'exécution. Pour cette raison au moins, d'avoir accès à ce genre d'information dans un débogueur peut être d'une valeur inestimable.
- +1. Aussi, le dictionnaire retourné par globals peut être modifié (probablement une capacité préférable de laisser aux experts). Aussi est la pertinence de cette citation de Plongez Dans Python "à l'Aide de la locals et globals fonctions, vous pouvez obtenir la valeur de l'arbitraire des variables dynamiquement, en fournissant le nom de la variable une chaîne de caractères. Cela reflète la fonctionnalité de la getattr fonction, ce qui vous permet d'accéder à des fonctions arbitraires de façon dynamique en fournissant le nom de la fonction comme une chaîne de caractères."
- Ne dites pas votre réponse était mieux que les autres, mais pour moi il était. Merci, je suppose que j'ai besoin de se calmer et de se rappeler que Python n'est pas C++ 🙂 Et merci pour tout le monde de répondre trop, effacé tout à fait beaucoup.
- La modification de certains éléments des sections() n'a généralement pas de travail. La plupart des fonctions python n'avez pas de dict pour les habitants - ainsi, lorsque vous appelez locals (), il construit un dict de la valeur actuelle de la population locale; la modification que dict ne reflète pas les habitants. Il y avait des cas où les fonctions a fait des choses comme "import * from xyz" (qui n'est plus autorisé) - qui définit les habitants avec des noms inconnus au moment de la compilation; ces fonctions ont été compilé avec une réelle habitants dict, il y a Longtemps, tous fonctions ont un réel habitants dict, et ils ont l'élimination progressive de la nécessité pour qui, je ne sais pas dans quelles conditions vous avez un dict maintenant.
InformationsquelleAutor Ian Clelland
36

Il est également utile lorsque vous avez besoin d'appeler une fonction à l'aide de la fonction nom de la chaîne. Par exemple:
```
def foo():
    pass

function_name_as_string = 'foo'

globals()[function_name_as_string]() # foo(). 
```
- Je vois. Est-ce une bonne pratique?
- Si la fonction a de nombreux paramètres comme, def foo(a, b, c=false). Comment voulez-vous passer de ces paramètres globals()
- Vous passez à la fonction, comme d'habitude: avec def foo(*args): print("hw", *args) que vous pouvez faire: globals()['foo']() ou globals()['foo']('reason', 42) etc.
InformationsquelleAutor Alex Soroka
8

Vous pouvez transmettre le résultat de globals() et locals() à la eval, execfile et __import__ commandes. Il en résulte la création d'un environnement restreint pour les commandes de travail.

Ainsi, ces fonctions existent pour soutenir d'autres fonctions qui bénéficient d'un environnement potentiellement différent du contexte actuel. Vous pourriez, par exemple, appeler globals() puis supprimer ou ajouter des variables avant d'appeler l'une de ces fonctions.

InformationsquelleAutor Bryan Oakley
6

globals() est utile pour eval() -- si vous voulez évaluer un code qui fait référence à des variables dans la portée, ces variables seront soit dans des variables globales ou locales.

À développer un peu plus, le eval() builtin fonction interpréter une chaîne de code Python qui lui est donné. La signature est: eval(codeString, globals, locals), et vous pouvez l'utiliser comme ceci:
```
def foo():
    x = 2
    y = eval("x + 1", globals(), locals())
    print("y=" + y) # should be 3
```
Cela fonctionne, parce que l'interprète obtient la valeur de x de la locals() dict de variables. Bien sûr, vous pouvez fournir votre propre dict de variables à eval.
- Downvoter: veuillez expliquer dans un commentaire.
- Je n'étais pas le seul downvoting, mais cela n'a pas vraiment de sens, pourriez-vous nous donner un exemple de code pour faciliter la compréhension?
- Bien sûr, j'ai élargi ma réponse.
- Un peu bizarre et semble inutile pour moi, mais peut-être que c'est juste parce que je suis nouveau sur Python 😛 Merci de toute façon
- eval("x+1") fait la même chose, en raison de ses paramètres par défaut; voir help(eval)
- Voir ici comment globals() peut être utilisé: stackoverflow.com/a/22021058/9024698.
InformationsquelleAutor Richard Close
0

Il peut être utile dans 'déclarative python'. Par exemple, dans le ci-dessous FooDef et BarDef sont des classes utilisées pour définir une série de structures de données qui sont ensuite utilisés par un paquet en entrée, ou sa configuration. Cela vous permet beaucoup de souplesse dans vos commentaires, et vous n'avez pas besoin d'écrire un analyseur syntaxique.
```
# FooDef, BarDef are classes

Foo_one = FooDef("This one", opt1 = False, valence = 3 )
Foo_two = FooDef("The other one", valence = 6, parent = Foo_one )

namelist = []
for i in range(6):
    namelist.append("nm%03d"%i)

Foo_other = FooDef("a third one", string_list = namelist )

Bar_thing = BarDef( (Foo_one, Foo_two), method = 'depth-first')
```
Noter que ce fichier de configuration utilise une boucle pour créer une liste de noms qui font partie de la configuration de Foo_other. Ainsi, cette configuration de la langue vient avec un très puissant "préprocesseur", avec une disposition des la bibliothèque run-time. Dans le cas où vous voulez, dire, trouver un ensemble de journal, ou un extrait de choses à partir d'un fichier zip et base64 les décoder, dans le cadre de la génération de votre configuration (cette approche n'est pas recommandée, bien sûr, pour les cas où l'entrée peut être à partir d'une source non fiable...)

Le package lit la configuration à l'aide de quelque chose comme ce qui suit:
```
conf_globals = {}  # make a namespace
# Give the config file the classes it needs
conf_globals['FooDef']= mypkgconfig.FooDef  # both of these are based ...
conf_globals['BarDef']= mypkgconfig.BarDef  # ... on .DefBase

fname = "user.conf"
try:
    exec open(fname) in conf_globals
except Exception:
    ...as needed...
# now find all the definitions in there
# (I'm assuming the names they are defined with are
# significant to interpreting the data; so they
# are stored under those keys here).

defs = {}
for nm,val in conf_globals.items():
    if isinstance(val,mypkgconfig.DefBase):
        defs[nm] = val
```
Donc, finalement, arriver à ce point, globals() est utile, lors de l'utilisation d'un tel paquet, si vous voulez à la menthe et une série de définitions de la procédure:
```
for idx in range(20):
    varname = "Foo_%02d" % i
    globals()[varname]= FooDef("one of several", id_code = i+1, scale_ratio = 2**i)
```
C'est l'équivalent de l'écriture
```
Foo_00 = FooDef("one of several", id_code = 1, scale_ratio=1)
Foo_01 = FooDef("one of several", id_code = 2, scale_ratio=2)
Foo_02 = FooDef("one of several", id_code = 3, scale_ratio=4)
... 17 more ...
```
Un exemple de ce package, qui obtient son entrée par la collecte d'un tas de définitions à partir d'un module python est PLY (Python-lex-yacc) http://www.dabeaz.com/ply/ - dans ce cas, les objets sont pour la plupart des objets de fonction, mais les métadonnées à partir de la fonction des objets (leurs noms, docstrings, et de l'ordre de définition) fait aussi partie de l'entrée. C'est pas un bon exemple pour l'utilisation de globals() . Aussi, il est importé par la 'configuration' - une normale script python -- plutôt que l'inverse.

J'ai utilisé le "déclaratif python" sur quelques projets sur lesquels j'ai travaillé, et ont eu l'occasion d'utiliser globals() lors de l'écriture des configurations pour ceux. Vous pourriez certainement faire valoir que cela était dû à une faiblesse dans la façon dont la configuration "langue" a été conçu. L'utilisation de globals() de cette façon, ne produit pas très clair résultats; seulement les résultats qui pourraient être plus faciles à entretenir que d'écrire une douzaine de près identiques consolidés.

Vous pouvez également l'utiliser pour donner de l'importance des variables dans le fichier de configuration, en fonction de leurs noms:
```
# All variables above here starting with Foo_k_ are collected
# in Bar_klist
#
foo_k = [ v for k,v in globals().items() if k.startswith('Foo_k_')]
Bar_klist  = BarDef( foo_k , method = "kset")
```
Cette méthode pourrait être utile pour tout module python qui définit un lot de tables et des structures, pour la rendre plus facile d'ajouter des éléments de données, sans avoir à maintenir les références ainsi.

InformationsquelleAutor greggo

Il peut également être utilisé pour obtenir une instance de la classe 'classname' partir d'une
chaîne:

class C:
    def __init__(self, x):
        self.x = x
        print('Added new instance, x:', self.x)


def call(str):
    obj = globals()[str](4)
    return obj

c = call('C')
print(c.x)

InformationsquelleAutor Bart

Vous devez vous connecter pour publier un commentaire.