Как работают переменные в Python
Каждый элемент данных в Python является объектом определенного типа или класса. Когда, в процессе выполнения программного кода, появляется новое значение, интерпретатор выделяет для него область памяти — то есть создаёт объект определенного типа (число, строка и т.д.). После этого Python записывает в свой внутренний список адрес этого объекта.
Но как теперь получить доступ к созданному объекту? ��♀️
Для этого и существуют переменные — они дают возможность удобно работать с объектами используя имена вместо адресов.
Простыми словами переменная в Python — это просто имя, прикрепленное к определенному объекту
Чтобы создать новую переменную в Python, ее не нужно заранее инициализировать — достаточно придумать ей имя и присвоить значение через оператор = .
a = 123 print(a) > 123 print(type(a)) <class 'int'> print(id(a)) 1827204944
В примере выше мы создали переменную a и присвоили ей значение 123 , далее вывели ее значение, тип и адрес объекта в памяти.
�� �� Приведем простую аналогию: Представьте, что у вас есть много непрозрачных бутылок, а сами вы занимаетесь производством фруктовых соков. Однажды вы выжали фрукты и в один сосуд налили апельсиновый сок, а во второй — яблочный. После этого ёмкости были запечатаны. Резонный вопрос: как теперь выяснить содержимое отдельно взятой бутылки?
Ответ: предварительно их подписать. Сделав это, вы будете точно знать, что находится в бутылках, а значит, сможете производить с ними дальнейшие операции: назначать цену, сортировать, отправлять на продажу и так далее.
Итак, ваш фреш-бизнес разросся, и для хранения соков пришлось арендовать склад, где каждая бутылка находится строго на своём месте. Теперь у вас есть ещё и специальные карточки: на каждой из них записаны наименование продукта и адрес этого продукта на складе. Когда требуется достать конкретную ёмкость с соком, вы смотрите на карточку, читаете номер ячейки, а затем идёте к обозначенному месту на складе и берёте оттуда нужную бутылку.
В данном примере:
- переменная — карточка продукции;
- адрес — это номер ячейки на складе;
- объект — сама ячейка;
- данные — бутылка с соком внутри.
Переменные, объекты и ссылки
Для понимания работы переменных, необходимо разобрать, что происходит, когда вы создаете новую переменную и присваиваете ей значение?
В данном примере происходит следующее:
- создается объект типа int со значением 100 ;
- создается переменная a ;
- в переменной a сохранится адрес (ссылка) на объект;
Важно : переменная в Python не хранит значение напрямую — она хранит лишь ссылку на объект
Теперь посмотрим что произойдет, если одной переменной присвоить другую переменную:
b = a print(id(a)) > 1827204576 print(id(b)) > 1827204576
В данном примере Python не создает новый объект — он просто создает переменную, которая ссылается на тот же объект, что и переменная a .
Предположим, что в какой-то момент вы захотели поменять значение переменной b :
b = 500 print(id(a)) > 1827204576 print(id(b)) > 56754272
В данном примере Python создал новый объект типа int, и теперь переменная b ссылается на новый объект.
Рассмотрим еще один пример:
b = "tree" print(id(b)) > 54134048
В этом примере создается новый объект типа str , и переменная b ссылается на новый объект.
b = "tree", переменная b теперь ссылается на новый объект строкового типа
На объект типа int со значением 500 больше никто не ссылается. Следовательно, он больше не доступен и будет удален сборщиком мусора (тем самым освободив немного памяти).
Идентификатор объекта (Object Identity)
В примерах выше мы вызывали функцию id() . Эта функция возвращает число, которое является неизменным и уникальным для каждого объекта на протяжении его жизненного периода:
a = b = 1 print(id(a)) > 1593636784 print(id(b)) > 1593636784 print(id(1)) > 1593636784
Видно, что объект здесь всего один. А a и b — по-разному названные переменные, которые на него ссылаются. Проверить равенство идентификаторов можно с помощью оператора is :
print(a is b) > True
Работа с переменными
Именование переменных
В языке Python имя переменной должно состоять только из цифр, букв и знаков подчеркивания. И не должно начинаться с цифры.
Это жёсткий внутренний закон языка, помимо которого есть свод более мягких, но не менее важных правил, и они говорят нам:
- давайте переменным имена, которые описывают суть объекта;
- используйте единый стиль именования в рамках каждого проекта;
- старайтесь не создавать наименования длиннее пятнадцати символов;
Список зарезервированных слов
В каждом языке есть зарезервированные слова. Такие слова имеют специальное значение, и поэтому запрещены для использования в качестве имён переменных. Вот список зарезервированных слов для Python:
False, class, finally, is, return, None, continue, for, lambda, try, True, def, from, nonlocal, whileand, del, global, not, with, as, elif, if, or, yield, assert, else, import, pass, break, except, in, raise.
Как объявить переменную
В Питоне не требуется специального объявления переменных. В момент присваивания значения, объявление происходит автоматически. А присваивание выглядит так:
Импорт переменной в Python
Чтобы импортировать переменную из другого файла, используем в начале текущего файла следующую конструкцию:
from <откуда_импортируем> import <что_импортируем>
# файл main.py space_ship = 'Millenium Falcon' # файл second.py from main import space_ship print(space_ship) > Millenium Falcon
Проверка существования переменной
Чтобы выяснить, есть ли в программе переменная (например cat ), ищем вхождение строки с её названием в словарях, возвращаемых функциями locals() (локальная видимость) и globals() (глобальная видимость):
if "cat" in locals(): # … if "cat" in globals(): # …
Удаление переменной
Переменная удаляется, если передать её в качестве аргумента во встроенную функцию del() :
please_dont = 'alive' del(please_dont) print(please_dont) > Traceback (most recent call last): print(please_dont) NameError: name 'please_dont' is not defined
Что означает звездочка перед переменной?
Символ * перед именем переменной может означать несколько вещей.
1 . Распаковывает итерируемый объект в аргументы функции.
status = ['open', 'close'] print(status) > ['open', 'close'] print(*status) > open close
2 . Позволяет передавать в функцию переменное количество аргументов, запаковывая их в кортеж.
def summer(*terms): sum = 0 for term in terms: sum = sum + term return sum print(summer(2)) > 2 print(summer(3, 3)) > 6 print(summer(4, 43, 1)) > 48
3 . Позволяет вложить итерируемый объект в новую коллекцию.
Область видимости: локальные и глобальные переменные
Сначала терминология. Область видимости или пространство имен — это место в программном коде, где переменной было присвоено значение.
Существуют три разные области видимости:
1 Локальная. Если переменная была инициализирована внутри def , то она локальная.
def localExample(): # x — локальная внутри localExample() x = 5
2 Нелокальная. Если внутри функции определена другая функция, то переменная внутри внешнего def будет нелокальной для def внутреннего. То есть сделать вот так не получится:
def nonlocalExample(): # x — локальная внутри localExample() x = 5 def innerFunc(): x = x + 1 return x return innerFunc() print(nonlocalExample()) > UnboundLocalError: local variable 'x' referenced before assignment
Поэтому для корректной работы нужно использовать ключевое слово nonlocal :
def nonlocalExample(): # x — локальная внутри localExample() x = 5 def innerFunc(): nonlocal x x = x + 1 return x return innerFunc() print(nonlocalExample()) > 6
3 Глобальная. Переменная глобальна, если её присваивание производится за пределами всех def .
num = 42 def globalExample(n): res = n + num return res print(globalExample(1)) > 43
Статические переменные
Звучит очень похоже на определение глобальной переменной, однако в том-то и дело, что статическая переменная может быть и локальной.
Переменные в Python
В данном уроке мы рассмотрим чрезвычайно важную концепцию языка Python: переменные. Они позволят нам запоминать, переиспользовать и передавать данные в программах. Поскольку переменные можно найти в любом современном языке программирования, поэтому вам уже могут быть знакомы основные концепции. Однако я настоятельно рекомендую прочитать статью даже тем, для кого Python является не первым языком, поскольку здесь будут разобраны особености, которые не имеют аналогов в других языках.
Объявление переменных
Во первых стоит отметить что Python является языком с динамической типизацией. Это означает что любая переменная может содержать любые значение. Это отличается от тех же переменных, например, в C++. Там нужно явно указывать тип, значение которого будет содержать переменная.
Теперь давайте посмотрим как мы можем создать переменную и присвоить ей значение:
В данном примере мы создаем две переменные: foo и bar . Первая переменная содержит число, а вторая строку. Подробнее о типах в Python в следующем уроке. Как видите, для того чтобы присвоить переменной значение достаточно слева от оператора = указать ее имя, а с права ее значение. Если во время присваивания такой переменной нет, то интерпретатор Python’a создаст новую переменную с указанным именем и присвоит ей указанное значение.
Переменные в Python следует именовать в нижнем регистре и слова разделять нижним подчеркиванием: _ . Например: max_age , init_state .
После объявления переменной мы можем ее использовать в любом выражении. В нашем примере, мы передали переменную bar в функцию print() .
Вот результат работы программы:
Мы также можем указать значение для нескольких переменных за одну операцию:
Использование переменных в 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 не выдаёт ошибку: переменная существует и вне, и внутри функции.
Примечание: Определение глобальных переменных внутри функции не очень часто используется, поскольку усложняет код.
Также следует помнить о том, что если вы ссылаетесь на переменную внутри функции, не присваивая ей значения, такая переменная будет глобальной. Для того чтобы создать локальную переменную, необходимо присвоить ей значение в теле функции.
Работая с переменными, важно определить, какие из них больше подходят этой программе: глобальные или локальные. Обычно лучше использовать локальные переменные; но если одна переменная используется в нескольких функциях, вы можете инициализировать глобальную переменную. Если вы работаете с переменной только в пределах одной функции или одного класса, лучше использовать её локально.