Jak mogę utworzyć lub użyć zmiennej globalnej w funkcji?

Jeśli utworzę zmienną globalną w jednej funkcji, jak mogę użyć tej zmiennej globalnej w innej funkcji? Czy muszę przechowywać zmienną globalną w zmiennej lokalnej funkcji, która potrzebuje jej dostępu?

Możesz użyć zmiennej globalnej w innych funkcjach, deklarując ją jak globalw każdej funkcji, która do niej przypisuje:

globvar = 0

def set_globvar_to_one():
    global globvar    # Needed to modify global copy of globvar
    globvar = 1

def print_globvar():
    print(globvar)     # No need for global declaration to read value of globvar

set_globvar_to_one()
print_globvar()       # Prints 1

Wyobrażam sobie, że powodem tego jest to, że ponieważ zmienne globalne są tak niebezpieczne, Python chce się upewnić, że naprawdę wiesz, z czym się bawisz, wyraźnie wymagając globalsłowa kluczowego.

Zobacz inne odpowiedzi, jeśli chcesz udostępnić zmienną globalną między modułami.

Jeśli dobrze rozumiem twoją sytuację, to, co widzisz, jest wynikiem tego, jak Python obsługuje lokalne (funkcyjne) i globalne (modułowe) przestrzenie nazw.

Powiedz, że masz taki moduł:

# sample.py
myGlobal = 5

def func1():
    myGlobal = 42

def func2():
    print myGlobal

func1()
func2()

Możesz spodziewać się, że to wydrukuje 42, ale zamiast tego wydrukuje 5. Jak już wspomniano, jeśli dodasz globaldeklarację „ ” func1(), func2()wydrukuje 42.

def func1():
    global myGlobal
    myGlobal = 42

To, co się tutaj dzieje, polega na tym, że Python zakłada, że ​​każda nazwa przypisana w dowolnym miejscu funkcji jest lokalna dla tej funkcji, chyba że wyraźnie zaznaczono inaczej. Jeśli czyta tylko z nazwy, a nazwa nie istnieje lokalnie, spróbuje wyszukać nazwę w dowolnym zawierającym zakresie (np. Globalnym zasięgu modułu).

myGlobalDlatego po przypisaniu 42 do nazwy Python tworzy zmienną lokalną, która przesłania zmienną globalną o tej samej nazwie. Ten lokalny wykracza poza zakres i jest zwracany w śmieciach po func1()powrocie; tymczasem func2()nigdy nie widzi niczego poza (niezmodyfikowaną) nazwą globalną. Zauważ, że decyzja o przestrzeni nazw ma miejsce w czasie kompilacji, a nie w czasie wykonywania - jeśli miałbyś odczytać wartość myGlobalinside func1()przed przypisaniem do niej, dostałbyś UnboundLocalError, ponieważ Python już zdecydował, że musi to być zmienna lokalna, ale nie ma jeszcze żadnej wartości z tym związanej. Ale używając instrukcji „ global”, mówisz Pythonowi, że powinien szukać innej nazwy zamiast przypisywać ją lokalnie.

(Uważam, że takie zachowanie powstało głównie dzięki optymalizacji lokalnych przestrzeni nazw - bez tego zachowania maszyna wirtualna Pythona musiałaby wykonywać co najmniej trzy wyszukiwania nazw za każdym razem, gdy nowa funkcja jest przypisywana do funkcji (aby upewnić się, że nazwa nie już istnieją na poziomie modułu / wbudowanego), co znacznie spowolniłoby bardzo częstą operację.)

Możesz zapoznać się z pojęciem przestrzeni nazw . W Pythonie moduł jest naturalnym miejscem dla danych globalnych :

Każdy moduł ma własną prywatną tablicę symboli, która jest używana jako globalna tablica symboli przez wszystkie funkcje zdefiniowane w module. Tak więc autor modułu może używać zmiennych globalnych w module bez obawy o przypadkowe zderzenia ze zmiennymi globalnymi użytkownika. Z drugiej strony, jeśli wiesz, co robisz, możesz dotknąć zmiennych globalnych modułu jest z tej samej notacji używane w odniesieniu do jego funkcji modname.itemname.

Konkretne zastosowanie globalnego modułu jest opisane tutaj - Jak współdzielić zmienne globalne między modułami? , a dla kompletności treść jest udostępniana tutaj:

