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

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

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

a = '' def func(): a = input() if not a: print('a is empty') else: print('a is not empty') func() 

Этот код условно должен проверять a — это пустая переменная или нет. Как мне сделать, чтобы пустая строка a заменилась на то, что введет пользователь и запомнилась глобально?

Отслеживать
73.1k 107 107 золотых знаков 38 38 серебряных знаков 55 55 бронзовых знаков
задан 18 ноя 2021 в 20:44
21 2 2 бронзовых знака

6 ответов 6

Сортировка: Сброс на вариант по умолчанию

Глобальные переменные плохи не от того, что они задаются описателем global . Они плохи потому, что неявное описание переменных усложняет логику программ, ее читаемость, отлаживаемость и предсказуемость результатов. Вы их или используете (и неважно как ) или нет. А если используете — то точно понимая все риски и точно понимая, зачем вы на них идете. И ответив (хотя-бы себе) на вопрос — а без них можно?

А если делать все «как положено» — то просто передаете переменную в функцию явно, а в функции выполняете свои проверки и модификации. Только и всего — просто и понятно.

Отслеживать
68k 5 5 золотых знаков 20 20 серебряных знаков 51 51 бронзовый знак
ответ дан 18 ноя 2021 в 20:57
11.6k 2 2 золотых знака 10 10 серебряных знаков 16 16 бронзовых знаков

def func(a): # a = input() if not a: print('\na is empty') a = f'a is empty --> ``' else: print('\na is not empty') a = f'a is not empty --> ``' return a a = '' a = func(a) print(f'1. a = ') a = 'Hello' a = func(a) print(f'2. a = ') 

Отслеживать
ответ дан 18 ноя 2021 в 20:57
73.1k 107 107 золотых знаков 38 38 серебряных знаков 55 55 бронзовых знаков

Лучше передать функции эту переменную, провести с ней какие-то действия, и вернуть результат функции через ‘return’, и переписать переменную.

Отслеживать
ответ дан 18 ноя 2021 в 20:56
405 2 2 серебряных знака 7 7 бронзовых знаков
Чем это отличается от уже данного ответа?
18 ноя 2021 в 21:43
Тем что он дан раньше
19 ноя 2021 в 7:46
Ой, сорри. Не заметил из очереди.
19 ноя 2021 в 7:52
Ничего страшного)
19 ноя 2021 в 8:09

Вынеси переменную за блок функций

a = 1 b = 2 def ab(): print(a + b) 

Отслеживать
ответ дан 19 ноя 2021 в 4:02
IPOleksenko IPOleksenko
82 9 9 бронзовых знаков

Ну это на самом деле и есть глобальные переменные. Просто пока вы их не модифицируете в функции, питон не требует использовать в ней ключевое слово global

19 ноя 2021 в 4:16

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

Вот в этом случае можно завести, например, специальный класс, который хранит эти параметры, а все ваши функции берут параметры из полей этого класса. А сам этот класс может загружать параметры из файла, например. Класс этот можно вынести в отдельный файл и импортировать этот файл когда нужны эти параметры.

Хотя по сути класс — это тоже в общем-то глобальная переменная, но класс — это лучше, чем переменная, переменные обычно называют абы как, а у класса скорее всего будет выделенное «говорящее» название и в одном классе будет собрано много параметров, а не так, что много глобальных переменных непонятно откуда взявшихся, ищи потом, откуда они, как и чего.

Ещё в случае, если вам нужно менять какие-то переменные в нескольких функциях, удобно вынести эти переменные в какой-то класс опять же, а функции сделать методами этого класса. Тогда эти функции-методы будут иметь прямой доступ к этим переменным-полям, при этом они не будут засорять этими переменными глобальное пространство имён и мешать другим функциям/классам. Чем и хороша собственно инкапсуляция — один из трёх принципов, на которых стоит ООП.

Использование глобальных переменных в функциях

Иногда возникает необходимость в использовании глобальных переменных в функциях. Глобальная переменная — это такая переменная, которая определена вне функции и может быть использована в любой части программы, включая функции.

Типичная проблема

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

x = 10 def change_x(): x = 5 change_x() print(x)

