Variables globales de fonction python ?

Question

Donc, je sais que je devrais éviter d'utiliser des variables globales, en premier lieu, en raison d'une confusion de ce genre, mais si je devais les utiliser est la suivante valable pour aller sur leur utilisation? (Je suis en train d'appeler la copie globale d'une variable créée dans une fonction distincte.)

x = somevalue

def func_A ():
   global x
   # do things to x
   return x

def func_B():
   x=func_A()
   # do things
   return x

func_A()
func_B()

L' x que la deuxième fonction utilise la même valeur de la copie globale de l' x que func_a utilise et modifie? Lors de l'appel de fonctions après la définition, n'est de l'ordre de la matière?

Answer 1

Si vous souhaitez accéder simplement un global variable vous il suffit d’utiliser son nom. Cependant pour modifier sa valeur vous devez utiliser le `` mot clé.

par exemple,

cela modifierait la valeur de la variable globale à 55. Sinon, il serait juste assigner 55 à une variable locale.

L’ordre des listes de définition de fonction n’est pas grave (en supposant qu’ils ne se réfèrent à l’autre en quelque sorte), le fait de l’ordre qu’ils sont appelés.

Answer 2

Au sein d'un Python de la portée, toute affectation à une variable n'est déjà déclarées au sein de ce champ crée une nouvelle variable locale à moins que la variable est déclarée plus tôt dans la fonction comme se référant à une étendue globale variable avec le mot-clé global.

Regardons une version modifiée de votre pseudo-code pour voir ce qui se passe:

# Here, we're creating a variable 'x', in the __main__ scope.
x = 'None!'

def func_A():
  # The below declaration lets the function know that we
  #  mean the global 'x' when we refer to that variable, not
  #  any local one

  global x
  x = 'A'
  return x

def func_B():
  # Here, we are somewhat mislead.  We're actually involving two different
  #  variables named 'x'.  One is local to func_B, the other is global.

  # By calling func_A(), we do two things: we're reassigning the value
  #  of the GLOBAL x as part of func_A, and then taking that same value
  #  since it's returned by func_A, and assigning it to a LOCAL variable
  #  named 'x'.     
  x = func_A() # look at this as: x_local = func_A()

  # Here, we're assigning the value of 'B' to the LOCAL x.
  x = 'B' # look at this as: x_local = 'B'

  return x # look at this as: return x_local

En fait, on pourrait réécrire tout func_B à la variable nommée x_local et cela fonctionne de la même manière.

L'importance de l'ordre dans la seule mesure où l'ordre dans lequel vos fonctions ne opérations qui modifient la valeur de la global x. Ainsi, dans notre exemple, l'ordre n'a pas d'importance, puisqu' func_B des appels func_A. Dans cet exemple, l'ordre a de l'importance:

def a():
  global foo
  foo = 'A'

def b():
  global foo
  foo = 'B'

b()
a()
print foo
# prints 'A' because a() was the last function to modify 'foo'.

Notez que global n'est nécessaire pour modifier des objets globaux. Vous pouvez toujours y accéder à partir de l'intérieur d'une fonction, sans le déclarer global. Ainsi, nous avons:

x = 5

def access_only():
  return x
  # This returns whatever the global value of 'x' is

def modify():
  global x
  x = 'modified'
  return x
  # This function makes the global 'x' equal to 'modified', and then returns that value

def create_locally():
  x = 'local!'
  return x
  # This function creates a new local variable named 'x', and sets it as 'local',
  #  and returns that.  The global 'x' is untouched.

Notez la différence entre create_locally et access_only -- access_only accède au mondial de x en dépit de ne pas appeler global, et même si create_locally ne pas utiliser global soit, il crée une copie locale puisque c'est l'attribution d'une valeur.

La confusion ici, c'est pourquoi vous ne devriez pas utiliser des variables globales.

Answer 3

Comme d'autres l'ont noté, vous devez déclarer une variable global dans une fonction lorsque vous souhaitez que la fonction pour être en mesure de modifier la variable globale. Si vous souhaitez accéder, puis vous n'avez pas besoin d' global.

Pour aller dans un peu plus de détail sur ce, ce "modifier" signifie: si vous voulez re-lier le nom global de sorte qu'il pointe vers un autre objet, le nom doit être déclarée global dans la fonction.

De nombreuses opérations qui modifient (muter) un objet de ne pas re-lier le nom global de point à un autre objet, et donc ils sont tous valides sans déclarer le nom de l' global dans la fonction.

d = {}
l = []
o = type("object", (object,), {})()

def valid():     # these are all valid without declaring any names global!
   d[0] = 1      # changes what's in d, but d still points to the same object
   d[0] += 1     # ditto
   d.clear()     # ditto! d is now empty but it`s still the same object!
   l.append(0)   # l is still the same list but has an additional member
   o.test = 1    # creating new attribute on o, but o is still the same object

Answer 4

Vous devez utiliser le `` déclaration lorsque vous souhaitez modifier la valeur assignée à une variable globale.

Vous n’avez pas besoin de lire à partir d’une variable globale. Notez que l’appel d’une méthode sur un objet (même s’il modifie les données dans cet objet) ne modifie pas la valeur de la variable contenant cet objet (absence de magie réfléchissant).

Answer 5

@jdotjdot Ici est une tentative pour expliquer ce qu'il fait. L'exemple ci-dessus est auto-explicatif. Dans "access_only fonction de la valeur de la variable "x", a déclaré à l'échelle mondiale est accessible que déclarés et retournée par la fonction est où, comme dans le 'create_locally" le retour de la valeur de " x " est la valeur affectée à la variable dans la fonction. Dans les deux cas, la variable x a déclaré dans le monde, reste le même quel que soit les opérations que vous effectuez sur cette variable dans les fonctions comme l'a déclaré comme une portée locale variable à l'intérieur de la fonction. La valeur renvoyée de la fonction lors de l'appelé ne renvoie la valeur de la variable locale déclarée dans la fonction et non pas la référence de la variable globale de lui-même lorsqu'il est initialisé. Donc, si vous appelez "access_only' sera de retour la valeur déclarée à l'échelle mondiale alors que dans 'create_locally" il revient", locale!' comme il l'a déclaré à l'intérieur de la fonction. Si vous imprimez x après l'appel de l'une de ces fonctions, il sera encore de retour global de la valeur de x comme initialement déclarée '5'.

Pour modifier la valeur de la variable initialement déclaré que la variable comme globale dans la fonction qu'il est appelé.

P. S - les Gens s'il vous plaît corrigez-moi si je me trompe ou raté quelque chose.