Как изменить переменную вне функции python

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

С другой стороны, переменная, объявленная внутри определенного блока кода, будет видна только внутри этого же блока — она называется локальной.

Разберемся с этими понятиями на примере.

Пример локальных и глобальных переменных

def sum():  
    a = 10   # локальные переменные 
    b = 20  
    c = a + b  
    print("Сумма:", c)  
  
sum() 

Вывод: Сумма: 30.

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

Для решения этой проблемы используются глобальные переменные.

Теперь взгляните на этот пример с глобальными переменными:

a = 20  # определены вне функции
b = 10  


def sum():  
    c = a + b  # Использование глобальных переменных  
    print("Сумма:", c)  

  
def sub():  
    d = a - b  # Использование глобальных переменных 
    print("Разница:", d)  
  
  
sum()
sub()

Вывод:

Сумма: 30
Разница: 10

В этом коде были объявлены две глобальные переменные: a и b. Они используются внутри функций sum() и sub(). Обе возвращают результат при вызове.

Если определить локальную переменную с тем же именем, то приоритет будет у нее. Посмотрите, как в функции msg это реализовано.

def msg():  
    m = "Привет, как дела?"  
    print(m)  
  
msg()  
m = "Отлично!"  # глобальная переменная
print(m) 

Вывод:

Привет, как дела?
Отлично!

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

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

Правила использования global

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

Пример без использования глобального ключевого слова.

c = 10  


def mul():
    c = c * 10 
    print(c) 


mul() 

Вывод:

line 5, in mul
    c = c * 10
UnboundLocalError: local variable 'c' referenced before assignment

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

c = 10  


def mul():
    global c
    c = c * 10 
    print("Значение в функции:", c)  

mul()  
print("Значение вне функции:", c)  

Вывод:

Значение в функции: 100
Значение вне функции: 100

Здесь переменная c была объявлена в функции mul() с помощью ключевого слова global. Ее значение умножается на 10 и становится равным 100. В процессе работы программы можно увидеть, что изменение значения внутри функции отражается на глобальном значении переменной.

Глобальные переменные в модулях Python

Преимущество использования ключевого слова global — в возможности создавать глобальные переменные и передавать их между модулями. Например, можно создать name.py, который бы состоял из глобальных переменных. Если их изменить, то изменения повлияют на все места, где эти переменные встречаются.

1. Создаем файл name.py для хранения глобальных переменных:

a = 10 
b = 20 
msg = "Hello World"

2. Создаем файл change.py для изменения переменных:

import name

name.a = 15  
name.b = 25
name.msg = "Dood bye"  

Меняем значения a, b и msg. Эти переменные были объявлены внутри name, и для их изменения модуль нужно было импортировать.

3. В третий файл выводим значения измененных глобальных переменных.

import name
import change

print(name.a) 
print(name.b)
print(name.msg)

Значение изменилось. Вывод:

15
25
Dood bye

Global во вложенных функциях

Можно использовать ключевое слово global во вложенных функциях.

def add():
    a = 15
  
    def modify():
        global a
        a = 20

    print("Перед изменением:", a)
    print("Внесение изменений")
    modify()
    print("После изменения:", a)


add()
print("Значение a:", a)  

Вывод:

Перед изменением: 15
Внесение изменений
После изменения: 15
Значение a: 20

В этом коде значение внутри add() принимает значение локальной переменной x = 15. В modify() оно переназначается и принимает значение 20 благодаря global. Это и отображается в переменной функции add().

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

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

Для создания переменных, обладающих локальной областью видимости, необходимо всего лишь поместить их в отдельный блок кода, изолированный от остальной программы. Чтобы увидеть локальную переменную в действии, достаточно инициализировать целочисленный объект с именем x и значением 100 в функции f, как это сделано в следующем примере:

def f():
    x = 100
    print(x)
f()

100

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

def f():
    x = 100
    print(x)
f()
print(x)

100
Traceback (most recent call last):
  File "main.py", line 5, in <module>
    print(x)
NameError: name 'x' is not defined

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

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

Чтобы иметь возможность использовать некоторое значение в любой части программы, следует объявить глобальную переменную. Для этого понадобиться создать переменную отдельно от области кода, ограниченной определенным блоком кода, например, функцией. В следующем примере демонстрируется идентификация целочисленного типа данных под названием x, который позже выводится на экран при помощи метода print в функции f:

x = 100
def f():
    print(x)
f()
print(x)

100
100

