2.1. Ввод и вывод данных. Операции с числами, строками. Форматирование

Ключевые вопросы параграфа

1. Как в Python получать данные от пользователя и выводить их на экран?
2. Что такое переменные и как с ними работать?
3. Как устроены строки в Python и какие операции можно с ними выполнять?
4. Какие существуют способы форматирования строк и зачем они нужны?
5. Как выполнять базовые арифметические операции с числами?

Ввод и вывод данных

Во введении к курсу мы уже узнали, что командная строка в Visual Studio Code находится внизу на вкладке «Терминал». Именно там мы будем вводить данные с клавиатуры, а программа будет выводить результат на экран. Графического интерфейса у наших программ не будет.

Вспомним первую программу из введения:

1phrase = input("Введите строку: ")
2print(phrase)

Здесь мы используем встроенную функцию print(). Как она устроена внутри — пока не так важно. Главное — запомнить, что у неё есть имя, по которому можно к ней обратиться, и она принимает данные, которые нужно вывести. В этом примере мы передаём строку «Привет, мир!».

В Python строки заключаются в кавычки. Можно использовать:

• одинарные кавычки: 'Привет',
• двойные: "Привет",
• или тройные двойные кавычки: """Привет""".

Можно также сочетать виды кавычек, чтобы вставлять одни внутрь других:

• print('Привет, мир!')
• print("Привет, мир!")
• print("""Привет, мир!""")
• print("Программа выводит фразу 'Привет, мир!'")

Что такое переменные и как с ними работать

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

Но чтобы сохранить введённые данные и использовать их позже, нам нужны переменные. Переменную можно представить как «контейнер», в который мы записываем значение. У каждой переменной есть имя.

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

1phrase = input()
2print(phrase)

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

Когда вы нажимаете Enter строка сохраняется в переменную phrase, и программа продолжает выполнение.

Переменная начинает существовать в программе, когда в неё записывается какое-то значение. В момент присваивания Python автоматически определяет тип данных. В данном случае phrase получает строковый тип — str. Тип данных str используется для хранения строк, а сами строки — это упорядоченная последовательность символов.

У функции input() можно задать параметр-строку перед вводом значения — и тогда указанный текст будет сопровождать приглашение к вводу данных:

1phrase = input("Введите строку: ")
2print(phrase)

Именование переменных

В Python принят стандарт оформления кода — PEP 8 (Python Enhancement Proposals).

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

Примеры хороших имён:

• name;
• user_input;
• value;
• first_value.

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

И ещё — если вам всё же потребуется использовать однобуквенную переменную, избегайте вариантов вроде: I (большая английская i), l (маленькая английская L), O — они легко путаются с цифрами и мешают читать код.

Все стандарты PEP можно посмотреть на этой странице.

Расширим пример: print() с несколькими значениями

Функция print() может выводить сразу несколько значений, перечисленных через запятую.

Выведем, например, фразу Добрый день, %имя%.:

1name = "Пользователь"
2print("Добрый день,", name, ".")

В консоли отобразится:

Добрый день, Пользователь .

Но здесь между Пользователь и точкой появится лишний пробел. Это происходит потому, что print() по умолчанию добавляет пробел между аргументами.

Чтобы убрать его, используем параметр (именованный аргумент) sep (англ. separator — «разделитель»):

1print("Добрый день, ", name, ".", sep="")

Теперь результат будет: Добрый день, Пользователь.

Обратите внимание: для именованных аргументов вокруг символа "=" не ставятся пробелы.

Но вручную управлять пробелами и разделителями — не всегда удобно. К счастью, в Python есть более элегантное решение — f-строки.

f-строки

С их помощью мы можем встроить переменные прямо внутрь строки и удобно её форматировать.

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

1name = "Пользователь"
2print(f"Добрый день, {name}.")

Можно не только вставлять переменные, но и выполнять операции, вызывать функции и настраивать выравнивание внутри строки:

1print(f"{123:0>9}") # 000000123 (выравнивание по правому краю)
2print(f"{123:0<9}") # 123000000 (выравнивание по левому краю)
3print(f"{123:0^9}") # 000123000 (выравнивание по центру)

В консоли будут напечатаны следующие строки:

000000123
123000000
000123000

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

Кроме f-строк, существуют и другие способы:

• format() — чуть менее удобен, но тоже широко используется:

1print("Привет, {}!".format(name))

• %-форматирование — устаревший способ, похожий на стиль языка C (здесь можно почитать про него подробнее)

1print("Привет, %s!" % name)

Управляющие символы в строках

Внутри строк можно использовать управляющие символы, начинающиеся с \ (бэкслеш):

• \n — переход на новую строку;
• \t — табуляция;
• \r — возврат каретки в начало строки;
• \b — возврат каретки на один символ.

Кроме того, с помощью бэкслеша можно экранировать символы, то есть делать их частью выводимой строки. Например, для вывода символа \ необходимо его экранировать самим собой:

1print("\\")

Подробнее об экранировании можно почитать тут.

Параметры sep и end в print()

В функции print() кроме параметра sep существует параметр end, который определяет символ в конце строки.

Значение по умолчанию для него — переход на новую строку, обозначаемый как \n.

Если вывести строки с помощью нескольких использований функции print(), то вывод каждой из них будет осуществлён с новой строки:

