Переменные в Python
Разберемся, как работать с переменными в Python, какие ошибки часто допускают неопытные разработчики и как их исправлять.
Как создать переменную
Представьте, что нам нужно напечатать на экран фразу Привет! два раза. Эту задачу можно решить так:
print('Привет!')
print('Привет!')
В простейшем случае так и стоит поступить. Но если фраза Привет! будет использоваться чаще двух раз, да еще и в разных частях программы, то придется ее везде повторять — это неудобно. Проблемы с таким подходом начнутся, когда понадобится изменить фразу, а такое происходит довольно часто. Нам придется найти все места с этой фразой и выполнить необходимую замену.
А можно поступить по-другому. Чтобы не копировать выражение, достаточно создать с ним переменную:
# greeting - переводится как приветствие
greeting = 'Привет!'
print(greeting)
print(greeting)
# => Привет!
# => Привет!
В строчке greeting = 'Привет!' мы берем переменную с именем greeting и присваиваем ей значение 'Привет!'. Переменная указывает на данные, которые в нее записали. Благодаря этому, данные можно использовать многократно и не дублировать их постоянно. Когда переменная создана, можно ее использовать. Она подставляется в те места, где раньше стояла наша фраза. Когда код выполняется, интерпретатор доходит до строчки print(greeting) и подставляет содержимое переменной, а затем выполняет код. Для имени переменной используется любой набор допустимых символов, к которым относятся буквы английского алфавита, цифры и знак нижнего подчёркивания(_). При этом цифру нельзя ставить в начале. Имена переменных зависят от регистра самих букв, то есть имя hello и имя Hello — это два разных имени для двух разных переменных. Регистр в Python имеет очень важное значение, никогда не забывайте про него. Количество создаваемых переменных неограниченно(лишь бы у устройства хватало мощности и памяти). Большие программы содержат десятки и сотни тысяч имен переменных. Вот как выглядят две переменные внутри одной программы:
greeting1 = 'Привет!'
print(greeting1)
print(greeting1)
greeting2 = 'Пока!'
print(greeting2)
print(greeting2)
Чтобы программу было удобно читать, среди программистов принято создавать переменные как можно ближе к тому месту, где они используются. Теперь нужно разобраться, как их изменять.
Как изменить переменную
Само слово «переменная» подсказывает, что ее можно менять. И действительно, со временем внутри программы значения переменных могут изменяться. Например:
greeting = 'Привет!'
print(greeting) # => Привет!
greeting = 'Пока!'
print(greeting) # => Пока!
Имя переменной осталось тем же, но внутри появились другие данные. Отметим, что переменные в Python не требуют специального объявления. Вместо этого переменная объявляется, когда ее впервые используют в программе. Переменные — мощная и в то же время запутанная вещь. Нельзя сразу с уверенностью сказать, что внутри нее записано — сначала надо проанализировать код, который находится до переменной. Именно этим занимаются разработчики во время отладки, когда пытаются разобраться, почему программа работает не так, как задумано.
Какие ошибки часто допускают с переменными
Порядок инструкций в коде с переменными имеет огромное значение. Поэтому переменную нужно определить до первого использования. Ниже пример ошибки, которую часто допускают новички:
print(greeting)
greeting = 'Привет!'
Запуск программы выше завершается с ошибкой NameError: name 'greeting' is not defined — это ошибка обращения. Это значит, что в коде используется имя переменной(идентификатор), которое пока не определено. Это говорится в самом тексте ошибки: 'greeting' is not defined. Кроме неправильного порядка действий, в Python встречаются банальные опечатки в имени переменной. Это происходит и когда переменная используется, и когда ее объявляют. Количество подобных ошибок можно уменьшить, если использовать правильно настроенный редактор. Он предупреждает о возможных проблемах и подсвечивает переменные, которые используются без объявления. С переменными мы разобрались. Можно переходить к данным, которые никогда не меняются.
Как работают константы
Некоторые данные никогда не меняются — например, математические постоянные. Возьмем для примера число π. Оно всегда равно 3.14 и не может измениться. Чтобы обратиться к подобным данным, в Python используют константы:
PI = 3.14
print(PI) # => 3.14
В Python интерпретатору нет разницы при работе с переменной как с обычной или константой(нет оператора const как в некоторых других языках программирования). Разница только в том, что константы принято именовать заглавными буквами и использовать нижнее подчёркивание(_) в качестве разделителя между словами. Константа, как и переменная, может использоваться в любом выражении.
Выражения в определениях
Переменные помогают упрощать сложные вычисления. Например, конвертация валюты или составление нового слова. Рассмотрим два способа.
Сложные вычисления через переменную
Представим, что нам нужно перевести доллары в рубли через евро. Подобные конвертации через промежуточную валюту часто делают банки при покупках за рубежом.
Для начала переведем 50 долларов в евро. Допустим, что один доллар — 0.96 евро:
euro_count = 50 * 0.96
print(euro_count) # => 48.0
Здесь в переменную euro_count = 50 * 0.96 справа от знака «равно» мы записываем выражение. Интерпретатор вычислит результат (48.0) и запишет его в переменную. Интерпретатору не важно, в каком виде записаны данные: 48.0 или 50 * 0.96. Для него оба варианта — выражения, которые надо вычислить. Он проводит вычисления и приходит к одному и тому же значению — 48.0.
Python различает выражения (expressions) и инструкции (statements). Выражение — это любой корректный блок кода, который возвращает значение. Конкатенация строк (склеивание значений переменных) — это тоже выражение. Когда интерпретатор видит выражение, он обрабатывает его и генерирует результат — значение выражения. Вот несколько примеров выражения. В комментариях справа от каждого выражения записаны итоговые значения:
48.0 # 48.0
50 * 0.96 # 48.0
100 / 10 * 2 # 20.0
int('50') # 50
'привет' # привет
'при' + 'вет' # привет
Инструкция — это команда, действие.
if, while, for — примеры инструкций. Они производят или контролируют действия, но не превращаются в значения.
Операция присваивания также является инструкцией, потому что она не возвращает, а связывает имя переменной с заданным значением:
x = 42 # это инструкция (statement)
x + 1 # а это выражение (expressions)
В тех местах, где ожидается выражение, можно поставить любое вычисление. Оно может быть не только математическим, но и строковым — как конкатенация. Программа все равно останется работоспособной. Программы состоят из множества комбинаций выражений. Основываясь на сказанном выше, подумайте, сработает ли такой код:
author = "Jack " + 'London'
print(author)
Такой код выведет на экран строку Jack London. Если хотите проверить самостоятельно, запустите код в конце статьи и поэкспериментируйте. С помощью переменных можно записывать еще более сложные вычисления. Вернемся к нашей валютной программе. Запишем стоимость евро в рублях как отдельную переменную. Вычислим цену 48 евро в рублях, умножив их на 105. Допустим, что 1 евро — 105 рублей:
rubles_per_euro = 105
euro_count = 50 * 0.96 # 48.0
rubles_count = euro_count * rubles_per_euro # 5040.0
print(rubles_count)
Теперь добавим к выводу текст с помощью конкатенации:
rubles_per_euro = 105
euro_count = 50 * 0.96 # 48.0
rubles_count = euro_count * rubles_per_euro # 5040.0
# Функция str() превращает число в строку.
print('У вас получилось: ' + str(rubles_count) + ' рублей.')
# => У вас получилось: 5040.0 рублей.
Любая переменная может быть частью любого выражения. В момент вычисления вместо имени переменной подставляется ее значение. Интерпретатор вычисляет значение euro_count до того, как эта переменная начнет использоваться в других выражениях. Когда подходит момент использования переменной, Python уже знает значение, потому что вычислил его. С помощью переменных можно проводить сложные вычисления, а также делать подробный вывод с получившимся значением. Но еще можно получать новые выражения посредством склеивания двух и более значений переменных. За это отвечает конкатенация.
Переменные и конкатенация
Попробуем использовать переменные с конкатенацией, при этом синтаксически ничего не поменяется. Вот как конкатенировать две строки:
author = "Jack " + "London"
print(author) # => Jack London
Значит, также можно склеить строку и одну переменную, в которой записана строка:
first_name = "Jack"
author = first_name + " London"
print(author) # => Jack London
А еще можно конкатенировать две или три переменные и т.д., в которых записаны строки:
first_name = "Jack"
last_name = "London"
author = first_name + " " + last_name
print(author) # => Jack London
Переменные — важный инструмент в программировании. Они упрощают сложные вычисления и таким образом облегчают разработку. Но, чтобы успешно работать с переменными, надо не только правильно использовать их, но и правильно называть.
Именование переменных
Представьте следующую программу:
x = 'Привет!'
print(x)
С подобной программой мы уже работали, но сейчас в ней изменилось имя переменной на x.
Компьютеру без разницы, как мы именуем ту или иную переменную. Названия важны только людям. Обычно программисты гораздо чаще читают чужой код, чем пишут свой. Чтобы другие смогли с легкостью прочитать и проанализировать ваш код, нужно понятно называть переменные. Важно придумать понятное название, которое отражает смысл переменной. При этом важно давать такие имена, которые будут понимать без контекста, без изучения окружающего кода. Существует общепринятое правило: не используйте транслит для имен — только английский язык. Если вы испытываете сложности с английским, то пользуйтесь переводчиком. Со временем, анализируя чужой код, вы научитесь правильно именовать переменные. Среди разработчиков есть шутка: «Названия переменных — это одна из самых сложных вещей в программировании». Придумывать названия и правда сложно. Например, сложно назвать переменную, в которой хранится количество неоплаченных заказов от клиентов с задолженностью в предыдущем квартале.
Чтобы проверить себя, попробуйте сделать такое задание: Придумайте название для переменной, в которой будет храниться «количество братьев и сестер». Запишите его в блокноте или отправьте себе на почту. Не указывайте там ничего, кроме названия переменной. А потом через пару месяцев попытайтесь вспомнить что это значило.
Теперь разберем, как придумывать простые и понятные имена переменных.
Именование переменных
greeting — пример простого имени, но не все имена так просты. Часто они включают в себя несколько слов: например, «имя пользователя». В разных языках применяются разные стили кодирования, и имя переменной будет отличаться.
К именованию переменных есть три основных подхода, которые иногда комбинируют друг с другом. Все эти подходы проявляют себя, когда имя переменной состоит из нескольких слов:
- kebab-case — составные части переменной разделяются дефисом (my-super-var)
- snake_case — для разделения используется подчеркивание (my_super_var)
- CamelCase — каждое слово в переменной пишется с заглавной буквы (MySuperVar)
Переменные в Python именуются в стиле snake_case: слова записываются строчными буквами и разделяются символом подчеркивания _. Чтобы разобраться подробнее, можете изучить раздел «Как называть переменные» в стандарте PEP8 https://peps.python.org/pep-0008/#method-names-and-instance-variables.
Далее посмотрим пример плохих практик и разберем, почему их стоит избегать.
Магические числа
Возьмем пример программы, которая считает курс валют:
rubles_per_euro = 105
euro_count = 50 * 0.96 # 48.0
rubles_count = euro_count * rubles_per_euro # 5040.0
print(rubles_count)
С точки зрения профессиональной разработки, такой код не соответствует «лучшим практикам» — best practices. В этом примере сложно понять, что значат числа 50 и 0.96. Представьте, что вам придется разбираться в этом коде через месяц или через год — это будет сложно. Также сложно будет программисту, который не видел код ранее. В нашем примере контекст легко восстановить, потому что переменные названы грамотно. Но в реальных проектах код значительно сложнее, поэтому понять смысл чисел зачастую невозможно. Проблема кроется в «магических числах» — magic numbers. Это числа, происхождение которых невозможно понять с первого взгляда — приходится глубоко вникать в то, что происходит в коде. Чтобы предотвратить проблему, нужно создавать переменные с правильными именами. Так все встанет на свои места:
euro_per_dollars = 0.96
rubles_per_euro = 105
dollars_count = 50
euro_count = dollars_count * euro_per_dollars # 48.0
rubles_count = euro_count * rubles_per_euro # 5040.0
print(rubles_count)
В этой программе:
- Используется именование snake_case.
- Две новые переменные отделяются от последующих вычислений пустой строчкой. Эти переменные имеют смысл и без вычислений, поэтому такое отделение уместно, потому что повышает читаемость.
Получился хорошо именованный и структурированный код, но он длиннее прошлой версии. Так часто бывает — это нормально, ведь код должен быть читабельным. Магические числа и непонятные именования переменных не ломают код, но делают его менее читабельным. Нужно понимать, что компьютер в любом случае выполнит заданное вычисление. Однако другой программист будет читать код и ничего не поймет — это усложнит работу. Правильное именование переменных — половина успеха анализа кода.
Попробуйте сами запустить код в окне ниже с интерпретатором Python и повторите примеры из статьи чтобы самим увидеть и понять как всё это работает. Для этого в ячейке с кодом нажмите клавиши на клавиатуре Shift+Enter или запустите код через кнопку Run по значку ▶.