Kanonicznym sposobem udostępniania informacji między modułami w ramach jednego programu jest utworzenie specjalnego modułu konfiguracyjnego (często nazywanego config lub cfg ). Wystarczy zaimportować moduł konfiguracji do wszystkich modułów aplikacji; moduł staje się dostępny jako nazwa globalna. Ponieważ istnieje tylko jedna instancja każdego modułu, wszelkie zmiany dokonane w obiekcie modułu są odzwierciedlane wszędzie. Na przykład:

Plik: config.py

x = 0   # Default value of the 'x' configuration setting

Plik: mod.py

import config
config.x = 1

Plik: main.py

import config
import mod
print config.x

Python używa prostej heurystyki, aby zdecydować, z którego zakresu powinna załadować zmienną, między lokalną a globalną. Jeśli nazwa zmiennej pojawia się po lewej stronie przypisania, ale nie jest deklarowana jako globalna, zakłada się, że jest lokalna. Jeśli nie pojawia się po lewej stronie zadania, przyjmuje się, że ma charakter globalny.

>>> import dis
>>> def foo():
...     global bar
...     baz = 5
...     print bar
...     print baz
...     print quux
... 
>>> dis.disassemble(foo.func_code)
  3           0 LOAD_CONST               1 (5)
              3 STORE_FAST               0 (baz)

  4           6 LOAD_GLOBAL              0 (bar)
              9 PRINT_ITEM          
             10 PRINT_NEWLINE       

  5          11 LOAD_FAST                0 (baz)
             14 PRINT_ITEM          
             15 PRINT_NEWLINE       

  6          16 LOAD_GLOBAL              1 (quux)
             19 PRINT_ITEM          
             20 PRINT_NEWLINE       
             21 LOAD_CONST               0 (None)
             24 RETURN_VALUE        
>>> 

Zobacz, jak baz, który pojawia się po lewej stronie przypisania w foo(), jest jedyną LOAD_FASTzmienną.

Jeśli chcesz odwoływać się do zmiennej globalnej w funkcji, możesz użyć słowa kluczowego global, aby zadeklarować, które zmienne są globalne. Nie musisz go używać we wszystkich przypadkach (jak ktoś tutaj błędnie twierdzi) - jeśli nazwy, do której odwołuje się wyrażenie, nie można znaleźć w zasięgu lokalnym lub zakresach w funkcjach, w których ta funkcja jest zdefiniowana, jest sprawdzana wśród globalnych zmienne.

Jeśli jednak przypiszesz do nowej zmiennej, która nie jest zadeklarowana jako globalna w funkcji, zostanie ona domyślnie zadeklarowana jako lokalna i może przyćmić dowolną istniejącą zmienną globalną o tej samej nazwie.

Przydatne są także zmienne globalne, w przeciwieństwie do fanatyków OOP, którzy twierdzą inaczej - szczególnie w przypadku mniejszych skryptów, w których OOP jest przesadą.

Jeśli utworzę zmienną globalną w jednej funkcji, jak mogę użyć tej zmiennej w innej funkcji?

Możemy stworzyć globalny za pomocą następującej funkcji:

def create_global_variable():
    global global_variable # must declare it to be a global first
    # modifications are thus reflected on the module's global scope
    global_variable = 'Foo' 

Napisanie funkcji tak naprawdę nie uruchamia jej kodu. Dlatego nazywamy create_global_variablefunkcję:

>>> create_global_variable()

Używanie globałów bez modyfikacji

Możesz po prostu z niego korzystać, o ile nie spodziewasz się zmienić obiektu, na który wskazuje:

Na przykład,

def use_global_variable():
    return global_variable + '!!!'

a teraz możemy użyć zmiennej globalnej:

>>> use_global_variable()
'Foo!!!'

Modyfikacja zmiennej globalnej z wnętrza funkcji

Aby wskazać zmienną globalną na inny obiekt, musisz ponownie użyć słowa kluczowego global:

def change_global_variable():
    global global_variable
    global_variable = 'Bar'

Zauważ, że po napisaniu tej funkcji kod, który ją zmienia, wciąż nie działa:

>>> use_global_variable()
'Foo!!!'

Po wywołaniu funkcji:

>>> change_global_variable()

widzimy, że zmienna globalna została zmieniona. global_variableNazwa wskazuje teraz 'Bar':

>>> use_global_variable()
'Bar!!!'

Zauważ, że „globalny” w Pythonie nie jest tak naprawdę globalny - jest tylko globalny do poziomu modułu. Jest więc dostępny tylko dla funkcji zapisanych w modułach, w których jest globalny. Funkcje zapamiętują moduł, w którym zostały napisane, więc kiedy są eksportowane do innych modułów, nadal szukają modułu, w którym zostały utworzone, aby znaleźć zmienne globalne.

