Как я могу создать или использовать глобальную переменную в функции?
Если я создаю глобальную переменную в одной функции, как я могу использовать эту глобальную переменную в другой функции? Нужно ли хранить глобальную переменную в локальной переменной функции, которой нужен доступ?
python
global-variables
scope
user46646
источник
источник
global
ключевое слово потому, что глобальные переменные опасны. Скорее, это потому, что язык не требует, чтобы вы явно объявляли переменные, и автоматически предполагает, что переменная, которую вы назначаете, имеет область действия функции, если вы не укажете иное.global
Ключевое слово является средством , которое предоставляется сказать иначе.f2()
состояние, чтобы теперьf3()
могло произойти что-то неожиданное? Функции теперь могут работать независимо от состояния внешней программы.Если я правильно понимаю вашу ситуацию, то, что вы видите, является результатом того, как Python обрабатывает локальные (функциональные) и глобальные (модульные) пространства имен.
Скажем, у вас есть такой модуль:
Вы могли бы ожидать, что это напечатает 42, но вместо этого оно печатает 5. Как уже упоминалось, если вы добавите объявление '
global
'func1()
, то выfunc2()
получите 42.Здесь происходит то, что Python предполагает, что любое имя, которое присваивается в любом месте функции, является локальным для этой функции, если явно не указано иное. Если это только чтение из имени, а имя не существует локально, оно попытается найти имя в любой содержащей области (например, в глобальной области видимости модуля).
myGlobal
Поэтому, когда вы назначаете 42 имени , Python создает локальную переменную, которая скрывает глобальную переменную с тем же именем. Это местный выходит из области видимости и сборки мусора , когдаfunc1()
возвращается; Между тем,func2()
никогда не вижу ничего, кроме (неизмененного) глобального имени. Обратите внимание, что это решение пространства имен происходит во время компиляции, а не во время выполнения - если бы вы прочитали значениеmyGlobal
insidefunc1()
перед тем, как присваивать ему, вы бы получилиUnboundLocalError
, потому что Python уже решил, что это должна быть локальная переменная, но это не имеет никакого значения, связанного с этим еще. Но используяglobal
оператор ' ', вы говорите Python, что он должен искать имя в другом месте, а не присваивать ему локально.(Я полагаю, что такое поведение возникло в основном за счет оптимизации локальных пространств имен - без этого поведения виртуальная машина Python должна была бы выполнять как минимум три поиска имен каждый раз, когда новое имя назначается внутри функции (чтобы гарантировать, что имя не уже существует на уровне модуля / встроенного), что значительно замедлит очень распространенную операцию.)
источник
MyGlobal = 5
x
локально, отличается от проверки во время выполнения, было ли локальное имя связано со значением до того, как оно использовалось в первый раз.MY_GLOBAL = 5
. Смотрите руководство по стилю для кода Python .Вы можете исследовать понятие пространств имен . В Python модуль является естественным местом для глобальных данных:
Конкретное использование global-in-a-module описано здесь - Как мне совместно использовать глобальные переменные между модулями? и для полноты содержания поделитесь здесь:
источник
config.x
могу ли я от нее избавиться? Я пришел с,x = lambda: config.x
а затем у меня есть новое значение вx()
. по какой-то причине наличиеa = config.x
не помогает мне.from config import x
решает?Python использует простую эвристику, чтобы решить, из какой области он должен загружать переменную, между локальной и глобальной. Если имя переменной появляется в левой части присваивания, но не объявлено как глобальное, оно считается локальным. Если он не отображается слева от присвоения, он считается глобальным.
Посмотрите, как
foo()
единственнаяLOAD_FAST
переменная - baz, которая появляется в левой части назначения .источник
for
цикла и имя после операторовas
inwith
иexcept
также связаны с.as
вexcept
предложении это не было очевидно для меня. Но он автоматически удаляется для экономии памяти.as ...
цель в обработчике исключений.Если вы хотите сослаться на глобальную переменную в функции, вы можете использовать ключевое слово global, чтобы объявить, какие переменные являются глобальными. Вам не нужно использовать его во всех случаях (как здесь неправильно утверждают) - если имя, на которое есть ссылка в выражении, не может быть найдено в локальной области видимости или области действия в функциях, в которых определена эта функция, оно ищется среди глобальных переменные.
Однако если вы присваиваете новую переменную, не объявленную как глобальную в функции, она неявно объявляется как локальная и может затмить любую существующую глобальную переменную с тем же именем.
Кроме того, глобальные переменные полезны, в отличие от некоторых фанатиков ООП, которые утверждают иначе - особенно для небольших сценариев, где ООП является избыточным.
источник
Мы можем создать глобал с помощью следующей функции:
Написание функции фактически не запускает ее код. Итак, мы вызываем
create_global_variable
функцию:Использование глобалов без изменений
Вы можете просто использовать его, если вы не собираетесь изменять, на какой объект он указывает:
Например,
и теперь мы можем использовать глобальную переменную:
Модификация глобальной переменной изнутри функции
Чтобы указать глобальную переменную на другой объект, необходимо снова использовать ключевое слово global:
Обратите внимание, что после написания этой функции код, фактически изменяющий ее, все еще не выполняется:
Итак, после вызова функции:
мы можем видеть, что глобальная переменная была изменена.
global_variable
Имя теперь указывает на'Bar'
:Обратите внимание, что «глобальный» в Python не является действительно глобальным - он только глобален для уровня модуля. Так что он доступен только для функций, написанных в модулях, в которых он является глобальным. Функции запоминают модуль, в котором они написаны, поэтому, когда они экспортируются в другие модули, они все равно ищут модуль, в котором они были созданы, чтобы найти глобальные переменные.
Локальные переменные с тем же именем
Если вы создадите локальную переменную с тем же именем, она заменит глобальную переменную:
Но использование этой неправильно названной локальной переменной не меняет глобальную переменную:
Обратите внимание, что вам следует избегать использования локальных переменных с такими же именами, как у глобальных, если вы точно не знаете, что делаете, и у вас есть веская причина для этого. Я еще не сталкивался с такой причиной.
Мы получаем то же самое поведение в классах
Последующий комментарий комментирует:
Здесь я демонстрирую, что мы получаем то же поведение в методах, что и в обычных функциях:
И сейчас:
Но я бы предложил вместо использования глобальных переменных использовать атрибуты класса, чтобы не загромождать пространство имен модуля. Также обратите внимание, что
self
здесь мы не используем аргументы - это могут быть методы класса (удобно, если мутирует атрибут класса из обычногоcls
аргумента) или статические методы (нетself
илиcls
).источник
В дополнение к уже существующим ответам и сделать это более запутанным:
Источник: Каковы правила для локальных и глобальных переменных в Python? ,
источник
При параллельном выполнении глобальные переменные могут привести к неожиданным результатам, если вы не понимаете, что происходит. Вот пример использования глобальной переменной в многопроцессорной обработке. Мы можем ясно видеть, что каждый процесс работает со своей собственной копией переменной:
Вывод:
источник
То, что вы говорите, это использовать метод следующим образом:
Но лучший способ - использовать глобальную переменную следующим образом:
Оба дают одинаковый результат.
источник
Как оказалось, ответ всегда прост.
Вот небольшой пример модуля с простым способом показать его в
main
определении:Вот как это показать в
main
определении:Этот простой код работает так же, и он будет выполняться. Я надеюсь, что это помогает.
источник
global_vars
и инициализирую данныеinit_global_vars
, которые вызываются в скрипте запуска. Затем я просто создаю метод доступа для каждого определенного глобального var. Я надеюсь, что смогу поднять это несколько раз! Спасибо, Питер!Вам нужно ссылаться на глобальную переменную в каждой функции, которую вы хотите использовать.
Следующее:
источник
Вы на самом деле не храните глобальную переменную в локальной переменной, а просто создаете локальную ссылку на тот же объект, на который ссылается ваша исходная глобальная ссылка. Помните, что почти все в Python - это имя, относящееся к объекту, и ничто не копируется в обычной операции.
Если вам не нужно было явно указывать, когда идентификатор должен ссылаться на предопределенную глобальную переменную, вам, вероятно, придется явно указывать, когда вместо этого идентификатор является новой локальной переменной (например, с чем-то вроде команды 'var'). видел в JavaScript). Поскольку локальные переменные встречаются чаще, чем глобальные переменные в любой серьезной и нетривиальной системе, в большинстве случаев система Python имеет больше смысла.
Вы может быть язык, который пытается угадать, используя глобальную переменную, если она существует, или создавая локальную переменную, если она не существует. Однако это было бы очень подвержено ошибкам. Например, импорт другого модуля может непреднамеренно ввести глобальную переменную с таким именем, что приведет к изменению поведения вашей программы.
источник
Попробуй это:
источник
Если у вас есть локальная переменная с тем же именем, вы можете использовать эту
globals()
функцию .источник
В качестве дополнения используйте файл, содержащий все глобальные переменные, объявленные локально, а затем
import as
:Файл initval.py :
Файл getstocks.py :
источник
import ... as ...
? Почему не простоimport ...
?global
:-) => +1 :-) Пожалуйста, отредактируйте свой ответ, чтобы уточнить эти допросы, которые могут быть и у других людей. ПриветствияЗапись в явные элементы глобального массива, по-видимому, не нуждается в глобальном объявлении, хотя запись в него «оптовым» действительно имеет это требование:
источник
Я добавляю это, поскольку я не видел это ни в одном из других ответов, и это могло бы быть полезным для кого-то, борющегося с чем-то подобным.
globals()
Функция возвращает изменяемый словарь глобальный символ , где вы можете «волшебно» данные сделать доступными для остальной части кода. Например:а также
Просто позволит вам выгружать / загружать переменные из и в глобальное пространство имен. Супер удобно, без суеты, без суеты. Уверен, что это только Python 3.
источник
globals()
всегда возвращает глобальные переменные, доступные в локальном контексте, поэтому мутация здесь может не отражаться в другом модуле.Ссылка на пространство имен класса, где вы хотите, чтобы изменения отображались.
В этом примере бегун использует max из файла config. Я хочу, чтобы мой тест изменил значение max, когда бегун его использует.
Основной / config.py
Основной / runner.py
Тесты / runner_test.py
источник
Глобалы в порядке - за исключением многопроцессорной обработки
Глобальные связи в связи с многопроцессорностью на разных платформах / средах, таких как Windows / Mac OS с одной стороны и Linux с другой, являются проблематичными.
Я покажу вам это на простом примере, указывающем на проблему, с которой я столкнулся некоторое время назад.
Если вы хотите понять, почему в Windows / MacO и Linux все по-другому, вам нужно это знать, механизм по умолчанию для запуска нового процесса ...
Они отличаются в распределении памяти при инициализации ... (но я не буду вдаваться в подробности).
Давайте посмотрим на проблему / пример ...
Windows
Если вы запустите это в Windows (и я полагаю, в MacOS тоже), вы получите следующий вывод ...
Linux
Если вы запустите это в Linux, вы получите следующее.
источник