Comment définir le libre-variable en python?

La local/global/free variable définitions de python doc:

Si un nom est lié à un bloc, il est variable locale de ce bloc, sauf si déclaré que locale. Si un nom est lié au niveau du module, c'est un variable globale. (Les variables du module bloc de code sont locales et mondiales.) Si une variable est utilisée dans un bloc de code, mais pas définie, elle est un gratuit variable.

Code 1:

>>> x = 0
>>> def foo():
...   print(x)
...   print(locals())
... 
>>> foo()
0
{}

Code 2:

>>> def bar():
...   x = 1
...   def foo():
...     print(x)
...     print(locals())
...   foo()
... 
>>> bar()
1
{'x':1}

_{variables Libres sont retournés par locals() lorsqu'il est appelé à la fonction des blocs, mais pas dans la classe des blocs.}

Dans Code 1, x est un variable globale, et il est utilisé mais non défini dans la foo().

Cependant, il n'est pas un gratuit variable, car il n'est pas retourné par locals().

Je pense que ce n'est pas ce que le doc a dit. Est-il une définition technique pour gratuit variable?

Très bonne question. Il y a des imprévus profondeurs derrière tout cela.

InformationsquelleAutor kev | 2012-10-16

python

38

Définition d'une variable: Utilisé, mais ni global, ni lié.

Par exemple:
1. x n'est pas libre dans le Code 1, parce que c'est un mondiale variable.
2. x n'est pas libre dans bar() en Code 2, parce que c'est un lié variable.
3. x est gratuit dans foo().
Python rend cette distinction en raison de fermetures d'usines. Gratuitement une variable n'est pas définie dans le contexte actuel, je. e. collection de variables locales, et est également pas une variable globale! Par conséquent, il doit être défini par ailleurs. Et c'est le concept de fermetures. Dans le Code 2, foo() ferme sur x défini dans bar(). Python utilise portée lexicale. Cela signifie, que l'interprète est en mesure de déterminer le champ d'application simplement en regardant le code.

Par exemple: x est connu comme une variable dans foo(), parce que foo() est fermée par bar(), et x est lié dans bar().

De portée mondiale est traitée spécialement par Python. Il serait possible de voir la portée mondiale comme un ultrapériphériques portée, mais ce n'est pas fait à cause des performances (je pense). Par conséquent, il n'est pas possible que x est à la fois gratuit et mondiale.

Exemption

La vie n'est pas si simple. Il existe gratuit global variables. Python docs (modèle d'Exécution) dit:

Le mondial de déclaration a la même portée que d'un nom de liaison de l'opération dans le même bloc. Si le plus proche du cadre englobant gratuit variable contient un mondial instruction, la variable indépendante est considérée comme un mondiale.
```
>>> x = 42
>>> def foo():
...   global x
...   def baz():
...     print(x)
...     print(locals())
...   baz()
... 
>>> foo()
42
{}
```
Je ne le savais pas moi-même. Nous sommes tous ici pour apprendre.
- Voulez-vous dire: x ne peut pas être free variable et variable globale en même temps?
- Qu'entendez-vous par "en même temps"? C'est une distinction importante entre la portée lexicale et dynamique de la portée. Pour rendre votre vie plus facile, je viens de dire: Non, x ne peut pas être gratuit et global "en même temps".
- pourquoi variable globale ne peut pas être free variable? Il n'est pas dit dans la doc, mais.
- global" est un peu exagéré ici. Avec ou sans mondiale, x, x, dans print(x) est tirée de portée mondiale. Ajout non x dans baz résultats avec une erreur de syntaxe car x n'est pas une variable indépendante, il est mondial. @kev Pourquoi? Parce que Python devs défini comme exclusive, période. Ils ont défini "variable indépendante" exclusivement pour fermetures et cadre englobant. En pratique: vous pouvez ajouter global y dans baz mais ne peuvent pas ajouter nonlocal y; certains a ne peut pas être à la fois global et nonlocal. Il en va de même pour le global et le local et champ d'application: vous ne pouvez pas x = 100 après print(x) dans baz (portée de mélange).
- Aussi, "la variable indépendante est considérée comme une" peut-être un peu trompeuse, car elle suggère que certains variable indépendante est considérée comme globale est donc à la fois global et gratuit, ce qui est faux. L'inspection baz à l'intérieur de foo avec baz.__code__.co_freevars montre il n'y a pas de variables libres. Ils signifiait probablement "candidat libre variable est traitée comme global".
InformationsquelleAutor nalply
3

De ce que j'ai compris la documentation est en effet un peu ambigu sur les variables libres. Il y a gratuit des variables globales qui sont traités comme de simples variables globales et lexicalement lié variables libres. Eli Bendersky somme est il parfaitement dans un blog sur les tables de symboles:

Malheureusement, il y a un raccourci dans le coeur de Python qui peut au premier abord confondre les lecteurs comme pour exactement ce que constitue un "gratuit" à la variable. Heureusement, il est très légère confusion qui est facile à mettre en ordre. Le modèle d'exécution de référence dit:

Si une variable est utilisée dans un bloc de code, mais pas définie, elle est une variable libre.

