2010-07-23 6 views
0

Il me semble que les fonctions peuvent référencer des variables en dehors de leur portée mais ne peuvent pas les définir. Est-ce correct? Est-ce que je comprends bien?Portée variable simple Python

J'ai également inclus l'utilisation globale. Je sais qu'ils sont mauvais ju-ju et les éviteront; Je sais comment contourner cela, mais je voulais juste être clair.

Mon exemple programme:

import foo 

# beginning of functions 

# this one works because I look at the variable but dont modify it 
def do_something_working: 

    if flag_to_do_something: 
      print "I did it" 

# this one does not work because I modify the var 
def do_something_not_working: 

    if flag_to_do_something: 
      print "I did it" 
      flag_to_do_something = 0 

# this one works, but if I do this God kills a kitten 
def do_something_using_globals_working_bad_ju_ju: 

    global flag_to_do_something 

    if flag_to_do_something: 
     print "I did it" 
     flag_to_do_something = 0 


# end of functions 

flag_to_do_something = 1 

do_something_working() 
do_something_not_working() 
do_something_using_globals_working_bad_ju_ju() 

Répondre

5

Correct. Eh bien surtout. Lorsque vous flag_to_do_something = 0 vous ne modifiez pas la variable, vous créez une nouvelle variable. Le flag_to_do_something qui est créé dans la fonction sera un lien séparé vers (dans ce cas) le même objet. Cependant, si vous aviez utilisé une fonction ou un opérateur qui modifiait la variable en place, le code aurait fonctionné.

Exemple:

g = [1,2,3] 
def a(): 
    g = [1,2] 
a() 
print g #outputs [1,2,3] 

g = [1,2,3] 
def b(): 
    g.remove(3) 
b() 
print g #outputs [1,2] 
+0

Ahhh je vois. Y a-t-il quelque chose comme remove pour les variables non listées? Comme flag_to_do_something.set (0)? –

+1

Non, vous ne pouvez pas muter * les variables * (qui sont juste des noms), seulement * les objets *. Et les objets immuables, comme les ints, ne peuvent pas être mutés. Vous pouvez cependant affecter des variables globales en utilisant la déclaration 'global' dans la fonction:' global flag_to_do_something; flag_to_do_something = 0'. –

0

Eh oui, à peu près. Notez que les variables "globales" dans Python sont en fait des variables au niveau du module - leur portée est ce module Python (fichier source a.k.a.), pas le programme entier, comme ce serait le cas avec une vraie variable globale. Les globals Python ne sont donc pas aussi mauvais que les globals, disons C. Mais il est toujours préférable de les éviter.