Программы из первых уроков курса походили на граммофон без пластинки: они умели говорить, но слушать никого не собирались. Все числа и текст лежали прямо в коде, и чтобы подставить свои значения, приходилось открывать файл и править строки руками. В прошлом уроке строки и f-строки уже научились собирать аккуратные сообщения, и теперь к этой паре присоединяется вторая половина диалога. Функция input читает то, что человек набирает на клавиатуре, а print возвращает ответ на экран, и вместе они превращают скрипт в партнёра по диалогу, который спрашивает, ждёт и отвечает. Дальше разбирается, почему input всегда приносит строку, как из текста получаются числа через int и float, чем управляют параметры sep и end, как f-строки оформляют персональный ответ, как принять несколько значений за один заход и что происходит, когда вместо числа пользователь вводит слово.

Функция input всегда возвращает строку

Стоит вызвать input, и программа замирает: на экране появляется подсказка, мигает курсор, а python терпеливо молчит, пока человек не наберёт ответ и не нажмёт Enter. Всё, что было напечатано до нажатия Enter, уходит в переменную, а сам Enter внутрь не проходит, лишний перевод строки программе не достаётся. Текст в скобках называется приглашением ко вводу, он не обязателен, но без него пользователь видит пустой терминал и не понимает, чего от него ждут, поэтому подсказку пишут почти всегда, и в её конце приятно видеть пробел после знака вопроса.

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

name = input("Как тебя зовут? ")
print("Привет,", name)

Если запустить файл и ввести имя Аня, терминал покажет такую сцену:

Как тебя зовут? Аня
Привет, Аня

Настоящее удивление начинается, когда в ответ вводят цифры. Кажется очевидным, что 25 и есть число, но python видит в ответе только два символа подряд, то есть текст. Проверка type(age) расставляет всё по местам:

age = input("Сколько тебе лет? ")
print(type(age))

На экране появится <class 'str'>, честное объявление, что в age лежит строка. Из этого наблюдения вырастает классическая ошибка первого знакомства с вводом:

age = input("Сколько тебе лет? ")
print(age + 1)

Python отвечает сообщением TypeError: can only concatenate str (not "int") to str. По-человечески это звучит так: строку нельзя сложить с числом. Строка со строкой склеится, число с числом посчитается, а смешивать интерпретатор отказывается наотрез. Символ плюс у строк работает клеем, и выражение "25" + "5" вернёт "255", хотя новичок, ждавший 30, обычно долго трёт глаза и пересчитывает заново. К этой ошибке полезно привыкнуть заранее: она означает одно и то же, python не понял, чего от строки хочет человек, и хорошая привычка состоит в том, чтобы проверять тип сомнительного значения через type прежде, чем писать вычисления.

Превращение текста в число через int и float

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

age = int(input("Сколько тебе лет? "))
print("Через пять лет тебе будет", age + 5)

Теперь сложение работает, потому что в age лежит честное целое число, а не набор символов. Кто любит пошаговость, может разложить превращение на две строки, результат получится точно таким же:

raw = input("Сколько тебе лет? ")
age = int(raw)

Одна строка компактнее, две нагляднее при поиске ошибки, и в учебных программах уместны оба варианта. Для денег, веса и роста целых чисел мало, там вступает в игру float, который понимает десятичную точку:

weight = float(input("Вес посылки в килограммах? "))
print("Половина веса:", weight / 2)

У пары int и float обнаруживается характер. float("10") вернёт 10.0, дробная часть не обязательна, а вот int точку не понимает и на строке "10.5" останавливается с уже знакомым ValueError, ведь целое число не может иметь дробную часть. Зато оба переживают лишние пробелы вокруг значения, int(" 7 ") молча вернёт 7, и оба понимают знак минус, int("-5") честно даст отрицательное число. Выбор на практике простой: целые количества шагов, людей и предметов считаются через int, а любые измерения с копейками, граммами и сантиметрами идут через float.

Параметры sep и end у функции print

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

print("Я", "учу", "Python")

Три слова склеятся с пробелами, и терминал покажет Я учу Python. Параметр sep задаёт разделитель между аргументами, имя происходит от английского separator:

print("15", "03", "2026", sep="-")

На экране появится готовая дата 15-03-2026. Разделителем может быть и несколько символов, sep="***" протянет между кусками декоративную линию. Параметр end отвечает за то, что печатается в самом конце вместо перевода строки:

print("Загружаю", end=" ")
print("данные...")

Оба вызова уложатся в одну строку: Загружаю данные... Таким манером удобно собирать ответ из кусочков, например печатать прогресс по шагам. А пустой print() без аргументов вставляет пустую строку и помогает отделять смысловые блоки вывода друг от друга, как абзацы в книге. Оба параметра указываются вместе в одном вызове, после всех печатаемых значений:

print("Итог", 42, "балла", sep=" ~ ", end="!")

Здесь слова разделятся тильдами, а перевод строки не случится, если дальше идёт продолжение. Тут стоит затронуть тонкость, которая часто путает. Запятая внутри print и знак плюс дают разные результаты. Запятая автоматически ставит пробел и принимает значения любого типа:

print("Сумма:", 2 + 3)

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

print("Сумма: " + str(2 + 3))

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

Красивый вывод результатов через f-строки

