Прошлый урок закончился тем, что первая программа наконец запустилась и напечатала свой результат. Теперь коду мало просто выводить готовые фразы: ему нужно где-то хранить данные, помнить их, изменять и передавать из одного места в другое. Именно для этого в Python существуют переменные и типы данных. Это фундамент, на котором держится вся дальнейшая работа: и простые вычисления, и обработка текста, и будущие программы на сотни строк. В этом уроке читатель узнает, что такое переменная и присваивание, как правильно назвать переменную, какие типы данных встречаются на старте, как типы превращаются один в другой и почему Python позволяет обменять два значения одной строкой.
Переменная как коробка с наклейкой для значения
Самое наглядное объяснение звучит так: переменная - это подписанная коробка, в которую кладут значение. Наклейка на коробке означает имя переменной, содержимое - сами данные. Положили число, достали число, заменили содержимое - коробка продолжает жить под той же наклейкой. В коде всё выглядит ещё проще:
age = 25
city = "Красноярск"
print(age)
print(city)
Знак равенства здесь работает совсем не так, как в школьной математике. Запись age = 25 это не утверждение о равенстве, а команда: вычислить то, что стоит справа, и сохранить результат под именем слева. Программисты называют это присваиванием. Читается строка естественно: положи число 25 в переменную age. Слева всегда стоит имя, справа всегда значение, перепутать их нельзя, за это интерпретатор сразу отругает.
Значение можно менять сколько угодно раз. Старое содержимое при этом просто выбрасывается:
x = 10
x = 20
print(x)
На экране появится 20, потому что число 10 было перезаписано. Никакого следа от него не остаётся, и Python не предупреждает о замене. Для новичка это иногда неожиданность: переменная помнит только последнее значение, о прошлых она забывает мгновенно. Отсюда растёт важная привычка - прежде чем перезаписать переменную, стоит убедиться, что старое значение больше нигде не понадобится.
Одно и то же значение можно передать сразу нескольким именам:
first = 7
second = first
print(second)
Теперь second хранит 7. Копируется именно содержимое, а не связь между именами: если позже first получит новое число, second останется при своём. Легко проверить, добавив пару строк с print(). Опытные программисты уточняют, что точнее говорить не о коробках, а о ярлыках: имя прикрепляется к значению, и один объект может носить несколько ярлыков одновременно. Разница заметна на примере:
a = 5
b = a
b = 99
print(a, b)
Вывод будет 5 и 99. Ярлык b переклеился на новое число, а старый объект со значением 5 никуда не делся, к нему по-прежнему прикреплён ярлык a. Пока переменная существует, её значение живёт в оперативной памяти, и программа может обращаться к нему сколько угодно раз.
Правила именования переменных без неожиданностей
Имя переменной выбирает сам программист, но интерпретатор предъявляет к нему жёсткие требования. Нарушение любого из них останавливает программу ещё до запуска с сообщением о синтаксической ошибке. Чтобы имена принимались без вопросов, соблюдают простые ограничения:
- Имя составляют латинские буквы, цифры и знак подчёркивания, пробелы и дефисы внутри имени запрещены;
- Цифра не может стоять первой, поэтому user_2 допустимо, а вот 2_user вызовет ошибку invalid decimal literal;
- Регистр важен, потому что age, Age и AGE для Python это три разные переменные;
- Зарезервированные слова языка вроде if, for, while и class занимать под имена нельзя;
- Составные имена пишут в стиле snake_case, разделяя слова подчёркиванием, например user_name или total_price.
Про регистр стоит убедиться собственными глазами:
Age = 30
age = 18
print(Age, age)
Программа выведет 30 и 18, потому что две переменные живут независимо. По этой же причине не стоит давать имена, отличающиеся только заглавной буквой: рано или поздно такой код запутает самого автора, а не только читателя.
Отдельная история с зарезервированными словами. Строка class = 5 упадёт с SyntaxError, потому что class в Python это команда объявления класса и ничем другим быть не может. Функция print к зарезервированным словам не относится, однако затирать её имя тоже плохая идея: строка print = 5 на время лишит программу возможности печатать, и следующая команда print("текст") закончится сообщением о том, что целое число нельзя вызвать.
Хорошее имя экономит время. total_price понятно через полгода, а вот tp превратится в загадку, которую придётся разгадывать по коду. Длина имени ограничена только здравым смыслом: и слишком короткие, и слишком длинные названия мешают чтению. Кириллица в именах технически возможна, но профессионалы пишут только латиницей, потому что так код одинаково читается в любой команде и в любом редакторе. Для логических переменных часто берут приставку is или has, например is_ready, и по одному взгляду на имя становится ясно, что внутри лежит True или False.
Четыре базовых типа данных для старта
Значения бывают разными по природе, и Python различает их с первого взгляда. На старте курса хватает четырёх базовых типов.
Целые числа хранит тип int. Сюда попадают 25, 0, -7 и числа хоть из миллиона знаков, длину целых Python не ограничивает. Для читаемости большие числа разрешено разделять подчёркиваниями: 1_000_000 для интерпретатора то же самое, что 1000000, а глазу заметно легче.
Дробные числа живут в типе float. Главное отличие - точка: 19.99, 3.14, 0.5. Даже целое по смыслу значение с точкой становится float, как 5.0. Здесь полезно заранее знать одну особенность: дробные числа иногда выдают длинные хвосты вроде 0.30000000000000004 после сложения 0.1 и 0.2. Это не сбой, а свойство хранения дробей в памяти компьютера, с ним рано или поздно сталкивается каждый разработчик, и следующие уроки про арифметику покажут это наглядно.
Строки принадлежат типу str. Это любой текст в кавычках, причём одинарные и двойные равноправны: "Привет" и 'Привет' для Python одно и то же. Внутри строки можно хранить и цифры, но тогда "25" остаётся текстом, с которым невозможно честно складывать числа. Разница проявляется мгновенно:
print(5 + 5)
print("5" + "5")
Первая строка выведет 10, вторая склеит текст и выдаст 55. Вот зачем нужны типы: одинаковая с виду операция даёт разный результат в зависимости от того, что лежит внутри.
Логический тип bool умеет ровно два значения: True и False, оба пишутся с большой буквы. Он отвечает на вопросы вида "открыт ли магазин" и "совпал ли пароль" и станет главным героем будущих уроков про условия. Даже обычное сравнение уже возвращает bool:
count = 42
price = 19.99
greeting = "Привет"
is_open = True
print(count, price, greeting, is_open)
print(type(5 > 3))
Пока достаточно запомнить написание значений и то, что сравнения вроде 5 > 3 дают именно True или False.
Функция type() называет тип любого значения
Иногда тип виден сразу, а иногда подкрадывается сомнение: передо мной число или строка с цифрами? Для таких случаев в Python есть встроенная функция type(). Ей передают значение или переменную, а она отвечает, к какому типу то относится:
age = 25
price = 19.99
name = "Анна"
is_open = True
print(type(age))
print(type(price))
print(type(name))
print(type(is_open))
Запустив этот код, программист увидит четыре строки:
<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>
Слово class в выводе означает лишь то, что каждый тип в Python описан специальным классом, читать ответ нужно просто как int, float, str или bool. Функция type() выручает в двух случаях. Первый - учёба: пока типы не отскакивают от зубов, полезно проверять ими каждое сомнительное значение. Второй - поиск проблем: когда программа ведёт себя странно, type() часто показывает, что под знакомым именем лежит вовсе не то, что ожидалось.
Важная деталь: type() всегда смотрит на текущее значение, а не на имя как таковое. Пока переменной не присвоено значение, спрашивать её тип бессмысленно, ведь интерпретатор вообще не знает о её существовании и ответит ошибкой NameError. Сначала значение, потом вопрос о типе, именно в таком порядке живёт любой код на Python.
Динамическая типизация привязывает тип к значению
Во многих языках программирования переменную заранее записывают в определённый тип, и переезд из целого числа в строку ей запрещён навсегда. Python выбрал другой путь. Тип здесь принадлежит значению, а не имени: коробка не требует, чтобы в ней всю жизнь лежали только яблоки. Такое устройство языка называют динамической типизацией, и выглядит оно так:
value = 42
print(type(value))
value = "сорок два"
print(type(value))
Сначала value хранит число и честно отвечает int, через строку кода хранит строку и отвечает str. Никаких объявлений, никаких разрешений, интерпретатор спокойно переваривает смену типа на ходу.
Удобство очевидно: код пишется быстрее, лишние формальности не мешают. Обратная сторона прячется в невнимательности. Если по дороге значение незаметно сменило тип, ошибка всплывёт не при написании, а при запуске, возможно, в самый неподходящий момент. Опытные разработчики поэтому держатся негласного правила: одна переменная на протяжении программы хранит данные одного сорта. А ещё они пользуются type() как страховкой, проверяя подозрительные места. Python допускает и подсказки вида name: str = "Анна": они ничего не запрещают и не проверяют на ходу, зато документируют намерения и помогают редакторам кода подсказывать правильные методы для значения.
Из той же идеи вырастает простая истина для новичка: ошибка, связанная с типом, это всегда ошибка значения, а не имени. Имя безобидно, менять тип оно не умеет, всё решает то, что в него положили последним.
Преобразование типов функциями int, float и str
Типы приходится не только узнавать, но и превращать один в другой. Для этого в Python есть три рабочие лошадки: int(), float() и str().
int() делает целое число. Из строки "25" получается число 25, из дробного 7.9 - целое 7, причём дробная часть не округляется, а просто отсекается:
number = int("25")
print(number + 5)
cut = int(7.9)
print(cut)
Вывод будет 30 и 7. Интересно, что int(7.9) не даёт восьмёрку: округления здесь нет, после точки всё отбрасывается. Если же настоящее округление всё-таки нужно, существуют отдельные функции, и они появятся позже в курсе.
float() делает дробное число и понимает как строку с точкой, так и целое:
pi = float("3.14")
whole = float(25)
print(pi, whole)
Здесь выведется 3.14 и 25.0: целое число честно переехало в дробный тип и теперь знает про запятую в памяти компьютера.
str() делает строку из чего угодно и незаменим, когда текст нужно склеить с числом:
age = 30
message = "Возраст: " + str(age)
print(message)
Без str(age) сложение строки и числа закончится TypeError, потому что Python не берёт на себя смелость угадывать, имелся в виду текст или арифметика.
Самая известная ошибка новичка случается, когда преобразование просят невозможное:
word = "abc"
number = int(word)
Интерпретатор ответит ValueError: invalid literal for int() with base 10: 'abc'. Смысл сообщения простой: из букв невозможно собрать целое число. Тот же отказ ждёт строку "25.5" внутри int(), хотя float("25.5") спокойно справится и вернёт 25.5. Практическое правило звучит так: прежде чем превращать строку в число, стоит убедиться, что внутри действительно цифры. Особенно часто это встречается при вводе данных пользователем, ведь функция input() возвращает всегда строку, даже если человек набрал 42, и перед вычислениями её отправляют в int().
Обмен значениями одной строкой кода
Классическая задача для разминки: есть две переменные, нужно поменять их содержимое местами. В большинстве языков для этого заводят третью, временную:
a = 5
b = 10
temp = a
a = b
b = temp
print(a, b)
Работает, но выглядит громоздко: четыре строки ради простого обмена. Python предлагает приём, который новички сначала принимают за фокус:
a = 5
b = 10
a, b = b, a
print(a, b)
На экране окажется 10 и 5, значения поменялись местами. Секрет в том, что справа от знака равенства Python сначала собирает пару из текущих значений b и a, словно раскладывает их на столе, и только потом раздаёт имена слева. Пока он это делает, старые значения никуда не исчезают, поэтому никакая третья переменная не нужна. Такой приём называют множественным присваиванием, и он умеет больше, чем обмен:
x, y, z = 1, 2, 3
print(x, y, z)
Теперь у каждой переменной своё число, и код получился короче и понятнее длинной колонки отдельных присваиваний.
На этой ноте урок заканчивается. Переменные уже умеют хранить данные любых базовых типов, превращать их один в другой и даже меняться местами одной строкой. В следующем уроке они начнут приносить пользу по-настоящему: впереди арифметические операторы, которые складывают, вычитают, умножают и делят значения, превращая коробки с числами в работающий калькулятор.