Ceci est cohérent avec le la définition formelle. Dans la source, cependant, le "gratuit" est en fait utilisé comme un raccourci pour "lexicalement lié gratuit variable" (c'est à dire les variables pour lesquelles une liaison a été trouvé dans un cadre englobant), "global" est utilisé pour désigner toutes les autres variables libres. Donc, lors de la lecture de Disponible le code source, il est important de rappeler que l'ensemble des variables libres comprend à la fois les variables marqués comme "libre", ainsi que ceux marqués en tant que "global".

Ainsi, pour éviter une confusion, je dis "lexicalement liées" quand je veux consulter les variables réellement traitées dans Disponible que gratuit.

(l'emphase est mienne)

La raison pour laquelle cette abréviation est utilisée est probablement parce que quand vous avez une mondial de la libre variable il n'y a vraiment aucun changement que ce soit dans le bytecode émis. Si un global variable est "libre" ou s'il n'est pas ne change pas le fait que la recherche pour le nom utilisera LOAD_GLOBAL dans les deux cas. Donc libre mondial de variables ne sont pas toutes spéciales.

D'autre part, sur le plan lexical lié variables sont spécialement traités et sont enfermés dans cellule objets, les objets sont l'espace de stockage pour lexicalement lié variables libres et sont situés dans le __closure__ attribut pour une fonction donnée. Un spécial LOAD_DEREF instruction est créé pour ces qui examine les cellules présentes pour les variables libres. La description de la LOAD_DEREF instruction est:

LOAD_DEREF(i)

Des charges de la cellule contenue dans le logement i de la cellule et gratuit de stockage variable

Donc en Python variables libres seulement faire une différence en tant que concept dans les situations où une définition pour un objet qui a de l'état est lexicalement (j'.e statiquement) imbriquée dans une autre définition pour un objet qui a de l'état.

InformationsquelleAutor Jim Fasarakis Hilliard
1

Variables ne sont rien, mais réservés les emplacements de la mémoire pour stocker des valeurs. Cela signifie que lorsque vous créez une variable de vous réserver de l'espace dans la mémoire.

Basé sur le type de données d'une variable, l'interprète alloue de la mémoire et décide de ce qui peut être stockée dans la mémoire réservée. Par conséquent, par l'affectation de différents types de données variables, vous pouvez stocker des nombres entiers, nombres décimaux ou des personnages de ces variables.

L'affectation de Valeurs à des Variables

Python variables n'ont pas besoin de déclaration explicite de réserver de l'espace mémoire. La déclaration se fait automatiquement lorsque vous affectez une valeur à une variable. Le signe égal (=) est utilisé pour affecter des valeurs à des variables.
- Cela ressemble à une bonne réponse, mais pouvez-vous répondre à ce que la définition de "variable indépendante", c'est exactement?
InformationsquelleAutor Nikhil
0

Il n'y a pas de mot clé explicit pour déclarer une variable libre en Python. Basée sur la définition d'une fonction et les instructions à l'intérieur et autour d'elle, Python classer les variables en tenue, de cellules et de variables libres.

L'exemple suivant illustre ce concept à l'aide de la fonction de code de l'objet qui encapsule les variables mentionnées dans le paragraphe précédent.
```
def func(arg1, arg2=2):
    def inner_func(arg3=arg2):
        return arg1, arg3
    arg1, arg2 = None
    return inner_func
```
Pour " func':

• arg1 et arg2 sont variables liées à la

• arg1 est un cellule variable puisque c'est un gratuit variable à l'intérieur de la " inner_func'

• Il n'y a pas de variables libres.
```
func.__code__.co_varnames
```
('arg1', 'arg2', 'inner_func')
```
func.__code__.co_cellvars
```
('arg1',)
```
func.__code__.co_freevars
```
()

Pour " inner_func':

• arg3 est un variable liée

• arg1 est un gratuit variable

• Il n'y a pas de cellules variables
```
inner_func.__code__.co_varnames
```
('arg3',)
```
inner_func.__code__.co_freevars
```
('arg1')
```
inner_func.__code__.co_cellvars
```
()

InformationsquelleAutor satishgoda
0

Juste pour que les novices n'obtenez pas induire en erreur, le commentaire ci-dessus par Nikhil commençant par "Variables ne sont rien, mais réservés les emplacements de la mémoire pour stocker des valeurs." est complètement faux pour Python.

En Python il y a des "noms" et il y a des "valeurs". Valeurs types, pas les noms. L'espace mémoire est réservé pour les valeurs, pas pour les noms. E. g., on peut avoir x = 1 puis plus tard dans le code par x = "une chaîne", suivi plus tard par x = [3, 9.1]. Au cours de ces missions, le nom de x premiers points pour un entier, une chaîne de caractères, et enfin à une liste. Lorsque la cession est effectuée, le nom sur le côté gauche de la cession est faite à un point de la valeur sur le côté droit de la cession. Les valeurs peuvent être non-modifiable (immuable) ou variable (mutable). Entiers, chaînes, tuples, etc sont immuables; les listes, etc sont mutables. Puisque les nombres entiers sont immuables, lorsqu'il y a deux états comme ceci:

x = 4

x = x +1

la deuxième déclaration ne fait point x d'une nouvelle valeur de 5, il n'est pas de modifier la valeur dans l'emplacement mémoire pointé par x de 4 à 5!

C'est un modèle très différent de celui de dire le langage C!

InformationsquelleAutor Intros Pector

Vous devez vous connecter pour publier un commentaire.

Code 1:

Code 2:

Définition d'une variable: Utilisé, mais ni global, ni lié.

Exemption