Как нескольким переменным присвоить одно значение python

Переменные, Константы и Литералы в Python

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

Константа в Python — это особый тип переменной, значение которой нельзя изменить. В Python константы обычно объявляются/определяются в модуле (отдельный файл, содержащий переменные, функции и прочее, который импортируется в основной файл).

Литералы в Python — это представления фиксированных значений в программе. Это могут быть числа, символы, строки и т.д., например, ‘Hello, World!’ , 12 , 23.0 , ‘C’ .

Переменные в Python

Как в Python присвоить нескольким переменным одинаковое значение?

Сколько ни гуглил, нашёл лишь 4 варианта:
1) a = b = c = []
2) a, b, c = [], [], []
3) a, b, c = [[]] * 3
4)
a = []
b = []
c = []
В первом варианте проблема в том, что переменные будут ссылаться друг на друга.
Во втором варианте проблема в длине записи, если элементов много, то замучаешься перечислять.
Четвёртый вариант аналогичен второму, только запись не в строчку, а в столбик.
Думал спасение в третьем варианте, но он подходит разве что для чисел, там нет проблем, если стартовое значение переменной будет храниться в списке. А как быть, если нужен пустой список ? Тогда запись a, b, c = [[]] * 3 не подойдёт, так как хоть для каждой переменной и создастся отдельный пустой список, но из-за того, что все они будут внутри ещё одного списка алгоритм не будет правильно работать.
Есть какой-нибудь вариант как в одну строку нескольким переменным присвоить значение (в частности интересует создание пустого списка для каждой переменной) ?

Использование переменных в Python 3

Переменные – очень важная составляющая программы; по сути, это символ (или набор символов), которому присвоено значение и который можно использовать вместо этого значения при написании программы.

Данное руководство ознакомит вас с основами работы с переменными в Python 3.

Что такое переменная?

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

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

К примеру, у вас есть целое число 103204934813. Вы можете сохранить его в переменной, и тогда вам не придётся постоянно вводить повторно длинное число. Сохраните число в переменной my_int:

По сути, my_int – это ярлык, привязанный к значению 103204934813.

Фраза my_int = 103204934813 – это операция присваивания, которая состоит из следующих частей:

my_int – имя переменной;
= – оператор присваивания;
103204934813 – значение.

Таким образом, присваивая значению имя, вы инициализируете, или создаёте переменную. После этого можно использовать переменную вместо значения. В Python, в отличие от некоторых других языков программирования, переменные не нужно явно декларировать. То есть, объявив, что my_int равно 103204934813, вы можете просто использовать my_int вместо числа. Попробуйте запустить:

С помощью переменных можно быстро выполнить вычисления. Попробуйте отнять 813 из my_int:

print(my_int — 813)
103204934000

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

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

Выведите значение x:

Python выводит 221, потому что именно это число получается в результате сложения 76 и 145.

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

my_string = ‘Hello, World!’
my_flt = 45.06
my_bool = 5 > 9 #логический оператор оценивает выражение как истинное или ложное
my_list = [‘item_1’, ‘item_2’, ‘item_3’, ‘item_4’] my_tuple = (‘one’, ‘two’, ‘three’)
my_dict =

Попробуйте запросить одну из этих переменных. На экране появится значение этой переменной:

my_list = [‘item_1’, ‘item_2’, ‘item_3’, ‘item_4’] print(my_list)
[‘item_1’, ‘item_2’, ‘item_3’, ‘item_4’]

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

Правила задания имен переменных

Существует ряд правил, которых следует придерживаться при наименовании переменных.

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

Для примера рассмотрим правильные и неправильные имена переменных:

Правильно

Неправильно

Выбирая имя для переменной, следует также учитывать регистр: my_int, MY_INT, My_Int и mY_iNt – не одна, а четыре разные переменные.

Примечание: Избегайте похожих имён переменных в рамках одной программы.

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

Правильно

Неправильно

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

Читайте также: PEP 8 – официальный мануал по кодированию в Python

Переназначение переменной

Значение переменной (что видно из самого понятия) можно изменять.

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

Попробуйте задать в переменной x число, а затем переназначить её и задать строку:

x = 76
print(x)
x = «8host»
print(x)
76
8host

Если бы программа была написана так:

x = 76
x = «8host»
print(x)

в результате на экране появилось бы только второе присвоенное значение, так как это последнее назначение:

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

Python позволяет присваивать одно значение нескольким переменным одновременно. Таким образом, вы можете инициализировать несколько переменных, а позже переназначить их.

Например, можно задать переменным x, y и z значение 0.

x = y = z = 0
print(x)
print(y)
print(z)
0
0
0

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

Python также позволяет присваивать несколько значений нескольким переменным в рамках одной строки. Например:

j, k, l = «8host», 1.05, 16
print(j)
print(k)
print(l)
8host
1.05
16

Как видите, переменной j было присвоено значение 8host, переменной k 1.05, l – 16.

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

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

При использовании переменной в программе важно иметь в виду её область видимости.

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

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

Рассмотрите пример таких переменных:

#Создайте глобальную переменную
glb_var = «global»
#Определите функцию
def var_function():
lcl_var = «local» #Создайте локальную переменную внутри функции
print(lcl_var)
#Вызовите функцию
var_function()
#Выведите глобальную переменную
print(glb_var)
local
global

Поскольку переменная glb_var является глобальной, мы можем сослаться на неё внутри функции var_function(). Отредактируйте предложенный выше код, чтобы сделать это:

glb_var = «global»
def var_function():
lcl_var = «local»
print(lcl_var)
print(glb_var) #Выводит glb_var внутри функции
var_function()
print(glb_var)
local
global
global

