Portée des variables

Bonjour

J'ai une petite interrogation sur la portée d'une variable. Tantôt je la vois, tantôt je ne la vois plus.

Petit exemple

Code:

---

1 2 3 4 5 6

def fct(): print(toto)   toto=10 fct() print(toto)

---

Jusqu'ici tout fonctionne comme indiqué sur le tuto de ce forum. Ma variable toto est globale et non modifiable mais visible dans la fonction donc ma fonction la voit et peut l'afficher.

Rajoutons maintenant 1 ligne

Code:

---

1 2 3 4 5 6 7

def fct(): toto=5 print(toto)   toto=10 fct() print(toto)

---

Je redéfinis une variable locale dont la visibilité surclasse la globale. Dans la fonction elle vaut 5 mais la globale inchangée reste à 10. Ca va encore.

Rajoutons maintenant une dernière ligne

Code:

---

1 2 3 4 5 6 7 8

def fct(): print(toto) toto=5 print(toto)   toto=10 fct() print(toto)

---

Et là, rien ne va plus. Python me dit qu'il ne connait pas la variable "toto" et lève une exception au premier print. Pourtant à cet endroit il devrait voir la globale qui n'a pas encore été supplantée par la locale !!! (à ce moment là, il n'y a encore aucune différence avec le premier code)...
On dirait que puisque "toto" a été définie dans la fonction, elle n'a alors plus le droit d'être invoquée avant sa définition et ce, même si une globale existe à son nom. Et cela impliquerait alors que Python fait au-moins 2 évaluations d'un code lors de son exécution...

Merci à ceux qui pourront m'éclairer de leurs avis à ce sujet...

Bonjour,

il n'y a aucune variable globale dans le code

Code:

---

1 2 3 4

def fct(): print(toto) toto=5 print(toto)

---

Le premier print(toto) renvoi la valeur de toto extérieure à la fonction.
le toto=5 affecte la valeur 5 à une deuxième variable toto locale à la fonction (car toto extérieur en lecture seule), et le deuxième print(toto) affiche la vauleur local de la fonctionne définie juste avant.
Il faudrait déclarer toto comme globale au sein de la fonction pour qu'elle le soit.
Enfin je crois arretez moi si je délire :D (vu votre nombre de messages c'est moi qui déraille)

Salut,

Citation:

---

Envoyé par Sve@r

Merci à ceux qui pourront m'éclairer de leurs avis à ce sujet...

---

C'est dans la FAQ Python qui traduit par un exemple simple ce qui est écrit dans le chapitre résolution des noms dans un langage un peu technique.

- W

Citation:

---

Envoyé par esope60

il n'y a aucune variable globale dans le code

Code:

---

1 2 3 4

def fct(): print(toto) toto=5 print(toto)

---

---

Moui, si tu n'en mets que la moitié alors effectivement, il n'y en a pas. Mais selon ta logique il n'y en n'a pas non plus dans mon tout premier code...

Code:

---

1 2	def fct(): print(toto)

---

Maintenant tu peux rajouter toto=10 au dessus de la fonction que cela ne change rien...

Citation:

---

Envoyé par esope60

Le premier print(toto) renvoi la valeur de toto extérieure à la fonction.
le toto=5 affecte la valeur 5 à une deuxième variable toto locale à la fonction (car toto extérieur en lecture seule), et le deuxième print(toto) affiche la vauleur local de la fonctionne définie juste avant.

---

C'était effectivement comme ça que je le voyais. Mais visiblement cela n'est pas le cas...

Citation:

---

Envoyé par esope60

Enfin je crois arretez moi si je délire :D (vu votre nombre de messages c'est moi qui déraille)

---

Ca ne veut pas dire grand chose. Je suis très actif sur le forum C et aussi shell mais ce n'est pas parce que je réponds souvent là bas que je connais tout sur tout (ou même tout sur Python).
Et puis même la mer n'est formée que de gouttes d'eau :mrgreen:
Merci de ton intervention ;)

Citation:

---

Envoyé par wiztricks

C'est dans la FAQ Python qui traduit par un exemple simple ce qui est écrit dans le chapitre résolution des noms dans un langage un peu technique.

---

Merci de ton aide. Effectivement c'est écrit

Citation:

---

A scope defines the visibility of a name within a block. If a local variable is defined in a block, its scope includes that block. If the definition occurs in a function block, the scope extends to any blocks contained within the defining one, unless a contained block introduces a different binding for the name.

---

J'ai bien compris le truc. Je m'interroge toutefois toujours sur la façon dont Python analyse. En effet, il est écrit que si la définition arrive dans une fonction, le scope s'étend à toute la fonction. Mais pour étendre le scope à tout le bloc de la fonction (donc y compris les lignes situées au dessus), il faut bien faire au-moins 2 passes non ?

Encore merci 8-)

Salut,

Citation:

---

Envoyé par Sve@r

Mais pour étendre le scope à tout le bloc de la fonction (donc y compris les lignes situées au dessus), il faut bien faire au-moins 2 passes non ?

---

Il faut aller voir les sources de l'implémentation Python.
Pour faire vite on peut observer les différences dans bytecode généré pour ces constructions.

Code:

---

1 2	def f(): print(toto)

---

Ici dis.dis(f) traduira l'accès à toto par LOAD_GLOBAL 1 (toto).
Si toto n'a pas été créé dans le scope global çà va planter en NameError.

Code:

---

1 2 3

def f(): print(toto) toto = 1

---

alors qu'ici ce sera LOAD_FAST 0 (toto).
Techniquement, si on "compile" une fonction, il va bien falloir construire une table de symboles, histoire de savoir si on va générer un LOAD_GLOBAL ou un LOAD_FAST.
Dans le deuxième cas, çà va marquer "toto" comme variable locale (à cause de l'assignation).
Puis lorsqu'on exécute le LOAD_FAST 0 (toto), on plante en UnboundLocalError: rien n'ayant été encore assigné à la variable (locale).
note: çà se fait en 2 étapes mais côté compilation, pas besoin de faire çà en 2 passes.

- W

Bonjour,

D'où l'importance d'éviter d'écrire un code dans le __main__, il vaut mieux créer une fonction "main" ça évitera bien des problèmes d'appels implicites de variables globales.

Et si vous voulez vraiment utiliser des variables globales, alors faites-le explicitement pour éviter que l'interpréteur choisisse si c'est local ou global : https://docs.python.org/3/reference/...obal-statement

Code:

---

1 2 3 4 5 6 7 8 9

def fct(): global toto # Déclare explicitement toto comme global print(toto) toto=5 print(toto)   toto=10 fct() print(toto)

---

La syntaxe global permet de déclarer une variable en global même si elle n'existe pas encore en globale.

Code:

---

1 2 3 4 5 6 7 8 9 10 11

def fct(): global toto, titi print(toto) toto=5 print(toto) titi = 2   toto=10 fct() print(toto) print(titi)

---

La suite pour Python 3 uniquement

Et tant qu'à être dans la résolution de portée, autre cas peu usuel :
La création d'une fonction dans une autre fonction permet de créer des variables locales propre à cette sous-fonction, et pour atteindre les variables locales de la fonction au dessus, il faut utiliser la syntaxe nonlocal.

pour ceux que ça intéresse je m'étais fait un script qui référence tous les cas de figure :

local nonlocal global scopes.py:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78

# -*- coding: utf-8 -*- # Python 3   x = "a" # (1) global scope y = "y"   def main(): # { x = 0 # (2) local/main scope   def change_local_x(): # { local/main scope value = 1 x = value # (3) initialization = implicit local print("change_local_x() {!r}".format(x)) # }   def change_nonlocal_x(): # { local/main scope nonlocal x # (2) value = 1 x = value print("change_nonlocal_x() {!r}".format(x)) # }   def change_global_x(): # { local/main scope global x # (1) explicit global value = "b" x = value print("change_global_x() {!r}".format(x)) # }   def print_nonlocal_or_global_x_y(): # { local/main scope print("print_nonlocal_or_global_x_y(): {!r}, {!r}".format(x, y)) # implicit (2) nonlocal if exists or (1) global # }   def print_global_x(): # { local/main scope global x # explicit global print("print_global_x(): {!r}".format(x)) # }   print("local x: {!r}".format(x)) print()   print_global_x() print_nonlocal_or_global_x_y() print()   change_local_x() print("local x: {!r}".format(x)) print()   change_nonlocal_x() print("local x: {!r}".format(x)) print()   change_global_x() print("local x: {!r}".format(x)) # } main   print("global x: {!r}".format(x)) print("global y: {!r}".format(y)) main() print("global x: {!r}".format(x))   # global x: 'a' # global y: 'y' # local x: 0 # # print_global_x(): 'a' # print_nonlocal_or_global_x_y(): 0, 'y' # # change_local_x() 1 # local x: 0 # # change_nonlocal_x() 1 # local x: 1 # # change_global_x() 'b' # local x: 1 # global x: 'b'

---