---
title: Учебник Python v 1.3
excerpt: Дополнительные задачи соедней сложности 
date: '2023-10-17'
tags:
  - Информатика
  - Программирование
  - Python
  - Задачи
---

<TableOfContents>

- [1. Ввод и вывод данных в Python](#1-ввод-и-вывод-данных-в-python)
- [2. Операторы в Python](#2-операторы-в-python)
- [3. Условный оператор в Python](#3-условный-оператор-в-python)
- [4. Цикл for в Python](#4-цикл-for-в-python)

</TableOfContents>

## 1. Ввод и вывод данных в Python

Переменная - это именованный контейнер для заданного значения.

```python

# Пример создания переменных
age = 19
name = 'Ivan'
isActive = True

```

```python

name = 'Petr'
Name = 'Ivan'

# name и Name - это разные переменные

```

```python
# Имена переменных не могут начинаться с цифры!
```

В Python есть 4 примитивных типа данных:

```python

# int (целые числа)
age = 18

# float (дробные числа)
fraction = 2.5

# str (строки)
fruit = 'apple'

# bool (правда или ложь)
isReady = True # всего два значения: True и False

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

```python

age = '22' # str -> '22'
age = int(age) # int -> 22
age = float(age) # float -> 22.0
age = bool(age) # bool -> True

```

Функция print() выводит данные на экран.

```python

name = 'Alexey'
# В скобках записываются переданные в функцию параметры
print(name)

```


```python

# Вывод
>> Alexey

```

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

```python

print(1, 2, 3)

```

```python

# Вывод
>> 1 2 3

```

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

```python

print('Hello')
print('world')

```

```python

# Вывод
>> Hello
>> world

```

Завершающий символ строки в функции print() можно изменять.

```python

print('Hello', end=' ')
print('world')

```

```python

# Вывод
>> Hello world

```

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

```python

name = input()
print('Hello ' + name)
# После запуска скрипта Python будет ожидать ввода данных

```

Функция input может принимать всего лишь один аргумент - строку, которая выведется перед входной строкой.

```python

name = input('Enter your name: ')
print('Hello, ' + name)

```

Данные, полученные с помощью функции input(), имеют строковый тип данных (str).

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


```python

# Сумма двух строчных чисел
number1 = input('Введите число: ')
number2 = input('Введите число: ')
print(number1 + number2)

```

```python

# Ввод:
>> 1
>> 2
# Вывод:
>> 12

```

Преобразуем строковый тип в целое число (str -> int).

```python
# Исправленная сумма двух чисел
number1 = int(input('Введите число: '))
number2 = int(input('Введите число: '))
print(number1 + number2)
```

```python
# Ввод:
>> 1
>> 2
# Вывод:
>> 3
```

## Примеры

1. Произведение


```python

# Произведение двух введенных чисел
a = int(input('Введите число: '))
b = int(input('Введите число: '))
print(a * b)

```

```python

# Ввод:
>> 4
>> 3
# Вывод:
>> 12

```

2. Приветствие

```python

# Приветствие пользователя по его имени
firstname = input('Введите свое имя: ') # здесь приводить к типу int не нужно
lastname = input('Введите свою фамилию: ')
print('Здравствуйте, ' + firstname + ' ' + lastname) # не забудьте про пробел между словами

```

```python

# Ввод:
>> Иван
>> Иванов
# Вывод:
>> Здравствуйте, Иван Иванов

```

3. Остаток

```python

# Операция % позволяет получить остаток от деления
print(10 % 2) # 0, так как 10 делится на 2 нацело
print(10 % 3) # 1, остаток равен 1
print(10 % 4) # 2, остаток равен 2

```

```python

# Вывод:
>> 0
>> 1
>> 2

```

4. Деление нацело

```python

# Операция // позволяет получить целую часть от деления
print(10 // 2) # 5
print(10 // 3) # 3
print(10 // 4) # 2

```

```python

# Вывод:
>> 5
>> 3
>> 2

```

## Решение задач

1. Сумма трех
Посчитайте сумму трех введенных целых чисел

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

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

4. Площадь круга
Пользователь вводит радиус круга, выведите площадь круга

```python

# Ввод:
>> 2
# Вывод:
>> 12.56

```
5. Сумма дробных
Посчитайте сумму трех введенных дробных чисел.

```python

# Ввод:
>> 1.5
>> 2.5
>> 1.1
# Вывод:
>> 5.1

```
6. Школьники и яблоки
n школьников делят k яблок поровну, неделящийся остаток остается в корзинке. Сколько яблок достанется каждому школьнику? Сколько яблок останется в корзинке?

```python
# Ввод:
>> 10
>> 3
# Вывод:
>> 3 # каждому
>> 1 # останется
```

<TableOfContents>

- [1. Ввод и вывод данных в Python](#1-ввод-и-вывод-данных-в-python)
- [2. Операторы в Python](#2-операторы-в-python)
- [3. Условный оператор в Python](#3-условный-оператор-в-python)
- [4. Цикл for в Python](#4-цикл-for-в-python)


</TableOfContents>


## 2. Операторы в Python

В языке программирования Python есть арифметические, логические и операторы сравнения.

Сложение:

```python
# Cложение
print(10 + 30)

```
```python
# Вывод
>> 40
```
Вычитание:
```python
# Вычитание
print(30 - 20)
```
```python
# Вывод
>> 10
```
Умножение:
```python
# Умножение
print(2 * 9)
```
```python
# Вывод
>> 18
```
Деление:
```python
# Деление
print(100 / 25)
```
```python
# Вывод
>> 4
```
Кроме всем знакомой четверки есть и несколько экзотических операторов: взятие остатка от деления, деление нацело, возведение в степень.

Взятие остатка от деления:
```python
# Взятие остатка от деления на 2
print(0 % 2)
print(1 % 2)
print(2 % 2)
print(3 % 2)
print(4 % 2)
```
```python
# Вывод
>> 0 # 0 % 2
>> 1 # 1 % 2
>> 0 # 2 % 2
>> 1 # 3 % 2
>> 0 # 4 % 2
```
```python
# Взятие остатка от деления на 3
print(0 % 3)
print(1 % 3)
print(2 % 3)
print(3 % 3)
print(4 % 3)
print(5 % 3)
print(6 % 3)
```
```python
# Вывод
>> 0 # 0 % 3
>> 1 # 1 % 3
>> 2 # 2 % 3
>> 0 # 3 % 3
>> 1 # 4 % 3
>> 2 # 5 % 3
>> 0 # 6 % 3
```
Деление нацело:
```python
# Деление нацело на 10
print(91 // 10)
print(85 // 10)
print(16 // 10)
print(8 // 10)
```
```python
# Вывод
>> 9 # 91 // 10
>> 8 # 85 // 10
>> 1 # 16 // 10
>> 0 # 8 // 10
```
```python
# Деление нацело на 2
print(14 // 2)
print(15 // 2)
print(7 // 2)
print(6 // 2)
```
```python
# Вывод
>> 7 # 14 // 2
>> 7 # 15 // 2
>> 3 # 7 // 2
>> 3 # 6 // 2
```
Возведение в степень:
```python
# Возведение в степень числа 2
print(2 ** 0) # 1
print(2 ** 1) # 2
print(2 ** 2) # 2 * 2
print(2 ** 3) # 2 * 2 * 2
print(2 ** 4) # 2 * 2 * 2 * 2
```
```python
# Вывод
>> 1
>> 2
>> 4
>> 8
>> 16
```
Операторы сравнения (╮°-°)╮ могут возвращать всего два результата: True и False.

Оператор равенства == возвращает True, если числа равны, и False в противном случае.
```python
a = 10
b = 10
print(a == b)
```
```python
# Вывод
>> True
```
```python
a = 8
b = 7
print(a == b)
```
```python
# Вывод
>> False
```

Оператор неравенства != возвращает True, если числа не равны, и False в противном случае.
```python
a = 8
b = 7
print(a != b)
```
```python
# Вывод
>> True
```
Оператор больше > возвращает True, если первое число больше второго, и False в противном случае.
```python
a = 8
b = 7
print(a > b)
print(b > a)
```
```python
# Вывод
>> True # a > b
>> False # b > a
```
Оператор меньше < возвращает True, если первое число меньше второго, и False в противном случае.
```python
c = 100
d = 200
print(c < d)
print(d < c)
```
```python
# Вывод
>> True # c < d
>> False # d < c

# Оператор меньше или равно <= возвращает True, если первое число меньше второго или равно ему, и False в противном случае.
```
Оператор больше или равно >= возвращает True, если первое число больше второго или равно ему, и False в противном случае.
```python
c = 200
d = 200
print(c >= d)
print(d <= c)
```
```python
# Вывод
>> True # c >= d
>> True # d <= c
```
Иногда требуются выполнение нескольких операторов сравнения сразу. Для таких целей существует оператор and (оператор логического умножения, конъюнкция).
```python
print(10 > 0 and 5 > 0)
print(10 % 2 == 0 and 12 % 2 == 0) # оба числа четные
```
```python
# Вывод:
>> True
>> True
```
Если хотя бы один из операторов равен False, то результат оператора будет равен False. Конъюкция истинна в том случае, когда все условия истинны.
```python
print(10 > 100 and 5 > 0 and 10 > 0) # False
```
```python
# Вывод:
>> False
```
Логическое сложение (дизъюнкция) или оператор or требует выполнения ХОТЯ БЫ одного условия.
```python
print(10 > 100 or 5 > 100 or 10 > 0) # True
print(1 == 0 or 2 == 0) # False, оба условия ложны
```
```python
# Вывод:
>> True
>> False
```
Последний из операторов - это оператор инверсии not. Оператор not изменяет (инвертирует) значение на противоположное.
```python
print(not False) # True
print(not True) # False
print(not 2 == 0) # True
```
```python
# Вывод:
>> True
>> False
>> True
```
Оператор not выполняется в приоритете.
```python
print(not 1 == 0 or 2 == 0) # True, значение первого условия инвертировано
```
```python
# Вывод:
>> True
```
Решение задач
1. Одинаковая четность
Даны два целых числа: A, B. Проверить истинность высказывания: "Числа A и B имеют одинаковую четность".
```python
# Ввод:
>> 0
>> 1
# Вывод:
>> False

# Ввод:
>> 2
>> 10
# Вывод:
>> True
```

2. Одно положительное
Даны три целых числа: A, B, C. Проверить истинность высказывания: "Хотя бы одно из чисел A, B, C положительное".
```python
# Ввод:
>> 0
>> -1
>> -10
# Вывод:
>> False

# Ввод:
>> -1
>> 1
>> 0
# Вывод:
>> True
```
3. Последняя цифра
Дано натуральное число. Выведите его последнюю цифру.
```python
# Ввод:
>> 2345678
# Вывод:
>> 8

# Ввод:
>> 19
# Вывод:
>> 9
```
4. Цифры двузначного
Дано двузначное число. Найдите сумму его цифр.
```python
# Ввод:
>> 22
# Вывод:
>> 4

# Ввод:
>> 99
# Вывод:
>> 18
```
5. Цифры трехзначного
Дано трехзначное число. Найдите сумму его цифр.
```python
# Ввод:
>>123
# Вывод:
>> 6

# Ввод:
>> 332
# Вывод:
>> 8
```
6. Разные цифры
Дано трехзначное число. Проверить истинность высказывания: "Все цифры данного числа различны".
```python
# Ввод:
>> 123
# Вывод:
>> True

# Ввод:
>> 332
# Вывод:
>> False
```
7. Часы (финальный босс)
С начала суток прошло N секунд (N - целое). Найти количество часов, минут и секунд на электронных часах.
```python
# Ввод:
>> 1000
# Вывод:
>> 0 16 40

# Ввод:
>> 10000
# Вывод:
>> 2 46 40

# Ввод:
>> 85001
# Вывод:
>> 23 36 41
```

<TableOfContents>

- [1. Ввод и вывод данных в Python](#1-ввод-и-вывод-данных-в-python)
- [2. Операторы в Python](#2-операторы-в-python)
- [3. Условный оператор в Python](#3-условный-оператор-в-python)
- [4. Цикл for в Python](#4-цикл-for-в-python)

</TableOfContents>

## 3. Условный оператор в Python

Условный оператор выполняет некоторое действие, если указанное условие истинно (равно True).

```python
# Обратите внимание на отступ в четыре (4!) пробела
# или одну табуляцию (кнопочка TAB)
if True: # Обязательное двоеточие перед блоком кода
    print('Условие истинно, поэтому я напечатаюсь')
```
```python
# Вывод
>> Условие истинно, поэтому я напечатаюсь
```
В условии любой тип данных неявно приводится к bool. Пустая строка и ноль равны False.
```python
print(bool(1)) # -> True
print(bool(0)) # -> False
print(bool(10.2)) # -> True
print(bool('')) # -> False
print(bool('Hello')) # -> True
```
Если условие ложно, то код, находящийся под оператором if не выполнится.
```python
if 0: # Обязательное двоеточие перед блоком кода
    print('Я никогда не напечатаюсь :(')
```
Если условие в if ложно, то выполнится оператор под оператором else.
```python
if 0:
    print('Я никогда не напечатаюсь :(')
else:
    print('Оператор else вступает в игру')
```
```python
# Вывод
>> Оператор else вступает в игру
```
Иногда двух вариантов недостаточно, для этого существует оператор elif, а для все остального есть...
```python
age = int(input())
if age < 10:
    print('Ваш возраст - это одна цифра :)')
elif age < 15:
    print('Удачи с геометрией :):):)')
else:
    print('Совсем взрослый уже :(')
```
Если условие в операторе if ложно, то интерпретатор проверяет истинность условия операторов elif, всех по очереди. Если все условия ложны, то выполнится оператор else.

Примеры
1. Четное-нечетное
```python
# Выведите строку 'четное', если введенное число четно, и строку 'нечетное', если число нечетно.
a = int(input())
if a % 2 == 0:
    print('четное')
else:
    print('нечетное')
```
```python
# Ввод
>> 10
# Вывод
>> четное

# Ввод
>> 11
# Вывод
>> нечетное
```
2. Много elif'ов
```python
# Если в вашем коде больше трех elif значит что-то не так и стоит придумать новый алгоритм.
# Это сугубо академический пример, так писать не стоит.
a = int(input('Введите число от одного до 1 до 100'))
if a < 10:
    print('Ваше число меньше 10')
elif a < 20:
    print('Ваше число меньше двадцатки')
elif a < 30:
    print('30 - это потолок')
elif a < 40:
    print('Ваше число меньше 40')
elif a < 50:
    print('Много, но не больше полтинника')
elif a < 60:
    print('Число меньше, чем шесть*десять')
elif a < 70:
    print('Ваше число расположено в восьмом десятке')
elif a < 80:
    print('Ваше число меньше 80')
elif a < 90:
    print('Ваше число находится в 9 десятке')
elif a < 100:
    print('Сотня больше вашего числа')
else:
    print('Хитро, но меня не обманешь, число слишком большое')
```
```python
# Ввод
>> 11
# Вывод
>> Ваше число меньше двадцатки

# Ввод
>> 91
# Вывод
>> Сотня больше вашего числа

# Ввод
>> 58
# Вывод
>> Число меньше, чем шесть*десять
```

3. Белая или черная
```python
# Пользователь вводит два числа: координаты шахматной клетки.
# Выведите YES, если клетка белая, и NO, если - черная.

x = int(input('Введите координату x: '))
y = int(input('Введите координату y: '))
# Идея такая: если четность координат совпадает,
# то это черная клетка, а если - нет, то белая.

if (x + y) % 2 == 1:
    print('YES')
else:
    print('NO')
```
```python
# Ввод:
>> 1
>> 1
# Вывод:
>> NO

# Ввод:
>> 1
>> 1
# Вывод:
>> NO
```
4. Белая или черная (случайные координаты)
```python
# Та же задача, но со случайными числами.
# Координаты шахматной клетки выбираются случайным образом
# Выведите YES, если клетка белая, и NO, если - черная.

from random import randint # импортирование функции randint
x = randint(1,8) # функция randint вернет случайное число от 1 до 8
y = randint(1,8)
print(x, y) # вывод пары случайных чисел

if (x + y) % 2 == 1:
    print('YES')
else:
    print('NO')
```
Решение задач
1. Меньшее из двух
Пользователь вводит два целых числа. Выведите меньшее из них.

2. Четырехзначное?
Пользователь вводит целое число. Выведите YES, если это число является четырехзначным, и NO в противном случае.

3. Треугольник?
Треугольник существует только тогда, когда сумма любых двух его сторон больше третьей. Дано a, b, c - стороны предполагаемого треугольника. Требуется сравнить длину каждого отрезка-стороны с суммой двух других. Если хотя бы в одном случае отрезок окажется больше суммы двух других, то треугольника с такими сторонами не существует.
```python
# Ввод:
>> 3
>> 4
>> 5
# Вывод:
>> YES

# Ввод:
>> 3
>> 10
>> 5
# Вывод:
>> NO
```
4. Время суток
Пользователь вводит время в часах. Если введенное число находится между 5 и 11 часами включительно, выведите строку 'Утро'. Если число лежит в диапазоне от 12 до 17 часов включительно, выведите строку 'День'. Если число находится между 18 и 22, то выведите 'Вечер'. В случае поздней ночи (от 23 до 4 включительно) выведите 'Ночь'. В остальных случаях выведите строку 'Ошибка'.
```python
# Ввод:
>> 3
# Вывод:
>> Ночь

# Ввод:
>> 6
# Вывод:
>> Утро

# Ввод:
>> 13
# Вывод:
>> День

# Ввод:
>> 2020
# Вывод:
>> Ошибка
```
5. День недели
Пользователь вводит номер дня недели. Выведите строку 'Выходные', если введенное число равно 6 или 7. В случае, если число лежит в диапазоне от 1 до 5 включительно, выведите строку 'Будни'.
```python
# Ввод:
>> 3
# Вывод:
>> Будни

# Ввод:
>> 6
# Вывод:
>> Выходные
```
6. Описание числа
Пользователь вводит целое число. Выведите его строку-описание вида "отрицательное четное число", "ноль", "положительное нечетное число", например, численным описанием числа 190 является строка "положительное четное число".

```python
# Ввод:
>> 1
# Вывод:
>> положительное нечетное число

# Ввод:
>> 06
# Вывод:
>> отрицательное четное число

# Ввод:
>> 0
# Вывод:
>> ноль

# Ввод:
>> 2
# Вывод:
>> положительное четное число
```
7. Конь (финальный босс)
Шахматный конь ходит буквой "Г" - на две клетки по вертикали в любом направлении и на одну клетку по горизонтали, или наоборот. Даны две различные клетки шахматной доски, определите, может ли конь попасть с первой клетки на вторую одним ходом. В случае, если хотя бы одно из введенных чисел не лежит в диапазоне от 1 до 8, выведите строку "Ошибка!".
```python
# Ввод:
>> 1 # координата x1
>> 1 # координата y1
>> 2 # координата x2
>> 2 # координата y2
# Вывод:
>> NO

# Ввод:
>> 1 # координата x1
>> 1 # координата y1
>> 3 # координата x2
>> 2 # координата y2
# Вывод:
>> YES

# Ввод:
>> 3 # координата x1
>> 8 # координата y1
>> 2 # координата x2
>> 6 # координата y2
# Вывод:
>> YES

# Ввод:
>> 3 # координата x1
>> 4 # координата y1
>> 5 # координата x2
>> 6 # координата y2
# Вывод:
>> YES
```

<TableOfContents>

- [1. Ввод и вывод данных в Python](#1-ввод-и-вывод-данных-в-python)
- [2. Операторы в Python](#2-операторы-в-python)
- [3. Условный оператор в Python](#3-условный-оператор-в-python)
- [4. Цикл for в Python](#4-цикл-for-в-python)

</TableOfContents>

## 4. Цикл for в Python

Цикл в любом языке программирования - это многократное выполнение одного и то же действия.

В Python все немного не так. Здесь цикл for - это цикл перебора последовательности. Он состоит из двух компонент: переменной (переменных) цикла и последовательности. Приведу пример:
```python
for item in 'one', 'two', 'three':
    print(item)
```
В приведенном выше примере переменная цикла item по очереди принимает каждое значение последовательности, которая записана после служебного слова in. На первом повторении переменная item равна строке 'one', на втором - строке 'two', на третьем - строке 'three'.
```python
# Вывод:
>> one
>> two
>> three
```
Еще несколько примеров:
```python
for element in '1', 'hello', 2, 1990, True, False:
    print(element)
```
```python
# Вывод:
>> 1
>> hello
>> 2
>> 1990
>> True
>> False
```
```python
for letter in 'Hello world':
    print(letter)
```
```python
>> H
>> e
>> l
>> l
>> o
>>
>> w
>> o
>> r
>> l
>> d
```
Функция range()

Функция range() возвращает диапазон (последовательность) целых чисел. range() может принимать 1, 2 или 3 аргумента.

Примеры функции range() с одним аргументом:
```python
# range() с одним аргументом

print('range(3) -> 0, 1, 2')
for x in range(3): # range(3) -> 0, 1, 2
    print(x)

print('range(5) -> 0, 1, 2, 3, 4')
for x in range(5): # range(5) -> 0, 1, 2, 3, 4
    print(x)

# range(1) -> 0
# range(6) -> 0, 1, 2, 3, 4, 5
# range(10) -> 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
```
```python
# Вывод:
>> range(3) -> 0, 1, 2
>> 0
>> 1
>> 2
>> range(5) -> 0, 1, 2, 3, 4
>> 0
>> 1
>> 2
>> 3
>> 4
```
Примеры функции range() с двумя аргументами:
```python
print('range(3, 5) -> 3, 4')
for x in range(3, 5): # range(3, 5) -> 3, 4
    print(x)

print('range(1, 5) -> 1, 2, 3, 4')
for x in range(1, 5): # range(1, 5) -> 1, 2, 3, 4
    print(x)

# range(2, 7) -> 2, 3, 4, 5, 6
# range(100, 105) -> 100, 101, 102, 103, 104
# range(50, 53) -> 50, 51, 52
```
```python
# Вывод:
>> range(3, 5) -> 3, 4
>> 3
>> 4
>> range(1, 5) -> 1, 2, 3, 4
>> 1
>> 2
>> 3
>> 4
```
Примеры функции range() с тремя аргументами:
```python
print('range(0, 10, 2) -> 0, 2, 4, 6, 8')
for x in range(0, 10, 2): # range(0, 10, 2) -> 0, 2, 4, 6, 8
    print(x)

print('range(1, 10, 2) -> 1, 3, 5, 7, 9')
for x in range(1, 10, 2): # range(1, 10, 2) -> 1, 3, 5, 7, 9
    print(x)

print('range(10, 20, 3) -> 10, 13, 16, 19')
for x in range(10, 20, 3): # range(10, 20, 3) -> 10, 13, 16, 19
    print(x)

# range(2, 7, 5) -> 2
# range(1, 8, 4) -> 1, 5
# range(4, 20, 5) -> 4, 9, 14, 19
```
```python
>> range(0, 10, 2) -> 0, 2, 4, 6, 8
>> 0
>> 2
>> 4
>> 6
>> 8
>> range(1, 10, 2) -> 1, 3, 5, 7, 9
>> 1
>> 3
>> 5
>> 7
>> 9
>> range(10, 20, 3) -> 10, 13, 16, 19
>> 10
>> 13
>> 16
>> 19
```
Решение задач
1. Вывод чисел от 0 до N
Пользователь вводит число N. Выведите все числа от 0 до N включительно.
```python
# Ввод:
>> 4
# Вывод:
>> 0
>> 1
>> 2
>> 3
>> 4
```
2. Вывод чисел от K до N
Пользователь вводит числа K и N. Выведите все числа от K до N включительно.
```python
# Ввод:
>> 2
>> 7
# Вывод:
>> 2
>> 3
>> 4
>> 5
>> 6
>> 7
```
3. Сумма от K до N
Пользователь вводит числа K и N. Выведите сумму чисел от K до N включительно.
```python
# Ввод:
>> 1
>> 5
# Вывод:
>> 15
```
4. Сумма четных от K до N
Пользователь вводит числа K и N. Выведите сумму только четных чисел от K до N включительно.
```python
# Ввод:
>> 1
>> 5
# Вывод:
>> 6 # 2 + 4
```
5. Сумма дробей (часть первая)
Пользователь вводит число N. Найдите сумму чисел: 1 + 1.1 + 1.2 + 1.3 + ... + (1 + N / 10).
```python
# Ввод:
>> 5
# Вывод:
>> 7.5
```
6. Сумма дробей (часть вторая)
Пользователь вводит число N. Найдите сумму чисел: 1 + 1/2 + 1/3 + ... + 1/N
```python
# Ввод:
>> 5
# Вывод:
>> 2.283
```
Цикл while в Python
Назад в начало
Цикл while ("пока") позволяет выполнить одну и ту же последовательность действий, пока проверяемое условие истинно. Условие записывается после ключевого слова while и проверяется до выполнения тела цикла.

Цикл while используется, когда невозможно определить точное количество повторений цикла.
```python
i = 0 # объявление переменной i для условия цикла
while i < 5: # ключевое слово 'while' и условие выполнение цикла
    # тело цикла
    print(i) # вывод значения переменной i
    i += 1 # увеличение значения переменной i на единицу
```
```python
# Вывод:
>> 0
>> 1
>> 2
>> 3
>> 4
```
Цикл while может быть бесконечным.
```python
i = 0
while True: # условие всегда истинно
    print(i)
    i += 1
```
```python
# Вывод:
>> 0
>> 1
>> 2
>> 3
>> 4
...
>> 999
...
# Это может продолжаться долго...
```
Выполнение цикла можно прерывать с помощью оператора break.
```python
i = 0
while 1: # условие всегда истинно
    if i == 3: # если i равно 3, то вызываем оператор break
        break # оператор break прерывает выполнение цикла
    print(i)
    i += 1
```
```python
# Вывод:
>> 0
>> 1
>> 2
```
Оператор continue начинает повторение цикла заново.
```python
i = 0
while i < 5:
    i += 1 #
    if i % 2 == 1: # если значение i нечетно, то вызываем оператор continue
        continue # оператор continue начинает повторение цикла заново
    # в случае вызова continue код ниже не выполнится
    print(i)
```
```python
# Вывод:
>> 0
>> 2
>> 4
```
Как и для цикла for, для цикла while мы можем записать конструкцию else.
```python
x = 1
while x < 5:
    print(x)
    x += 1
else:
    print('Цикл завершен')
```
```python
# Вывод:
>> 1
>> 2
>> 3
>> 4
>> Цикл завершен
```
Примеры
1. Числа от A до B
```python
# Пользователь вводит числа A и B (A > B). Выведите все числа от A до B включительно.
A = int(input('Введите число: '))
B = int(input('Введите число: '))

while A >= B:
    print(A)
    A -= 1
```
```python
# Ввод:
>> 12
>> 7
# Вывод:
>> 12
>> 11
>> 10
>> 9
>> 8
>> 7

# Ввод:
>> 5
>> 2
# Вывод:
>> 5
>> 4
>> 3
>> 2
```
2. Много чисел
```python
# Пользователь вводит числа до тех пор, пока не введет 0.
# Выведите количество введенных чисел (0 считать не нужно).
n = int(input('Введите число: '))
counter = 0 # счетчик введенных чисел
while n: # n неявно преобразуется в тип bool
    # если n равно 0, то выполнение цикла прервется
    n = int(input('Введите число: ')) # вводим очередное число
    counter += 1 # увеличиваем счетчик

print(f'Количество чисел {counter}')
```
```python
# Ввод:
>> 1
>> 10
>> 100
>> 1000
>> 0
# Вывод:
>> Количество чисел 4
```
3. Наименьший делитель
```python
# Пользователь вводит число N (N > 1). Выведите его наименьший делитель.
N = int(input('Введите число: '))
div = 2

while N % div != 0:
    div += 1
print(f'Наименьший делитель равен {div}')
```
```python
# Ввод:
>> 10
# Вывод:
>> Наименьший делитель равен 2
```
```python
# Ввод:
>> 15
# Вывод:
>> Наименьший делитель равен 3
```
```python
# Ввод:
>> 17
# Вывод:
>> Наименьший делитель равен 17
```
Решение задач
1. Четные от A до B
Пользователь вводит числа A и B (A > B). Выведите четные числа от A до B включительно.
```python
# Ввод:
>> 10
>> 1
# Вывод:
>> 10
>> 8
>> 6
>> 4
>> 2
```
2. От A до B на три
Пользователь вводит числа A и B (A < B, A меньше B). Выведите числа от A до B включительно, которые делятся на три.
```python
# Ввод:
>> 1
>> 15
# Вывод:
>> 3
>> 6
>> 9
>> 12
>> 15
```
3. Сумма чисел
Пользователь вводит числа до тех пор, пока не введет 0. Выведите сумму введенных чисел (0 считать не нужно).
```python
# Ввод:
>> 1
>> 15
>> 10
>> 11
>> 2
>> 0
# Вывод:
>> Сумма равна: 39
```
4. Максимум
Пользователь вводит числа до тех пор, пока не введет 0. Выведите максимальное введенное число (0 считать не нужно).
```python
# Ввод:
>> 1
>> 15
>> 10
>> 11
>> 2
>> 0
# Вывод:
>> Максимум равен: 15
```
5. Минимум
Пользователь вводит числа до тех пор, пока не введет 0. Выведите минимальное введенное число (0 считать не нужно).
```python
# Ввод:
>> 1
>> 15
>> 10
>> 11
>> 2
>> 0 # 0 не входит в последовательность
# Вывод:
>> Минимум равен: 1
```

6. Факториал
Пользователь вводит число N. Выведите факториал число N. Факториал числа N - это произведение всех чисел от 1 до N включительно. Например, факториал числа 5 равен 120.
```python
# Ввод:
>> 5
# Вывод:
>> 120
```
```python
# Ввод:
>> 3
# Вывод:
>> 6
```
```python
# Ввод:
>> 4
# Вывод:
>> 24
```
7. Фибоначчи (финальный босс)
Пользователь вводит число N. Выведите N-ное по счету число Фибоначчи. Последовательность чисел Фибоначчи рассчитывается по такой формуле: F(1) = 1, F(2) = 1, F(K) = F(K-2) + F(K-1). Идея такая: каждое следующее число равно сумму двух предыдущих.

Первые 10 чисел последовательности: 1 1 2 3 5 8 13 21 34 55 ...
```python
# Ввод:
>> 5
# Вывод:
>> 5
```
```python
# Ввод:
>> 10
# Вывод:
>> 55
```
```python
# Ввод:
>> 8
# Вывод:
>> 21
```