Zmienne lokalne o tej samej nazwie

Jeśli utworzysz zmienną lokalną o tej samej nazwie, przyćmi ona zmienną globalną:

def use_local_with_same_name_as_global():
    # bad name for a local variable, though.
    global_variable = 'Baz' 
    return global_variable + '!!!'

>>> use_local_with_same_name_as_global()
'Baz!!!'

Ale użycie tej źle nazwanej zmiennej lokalnej nie zmienia zmiennej globalnej:

>>> use_global_variable()
'Bar!!!'

Pamiętaj, że powinieneś unikać używania lokalnych zmiennych o takich samych nazwach jak globale, chyba że wiesz dokładnie, co robisz i masz bardzo dobry powód, aby to zrobić. Nie spotkałem jeszcze takiego powodu.

Takie samo zachowanie uzyskujemy na zajęciach

W komentarzu pojawia się pytanie:

co zrobić, jeśli chcę utworzyć zmienną globalną wewnątrz funkcji w klasie i chcę użyć tej zmiennej w innej funkcji w innej klasie?

Tutaj pokazuję, że uzyskujemy takie samo zachowanie w metodach, jak w przypadku zwykłych funkcji:

class Foo:
    def foo(self):
        global global_variable
        global_variable = 'Foo'

class Bar:
    def bar(self):
        return global_variable + '!!!'

Foo().foo()

I teraz:

>>> Bar().bar()
'Foo!!!'

Proponuję jednak zamiast używać zmiennych globalnych używać atrybutów klas, aby uniknąć zaśmiecania przestrzeni nazw modułów. Zauważ też, że nie używamy selftutaj argumentów - mogą to być metody klasowe (przydatne, gdy mutujemy atrybut klasy ze zwykłego clsargumentu) lub metody statyczne (nie selflub cls).

Oprócz już istniejących odpowiedzi i aby było to bardziej mylące:

W Pythonie zmienne, do których odwołuje się tylko funkcja, są domyślnie globalne . Jeśli zmiennej przypisano nową wartość w dowolnym miejscu w ciele funkcji, zakłada się, że jest ona lokalna . Jeśli zmienna kiedykolwiek ma przypisaną nową wartość w funkcji, zmienna jest domyślnie lokalna i musisz jawnie zadeklarować ją jako „globalną”.

Choć na początku trochę zaskakujące, moment zastanowienia wyjaśnia to. Z jednej strony, wymaganie globalne dla przypisanych zmiennych zapewnia pasek przeciw niezamierzonym skutkom ubocznym. Z drugiej strony, gdyby globalny był wymagany dla wszystkich globalnych odniesień, cały czas będziesz używać globalnego. Będziesz musiał zadeklarować jako globalne każde odwołanie do wbudowanej funkcji lub komponentu importowanego modułu. Ten bałagan pokonałby przydatność globalnej deklaracji do identyfikowania skutków ubocznych.

Źródło: Jakie są reguły dla zmiennych lokalnych i globalnych w Pythonie? .

Przy równoległym wykonywaniu zmienne globalne mogą powodować nieoczekiwane wyniki, jeśli nie rozumiesz, co się dzieje. Oto przykład użycia zmiennej globalnej w ramach wieloprocesowego przetwarzania. Widzimy wyraźnie, że każdy proces działa z własną kopią zmiennej:

import multiprocessing
import os
import random
import sys
import time

def worker(new_value):
    old_value = get_value()
    set_value(random.randint(1, 99))
    print('pid=[{pid}] '
          'old_value=[{old_value:2}] '
          'new_value=[{new_value:2}] '
          'get_value=[{get_value:2}]'.format(
          pid=str(os.getpid()),
          old_value=old_value,
          new_value=new_value,
          get_value=get_value()))

def get_value():
    global global_variable
    return global_variable

def set_value(new_value):
    global global_variable
    global_variable = new_value

global_variable = -1

print('before set_value(), get_value() = [%s]' % get_value())
set_value(new_value=-2)
print('after  set_value(), get_value() = [%s]' % get_value())

processPool = multiprocessing.Pool(processes=5)
processPool.map(func=worker, iterable=range(15))

Wynik:

