How to use a global variable in a function?

Как мне создать или использовать глобальную переменную внутри функции?

Как мне использовать глобальную переменную, которая была определена в одной функции, внутри других функций?

_{Неспособность использовать global ключевое слово там, где это уместно, часто приводит к UnboundLocalError. Точные правила для этого описаны в UnboundLocalError для локальной переменной при переназначении после первого использования. Как правило, пожалуйста, закрывайте другие вопросы как дублирующие этот вопрос, когда требуется объяснение, и этот вопрос, когда кому-то просто нужно знать global ключевое слово.}

Вы можете использовать глобальную переменную в других функциях, объявив ее как global в каждой функции, которая присваивает ей значение:

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

Поскольку неясно, globvar = 1 создается локальная переменная или изменяется глобальная переменная, Python по умолчанию создает локальную переменную и заставляет вас явно выбирать другое поведение с помощью global ключевого слова.

Посмотрите другие ответы, если вы хотите разделить глобальную переменную между модулями.

Если я правильно понимаю вашу ситуацию, то то, что вы видите, является результатом того, как Python обрабатывает локальные (функция) и глобальные (модуль) пространства имен.

Допустим, у вас есть такой модуль:

# sample.py
_my_global = 5

def func1():
    _my_global = 42

def func2():
    print _my_global

func1()
func2()

Возможно, вы ожидали, что это выведет 42, но вместо этого выводится 5. Как уже упоминалось, если вы добавите объявление 'global' в func1(), то func2() будет выведено 42.

def func1():
    global _my_global 
    _my_global = 42

Здесь происходит то, что Python предполагает, что любое имя, присвоенное в любом месте внутри функции, является локальным для этой функции, если явно не указано иное. Если он только считывает имя, а имя не существует локально, он попытается найти имя во всех содержащих областях (например, в глобальной области модуля).

Таким образом, когда вы присваиваете 42 имени _my_global, Python создает локальную переменную, которая затеняет глобальную переменную с тем же именем. Эта локальная переменная выходит за пределы области видимости и собирается как мусор при func1() возврате; между тем, func2() никогда не сможет увидеть ничего, кроме (неизмененного) глобального имени. Обратите внимание, что это решение о пространстве имен происходит во время компиляции, а не во время выполнения - если бы вы прочитали значение _my_global inside func1() перед присвоением ему, вы бы получили UnboundLocalError, потому что Python уже решил, что это должна быть локальная переменная, но с ней еще не было связано никакого значения. Но, используя оператор 'global' , вы сообщаете Python, что он должен искать имя в другом месте, а не присваивать ему локально.

(Я полагаю, что такое поведение возникло в основном из-за оптимизации локальных пространств имен - без такого поведения виртуальной машине Python потребовалось бы выполнять как минимум три поиска имен каждый раз, когда внутри функции присваивается новое имя (чтобы убедиться, что имя еще не существует на уровне модуля / встроенной системы), что значительно замедлило бы очень распространенную операцию.)

Возможно, вы захотите изучить понятие пространств имен. В Python модуль является естественным местом для глобальных данных:

Каждый модуль имеет свою собственную таблицу символов, которая используется в качестве глобальной таблицы символов всеми функциями, определенными в модуле. Таким образом, автор модуля может использовать глобальные переменные в модуле, не беспокоясь о случайных столкновениях с глобальными переменными пользователя. С другой стороны, если вы знаете, что делаете, вы можете обращаться к глобальным переменным модуля с теми же обозначениями, которые используются для обозначения его функций, modname.itemname.

Конкретное использование global-in-a-module описано здесь - Как мне разделить глобальные переменные между модулями?, и для полноты картины содержимое представлено здесь:

Канонический способ обмена информацией между модулями в рамках одной программы заключается в создании специального модуля конфигурации (часто называемого config или cfg). Просто импортируйте модуль конфигурации во все модули вашего приложения; затем модуль становится доступным как глобальное имя. Поскольку существует только один экземпляр каждого модуля, любые изменения, внесенные в объект module, отражаются везде. Например:

Файл: config.py

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

Файл: mod.py

import config
config.x = 1

Файл: main.py

import config
import mod
print config.x

Python использует простую эвристику, чтобы решить, из какой области видимости следует загружать переменную, между локальной и глобальной. Если имя переменной отображается в левой части присваивания, но не объявлено глобальным, предполагается, что оно локальное. Если она не отображается в левой части присваивания, предполагается, что она глобальная.

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

Посмотрите, как baz, который отображается в левой части присваивания в foo(), является единственной LOAD_FAST переменной.