1print("Привет, Пользователь!")
2print("Как дела?")

Привет, Пользователь!
Как дела?

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

Операции со строками

Сложение (конкатенация строк)

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

1print("Сложно" + "подчинённый") # Сложноподчинённый

Умножение строки на целое число

При умножении строки на целое число n получается новая строка, состоящая из n дублирований исходной строки. Например, выведем 10 символов - подряд:

1print("-" * 10)

Это только часть возможностей Python по работе со строками. В следующих параграфах мы подробнее рассмотрим работу со списками, методами строк и регулярными выражениями. А сейчас — к числам!

Операции с числами

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

Целые и вещественные числа

В программировании, как и в математике, существуют два основных типа чисел:

• Целые числа — это числа без дробной части:
  -3, 0, 42

• Вещественные числа (или числа с плавающей точкой, float) — это числа с дробной частью:
  3.14, 0.5, -7.25

В Python для записи вещественных чисел используется точка, а не запятая.

1a = 2 # целое число
2b = 2.0 # вещественное число

Создание числовых переменных

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

1n = 10 # целое число
2pi = 3.14 # вещественное число

Преобразование типов

Для преобразования строк в числа и наоборот используются следующие функции:

• int() — преобразует строку (или вещественное число) в целое число. Дополнительно можно указать, в какой системе счисления было записано исходное число. По умолчанию используется десятичная система. При конвертации вещественного числа в целое отбрасывается дробная часть;
• float() — преобразует строку (или целое число) в вещественное число;
• str() — преобразует значения (в общем случае не только числовые) в строки.

1n_1 = "1"
2n_2 = "2"
3print(n_1 + n_2)
4n_1 = int(n_1)
5n_2 = int(n_2)
6print(n_1 + n_2)

В результате выполнения программы получим:

12
3

Первый результат — результат сложения (конкатенации) двух строк. Второй — результат сложения целых чисел, которые были преобразованы из строк функцией int().

1x = 3.89
2x = int(x)
3print(x)

Здесь программа выведет в консоли результат 3. Дробная часть после десятичного разделителя была отброшена при преобразовании в целое число.

1width = "3.7"
2height = "2.5"
3s = float(width) * float(height)
4print(s)

Программа выведет: 9.25.

А чтобы вводить целые или вещественные числа с клавиатуры, можно использовать уже знакомую нам функцию input() в сочетании с функциями int() и float():

1int_number = int(input())
2float_number = float(input())

Основные арифметические операции

Для работы с числовыми переменными доступны следующие математические операции:

• сложение — x + y;
• вычитание — x - y;
• умножение — x * y;
• деление — x / y;
• возведение в степень x ** y.

Используем все эти операции в следующей программе:

1n = 25
2x = 0.5
3
4print(n + x)
5print(n - x)
6print(n * x)
7print(n / x)
8print(n ** x)

Вывод программы будет таким:

25.5
24.5
12.5
50.0
5.0

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

Например, выполнение следующего кода выведет на экран 2.0:

1print(4 / 2)

Округление

Для округления вещественных чисел при выводе можно использовать уже известные нам f-строки. Например, выведем квадратный корень из 2 с точностью до двух знаков после запятой:

1print(f"{2 ** 0.5:.2f}")

Дополнительные операции

Для целых чисел дополнительно доступны операции:

• целочисленное деление — x // y;
• остаток от деления — x % y.

Эти операции можно использовать, например, для получения определённых цифр числа. Получим последнюю цифру числа 1234 (то есть остаток от деления на 10):

1last_digit = 1234 % 10

Для получения предпоследней цифры нужно «отрезать» последнюю цифру целочисленным делением на 10, а затем у нового числа найти последнюю цифру — уже известным нам способом:

1penultimate_digit = 1234 // 10 % 10

Порядок выполнения операций (приоритет)

• **;
• *, /, %, //;
• +, -.

Системы счисления

В Python можно переводить числа между системами счисления.

Если требуется перевести число из системы счисления с основанием от 2 до 36 в десятичную систему счисления, то для этого следует использовать функцию int() с двумя параметрами:

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

Переведём число 1001 из двоичной системы счисления в десятичную, чтобы получить число 9:

1binary_value = "1001"
2print(int(binary_value, 2))

Если требуется перевести число из десятичной системы счисления в двоичную, восьмеричную или шестнадцатеричную, то следует использовать соответственно функции: bin(), oct() и hex(). Эти функции принимают число в десятичной системе счисления, а возвращают строку, представляющую запись числа в соответствующей системе счисления.

✅ У вас получилось справиться с каждым примером?

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

👉 Оценить этот параграф

Что дальше

Теперь, когда вы научились работать с вводом, выводом, строками и числами в Python, можно переходить к следующему важному шагу — обучить программу принимать решения.

В следующем параграфе вы узнаете:

• как писать условия с помощью if и else;
• как проверять несколько вариантов с помощью elif;
• что такое логические выражения и как они работают в коде;
• как сделать программу более гибкой и интерактивной.

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

А пока вы не ушли дальше — закрепите материал на практике:

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

Хотите обсудить, задать вопрос или не понимаете, почему код не работает? Мы всё предусмотрели — вступайте в сообщество Хендбука! Там студенты помогают друг другу разобраться..

Ключевые выводы параграфа

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