before set_value(), get_value() = [-1]
after  set_value(), get_value() = [-2]
pid=[53970] old_value=[-2] new_value=[ 0] get_value=[23]
pid=[53971] old_value=[-2] new_value=[ 1] get_value=[42]
pid=[53970] old_value=[23] new_value=[ 4] get_value=[50]
pid=[53970] old_value=[50] new_value=[ 6] get_value=[14]
pid=[53971] old_value=[42] new_value=[ 5] get_value=[31]
pid=[53972] old_value=[-2] new_value=[ 2] get_value=[44]
pid=[53973] old_value=[-2] new_value=[ 3] get_value=[94]
pid=[53970] old_value=[14] new_value=[ 7] get_value=[21]
pid=[53971] old_value=[31] new_value=[ 8] get_value=[34]
pid=[53972] old_value=[44] new_value=[ 9] get_value=[59]
pid=[53973] old_value=[94] new_value=[10] get_value=[87]
pid=[53970] old_value=[21] new_value=[11] get_value=[21]
pid=[53971] old_value=[34] new_value=[12] get_value=[82]
pid=[53972] old_value=[59] new_value=[13] get_value=[ 4]
pid=[53973] old_value=[87] new_value=[14] get_value=[70]

Mówisz o użyciu następującej metody:

globvar = 5

def f():
    var = globvar
    print(var)

f()  # Prints 5

Ale lepszym sposobem jest użycie globalnej zmiennej w ten sposób:

globavar = 5
def f():
    global globvar
    print(globvar)
f()   #prints 5

Oba dają taką samą moc wyjściową.

Jak się okazuje, odpowiedź jest zawsze prosta.

Oto mały przykładowy moduł z prostym sposobem pokazania go w maindefinicji:

def five(enterAnumber,sumation):
    global helper
    helper  = enterAnumber + sumation

def isTheNumber():
    return helper

Oto jak to pokazać w maindefinicji:

import TestPy

def main():
    atest  = TestPy
    atest.five(5,8)
    print(atest.isTheNumber())

if __name__ == '__main__':
    main()

Ten prosty kod działa w ten sposób i zostanie wykonany. Mam nadzieję, że to pomoże.

Musisz odwoływać się do zmiennej globalnej w każdej funkcji, której chcesz użyć.

Następująco:

var = "test"

def printGlobalText():
    global var #wWe are telling to explicitly use the global version
    var = "global from printGlobalText fun."
    print "var from printGlobalText: " + var

def printLocalText():
    #We are NOT telling to explicitly use the global version, so we are creating a local variable
    var = "local version from printLocalText fun"
    print "var from printLocalText: " + var

printGlobalText()
printLocalText()
"""
Output Result:
var from printGlobalText: global from printGlobalText fun.
var from printLocalText: local version from printLocalText
[Finished in 0.1s]
"""

W rzeczywistości nie przechowujesz globalnego w zmiennej lokalnej, po prostu tworzysz lokalne odwołanie do tego samego obiektu, do którego odnosi się twoje oryginalne odwołanie globalne. Pamiętaj, że prawie wszystko w Pythonie jest nazwą odnoszącą się do obiektu i nic nie jest kopiowane podczas zwykłej operacji.

Jeśli nie musisz jawnie określać, kiedy identyfikator ma odnosić się do predefiniowanej globalnej, prawdopodobnie musiałbyś jawnie określić, kiedy identyfikator jest nową zmienną lokalną (na przykład za pomocą czegoś takiego jak polecenie „var” widoczne w JavaScript). Ponieważ zmienne lokalne są bardziej powszechne niż zmienne globalne w dowolnym poważnym i nietrywialnym systemie, w większości przypadków system Pythona ma większy sens.

Państwo mogłoby mieć język, który próbował odgadnąć, wykorzystując zmienną globalną gdyby istniał lub utworzenie zmiennej lokalnej, czy nie. Byłoby to jednak bardzo podatne na błędy. Na przykład zaimportowanie innego modułu może przypadkowo wprowadzić zmienną globalną o tej nazwie, zmieniając zachowanie twojego programu.

Spróbuj tego:

def x1():
    global x
    x = 6

def x2():
    global x
    x = x+1
    print x

x = 5
x1()
x2()  # output --> 7

Jeśli masz zmienną lokalną o tej samej nazwie, możesz chcieć użyć globals()funkcji .

globals()['your_global_var'] = 42

Następnie i jako dodatek użyj pliku, który zawiera wszystkie zmienne globalne wszystkie zadeklarowane lokalnie, a następnie import as:

Plik initval.py :

Stocksin = 300
Prices = []

