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

Как фиксировать изменение значения переменной в Python?

Господи. Ну может хоть ПОЛ СТРАНИЧКИ ПЕРВЫХ любого учебника по любому языку программирования. нет, по основам информатики прочитать прежде, чем кидаться писать парсер?

Решения вопроса 0
Ответы на вопрос 1

Не так, переменная меняется не присвоением ей значения, а за счет парсинга с сайта

Вот что я люблю в вопросах от нубов — никогда не знаешь, про что вопрос на самом деле.
Твой вопрос звучит так, словно тебя интересует любое присвоение значения переменной, даже если новое значение равно старому. И советы тебе дают в этом направлении. А тебе ведь нужно обнаружить изменение значения, так? Если так, читай дальше.

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

old_value = None while True: new_value = parse_site() # parse_site() - написанная тобой функция, которая возвращает искомое значение if old_value is not None and new_value != old_value: # если это не первый раз, и значение изменилось print('Значение изменилось!') old_value = new_value # чтобы в следующий раз сравнивать с последним увиденным значением time.sleep(600) # спим 10 минут, чтобы не долбить сайт запросами

Ну и да, неважно откуда ты берёшь значение. Ты всё равно присваиваешь его переменной. Всё равно.
Если ты этого не понимаешь — отложи свой парсер, и почитай хороший учебник по Питону, того же Марка Лутца, «Изучаем Питон».

Можно ли в 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, чтобы обращаться к ним было легко и приятно.

Иллюстрация: Оля Ежак для Skillbox Media

Иван Стуков
Журналист, изучает Python. Любит разбираться в мелочах, общаться с людьми и понимать их.

Если вы откроете любую программу в Python, то, скорее всего, увидите много таких равенств:

Как давать имена переменным

Создавая переменную на языке Python, программисты придумывают ей названия по определённым правилам именования:

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

Приведём несколько примеров.

• Какие имена можно давать переменным: x, X, xyz, _x_y_z, XYZ, xyz_123, _123, x1Y2z2.
• Как нельзя называть переменные: 1, 1x, x y z, x&y.

Python чувствителен к регистру. Таким образом, name и Name будут считаться разными переменными.

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

В любой момент мы можем присвоить переменной новое значение. Тогда она станет ссылаться на другой объект:

x = 1.2 y = 'строка'

Теперь x и y ссылаются на другие объекты с другими адресами. И так как больше ни одна переменная не ссылается на объект по адресу 2056817043856, то его автоматически удалит сборщик мусора.

Множественное присваивание значений

Если нескольким переменным нужно присвоить одно и то же значение, это можно сделать в одну строку с помощью следующей конструкции:

x = y = z = 4

print(x, y, z) >>> 4 4 4

Для присвоения разных значений тоже есть способ:

x, y, z = 1, 'игрек', ['список', 'со', 'строками'] print(x, y, z) >>> 1 игрек ['список', 'со', 'строками']

Импорт переменных

Если переменную нужно импортировать из другого файла, то используют конструкцию from import .

Например, у нас есть файл variables1.py:

name = 'Виктория' age = 23 city = 'Москва'

Используем переменную name в файле variables2.py:

from variables1 import name print(name) >>> Виктория

При этом доступа к другим переменным из variables1.py в таком случае нет:

from variables1 import name print(age) >>> NameError: name 'age' is not defined

Чтобы импортировать несколько переменных, их можно перечислить через запятую:

from variables1 import name, age print(name, age) >>> Виктория 23

Для импорта всех объектов после import ставят звёздочку *:

from variables1 import * print(name, age, city) >>> Виктория 23 Москва

Удаление переменных

Чтобы удалить переменную, используют ключевое слово del:

x = 4 del x print(x) >>> NameError: name 'x' is not defined

Типы переменных в Python

Все переменные существуют внутри определённой области видимости. В Python их три:

• локальная — внутри одной функции;
• глобальная — внутри целой программы (py-файла);
• нелокальная — внутри двух смежных функций (внутренней и внешней).

Переменные, которые принадлежат к той или иной области видимости, образуют её пространство имён.

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

Любые переменные, которые объявлены внутри функции, остаются только в этой функции. Например:

def local_namespace(): x = 4 x = x ** 2 return x print(local_namespace()) >>> 16

Мы можем, как обычно, распоряжаться x: изменять значение, проводить операции, возвращать — но только до тех пор, пока мы делаем это внутри функции local_namespace().

Если мы решим обратиться к x где-то в другой части программы, то интерпретатор её просто не увидит:

def local_namespace(): x = 4 x = x ** 2 return x print(x) >>> NameError: name 'x' is not defined

И наоборот: функция может распоряжаться только теми переменными, которые находятся внутри неё:

x = 4 def local_namespace(): x = x ** 2 return x print(local_namespace()) >>> UnboundLocalError: local variable 'x' referenced before assignment

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

x = 4 def local_namespace(): y = x ** 2 return y print(x) print(local_namespace()) >>> 4 >>> 16

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

x = 0 def local_namespace(): x = 4 x = x ** 2 return x print(x) print(local_namespace()) >>> 0 >>> 16

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

Любая переменная, которую объявляют вне функций, является глобальной. Она существует в пространстве имён всего py-файла.

Как мы показали выше, к ней можно обратиться внутри функции, но нельзя изменять. Чтобы исправить это, существует ключевое слово global:

x = 4 def local_namespace(): global x x = x ** 2 return x print(local_namespace()) >>> 16

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

def local_namespace(): global x x = 4 return x print(local_namespace()) print(x) >>> 4 >>> 4

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

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

Их создают с помощью ключевого слова nonlocal.

def nonlocal_namespace(): x = 4 def local_namespace(): nonlocal x x = x ** 2 return x return local_namespace() print(nonlocal_namespace()) >>> 16

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

def nonlocal_namespace(): x = 4 def local_namespace(): nonlocal x x = x ** 2 return x return local_namespace() print(x) >>> NameError: name 'x' is not defined

Проверка существования переменной

В Python есть функции globals() и locals(). Они возвращают словарь с таблицей глобальных и локальных символов соответственно. В них, помимо прочего, хранятся данные о переменных.

Ключом в этих словарях является строка с именем переменной — так можно проверить её существование:

name = 'Виктория' if 'name' in globals(): print(True) >>> True

Также из этого словаря по имени переменной можно достать её значение:

name = 'Виктория' if 'name' in globals(): print(globals().get('name')) >>> Виктория

Точно так же можно делать и в локальной области видимости:

def local_namespace(): name = 'Виктория' if 'name' in locals(): print(locals().get('name')) local_namespace() >>> Виктория

Максимально возможное значение переменной

В Python, в отличие от многих других языков программирования, нет особого типа данных для хранения больших чисел. Все целые числа относятся к классу int, все числа с плавающей запятой — к классу float.

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

Печать одиноких и множественных переменных

Для печати в Python используется функция print(). С её помощью можно вывести как одиночную переменную, так и несколько, перечислив их через запятую:

name, age, city = 'Виктория', 23, 'Москва' print(name) print(name, age, city) >>> Виктория >>> Виктория 23 Москва

Также в Python можно форматировать печать переменных. Для этого предусмотрено несколько способов, но самый удобный из них — f-строки. Нужно передать функции print() строку c буквой f перед ней. Сами переменные указываются в фигурных скобках: .

name, age, city = 'Виктория', 23, 'Москва' print(f'Имя: . Возраст: . Город: .') >>> Имя: Виктория. Возраст: 23. Город: Москва.