Как можно заметить из результатов выполнения программы, значение 100 воспроизводится не только через f, но и с помощью обычного print. Таким образом, получение доступа к x осуществляется из любой части кода, благодаря глобальной области видимости подобного объекта. Но что будет, если попытаться изменить значение глобальной переменной в некой функции? Результаты такого эксперимента представлены в следующем фрагменте кода:

x = 100
def f():
    x = 200
f()
print(x)

100

Функция f присваивает значение 200 переменной с именем x, однако, вопреки ожиданиям, внешний метод print выводит число 100, которое принадлежало x изначально. Происходит так потому, что в данной программе создаются два разных объекта x с локальной, а также глобальной областью видимости. Исправить ситуацию поможет ключевое слово global:

x = 100
def f():
    global x
    x = 200
f()
print(x)

200

Пометив переменную x как global, можно обращаться к ее изначальному значению, которое было определено вне зоны действия функции f. Теперь после того как в x поместили число 200, вызов метода print выводит вполне ожидаемый результат, то есть измененное значение.

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

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

def my_abs(val):
    return -val if val < 0 else val
    return val + 1
x = -15
x = my_abs(x)

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

Итак, для обращения к глобальной переменной внутри функции f необходимо использовать ключевое слово global перед ее идентификатором. Но что если требуется вызывать совсем не глобальную, а переменную, которая была определена во внешнем методе, являясь при этом локальной для другого пространства имен, находящегося на уровень выше? Следующий код демонстрирует попытку взаимодействия со значением из внешней функции f1 в методе f2:

def f1():
    x = 100
    def f2():
        x = 200
    f2()
    print(x)
f1()

100

Несмотря на то, что переменной с таким же именем x было присвоено новое значение 200, в результате выполнения написанных методов на экране отобразилось 100. Как и в том случае с двумя разными переменными, локальной и глобальной, здесь имеется также два различных объекта, которые идентифицированы в отдельных блоках кода. Чтобы обратиться к объекту, который не является локальным, необходимо воспользоваться модификатором nonlocal:

def f1():
    x = 100
    def f2():
        nonlocal x
        x = 200
    f2()
    print(x)
f1()

200

Таким образом, в методе f2 осуществляется запись значения 200 в переменную x из функции f1. В результате подобных действий, вызов метода f1 из внешней части программы создает новую переменную x, значение которой меняется в f2 со 100 на 200 и выводится при помощи print.

Важно заметить, что конструкция nonlocal была добавлена только в 3-ей версии языка Python.

Видимость из загружаемого модуля

Теперь разберемся с видимостью глобальных переменных между загружаемыми модулями Python. Например, мы подключаем другой модуль с помощью команды import. Создадим файл «test.py» и в него запишем следующий код:

print('Загружается модуль test')
x = 100
def f():
    print('Из функции x=' + str(x))

То есть мы определили глобальную переменную x для модуля test. Так же определили функцию, которая выводит на экран её значение.

Теперь создадим файл main.py, который и будем запускать. В нем мы импортируем модуль test, а так же создадим свою глобальную переменную x. После этого выведем значения глобальной переменной из test, вызовим функцию f, а так же проверим, что значение переменной в модуле main не изменилось:

x = 200
print('Из модуля main x=' + str(x))
import test
print('Из модуля test x=' + str(test.x))
print('Присваиваем значение 300')
test.x = 300;
print('Из модуля test x=' + str(test.x))
test.f()
print('Из модуля main x=' + str(x))

Из модуля main x=200
Загружается модуль test
Из модуля test x=100
Присваиваем значение 300
Из модуля test x=300
Из функции x=300
Из модуля main x=200

Мы в первой же строчке записали в x значение 200. Это было сделано, чтобы показать, что после того, как мы загрузим внешний модуль, значение этой переменной не изменится. Так и вышло. Обращаясь к переменной из загруженной библиотеки, удалось прочитать его и изменить значение.

Теперь модифицируем программу следующим образом:

x = 200
print('Из модуля main x=' + str(x))
from test import *
f()
print('Из модуля main x=' + str(x))
print('Присваиваем значение 300')
x = 300
f()
print('Из модуля main x=' + str(x))

Из модуля main x=200
Загружается модуль test
Из функции x=100
Из модуля main x=100
Присваиваем значение 300
Из функции x=100
Из модуля main x=300

В этом случае для загрузки мы использовали команду «from test import *». Мы импортировали все переменные и функции. После загрузки модуля значение переменной x в модуле main изменилось. Но при вызове функции, мы получаем значение x из модуля test. После присвоения нового значения переменной x, значение, которое выводит функция f не изменяется.

Следует по возможности избегать подключение библиотек с помощью команды from библиотека import *, а подключать только необходимые функции — from библиотека import функция. При этом надо удостовериться, что эти имена не используются в основном модуле.

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

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

Точно так же как и в функциях, можно обращаться к глобальным переменным и в классе Python. Разберем пример:

x = 100
print(x)
class c1:
    global x
    x = 200
    def __init__(self):
        global x
        x = 300
    def f(self):
        global x
        x = 400
print(x)
o1 = c1()
print(x)
o1.f()
print(x)

100
200
300
400

Мы объявили глобальную переменную x. Вывели значение переменной до и после объявления класса. Как видим значение изменилось. После того как мы создали объект класса, значение в очередной раз поменялось. Это произошло, потому что сработал конструктор класса — метод __init__. После вызова функции f у созданного объекта, значение стало 400. В Python использование global переменная и в функции класса, и в его конструкторе, и после описания класса дают возможность изменения глобальной переменной. Если убрать это объявление, то тогда выполнится присвоение локальной переменной.

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

class c1:
    x = 100
class c2:
    def f(self):
        print(x)
o = c2()
o.f()

Traceback (most recent call last):
  File "main.py", line 7, in <module> 
    o.f()
  File "main.py", line 5, in f
    print(x)
NameError: name 'x' is not defined

Для того, чтобы код работал, переменная x должна быль глобальной.

Заключение

Таким образом, область видимости переменных в языке программирования Python, является важной составляющей платформы. Правильное взаимодействие со всеми ее особенностями позволяет избежать множества довольно сложных ошибок. Для более безопасного контроля над видимостью отдельных объектов применяются ключевые слова global и nonlocal. Чтобы ознакомиться с дополнительными сведениями по данной теме, следует изучить PEP 3104.

В процессе нашего обучения мы изучили ряд встроенных в Python функций: print(), input(), max(), min() и другие. Часто в программах требуется использовать какую-то часть кода несколько раз. В таком случае программисты создают функции. Функции помогают использовать написанный код в программах многократно, а также делают код более понятным за счёт деления его на блоки.

Синтаксис создания функции выглядит следующим образом:

def <имя функции>(<аргументы функции>):
    <тело функции>

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

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

def only_even(numbers):
    result = True
    for x in numbers:
        if x % 2 != 0:
            result = False
            break
    return result


print(only_even([2, 4, 6]))
print(only_even([1, 2, 3]))

Вывод программы:

True
False

В функциях можно использовать несколько операторов return. Первый сработавший в теле функции оператор return остановит выполнение функции и вернёт её значение. Наш пример можно упростить, использовав вместо флага result несколько точек возврата значения:

def only_even(numbers):
    for x in numbers:
        if x % 2 != 0:
            return False
    return True


print(only_even([2, 4, 6]))
print(only_even([1, 2, 3]))

Вывод программы:

True
False

Обратите внимание: функция в Python всегда возвращает результат, даже если в ней нет return или присутствует return без возвращаемого значения. Тогда возвращаемый результат будет None — специальный тип данных в Python, который дословно можно перевести с английского как «ничего». Например, None возвращает функция print():

print(print("Эту строку выведет функция до возврата значения."))

Вывод программы:

Эту строку выведет функция до возврата значения.
None

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

def only_even(numbers):
    for i, x in enumerate(numbers):
        if x % 2 != 0:
            return False, i
    return True


print(only_even([2, 4, 6]))
print(only_even([1, 2, 3]))

Вывод программы:

True
(False, 0)

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

Итак, функции могут работать с аргументами и возвращать значения. Значение аргумента доступно только внутри функции. Покажем это на примере:

def only_even(numbers):
    for i, x in enumerate(numbers):
        if x % 2 != 0:
            return False, i
    return True


print(numbers)

Вывод программы:

NameError: name 'numbers' is not defined

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

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

def check_password(pwd):
    return pwd == password


password = "Python"
print(check_password("123"))

Вывод программы:

False

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

def list_modify():
    del sample[-1]


sample = [1, 2, 3]
list_modify()
print(sample)

Вывод программы:

[1, 2]

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

def list_modify():
    sample = [4, 5, 6]


sample = [1, 2, 3]
list_modify()
print(sample)

Вывод программы:

[1, 2, 3]

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

def list_modify_1(list_arg):
    # создаём новый локальный список, не имеющий связи с внешним
    list_arg = [1, 2, 3, 4]


def list_modify_2(list_arg):
    # меняем исходный внешний список, переданный как аргумент
    list_arg += [4]


sample_1 = [1, 2, 3]
sample_2 = [1, 2, 3]
list_modify_1(sample_1)
list_modify_2(sample_2)
print(sample_1)
print(sample_2)

Вывод программы:

[1, 2, 3]
[1, 2, 3, 4]

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

def inc():
    global x
    x += 1
    print(f"Количество вызовов функции равно {x}.")


x = 0
inc()
inc()
inc()

Вывод программы:

Количество запусков функции равно 1.
Количество запусков функции равно 2.
Количество запусков функции равно 3.

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

def f(count):
    count += 1
    print(f'Количество вызовов функции равно {count}.')
    return count

    
count_f = 0
count_f = f(count_f)
count_f = f(count_f)
count_f = f(count_f)

Вывод программы:

Количество запусков функции равно 1.
Количество запусков функции равно 2.
Количество запусков функции равно 3.

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

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

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

Пример  локальной переменной:

 
# example of local variable 
def sum(): 
    a = 10   # local variables 
    b = 20 
    c = a + b 
    print("the sum is:", c) 
 
sum()  # function calling 

Выход:

The sum is: 30 

Объяснение:

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

Чтобы преодолеть эту проблему, мы используем глобальные переменные. Давайте разберемся в примере глобальной переменной.

Пример –

 
# example of a global variable 
a = 20   # defined outside the function 
b = 10 
 
def sum(): 
    c = a + b  # Using global variables 
    print("The sum is:", c) 
 
def sub(): 
    d = a - b   # using global variables 
    print("The sub is:", d) 
 
 
sum()  # function calling 
sub() 

Выход:

The sum is: 30 
The sub is: 10 

Объяснение:

В приведенном выше коде мы определили две глобальные переменные a и b вне функций. Мы использовали их внутри функций sum() и sub(). Обе функции вернули результат при вызове.

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

Пример 3:

 
def msg(): 
    m = "Hello, how are you?" 
    print(m) 
 
msg() 
m = "I am fine"  # global scope 
print(m) 

Выход:

Hello, how are you? 
I am fine 

Объяснение:

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

Глобальное ключевое слово

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

Правила глобальных ключевых слов:

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

Пример – без глобального ключевого слова:

 
# The example of without using the global keyword 
 
c = 10 
 
def mul(): 
 
    # Multiply by 10 
    c = c * 10 
    print(c) 
 
mul() 

Выход:

line 8, in mul 
    c = c * 10 
UnboundLocalError: local variable 'c' referenced before assignment 

Объяснение:

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

Пример – с глобальным ключевым словом:

 
# The example using the global keyword 
 
c = 10 
 
def mul(): 
    global c 
    # Multiply by 10 
    c = c * 10 
    print("The value inside function: ", c) 
 
mul() 
print('The value outside the function: ', c) 

Выход:

The value inside function:  100 
The value outside the function:  100 

В приведенном выше примере мы определили переменную c в функции mul() с помощью ключевого слова global. Значение c умножается на 10; следовательно, возвращается 200. Мы видим в выходных данных, что изменение значения внутри функции отражается на значении вне глобальной переменной.

Преимущество ключевого слова global заключается в создании глобальных переменных и совместном использовании их между различными модулями. Например, мы создаем name.py, который состоит из глобальных переменных. Если мы изменим эти переменные, то это изменение отразится повсюду. Давайте разберемся в следующем примере.

Код – 1: Создайте файл name.py для хранения глобальных переменных.

 
a = 10 
b = 20 
msg = "Hello World" 

Код – 2: Создайте файл change.py для изменения глобальных переменных.

 
import name 
name.a = 15 
name.b = 26 
name.msg = "Welcome to JavaTpoint" 

Здесь мы изменили значение a, b и msg. Эти глобальные переменные были определены в файле name.py, и мы импортировали name и получили доступ к этим переменным.

Код – 3: Создайте файл result.py для печати измененных глобальных переменных.

 
import name  
import change 
print(change.a)  
print(change.b)   
print(change.msg) 

Выход:

15 
26 
Welcome to JavaTpoint 

Ключевое слово global во вложенных функциях

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

Пример –

 
# The example of global in nested function 
 
def add(): 
    a = 15 
 
    def modify(): 
        global a 
        a = 20 
 
    print("Before modifying : ", a) 
    print("Making change") 
    modify() 
    print("After modifying: ", a) 
 
 
add() 
print("value of x: ", a) 

Выход:

Before modifying :  15 
Making change 
After modifying:  15 
value of x 20 

Объяснение:

В приведенном выше коде значение внутри add() принимает значение локальной переменной x = 15. В функции modify() мы присвоили x = 20 с помощью ключевого слова global. Это изменение отражено в переменной функции add().