Plik getstocks.py :

import initval as iv

def getmystocks(): 
    iv.Stocksin = getstockcount()


def getmycharts():
    for ic in range(iv.Stocksin):

Zapis do jawnych elementów tablicy globalnej najwyraźniej nie wymaga globalnej deklaracji, chociaż zapis do niej „hurtowy” ma ten wymóg:

import numpy as np

hostValue = 3.14159
hostArray = np.array([2., 3.])
hostMatrix = np.array([[1.0, 0.0],[ 0.0, 1.0]])

def func1():
    global hostValue    # mandatory, else local.
    hostValue = 2.0

def func2():
    global hostValue    # mandatory, else UnboundLocalError.
    hostValue += 1.0

def func3():
    global hostArray    # mandatory, else local.
    hostArray = np.array([14., 15.])

def func4():            # no need for globals
    hostArray[0] = 123.4

def func5():            # no need for globals
    hostArray[1] += 1.0

def func6():            # no need for globals
    hostMatrix[1][1] = 12.

def func7():            # no need for globals
    hostMatrix[0][0] += 0.33

func1()
print "After func1(), hostValue = ", hostValue
func2()
print "After func2(), hostValue = ", hostValue
func3()
print "After func3(), hostArray = ", hostArray
func4()
print "After func4(), hostArray = ", hostArray
func5()
print "After func5(), hostArray = ", hostArray
func6()
print "After func6(), hostMatrix = \n", hostMatrix
func7()
print "After func7(), hostMatrix = \n", hostMatrix

Dodam to, ponieważ nie widziałem tego w żadnej innej odpowiedzi i może być przydatne dla kogoś, kto zmaga się z czymś podobnym. globals()Funkcja zwraca zmienny słownika globalny symbol, gdzie można „magicznie” dostępne do reszty kodu dane wprowadzić. Na przykład:

from pickle import load
def loaditem(name):
    with open(r"C:\pickle\file\location"+"\{}.dat".format(name), "rb") as openfile:
        globals()[name] = load(openfile)
    return True

i

from pickle import dump
def dumpfile(name):
    with open(name+".dat", "wb") as outfile:
        dump(globals()[name], outfile)
    return True

Pozwoli tylko zrzucić / załadować zmienne zi do globalnej przestrzeni nazw. Super wygodne, bez musków, bez zamieszania. Jestem pewien, że to tylko Python 3.

Odwołaj się do przestrzeni nazw klas, w której chcesz pokazać zmianę.

W tym przykładzie runner używa max z konfiguracji pliku. Chcę, aby mój test zmienił wartość maks gdy biegacz go używa.

main / config.py

max = 15000

main / runner.py

from main import config
def check_threads():
    return max < thread_count 

testy / runner_test.py

from main import runner                # <----- 1. add file
from main.runner import check_threads
class RunnerTest(unittest):
   def test_threads(self):
       runner.max = 0                  # <----- 2. set global 
       check_threads()

Globale są w porządku - z wyjątkiem wieloprocesowego

Globalne w związku z wieloprocesowym przetwarzaniem na różnych platformach / środowiskach, takich jak Windows / Mac OS z jednej strony i Linux z drugiej, są kłopotliwe.

Pokażę to na prostym przykładzie, wskazując problem, na który wpadłem jakiś czas temu.

Jeśli chcesz zrozumieć, dlaczego sprawy różnią się w systemach Windows / MacO i Linux, musisz to wiedzieć, domyślny mechanizm uruchamiania nowego procesu w ...

• Windows / MacO to „spawn”
• Linux to „widelec”

Różnią się one inicjalizacją przydziału pamięci ... (ale nie wchodzę w to tutaj).

Rzućmy okiem na problem / przykład ...

import multiprocessing

counter = 0

def do(task_id):
    global counter
    counter +=1
    print(f'task {task_id}: counter = {counter}')

if __name__ == '__main__':

    pool = multiprocessing.Pool(processes=4)
    task_ids = list(range(4))
    pool.map(do, task_ids)

Windows

Jeśli uruchomisz to w systemie Windows (i przypuszczam, że także w systemie MacOS), otrzymasz następujące dane wyjściowe ...

task 0: counter = 1
task 1: counter = 2
task 2: counter = 3
task 3: counter = 4

Linux

Jeśli uruchomisz to w systemie Linux, zamiast tego otrzymasz następujące.

task 0: counter = 1
task 1: counter = 1
task 2: counter = 1
task 3: counter = 1