Zmienne globalne funkcji Pythona?

Wiem, że powinienem unikać używania zmiennych globalnych przede wszystkim z powodu takiego zamieszania, ale jeślibym ich używał, czy przestrzeganie tych zasad jest dobrym sposobem? (Próbuję wywołać globalną kopię zmiennej utworzonej w oddzielnej funkcji).

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()

Czy xdruga funkcja używa tej samej wartości globalnej kopii, xktóra func_aużywa i modyfikuje? Czy przy wywoływaniu funkcji po zdefiniowaniu kolejność ma znaczenie?

Jeśli chcesz po prostu uzyskać dostęp do zmiennej globalnej, po prostu użyj jej nazwy. Jednak, aby zmienić jego wartość, musisz użyć globalsłowa kluczowego.

Na przykład

global someVar
someVar = 55

Zmieniłoby to wartość zmiennej globalnej na 55. W przeciwnym razie po prostu przypisałoby 55 do zmiennej lokalnej.

Kolejność list definicji funkcji nie ma znaczenia (zakładając, że nie odnoszą się one do siebie w jakiś sposób), kolejność, w jakiej są nazywane, ma znaczenie.

W zakresie Pythona każde przypisanie do zmiennej, która nie została jeszcze zadeklarowana w tym zakresie, tworzy nową zmienną lokalną, chyba że zmienna ta została zadeklarowana wcześniej w funkcji jako odnosząca się do zmiennej o zasięgu globalnym ze słowem kluczowym global.

Spójrzmy na zmodyfikowaną wersję twojego pseudokodu, aby zobaczyć, co się stanie:

# 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

W rzeczywistości możesz przepisać wszystko func_Bze zmienną o nazwie x_locali będzie działać identycznie.

Kolejność ma znaczenie tylko w takim stopniu, w jakim twoje funkcje wykonują operacje zmieniające wartość globalnego x. Zatem w naszym przykładzie kolejność nie ma znaczenia, ponieważ func_Bpołączenia func_A. W tym przykładzie kolejność ma znaczenie:

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'.

Pamiętaj, że globaljest to wymagane tylko do modyfikowania obiektów globalnych. Nadal możesz uzyskać do nich dostęp z poziomu funkcji bez deklarowania global. Mamy zatem:

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.

Zwróć uwagę na różnicę między create_locallyi access_only- access_onlyuzyskuje dostęp do globalnego x, mimo że nie dzwoni global, i chociaż create_locallynie używa globalżadnego z nich, tworzy lokalną kopię, ponieważ przypisuje wartość.

To zamieszanie powoduje, że nie powinieneś używać zmiennych globalnych.

Jak zauważyli inni, musisz zadeklarować zmienną globalw funkcji, jeśli chcesz, aby ta funkcja mogła modyfikować zmienną globalną. Jeśli chcesz tylko uzyskać do niego dostęp, nie potrzebujesz global.

Aby przejść do bardziej szczegółowych informacji na temat tego, co oznacza „modyfikuj”, jest to: jeśli chcesz ponownie powiązać nazwę globalną, aby wskazywała na inny obiekt, nazwa musi zostać zadeklarowana globalw funkcji.

Wiele operacji, które modyfikują (mutują) obiekt , nie wiążą ponownie globalnej nazwy w celu wskazania innego obiektu, a zatem wszystkie są poprawne bez podania nazwy globalw funkcji.

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

Oto jeden przypadek, który mnie złapał, używając globalnej jako domyślnej wartości parametru.

globVar = None    # initialize value of global variable

def func(param = globVar):   # use globVar as default value for param
    print 'param =', param, 'globVar =', globVar  # display values

def test():
    global globVar
    globVar = 42  # change value of global
    func()

test()
=========
output: param = None, globVar = 42

Spodziewałem się, że param będzie miał wartość 42. Niespodzianka. Python 2.7 ocenił wartość globVar podczas pierwszej analizy funkcji func. Zmiana wartości globVar nie wpłynęła na domyślną wartość przypisaną do parametru. Opóźnianie oceny, jak poniżej, działało tak, jak tego potrzebowałem.

def func(param = eval('globVar')):       # this seems to work
    print 'param =', param, 'globVar =', globVar  # display values

Lub, jeśli chcesz być bezpieczny,

def func(param = None)):
    if param == None:
        param = globVar
    print 'param =', param, 'globVar =', globVar  # display values

Możesz bezpośrednio uzyskać dostęp do zmiennej globalnej wewnątrz funkcji. Jeśli chcesz zmienić wartość tej zmiennej globalnej, użyj „globalnej nazwy zmiennej”. Zobacz następujący przykład:

var = 1
def global_var_change():
      global var
      var = "value changed"
global_var_change() #call the function for changes
print var

Ogólnie rzecz biorąc, nie jest to dobra praktyka programowania. Łamanie logiki przestrzeni nazw powoduje, że kod może być trudny do zrozumienia i debugowania.

Z globaldeklaracji należy skorzystać , aby zmienić wartość przypisaną zmiennej globalnej.

Nie potrzebujesz go do odczytu ze zmiennej globalnej. Zauważ, że wywołanie metody na obiekcie (nawet jeśli zmienia dane w tym obiekcie) nie zmienia wartości zmiennej przechowującej ten obiekt (brak magii odbijającej).