Теперь переменная glb_var выводится дважды: внутри и вне функции.

Попробуйте вызвать локальную переменную вне функции:

glb_var = «global»
def var_function():
lcl_var = «local»
print(lcl_var)
print(lcl_var)
NameError: name ‘lcl_var’ is not defined

Как видите, вы не можете вызвать локальную переменную вне функции, так как она существует только внутри функции.

Рассмотрим ещё один пример. Задайте глобальной и локальной переменной одно и то же имя:

num1 = 5 #Глобальная переменная
def my_function():
num1 = 10 #Локальная переменная с таким же именем, num1
num2 = 7 #Локальная переменная
print(num1) #Выведет локальную переменную num1
print(num2) #Выведет локальную переменную num2
#Вызывает my_function()
my_function()
#Выводит глобальную переменную num1
print(num1)
10
7
5

Поскольку локальная переменная num1 присвоена внутри функции, при вызове num1 появляется 10. При выводе глобальной переменной num1 (после вызова функции my_function()) появляется значение 5.

Оператор global позволяет определять глобальные переменные Python внутри функции:

def new_blog():
global blog = «8host» #Присваивает глобальную переменную
#Выводит глобальную переменную blog
print(blog)

Несмотря на то, что переменная blog была присвоена локально внутри функции new_blog(), она доступна вне функции благодаря оператору global. Потому при вызове print(blog) Python не выдаёт ошибку: переменная существует и вне, и внутри функции.

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

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

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

Переменные в Python: что это такое и какие они бывают

Как хранить данные в Python, чтобы обращаться к ним было легко и приятно.

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

Иван Стуков

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

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

Что такое переменная в Python

Переменная — это область памяти компьютера, у которой есть имя. Структурно она состоит из трёх частей:

Имя,или идентификатор, — это название, придуманное программистом, чтобы обращаться к переменной. В примерах выше это x, name и coin_flipping_result.
Значение — это информация, которая хранится в памяти компьютера и с которой работает программа. В примерах выше это 4, ‘Виктория’ и [‘орёл’, ‘решка’, ‘решка’, ‘орёл’]. Они всегда принадлежат к какому-либо типу данных.
Адрес — это номер ячейки памяти, в которой хранится значение переменной.

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

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

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

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

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

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

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

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

Чуть позже мы объясним, почему так происходит.

Стили именования переменных

Синтаксис Python позволяет использовать разные стили для именования переменных:

lowercase — все буквы строчные;
lower_case_with_underscores — все буквы строчные, между словами нижние подчёркивания;
UPPERCASE — все буквы заглавные;
UPPER_CASE_WITH_UNDERSCORES — все буквы заглавные, между словами нижние подчёркивания;
CamelCase — каждое слово начинается с заглавной буквы;
mixedCase — каждое слово, кроме первого, начинается с заглавной буквы;
Camel_Case_With_Underscores — каждое слово начинается с заглавной буквы, между словами нижние подчёркивания (это некрасиво, никогда так не делайте).

Тем не менее среди Python-разработчиков принят стандарт PEP 8 — это руководство, в котором собраны рекомендации по оформлению кода. То есть сообщество само для себя устанавливает дополнительные ограничения при именовании переменных:

использовать lowercase, при необходимости разбивая слова нижними подчёркиваниями, если это нужно для улучшения читаемости;
если в готовом проекте преобладает mixedCase, то писать стоит в этом стиле — чтобы сохранялась обратная совместимость;
не давать имена l (строчная L), O (заглавная o) и I (заглавная i) — в некоторых шрифтах они неотличимы от нуля и единицы.

Следуйте советам PEP 8, чтобы ваш код был понятным и легко поддерживаемым.

Как объявить переменную и присвоить ей значение в Python

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

Поэтому в Python объявлять переменную отдельно не нужно — достаточно сразу её инициализировать, то есть присвоить значение. Для этого используют знак равно =.

Более того, потом ей же можно присвоить значение другого типа:

В языках со статической типизацией, таких как C++ и Java, подобный трюк не пройдёт: компилятор сообщит об ошибке — ведь переменная изначально хранила целое число, а не строку. А в Python это возможно, потому что переменные ссылаются не на сами данные, а на их адрес в памяти.

Как работает инициализация переменных

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

Этот идентификатор можно узнать с помощью функции id():

Когда мы инициализировали x, программа создала объект с числом 4, принадлежащий к классу (типу данных) int.

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

Выглядит это так:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Итоги

Переменные в Python состоят из имени и значения. При этом они хранят в себе не само значение, а ссылку на его адрес в памяти.
Для их именования используют цифры (не могут быть первым символом в имени), латинские буквы и нижние подчёркивания.
В Python не надо отдельно объявлять переменную — ей сразу присваивают значение. В одной строке можно создать сразу несколько переменных.
Они существуют внутри определённой области видимости. Переменные бывают глобальные (внутри всей программы), локальные (внутри одной функции) и нелокальные (внутри двух вложенных друг в друга функций).
У переменных в Python нет ограничения по размеру — они могут быть настолько большими, насколько хватит памяти устройства.
Их можно импортировать из других файлов, удалять, проверять их существование в текущей области видимости, печатать в форматированной строке.

Читайте также:

Вот их список: and, as, assert, async, await, break, class, continue, def, del, elif, else, except, False, finally, for, from, global, if, import, in, is, lambda, None, nonlocal, not, or, pass, raise, return, True, try, while, with, yield.

Целое число, число с плавающей запятой, строка, список, словарь и так далее.