2.1 Введение.

Знакомство с Python
Среда разработки VS Code

Команды для интерпретатора можно писать в обычном текстовом редакторе

(например, в "Блокноте"). Но чаще для этого пользуются специальной
программой, которая называется средой разработки (англ. IDE, Integrated
Development Environment).

Среда разработки — тоже текстовый редактор, но с дополнительными

возможностями. Например, она умеет сама находить на компьютере
программу-интерпретатор и запускать программу одной кнопкой. Среда
разработки, кроме того, форматирует написанный вами код, чтобы его
удобно было читать, а иногда даже подсказывает, где вы допустили ошибку.

На текущий момент очень популярной и удобной IDE является VS Code.

Рекомендуем использовать её для решения задач в курсе и вообще в жизни.

В VS Code есть много расширений, которые позволяют настроить среду

разработки под свои нужды. Есть расширения для работы с разными
языками, сборки проектов, автоматического форматирования кода и многого
другого. Это надёжная IDE, которую легко использовать.

Шаг 1. Скачиваем установщик VS Code

1. Открываем окно браузера и переходим по ссылке

2. Кликаем по синей кнопке Download for Windows (или кликаем по

кнопке справа для выбора дополнительных параметров)

Шаг 2. Устанавливаем VS Code

1. Запускаем установщик программы
2. Следуем указаниям установщика, нажимая кнопку Далее (Next) и
потом – Установить (Install)
3. Через несколько секунд на нашем компьютере будет установлена IDE
VS Code

Шаг 3. Запускаем VS Code

При открытии VS Code мы увидим экран приветствия:
Закроем это окно в верхнем левом углу:

Теперь нам нужно выбрать папку для наших проектов (File -> Open
Folder...):
Для этого создаем папку MyPythonProjects в директории Локальный диск
(C:):

Далее кликаем по этой папке левой кнопкой мыши и жмем кнопку Выбор
папки в правом нижнем углу:

Далее у нас откроется папка для наших проектов, и выскочит такое окно:
Нажимаем на квадратик напротив первой стрелки и синюю кнопку напротив
второй стрелки.

У нас должно остаться следующее окно:

Шаг 4. Создаем первый проект на Python

Наведем мышь на указанную область:

Далее кликаем на указанную иконку New File:

Печатаем сюда название нашей первой программы first_program.py и
нажимаем клавишу Enter:

Далее в правом нижнем углу у нас выскочит окно рекомендации установить

расширение для Python:

Кликаем по кнопке Install:

У нас автоматически начнётся установка расширения для Python:

Если же у вас не появилось окно с рекомендацией установить расширения

для Python, то это можно сделать вручную во вкладке Extensions, введя в
поиск python:

После успешной установки кликаем на указанную вкладку Explorer:

Далее выбираем файл нашей программы:

Лишние вкладки можно закрыть:

Далее нам надо проверить, что все работает. Напишем простой код для
проверки: print("Hello world") .
Чтобы запустить программу, нажимаем на треугольник в правом верхнем
углу. Также запуск программы возможно осуществить через Ctrl + F5.

Если мы сделали все правильно, у нас появится окно терминала внизу экрана
с выведенным текстом "Hello world":
Шаг 5. Некоторые рекомендации по работе с VS Code
Некоторые ошибки в программе будут прописаны в разделе PROBLEMS (в
следующем случае мы специально удалили закрывающую скобку, что
является синтаксической ошибкой в Python).

Такое возможно благодаря плагину Pylance, который был автоматически

установлен вместе с расширением Python.
В разделе Settings (настройки) можно включить автосохранение программы.
Программа будет автоматически сохраняться спустя некоторое время. Для
этого с помощью сочетания клавиш Ctrl + , переходим в Settings (также в
настройки можно перейти через File -> Preferences -> Settings).
Печатаем auto save и находим нужную настройку.

В открывшемся окне выбираем пункт afterDelay.

Автоформатирование программы можно включить также в разделе Settings.

Это очень удобная и полезная функция. Ваш файл будет автоматически
форматироваться по стандартам PEP8 (официальный стандарт написания
кода на языке Python). Для этого печатаем в настройках format on save и
находим нужную настройку:

Ставим галочку:

Вернемся к файлу с нашей программой. При нажатии сочетания

клавиш Ctrl + S у нас выскочит окошко, что IDE хочет отформатировать
файл. Нажимаем на клавишу Black:

Через несколько секунд у нас автоматически установится форматер Black.

Если же у вас такое окно не появилось, придется установить форматер
вручную. Это можно сделать через вкладку Extensions, введя в строку
поиска black formatter:

Или это можно сделать через командную строку. Чтобы попасть в командную
строку, нужно использовать клавиш Win + R, в появившемся окне
"Выполнить" ввести команду cmd и нажать Enter. После этого скачаем
форматер следующей командой: pip install black .

Теперь наша программа будет форматироваться каждый раз после нажатия

сочетания Ctrl + S (возможно, придётся перезапустить программу VS Code
для работы автоформатера). Учитывайте, что программа будет
форматироваться только при отсутствии синтаксических ошибок.
Рекомендуем использовать следующий код для проверки (не вдавайтесь в
подробности языка, пример только для демонстрации):

def get_sum(a,b)->int :

return a+b

print( get_sum(5,7))

При автоформатировании этот небрежный код:

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

Установка форматера не является обязательной, больше носит

рекомендательный характер. Кодить вы можете и без этого, тем более на
первых шагах.

Изменить тему оформления в VS Code также возможно (если хотите, чтобы

всё было красиво и приятно для глаз). Ищем в настройках color theme. И в
этой настройке выбираем ту тему, которая вам понравится больше. Темы

менять также можно через шестеренку в левом нижнем углу -

> Themes -> Color Theme. И дальше клавишами вверх-вниз листать (тема
будет меняться на ходу, так что можно будет посмотреть все сразу).

Изменить размер иконок в самой VS Code можно с

помощью Ctrl + (увеличение) и Ctrl - (уменьшение).

В VS Code есть ещё очень много интересного. Можете поискать сами какие-
нибудь классные расширения или удобные настройки.

P.S. VS Code иногда не видит папки и файлы с именами, содержащими

заглавные русские буквы. В том числе если у вас имя пользователя написано
кириллицей, у вас могут возникнуть проблемы при работе VS Code.
 Среда разработки Wing IDE
Еще одной достаточно простой IDE является Wing. У нее есть официальная
бесплатная версия для образовательных целей, которая называется Wing
IDE 101. Она доступна для всех операционных систем: Windows, Linux, OS X.
Если же у вас получилось успешно установить VS Code, то не нужно
устанавливать Wing IDE.

Установка Wing IDE на Windows

Шаг 1. Скачайте установщик Wing 101
1. Откройте окно браузера и перейдите по ссылке;
2. Кликните по зелёной кнопке Windows Installer;
3. Если загрузка не началась, кликните по ссылке для скачивания.
Шаг 2. Запустите установщик
1. Следуйте указаниям установщика, нажимая кнопку Next;
2. Через несколько минут на вашем компьютере будет установлена IDE
wing 101.

Шаг 3. Запустите Wing IDE

1. Убедитесь, что Wing IDE использует последнюю версию Python;
2. Если Wing IDE использует другую версию Python, то установите её
самостоятельно: выберите меню Edit → Configure Python;
3. Выберите в пункте Python Executable точку Custom и в выпадающем
списке выберите последнюю версию Python;
4. Нажмите на кнопку OK. Теперь Wing IDE использует последнюю
установленную версию Python.
На момент создания курса последней версией является Python 3.8.1.

Глоссарий
✅ Компьютерная программа — список команд (инструкций) для
компьютера.
✅ Язык программирования — набор определенных правил, по которым
компьютер может понимать команды (инструкции) и выполнять их.
✅ Программный код — текст программы.
✅ Язык Python разработал голландский программист Гвидо Ван
Россум (Guido van Rossum) в 1991 году.
✅ Преимущества Python:
1. Это интерпретируемый язык программирования.
2. Это высокоуровневый язык программирования.
3. Это платформонезависимый язык.
 4. Это open source проект.
5. Это простой язык.
6. Это встраиваемый скриптовый язык.
7. Это динамический язык, что упрощает написание несложных программ.
8. Для Python существует огромная библиотека классов на любой вкус.
✅ Недостатки Python:
1. Низкая скорость выполнения по сравнению с такими языками, как C и
C++.
2. Динамическая типизация языка — минус при написании сложных
программ.
✅ Задачи, решаемые с помощью Python:
1. Системное программирование.
2. Графические приложения.
3. Веб-приложения.
4. Веб-сценарии.
5. Интеграция компонентов.
6. Приложения баз данных.
✅ Текст «The Zen of Python» выдаётся интерпретатором Python по
команде import this.

2.2 Команды print() и input(), переменные

Тема урока: ввод-вывод данных, переменные
1. Вывод данных, команда print()
2. Ввод данных, команда input()
3. Переменные
4. Частые ошибки

Аннотация. Ввод и вывод данных в языке Python. Несложные программы,

которые умеют что-то выводить на экран (команда print() ) и считывать
информацию с клавиатуры (команда input() ).

Вывод данных, команда print

Для вывода данных на экран используется команда print() .

Внутри круглых скобок пишем, что хотим вывести на экран. Если это текст,
то обязательно указываем его внутри кавычек. Кавычки могут быть
одинарными ( ' ) или двойными ( " ). До и после текста мы ставим только
одинаковые кавычки.

Приведённый ниже код:

print('Мы изучаем язык Python')

выводит:

Мы изучаем язык Python

Если вы используете IDE VS Code, то вывод появится в окне TERMINAL:

Запомни: кавычки могут быть или одинарными, или двойными.

Следующие две строки делают одно и то же:

print('Python')

print("Python")

Аргументы команды print()

То, что мы пишем в круглых скобках у команды print() ,
называется аргументами команды.

Аргументы – это конкретные значения, которые вы передаете функции при

ее вызове.

Команда print() позволяет указывать несколько аргументов, в таком

случае их надо отделять запятыми.

Приведённый ниже код:

print('Я', 'учусь', 'программировать', 'на', 'Python!')

выводит:

Я учусь программировать на Python!

Обратите внимание, в качестве разделителя при выводе данных между

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

Приведённый ниже код:

print('1', '2', '4', '8', '16')

выводит:

1 2 4 8 16

Запомни: при написании кода между аргументами команды print() после

запятой мы ставим один символ пробел. Это общепринятое соглашение в
языке Python. Этот символ пробела не влияет на вывод данных. Это
просто для читабельности кода.

Примечания
Примечание 1. Команда print() записывается только маленькими буквами,
другое написание недопустимо, так как в Python строчные и заглавные
буквы различны.

Примечание 2. Каждая последующая команда print() выводит указанный

текст с новой строки.

Приведённый ниже код:

print('Какой хороший день!')

print('Работать мне не лень!')

выводит:

Какой хороший день!

Работать мне не лень!

Примечание 3. Команда print() с пустым списком аргументов просто

вставляет новую пустую строку.

Приведённый ниже код:

print('Какой хороший день!')

print()

print('Работать мне не лень!')

выводит:
Какой хороший день!

Работать мне не лень!

Обратите внимание на то, что вторая строка пустая.

Примечание 4. Почему в Python можно использовать как одинарные, так и
двойные кавычки для обрамления текста? Ответ очень прост — часто
кавычки являются частью текста. И чтобы Python мог правильно распознать
такой текст, пользуемся разными:

 если в тексте нужны одинарные кавычки, то для обрамления такого

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

Приведённый ниже код:

print('В тексте есть "двойные" кавычки')

print("В тексте есть 'одинарные' кавычки")

выводит:

В тексте есть "двойные" кавычки

В тексте есть 'одинарные' кавычки

Примечание 5. Обратите внимание, что в одном print() мы можем

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

Приведённый ниже код:

print("I'm", 'the', "BAD", 'guy')

выводит:

I'm the BAD guy

Python не делает различий между одинарными и двойными кавычками: они

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

print('12 ' 34')

приводит к возникновению ошибки:

SyntaxError: unterminated string literal (detected at line 1)

Частые ошибки
В этом степе мы обсуждаем ошибки, которые учащиеся нашего курса чаще
всего совершают при освоении данной темы.

1. Отсутствие кавычек '' для строк в команде print() .

❌ Неправильно:

print(Я также люблю математику !)

print(Я, также, люблю, математику, !)

✅ Правильно:

print('Я также люблю математику !')

print('Я', 'также', 'люблю', 'математику', '!')

В Python строки всегда должны быть заключены в кавычки, иначе

возникнет ошибка.

2. Знак = после команды print() :

❌ Неправильно:

print = ('Оппенгеймер vs Барби')

✅ Правильно:

print('Оппенгеймер vs Барби')

Ввод данных, команда input(), переменные

Все предыдущие программы выводили на экран текст, известный в момент
написания программного кода. Однако программы могут работать с
данными, которые станут известны только во время выполнения программы.
Другими словами, программы могут считывать данные, а затем их
использовать.

Для считывания данных в языке Python используется команда input() .

Рассмотрим следующую программу:

print('Как тебя зовут?') # вывод текста

print('Привет,', input()) # ввод текста и вывод текста

Сначала программа распечатает текст на экран 'Как тебя зовут?' .

Далее программа будет ждать от пользователя ввода данных. Ввод данных
реализуется с помощью команды input() . И в конце произойдет вывод
текста вместе с введенными от пользователя данными.

Команда input() всегда пишется с круглыми скобками. Она работает так:

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

Если вы используете IDE VS Code, то у вас ввод будет требоваться в

окне TERMINAL. Сюда и нужно вводить текст:

В VS Code после введения текста нужно нажать клавишу Enter:

После нажатия клавиши Enter у нас был выведен текст 'Привет, Сэм' , и
программа завершила свою работу.

Если вы ввели строку Сэм , программа дальше работала так же, словно
на месте input() было написано 'Сэм' .

Таким образом, команда input() получает от пользователя (нас) какие-то

данные и в место вызова подставляет строковое значение.

Запоминаем:

Команда print() выводит данные на экран.

Команда input() считывает данные, введенные с клавиатуры.

Переменные
Команда input() обозначает: "подожди, пока пользователь введет что-
нибудь с клавиатуры, и запомни то, что он ввел". Просто так просить
"запомнить" довольно бессмысленно: нам ведь потом надо будет как-то
сказать компьютеру, чтобы он вспомнил то, что запомнил! Для этого мы
используем переменные и пишем следующий код:

variable_name = input()

print('Вы ввели текст:', variable_name)

Данный код означает: "Сохрани то, что ввел пользователь, в памяти, и

дальше это место в памяти мы будем называть именем variable_name ".
Соответственно, команда print(variable_name) означает: "Посмотри, что
лежит в памяти под именем variable_name , и выведи это на экран".

Вот такие "места в памяти" и называются переменными. Любая переменная

имеет имя и значение.

Переменные в команде print()

Как вы заметили, мы можем использовать переменные в команде print() .
Для этого мы просто указываем имя переменной без кавычек внутри круглых
скобок как аргумент.

Приведенный ниже код:

city = 'Минск'

print(city, '- мой город!')

выводит:

Минск - мой город!

Мы можем использовать несколько переменных в команде print() , нам это

никто не запрещает. Только стоит помнить, что аргументы в
команде print() нужно отделять запятыми друг от друга.

Приведенный ниже код:

name = 'Ян'

city = 'Минск'

print('Меня зовут', name, '.', city, '- мой город!')

выводит:

Меня зовут Ян . Минск - мой город!

Имя переменной
1. В имени переменной рекомендуется использовать только латинские
буквы a-z , A-Z , цифры и символ нижнего подчеркивания ( _ )
2. Имя переменной не может начинаться с цифры
3. Имя переменной не может содержать пробелы
4. Имя переменной по возможности должно отражать ее назначение

Запомни: Python – регистрочувствительный язык.

Переменные name и Name – две совершенно разные переменные.

Для именования переменных принято использовать

стиль lower_case_with_underscores (слова из маленьких букв
с подчеркиваниями). Например, следующие имена для переменных хорошие:

server_response

is_password_good

username

cyberpunk_77
 Значение переменной
Значение переменной — это сохранённая в ней информация: текст, число и
т.д.

Символ = в языках программирования выступает в роли оператора

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

Запомни: интерпретатор ждет, что пользователь что-то введет

с клавиатуры ровно столько раз, сколько команд input() встречается
в программе. Каждый input() завершается нажатием Enter на клавиатуре.

Значения переменной, естественно, можно менять (переприсваивать).

print('Как тебя зовут?')

name = input()

print('Привет,', name)

name = 'Timur'

print('Привет,', name)

Оператор присваивания сообщает переменной то или иное значение

независимо от того, была ли эта переменная введена раньше. Вы можете
менять значение переменной, записав еще один оператор присваивания.
Если у нас имеется переменная, мы можем делать с ней все что угодно —
например, присвоить другой переменной или изменить значение.

Приведённый ниже код:

name1 = 'Тимур'

name2 = name1

name1 = 'Гвидо'

print(name1)

print(name2)
выводит:

Гвидо

Тимур

Запомни: название переменной всегда должно быть слева от знака

равенства.

Приведённый ниже код:

'Timur' = name

приводит к возникновению ошибки:

SyntaxError: cannot assign to literal here. Maybe you meant '==' instead of
'='?

Примечания
Примечание 1. Очень часто перед считыванием данных мы печатаем
некоторый текст, чтобы пользователь, который вводит эти данные, понимал,
что именно от него требуется. Например, в программе:

print('Как тебя зовут?')

name = input()

Мы сначала выведем текст "Как тебя зовут?", а уже потом считаем данные.

Поскольку это достаточно распространенный сценарий, то в языке

Python можно выводить текст, передавая его в качестве аргумента в
команду input() . Предыдущий код можно переписать так:

# сначала тут печатается строка 'Как тебя зовут', а потом принимается на

вход имя

name = input('Как тебя зовут?')

То есть команда input() при наличии аргументов внутри нее отрабатывает

одновременно как вывод текста, а потом ввод текста (именно в этом
порядке). Однако в задачах нашего курса нужно использовать
команду input() без аргументов! Так как это будет лишний вывод, ваша
программа не будет проходить тесты.

Примечание 2. Имейте в виду, что мы можем принимать сразу несколько

строк, а потом со всеми ними работать.

first = input()

second = input()
print('I am', first, 'and', second)

Например, если на вход программе будут поданы строки:

cool

I know it

то она выведет следующее:

I am cool and I know it

Примечание 3. Переменные можно вводить в любой момент (не только

в самом начале программы):

name_1 = input() # принимаем имя первого человека

print('Привет,', name_1, '!') # делаем первый вывод

name_2 = input() # принимаем имя второго человека

print('Здравствуйте,', name_2, '.') # делаем второй вывод

Например, если на вход программе будут поданы строки:

Билл

Тед

то она выведет следующее:

Привет, Билл !

Здравствуйте, Тед .

Примечание 4. Обратите внимание на то, что при попытке считать больше

данных, чем поступает на вход, возникает ошибка EOFError ("End-of-File
Error") – "ошибка конца файла".

Если программе на вход будет подана строка:

Jensen Huang

а вы пытаетесь принять две строки:

name = input()

surname = input()

то возникает ошибка:

EOFError: EOF when reading a line

2.3 Параметры sep и end, PEP8
Тема урока: sep, end, PEP 8
1. Необязательные параметры команды print() : sep , end
2. Множественное присваивание
3. Стандарт PEP 8
4. Комментарии

Аннотация. Урок посвящен изучению необязательных параметров

команды print() и дополнительным возможностям переменных. Также мы
поговорим о комментариях и стандарте PEP 8, которого придерживаются
Python-программисты.

Необязательные параметры команды print

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

Параметр sep
Давайте рассмотрим следующий код:

print('aa', 'bb', 'cc')

Результатом выполнения такого кода будет:

aa bb cc

Как вы можете заметить, все строки выводятся с пробелом между друг

другом – это неслучайное поведение. У команды print() есть параметр,
который отвечает за разделение аргументов при выводе. Этот параметр
называется sep (separator – разделитель). По умолчанию этот параметр
равен символу пробела . Следующие строки кода являются
эквивалентными:

print('aa', 'bb', 'cc')

print('aa', 'bb', 'cc', sep=' ')

Мы можем изменить параметр sep на любую другую строку, например, на

символ звёздочки * .

Приведённый ниже код:

print('aa', 'bb', 'cc', sep='*')

выводит:
aa*bb*cc

Сейчас у нас аргументы разделены символом звёздочки * . Также в качестве

параметра sep мы можем указать и переменную.

Приведённый ниже код:

minus = '-'

print('aa', 'bb', 'cc', sep=minus)

выводит:

aa-bb-cc

Таким образом, необязательный

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

Параметр end
Теперь давайте рассмотрим ситуацию, когда у нас не один print() , а
несколько.

Приведённый ниже код:

print("A great man doesn't seek to lead.")

print("He's called to it. And he answers.")

выводит:

A great man doesn't seek to lead.

He's called to it. And he answers.

Как вы можете заметить, после каждого print() курсор переходит на новую

строку. И это поведение тоже не является случайным, потому что у
команды print() есть параметр end , определяющий, что нужно добавить в
конец вывода. По умолчанию параметр end равен символу перевода строки
( \n ).

Следующие строки кода являются эквивалентными:

print("A great man doesn't seek to lead.")

print("He's called to it. And he answers.")

print("A great man doesn't seek to lead.", end='\n')

print("He's called to it. And he answers.", end='\n')

Если перевод строки делать не нужно или требуется указать специальное
окончание для вывода, то следует явно указать значение для
параметра end (можем указать через переменную, как и с параметром sep ).

Приведенный ниже код:

minus = '-'

print('a', 'b', 'c', end=minus)

print('second line')

выводит:

a b c-second line

По завершении печати первой команды print() вставлен символ - вместо

символа перевода строки \n .

Таким образом, параметр end определяет строку, которая будет

добавлена после вывода всех аргументов команды print() .

Примечания
Примечание 1. Вызов команды print() с пустыми скобками делает перевод
строки.

Приведённый ниже код:

print('Python')

print()

print('C#')

print('Java')

print()

print('JavaScript')

выводит:

Python

C#

Java
JavaScript

Примечание 2. Последовательность символов \

n называется управляющей последовательностью и задаёт перевод
строки.

Приведённый ниже код:

print('a', '\n', 'b', '\n', 'c', sep='*', end='#')

выводит:

a*

*b*

*c#

Примечание 3. Параметры sep и end можно устанавливать одновременно.

Приведённый ниже код:

print('a', 'b', 'c', sep='*', end='finish')

выводит:

a*b*cfinish

Примечание 4. Для разных команд print() можно задавать разные

параметры sep и end .

Приведённый ниже код:

arg1 = 'Hello'

sep1 = '_-_'

end2 = '+++'

print(arg1, 'everyone', sep=sep1, end='! ')

print('How', 'are', 'you', 'in', '2024?', sep=' ', end=end2)

выводит:

Hello_-_everyone! How are you in 2024?+++

Примечание 5. Чтобы убрать все дополнительные выводимые символы,

можно установить параметры sep и end команды print() как пустые строки
( '' ).

Приведённый ниже код:

print('a', 'b', 'c', sep='', end='')

print('d', 'e', 'f', sep='', end='')

выводит:

abcdef

Примечание 6. Если после вывода данных нужно более одного перевода

строки, то можно использовать следующий код:

print('Python', end='\n\n\n')

Примечание 7. Мы не можем указывать параметры sep и end перед

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

Приведённый ниже код:

print('5', '+', sep='_', '5', end='!!!', '=', '10')

приводит к возникновению ошибки:

SyntaxError: positional argument follows keyword argument

Примечание 8. Параметр sep является разделителем для нескольких

аргументов в команде print() .

Если аргумент в команде print() только один, то параметру sep нечего

разделять. В таком случае параметр sep никак не будет влиять на
выводимый текст.

Приведённый ниже код:

print('Python', sep='777')

выводит:

Python

Множественное присваивание
В языке Python за одну инструкцию присваивания можно задавать значения
сразу нескольким переменным. Делается это так:

name, surname = 'Timur', 'Guev'

print('Имя:', name, 'Фамилия:', surname)

Этот код можно записать и так:

name = 'Timur'

surname = 'Guev'

print('Имя:', name, 'Фамилия:', surname)

Отличие двух способов состоит в том, что множественное присваивание в

первом способе присваивает значения двум переменным одновременно.

Если требуется считать текст с клавиатуры и присвоить его в качестве

значения переменным, то можно написать так:

name, surname = input(), input()

print('Имя:', name, 'Фамилия:', surname)

Если слева от знака = во множественном присваивании должны стоять через

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

Множественное присваивание удобно использовать, когда нужно обменять

значения двух переменных. В Python это делается так:

name1 = 'Timur'

name2 = 'Gvido'

name1, name2 = name2, name1

Обратите внимание, что для обмена значений переменных следующий

вариант не сработает:

name1 = 'Timur'

name2 = 'Gvido'

name1 = name2

name2 = name1

Дело в том, что инструкция name1 = name2 полностью стирает старое

значение переменной name1 . Когда мы в инструкции name2 =
name1 присваиваем для переменной name2 значение переменной name1 , этим
значением уже не является строка 'Timur' , этим значением уже является
строка 'Gvido' .

Примечания
Примечание 1. Названия переменных ничего не говорят интерпретатору о
значениях в этих переменных, и даже в очень хорошо названной переменной
не появится нужное значение, если мы сами его туда не запишем.

Примечание 2. Новое значение переменной вытесняет старое. Важно

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

Приведённый ниже код:

name = 'Timur'

name = 'Arthur'

print(name)

name = 'Anton'

print(name)

выводит:

Arthur

Anton

Примечание 3. В качестве названия переменных запрещено использовать

ключевые (зарезервированные) слова. К ключевым словам в языке Python
относятся:

1. False;
2. True;
3. None;
4. and;
5. with;
6. as;
7. assert;
8. break;
9. class;
10. continue;
11. def;
12. del;
13. elif;
14. else;
15. except;
16. finally;
17. try;
18. for;
19. from;
20. global;
21. if;
22. import;
23. in;
24. is;
25. lambda;
 26. nonlocal;
27. not;
28. or;
29. pass;
30. raise;
31. return;
32. while;
33. yield.

PEP 8
При оформлении программ мы будем пользоваться PEP 8 — Python
Enhancement Proposal. Этот документ предлагает единый и общепринятый
стиль написания программ на языке Python. Документ создан по
рекомендациям Гвидо Ван Россума, автора Python. Прочесть его на русском
языке можно по ссылке.

Некоторые рекомендации PEP 8

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

Правильно:

print('Follow PEP8!')

Неправильно:

print ('Follow PEP8!')

Рекомендация 2. Используйте пробел после запятой , при перечислении

аргументов в команде print() .

Правильно:

print('PEP8', 'Rocks!')

Неправильно:

print('PEP8','Rocks!')

Рекомендация 3. Не отделяйте пробелами оператор присваивания = при

определении параметра по умолчанию.

Правильно:

print('My name', 'is', 'Python', sep='**', end='+')

Неправильно:

print('My name', 'is', 'Python', sep = '**', end = '+')

Рекомендация 4. Отделяйте пробелами оператор присваивания = при
определении переменных.

Правильно:

a = 10

b = 20

Неправильно:

a=10

b=20

PEP 8 в Wing IDE

Среда Wing IDE имеет встроенную поддержку форматирования кода по
стандарту PEP 8. Для включения такой возможности в Wing IDE зайдите
в меню Edit → Preferences. Перейдите к категории Editor → PEP 8.

После включения форматирования под стандарт PEP 8, среда Wing IDE

автоматически будет исправлять код, дополняя его пробелами и т.д.

Комментарии
До этого момента всё, что мы набирали в тексте наших программ,
представляло собой команды для компьютера. Но в программу имеет смысл
включать также примечания, описывающие, что она делает и как работает.
Это может помочь вам или кому-то другому понять принцип работы
программы спустя некоторое время.

Такие примечания называются комментариями.

Однострочные комментарии
Любую строку можно превратить в комментарий, поместив перед ней символ
#.

Рассмотрим следующий код:

# Это комментарий в программе на языке Python.

print('Python rocks!')

Если запустить эту программу, то получится:

Python rocks!

Первая строка при запуске игнорируется. Комментарий, начинающийся с

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

Комментарий в конце строки

Комментарий можно поместить после строки кода.

print('Python rocks!') # Это комментарий в программе на языке Python.

Комментарий начинается после символа #. Все, что находится до этого

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

Python rocks!

Примечания
Примечание 1. Согласно стандарту PEP 8, комментарии должны отделяться
хотя бы двумя пробелами от кода. Они должны начинаться с символа # и
одного пробела.

Правильно:

# Далее будет напечатан текст

print('Comments in Python') # Печать текста с помощью команды print.

Неправильно:

#Далее будет напечатан текст

print('Comments in Python')#Печать текста с помощью команды print.

Примечание 2. При вводе комментариев в среде Wing IDE вы обнаружите,

что они выделяются цветом. Это сделано, чтобы облегчить чтение кода.
2.4 Целочисленная арифметика. Часть 1
Тема урока: работа с целыми числами
1. Целочисленный тип данных
2. Преобразование строки к целому числу
3. Операции над целыми числами
4. Частые ошибки

Аннотация. Урок посвящен изучению работы с целыми числами. Изучим

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

Целые числа
Все предыдущие программы, которые мы писали, работали со строковыми
данными. Действительно, команда input() считывает строку текста. Однако
во многих случаях нам нужно работать именно с числами. Чтобы в Python
создать переменную целого типа данных, нужно опустить кавычки при
объявлении переменной. Рассмотрим следующий код:

num1 = 7 # num1 - это число

num2 = 10 # num2 - это число

num3 = num1 + num2 # num3 - это число

print(num3)

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

Запомни: числа обозначаются без кавычек, а строки — с кавычками.

Основные операции с числами

В языке Python, как и в математике, над числами можно совершать 4
основные операции ( + , - , * , / ).

Оператор Описание

+ сложение

вычитани
-
е
 Оператор Описание

умножен
*
ие

/ деление

Приведённый ниже код:

a = 3

b = 2

print(a + b)

print(a - b)

print(a * b)

print(a / b)

выводит:

1.5

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

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

Приведённый ниже код:

num1 = 2 + 3 * 4

num2 = (2 + 3) * 4

print(num1)

print(num2)

выводит:
14

20

В переменной num1 будет храниться число 14 , поскольку первым делом

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

Запомни: первым делом выполняется умножение или деление, затем

сложение и вычитание. Для изменения порядка выполнения операций
понадобятся скобки.

Преобразование типов
Преобразование строки к целому числу
Для того чтобы преобразовать строку к целому числу, мы используем
команду int() .

Приведенный ниже код:

s = '1992'

year = int(s)

print(year)

выводит:

1992

Переменная s имеет строковый тип данных. С помощью команды int() мы

преобразовали строку к целому числу и записали результат в переменную с
именем year . Мы используем новую команду (точнее, функцию) – int() . Она
означает следующее: "Возьми то, что указано в качестве аргумента в
скобках, и преврати это в целое число". Таким образом,
переменная year имеет целочисленный тип данных, а
переменная s – строковый тип данных.

Теперь попробуем написать программу, которая считывает два целых числа

и выводит на экран их сумму:

num1 = input()

num2 = input()

print(num1 + num2)
Приведенный выше код не дает нам желаемого результата, потому что
Python считает, что в переменных num1 и num2 находится текст (строковый
тип данных). Так происходит, поскольку команда input() по умолчанию
считывает именно текст. Для того чтобы явно указать, что требуется
работать с переменными целого типа, надо написать так:

num1 = int(input())

num2 = int(input())

print(num1 + num2)

Запомни: для того чтобы считать одно целое число, мы пишем

следующий код:

num = int(input())

Преобразование целого числа к строке

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

num = 17

s = str(num) # теперь в переменной s содержится строка '17'

Переменная num имеет целочисленный тип данных. С помощью

команды str() мы преобразовали целое число в строку и записали результат
в переменную s . Таким образом, переменная num имеет целочисленный тип
данных, а переменная s – строковый тип данных.

Примечания
Примечание 1. При работе с целочисленными переменными часто нужно
осуществлять присвоение значению переменной целой математической
формулы:

<имя переменной> = <математическая формула>

Примечание 2. Сокращение int происходит от английского integer – целый.

Примечание 3. В большинстве языков программирования
переменная целого типа имеет ограничения. Например, в языке
C# переменная целого типа может принимать значения из
диапазона [−263;263−1][−263;263−1]. В Python реализована так
называемая длинная арифметика, то есть, по сути, переменная целого
типа не имеет ограничений.

Примечание 4. Минус может использоваться для обозначения

отрицательных чисел. А вот операции + , / и * всегда стоят между двумя
переменными и что-то с ними делают.

num1 = -6 # унарный минус

num2 = 17 - 7 # бинарный минус

Примечание 5. Обратите внимание: результат операции деления / всегда

будет числом с плавающей точкой.

Приведённый ниже код:

print(4 / 2)

print(1 / 1)

выводит:

2.0

1.0

Подробнее числа с плавающей точкой мы изучим далее в курсе.

Глоссарий
✅ Чтобы создать переменную с целым числом, нужно указать число без
кавычек при её объявлении.

✅ Числа обозначаются без кавычек, строки — с кавычками.

✅ В языке Python, как и в математике, над числами можно совершать 4

основные операции:

Оператор Описание

+ сложение

- вычитание

* умножение

/ деление
✅ Порядок выполнения операций: первым делом выполняется умножение
или деление, затем сложение и вычитание. Для изменения порядка
выполнения операций понадобятся скобки.

✅ Для того чтобы преобразовать строку к целому числу, мы

используем команду int() .

✅ Для того чтобы считать одно целое число, мы пишем следующий код:

num = int(input())

✅ Для того чтобы преобразовать целое число в строку, мы

используем команду str() .

2.5 Целочисленная арифметика. Часть

2
Тема урока: работа с целыми числами
1. Операция возведения в степень ( ** )
2. Операция нахождения остатка ( % )
3. Операция целочисленного деления ( // )
4. Обработка цифр числа
5. Частые ошибки
6. Решение задач

Аннотация. Урок посвящён дополнительным операциям при работе с

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

Дополнительные операции
Мы познакомились с 4 основными математическими операциями в языке
Python: сложение ( + ), вычитание ( - ), умножение ( * ) и деление ( / ). Добавив
ещё 3 операции, мы получим инструментарий, достаточный для написания
99% программ.

Операт
Описание
ор

Возведение в
**
степень

% Остаток от деления

Целочисленное
//
деление

Возведение в степень
Для возведения числа в степень используется оператор ** .

Приведённый ниже код:

print(2 ** 0)

print(2 ** 1)

print(2 ** 2)

print(2 ** 3)

print(2 ** (-1))

выводит:

0.5

Обратите внимание: оператор возведения в степень ( ** ) может возводить

не только в положительную степень, но и в отрицательную. Аналогично,
основание степени aa также может быть числом отрицательным.

Приведённый ниже код:

print(2**(-2))

print((-3)**3)

выводит:

0.25

-27

Запомни: в отличие от многих языков программирования, в языке

Python для возведения в степень используется оператор ** , а не ^ .

Обратите внимание: оператор возведения в степень ( ** ) является

правоассоциативным (значение выражения вычисляется справа налево) в
соответствии с правилами математики. Таким образом, выражение x ** y **
z вычисляется как x ** (y ** z) .

Приведённый ниже код:

print(2 ** 2 ** 3) # 2 ** (2 ** 3) = 2 ** 8

выводит:

256
 Целочисленное деление
Для положительных чисел оператор целочисленного деления ( // ) ведёт
себя как обычное деление, за исключением того, что он отбрасывает
десятичную часть результата.

Приведённый ниже код:

print(10 // 3)
print(10 // 4)
print(10 // 5)
print(10 // 6)
print(10 // 12)
выводит:
3
2
2
1
0

При делении отрицательных чисел необходимо помнить, что

результат целочисленного деления не превосходит частное. Другими
словами, округление всегда берётся в меньшую сторону.

Приведённый ниже код:

print(10 // 3)

print(-10 // 3)

выводит:

3 # округление в меньшую сторону

-4 # округление в меньшую сторону

Деление с остатком
Оператор деления с остатком ( % ) возвращает остаток от деления двух
целых чисел. Рассмотрим работу данного оператора на примерах.

Приведённый ниже код:

print(10 % 3)

print(10 % 4)

print(10 % 5)
print(10 % 6)

print(10 % 12)

print(10 % 20)

выводит:

10

10

Запомни: при нахождении остатка от деления на целое

число nn может получаться результат 0,1,2,…n −10,1,2,…n −1.
Например, при делении на 22 возможны остатки 0,10,1, при делении
на 33 возможны остатки 0,1,20,1,2 и т.д.

Примечания
Примечание 1. Оператор нахождения остатка очень полезен при решении
многих задач. Например, число делится на nn нацело тогда и только тогда,
когда остаток от деления на nn равен 00.

Примечание 2. Таблица приоритетов арифметических операторов в Python

приведена ниже (чем ниже расположен оператор в таблице, тем ниже его
приоритет).

Оператор Описание

() Скобки

** Возведение в степень

- (унарный
Унарный минус
минус)

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

* , / , // , %
деления

+, - Сложение, вычитание
Как видно из таблицы, операторы умножения ( * ) и все операторы
деления ( / , // , % ) имеют равные приоритеты. А у оператора возведения в
степень ( ** ) приоритет выше, чем у любого другого арифметического
оператора, кроме скобок ( () ).

Примечание 3. Полезно прочитать про модулярную арифметику в

математике.

Примечание 4. Обратите внимание: при 0 < n < m результатом деления n

% m является число n , а результатом деления n // m является число 0 .

Приведённый ниже код:

print(5 % 9)

print(3 % 13)

print(5 // 9)

print(3 // 13)

выводит:

Частые ошибки
В этом степе мы обсуждаем ошибки, которые учащиеся нашего курса чаще
всего совершают при освоении данной темы.

1. Ошибочное использование знака / вместо знака // .

❌ Неправильно:

print(10 / 3) # печатает 3.3333333333333335

✅ Правильно:

print(10 // 3) # печатает 3

/ – это операция обычного (или “плавающего”) деления. В результате

обычного деления получается десятичная дробь, а не целое число.
Подробнее числа с плавающей точкой и оператор / мы изучим далее в
курсе.
2. Ошибочное понимание приоритета операций. Не забываем, что
оператор ** имеет самый высокий приоритет:

print(-10**2) # -100

print(5 * 3**2) # 45

3. Неверное представление, в какую сторону округляет операция

целочисленного деления:

print(5 // 2) # 2

print(-5 // 2) # -3

Операция целочисленного деления всегда округляет только в меньшую

сторону!

Обработка цифр числа

При помощи операторов целочисленного деления // и нахождения
остатка % от целочисленного деления можно вычислить любую цифру числа.

Рассмотрим программу получения цифр двузначного числа:

num = 17

a = num % 10 # вычисляем последнюю цифру числа

b = num // 10 # вычисляем первую цифру числа

print(a)

print(b)

Приведённый выше код выводит:

То есть сначала мы вывели последнюю, а затем первую цифру числа.

Запомни: последняя цифра числа определяется всегда как остаток от

деления числа на 10 : % 10 . Чтобы избавиться от последней цифры числа,
необходимо разделить число нацело на 10 : // 10 .
Рассмотрим программу получения цифр трёхзначного числа:

num = 754

a = num % 10 # вычисляем последнюю цифру числа

b = (num % 100) // 10 # вычисляем среднюю цифру числа

c = num // 100 # вычисляем первую цифру числа

print(a)

print(b)

print(c)

Приведённый выше код выводит:

То есть сначала мы вывели последнюю цифру числа, затем среднюю цифру, а

затем первую цифру.

Алгоритм получения цифр n-значного числа

Несложно понять, по какому алгоритму можно получить каждую цифру n -
значного числа num :

 Последняя цифра: num % 10

 Предпоследняя цифра: (num // 10) % 10
 Предпредпоследняя цифра: (num // 100) % 10
 ...
 Третья цифра: (num // 10 ** (n - 3)) % 10
 Вторая цифра: (num // 10 ** (n - 2)) % 10
 Первая цифра: num // 10 ** (n - 1)

Запишем формулу для вычисления i -й цифры n -значного числа num в

общем виде:

(num // 10 ** (n - i)) % 10

Также предложим другой алгоритм получения каждой цифры n -значного

числа num :
  Последняя цифра: num % 10
 Предпоследняя цифра: (num % 100) // 10
 Предпредпоследняя цифра: (num % 1000) // 100
 ...
 Третья цифра: (num % 10 ** (n - 2)) // (10 ** (n - 3))
 Вторая цифра: (num % 10 ** (n - 1)) // (10 ** (n - 2))
 Первая цифра: (num % 10 ** n) // (10 ** (n - 1))

Мы можем записать формулу для вычисления i -й цифры n -

значного числа num в общем виде:

num % 10 ** (n + 1 - i) // (10 ** (n - i))

Решение задач
Задача 1. Напишите программу, определяющую число десятков и единиц в
двузначном числе.

Решение. Число единиц – это последняя цифра числа, число десятков

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

num = int(input())

last_digit = num % 10

first_digit = num // 10

print('Число десятков =', first_digit)

print('Число единиц =', last_digit)

Задача 2. Напишите программу, в которой рассчитывается сумма цифр

двузначного числа.

Решение. Программа, решающая поставленную задачу, может иметь

следующий вид:

num = int(input())

last_digit = num % 10

first_digit = num // 10

print('Сумма цифр =', last_digit + first_digit)

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

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

num = int(input())

last_digit = num % 10

first_digit = num // 10

print('Искомое число =', last_digit * 10 + first_digit)

Задача 4. Напишите программу, в которую вводится трехзначное число и

которая выводит на экран его цифры (через запятую).

Решение. Программа, решающая поставленную задачу, может

иметь следующий вид:

num = int(input())

digit3 = num % 10

digit2 = (num // 10) % 10

digit1 = num // 100

print(digit1, digit2, digit3, sep=',')

Глоссарий
✅ Оператор ** используется для возведения числа в степень. Является
правоассоциативным (значение выражения вычисляется справа налево) в
соответствии с правилами математики.

Таким образом, выражение x ** y ** z вычисляется как x ** (y ** z) .

✅ Оператор целочисленного деления // делит одно число на другое и

отбрасывает дробную часть результата. При делении отрицательных чисел
необходимо помнить, что результат целочисленного деления не превосходит
частное. Другими словами, округление всегда берётся в меньшую сторону.

✅ Оператор деления с остатком % возвращает остаток от деления двух

целых чисел.

✅ Таблица приоритетов арифметических операторов в Python (чем ниже

расположен оператор в таблице, тем ниже его приоритет):

Оператор Описание

() Скобки

** Возведение в степень
Оператор Описание

- Унарный минус

* , / , // , % Умножение, деление, целочисленное деление, остаток от деления

+, - Сложение, вычитание

✅ Последняя цифра числа определяется всегда как остаток от

деления числа на 10 (% 10) . Чтобы отщепить последнюю цифру от числа,
необходимо разделить его нацело на 10 (// 10) .

✅ Алгоритм получения цифр nn-значного числа num :

 Последняя цифра: num % 10

 Предпоследняя цифра: (num // 10) % 10
 Предпредпоследняя цифра: (num // 100) % 10
 ...
 Третья цифра: (num // 10 ** (n - 3)) % 10
 Вторая цифра: (num // 10 ** (n - 2)) % 10
 Первая цифра: num // 10 ** (n - 1)

или

 Последняя цифра: num % 10

 Предпоследняя цифра: (num % 100) // 10
 Предпредпоследняя цифра: (num % 1000) // 100
 ...
 Третья цифра: (num % 10 ** (n - 2)) // (10 ** (n - 3))
 Вторая цифра: (num % 10 ** (n - 1)) // (10 ** (n - 2))
 Первая цифра: (num % 10 ** n) // (10 ** (n - 1))

4.1 Выбор из двух

Тема урока: условный оператор
1. Условный оператор
2. Отступы
3. Операторы сравнения
4. Цепочки сравнений
5. Решение задач
6. Частые ошибки

Аннотация. Урок посвящен условному оператору if-else .

Условный оператор if-else

Мы познакомились с базовыми строительными блоками программ, научились
писать программы, обеспечивающие ввод, обработку и вывод данных. Более
того, мы умеем работать со строками и числами, как мы делаем это в
математике. Теперь научимся управлять ходом выполнения программы.

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

введенных данных. Для принятия решения программа проверяет, истинно
или ложно определенное условие.

В Python существует несколько способов проверки, и в каждом случае

возможны два исхода: истина ( True ) или ложь ( False ).

Проверка условий и принятие решений по результатам этой проверки

называется ветвлением (branching). Программа таким способом выбирает,
по какой из возможных ветвей ей двигаться дальше.

В Python проверка условия осуществляется при помощи ключевого слова if .

Рассмотрим следующую программу:

answer = input('Какой язык программирования мы изучаем?')

if answer == 'Python':

print('Верно! Мы ботаем Python =)')

print('Python - отличный язык!')

Программа просит пользователя ввести текст и проверяет результат

ввода. Если введенный текст равен строке «Python», то выводит
пользователю текст:

Верно! Мы ботаем Python =)

Python - отличный язык!

Двоеточие ( : ) в конце строки с инструкцией if сообщает интерпретатору

Python, что дальше находится блок команд. В блок команд входят все
строки с отступом под строкой с инструкцией if , вплоть до следующей
строки без отступа.

Если условие истинно, выполняется весь расположенный ниже блок. В

предыдущем примере блок инструкций составляет третья и четвертая
строки программы.

Блоком кода называют объединенные друг с другом строки. Они

всегда связаны с определенной частью программы (например, с
инструкцией if ). В Python блоки кода формируются при помощи отступов.
Предыдущая программа выводит текст в случае, если условие истинно. Но
если условие ложно, то программа ничего не выводит. Для того чтобы
обеспечить возможность выполнять что-либо в случае, если условие
оказалось ложным, мы используем ключевое слово else .

answer = input('Какой язык программирования мы изучаем?')

if answer == 'Python':

print('Верно! Мы ботаем Python =)')

print('Python - отличный язык!')

else:

print('Не совсем так!')

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

(пользователь ввел «Python»), и если условие ложно (пользователь ввел что
угодно, кроме «Python»).

Отступы
В некоторых языках программирования отступы — дело личного вкуса, и
можно вообще обходиться без них. Однако в Python они – неотъемлемая
часть кода. Именно отступ сообщает интерпретатору Python, где начинается
и где заканчивается блок кода.
 Отступ — небольшое смещение строки кода вправо. В начале такой
строки находятся пробелы, и поэтому она на несколько символов отстоит от
левого края.

Некоторым инструкциям в Python (например, инструкции if ) именно блок

кода сообщает, какие действия следует предпринять. После if блок кода
информирует интерпретатор Python, как действовать, если условие истинно,
и как — если оно ложно.

По соглашению PEP 8, для отступа блоков кода используются 4

пробела. Если в среде VS Code или Wing IDE нажать на клавишу Enter
после if , она автоматически выставит 4 пробела.

Операторы сравнения
Можно заметить, что в проверке условия мы использовали двойное
равенство ( == ), вместо ожидаемого одиночного ( = ). Не стоит
путать оператор присваивания ( = ) с условным оператором ( == ).

Оператор присваивания ( = ) присваивает переменным значения:

num = 1992
s = 'I love Python'
Для проверки двух элементов на равенство Python использует удвоенный
знак равно ( == ). Вот так:
if answer == 'Python':
...

if name == 'Gvido':
...

if temperature == 40:
...

Путаница с операторами == и = является одной из самых

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

В Python существует 6 основных операторов сравнения.

 Выражение Описание

if x > 7 если x больше 77

if x < 7 если x меньше 77

если x больше либо

if x >= 7
равен 77

если x меньше либо

if x <= 7
равен 77

if x == 7 если x равен 77

if x != 7 если x не равен 77

Рассмотрим пример:
num1 = int(input())
num2 = int(input())

if num1 < num2:

print(num1, 'меньше чем', num2)
if num1 > num2:
print(num1, 'больше чем', num2)

if num1 == num2: # используем двойное равенство

print(num1, 'равно', num2)
if num1 != num2:
print(num1, 'не равно', num2)

Цепочки сравнений
Операторы сравнения в Python можно объединять в цепочки (в отличие от
большинства других языков программирования, где для этого нужно
использовать логические связки), например, a == b == c или 1 <= x <= 10 .
Следующий код проверяет, находится ли значение переменной age в
диапазоне от 33 до 66:
age = int(input())
if 3 <= age <= 6:
print('Вы ребёнок')
Код, проверяющий равенство трех переменных, может выглядеть так:
if a == b == c:
print('числа равны')
else:
print('числа не равны')

Транзитивность
Операция равенства является транзитивной. Это означает, что если a ==
b и b == c , то из этого следует, что a == c . Именно поэтому предыдущий
код, проверяющий равенство трех переменных, работает, как полагается.

Из курса математики вам могут быть знакомы другие примеры транзитивных

операций:

Параллельность прямых: если a∥ba∥b и b ∥cb ∥c, то a∥ca∥c;

 Отношение порядка: если a>ba>b и b>cb>c, то a>ca>c;

 Делимость: если aa делится на bb и bb делится на cc, то aa делится
на cc.

Наглядно транзитивность отношения порядка можно понять на таком

примере: если сосед слева старше вас (a>b)(a>b), а вы старше соседа
справа (b>c)(b>c), то сосед слева точно старше соседа справа (a>c)(a>c).

Операция неравенства ( != ), в отличие от операции равенства ( == ),

является нетранзитивной. То есть из того, что a != b и b != c вовсе не
следует, что a != c . Действительно, если вас зовут не так, как соседа
слева и не так, как соседа справа, то нет гарантии, что у обоих соседей не
окажутся одинаковые имена.

Таким образом, следующий код вовсе не проверяет тот факт, что все три
переменные различны:

if a != b != c:

print('числа не равны')

else:

print('числа равны')

Код, проверяющий, что значения трех переменных различны, мы научимся

писать немного позже.

Решение задач
Задача 1. Напишите программу, которая считывает одну строку. Если это
строка «Python», программа выводит «ДА», в противном случае программа
выводит «НЕТ».

Решение. Программа, решающая поставленную задачу, может иметь вид:

word = input()

if word == 'Python':

print('ДА')

else:

print('НЕТ')

Задача 2. Напишите программу, которая определяет, состоит ли двузначное

число, введенное с клавиатуры, из одинаковых цифр. Если состоит,
то программа выводит «ДА», в противном случае программа выводит «НЕТ».

Решение. Программа, решающая поставленную задачу, может иметь вид:

num = int(input())

last_digit = num % 10 # последняя цифра числа

first_digit = num // 10 # первая цифра числа

if last_digit == first_digit:

print('ДА')

else:

print('НЕТ')

Задача 3. Напишите программу, которая считывает три числа и

подсчитывает количество чётных чисел.

Решение. Программа, решающая поставленную задачу, может иметь вид:

num1, num2, num3 = int(input()), int(input()), int(input())

counter = 0 # переменная счётчик

if num1 % 2 == 0:

counter = counter + 1 # увеличиваем счётчик на 1

if num2 % 2 == 0:

counter = counter + 1 # увеличиваем счётчик на 1

if num3 % 2 == 0:
 counter = counter + 1 # увеличиваем счётчик на 1

print(counter)

Частые ошибки
В этом степе мы обсуждаем ошибки, которые учащиеся нашего курса чаще
всего совершают при освоении данной темы.

1. Отсутствие двоеточия : в блоке if после условия.

❌ Неправильно:
if num % 10 == 0
print('Число num кратно 10')
✅ Правильно:
if num % 10 == 0:
print('Число num кратно 10')
2. Использование оператора присваивания = вместо оператора
сравнения == .
❌ Неправильно:
if num = 10:
print('Число num равно 10')

✅ Правильно:
if num == 10:
print('Число num равно 10')
3. Отсутствие отступов в блоке if .
❌ Неправильно:
if color == 'red':
print('В переменной color содержится красный')
✅ Правильно:
if color == 'red':
print('В переменной color содержится красный')
4. if и else не на одном уровне:
❌ Неправильно:
if num == 777:
print('Число num равно 777')
else:
print('Число num НЕ равно 777')
✅ Правильно:
if num == 777:
 print('Число num равно 777')
else:
print('Число num НЕ равно 777')
5. Неправильное написание операторов сравнения:
❌ Неправильно:
if x => 10:
print('x больше либо равен 10')
if y =< 20:
print('y меньше либо равен 20')
if z =! 777:
print('z не равен 777')
✅ Правильно:
if x >= 10:
print('x больше либо равен 10')
if y <= 20:
print('y меньше либо равен 20')
if z != 777:
print('z не равен 777')
Запомните, что операторов => , =< , =! в Python не существует! Существуют
только >= , <= , != .

Глоссарий
✅ Ветвление (branching) — проверка условий и принятие решений по
результатам этой проверки. Программа таким способом выбирает, по какой
из возможных ветвей ей двигаться дальше.

✅ Блок кода — объединенные друг с другом строки. Они всегда связаны с

определенной частью программы. В Python блоки кода формируются при
помощи отступов.

✅ Отступ — небольшое смещение строки кода вправо. В начале такой строки

находятся пробелы, и поэтому она на несколько символов отстоит от левого
края. По соглашению PEP 8, для отступа блоков кода используются 4
пробела.

✅ В Python проверка условия выполняется с помощью оператора if :

 если условие истинно ( True ), выполняется блок кода после if
 если условие ложно ( False ), выполняется блок кода после else (при
наличии)
if условие:
блок кода
else:
блок кода
✅ Основные операторы сравнения:

Выражение Описание

if x > 7 если x больше 77

if x < 7 если x меньше 77

если x больше либо

if x >= 7
равен 77

если x меньше либо

if x <= 7
равен 77

if x == 7 если x равен 77

if x != 7 если x не равен 77

✅ Операция равенства является транзитивной. Это означает, что если a ==

b и b == c , то из этого следует, что a == c .

✅ Операция неравенства ( != ) является нетранзитивной. То есть из того,

что a != b и b != c вовсе не следует, что a != c

4.2 Логические операции

Тема урока: логические операторы
1. Логическое умножение and
2. Логическое сложение or
3. Логическое отрицание not
4. Решение задач
5. Частые ошибки

Аннотация. Изучим способ работы логических операторов в Python и

приоритетность их выполнения.

Логические операторы
Как быть в ситуации, когда у нас есть несколько условий? В Python есть три
логических оператора, которые позволяют создавать сложные условия:

 and — логическое умножение;

 or — логическое сложение;
 not — логическое отрицание.
 Оператор and
Предположим, мы написали программу для учеников от двенадцати лет,
которые учатся по крайней мере в 7 классе. Доступ к ней тем, кто младше,
надо запретить. Следующий код решает поставленную задачу:

age = int(input('Сколько вам лет?: '))

grade = int(input('В каком классе вы учитесь?: '))

if age >= 12 and grade >= 7:

print('Доступ разрешен.')

else:

print('Доступ запрещен.')

Мы объединили два условия при помощи оператора and . Он означает, что в

этом ветвлении блок кода выполняется только при выполнении обоих
условий одновременно!

Оператор and может объединять произвольное количество условий:

age = int(input('Сколько вам лет?: '))

grade = int(input('В каком классе вы учитесь?: '))

city = input('В каком городе вы живете?: ')

if age >= 12 and grade >= 7 and city == 'Москва':

print('Доступ разрешен.')

else:

print('Доступ запрещен.')

Это таблица истинности для оператора and . В ней перечислены выражения,

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

a b a and b

False False False

False True False

 a b a and b

True False False

True True True

Как показывает таблица, чтобы значение выражения с оператором and было

истинным, должны быть истинными оба (все) объединенные им условия.

Оператор or
Оператор or также применяется для объединения условий. Однако, в
отличие от and , для выполнения блока кода достаточно выполнения хотя бы
одного из условий.

city = input('В каком городе вы живете?: ')

if city == 'Москва' or city == 'Санкт-Петербург' or city == 'Екатеринбург':

print('Доступ разрешен.')

else:

print('Доступ запрещен.')

Доступ будет разрешен в случае, если хотя бы одно из условий выполнится.

Это таблица истинности для оператора or . В ней перечислены выражения,

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

a b a or b

False False False

False True True

True False True

True True True

Для того, чтобы выражение or было истинным, требуется, чтобы хотя бы

одно условие оператора or было истинным. При этом не имеет значения,
истинным или ложным является второе выражение.
 Логическое выражение X and Y истинно, если оба значения X и Y
истинны.

Логическое выражение X or Y истинно, если хотя бы одно из значений X и

Y истинно.

Мы можем использовать оба логических оператора одновременно:

age = int(input('Сколько вам лет?: '))

grade = int(input('В каком классе вы учитесь?: '))

city = input('В каком городе вы живете?: ')

if age >= 12 and grade >= 7 and (city == 'Москва' or city == 'Санкт-
Петербург'):

print('Доступ разрешен.')

else:

print('Доступ запрещен.')

Такой код проверяет, что возраст учеников от двенадцати лет и учатся они
по крайней мере в 7 классе и живут в Москве или Санкт-Петербурге.

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

age = int(input('Сколько вам лет?: '))

if not (age < 12):

print('Доступ разрешен.')

else:

print('Доступ запрещен.')

полностью эквивалентен коду:

age = int(input('Сколько вам лет?: '))

if age >= 12:

print('Доступ разрешен.')

else:

print('Доступ запрещен.')

В первом примере мы поместили выражение age < 12 в скобки для того,

чтобы было чётко видно, что мы применяем оператор not к значению
выражения age < 12 , а не только к переменной age .

Таблица истинности для оператора not :

a not a

False True

True False

Приоритеты логических операторов

Логические операторы, подобно арифметическим операторам ( + , - , * , / ),
имеют приоритет выполнения. Приоритет выполнения следующий:

 в первую очередь выполняется логическое отрицание not ;

 далее выполняется логическое умножение and ;
 далее выполняется логическое сложение or .

Для явного указания порядка выполнения условных

операторов используют скобки.

Примечания
Примечание 1. Частой ошибкой у начинающих программистов является
путаница логических операторов and и or . Рассмотрим два условия:

if x > 1 and x < 100:

if x > 1 or x < 100:

Верным является только первое условие. В нём проверяется, что

число xx находится в диапазоне от 1 до 100, другими
словами, x∈(1;100)x∈(1;100). Второе условие проверяет, что число xx или
больше 1, или меньше 100. Однако такому условию удовлетворяет любое
число!

Примечание 2. Другую частую ошибку видим в следующем примере кода:

if age >= 7 and <= 9:

Запуск такого кода приведет к появлению ошибки во время выполнения

программы. Необходимо явно записывать условия:

if age >= 7 and age <= 9:

Примечание 3. Не забывайте, что в Python есть удобный способ для

проверки принадлежности диапазону. Например, следующий код:

if age >= 7 and age <= 9:

полностью эквивалентен коду:

if 7 <= age <= 9:

Последний код предпочтительнее.

Примечание 4. Оба оператора, and и or , вычисляются по укороченной

схеме.

Вот как это работает с оператором and . Если условие слева от

оператора and является ложным, то условие справа от него не проверяется,
так как результат выражения будет гарантированно ложным и проверка
оставшегося условия — пустая трата процессорного времени.

Например, в таком выражении:

5 > 100 and 10 > 0

вычисляется только выражение 5 > 100 . Оно ложно (потому что 5 не может
быть больше 100). При операторе and оба выражения должны быть
правдивы, чтобы результат был True . Но у нас уже одно не правдиво,
значит, результат и так будет False . Поэтому нам и не надо вычислять
второе выражение, оно всё равно не повлияет на результат.

Аналогично работает оператор or . Если условие слева от

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

Например, в таком выражении:

10 > 0 or 5 > 100

вычисляется только выражение 10 > 0 . Оно правдиво, значит результат

тоже правдив, т.к. нам достаточно одного правдивого выражения при
операторе or .
Примечание 5. Подробнее про логические операторы and , or и not вы
можете прочитать в нашей статье на Хабре по ссылке.

Решение задач
Задача 1. Напишите программу, которая определяет, является ли заданное
натуральное число трёхзначным.

Решение. Программа, решающая поставленную задачу, может иметь

следующий вид:

num = int(input())

if 100 <= num <= 999: # num >= 100 and num <= 999

print('Число является трёхзначным')

else:

print('Число не является трёхзначным')

Задача 2. Напишите программу, которая проверяет, что все три цифры

натурального трёхзначного числа различны.

Решение. Программа, решающая поставленную задачу, может иметь

следующий вид:

num = int(input())

d3 = num % 10

d2 = num % 100 // 10

d1 = num // 100

if d3 != d2 and d3 != d1 and d2 != d1:

print('Цифры различны')

else:

print('Цифры не различны')

Задача 3. Напишите программу, которая по координатам точки, не лежащей

на осях координат, определяет номер координатной четверти, в которой она
находится.

Решение. Программа, решающая поставленную задачу, может иметь

следующий вид:

x = int(input())

y = int(input())
if x > 0 and y > 0:

print('1 четверть')

if x < 0 and y > 0:

print('2 четверть')

if x < 0 and y < 0:

print('3 четверть')

if x > 0 and y < 0:

print('4 четверть')

Примечание. Обратите внимание: никакие два из четырёх условий не могут

быть истинными одновременно.

Частые ошибки
В этом степе мы обсуждаем ошибки, которые учащиеся нашего курса чаще
всего совершают при освоении данной темы.

1. Неправильное использование оператора сравнения.

❌ Неправильно:

if age >= 7 and <= 9:

...

Запуск такого кода приведет к появлению ошибки во время выполнения

программы. Необходимо явно записывать условия.

✅ Правильно:
if age >= 7 and age <= 9:

...

2. Неправильное использование логического оператора or .

❌ Неправильно:

if my_city == 'Сидней' or 'Аделаида' or 'Перт':

print('Я живу в Австралии')

Когда вы таким образом "проверяете" значение переменной на равенство

строкам 'Сидней' , 'Аделаида' , 'Перт' , вы на самом деле делаете такую
проверку (python внутри себя проверяет на истинность
строки 'Аделаида' , 'Перт' ):

if my_city == 'Сидней' or True or True:

print('Я живу в Австралии')

Как вы понимаете, такой код всегда будет приводить к истинному

выражению ( True ). Дело в том, что Python воспринимает
строки 'Аделаида' , 'Перт' как нечто непустое и считает их
за True (подробнее про строки и их проверку на истинность мы поговорим
позже 🤯). Поэтому проверку на несколько строк надо осуществлять только в
явном виде.

✅ Правильно:

if my_city == 'Сидней' or my_city == 'Аделаида' or my_city == 'Перт':

print('Я живу в Австралии')

Глоссарий
✅ В Python есть три логических оператора, которые позволяют создавать
сложные условия:

 and — логическое умножение;

 or — логическое сложение;
 not — логическое отрицание.

✅ Таблица истинности для оператора and :

a b a and b

False False False

False True False

 a b a and b

True False False

True True True

✅ Таблица истинности для оператора or :

a b a or b

False False False

False True True

True False True

True True True

✅ Таблица истинности для оператора not :

a not a

False True

True False

✅ Приоритет выполнения логических операторов:

 в первую очередь выполняется логическое отрицание not ;

 далее выполняется логическое умножение and ;
 далее выполняется логическое сложение or .

Для явного указания порядка выполнения условных

операторов используют скобки.
4.3 Вложенные и каскадные условия
Тема урока: условный оператор
1. Вложенные условия
2. Каскадные условия
3. Решение задач

Аннотация. Изучим вложенный и каскадный условный оператор.

Вложенный оператор
Внутри условного оператора можно использовать любые инструкции языка
Python, в том числе и условный оператор. Получаем вложенное ветвление:
после одной развилки в ходе исполнения программы появляется другая
развилка. При этом вложенные блоки имеют больший размер отступа (+4
пробела для каждого следующего уровня).

if условие1:
блок кода
else:
if условие2:
блок кода
else:
if условие3:
блок кода
...

В предыдущем уроке мы разбирали задачу об определении координатной

четверти точки. Программу можно переписать с использованием вложенного
оператора:
x = int(input())
y = int(input())

if x > 0:
if y > 0:
print('Первая четверть')
else:
print('Четвертая четверть')
else:
if y > 0:
print('Вторая четверть')
else:
print('Третья четверть')
В данном случае уровень вложенности равен двум, так что программа
одинаково хорошо читается как с помощью использования логического
оператора and , так и с помощью вложенного оператора.

Рассмотрим программу, которая переводит стобалльную оценку в

пятибалльную. Для ее реализации нужно воспользоваться вложенным
условным оператором:

grade = int(input('Введите вашу отметку по 100-балльной системе: '))

if grade >= 90:

print(5)
else:
if grade >= 80:
print(4)
else:
if grade >= 70:
print(3)
else:
if grade >= 60:
print(2)
else:
print(1)

В этом примере уровень вложенности настолько глубок, что код становится

трудно понять.

Выбор из нескольких альтернатив – это обычное дело, здесь имеет смысл

избегать глубокого вложения. Для этого в Python есть каскадный условный
оператор.

Каскадный условный оператор

Если требуется проверить несколько условий, в языке Python
используется каскадный условный оператор.

Синтаксис каскадного условного оператора имеет следующий вид:

if условие1:

блок кода

elif условие2:

блок кода
...

else:

блок кода

При исполнении такого условного оператора сначала проверяется условие1.

Если оно является истинным, то исполняется блок кода, который следует
сразу после него, вплоть до выражения elif . Остальная часть конструкции
игнорируется. Однако если условие1 является ложным, то программа
перескакивает непосредственно к следующему выражению elif и
проверяет условие2. Если оно истинное, то исполняется блок кода, который
следует сразу после него, вплоть до следующего выражения elif . И
остальная часть условного оператора тогда игнорируется. Этот процесс
продолжается до тех пор, пока не будет найдено условие, которое является
истинным, либо пока больше не останется выражений elif . Если ни одно
условие не является истинным, то исполняется блок кода после
выражения else .

Приведенный ниже фрагмент кода является примером каскадного условного

оператора if-elif-else . Этот фрагмент кода работает так же, как
предыдущий код, использующий вложенный условный оператор.

grade = int(input('Введите вашу отметку: '))

if grade >= 90:

print(5)

elif grade >= 80:

 print(4)

elif grade >= 70:

print(3)

elif grade >= 60:

print(2)

else:

print(1)

Обратите внимание на выравнивание и выделение отступом, которые

применены в инструкции if-elif-else :
выражения if , elif и else выравнены и исполняемые по условию блоки
выделены отступом.

Инструкция if-elif-else не является обязательной, потому что ее логика

может быть запрограммирована вложенными инструкциями if-else . Однако
длинная серия вложенных инструкций if-else имеет два характерных
недостатка:

 программный код может стать сложным и трудным для восприятия;

 из-за необходимого выделения отступом продолжительная серия
вложенных инструкций if-else может стать слишком длинной, чтобы
целиком уместиться на экране монитора без горизонтальной
прокрутки.

Логика инструкции if-elif-else обычно прослеживается легче, чем длинная

серия вложенных инструкций if-else . И поскольку в инструкции if-elif-
else все выражения выровнены, длина строк в данной инструкции, как
правило, короче.

Запомни. Заключительный блок else в операторе if-elif-

else является необязательным:

traffic_light_signal = input('Введите сигнал светофора: ')

if traffic_light_signal == 'красный':

print('Стой!')

elif traffic_light_signal == 'желтый':

print('Приготовься...')
elif traffic_light_signal == 'зеленый':

print('Иди!')

В данном случае если будет введен некорректный сигнал светофора,

программа ничего не выведет. Каждое условие будет проверено поочередно,
и программа завершится без ошибок.

Решение задач
Задача 1. Даны три целых числа. Определите, сколько среди них
совпадающих. Программа должна вывести одно из чисел: 33 (если все
совпадают), 22 (если два совпадает) или 00 (если все числа различны).

Решение. Программа, решающая поставленную задачу, может иметь

следующий вид:

1 способ. Использование вложенного условного оператора.

a, b, c = int(input()), int(input()), int(input())

if a == b:

if b == c:

print(3)

else:

print(2)

else:

if a == c:

print(2)

else:

if b == c:

print(2)

else:

print(0)

2 способ. Использование каскадного условного оператора.

a, b, c = int(input()), int(input()), int(input())

if a == b == c:
 print(3)

elif a == b:

print(2)

elif b == c:

print(2)

elif a == c:

print(2)

else:

print(0)

3 способ. Использование каскадного условного оператора и логического

оператора or .

a, b, c = int(input()), int(input()), int(input())

if a == b == c:

print(3)

elif a == b or b == c or a == c:

print(2)

else:

print(0)

Глоссарий
✅ Внутри условного оператора можно размещать другие инструкции, в том
числе и условный оператор. Это создаёт вложенное ветвление. Каждый
уровень вложенности требует увеличенного отступа.

if условие1:

блок кода

else:

if условие2:

блок кода
 else:

if условие3:

блок кода

...

✅ Каскадный условный оператор используется, если требуется проверить

несколько условий. Синтаксис каскадного условного оператора имеет
следующий вид:

if условие1:

блок кода

elif условие2:

блок кода

...

else:

блок кода

6.1 Числовые типы данных: int, float

Тема урока: числовые типы данных
1. Целочисленный тип данных int
2. Числа с плавающей точкой float
3. Встроенные функции max() , min() , abs()
4. Решение задач

Аннотация. Числовые типы данных. Вспомним особенности работы с целыми

числами, научимся работать с числами с плавающей точкой. Изучим три
встроенные функции для работы с числами max , min , abs .

Целочисленный тип данных

Целые числа в Python представлены типом данных int (сокращение int
происходит от слова integer). Для определения целого числа
типа int используется последовательность цифр от 0 до 9 .

Явно указанное численное значение в коде программы

называется целочисленным литералом. Когда Python встречает
целочисленный литерал, он создает объект типа int , хранящий указанное
значение.
n = 17 # целочисленный литерал

m = 7 # целочисленный литерал

Целочисленный тип данных int используют не только потому, что

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

Преобразование строки в целое число

Для преобразования строки в целое число, мы используем команду int() :

num = int(input()) # преобразование считанной строки в целое число

Для преобразования строки в целое число не обязательно использовать

команду input() .

Следующий код преобразует строку '12345' в целое число:

n = int('12345') # преобразование строки в целое число

Если строка не является целым числом, то при преобразовании возникнет

ошибка.

Приведенный ниже код:

num = int('123!A')

num = int('2.5')

приводит к возникновению ошибки:

ValueError: invalid literal for int() with base 10

Целочисленные операторы
Язык Python предоставляет четыре основных арифметических оператора для
работы с целыми числами ( + , − , * , / ), а также три дополнительных ( % для
остатка, // для целочисленного деления и ** для возведения в степень).

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

a = 13
b = 7

total = a + b

diff = a - b

prod = a * b

div1 = a / b

div2 = a // b

mod = a % b

exp = a ** b

print(a, '+', b, '=', total)

print(a, '-', b, '=', diff)

print(a, '*', b, '=', prod)

print(a, '/', b, '=', div1)

print(a, '//', b, '=', div2)

print(a, '%', b, '=', mod)

print(a, '**', b, '=', exp)

В результате работы такой программы будет выведено:

13 + 7 = 20

13 - 7 = 6

13 * 7 = 91

13 / 7 = 1.8571428571428572

13 // 7 = 1

13 % 7 = 6

13 ** 7 = 62748517

При обычном делении ( / ) получается число, не являющееся целым.

Деление на ноль приводит к ошибке.

Длинная арифметика
Отличительной особенностью языка Python является неограниченность
целочисленного типа данных. По факту, размер числа зависит только от
наличия свободной памяти на компьютере. Это отличает Python от таких
языков как C++, C, C#, Java, где переменные целого типа данных имеют
ограничение. Например, в языке C# диапазон целых чисел ограничен
от −263−263 до 263−1263−1.

atom = 10 ** 80 # количество атомов во вселенной

print('Количество атомов =', atom)

Результатом выполнения программы будет число с 8181 цифрой:

Количество атомов =
1000000000000000000000000000000000000000000000000000000000000000000000000000
00000

Символ-разделитель
Для удобного чтения чисел можно использовать символ подчеркивания:

num1 = 25_000_000

num2 = 25000000

print(num1)

print(num2)

Приведённый выше код выводит:

25000000

25000000

Числа с плавающей точкой

Наравне с целыми числами в Python есть возможность работы с дробными
(вещественными) числами. Так, например, числа 23,2,π32,2,π – являются
вещественными и целого типа int недостаточно для их представления.

Дробные (вещественные) числа в информатике называют числами с

плавающей точкой.

Для представления чисел с плавающей точкой в Python используется тип

данных float .

e = 2.71828 # литерал с плавающей точкой

pi = 3.1415 # литерал с плавающей точкой

В Python, когда вы используете операцию деления / , результат всегда будет
числом с плавающей точкой, даже если оба числа являются целыми.

Приведённый ниже код:

print(4 / 2)

выводит:

2.0

В отличие от математики, где разделителем является запятая, в

информатике используется точка при записи чисел с плавающей точкой.

Преобразование строки к числу с плавающей точкой

Для преобразования строки к числу с плавающей точкой мы используем
команду float() :

num = float(input()) # преобразование считанной строки в число с плавающей

точкой

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

использовать команду input() .

Следующий код преобразует строку 1.2345 к числу с плавающей точкой:

n = float('1.2345') # преобразование строки к числу с плавающей точкой

Если строка не является числом, то при преобразовании возникнет

ошибка.

Арифметические операторы
Язык Python предоставляет четыре основных арифметических оператора для
работы с числами с плавающей точкой ( + , − , * , / ) и один дополнительный
( ** – для возведения в степень).

Следующая программа демонстрирует арифметические операторы:

a = 13.5

b = 2.0

total = a + b

diff = a - b
prod = a * b

div = a / b

exp = a ** b

print(a, '+', b, '=', total)

print(a, '-', b, '=', diff)

print(a, '*', b, '=', prod)

print(a, '/', b, '=', div)

print(a, '**', b, '=', exp)

Приведённый выше код выводит:

13.5 + 2.0 = 15.5

13.5 - 2.0 = 11.5

13.5 * 2.0 = 27.0

13.5 / 2.0 = 6.75

13.5 ** 2.0 = 182.25

Помимо операторов + , - , * , / и ** при работе с числами с плавающей

точкой также можно использовать операторы целочисленного деления // и
взятия остатка от целочисленного деления % .

Приведённый ниже код:

a = 13.5

b = 2.0

int_div = a // b

mod = a % b

print(a, '//', b, '=', int_div)

print(a, '%', b, '=', mod)

выводит:

13.5 // 2.0 = 6.0

13.5 % 2.0 = 1.5

 Деление на ноль приводит к ошибке.

Преобразование между int и float

Неявное преобразование. Любое целое число (тип int ) можно
использовать там, где ожидается число с плавающей точкой (тип float ),
поскольку при необходимости Python автоматически преобразует целые
числа в числа с плавающей точкой.

Явное преобразование. Число с плавающей точкой нельзя неявно

преобразовать в целое число. Для такого преобразования необходимо
использовать явное преобразование с помощью команды int() .

num1 = 17.89

num2 = -13.56

num3 = int(num1)

num4 = int(num2)

print(num3)

print(num4)

Приведённый выше код выводит:

17

-13

Обратите внимание: преобразование чисел с плавающей точкой в целое

производится с округлением в сторону нуля, то есть int(1.7) = 1 , int(-1.7)
= -1 .

Не путайте операцию преобразования и округления. Для округления

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

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

Встроенные функции
Python включает много заранее определенных функций. Программист не
видит их реализацию, она скрыта. Достаточно знать, как эти функции
называются и что они делают.

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

 print() – вывести на экран;

 input() – считать с клавиатуры;
 int() – преобразовать к целому числу;
 float() – преобразовать к числу с плавающей точкой.

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

достаточно часто при работе с числами.

Функции min() и max()

Для определения соответственно минимального или максимального
значения используются функции min() и max() . Аргументов у этих функций
может быть любое количество, главное, чтобы они все поддерживали между
собой операцию сравнения (например, float и int поддерживают
сравнение, а float и str – нет).

Приведённый ниже код:

a = max(3, 8, -3, 12, 9)
b = min(3, 8, -3, 12, 9)
c = max(3.14, 2.17, 9.8)
print(a)
print(b)
print(c)
выводит:
12
-3
9.8

Функция abs()
Модулем (абсолютной величиной) положительного числа называется само

число, модуль нуля – нуль. Модуль числа aa обозначается ∣a∣∣a∣, для него
число, модулем отрицательного числа называется противоположное ему

имеет место равенство:

∣a∣ ={a,если a>0 0,если a=0 −a,если a<0 ∣a∣ =⎩⎨⎧a,0,−a,если a>0 если a=0 ес
ли a<0
Для нахождения модуля (абсолютной величины) числа в Python используется
функция abs() .

Приведённый ниже код:

print(abs(10))
print(abs(-7))
print(abs(0))
print(abs(-17.67))
выводит:
10
7
0
17.67
Обратите внимание, все три функции max() , min() , abs() работают как с
целыми числами, так и с числами с плавающей точкой.

Глоссарий
✅ Тип данных int используется для представления целых чисел
(сокращение int происходит от слова integer).

✅ Целочисленный литерал — явно указанное численное значение в коде

программы.

✅ Для преобразования строки в целое число используется команда int() :

num1 = int(input()) # преобразование считанной строки в целое число

num2 = int('12345') # преобразование строки в целое число

Если строка не является числом, то при преобразовании возникнет ошибка.

✅ Язык Python предоставляет четыре основных арифметических оператора

для работы с целыми числами ( + , − , * , / ), а также три
дополнительных ( % для остатка, // для целочисленного деления и ** для
возведения в степень).

✅ Для удобного чтения чисел можно использовать символ подчеркивания:

num = 25_000_000 # 25000000

✅ Числа с плавающей точкой — дробные (вещественные) числа.

✅ Тип данных float используется для представления чисел с плавающей

точкой.
Для преобразования строки к числу с плавающей точкой используется
команда float() :

num1 = float(input()) # преобразование считанной строки в число с

плавающей точкой

num2 = float('1.2345') # преобразование строки к числу с плавающей точкой

Если строка не является числом, то при преобразовании возникнет ошибка.

✅ Язык Python предоставляет четыре основных арифметических

оператора для работы с числами с плавающей точкой ( + , − , * , / ) и один
дополнительный ( ** – для возведения в степень).

✅ Любое целое число (тип int ) можно использовать там, где ожидается
число с плавающей точкой (тип float ), поскольку при необходимости Python
автоматически преобразует целые числа в числа с плавающей точкой.

✅ Число с плавающей точкой нельзя неявно преобразовать в целое число.

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

✅ Функции min() и max() используются для определения минимального или

максимального значения соответственно.

✅ Модулем (абсолютной величиной) положительного числа называется само

число, модулем отрицательного числа называется противоположное ему
число, модуль нуля – нуль.

✅ Функция abs() используется для определения модуля числа.

6.2 Строковый тип данных

Тема урока: строковый тип данных
1. Строковый тип данных str
2. Функции len() и str()
3. Конкатенация строк
4. Умножение строки на число
5. Оператор in

Аннотация. Поговорим о строковом типе данных и научимся использовать

встроенные функции len() , str() , а также работать с
операторами + , * , in .

Строковый тип данных

Строковый тип данных, как и числовой, очень часто используется в
программировании. В Python строковый тип данных имеет
название str (сокращение от string – строка, струна, ряд).

Для создания строковой переменной (литерала), мы должны заключить

необходимый текст в кавычки. В Python можно использовать как одинарные
кавычки, так и двойные:

s1 = 'Python rocks!'

s2 = "Python rocks!"

Напомним, что по умолчанию команда input() считывает именно строку

текста:

s = input() # переменная s имеет строковый тип str

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

s1 = '' # пустая строка

s2 = ' ' # строка, состоящая из одного символа

пробела

Не стоит путать пустую строку и строку состоящую из одного символа

пробела. Это абсолютно разные строки.

Длина строки
Длиной строки называется количество символов, из которых она состоит.
Чтобы посчитать длину строки используем встроенную функцию len() (от
слова length – длина).

Приведённый ниже код:

s1 = 'abcdef'

length1 = len(s1) # считаем длину строки из переменной s1

length2 = len('Python rocks!') # считаем длину строкового литерала

print(length1)

print(length2)

выводит:

13
 При подсчете длины строки считаются все символы, включая
пробелы.

Преобразование чисел в строку

Для преобразования строки к числу мы использовали
функции int() и float() . Для обратного преобразования, то есть из числа в
строку мы используем функцию str() .

Рассмотрим следующий программный код:

num1 = 1777 # целое число

num2 = 17.77 # число с плавающей точкой

s1 = str(num1) # преобразовали целое число в строку '1777'

s2 = str(num2) # преобразовали число с плавающей точкой в строку '17.77'

Иногда работать со строками намного проще, чем с числами. Даже если

в условии задачи сказано, что дается число, нам ничто не мешает работать с
ним как со строкой.

Конкатенация строк
Строки, как и числа, можно складывать. Операция сложения строк
называется конкатенацией или сцеплением.

Приведённый ниже код:

s1 = 'ab' + 'bc'
s2 = 'bc' + 'ab'
s3 = s1 + s2 + '!!'
print(s1)
print(s2)
print(s3)

выводит:
abbc
bcab
abbcbcab!!
Операция сложения строк в отличие от операции сложения чисел не
является коммутативной, то есть, от перестановки мест слагаемых строк
результат меняется!

С помощью конкатенации строк можно эмулировать вывод данных, который

раньше мы делали используя необязательные параметры sep и end .
Следующие две строки кода делают одно и то же:
print('a', 'b', 'c', sep='*', end='!')
print() # переход на новую строку
print('a' + '*' + 'b' + '*' + 'c' + '!')

Приведённый выше код выводит:

a*b*c!
a*b*c!

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

В Python также можно умножать строку на целое неотрицательное число.
Такой оператор повторяет строку указанное количество раз.
Приведённый ниже код:
s = 'Hi' * 4
print(s)
выводит:
HiHiHiHi
Оператор умножения строки на число (repetition) очень удобен на практике.
Например, мы хотим распечатать строку, состоящую из 75 символов - . Мы
можем это сделать с помощью кода:
print('-' * 75)
Приведённый выше код выводит:

---------------------------------------------------------------------------

Строку можно умножать на число, но нельзя умножать на строку.

Примечания
Примечание 1. Тройные кавычки в Python используются для многострочного
(multiline) текста. Например,
text = '''Python is an interpreted, high-level, general-purpose programming
language.
Created by Guido van Rossum and first released in 1991, Python design
philosophy emphasizes code readability with its notable use of significant
whitespace.'''
Примечание 2. На первый взгляд может показаться странным, что можно
использовать как одинарные, так и двойные кавычки, однако такой подход
позволяет очень легко добавлять в строку нужные кавычки.
Приведённый ниже код:
s1 = 'Мы можем использовать в одиночных кавычках двойные кавычки "Война и
мир"'
s2 = "Мы можем использовать в двойных кавычках одиночные кавычки 'Война и
мир'"
print(s1)
print(s2)
выводит:
Мы можем использовать в одиночных кавычках двойные кавычки "Война и мир"
Мы можем использовать в двойных кавычках одиночные кавычки 'Война и мир'

Примечание 3. Обратите внимание: при умножении строки на 00 получается

пустая строка.
Приведённый ниже код:
print('C++ sucks.' * 0 == '')
выводит:
True
 Оператор in
В Python есть специальный оператор in , который позволяет проверить, что
одна строка находится внутри другой.
Приведённый ниже код:
s = '[Link]
if 'a' in s:
print('Введенная строка содержит символ а')
else:
print('Введенная строка не содержит символ а')
проверяет, содержится ли в переменной s символ 'a' , и выводит:
Введенная строка не содержит символ а

Использование вместе с логическими операторами

Мы можем использовать оператор in вместе с логическим оператором not ,
например:
s = input()
if '.' not in s:
print('Введенная строка не содержит символа точки')
С помощью оператора in мы можем упростить следующий код,
проверяющий, что значение переменной s равно одному из пяти
символов 'a' , 'e' , 'i' , 'o' , 'u' :

if s == 'a' or s == 'e' or s == 'i' or s == 'o' or s == 'u':

print('YES')
до вида:
if len(s) == 1 and s in 'aeiou':
print('YES')
С помощью оператора in мы можем проверять наличие сразу нескольких
символов в строке.
Приведённый ниже код:
s = 'Sigma'
print('a' in s)
print('z' in s)
выводит:
True
False

Точное вхождение
Оператор in проверяет, содержится ли одна строка в другой строке
как точная последовательность символов. В обеих строках символы
должны находиться в том же порядке друг относительно друга и не должны
быть разделены другими символами, чтобы выражение с
оператором in вернуло значение True .
Приведённый ниже код:
print('ab' in 'abc')
print('ac' in 'abc')
выводит:
True
False
Во втором случае выводится False , потому что строка 'abc' не содержит
последовательности символов 'ac' (символы 'a' и 'с' идут не подряд, они
разделены символом 'b' ).

Чувствительность к регистру
Проверка с использованием оператора in чувствительна к регистру.
Приведённый ниже код:
s = 'Alpha'
print('p' in s)
print('P' in s)
выводит:
True
False

Примечания
Примечание 1. Если строка s1 содержится в строке s2 , то говорят, что
строка s1 является подстрокой для строки s2 . Другими словами,
оператор in определяет, является ли одна строка подстрокой для другой
строки.

Глоссарий
✅ Строковый тип данных в Python имеет название str (сокращение от
string — строка, струна, ряд).

✅ Для создания строковой переменной (литерала) нужно заключить

необходимый текст в кавычки. В Python можно использовать как одинарные
кавычки, так и двойные.

✅ Длина строки — это количество символов, из которых она состоит. Чтобы

посчитать длину строки используем встроенную функцию len() (от слова
length – длина). При подсчете длины строки считаются все
символы, включая пробелы.

✅ Для преобразования строки в число используются

функции int() и float() .

✅ Для преобразования числа в строку используется функция str() .

✅ Конкатенация — операция сложения строк.

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

строку указанное количество раз.

✅ Тройные кавычки в Python используются для многострочного

(multiline) текста.

✅ Оператор in позволяет проверить, содержит ли одна строка другую. Его

можно использовать вместе с логическим оператором not . Если
строка s1 содержится в строке s2 , то говорят, что
строка s1 является подстрокой для строки s2 . Другими словами,
оператор in определяет, является ли одна строка подстрокой для другой
строки.

6.3 Модуль math

Тема урока: модуль math
1. Модуль math
2. Решение задач

Аннотация. Урок посвящён модулю math , который содержит

математические функции по работе с действительными числами.

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

Модуль math
Модуль math – один из наиважнейших в Python. Этот модуль предоставляет
обширный функционал для проведения вычислений с действительными
числами.

Для использования этих функций в начале программы необходимо

подключить модуль, что делается командой import :
import math

# программный код

После подключения модуля мы можем использовать его функции. Пусть мы

хотим:

 вычислить 22 (корень квадратный из двух);

 округлить число 3.83.8 до ближайшего целого числа вверх и вниз

Приведённый ниже код:

import math

num1 = [Link](2) # вычисление квадратного корня из двух

num2 = [Link](3.8) # округление числа вверх

num3 = [Link](3.8) # округление числа вниз

print(num1)

print(num2)

print(num3)

выводит:

1.4142135623730951

Особенности подключения модулей

Как можно заметить из примера выше, для вызова функции мы вынуждены
указывать название модуля и символ точки. С другой стороны, если функции
используются достаточно часто, то такой вызов (постоянное указание
названия модуля и символа точки) может усложнить программу и сделать
её менее читабельной. Для того чтобы не указывать название модуля и
символ точки при вызове функций, мы пишем следующий код:

from math import *

num1 = sqrt(2) # вычисление корня квадратного из двух

num2 = ceil(3.8) # округление числа вверх

num3 = floor(3.8) # округление числа вниз

print(num1)
 print(num2)

print(num3)

Таким образом, подключение модуля следующим образом:

from math import *

позволяет не писать название модуля и символ точки. При таком способе

подключения, импортируются абсолютно все функции модуля math .

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

импортировать их следующим образом:

from math import sqrt, ceil

Теперь мы можем вызывать функции sqrt() и ceil() без префикса math. ,

однако мы не можем вызвать функцию floor() , так как она не подключена:

from math import sqrt, ceil

print(sqrt(25))

print(ceil(34.7))

print(floor(12.8)) # приведет к ошибке, так как функция floor не подключена

Список функций модуля math

Список наиболее часто используемых функций модуля math :

Функция Описание

Округления

floor(x) Округляет число x вниз («пол»)

ceil(x) Округляет число x вверх («потолок»)

Корни, логарифмы,
степени и факториал

sqrt(x) Квадратный корень числа x

pow(x, n) Возведение числа x в степень n

Функция Описание

Натуральный логарифм числа x . Основание натурального логарифма равно

log(x)
числу e

Десятичный логарифм числа x . Основание десятичного логарифма равно

log10(x)
числу 10

log(x, b) Логарифм числа x по основанию b

factorial(n) Факториал натурального числа n

Тригонометрия

degrees(x) Преобразует угол x , заданный в радианах, в градусы

radians(x) Преобразует угол x , заданный в градусах, в радианы

cos(x) Косинус угла x , задаваемого в радианах

sin(x) Синус угла x , задаваемого в радианах

tan(x) Тангенс угла x , задаваемого в радианах

acos(x) Возвращает угол в радианах от 00 до ππ, cos которого равен x

asin(x) Возвращает угол в радианах от −π2−2π до π22π, sin которого равен x

atan(x) Возвращает угол в радианах от −π2−2π до π22π, tan которого равен x

atan2(y, x) Полярный угол (в радианах) точки с координатами (x, y)

Для извлечения квадратного корня можно воспользоваться кодом n

** 0.5 , вместо [Link](n) .

Список констант модуля math

Модуль math предоставляет ряд встроенных математических констант:
 Константа Описание

pi Число π=3.141592653589793π=3.141592653589793

e Число e= 2.718281828459045e= 2.718281828459045 (константа

Эйлера)

Примечания
Примечание 1. Все функции модуля math возвращают значение, которое
можно вывести на экран, присвоить другой переменной или использовать в
математическом выражении.

Примечание 2. Для округления чисел в Python, помимо

функций ceil() и floor() модуля math , также используются встроенные
функции int() и round() :

int() Округляет число в сторону нуля

Округляет число x до ближайшего целого. Если дробная часть числа

round(x) равна 0.50.5, то число округляется до ближайшего четного числа
(банковское округление)

round(x, n) Округляет число x до n знаков после точки

Примечание 3. Вызов функций pow(x, n) можно заменить использованием

оператора возведения в степень: x**n .
Примечание 4. Импортировать функции (или любые другие объекты) из
модуля можно несколькими способами:
from math import *
num = sqrt(10)
from math import sqrt
num = sqrt(10)
import math

num = [Link](10)
Однако рекомендуется избегать импортирования через from math
import * , так как нет ясности, какие функции были импортированы и это
загрязняет пространство имён лишними, неиспользуемыми функциями.
 Вместо этого рекомендуется использовать from math import sqrt или import
math , чтобы явно указать, что именно вы импортируете. Это делает ваш код
более читаемым и управляемым.
Глоссарий
✅ Модуль math – один из наиважнейших в Python. Этот модуль
предоставляет обширный функционал для проведения вычислений с
действительными числами.
Наиболее часто используемые функции модуля math

Функция Описание

Округления

floor(x) Округляет число x вниз («пол»)

ceil(x) Округляет число x вверх («потолок»)

Корни,
логарифмы,
степени и
факториал

sqrt(x) Квадратный корень числа x

pow(x, n) Возведение числа x в степень n

Натуральный логарифм числа x. Основание натурального

log(x)
логарифма равно числу e

Десятичный логарифм числа x. Основание десятичного

log10(x)
логарифма равно числу 10

log(x, b) Логарифм числа x по основанию b

factorial(n) Факториал натурального числа n

Тригонометрия

degrees(x) Преобразует угол x, заданный в радианах, в градусы

radians(x) Преобразует угол x, заданный в градусах, в радианы

cos(x) Косинус угла x, задаваемого в радианах

Функция Описание

sin(x) Синус угла x, задаваемого в радианах

tan(x) Тангенс угла x, задаваемого в радианах

Возвращает угол в радианах от 00 до ππ, cos которого

acos(x)
равен x

Возвращает угол в радианах от −π2−2π до π22π

asin(x)
, sin которого равен x

Возвращает угол в радианах от −π2−2π до π22π

atan(x)
, tan которого равен x

atan2(y, x) Полярный угол (в радианах) точки с координатами (x, y)

✅ Подключение модуля:
import math # использовать функции нужно с указанием названия
модуля с точкой
from math import sqrt, ceil # позволяет не писать название модуля и символ
точки

from math import * # позволяет не писать название модуля и символ

точки,
# импорт всех функций (не рекомендуется)
✅ Математические константы модуля math:

Описание
Константа

pi Число π=3.141592653589793π=3.141592653589793

Число e= 2.718281828459045e= 2.718281828459045 (конста

e
нта Эйлера)

7.1 Цикл for

Тема урока: цикл for
1. Цикл for
 2. Переменная цикла
3. Решение задач

Аннотация. Урок посвящен циклу for . Что такое цикл for и как создавать
программы, повторяющие определенные действия? Понятие переменной
цикла.

Цикл for
Одно из преимуществ компьютеров перед людьми - способность повторять
одни и те же действия многократно, быстро и совсем не утомляясь 💻.

В Python существует две основных разновидности циклов:

 циклы, повторяющиеся определенное количество раз ( for , счетные

циклы, counting loops);
 циклы, повторяющиеся до наступления определенного события ( while ,
условные циклы, conditional loops).

Цикл for замечательно работает, если мы заранее знаем, сколько

повторений (итераций) нам требуется сделать.

Рассмотрим код, который распечатает 1010 раз слово "Привет":

for i in range(10):

print('Привет')

Структура цикла for в Python выглядит так:

for название_переменной_цикла in range(количество_повторений):

блок кода

Двоеточие ( : ) в конце строки с инструкцией for сообщает интерпретатору

Python, что дальше находится блок команд. В блок команд входят все
строки, расположенные с отступом от строки с инструкцией for , вплоть до
следующей строки без отступа.

Блок команд, который выполняется в цикле for , называется телом

цикла.

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

при помощи нескольких команд input() . С помощью цикла for можно
считывать и обрабатывать сколько угодно чисел.

Рассмотрим следующий программный код:

for i in range(5):
 num = int(input())

print('Квадрат вашего числа равен:', num * num)

print('Цикл завершен')

Такая программа считывает 55 чисел и выводит на экран их квадраты вместе

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

Примеры использования цикла for

Рассмотрим следующий программный код:
print("A")
print("B")

for i in range(5):
print("C")
print("D")
print("E")

Результатом выполнения такой программы будут строки

A
B
C
D
C
D
C
D
C
D
C
D
E

То есть сначала программа распечатает символы А и В ,

затем символы C и D пять раз, а затем распечатает символ Е один раз. Тело
цикла состоит из двух строк: пятой и шестой; именно они и будут
повторяться.

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

чтобы сначала 55 раз был распечатан символ С , а затем 55 раз символ D , мы
можем использовать 22 цикла:
print('A')
print('B')

for i in range(5):
print('C')

for i in range(5):
print('D')

print('E')

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

A
B
C
C
C
C
C
D
D
D
D
D
E

Примечания
Примечание 1. Однократное выполнение тела цикла
называется итерацией цикла.

Примечание 2. Графическое представление цикла for имеет вид:

Примечание 3. Напомним, что блоком кода называют объединенные друг
с другом строки. Они всегда связаны с определенной частью программы
(например, с инструкцией if или for ). В Python блоки кода формируются
при помощи отступов:

Примечание 4. Слово for пишется маленькими буквами, первая строка

должна заканчиваться двоеточием, а тело цикла должно быть выделено
отступом.
 Переменная цикла
Давайте еще раз взглянем на базовую структуру цикла for :

for название_переменной_цикла in range(количество_повторений):

блок кода

Не совсем понятно, для чего нужна и как работает переменная цикла.

Рассмотрим следующий код:

for i in range(10):

print(i)

Результатом выполнения такого кода будет:

0
1
2
3
4
5
6
7
8
9

Когда цикл впервые начинает работу, Python устанавливает значение

переменной цикла i = 0 . Каждый раз, когда мы повторяем тело цикла,
Python увеличивает значение переменной на 11.

Почему большинство программистов начинают цикл с 00, а не

с 11? Раньше некоторые начинали цикл с 11, а некоторые с 00. Те и другие
приводили весьма изощренные аргументы, споря о том, какой способ лучше.
Но в конце концов победили сторонники второго варианта. С тех пор
большинство начинает циклы с 00. В частности, в Python
цикл for начинается с 00, однако в будущих уроках вы узнаете, как
это изменить.
Поскольку переменная цикла i увеличивается на 11 каждый раз, то ее
можно использовать для отслеживания номера итерации, на которой мы
находимся в циклическом процессе.

Рассмотрим следующий код:

for i in range(10):

print(i, '-- Привет')

Результатом выполнения такого кода будет:

0 -- Привет

1 -- Привет

2 -- Привет

3 -- Привет

4 -- Привет

5 -- Привет

6 -- Привет

7 -- Привет

8 -- Привет

9 -- Привет

Если мы хотим начать с 11, то можем написать код:

for i in range(10):

print(i + 1, '-- Привет')

Результатом выполнения такого кода будет:

1 -- Привет

2 -- Привет

3 -- Привет

4 -- Привет
5 -- Привет

6 -- Привет

7 -- Привет

8 -- Привет

9 -- Привет

10 -- Привет

Обратите внимание, за счет выражения i + 1 , мы начинаем вывод с 11, а не

с 00.

Имена переменных цикла

Ранее говорилось, что имена переменных должны носить
осмысленный характер и описывать их назначение. Однако для переменных
цикла иногда делаются исключения. В программировании для переменных
цикла обычно используют буквы i , j , k .

Следующие две программы абсолютно одинаковые: в первой программе

переменная цикла имеет название i , во второй программе – number :

for i in range(10):
print(i)

for number in range(10):

print(number)

Результатом выполнения обеих программ будет:

0
1
2
3
4
5
6
7
8
9

Почему для переменной циклов зарезервированы буквы i , j , k ?

Дело в том, что раньше программы использовались для математических
расчетов, а в математике буквы a , b , c и x , y , z уже зарезервированы для
других целей. Поэтому программисты выбрали для этой цели
переменные i , j , k , и это стало общепринятой практикой.

Бывают ситуации, когда переменная цикла не используется в теле цикла. В

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

for _ in range(5):
print('Python - awesome!')

Результатом выполнения такого кода будет:

Python - awesome!
Python - awesome!
Python - awesome!
Python - awesome!
Python - awesome!

Если переменная цикла не используется в теле цикла, то указывайте

вместо неё символ нижнего подчеркивания _ .

Примечания
Примечание 1. Следует помнить, что правая граница цикла в Python всегда
невключительна.
Приведённый ниже код:
for i in range(5):
print(i)
выводит:
0
1
2
3
4

Если требуется распечатать числа от 11 до 55 (включительно), то мы можем

написать следующий код:

for i in range(5):

print(i + 1)

Глоссарий
✅ В Python существует две основных разновидности циклов:

 циклы, повторяющиеся определенное количество раз ( for , счетные

циклы, counting loops);
 циклы, повторяющиеся до наступления определенного события ( while ,
условные циклы, conditional loops).

✅ Структура цикла for в Python выглядит так:

for название_переменной_цикла in range(количество_повторений):

блок кода

✅ Блок команд, который выполняется в цикле for , называется телом цикла.

7.2 Цикл for: функция range

Тема урока: цикл for
1. Цикл for
2. Функции range() с одним параметром
3. Функции range() с двумя параметрами
4. Функции range() с тремя параметрами
5. Решение задач

Аннотация. Урок посвящен циклу for , в частности функции range() , которая

позволяет генерировать последовательность чисел. Изучим две
дополнительные перегрузки функции range() , которые позволяют
настраивать элементы последовательности.

Функция range() с одним параметром

Рассмотрим программный код:

for i in range(10):
 print('Привет', i)

Значение, которое мы указываем в скобках у функции range() обозначает

количество итераций цикла, при этом переменная i принимает
последовательно значения: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 .

Если быть более точным, то мы говорим, что функция range(stop) генерирует

последовательность чисел от 0 до stop - 1 , а цикл for последовательно
перебирает эту последовательность.

Перегрузка range() с двумя параметрами

Если мы хотим начинать последовательность не с 0 , а с какого-то
другого числа, то мы можем использовать перегрузку
функции range() принимающую два параметра. Например, вызов
функции range(1, 5) сгенерирует последовательность чисел 1, 2, 3, 4
(будьте внимательны, правая граница не включительна). Если нам нужны
числа от 11 до 55 включительно, то мы используем range(1, 6) .

Таким образом:

 range(stop) : создает последовательность чисел 0, 1, 2, 3, ...,

stop - 1 ;
 range(start, stop) : создает последовательность чисел start, start +
1, start + 2, ..., stop - 2, stop - 1 .

Напишем программу, которая выводит те числа из промежутка [100;999]

[100;999], которые оканчиваются на 77.
Используя функцию range() с двумя параметрами, получаем:

for i in range(100, 1000): # перебираем числа от 100 до 999

if i % 10 == 7: # используем остаток от деления на 10, для

получения последней цифры

print(i)

Обратите внимание, в качестве второго параметра мы передали

число 10001000.
 Если первый параметр больше второго, то функция range() генерирует
пустую последовательность. Например, вызов функции range(10, 1) приводит
к генерации пустой последовательности.

Перегрузка range() с 3 параметрами

Передавая два параметра в функцию range() мы можем генерировать любую
последовательность целых чисел с шагом 11. Но, что делать, если нужно
поменять шаг? Как быть, если мы хотим сгенерировать последовательность
чисел 5, 10, 15, 20, 25 ? В этом случае существует еще одна перегрузка
функции range() , принимающая три параметра: range(start, stop, step) .
Первый параметр задает старт последовательности, второй параметр
задает стоп последовательности и третий – шаг генерации чисел.

Например, вызов функции range(1, 10, 2) создаст последовательность

чисел 1, 3, 5, 7, 9 , а вызов функции range(5, 30, 5) сгенерирует
последовательность 5, 10, 15, 20, 25 .

Напишем программу, которая выводит все четные числа из

промежутка [56;170][56;170].

Используя функцию range() с тремя параметрами, получаем:

for i in range(56, 171, 2):

print(i)

Обратите внимание, мы можем использовать функцию range() с двумя

параметрами:

for i in range(56, 171):

if i % 2 == 0:

print(i)

Однако такой код получается менее эффективным.

Отрицательный шаг генерации

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

В случае отрицательного шага, мы должны гарантировать, что старт

последовательности (первый параметр) больше чем конец
последовательности (второй параметр).

Например, вызов функции range(20, 16, -1) создаст последовательность

чисел 20, 19, 18, 17 , а вызов функции range(20, 10, -3) сгенерирует
последовательность 20, 17, 14, 11 .

Напишем программу, которая отсчитывает от 5 до 1, а затем выводит

текст Взлетаем!!! :

for i in range(5, 0, -1):

print(i, end=' ')

print('Взлетаем!!!')

Результатом будет:

5 4 3 2 1 Взлетаем!!!

Если величина шага отрицательна и первый параметр меньше второго,

то функция range() генерирует пустую последовательность. Например,
вызов функции range(1, 10, -1) приводит к генерации пустой
последовательности.

Примеры использования функции range()

Вызов функции Последовательность чисел

0, 1, 2, 3, 4, 5, 6, 7, 8,
range(10)
9

range(1, 10) 1, 2, 3, 4, 5, 6, 7, 8, 9

range(3, 7) 3, 4, 5, 6

range(7, 3) пустая последовательность

 Вызов функции Последовательность чисел

range(2, 15, 3) 2, 5, 8, 11, 14

range(9, 2, -1) 9, 8, 7, 6, 5, 4, 3

range(3, 10, -2) пустая последовательность

Примечания
Примечание 1. Функция range() может принимать от одного до трёх
параметров: range(stop), range(start, stop), range(start, stop, step)

 параметр start – это старт последовательности (включительно)

 параметр stop – это стоп последовательности (не включительно)
 параметр step – это величина шага

Примечание 2. Функция range() может генерировать только целые числа,

включая отрицательные.

Примечание 3. Величина шага не может равняться нулю.

Приведённый ниже код:

for i in range(1, 10, 0):

print(i)

приводит к возникновению ошибки:

ValueError: range() arg 3 must not be zero

Глоссарий
✅ Функция range() позволяет генерировать последовательность целых
чисел.

✅ Функция range() может принимать от одного до трёх

параметров: range(stop), range(start, stop), range(start, stop, step)

 параметр start – это старт последовательности (включительно)

 параметр stop – это стоп последовательности (не включительно)
 параметр step – это величина шага
7.3 Частые сценарии
1. Подсчёт количества
2. Вычисление суммы и произведения
3. Определение максимума и минимума
4. Обмен значений переменных
5. Расширенные операторы присваивания ( += , -= , //= и т.д.)
6. Сигнальные метки

Аннотация. Рассмотрим частые сценарии при написании циклов.

Подсчёт количества
Нередко нужно, чтобы наши программы подсчитывали, сколько раз что-либо
произошло. К примеру, видеоигра может подсчитывать количество
поворотов персонажа, или математическая программа может считать, как
много чисел обладают некоторым свойством. Ключ к подсчёту –
использование переменной счётчика.

Напишем программу, которая считывает 10 чисел и определяет, сколько из

них больше 10 .

counter = 0 # создаём переменную

счётчика

for _ in range(10):

num = int(input())

if num > 10: # при выполнении

условия

counter = counter + 1 # увеличиваем

значение cчётчика

print('Было введено', counter, 'чисел, больших 10.')

Каждый раз, когда мы считываем число, большее 10 , мы добавляем 1 к

нашему текущему значению переменной counter . В программе это
реализовано в строке counter = counter + 1 . Обратите внимание на
начальное значение переменной счетчика counter = 0 . Без начального
значения мы получили бы ошибку, поскольку, дойдя до строки counter =
counter + 1 , Python ничего не знал бы о переменной counter . Строка
кода counter = counter + 1 означает: возьми старое значение
переменной counter , прибавь к нему 1 и переприсвой переменной это
значение. Если не придать переменной начальное значение, то непонятно, к
чему прибавлять 1 в самый первый раз.

Подсчёт количества – это очень частый сценарий. Он состоит из двух

шагов:

1. Создание переменной счётчика, и придание ей первоначального

значения: counter = 0 ;
2. Увеличение переменной счётчика на 1 : counter = counter + 1 .

Часто при написании программ требуется использовать несколько счётчиков.

Модифицируем предыдущую программу: посчитаем ещё и количество нулей
среди введённых чисел.

counter1 = 0

counter2 = 0

for _ in range(10):

num = int(input())

if num > 10:

counter1 = counter1 + 1

if num == 0:

counter2 = counter2 + 1

print('Было введено', counter1, 'чисел, больших 10.')

print('Было введено', counter2, 'нулей.' )

Рассмотрим ещё один пример: подсчитать количество чисел из диапазона

от 1 до 100 (включительно), квадрат которых оканчивается на 4 .

counter = 0

for i in range(1, 101):

if i**2 % 10 == 4:

counter = counter + 1

print(counter)
Мы используем функцию range() с двумя параметрами для генерации
последовательности чисел от 1 до 100 . Каждый раз, когда
переменная i последовательно принимает значения от 1 до 100 , мы
проверяем условие: i**2 % 10 == 4 (оканчивается ли квадрат числа i на 4 ).

Для переменной счётчика удобно использовать имя counter .

Вычисление суммы и произведения

Наравне с подсчетом количества по частоте стоит задача вычисления
суммы. К примеру, видеоигра должна считать сумму очков. В таком случае
начальное значение переменной будет равно 0 , а далее оно будет
увеличиваться на некоторое количество заработанных очков, скажем на 10 .
Мы пишем следующий код:

score = 0

...

score = score + 10

Напишем программу, которая считывает 10 чисел и определяет сумму тех из

них, которые больше 10 .

total = 0

for _ in range(10):

num = int(input())

if num > 10:

total = total + num

print('Сумма чисел больших 10 равна', total)

Каждый раз, когда программа считывает число, большее 10 , она добавляет

его к текущему значению переменной total . Это реализовано в
строке total = total + num . Обратите внимание на начальное значение
переменной-сумматора total = 0 . Без начального значения мы получили бы
ошибку, поскольку, дойдя до строки total = total + num , Python ничего не
знал бы о переменной total . Строка кода total = total + num означает:
возьми старое значение переменной total , прибавь к нему num и
переприсвой переменной это значение. Если не придать переменной
начальное значение, то не к чему прибавлять num в самый первый раз.

Подсчет суммы состоит из двух шагов:

1. Создание переменной сумматора и придание ей первоначального

значения: total = 0 ;
2. Увеличение переменной сумматора на нужное число: total = total +
num .

Напишем программу, которая считает сумму натуральных чисел от 1 до 100 :

total = 0

for i in range(1, 101):

total = total + i

print('Сумма равна', total)

Рассмотрим еще один пример: напишем программу, которая

запрашивает 10 целых чисел и находит их среднее значение:

total = 0

for _ in range(10):

num = int(input())

total = total + num

average = total / 10

print('Среднее значение равно', average)

Аналогичным образом вычисляется произведение. При вычислении

произведения начальное значение переменной мультипликатора мы
устанавливаем равным 1 , в отличие от сумматора, где оно равно 0 .
 Для переменной сумматора и мультипликатора удобно использовать
имя total .

Максимум и минимум
Поиск наибольшего или наименьшего значения в некоторой
последовательности чисел – также частая задача в программировании.
Напишем программу, которая считывает 10 положительных чисел и
находит среди них наибольшее число.

largest = 0

for _ in range(10):

num = int(input())

if num > largest:

largest = num

print('Наибольшее число равно', largest)

Мы устанавливаем начальное значение переменной largest в 0 . Далее

программа считывает 10 чисел, и если какое-то из них оказывается
больше текущего значения largest , переприсваивает его. В качестве
начального значения взято число 0 , поскольку мы знаем, что все числа
положительны (а 0 является максимальным неположительным числом).
Таким образом, уже первое сравнение приведет к переприсваиванию.

Распространен подход, когда в качестве начального значения переменной

сразу принимается первый элемент последовательности. Напишем
программу, которая считывает 10 чисел (необязательно положительных) и
находит среди них наибольшее:

largest = int(input()) # принимаем первое число за максимальное

for _ in range(9):

num = int(input())

if num > largest:

 largest = num

print('Наибольшее число равно', largest)

Для нахождения наименьшего значения последовательности следует

поменять знак неравенства ( > ) на противоположный ( < ). В таком случае
название переменной largest стоит заменить на smallest .

Для переменных, хранящих наибольшее и наименьшее значения,

подходят имена largest и smallest соответственно.

Примечания
Примечание 1. Поскольку в Python есть встроенные функции max() и min() ,
то давать такие названия для максимального и минимального значения не
очень хорошо. Куда лучше использовать
названия largest и smallest или maximum и minimum .

Примечание 2. Сумму чисел от 1 до 100 можно вычислить и без цикла,

используя формулу арифметической прогрессии: 1+2+3+...

⋅100=101⋅50=5050Действительно, числа от 1 до 100 можно разбить

+100=1+1002⋅100=101⋅50=50501+2+3+...+100=21+100

на 50 пар, сумма в которых равна 101 :1+100=101,2+99=101,3+98=101,

…,50+51=1011+100=101,2+99=101,3+98=101,…,50+51=101В начальной школе,
где учился математик Карл Фридрих Гаусс (6 лет), учитель, чтобы занять
класс на продолжительное время самостоятельной работой, дал задание
ученикам – вычислить сумму всех натуральных чисел от 1 до 100 . Маленький
Гаусс ответил на вопрос почти мгновенно, применив указанный способ
подсчета, чем невероятно удивил всех и, прежде всего, учителя.

Обмен значений переменных

Очень часто нам требуется обменять значения двух переменных x и y .
Начинающие программисты иногда пишут такой код:
x = y
y = x
Однако он не работает. Предположим, что x = 3 и y = 5 . Первая строка
присвоит переменной x значение 5 , что правильно, однако вторая строка
установит значение переменной y в 5 , поскольку значение x уже равно 5 .
Для решения задачи мы можем использовать временную переменную:
temp = x
x = y
y = temp
Такой код пишут почти во всех языках программирования. Однако в Python
есть и более простой способ. Мы можем написать так:
x, y = y, x

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

переменных x и y местами.

Расширенные операторы присваивания

Довольно часто программы имеют инструкции присваивания, в которых
переменная на левой стороне от оператора = также появляется на правой от
него стороне. Например,
counter = counter + 1

На правой стороне оператора присваивания 1 прибавляется к

переменной counter . Полученный результат затем присваивается
переменной counter , заменяя первоначальное значение. По сути, это строка
кода добавляет 1 к переменной counter . Ещё один пример такой
инструкции мы видели при подсчёте суммы:
total = total + num

Эта инструкция присваивает значение выражения total +

num переменной total . В результате исполнения этой инструкции
число num прибавляется к переменной total .
Различные инструкции присваивания (в каждой инструкции x = 6 )

Инструкция Что она делает Значение x после инструкции

x = x + 4 Прибавляет 4 к x 10

x = x - 3 Вычитает 3 из x 3

x = x * 10 Умножает x на 10 60

x = x / 4 Делит x на 4 1.5

x = x // 4 Делит нацело x на 4 1

x = x % 4 Находит остаток от деления x на 4 2

Эти типы операций находят широкое применение в программировании. Для

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

total = total + num

можно переписать как

total += num

Точно так же инструкцию

counter = counter + 1

можно переписать как

counter += 1

Оператор Пример использования Эквивалент

+= x += 5 x = x + 5

-= x -= 2 x = x - 2

*= x *= 10 x = x * 10

/= x /= 4 x = x / 4

//= x //= 4 x = x // 4

%= x %= 4 x = x % 4

Сигнальные метки
Сигнальная метка (флажок) может использоваться, когда надо, чтобы одна
часть программы узнала о происходящем в другой части программы.
Напишем программу, определяющую, что натуральное число
является простым:

num = int(input())

flag = True

for i in range(2, num):

if num % i == 0: # если исходное число делится на какое-либо отличное

от 1 и самого себя

flag = False

if num == 1:

print('Это единица, она не простая и не составная')

elif flag == True:

 print('Число простое')

else:

print('Число составное')

Напомним, что число является простым, если оно не имеет делителей,

кроме 1 и самого себя. Вышеприведенная программа работает следующим
образом: начальное значение переменной флага равно True , что говорит о
том, что число является простым. Затем мы перебираем все числа
от 2 до num - 1 (включительно). Если одно из этих значений оказывается
делителем числа num , тогда число num является составным и мы
устанавливаем значение флага False . Как только цикл завершен, мы
проверяем, установлен флаг в True или нет. Если это так, мы знаем, что
делитель найден не был и число является простым. В противном случае
число является составным.
Флаговые переменные могут иметь более осмысленное название. Например,
в случае с проверкой числа на простоту, название флаговой переменной
могло бы быть is_prime .

Примечания
Примечание 1. По аналогии с обменом значений двух переменных мы
можем менять местами значения трёх и более переменных.

Приведённый ниже код:

a, b, c, d = 1, 2, 3, 4
a, b, c, d = b, c, d, a
print(a, b, c, d)
выводит:
2 3 4 1

Примечание 2. При множественном присваивании Python сначала

вычисляет все выражения справа (в порядке слева направо), затем уже
присваивает полученные значения переменным слева (тоже слева направо).

Приведённый ниже код:

a, b = 3, 4
a, b = a + b, 2 * a
print(a, b)
выводит:
7 6

В приведённом выше примере сначала будут вычислены значения

выражений a + b и 2 * a – 7 и 6 соответственно. Далее
переменной a будет присвоено значение 7 , а переменной b будет
присвоено значение 6 .

Примечание 3. Очень часто сигнальные метки называют flag .

 Глоссарий
✅ Подсчёт количества состоит из двух шагов:
1. Создание переменной счётчика, и придание ей первоначального
значения: counter = 0 ;

2. Увеличение переменной счётчика на 11: counter = counter + 1 .

✅ Вычисление суммы состоит из двух шагов:

1. Создание переменной сумматора и придание ей первоначального
значения: total = 0 ;
2. Увеличение переменной сумматора на нужное число: total = total +
num .

✅ Вычисление произведения состоит из двух шагов:

1. Создание переменной мультипликатора и придание ей
первоначального значения: product = 1 ;
2. Умножение переменной мультипликатора на нужное число: product =
product * num .

✅ Поиск наибольшего или наименьшего значения в некоторой

последовательности чисел выполняется с помощью перебора в цикле всех
элементов и обновления текущего максимума или минимума при
необходимости.
✅ Обмен значений переменных:
x, y = y, x
a, b, c, d = b, c, d, a
✅ Расширенные операторы присваивания:
Оператор Пример использования Эквивалент

+= x += 5 x = x + 5

-= x -= 2 x = x - 2

*= x *= 10 x = x * 10

/= x /= 4 x = x / 4

//= x //= 4 x = x // 4

%= x %= 4 x = x % 4

✅ Сигнальная метка (флажок) — это переменная, используемая для

передачи информации между разными частями программы, чтобы одна часть
могла узнать о состоянии или событии в другой части и действовать
соответственно.
7.5 Тема урока: цикл while
1. Цикл while
2. Считывание данных до стоп значения
3. Бесконечный цикл
4. Решение задач

Аннотация. Урок посвящен циклу while . Мы научимся создавать программы,

повторяющие определенные действия, пока выполняется некоторое условие.

Цикл while
Как уже было сказано в предыдущем уроке, существуют две
основные разновидности цикла:

 циклы, повторяющиеся определенное количество раз ( for , счетные

циклы, counting loops);
 циклы, повторяющиеся до наступления определенного события ( while ,
условные циклы, conditional loops)

Мы уже рассмотрели работу цикла for , который является счетным циклом.

Цикл for замечательно работает, если мы заранее знаем, сколько
повторений (итераций) нам потребуется сделать. Но иногда нужно, чтобы
цикл выполнялся до наступления некоторого события, и количество
итераций в этом случае заранее оценить просто невозможно. И здесь на
помощь приходит цикл while .

Структура цикла while в Python выглядит так:

while условие:

блок кода

Двоеточие ( : ) в конце строки с инструкцией while сообщает Python, что

дальше находится блок команд. В блок входят все строки, расположенные с
отступом от строки с инструкцией while , вплоть до следующей строки без
отступа.

Блок команд, который выполняется в цикле while , называется телом цикла.

Рассмотрим код, использующий цикл while , который распечатает 1010 раз

слово Привет :

i = 0

while i < 10:

print('Привет')
 i += 1

Такой код можно легко заменить циклом for , поскольку мы заранее знаем,
сколько раз нужно выполнить тело цикла. Однако так бывает не всегда.

Напишем программу, которая считывает числа и выводит их квадраты, пока

не будет введено −1−1. При такой постановке задачи мы не можем
воспользоваться циклом for , так как не знаем, сколько чисел будет
предшествовать числу −1−1.
num = int(input())

while num != -1:

print('Квадрат вашего числа равен:', num * num)

num = int(input())

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

чисел. Далее, пока выполняется условие цикла, а именно пока введенное
число не равно −1−1, мы исполняем тело цикла. В тело цикла входит две
команды:

1. напечатать квадрат введенного числа;

2. считать следующее число.

Важным являются два момента:

1. правильная инициализация переменной num ;

2. изменение переменной num внутри цикла while .

Важно: если не изменять переменную num внутри цикла, то можно

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

Цикл while очень похож на условный оператор if . Разница заключается в

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

Цикл for VS цикл while

Мы всегда можем заменить цикл for с помощью цикла while . Следующие
две программы выводят числа от 00 до 100100:
# используем for

for i in range(101):
 print(i)

# используем while

i = 0

while i < 101:

print(i)

i += 1

В первом цикле переменная i последовательно принимает значения

от 00 до 100100. Для цикла while нам пришлось завести самостоятельно
переменную i и придать ей начальное значение. Тело
цикла while содержит аналогичную инструкцию вывода print(i) , однако
помимо этого мы самостоятельно увеличиваем значение
переменной i на 11, что делается автоматически в случае с циклом for .

Напишем программу, выводящую все числа, кратные 33, используя

цикл for и while :

# используем for

for i in range(0, 100, 3):

print(i)

# используем while

i = 0

while i < 100:

print(i)

i += 3

Не всегда, однако, удается заменить цикл while с помощью цикла for . Если
заранее не известно количество итераций, то необходимо использовать
цикл while и только его.

Считывание данных до стоп значения

Часто при решении задач на цикл while мы считываем данные до тех пор,
пока пользователь не введет некоторое значение, которое называют стоп
значением. Напишем программу, которая считывает числа и находит их
сумму до тех пор, пока пользователь не введет слово stop :

text = input()
total = 0

while text != 'stop':

total += int(text)

text = input()

print('Сумма чисел равна', total)

Такой код будет часто использоваться при решении задач.

Бесконечный цикл
Всегда кроме редких случаев цикл while должен содержать возможность
завершиться. То есть в цикле что-то должно сделать проверяемое условие
ложным. Если цикл не имеет возможности завершиться, то он
называется бесконечным циклом. Бесконечный цикл продолжает
повторяться до тех пор, пока программа не будет прервана. Бесконечные
циклы обычно появляются, когда программист забывает написать
программный код внутри цикла, который делает проверяемое условие
ложным. В большинстве случаев следует избегать применения
бесконечных циклов.
Пример бесконечного цикла:
i = 0
total = 0
while i < 10:
total += i
Так как в теле цикла не происходит изменения переменной i , то условие i
< 10 остается истинным и цикл выполняется бесконечно много раз.

Бесконечные циклы можно использовать в связке с оператором

прерывания break . Об этом будет рассказано в следующих уроках.

Примечания
Примечание 1. Цикл while получил свое название из-за характера своей
работы: он выполняет некую задачу до тех пор, пока условие является
истинным. Слово while на английском означает как раз "пока".

Примечание 2. Цикл while называют циклом с предусловием, поскольку

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

Примечание 3. Однократное выполнение тела цикла

называется итерацией цикла.
Примечание 4. Цикл while может не выполниться ни одного раза.
Например, следующий код:

i = -1

while i > 0:

print('Hello world!')

не выведет текст, поскольку условие i > 0 ложно с самого начала.

Примечание 5. Графическое представление цикла while имеет вид:

Примечание 6. Условие в цикле while , как и в условном операторе if ,

может содержать логические операторы or , and , not .

Примечание 7. Обратите внимание: в задачах нашего курса есть лимит на

время выполнения программы (обычно это 1515 секунд). Если написанный
вами код выполняется дольше этого лимита, то проверяющая система
выводит сообщение об ошибке:

Failed test #№ of №. Time limit exceeded

Чаще всего данная ошибка возникает, когда студент отправляет решение, в

котором запускается бесконечный цикл. 😵

Глоссарий
✅ Существуют две основные разновидности цикла:

 циклы, повторяющиеся определенное количество раз ( for , счетные

циклы, counting loops);
 циклы, повторяющиеся до наступления определенного события ( while ,
условные циклы, conditional loops)

✅ Структура цикла while в Python выглядит так:

while условие:

блок кода

✅ Блок команд, который выполняется в цикле while , называется телом

цикла.
✅ Бесконечным называется цикл, который не имеет возможности
завершиться.

✅ Итерация цикла – однократное выполнение тела цикла.

✅ Условие в цикле while , как и в условном операторе if , может содержать

логические операторы or , and , not .

7.6 Обработка цифр числа

1. Обработка цифр числа с помощью цикла while
2. Обработка цифр числа с помощью цикла for

Аннотация. Урок посвящён обработке цифр натурального числа.

Обработка цифр числа с помощью цикла while

При изучении целых чисел (тип данных int ) мы говорили про
операцию целочисленного деления // и операцию нахождения остатка от
деления одного целого числа на другое % . Используя цикл while и две
данных операции, можно обработать цифры числа с произвольным
количеством разрядов (цифр).

Пусть дано натуральное число num . Тогда:

 результатом операции num % 10 является последняя цифра числа

 результатом операции num // 10 является число с удалённой
последней цифрой
Напишем программу, которая считывает натуральное число и обрабатывает
его цифры.
num = int(input()) # считываем число
while num != 0: # проверяем, что цифры
числа не закончились
last_digit = num % 10 # получаем последнюю цифру
числа
... # обрабатываем последнюю
цифру числа
num = num // 10 # удаляем последнюю цифру
из числа

Цикл while работает до тех пор, пока в числе есть необработанные

цифры. Тело цикла содержит:

1. процедуру получения последней цифры last_digit = num % 10

 2. код обработки последней цифры
3. процедуру удаления последней цифры из числа num = num // 10

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

Напишем программу, которая определяет, есть ли в числе num цифра 7 .

num = 1576
has_seven = False # сигнальная метка (флаг)

while num != 0:
last_digit = num % 10
if last_digit == 7:
has_seven = True
num = num // 10

if has_seven == True:
print('YES')
else:
print('NO')

Приведённый выше код выводит:

YES

Обработка цифр числа с помощью цикла for

В одном из уроков мы говорили про получение любой цифры числа по
формуле:

(num // 10 ** (n - i)) % 10

где n – количество разрядов числа, i – номер цифры числа (слева направо,

начиная с 1 ).

Для того чтобы пройтись по всем цифрам числа, нам нужно лишь знать
количество разрядов n этого числа. Мы можем найти количество
разрядов n следующим способом:

n = len(str(num))

Другими словами, можно сказать, что тут мы находим «длину» числа.

Если все разряды числа пронумеровать от 1 до n включительно, то мы

можем рассмотреть все цифры числа слева направо следующим образом:
num = int(input()) # считываем число
n = len(str(num)) # количество разрядов
числа
for i in range(1, n + 1): # проходим по всем
разрядам числа от 1 до n
digit = num // 10 ** (n - i) % 10 # получаем i-ю цифру числа
... # обрабатываем i-ю цифру
числа

Приведённый ниже код:

num = 8619
n = len(str(num))
for i in range(1, n + 1):
digit = num // 10 ** (n - i) % 10
print(i, '-я', ' цифра равна ', digit, sep='')
выводит:
1-я цифра равна 8
2-я цифра равна 6
3-я цифра равна 1
4-я цифра равна 9

Глоссарий
✅ Для обработки цифр натурального числа используются
операции // и % :
 операция % 10 позволяет получить последнюю цифру числа
 операция // 10 удаляет последнюю цифру из числа
✅ Обработка цифр числа с помощью цикла while :

num = int(input()) # считываем число

while num != 0: # проверяем, что цифры
числа не закончились
last_digit = num % 10 # получаем последнюю цифру
числа
... # обрабатываем последнюю
цифру числа
num = num // 10 # удаляем последнюю цифру
из числа

✅ Обработка цифр числа с помощью цикла for :

num = int(input()) # считываем число

n = len(str(num)) # количество разрядов
числа
for i in range(1, n + 1): # проходим по всем
разрядам числа от 1 до n
digit = num // 10 ** (n - i) % 10 # получаем i-ю цифру числа
... # обрабатываем i-ю цифру
числа
7.7 break, continue, else
1. Оператор break
2. Оператор continue
3. Бесконечные циклы
4. Ключевое слово else в циклах
5. Решение задач

Аннотация. Урок посвящен операторам break и continue , а также

необязательному блоку else .

Оператор прерывания цикла break

Иногда бывает нужно прервать выполнение цикла преждевременно.
Оператор break прерывает ближайший цикл for или while .

Усовершенствуем с помощью оператора break программу, проверяющую

число на простоту:

num = int(input())

flag = True

for i in range(2, num):

if num % i == 0: # если исходное число делится на какое-либо

отличное от 1 и самого себя

flag = False

break # останавливаем цикл если встретили делитель

числа

if flag: # эквивалентно if flag == True:

print('Число простое')

else:

print('Число составное')

Как только мы встречаем делитель отличный от 1 и num , мы меняем

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

Оператор прерывания цикла break позволяет ускорять программы,

так как мы избавляемся от лишних итераций.
Напишем программу, использующую цикл for , которая считывает 10 чисел
и суммирует их до тех пор, пока не обнаружит отрицательное число. В этом
случае выполнение цикла прерывается командой break :

result = 0
for i in range(10):
num = int(input())
if num < 0:
break
result += num
print(result)

Оператор прерывания цикла break удобен в связке с сигнальными

метками: когда после проверки некоторого условия нам нет смысла
продолжать выполнение цикла.

Напишем программу, которая определяет, содержит ли введенное

пользователем число цифру 7.
num = int(input())
number = num
flag = False
while num != 0:
last_digit = num % 10
if last_digit == 7:
flag = True
break # прерываем цикл, так как число гарантированно содержит
цифру 7
num //= 10

if flag: # эквивалентно if flag == True:

print('Число', number, 'содержит цифру 7')
else:
print('Число', number, 'не содержит цифру 7')

Как только мы встретили цифру 7, мы меняем значение сигнальной метки и

прерываем цикл с помощью оператора break . Мы можем и не прерывать
цикл преждевременно, а дождаться его естественного завершения
(условие num != 0 , то есть все цифры числа обработаны), однако в таком
случае мы будем совершать лишнюю работу, и в случае, если число очень
большое, программа будет работать медленнее.

Бесконечные циклы
В предыдущих уроках мы говорили о цикле, который не имеет возможности
завершиться и назвали его бесконечным циклом. Самый простой способ
создать бесконечный цикл в Python – записать следующий код:
while True:
print('Python is awesome!')

Результатом выполнения такого кода будет бесконечное количество строчек

текста:
Python is awesome!
Python is awesome!
.
.
.
Python is awesome!
Python is awesome!
Python is awesome!

Бесконечный цикл продолжает повторяться до тех пор, пока программа не

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

Возможно, вам может показаться, что бесконечные циклы лишены смысла,

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

while True:
query = get_new_query() # получаем новый запрос на обработку
[Link]() # обрабатываем запрос

Иногда с помощью бесконечного цикла удается сделать программный код

более читабельным. Более простым может быть завершение цикла на основе
условий внутри тела цикла, а не на основе условий в его заголовке:

while True:
if условие 1: # условие для остановки цикла
break
...
 if условие 2: # еще одно условие для остановки цикла
break
...
if условие 3: # еще одно условие для остановки цикла
break

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

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

Важно: бесконечные циклы могут быть очень полезными. Просто

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

Оператор continue
Другая стандартная идиома циклов — пропуск отдельных элементов при
переборе. Оператор continue позволяет перейти к следующей итерации
цикла for или while до завершения всех команд в теле цикла.
Напишем программу, которая выводит все числа от 1 до 100, кроме чисел 7,
17, 29 и 78.
for i in range(1, 101):
if i == 7 or i == 17 or i == 29 or i == 78:
continue # переходим на следующую итерацию
print(i)

Примечания
Примечание 1. Оператор break прерывает выполнение ближайшего цикла,
а не программы, то есть далее будет выполнена команда, следующая
сразу за циклом.

Примечание 2. Графическое представление

операторов break и continue имеет вид:
7.8 Поиск ошибок и ревью кода
1. Поиск ошибок
2. Производительность кода

Аннотация. Урок посвящен проведению ревью кода, поиску ошибок и

анализу производительности.

Ревью кода
Ревью кода – проверка исходного кода программы с целью обнаружения и
исправления ошибок и неточностей, которые остались незамеченными при
начальной разработке.

В процессе ревью кода могут быть исправлены:

 фактические ошибки;
 производительность кода;
 читабельность кода и ошибки форматирования кода.

Целью ревью кода является улучшение качества программного

кода и совершенствование навыков программиста.

Как правило, ревью кода выполняет программист с большим опытом.

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

Среди частых фактических ошибок встречаются:

 отсутствие начальной инициализации переменной;

 неправильная начальная инициализация переменной;
 отсутствие отступа (в Python блоки кода выделяются отступами);
 неправильные числовые граничные значения, например при
использовании функции range() ;
 неправильные граничные сравнения (путаница с >, >= или <, <= );
 путаница логических операций or и and и т.д.

Производительность кода
Под производительностью кода в простейшем случае можно подразумевать
то, сколько времени программа тратит на решение задачи. При
написании программы, программист должен думать над тем, сколько
времени в худшем случае потребуется его программе для решения задачи.
Рассмотрим задачу, которая проверяет число на простоту.
1 версия программы: Перебираем все числа от 2 до num -
1 (включительно) и делаем проверку делимости числа num на i :
num = int(input())
flag = True

for i in range(2, num):

if num % i == 0:
flag = False

if num == 1:
print('Число равно 1')
elif flag == True:
print('Число простое')
else:
print('Число составное')

Если программе на вход подаётся простое число num = 1934234249 , то она

будет работать примерно 270270 секунд = 4.54.5 минуты. 🙄
2 версия программы: Несложно понять, что перебирать все числа
от 2 до num - 1 (включительно) не имеет смысла. Достаточно проверить
числа от 2 до num // 2 (включительно):
num = int(input())
flag = True

for i in range(2, num // 2 + 1):

if num % i == 0:
flag = False

if num == 1:
print('Число равно 1')
elif flag == True:
print('Число простое')
else:
print('Число составное')

Если программе на вход подается простое число num = 1934234249 , то она

будет работать примерно 130130 секунд = 2.22.2 минуты. По сути мы
улучшили время работы программы вдвое! 😊

3 версия программы: Правую границу num // 2 проверки можно улучшить,

если заметить, что у любого составного числа есть делитель (отличный
от 11), не превосходящий квадратного корня из числа. Таким образом,
имеет смысл перебирать делители от 22 до numnum (включительно).

num = int(input())
flag = True

for i in range(2, int(num ** 0.5) + 1):

if num % i == 0:
flag = False

if num == 1:
print('Число равно 1')
elif flag == True:
print('Число простое')
else:
print('Число составное')
Если программе на вход подаётся простое число num = 1934234249 , то она
будет работать примерно 0.0660.066 секунд. По сути мы улучшили время
работы программы в 4000 раз! 😎

4 версия программы: Предыдущие оптимизации касались случая, когда

проверяемое число является простым. В случае если число является
составным и мы нашли его первый делитель (отличный от 11), мы прерываем
цикл с помощью оператора break :

num = int(input())
flag = True

for i in range(2, int(num ** 0.5) + 1):

if num % i == 0:
flag = False
break

if num == 1:
print('Число равно 1')
elif flag == True:
print('Число простое')
else:
print('Число составное')

Число 11 не является ни простым, ни составным, так как у него

только один делитель – оно само.

Читабельность кода
Следует помнить, что наш код должен легко читаться другими
программистами. Чтобы этого достичь, следует придерживаться
стандарта PEP 8. Обращайте внимание на следующие моменты:

1. отступы и пробелы: используйте 4 пробела на один уровень отступа и

никогда не смешивайте символы табуляции и пробелы;
2. названия переменных: используйте говорящие названия для
переменных ( total, counter, product ) и следуйте
стилю lower_case_with_underscores (слова из маленьких букв с
подчеркиваниями);
3. пустые строки: дополнительные отступы пустыми строками могут
быть изредка полезны для выделения группы логически связанных
частей программы: инициализация переменных, основной алгоритм,
завершающая проверка и т.д.;
 4. комментарии: комментарии должны являться законченными
предложениями. И помните, комментарии, которые противоречат коду,
хуже, чем отсутствие комментариев. Всегда исправляйте комментарии,
если меняете код!

О стандарте PEP 8 на русском языке можно почитать тут.

Примечания
Примечание 1. Хорошие статьи о ревью кода можно почитать на
хабре: статья 1, статья 2.
Примечание 2. Программные ошибки, часто называют багами 🦟
Примечание 3. Все программисты создают баги, особенно в начале своего
карьерного пути. Это норма 😀

Примеры
Пример 1. Требовалось написать программу, которая выводит 1010 раз
символ А . Вы ревьювите приведённый ниже код:

print('A')

print('A')

print('A')

print('A')

print('A')

print('A')

print('A')

print('A')

print('A')

print('A')

Что вы о нём скажете? Правильно ли он работает? Как его улучшить?

Ревью. Приведённый выше код выполняет поставленную задачу, однако его

можно улучшить. Поскольку действия в строках одинаковые, то можно
использовать цикл. Поскольку мы знаем количество повторений (итераций),
то нам подходит цикл for :
for _ in range(10):

print('A')

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

числа от 11 до 100100, кратные 77. Вы ревьювите приведённый ниже код:

i = 1

while i < 101:

if i % 7 == 0:

print(i)

i += 1

Что вы о нём скажете? Правильно ли он работает? Как его улучшить?

Ревью. Приведённый выше код содержит достаточно распространённую

ошибку: неверно поставленный отступ. Поскольку управление
циклом while происходит при помощи переменной i , то её необходимо
инкрементировать (увеличивать) каждую итерацию. В приведённом выше
коде она инкрементируется, только если выполняется условие i % 7 == 0 ,
которое ложно для начального значения i = 1 . Таким образом, получаем
бесконечный цикл. Для исправления ошибки необходимо удалить отступ у
строки i += 1 :

i = 1

while i < 101:

if i % 7 == 0:

print(i)

i += 1

В данном случае лучше использовать цикл for с шагом, равным 77. Это
позволит сделать код более наглядным и сократит время выполнения
программы, так как нет необходимости просматривать и проверять все числа
на делимость на 7:

for i in range(7, 101, 7):

print(i)
Пример 3. Требовалось написать программу, которая выводит все числа от
100 до 1 в порядке убывания. Вы ревьювите приведённый ниже код:

for i in range(1, 100):

print(101 - i)

Что вы о нём скажете? Правильно ли он работает? Как его улучшить?

Ревью. Приведенный код содержит достаточно распространенную ошибку:

неправильная правая граница цикла for . Следует помнить, что правая
граница в цикле for всегда не включительна. Таким образом, для
исправления ошибки необходимо заменить число 100100 на 101101:
for i in range(1, 101):

print(101 - i)

В данном случае лучше использовать цикл for с шагом, равным −1−1:

for i in range(100, 0, -1):

print(i)

Пример 4. Требовалось написать программу, которая находит сумму всех

нечётных чисел от 11 до 10001000 (включительно). Вы ревьювите
приведённый ниже код:

a = 1

for i in range(1, 1000):

if i % 2 == 1:

a = a + 1

print(a)

Что вы о нем скажете? Правильно ли он работает? Как его улучшить?

Ревью. Приведенный код содержит достаточно распространенные ошибки:

1. неправильная начальная инициализация переменной a ;

2. неправильная правая граница цикла for ;
 3. неправильно записанная операция накапливания значения суммы.

a = 0

for i in range(1, 1001):

if i % 2 == 1:

a = a + i

print(a)

Для улучшения читабельности кода изменим название

переменной a на total и используем расширенный оператор присваивания:

total = 0

for i in range(1, 1001, 2):

total += i

print(total)

Пример 5. Требовалось написать программу, которая вычисляет факториал

числа. Вы ревьювите следующий код:

n = input()

a = 0

for i in range(n):

a = a * i

print(a)

Что вы о нем скажете? Правильно ли он работает? Как его улучшить?

Ревью. Приведенный код содержит достаточно распространенные ошибки:

1. отсутствие преобразования строки текста в целое число;

2. неправильная начальная инициализация переменной a ;
3. неправильная работа с границами итерирования:
переменная i принимает значения от 0 до n - 1 .

n = int(input())

a = 1
for i in range(1, n + 1):

a = a * i

print(a)

Для улучшения читабельности кода, изменим название

переменной a на factorial и используем расширенный оператор
присваивания:

n = int(input())

factorial = 1

for i in range(1, n + 1):

factorial *= i

print(factorial)

В модуле math есть функция factorial() , которая вычисляет

факториал числа. Поэтому вместо реализации своей версии куда правильнее
и удобнее воспользоваться уже готовой.

Глоссарий
✅ Ревью кода – проверка исходного кода программы с целью обнаружения и
исправления ошибок и неточностей, которые остались незамеченными при
начальной разработке.

✅ В процессе ревью кода могут быть исправлены:

 фактические ошибки;
 производительность кода;
 читабельность кода и ошибки форматирования кода.

✅ Целью ревью кода является улучшение качества программного

кода и совершенствование навыков программиста.

7.9 Вложенные циклы

1. Вложенные циклы
2. Операторы break и continue во вложенных циклах
3. Решение задач

Аннотация. Вложенные, находящиеся внутри других циклов, циклы.

 Вложенные циклы
Вложенный цикл расположен в еще одном цикле. Часы служат хорошим
примером работы вложенного цикла. Секундная, минутная и часовая стрелки
вращаются вокруг циферблата.Часовая стрелка смещается всего на 1
шаг для каждых 60 шагов минутной стрелки. И секундная стрелка должна
сделать 60 шагов для 1 шага минутной стрелки. Это означает, что для
каждого полного оборота часовой стрелки (12 шагов), минутная стрелка
делает 720 шагов.

Рассмотрим цикл, который частично моделирует электронные часы. Он

показывает секунды от 0 до 59:
for seconds in range(60):
print(seconds)

Можно добавить переменную minutes и вложить цикл написанный выше

внутрь еще одного цикла, который повторяется 60 раз:
for minutes in range(60):
for seconds in range(60):
print(minutes, ':', seconds)

Для того, чтобы сделать модель законченной, можно добавить еще одну
переменную для подсчета часов:
for hours in range(24):
for minutes in range(60):
for seconds in range(60):
print(hours, ':', minutes, ':', seconds)

Результатом работы такого кода будет:

0 : 0 : 0
0 : 0 : 1
0 : 0 : 2
...
23 : 59 : 58
23 : 59 : 59

Самый внутренний цикл сделает 60 итераций для каждой итерации среднего

цикла. Средний цикл сделает 60 итераций для каждой итерации самого
внешнего цикла. Когда самый внешний цикл сделает 24 итерации, средний

сделает 24 ⋅60⋅60=8640024 ⋅60⋅60=86400 итераций!

сделает 24⋅60=144024⋅60=1440 итераций, и самый внутренний цикл

Пример имитационной модели часов подводит нас к нескольким моментам,

имеющим отношение к вложенным циклам:

 вложенный цикл выполняет все свои итерации для каждой отдельной

итерации внешнего цикла;
 вложенные циклы завершают свои итерации быстрее, чем внешние
циклы;
 для того, чтобы получить общее количество итераций вложенного
цикла, надо перемножить количество итераций всех циклов.

Мы можем вкладывать друг в друга циклы как for , так и while .

Операторы break и continue во вложенных

циклах
Оператор break выполняет прерывание ближайшего цикла в котором он
расположен. Аналогично, оператор continue осуществляет переход на
следующую итерацию ближайшего цикла.
Рассмотрим программный код:
for i in range(3):
for j in range(3):
print(i, j)

Результатом его выполнения будут 9 строк:

0 0
0 1
0 2
1 0
1 1
1 2
2 0
2 1
2 2
Изменим код, добавив во вложенный цикл условный оператор с
оператором break :
for i in range(3):
for j in range(3):
if i == j:
break
print(i, j)

Результатом выполнения нового кода будут 3 строки:

1 0
2 0
2 1

Изменим оператор прерывания break на оператор continue :

for i in range(3):
for j in range(3):
if i == j:
continue
print(i, j)

Результатом выполнения нового кода будут 6 строк:

0 1
0 2
1 0
1 2
2 0
2 1

Если необходимо добиться прерывания внешнего цикла из-за

выполнения условия во внутреннем, то стоит сделать это через сигнальную
метку.

Примеры решения задач

Один интересный способ узнать о работе вложенных циклов состоит в их
использовании для вывода на экран комбинаций символов. Давайте взглянем
на один простой пример. Предположим, что мы хотим напечатать на экране
звездочки в виде прямоугольной таблицы:
******
******
******
******
******
******
******
******

Таблица состоящая из звездочек состоит из 8 строк и 6 столбцов.

Приведенный ниже фрагмент кода можно использовать для вывода одной
строки звездочек:
for i in range(6):
print ( '*', end='')

Для того чтобы завершить весь вывод таблицы звездочек, нам нужно
выполнить этот цикл восемь раз. Мы можем поместить этот цикл в еще один
цикл, который делает восемь итераций, как показано ниже:
for i in range(8):
for j in range(6):
print('*', end='')
print()

Внешний цикл делает восемь итераций. Во время каждой итерации этого

цикла внутренний цикл делает 6 итераций. (Обратите внимание, что в
строке 4 после того, как все строки были напечатаны, мы вызываем
функцию print() . Мы должны это сделать, чтобы в конце каждой строки
продвинуть экранный курсор на следующую строку. Без этой инструкции все
звездочки будут напечатаны на экране в виде одной длинной строки.)

Давайте рассмотрим еще один пример. Предположим, что вы хотите

напечатать звездочки в комбинации, которая похожа на приведенный ниже
звездный треугольник:
*
**
***
****
*****
******
*******
********

Представим эту комбинацию звездочек, как сочетание строк и столбцов. В

этой комбинации всего восемь строк. В первой строке один столбец. Во
второй строке – два столбца. В третьей строке – три. И так продолжается до
восьмой строки, в которой восемь столбцов.
for i in range(8):
for j in range(i + 1):
print('*', end='')
print()

Использование вложенных циклов при

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

Решение задач
Задача 1. Найдите все пары натуральных чисел (и их количество),
являющихся решением уравнения 12x+13y=77712x+13y=777.

Решение. Поскольку по условию числа xx и yy являются натуральными,

то x≤64,y≤59x≤64,y≤59 (при x=65x=65, 12⋅65=78012⋅65=780, что больше,
чем 777777, поэтому x≤64x≤64, т.к. yy не может быть отрицательным по
условию; аналогично получается, что y≤59y≤59). Напишем программу,
которая перебирает всевозможные пары чисел (x;y)(x;y) и проверяет для них
выполнение условия 12x+13y=77712x+13y=777.
total = 0
for x in range(1, 65):
for y in range(1, 60):
if 12 * x + 13 * y == 777:
total += 1
print('x =', x, 'y =', y)
print('Общее количество натуральных решений =', total)

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

x = 3 y = 57
x = 16 y = 45
x = 29 y = 33
x = 42 y = 21
x = 55 y = 9
Общее количество натуральных решений = 5
Задача 2. Найдите все тройки натуральных чисел (и их количество),
являющихся решением уравнения x2+y2+z2=2020x2+y2+z2=2020.

Решение. Поскольку по условию числа x,yx,y и zz являются натуральными,

то x,y,z<2020≈45x,y,z<2020≈45. Напишем программу, которая перебирает
всевозможные тройки чисел (x;y;z)(x;y;z) и проверяет для них
условие x2+y2+z2=2020x2+y2+z2=2020.

total = 0
for x in range(1, 45):
for y in range(1, 45):
for z in range(1, 45):
if x ** 2 + y ** 2 + z ** 2 == 2020:
total += 1
print('x =', x, 'y =', y, 'z =', z)
print('Общее количество натуральных решений =', total)

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

x = 18 y = 20 z = 36
x = 18 y = 36 z = 20
x = 20 y = 18 z = 36
x = 20 y = 36 z = 18
x = 36 y = 18 z = 20
x = 36 y = 20 z = 18
Общее количество натуральных решений = 6

Глоссарий
✅ Вложенный цикл расположен в еще одном цикле.

✅ Некоторые особенности вложенных циклов:

 вложенный цикл выполняет все свои итерации для каждой отдельной

итерации внешнего цикла;
 вложенные циклы завершают свои итерации быстрее, чем внешние
циклы;
 для того, чтобы получить общее количество итераций вложенного
цикла, надо перемножить количество итераций всех циклов.

✅ Можно вкладывать друг в друга циклы как for , так и while .

✅ Оператор break выполняет прерывание ближайшего цикла в котором он
расположен.

✅ Оператор continue осуществляет переход на следующую

итерацию ближайшего цикла.
9.1 Индексация
1. Индексация строк
2. Итерирование строк
3. Решение задач

Аннотация. Строковый тип данных. Вспомним основные операции над

строками, научимся работать с отдельными символами, а также перебирать
(итерировать) символы строк.

Повторение материала
Строки в Python используются, когда надо работать с текстовыми данными.
Создание строки. Для создания строк мы используем парные
кавычки '' или "" :
s1 = 'Python'
s2 = "Pascal"

Считывание строки. Для считывания текстовых данных в строковую

переменную мы используем функцию input() :
s = input() # считали текст
num = int(input()) # считали текст и преобразовали его в целое число

Пустая строка. Для создания пустой строки мы пишем s = '' или s = "" .
Пустая строка – это аналог числа 0 .
Длина строки. Для определения длины строки (количества символов) мы
используем встроенную функцию len() :
s = 'Hello'
n = len(s) # значение переменной равно 5
print(n)

Конкатенация и умножение на число. Операторы + и * можно

использовать для строк. Оператор + сцепляет две и более строк. Это
называется конкатенацией строк. Оператор * повторяет строку указанное
количество раз.

Выражение Результат

'AB' + 'cd' 'ABcd'

'A' + '7' + 'B' 'A7B'

 Выражение Результат

'Hi'* 4 'HiHiHiHi'

Оператор принадлежности in . С помощью оператора in мы можем

проверять, находится ли одна строка в составе другой. То есть, является ли
одна строка подстрокой другой:
s = 'All you need is love'
if 'love' in s:
print('❤️')
else:
print('💔')

Так как строка s содержит подстроку 'love' , то будет выведен смайлик ❤️.

В Python можно использовать смайлики emoji👍

Индексация строк
Очень часто бывает необходимо обратиться к конкретному символу в строке.
Для этого в Python используются квадратные скобки [] , в которых
указывается индекс (номер) нужного символа в строке.

Пусть s = 'Python' . Таблица ниже показывает, как работает индексация:

Выражение Результат Пояснение

s[0] P первый символ строки

s[1] y второй символ строки

s[2] t третий символ строки

s[3] h четвертый символ строки

s[4] o пятый символ строки

s[5] n шестой символ строки

 Обратите внимание, первый символ строки равен s[0] , а не s[1] . В
Python индексация начинается с 0 , по аналогии с функцией range(n) ,
которая генерировала последовательность натуральных чисел от 0 до n -
1.

В отличие от многих языков программирования, в Python есть возможность

работы с отрицательными индексами. Если первый символ строки имеет
индекс 0 , то последнему элементу присваивается индекс -1 .

Выражение Результат Пояснение

s[-6] P первый символ строки

s[-5] y второй символ строки

s[-4] t третий символ строки

s[-3] h четвертый символ строки

s[-2] o пятый символ строки

s[-1] n шестой символ строки

Таким образом, получаем

Положительные индексы 0 1 2 3 4 5

Строка P y t h o n

Отрицательные индексы -6 -5 -4 -3 -2 -1

Частая ошибка у начинающих программистов — обращение по

несуществующему индексу в строке.
Например, если s = 'Python' , и мы попытаемся обратиться к s[17] , то мы
получим ошибку:
IndexError: string index out of range
Ошибка возникает, поскольку строка содержит всего 66 символов.

Обратите внимание: если длина строки s равна len(s) , то при

положительной нумерации слева направо, последний элемент имеет индекс
равный len(s) - 1 , а при отрицательной индексации справа налево, первый
элемент имеет индекс равный -len(s) .

Итерирование строк
Очень часто нужно просканировать всю строку целиком, обрабатывая
каждый ее символ. Для этого удобно использовать цикл for . Напишем
программу, которая выводит каждый символ строки на отдельной строке:
s = 'abcdef'
for i in range(len(s)):
print(s[i])

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

a
b
c
d
e
f

Мы передаем в функцию range() длину строки len(s) . В нашем случае

длина строки s , равна 66. Таким образом, вызов
функции range(len(s)) имеет вид range(6) и переменная
цикла i последовательно перебирает все значения от 00 до 55. Это
означает, что выражение s[i] последовательно вернет все символы
строки s . Такой способ итерации строки удобен, когда нам нужен не только
сам элемент s[i] , но и его индекс i .

Если нам не нужен индекс самого символа, то мы можем использовать более

короткий способ итерации:

s = 'abcdef'

for c in s:

print(c)
Этот цикл пройдет по строке s , придавая переменной цикла c значение
каждого символа (!) в отличие от предыдущего цикла, в котором переменная
цикла «бегала» по индексам строки.

Обратите внимание на обозначение переменных цикла. В первом

цикле мы используем имя i , что соответствует стандартной идеологии
наименования переменных цикла. Во втором цикле, мы назвали переменную
буквой c – первая буква слова char (символ).

Глоссарий
✅ Для создания строк используются парные кавычки '' или "" .

✅ Для считывания текстовых данных в строковую переменную используется

функция input() .

✅ Для определения длины строки (количества символов) используется

встроенная функция len() .

✅Операторы + и * можно использовать для строк.

Оператор + сцепляет две и более строк. Это называется конкатенацией
строк. Оператор * повторяет строку указанное количество раз.

✅ Оператор принадлежности in . С помощью оператора in можно

проверять, находится ли одна строка в составе другой.

✅ Индексация строк – обращение к конкретному символу в строке по его

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

✅ Обращение по несуществующему индексу приводит к ошибке.

✅ Для обхода строки удобно использовать цикл for :

s = 'abcdef'
for i in range(len(s)): # перебор символов по индексам
print(s[i])
s = 'abcdef'
for c in s: # перебор символов напрямую
print(c)

9.2 Срезы
1. Срезы строк
2. Изменение символов строки
3. Решение задач

Аннотация. Снова строковый тип данных. Учимся делать строковые срезы, а

также изменять символы в строке.

Срезы строк
В предыдущем уроке мы научились работать с конкретными символами
строки с помощью индексов [] . Иногда необходимо работать с целыми
частями строки, в таком случае мы используем срезы (slices). Срезы похожи
на комбинацию индексации и функции range() .

Рассмотрим строку s = 'abcdefghij' .

Положительные индексы 0 1 2 3 4 5 6 7 8 9

Строка a b c d e f g h i j

Отрицательные индексы -10 -9 -8 -7 -6 -5 -4 -3 -2 -1

С помощью среза мы можем получить несколько символов исходной строки,

создав диапазон индексов разделенных двоеточием s[x:y] .
Приведённый ниже код:
print(s[2:5])
print(s[0:6])
print(s[2:7])

выводит:
cde
abcdef
cdefg

При построении среза s[x:y] первое число – это то место, где начинается
срез (включительно), а второе – это место, где заканчивается срез
(невключительно). Разрезая строки, мы создаем подстроку, которая по сути
является строкой внутри другой строки.

Срез до конца, от начала

Если опустить второй параметр в срезе s[x:] (но поставить двоеточие), то
срез берется до конца строки. Аналогично если опустить первый
параметр s[:y] , то можно взять срез от начала строки. Срез s[:] совпадает
с самой строкой s .
Приведённый ниже код:
print(s[2:])
print(s[:7])

выводит:
cdefghij
abcdefg
 Срез s[:] возвращает исходную строку.

Отрицательные индексы в срезе

Мы также можем использовать отрицательные индексы для создания срезов.
Как уже говорилось ранее, отрицательные индексы строки начинаются с -
1 и отсчитываются до достижения начала строки. При использовании
отрицательных индексов первый параметр среза должен быть меньше
второго, либо должен быть пропущен.
Приведённый ниже код:
print(s[-9:-4])
print(s[-3:])
print(s[:-3])

выводит:
bcdef
hij
abcdefg
 Удалить из строки последний символ можно при помощи среза s[:-
1] .

Шаг среза
Мы можем передать в срез третий необязательный параметр, который
отвечает за шаг среза. К примеру, срез s[1:7:2] создаст
строку bdf состоящую из каждого второго символа (индексы 1, 3, 5 ,
правая граница не включена в срез).

Отрицательный шаг среза

Если в качестве шага среза указать отрицательное число, то символы
будут идти в обратном порядке.
Приведённый ниже код:
print(s[::-1])

выводит:
jihgfedcba

Приведённый ниже код:

print(s[1:7:2])
print(s[3::2])
print(s[:7:3])
 print(s[::2])
print(s[::-1])
print(s[::-2])

выводит:
bdf
dfhj
adg
acegi
jihgfedcba
jhfdb

Подводя итог

s = 'abcdefghij'

Программный код Результат Пояснение

s[2:5] cde строка состоящая из символов с индексами 2, 3, 4

s[:5] abcde первые пять символов строки

s[5:] fghij строка состоящая из символов с индексами от 5 до конца

s[-2:] ij последние два символа строки

s[:] abcdefghij вся строка целиком

s[1:7:2] bdf строка, состоящая из каждого второго символа с индексами от 1 до 6

s[::-1] jihgfedcba строка в обратном порядке, так как шаг отрицательный

Изменение символа строки по индексу

Предположим, у нас есть строка s = 'abcdefghij' и мы хотим заменить
символ с индексом 4 на 'X' . Можно попытаться написать код:

s[4] = 'X'

Однако такой код не работает. В Python строки являются неизменяемыми,

то есть мы не можем менять их содержимое с помощью индексатора.
Если мы хотим поменять какой-либо символ строки s , мы должны создать
новую строку. Следующий код использует срезы и решает поставленную
задачу:

s = s[:4] + 'X' + s[5:]

Мы создаем два среза: от начала строки до 3 символа и с 5 символа по конец

строки, а между ними вставляем нужный нам символ, который встанет на 4
позицию.

Примечания
Примечание 1. Синтаксис срезов строк очень похож на синтаксис
функции range() .

Примечание 2. Если первый параметр среза больше второго, то срез

создает пустую строку.

Примечание 3. Обратите внимание: срез возвращает новую строку. Поэтому

мы можем написать несколько срезов подряд.
Приведённый ниже код:
s = 'abcdefghij'

print(s[2:][:-2])
print(s[1::2][::-1][:3])

выводит:
cdefgh
jhf

Глоссарий
✅ Срезы (slices) используются для работы с частями строки. С помощью
среза можно получить несколько символов исходной строки, создав
диапазон индексов разделенных двоеточием:

 при построении среза s[x:y] первое число – это то место, где

начинается срез (включительно), а второе – это место, где
заканчивается срез (невключительно)
 если опустить второй параметр в срезе s[x:] (но поставить
двоеточие), то срез берется до конца строки
 если опустить первый параметр s[:y] , то можно взять срез от начала
строки
  срез s[:] совпадает с самой строкой s
 можно передать в срез третий необязательный параметр, который
отвечает за шаг среза

✅ При использовании отрицательных индексов первый параметр среза

должен быть меньше второго, либо должен быть пропущен.

✅ Если в качестве шага среза указать отрицательное число, то символы

будут идти в обратном порядке.
9.3 Методы строк. Часть 1
1. Метод capitalize()
2. Метод swapcase()
3. Метод title()
4. Метод lower()
5. Метод upper()
6. Решение задач

Аннотация. Строковый тип данных, основные методы конвертации регистра.

Методы и функции
Мы уже знакомы с некоторыми встроенными
функциями: min() , max() , len() , int() , float() и так далее. Метод –
специализированная функция, тесно связанная с объектом. Как и функция,
метод вызывается для выполнения отдельной задачи, но он вызывается для
определенного объекта и “знает” о своем целевом объекте во время
выполнения.

Таким образом: метод — функция, применяемая к объекту. В данном случае к

строке. Метод вызывается в виде имя_объекта.имя_метода(параметры) .

Например, [Link]('e') — это применение к строке s метода find с одним

параметром 'e' .

Методы строкового типа данных можно разделить на три группы:

1. Конвертация регистра;
2. Поиск и замена;
3. Классификация символов.

Конвертация регистра
Методы в этой группе выполняют преобразование регистра для строк.

Метод capitalize()
Метод capitalize() возвращает копию строки s , в которой первый символ
имеет верхний регистр, а все остальные символы имеют нижний регистр.
Приведённый ниже код:
s = 'foO BaR BAZ quX'
print([Link]())

выводит:
Foo bar baz qux
Символы, не являющиеся буквами алфавита, остаются неизменными.
Приведённый ниже код:
s = 'foo123#BAR#.'
print([Link]())

выводит:
Foo123#bar#.

Метод swapcase()
Метод swapcase() возвращает копию строки s , в которой все символы,
имеющие верхний регистр, преобразуются в символы нижнего регистра и
наоборот.
Приведённый ниже код:
s = 'FOO Bar 123 baz qUX'
print([Link]())

выводит:
foo bAR 123 BAZ Qux

Метод title()
Метод title() возвращает копию строки s , в которой
первый символ каждого слова переводится в верхний регистр.
Приведённый ниже код:
s = 'the sun also rises'
print([Link]())

выводит:
The Sun Also Rises

Этот метод использует довольно простой алгоритм: он не пытается

различить важные и неважные слова и не обрабатывает аббревиатуры и
апострофы.
Приведённый ниже код:
s = "what's happened to ted's IBM stock?"
print([Link]())

выводит:
What'S Happened To Ted'S Ibm Stock?

Метод lower()
Метод lower() возвращает копию строки s , в которой все символы имеют
нижний регистр.
Приведённый ниже код:
s = 'FOO Bar 123 baz qUX'
print([Link]())

выводит:
foo bar 123 baz qux

Метод upper()
Метод upper() возвращает копию строки s , в которой все символы имеют
верхний регистр.
Приведённый ниже код:
s = 'FOO Bar 123 baz qUX'
print([Link]())

выводит:
FOO BAR 123 BAZ QUX

Примечания
Примечание 1. Обратите внимание на то, что строковые методы не
изменяют исходную строку: вместо этого они возвращают новую строку.
Приведённый ниже код:
song = 'the show must go on'
[Link]()

print(song)

выводит:
the show must go on

Для изменения значения определённой переменной необходимо явно

присвоить ей результат вызова строкового метода.
Приведённый ниже код:
song = 'the show must go on'
song = [Link]()

print(song)

выводит:
The Show Must Go On

Примечание 2. Англо-русский словарик:

 capitalize – писать прописными буквами, закрепить

 swapcase – обменять регистр. swap – гл. обмениваться, case – случай,
регистр, падеж, дело, расследование
 title – заголовок, титул
 lower – нижний
 upper – верхний

Глоссарий
✅ Метод — это функция, применяемая к объекту.

✅ Метод вызывается в виде:

имя_объекта.имя_метода(параметры)

✅ Методы строкового типа данных можно разделить на три группы:

1. Конвертация регистра;
2. Поиск и замена;
3. Классификация символов.

✅ Метод capitalize() возвращает копию строки s , в которой первый символ

имеет верхний регистр, а все остальные символы имеют нижний регистр.

✅ Метод swapcase() возвращает копию строки s , в которой все символы,

имеющие верхний регистр, преобразуются в символы нижнего регистра и
наоборот.

✅ Метод title() возвращает копию строки s , в которой

первый символ каждого слова переводится в верхний регистр.

✅ Метод lower() возвращает копию строки s , в которой все символы имеют

нижний регистр.

✅ Метод upper() возвращает копию строки s , в которой все символы имеют

верхний регистр.
✅ Строковые методы не изменяют исходную строку: вместо этого
они возвращают новую строку.

9.4 Методы строк. Часть 2

1. Методы count()
2. Метод startswith()
3. Метод endswith()
4. Метод find()
5. Метод rfind()
6. Метод index()
7. Метод rindex()
8. Метод strip()
9. Метод lstrip()
10. Метод rstrip()
11. Метод replace()

Аннотация. Строковый тип данных, основные методы поиска и замены.

Поиск и замена
Методы поиска и замены строк внутри других строк.

Многие методы в этой группе поддерживают необязательные

аргументы <start> и <end> . Как и в строковых срезах, действие таких
методов ограничено частью исходной строки, начинающейся с позиции
символа <start> и продолжающейся вплоть до позиции символа <end> , но
не включающей её. Если параметр <start> указан, а параметр <end> нет, то
метод применяется к части исходной строки от <start> до конца строки.
Если параметры не заданы, то подразумевается, что <start> = 0 , <end> =
len(s) .

Метод count()
Метод count(<sub>, <start>, <end>) считает
количество непересекающихся вхождений подстроки <sub> в исходную
строку s .
Приведённый ниже код:
s = 'foo goo moo'
print([Link]('oo'))
print([Link]('oo', 0, 8)) # подсчет с 0 по 7 символ

выводит:
3
2

Метод startswith()
Метод startswith(<prefix>, <start>, <end>) определяет, начинается ли
исходная строка s подстрокой <prefix> . Метод возвращает значение True ,
если исходная строка начинается с подстроки <prefix> , или False в
противном случае.
Приведённый ниже код:
s = 'foobar'
print([Link]('foo'))
print([Link]('baz'))

выводит:
True
False

Метод endswith()
Метод endswith(<suffix>, <start>, <end>) определяет, оканчивается ли
исходная строка s подстрокой <suffix> . Метод возвращает значение True ,
если исходная строка оканчивается на подстроку <suffix> , или False в
противном случае.
Приведённый ниже код:
s = 'foobar'
print([Link]('bar'))
print([Link]('baz'))

выводит:
True
False

Методы find(), rfind()

Метод find(<sub>, <start>, <end>) находит индекс первого
вхождения подстроки <sub> в исходной строке s . Если строка s не
содержит подстроки <sub> , то метод возвращает значение -1 . Мы можем
использовать данный метод наравне с оператором in для проверки:
содержит ли заданная строка некоторую подстроку или нет.
Приведённый ниже код:
s = 'foo bar foo baz foo qux'
print([Link]('foo'))
print([Link]('bar'))
print([Link]('qu'))
print([Link]('python'))

выводит:
0
4
20
-1

Метод rfind(<sub>, <start>, <end>) идентичен методу find(<sub>, <start>,

<end>) , за тем исключением, что он ищет первое вхождение
подстроки <sub> , начиная с конца строки s .

Методы index(), rindex()

Метод index(<sub>, <start>, <end>) идентичен методу find(<sub>, <start>,
<end>) , за тем исключением, что он вызывает ошибку ValueError:
substring not found во время выполнения программы, если
подстрока <sub> не найдена.

Метод rindex(<sub>, <start>, <end>) идентичен методу index(<sub>,

<start>, <end>) , за тем исключением, что он ищет первое вхождение
подстроки <sub> , начиная с конца строки s .

Методы find() и rfind() являются более безопасными,

чем index() и rindex() , так как не приводят к возникновению ошибки во
время выполнения программы.

Метод strip()
Метод strip() возвращает копию строки s , у которой удалены все пробелы,
стоящие в начале и конце строки.
Приведённый ниже код:
s = ' foo bar foo baz foo qux '
print([Link]())

выводит:
foo bar foo baz foo qux

Метод lstrip()
Метод lstrip() возвращает копию строки s , у которой удалены все
пробелы, стоящие в начале строки.
Приведённый ниже код:
s = ' foo bar foo baz foo qux '
print([Link]())

выводит (символом ⎵ обозначены пробелы):

foo bar foo baz foo qux⎵⎵⎵⎵⎵⎵

Метод rstrip()
Метод rstrip() возвращает копию строки s , у которой удалены все
пробелы, стоящие в конце строки.
Приведённый ниже код:
s = ' foo bar foo baz foo qux '
print([Link]())

выводит (символом ⎵ обозначены пробелы):

⎵⎵⎵⎵⎵⎵foo bar foo baz foo qux

Метод replace()
Метод replace(<old>, <new>) возвращает копию s со всеми вхождениями
подстроки <old> , заменёнными на <new> .
Приведённый ниже код:
s = 'foo bar foo baz foo qux'
print([Link]('foo', 'grault'))

выводит:
grault bar grault baz grault qux

Метод replace() может принимать необязательный третий

аргумент <count> , который определяет количество замен.
Приведённый ниже код:
s = 'foo bar foo baz foo qux'
print([Link]('foo', 'grault', 2))

выводит:
grault bar grault baz foo qux

Примечания
Примечание 1. Методы strip() , lstrip() , rstrip() могут принимать на
вход необязательный аргумент <chars> . Необязательный аргумент <chars> –
это строка, которая определяет набор символов для удаления.
Приведённый ниже код:
s = '-+-+abc+-+-'

print([Link]('+-'))
print([Link]('+-'))
print([Link]('+-'))

выводит:
abc
-+-+abc
abc+-+-

Примечание 2. Обратите внимание: в Python не принято писать == True при

сравнении с выражениями, возвращающими булево значение
( True или False ). Следующие строки кода являются эквивалентными:
s = '[Link]
print([Link]('.ru') == True)

s = '[Link]
print([Link]('.ru'))

В первом случае [Link]('.ru') уже возвращает булево значение

( True или False ), и мы просто лишний раз
сравниваем True или False с True . Во втором случае код короче и читается
проще.
 Глоссарий
✅ Методы поиска и замены строк внутри других строк поддерживают
необязательные аргументы <start> и <end> . Действие методов ограничено
частью исходной строки, начинающейся с позиции символа <start> и
продолжающейся вплоть до позиции символа <end> , но не включающей её.
Если параметр <start> указан, а параметр <end> нет, то метод применяется
к части исходной строки от <start> до конца строки. Если параметры не
заданы, то подразумевается, что <start> = 0 , <end> = len(s) .
✅ Метод count(<sub>, <start>, <end>) считает
количество непересекающихся вхождений подстроки <sub> в исходную
строку s .
✅ Метод startswith(<prefix>, <start>, <end>) определяет, начинается ли
исходная строка s подстрокой <prefix> . Метод возвращает значение True ,
если исходная строка начинается с подстроки <prefix> , или False в
противном случае.
✅ Метод endswith(<suffix>, <start>, <end>) определяет, оканчивается ли
исходная строка s подстрокой <suffix> . Метод возвращает значение True ,
если исходная строка оканчивается на подстроку <suffix> , или False в
противном случае.
✅ Метод find(<sub>, <start>, <end>) находит индекс первого
вхождения подстроки <sub> в исходной строке s . Если строка s не
содержит подстроки <sub> , то метод возвращает значение -1 .
✅ Метод rfind(<sub>, <start>, <end>) идентичен методу find(<sub>,
<start>, <end>) , за тем исключением, что он ищет первое вхождение
подстроки <sub> , начиная с конца строки s .
✅ Метод index(<sub>, <start>, <end>) идентичен методу find(<sub>,
<start>, <end>) , за тем исключением, что он вызывает ошибку ValueError:
substring not found во время выполнения программы, если
подстрока <sub> не найдена.
✅ Метод rindex(<sub>, <start>, <end>) идентичен методу index(<sub>,
<start>, <end>) , за тем исключением, что он ищет первое вхождение
подстроки <sub> , начиная с конца строки s .
✅ Метод strip() возвращает копию строки s , у которой удалены все
пробелы, стоящие в начале и конце строки.
✅ Метод lstrip() возвращает копию строки s , у которой удалены все
пробелы, стоящие в начале строки.
✅ Метод rstrip() возвращает копию строки s , у которой удалены все
пробелы, стоящие в конце строки.
✅ Метод replace(<old>, <new>) возвращает копию s со всеми вхождениями
подстроки <old> , заменёнными на <new> .
✅ Методы strip() , lstrip() , rstrip() могут принимать на вход
необязательный аргумент <chars> . Необязательный аргумент <chars> – это
строка, которая определяет набор символов для удаления.