В данном учебном курсе мы будем писать программы без графического пользовательского интерфейса, то есть без кнопок, текстовых полей ввода и т. д. Программы будут принимать на вход данные от пользователя с клавиатуры (а чуть позже мы научимся работать с файловым вводом и выводом), а выводить результат будут на экран. Всё взаимодействие с программой будет происходить в командной строке, также называемой консолью или терминалом.
Во введении к курсу мы узнали, что командная строка в среде разработки Visual Studio Code находится внизу на вкладке «Терминал». Именно в ней мы будем вводить данные с клавиатуры, а программа будет выводить результаты. Как было сказано ранее, мы будем писать компьютерные программы, которые принимают на вход данные, работают с ними и выводят результат на экран.
Вспомним программу из введения:
print("Привет, мир!")
В этой программе мы вызываем встроенную функцию под названием print(). Как она устроена внутри, нам пока не столь важно. Главное — запомнить, что у неё есть имя, по которому к ней можно обратиться, плюс она принимает данные и обрабатывает их. О том, какими могут быть данные, мы тоже поговорим позже — в нашем примере мы передаём строку «Привет, мир!».
В Python строки заключены в кавычки — можно использовать одинарные, двойные и тройные (рекомендуется их составлять из трёх двойных). Внутри кавычек одного вида можно использовать другой вид кавычек как часть выводимой на экран строки.
Например:
print('Привет, мир!')print("Привет, мир!")print("""Привет, мир!""")print("Программа выводит фразу 'Привет, мир!'")
Данные в программу могут поступать различными способами. Самый простой и привычный для пользователя — это ввод с клавиатуры. Для этого в Python используется функция input(), которая возвращает в программу введённую пользователем строку. Но данные нужно куда-то сохранить, и в этом нам помогают переменные. Переменным назначаются имена, в них записываются значения, и затем они используются в программе по мере необходимости.
Напишем программу, которая получает от пользователя строку и выводит на экран:
phrase = input()
print(phrase)
После запуска программы происходит приостановка выполнения и в терминале появляется приглашение для ввода данных:
После ввода данных необходимо нажать клавишу Enter. Программа запишет введённые данные в переменную phrase и продолжит выполнение со следующей строчки. Переменная начинает существовать в программе, когда в неё записывается какое-то значение. В момент записи значения переменной назначается тип данных, определённый в соответствии со значением.
В нашем примере в переменную phrase записывается строка, введённая пользователем. Поэтому переменной phrase назначается встроенный в язык Python тип данных str. Тип данных str используется для хранения строк, а сами строки являются упорядоченной последовательностью символов.
У функции input() можно задать параметр-строку перед вводом значения — и тогда указанный текст будет сопровождать приглашение к вводу данных:
phrase = input("Введите строку: ")
print(phrase)
Для именования переменных и правильного оформления кода существует стандарт PEP 8 (Python Enhancement Proposals), который следует соблюдать. Согласно стандарту PEP 8, имена переменных должны содержать маленькие буквы английского алфавита и символ «подчёркивание» для разделения слов в имени. Пример имён переменных по стандарту: value, first_value.
Нельзя использовать следующие однобуквенные имена переменных:
- I (большая английская i);
- l (маленькая английская L);
- O.
Эти однобуквенные имена усложнят читаемость кода, так как могут быть перепутаны между собой или с цифрами. Все стандарты PEP можно посмотреть на этой странице.
Но вернёмся к функции print(). С её помощью можно выводить сразу несколько значений. Для этого их нужно перечислить через запятую. Выведем, например, фразу Добрый день, %имя%.:
name = "Пользователь"
print("Добрый день,", name, ".")
В консоли отобразится:
Добрый день, Пользователь .
Как видим, результат работы программы не соответствует нашим ожиданиям, так как между словом «Пользователь» и точкой появился пробел. Данный пробел является символом, который по умолчанию ставится между выводимыми значениями. Вместо пробела можно указать любую другую строку, даже пустую. Для этого нужно передать в функцию print() именованный аргумент sep (англ. separator — «разделитель»). Обратите внимание: для именованных аргументов вокруг символа "=" не ставятся пробелы. Сделаем так, чтобы вместо пробела в качестве разделителя использовалась пустая строка:
name = "Пользователь"
print("Добрый день, ", name, ".", sep="")
В консоли отобразится:
Добрый день, Пользователь.
Но в таком случае необходимые пробелы нам придётся ставить самим, а это неудобно. К счастью, в Python существует удобный и мощный инструмент для форматирования строк — f-строки. Чтобы задать f-строку, необходимо поставить букву f перед открывающей кавычкой строки. Далее f-строка записывается как единое целое, с учётом правил её форматирования, и закрывается соответствующей кавычкой:
name = "Пользователь"
print(f"Добрый день, {name}.")
f-строки также можно использовать для выравнивания строк. Например, если требуется добавить символы "0" слева (для выравнивания по правому краю), справа (для выравнивания по левому краю) или слева и справа (для выравнивания посередине) от исходной строки до достижения длины в 9 символов:
print(f"{123:0>9}")
print(f"{123:0<9}")
print(f"{123:0^9}")
В консоли будут напечатаны следующие строки:
000000123 123000000 000123000
Внутри f-строк можно обращаться к переменным, используя фигурные скобки, как в примере выше, а также производить операции, выполнять функции и подставлять их результаты в данную строку. И это только малая часть возможностей f-строк. Более подробно про них можно почитать в данном источнике.
Использование f-строк является приоритетным способом форматирования. Наряду с f-строками существует функция format(), которая также предназначена для удобного форматирования (мы рассмотрим её чуть позже). Также форматирование строк может производиться с помощью символа %. Однако данный способ форматирования является устаревшим (здесь можно почитать про него подробнее).
В строках можно применять управляющие символы, начинающиеся с символа «бэкслеш» \. Например:
\n— переход на новую строку;\t— табуляция;\r— возврат каретки в начало строки;\b— возврат каретки на один символ.
Кроме того, с помощью бэкслеша можно экранировать символы, то есть делать их частью выводимой строки. Например, для вывода символа \ необходимо его экранировать самим собой:
print("\\")
Подробнее об экранировании можно почитать в этом источнике.
В функции print() кроме параметра sep существует параметр end, который определяет символ в конце строки. Значение по умолчанию для него — переход на новую строку, обозначаемый как \n. Если вывести строки с помощью нескольких использований функции print(), то вывод каждой из них будет осуществлён с новой строки:
print("Привет, Пользователь!")
print("Как дела?")
Привет, Пользователь! Как дела?
Над строками можно производить следующие операции:
- сложение (конкатенация строк);
- умножение строки на целое число.
Результатом сложения строк будет новая строка, представляющая собой записанные последовательно складываемые строки (строки как бы склеиваются друг с другом, образуя новую строку).
print("Сложно" + "подчинённый")
Сложноподчинённый
При умножении строки на целое число n получается новая строка, состоящая из n дублирований исходной строки. Например, выведем 10 символов - подряд:
print("-" * 10)
В одном из следующих параграфов мы познакомимся с другими возможностями Python по работе со строками. А сейчас перейдём к работе с числами. Для создания целочисленной переменной в программе достаточно назначить ей имя и присвоить целочисленное значение. Например:
n = 10
По аналогии создаются вещественные числовые переменные, только в качестве разделителя целой и дробной частей используется десятичный разделитель «точка»:
pi = 3.14
Для преобразования строк в числа и наоборот используются следующие функции:
int()— преобразует строку (или вещественное число) в целое число. Дополнительно можно указать, в какой системе счисления было записано исходное число. По умолчанию используется десятичная система. При конвертации вещественного числа в целое отбрасывается дробная часть;float()— преобразует строку (или целое число) в вещественное число;str()— преобразует значения (в общем случае не только числовые) в строки.
Рассмотрим несколько примеров применения этих функций.
n_1 = "1"
n_2 = "2"
print(n_1 + n_2)
n_1 = int(n_1)
n_2 = int(n_2)
print(n_1 + n_2)
В результате выполнения программы получим:
12 3
Первый результат — результат сложения (конкатенации) двух строк. Второй — результат сложения целых чисел, которые были преобразованы из строк функцией int().
x = 3.89
x = int(x)
print(x)
Здесь программа выведет в консоли результат 3. Дробная часть после десятичного разделителя была отброшена при преобразовании в целое число.
width = "3.7"
height = "2.5"
s = float(width) * float(height)
print(s)
Программа выведет: 9.25.
А чтобы вводить целые или вещественные числа с клавиатуры, можно использовать уже знакомую нам функцию input() в сочетании с функциями int() и float():
int_number = int(input())
float_number = float(input())
Для работы с числовыми переменными доступны следующие математические операции:
- сложение —
x + y; - вычитание —
x - y; - умножение —
x * y; - деление —
x / y; - возведение в степень
x ** y.
Используем все эти операции в следующей программе:
n = 25
x = 0.5
print(n + x)
print(n - x)
print(n * x)
print(n / x)
print(n ** x)
Вывод программы будет таким:
25.5 24.5 12.5 50.0 5.0
Необходимо учитывать, что если выполняется операция деления или хотя бы один из операндов является вещественным числом, то результат также будет вещественным.
Например, выполнение следующего кода выведет на экран 2.0:
print(4 / 2)
Для округления вещественных чисел при выводе можно использовать уже известные нам f-строки. Например, выведем квадратный корень из 2 с точностью 2 знака после запятой:
print(f"{2 ** 0.5:.2f}")
Для целых чисел дополнительно доступны операции:
- целочисленное деление —
x // y; - остаток от деления —
x % y.
Эти операции можно использовать, например, для получения определённых цифр числа. Получим последнюю цифру числа 1234 (то есть остаток от деления на 10):
last_digit = 1234 % 10
Для получения предпоследней цифры нужно «отрезать» последнюю цифру целочисленным делением на 10, а затем у нового числа найти последнюю цифру — уже известным нам способом:
penultimate_digit = 1234 // 10 % 10
Перечислим указанные выше арифметические операции в порядке приоритета:
**;*,/,%,//;+,-.
В Python можно переводить числа между системами счисления. Если требуется перевести число из системы счисления с основанием от 2 до 36 в десятичную систему счисления, то для этого следует использовать функцию int() с двумя параметрами:
- строка, представляющая запись числа в соответствующей системе счисления;
- основание системы счисления.
Переведём число 1001 из двоичной системы счисления в десятичную:
binary_value = "1001"
print(int(binary_value, 2))
Если требуется перевести число из десятичной системы счисления в двоичную, восьмеричную или шестнадцатеричную, то следует использовать соответственно функции: bin(), oct() и hex(). Эти функции принимают число в десятичной системе счисления, а возвращают строку, представляющую запись числа в соответствующей системе счисления.
Чтобы закрепить новые знания, рекомендуем вам прорешать задачи для этого параграфа. Но прежде чем приступить к ним, советуем сперва взглянуть на небольшой гайд о том, как пользоваться системой проверки заданий.
Встретимся в следующей главе — она будет посвящена тому, как создавать программы, способные учитывать несколько вариантов развития событий.