Глобальные переменные в Python: сохранить локальную переменную от вызова к вызову функции
У меня есть функция, которой необходимо сохранять значение от вызова к вызову, при этом это значение используется только в этой функции. Как правильно использовать глобальные переменные в Python? Я пробовал написать нечто подобное:
Но данный код не работает. Может есть другие способы решения данной задачи?
Есть несколько способов реализовать подобное поведение.
Глобальные переменные
Первое, что может прийти в голову, это использовать глобальные переменные.
Важно учитывать то, что глобальные переменные доступы на чтение
но простое использование на запись не разрешается:
Более того, при попытке обратиться к переменной сначала на чтение, потом на запись, мы получим ошибку:
Это происходит из-за того, что использование присваивания переменной z обозначает её, как локальную (как в случае 2). Попытка вывести значение локальной переменной, у которой ещё не задано значение, как раз и порождает возникновение этой ошибки.
Аналогичный пример как раз приведён в вашем вопросе. Там тоже переменная someGlobalVar определяется, как локальная, потому что выполняется присваивание. Так как в этом присваивании используется сначала чтение значения ещё не инициализированной переменной someGlobalVar , мы получаем ту же ошибку.
Для того, чтобы этот пример работал, необходимо предварительно пометить переменную, как global :
Аналогично будет работать и в вашем случае.
Использование поля функции
Второй способ, который может прийти в голову, это использование объекта функции для хранения состояния функции.
В этом способе удобно то, что значение ассоциировано с самой функцией.
Стоит быть осторожным, давая имена подобным полям функции, так как в Python 2 у функции есть стандартные поля с названиями, не начинающимися с двух подчёркиваний, например, func_closure , func_code и т.п. Все они начинаются с func_ , поэтому главное не использовать этот префикс и не начинать название поля с __ , в остальных случаях шанс коллизии имён практически равен нулю.
Использование класса с поведением функции
Третий способ заключается в создании класса с поведением функции. Это наиболее удобный и безопасный, по моему мнению, способ реализации подобного поведения. Просто создайте класс и перегрузите его метод __call__ :
Это увеличивает объём кода, но добавляет удобств от использования функциональности класса.
Использование изменяемого объекта, как значение по умолчанию для параметра
Четвёртый способ заключается в том, чтобы создать функцию, у которой будет необязательный параметр, использующий изменяемое значение в качестве состояния:
В качестве объекта состояния можно использовать любой изменяемый объект. Это использует то, что все значения по умолчанию присваиваются один раз.
Использование декоратора, выполняющего необходимые вычисления
Если вернуться к исходному примеру, то для подсчёта числа вызовов функции будет также может быть удобно использовать декораторы. Это позволит в том числе и переиспользовать код.
Для Python 3 код может выглядеть, например, так:
В Python 2 нет nonlocal , но можно использовать изменяемые переменные:
Использоваться это будет следующим образом:
При желании вы можете скомбинировать этот способ с каким-нибудь из описанных ранее.
Из всех выше упомянутых способов я бы рекомендовал использовать классы (так как функция с изменяющимся состоянием уже больше похожа на класс, чем на функцию) или поле функции, в случае необходимости быстрого добавления функциональности в код.
Как получить(вернуть) значение переменной из функции в python 3?
Совсем не могу понять логику.
Написал короткий код для эксперимента.
Что я делаю не так?
Спасибо.
- Вопрос задан более трёх лет назад
- 28608 просмотров
- Вконтакте
- Вконтакте
Есть три варианта:
1. Использовать глобальную переменную
2. Вернуть тербуемое значение как значение функции и присвоить в переменную которая передана
3. Вернуть значение в списке переданном как параметр
Первый вариант — не слишком хорош т.к. глобальных переменных в большой программе может быть очень много и это приводит к сложностям сопровождения кода программы.
Второй вариант — довольно удобен, но нужно не забывать присваивать значение возвращаемое из функции.
Третий вариант — вообще экзотика, но и он иногда бывает востребован, особенно в рекурсиях или при работе с потоками (когда из потока хочется получить результат).
Глобальные, локальные и нелокальные переменные в Python
В этом руководстве вы узнаете о глобальных, локальных и нелокальных переменных в Python и о том, где и как их использовать.
Глобальные переменные
В Python переменная, объявленная вне функции или в глобальной области видимости, называется глобальной переменной. К глобальной переменной можно получить доступ как внутри, так и вне функции.
Давайте посмотрим на примере, как в Python создается глобальная переменная.
Пример 1. Создаем глобальную переменную
Вывод:
В приведенной выше программе мы создали глобальную переменную x и задали функцию foo() , которая выводит на экран значение x . В коде программы мы вызвали функцию foo() , которая напечатала значение x внутри функции. Как вы видите, оно совпадает со значением x вне функции.
А что если нужно изменить значение x внутри функции?
Вывод:
Python выдает ошибку, потому что он обрабатывает x как локальную переменную, но x при этом не определена внутри функции foo() .
Чтобы исправить эту ошибку, нам понадобится ключевое слово global . О том, что это такое и как оно работает, подробнее можете почитать в статье «Ключевое слово global».
Локальные переменные
Переменная, объявленная внутри тела функции или в локальной области видимости, называется локальной переменной.
Пример 2. Доступ к локальной переменной вне области видимости
Вывод:
Python выдает ошибку, потому что мы пытаемся получить доступ к локальной переменной y в глобальной области видимости. Так делать нельзя: локальная переменная y «существует» только внутри функции foo() .
Давайте рассмотрим пример, который демонстрирует, как в Python создаются локальные переменные.
Пример 3. Создаем локальную переменную
Мы создаем локальные переменные, когда, например, объявляем переменные внутри функции.
Вывод:
Теперь вернитесь к программе, в которой x была глобальной переменной, а нам нужно было изменить эту переменную внутри функции foo() .
Глобальные и локальные переменные
В этом разделе мы поговорим о том, как использовать глобальные и локальные переменные в одной программе.
Пример 4. Локальные и глобальные переменные в одной программе
Вывод:
В приведенном выше программе мы объявили глобальную переменную x и локальную переменную y внутри функции foo() . Затем мы использовали оператор умножения, чтобы изменить глобальную переменную x , и вывели на экран значения переменных x и y .
После вызова функции foo() значение x становится равным «глобальная переменная глобальная переменная» , потому что внутри функции строка «глобальная переменная» умножается на два. Затем функция foo() выводит на экран новое значение x и значение переменной y — «локальная переменная» .
Пример 5. Глобальная и локальная переменные с одинаковым именем
Вывод:
В приведенной выше программе мы использовали одно и то же имя x как для глобальной переменной, так и для локальной переменной. Python выводит разные значения переменных x , потому что локальная переменная объявлена внутри функции `foo()`, а другая — вне ее, то есть в глобальной области видимости.
Когда мы печатаем переменную x внутри функции foo() , на экран выводится сообщение «локальная переменная x: 10» . Это называется локальной областью видимости переменной.
Когда мы печатаем переменную x за пределами foo() , на экран выводится сообщение «глобальная переменная x: 5» . Это называется глобальной областью видимости переменной.
Нелокальные переменные
Нелокальные переменные используются во вложенных функциях, локальная область видимости которых не определена. Это означает, что переменная может не находиться ни в локальной, ни в глобальной области.
Давайте на примере рассмотрим, как нелокальная переменная работает в Python.
Для этого нам понадобится ключевое слово nonlocal .
Пример 6. Создаем нелокальную переменную
Вывод:
В приведенной выше программе есть вложенная функция inner() . Для создания нелокальной переменной мы используем ключевое слово nonlocal . Функция inner() определяется внутри функции outer() .
Примечание. Если мы изменим значение нелокальной переменной, изменится и значение локальной переменной.