Прошлый урок разобрал f-строки по винтикам, и здесь они раскрываются в полную силу, потому что именно f-строки превращают сухой вывод в живой персональный ответ. Внутрь фигурных скобок можно ставить не только переменные, но и целые выражения с вычислениями:

name = input("Как тебя зовут? ")
age = int(input("Сколько тебе лет? "))
print(f"{name}, через десять лет тебе будет {age + 10}")

Возраст прибавится прямо внутри строки, и отдельная переменная для результата не нужна. С дробными числами f-строки проявляют ещё один талант, форматирование. Спецификатор .2f оставляет в числе два знака после запятой и превращает длинный хвост вида 12.400000000000001 в аккуратные 12.40:

price = float(input("Цена за килограмм? "))
weight = float(input("Сколько килограмм? "))
print(f"К оплате: {price * weight:.2f} руб.")

Такой трюк выручает при печати цен, процентов и любых таблиц, где столбцы должны выровняться по разряду. Частая оплошность новичка это потерянная буква f перед кавычками, тогда фигурные скобки печатаются на экран как обычный текст, и вместо имени пользователь видит {name}. Такая связка input плюс f-строка и есть рабочая лошадка учебных проектов и мелких утилит: спросил, посчитал, красиво ответил.

Несколько значений в одной строке через split

Расспрашивать пользователя по одному вопросу на значение бывает утомительно, и для этого приёма существует split. Метод разбивает введённую строку на части по пробелам и возвращает список, а python умеет сразу раздавать значения списка переменным:

a, b = input("Два числа через пробел? ").split()
print("Сумма:", int(a) + int(b))

Ввели 3 и 7 через пробел, получили Сумма: 10. Каждая часть остаётся строкой, поэтому перед вычислениями числа всё равно нужно превратить через int или float. Значений может быть и больше, механизм не меняется:

x, y, z = input("Три числа через пробел? ").split()
print(int(x) + int(y) + int(z))

Разделитель можно менять, и даты удобно резать по точкам:

day, month, year = input("Дату в формате дд.мм.гггг? ").split(".")
print(day, month, year, sep="/")

Ввод 15.03.2026 напечатает 15/03/2026. Метод split без аргументов переживает любое количество лишних пробелов между значениями, а split(",") разрежет перечень покупок, набранный через запятую. Лишь бы количество переменных слева совпадало с количеством кусков справа: если пользователь введёт два числа вместо трёх, python остановится с сообщением про нехватку значений, и это снова будет ValueError, только с другой формулировкой.

Мини-калькулятор из двух чисел и трёх действий

Пора собрать всё изученное в маленькую, но настоящую программу. Калькулятор задаёт два вопроса, считает и печатает три результата:

print("Простой калькулятор")
a = float(input("Первое число: "))
b = float(input("Второе число: "))
print("Сумма:", a + b)
print("Разность:", a - b)
print("Произведение:", a * b)

Сессия работы выглядит так:

Простой калькулятор
Первое число: 12.5
Второе число: 4
Сумма: 16.5
Разность: 8.5
Произведение: 50.0

float выбран сознательно: калькулятор принимает и дробные значения вроде 12.5, и целые, float понимает и те и другие. Стоит ввести целые, дробные и отрицательные числа, и программа переваривает всё, что похоже на число. Три вызова print подряд дают три аккуратные строки, а если хочется более выразительной записи, f-строки ужимают вывод:

print(f"{a} + {b} = {a + b}")
print(f"{a} - {b} = {a - b}")
print(f"{a} * {b} = {a * b}")

Для чисел 12.5 и 4 получится строка 12.5 + 4.0 = 16.5, float добавляет ноль к целому второму числу, на результат вычислений это не влияет, а в записи выглядит честно. Деление в программу сознательно не включено, и дело не только в экономии места. Делить на ноль нельзя, python завершает работу с ошибкой ZeroDivisionError, а чтобы программа вежливо отказывалась от опасного действия, ей сначала нужно научиться выбирать путь. Этим умением занимается следующий урок.

Ошибка ValueError при вводе букв вместо чисел

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

  1. Создать файл с одной строкой number = int(input("Введите число: ")) и запустить его;
  2. Ввести вместо числа слово двадцать и нажать Enter;
  3. Прочитать последнюю строку traceback, где python называет проблему по имени.

Экран покажет примерно такой текст:

Traceback (most recent call last):
  File "numbers.py", line 1, in <module>
    number = int(input("Введите число: "))
ValueError: invalid literal for int() with base 10: 'двадцать'

Последняя строка здесь главная. Слово ValueError сообщает тип ошибки, значение не подошло, а дальше python честно цитирует то, что пытался превратить в число. У float формулировка похожая: could not convert string to float: 'двадцать'. Пустой ввод валит программу точно так же, ведь превращать в число в пустой строке нечего. Сама ошибка не означает, что python сломался, программа просто получила данные, с которыми не умеет работать.

Из этого следуют два практических вывода. Первый: traceback читают с конца, последняя строка называет тип ошибки, а строка выше показывает место в файле. Второй: настоящие программы перед преобразованием проверяют, что именно ввёл человек, и вежливо переспрашивают вместо обрыва работы. Практика первых недель обучения показывает, что ValueError занимает верх строчек в списке встреченных ошибок, и это нормальный этап: язык лишь сообщает, что ждал данных одного вида, а пришли другого.

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