В данном случае ожидается, что переменная x изменит свое значение на 5 после вызова функции change_x() . Однако, когда программа выводит значение x с помощью print(x) , оно все еще равно 10 . Почему так происходит?

Пояснение

Проблема возникает из-за области видимости переменных в Python. Когда в функции создается переменная с тем же именем, что и глобальная переменная, Python предполагает, что это новая локальная переменная, которая существует только внутри функции.

Решение

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

x = 10 def change_x(): global x x = 5 change_x() print(x)

Теперь, когда функция change_x() вызывается, она изменяет глобальную переменную x на 5 , и print(x) выводит 5 .

Использование глобальной переменной в других функциях

Глобальные переменные также можно использовать в других функциях. Например:

x = 10 def print_x(): print(x) print_x()

В этом случае функция print_x() выводит значение глобальной переменной x , которое равно 10 .

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

Глобальные, локальные и нелокальные переменные в Python

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

Глобальные переменные

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

Давайте посмотрим на примере, как в Python создается глобальная переменная.

Пример 1. Создаем глобальную переменную

x = "глобальная переменная" def foo(): print("x внутри функции:", x) foo() print("x вне функции:", x) 

Вывод:

x внутри функции: глобальная переменная x вне функции: глобальная переменная

В приведенной выше программе мы создали глобальную переменную x и задали функцию foo() , которая выводит на экран значение x . В коде программы мы вызвали функцию foo() , которая напечатала значение x внутри функции. Как вы видите, оно совпадает со значением x вне функции.

А что если нужно изменить значение x внутри функции?

x = "глобальная переменная" def foo(): x = x * 2 print(x) foo() 

Вывод:

UnboundLocalError: local variable 'x' referenced before assignment

Python выдает ошибку, потому что он обрабатывает x как локальную переменную, но x при этом не определена внутри функции foo() .

Чтобы исправить эту ошибку, нам понадобится ключевое слово global . О том, что это такое и как оно работает, подробнее можете почитать в статье «Ключевое слово global».

Локальные переменные

Переменная, объявленная внутри тела функции или в локальной области видимости, называется локальной переменной.

Пример 2. Доступ к локальной переменной вне области видимости

def foo(): y = "локальная переменная" foo() print(y)

Вывод:

NameError: name 'y' is not defined

Python выдает ошибку, потому что мы пытаемся получить доступ к локальной переменной y в глобальной области видимости. Так делать нельзя: локальная переменная y «существует» только внутри функции foo() .

Давайте рассмотрим пример, который демонстрирует, как в Python создаются локальные переменные.

Пример 3. Создаем локальную переменную

Мы создаем локальные переменные, когда, например, объявляем переменные внутри функции.

def foo(): y = "локальная переменная" print(y) foo()

Вывод:

локальная переменная

Теперь вернитесь к программе, в которой x была глобальной переменной, а нам нужно было изменить эту переменную внутри функции foo() .

Глобальные и локальные переменные

В этом разделе мы поговорим о том, как использовать глобальные и локальные переменные в одной программе.

Пример 4. Локальные и глобальные переменные в одной программе

x = "глобальная переменная" def foo(): global x y = "локальная переменная" x = x * 2 print(x) print(y) foo()

Вывод:

глобальная переменная глобальная переменная локальная переменная

В приведенном выше программе мы объявили глобальную переменную x и локальную переменную y внутри функции foo() . Затем мы использовали оператор умножения, чтобы изменить глобальную переменную x , и вывели на экран значения переменных x и y .

После вызова функции foo() значение x становится равным «глобальная переменная глобальная переменная» , потому что внутри функции строка «глобальная переменная» умножается на два. Затем функция foo() выводит на экран новое значение x и значение переменной y — «локальная переменная» .

Пример 5. Глобальная и локальная переменные с одинаковым именем

x = 5 def foo(): x = 10 print("локальная переменная x:", x) foo() print("глобальная переменная x:", x)

Вывод:

локальная переменная x: 10 глобальная переменная x: 5

В приведенной выше программе мы использовали одно и то же имя x как для глобальной переменной, так и для локальной переменной. Python выводит разные значения переменных x , потому что локальная переменная объявлена внутри функции `foo()`, а другая — вне ее, то есть в глобальной области видимости.

