Python как изменить переменную через функцию

Можно ли в python изменить переменную переданную в аргементе функции

В функцию передается не переменная, а ее значение, это не указатели. Просто верните новое значение из функции a = func(a) , в функцию добавить return a . Другой вариант, передавать в параметр функции что-нибудь сложное, типа объекта класса или контейнер (список, словарь, . )

26 авг 2021 в 8:25

Переменная a, которой присваивается значение «victor», и переменная а, которая в функции, это две совершенно разные вещи. Общего у них только имя. Любое из них можно изменить на какое угодно другое и в выполнении программы совершенно ничего не изменится. Так же, как у Бориса из Новосибирска и Бориса из Симферополя общего только имя Борис. А все остальное разное.

26 авг 2021 в 8:41

1 ответ 1

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

Почему значение a не меняется?

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

def func(a): a = "anton" print("внутри функции", id(a)) a = "victor" print("вне функции", id(a)) func(a) print("вне функции", id(a)) print(a) 

Выведет что-то типо

вне функции 485256706736 внутри функции 485257302960 вне функции 485256706736 victor 

id показывает место в памяти, где лежит значение переменной и, как видите, вне функции оно одно, а внутри — другое.

Как можно обойти?

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

def func(): global a a = "anton" print("внутри функции", id(a)) a = "victor" print("вне функции", id(a)) func() print("вне функции", id(a)) print(a) 

Выведет что-то на подобии:

вне функции 542195432176 внутри функции 542200565424 вне функции 542200565424 anton 

Как лучше реализовать?

Метод с использованием global — наверняка не лучший способ достичь результата, который вы хотите, и я бы посчитал бы это code smell-ом, потому я предлагаю вам сделать так:

def func(a): a = "anton" print("внутри функции", id(a)) return a a = "victor" print("вне функции", id(a)) a = func(a) print("вне функции", id(a)) print(a) 

Выведет что-то такое:

вне функции 486729169712 внутри функции 486730096368 вне функции 486730096368 anton 

Этот подход намного лучше первого.

Что за локальные и глобальные переменные?
Локальные переменные — те, которые «заперты» в каком-то контексте, например:

def func(arg): pass 

Здесь arg — локальная переменная, она существует только в контексте функции func , и имеет влияние только на этот контекст.

Глобальные переменные — те, котоые мы объявляем в контексте программы:

foo = 5 

Переменная foo — глобалья, т.к. объявлена в контексте программы (модуля, или же без отступа)

Python: Изменение переменной

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

# greeting - переводится как приветствие greeting = 'Father!' print(greeting) # => Father! greeting = 'Mother!' print(greeting) # => Mother! 

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

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

Задание

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

Обратите внимание: в данном задании вам предстоит писать код между строчками с комментариями # BEGIN и # END (об этом говорилось ранее, но это первый раз, когда вы встречаетесь с таким форматом).

Упражнение не проходит проверку — что делать? ��

Если вы зашли в тупик, то самое время задать вопрос в «Обсуждениях». Как правильно задать вопрос:

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

В моей среде код работает, а здесь нет ��

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

Мой код отличается от решения учителя ��

Это нормально ��, в программировании одну задачу можно выполнить множеством способов. Если ваш код прошел проверку, то он соответствует условиям задачи.

В редких случаях бывает, что решение подогнано под тесты, но это видно сразу.

Прочитал урок — ничего не понятно ��

Создавать обучающие материалы, понятные для всех без исключения, довольно сложно. Мы очень стараемся, но всегда есть что улучшать. Если вы встретили материал, который вам непонятен, опишите проблему в «Обсуждениях». Идеально, если вы сформулируете непонятные моменты в виде вопросов. Обычно нам нужно несколько дней для внесения правок.

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

Определения

• Переменная — способ сохранить информацию и дать ей имя для последующего использования в коде.

Python как изменить переменную через функцию

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

def say_hello(): print("Hello") def say_goodbye(): print("Good Bye") message = say_hello message() # Hello message = say_goodbye message() # Good Bye

В данном случае переменной message присваивается одна из функций. Сначала ей передается функция say_hello() :

message = say_hello

После этого переменная message будет указывать на данную функцию, то есть фактически представлять функцию say_hello. А это значит, что мы можем вызывать переменную message как обычную функцию:

message() # Hello

Фактически это приведет к выполнению функции say_hello, и на консоль будет выведена строка «Hello». Затем подобным образом мы можем передать переменной message другую функцию и вызвать ее.

Подобным образом можно через переменную вызывать функцию с параметрами и возвращать ее результат:

def sum(a, b): return a + b def multiply(a, b): return a * b operation = sum result = operation(5, 6) print(result) # 11 operation = multiply print(operation(5, 6)) # 30

Функция как параметр функции

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

def do_operation(a, b, operation): result = operation(a, b) print(f"result = ") def sum(a, b): return a + b def multiply(a, b): return a * b do_operation(5, 4, sum) # result = 9 do_operation(5, 4, multiply) # result = 20

В данном случае функция do_operation имеет три параметра, причем третий параметр, как предполагается, будет представлять функцию, которая принимает два параметра и возвращает некоторый результат. Иными словами третий параметр — operation представляет некоторую операцию, но на момент определения функции do_operation мы точно не знаем, что это будет за операция. Мы только знаем, что она принимает два параметр и возвращает какой-то результат, который потом выводится на консоль.

При вызове функции do_operation мы сможем передать в качестве третьего параметра другую функцию, например, функцию sum:

do_operation(5, 4, sum)

То есть в данном случае параметр operation фактически будет представлять функцию sum и будет возвращать сумму дву чисел.

Затем аналогичным образов в вызов функции do_operation можно передать третьему параметру другую функцию — multiply, которая выполнит умножение чисел:

do_operation(5, 4, multiply) # result = 20

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

Функция как результат функции

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

def sum(a, b): return a + b def subtract(a, b): return a - b def multiply(a, b): return a * b def select_operation(choice): if choice == 1: return sum elif choice == 2: return subtract else: return multiply operation = select_operation(1) # operation = sum print(operation(10, 6)) # 16 operation = select_operation(2) # operation = subtract print(operation(10, 6)) # 4 operation = select_operation(3) # operation = multiply print(operation(10, 6)) # 60

В данном случае функция select_operation в зависимости от значения параметра choice возвращает одну из трех функций — sum, subtract и multiply. Затем мы мы можем получить результат функции select_operation в переменную operation:

operation = select_operation(1)

Так, в данном случае в функцию select_operation передается число 1, соответственно она будет возвращать функцию sum. Поэтому переменная operation фактически будет указывать на функцию sum, которая выполняет сложение двух чисел:

print(operation(10, 6)) # 16 - фактически равно sum(10, 6)

Аналогичным образом можно получить и выполнить другие функции.

Руководство по глобальным переменным

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

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

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

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

 
 
def sum(): a = 10 # локальные переменные b = 20 c = a + b print("Сумма:", c) sum()
Переменная объявлена внутри функции и может использоваться только в ней. Получить доступ к этой локальной функции в других нельзя.
Для решения этой проблемы используются глобальные переменные.
Теперь взгляните на этот пример с глобальными переменными:
 
 
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)
Привет, как дела? Отлично!
Здесь была объявлена локальная переменная с таким же именем, как и у глобальной. Сперва выводится значение локальной, а после этого — глобальной.
Ключевое слово global
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 для хранения глобальных переменных:


Похожие публикации:

Hp freedos как установить windows
Как вывести данные в виде таблицы c
Как скомпилировать папку в exe
Что из этого языки программирования соня