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

№4 Переменные в Python / Уроки по Python для начинающих

В отличие от других языков программирования, Python не имеет команды для объявления переменной. Переменная создается тогда, когда вы назначили ей значение.

x = 5 y = "Саша" print(x) print(y) 

5 Саша 

Не нужно указывать конкретный тип переменной при объявлении. Можно даже изменять их тип после создания.

x = 4 # сейчас x с типом int x = "Алёна" # теперь x с типом str print(x) 

Алёна 

Имя переменной

Переменная может иметь краткое имя (например, x и y ) или более содержательное имя ( age , carname , total_volume ).
Правила для переменных в Python:

• Имя переменной должно начинаться с буквы или символа подчеркивания.
• Оно не может начинаться с числа.
• Имя переменной может содержать только буквенно-цифровые символы и символы подчеркивания (Az, 0-9 и _ )
• Имена переменных чувствительны к регистру ( age , Age и AGE — три разных переменные)

Помните, что переменные чувствительны к регистру

Вывод переменных

Функция Python print часто используется для вывода переменных:
Чтобы комбинировать как текст, так и переменную, Python использует символ +

x = "невероятен" print("Python " + x) 

Python невероятен 

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

x = "Python " y = "невероятен" z = x + y print(z) 

Python невероятен 

Для чисел символ + работает как математический оператор:

x = 5 y = 10 print(x + y) 

Если вы попытаетесь объединить строку и число, Python покажет вам сообщение об ошибке:

x = 5 y = "Саша" print(x + y) 

TypeError: unsupported operand type(s) for +: 'int' and 'str' 

• ТЕГИ
• Уроки Python для начинающих

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

Мои контакты: Почта
Python Q https://yandex.ru/q/loves/python Online

Python Q CEO Pythonru admin@pythonru.com https://secure.gravatar.com/avatar/b16f253879f7349f64830c64d1da4415?s=96&d=mm&r=g CEO Pythonru Python Александр Редактор https://t.me/cashncarryhttps://pythonru.com/https://yandex.ru/q/profile/cashnc/ PythonRu.com admin@pythonru.com Alex Zabrodin 2018-10-26 Online Python, Programming, HTML, CSS, JavaScript

Как изменить переменную в другом скрипте?

У меня есть файл main.py и файл data.py. Мне нужно изменить переменную в data.py.
Пишу такой код в файле data.py:

 
game_map = None #почему-то отображается 
, не знаю почему(

import data data.game_map = [0, 1, 0, 1, 0] #другие значения.

Это не работает, переменная game_map в data.py так и осталась None. Как это исправить?
Только не советуйте использовать json, мне нужно ИМЕННО так.

• Вопрос задан более двух лет назад
• 715 просмотров

4 комментария

Простой 4 комментария

Владимир Куц @fox_12 Куратор тега Python
А что — она по-вашему именно в файле data.py должна изменится?
Вадимка))) @VadimCoder Автор вопроса

Владимир Куц @fox_12 Куратор тега Python
Вадимка))), это так не работает
Вадимка))) @VadimCoder Автор вопроса
Решения вопроса 0
Ответы на вопрос 1

Алан Гибизов @phaggi Куратор тега Python
лужу, паяю, ЭВМы починяю

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

Ответ написан более двух лет назад
Вадимка))) @VadimCoder Автор вопроса
Я же написал, без json.
Вадимка))) @VadimCoder Автор вопроса
Нельзя иначе?

Алан Гибизов @phaggi Куратор тега Python

Вадимка))), json — это формат текстового представления структур типа «словарь», «список» и их сочетаний. Их удобно использовать для хранения данных, подобных вашим. Но для того, что я сказал в рекомендации, json не обязателен. Хотя и удобен.

Важно другое:
вы неправильно представляете себе работу python с переменными и объектами. Вы представляете себе переменную как кармашек, куда можно положить что-то и оно там будет.
Это не так.

Когда вы импортировали модуль data, в нем исполнилась инструкция:
game_map = []

Эта инструкция создала переменную и приравняла ее к пустому списку.

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

В начале скрипт data создал некую переменную game_map. Это — ярлычок где-то в памяти компа. Он привязался к объекту «пустой список», который тоже где-то в памяти компа. Пустой список создался в памяти, когда считался с вашего модуля «data». Ярлычок не привязан к записи в файле, нет. Лишь к отображению в памяти.

Положим, вы говорите python — «эта переменная game_map равна теперь списку циферок».
Это не значит, что вы список циферок положили туда, где раньше лежал пустой список.
Это значит, что ярлычок отвязался от пустого списка в памяти и привязался к другому объекту — списку с циферками. Который, естественно, тоже в памяти.

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

Для записи файл НЕОБХОДИМО явным образом открыть на запись — при этом создастся очень специальный объект в памяти. У этого объекта будет специальный метод write, который сбросит содержимое другого объекта в файл, если этот объект дернуть за этот метод и указать, что сбрасывать в него. Потом файл, открытый на запись, закрываем — и у нас новый файл на диске, с новым содержимым.

У вас в коде этого ничего нет. Всё у вас происходит С ОТОБРАЖЕНИЯМИ в памяти.

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

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

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

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

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

Иллюстрация: Оля Ежак для 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. Город: Москва.