Когда мы печатаем переменную x внутри функции foo() , на экран выводится сообщение «локальная переменная x: 10» . Это называется локальной областью видимости переменной.

Когда мы печатаем переменную x за пределами foo() , на экран выводится сообщение «глобальная переменная x: 5» . Это называется глобальной областью видимости переменной.

Нелокальные переменные

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

Давайте на примере рассмотрим, как нелокальная переменная работает в Python.

Для этого нам понадобится ключевое слово nonlocal .

Пример 6. Создаем нелокальную переменную

def outer(): x = "локальная переменная" def inner(): nonlocal x x = "нелокальная переменная x" print("вложенная функция:", x) inner() print(":", x) outer()

Вывод:

вложенная функция: нелокальная переменная внешняя функция: нелокальная переменная

В приведенной выше программе есть вложенная функция inner() . Для создания нелокальной переменной мы используем ключевое слово nonlocal . Функция inner() определяется внутри функции outer() .

Примечание. Если мы изменим значение нелокальной переменной, изменится и значение локальной переменной.

СodeСhick.io — простой и эффективный способ изучения программирования.

2023 © ООО «Алгоритмы и практика»

Как использовать global и nonlocal переменные в Python

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

Мы начнем с краткого руководства по областям видимости переменных, прежде чем мы расскажем, как и почему использовать глобальные и нелокальные переменные в ваших собственных функциях.

Области видимости в Python

Прежде чем мы сможем начать, мы сначала должны коснуться областей. Для тех из вас, кто не знаком, «область видимости» относится к контексту, в котором определяется переменная и как к ней можно получить доступ или изменить или, более конкретно, откуда она может быть получена.

И в программировании, как и в жизни, важен контекст.

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

Глобальная и локальная области видимости — это то, как ваша программа понимает контекст переменной, на которую вы ссылаетесь.

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

Локальные переменные в Python

Поняв это, давайте посмотрим на это в действии. Мы начнем с определения функции с ее собственной локальной переменной внутри. В этой функции у нас есть переменная fruit , которую мы инициализируем как список и печатаем:

def shopping_list(): fruit = ['apple', 'banana'] print(fruit) shopping_list() 

Как и ожидалось, этот код выведет нам:

['apple', 'banana'] 

Но что происходит, когда мы перемещаем оператор печати за пределы функции?

def shopping_list(): fruit = ['apple', 'banana'] shopping_list() print(fruit) 

Мы получаем ошибку:

Traceback (most recent call last): File "", line 5, in NameError: name 'fruit' is not defined 

В частности, NameError , поскольку fruit был определен локально и поэтому остается ограниченным в этом контексте.

Чтобы наша программа могла понимать переменную глобально (вне функции), нам нужно определить ее глобально.

Глобальные переменные в Python

Что, если вместо первоначального определения нашей переменной внутри функции мы переместим ее наружу и инициализируем там?

В этом случае мы можем ссылаться на нее вне функции, и все работает.

Но если мы попытаемся переопределить переменную fruit внутри shopping_list , эти изменения не будут обновлены до исходной глобальной переменной, а будут изолированы локально:

fruit = ['apple', 'banana'] def shopping_list(): fruit = ['apple', 'banana', 'grapes'] shopping_list() print(fruit) 

['apple', 'banana'] 

Это потому, что fruit мы изменили в функции shopping_list() создав новую локальную переменную. Мы создали ее, присвоили ей значение и после этого ничего не сделали. Это фактически полностью избыточный код. print() выводит значение глобальной переменной.

Ключевое слово global

Если мы хотим, чтобы эти изменения отражались в нашей глобальной переменной, вместо того, чтобы создавать новую локальную, все, что нам нужно сделать, это добавить ключевое слово global . Это позволяет нам сообщить, что переменная fruit действительно является глобальной переменной:

fruit = ['pineapple', 'grapes'] def shopping_list(): global fruit fruit = ['pineapple', 'grapes', 'apple', 'banana'] shopping_list() print(fruit) 

И, конечно же, глобальная переменная модифицируется новыми значениями, поэтому, когда мы вызываем print(fruit) , новые значения печатаются:

['pineapple', 'grapes', 'apple', 'banana'] 

Определив контекст переменной fruit, которую мы называем глобальной, мы можем затем переопределить и изменить его, насколько нам нравится, зная, что изменения, которые мы вносим в функцию, будут перенесены.

Мы также могли бы определить глобальную переменную в нашей функции и иметь возможность ссылаться на нее и получать к ней доступ в любом другом месте.

def shopping_list(): global fruit fruit = ['pineapple', 'grapes', 'apple', 'banana'] shopping_list() print(fruit) 

['pineapple', 'grapes', 'apple', 'banana'] 

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

def shopping_list(): global fruit fruit = ['pineapple', 'grapes', 'apple', 'banana'] def print_list(): print(fruit) shopping_list() print(fruit) print_list() 

['pineapple', 'grapes', 'apple', 'banana'] ['pineapple', 'grapes', 'apple', 'banana'] 

Осторожность при использовании глобальных переменных

Хотя возможность локально изменять глобальную переменную — это небольшой удобный инструмент, к нему нужно относиться с некоторой осторожностью. Чрезмерное переписывание и переопределение области видимости — это рецепт катастрофы, которая заканчивается ошибками и неожиданным поведением.

Всегда важно убедиться, что вы манипулируете переменной только в том контексте, который вам нужен, а в противном случае, оставив его в покое, это основной движущий принцип принципа инкапсуляции.

Мы быстро рассмотрим пример потенциальной проблемы, прежде чем перейти к некоторым из способов, которыми глобальные переменные могут быть полезны в вашем собственном коде:

fruit = ['pineapple', 'grapes', 'apple', 'banana'] def first_item(): global fruit fruit = fruit[0] def iterate(): global fruit for entry in fruit: print(entry) iterate() print(fruit) first_item() print(fruit) 

Запустив приведенный выше код, мы получим следующий вывод:

pineapple grapes apple banana ['pineapple', 'grapes', 'apple', 'banana'] pineapple 

В этом примере мы ссылаемся на переменную в обеих функциях first_item() и iterate() . Все вроде работает нормально, если вызвать iterate() и потом first_item() .

Если мы изменим этот порядок или попытаемся повторить его позже, мы столкнемся с большой проблемой:

first_item() print(fruit) iterate() print(fruit) 

Теперь это выводит:

pineapple p i n e a p p l e pineapple 

А именно, теперь fruit это строка, которая будет повторяться. Что еще хуже, эта ошибка не проявляется, пока, по-видимому, не станет слишком поздно. Первый код вроде бы работал нормально.

Теперь эта проблема очевидна намеренно. Мы напрямую изменили глобальную переменную — и вот, она изменилась. Однако в более сложных структурах можно случайно зайти слишком далеко от модификации глобальной переменной и получить неожиданные результаты.

Ключевое слово nonlocal

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

Для тех из вас, кто использует Python 3+ , вы можете использовать ключевое слово nonlocal , которое действует аналогично global , но в основном действует при вложении в методы. nonlocal по сути образует промежуточное звено между глобальной и локальной областью.

Поскольку в большинстве наших примеров мы использовали списки покупок и фрукты, мы могли бы подумать о функции оформления заказа, которая суммирует сумму покупок:

def shopping_bill(promo=False): items_prices = [10, 5, 20, 2, 8] pct_off = 0 def half_off(): nonlocal pct_off pct_off = .50 if promo: half_off() total = sum(items_prices) - (sum(items_prices) * pct_off) print(total) shopping_bill(True) 

Запустив приведенный выше код, мы получим результат:

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

Вы всегда можете подтвердить это, попробовав распечатать pct_off не с помощью метода подсчета покупок:

NameError: name 'pct_off' is not defined 

Если бы мы использовали ключевое слово global вместо nonlocal , печать привела бы к pct_off :

Заключение

В конце концов, global (nonlocal) ключевые слова — это инструмент, и при правильном использовании они могут открыть множество возможностей для вашего кода. Лично я довольно часто использую оба этих ключевых слова в своем собственном коде, и при достаточной практике вы поймете, насколько мощными и полезными они могут быть.

Источник: