<jupyter_start><jupyter_text>Блок A1.5 Модуля A1  А1.5.1 Общий синтаксис цикла с параметром До сих пор все наши программы выполняли какое-то определённое действие один раз и применялись к одному объекту. Нередко встречаются ситуации, когда одно и то же действие следует повторить несколько раз и для нескольких объектов.В таких случаях очень полезным инструментом становится **цикл** , который позволяет выполнять однотипные действия множество раз, не дублируя при этом код.В одной из предыдущих задач мы проверяли чётность числа с помощью условий и выводили соответствующую информацию на экран. Вернёмся к этой задаче: что, если нам необходимо проверить на чётность несколько чисел? Повторять код вручную несколько раз, меняя в нём число, было бы не оптимально даже для такой простой задачи.Представим, что нам нужно проверить на чётность все числа в диапазоне от `30` до `41` включительно и вывести результат для каждого из них на экран.<jupyter_code>for i in range(30, 42): # Условия для прохода по циклу
    # Тело цикла
    if i%2 == 0:
        print('Число', i, 'чётное')
    else:
        print('Число', i, 'нечётное')<jupyter_output><empty_output><jupyter_text>В нашем случае цикл _**for**_ прошел по всем целочисленным элементам от `30` до `41` ( _**range(30, 42)**_ ) и для каждого элемента выполнил тело цикла.Для получения диапазона для циклов часто используется функция _**range()**_. **Важно!**По умолчанию нижняя граница диапазона в функции _**range()**_ равна нулю, а не единице, а указанная верхняя граница не включается. Пример	Соответствующий диапазон* `range(10)` => от `0` до `9`* `range(1, 10)` => от `1` до `9`* `range(1, 10, 2)` => от `1` до `9` с шагом `2`, т.е. `1`, `3`, `5`, `7`, `9` И функция _**enumerate()**_ , которая возвращает пары вида «**счётчик-элемент**». Её можно применять, например, к строкам.<jupyter_code>for i, letter in enumerate('Привет!'):
    #Здесь i - номер итерации, а letter - символ номер i из строки 'Привет!'
    print(i, letter)<jupyter_output><empty_output><jupyter_text>**А1.5.1.1 Задание 1**Друзья придумали свой шифр: исходные слова заменять на последовательность нечётных символов в этих словах. Например, ' _`python`_ ' в их шифровке будет выглядеть как ' _`pto`_ '. Напишите программу, которая помогает зашифровывать слова по этой схеме: принимает на вход слово (**`word`**) и последовательно выводит каждый **нечётный** символ в нём.Для проверки используйте **`word = 'подшипник'`**.<jupyter_code>word='подшипник'
for index in range(len(word)):
    if(index % 2 == 0):
        print(word[index])<jupyter_output><empty_output><jupyter_text>**А1.5.1.2 Задание 2**Вы решили написать программу, которая выявляет високосные года в диапазоне лет. Пусть она принимает на вход два числа: нижнюю и верхнюю границы годов (переменные _`year_1`_ и _`year_2`_ ), и для каждого года из диапазона выводит информацию: "**... год високосный**" или "**... год невисокосный**", где вместо многоточия указывается **номер года**.Для проверки используйте **`year_1 = 2013`**, **`year_2 = 2020`**. Значения обеих переменных **должны быть включены в диапазон**.<jupyter_code>#Вариант № 1 (Укороченный)
year_1=2013
year_2=2020
for i in range(year_1, year_2+1):
    if i%4 == 0:
        print(i, 'год високосный')
    else:
        print(i,'год невисокосный')

#Вариант № 2 (Полный)
year_1 = 2013
year_2 = 2020
for i in range(year_1,year_2+1):
    if i % 4 == 0:
        if i % 100 == 0:
            if  i % 400 == 0:
                print(i,"год високосный")
            else:
                print(i,"год невисокосный")
        else:
            print(i,"год високосный")            
    else:
        print(i,"год невисокосный")<jupyter_output><empty_output><jupyter_text>**А1.5.1.3 Задание 3**Напишите программу, которая принимает на вход слово (**`word`**) и последовательно выводит **все русские гласные** из этого слова.Для проверки используйте **`word = 'Зимушка-зима'`**.<jupyter_code>#Вариант № 1
word = 'Зимушка-зима'
for i, letter in enumerate(word):
    if letter == 'а' or letter == 'и'or letter == 'е' or letter == 'ё' or letter == 'у' or letter == 'о' or letter == 'э' or letter == 'я' or letter == 'ы' or letter == 'ю' :
        print(letter)

#Вариант № 2 (Короткий)
word='Зимушка-зима'
for i, letter in enumerate(word):
    if letter in 'аоиеёэыуюя':
        print(letter)<jupyter_output><empty_output><jupyter_text>**А1.5.1.4 Задание 4**Попросите пользователя ввести своё имя (**`name`**) и с помощью цикла выведите каждую букву этого имени на экран, сопроводив порядковым номером с помощью фразы: "**Буква ... в этом имени - ...**" (например, "**Буква 1 в этом имени - С"**).Для проверки используйте **`name = 'Сергей'`**.<jupyter_code>name='Сергей'
for i, letter in enumerate(name):
    print('Буква',i+1,'в этом имени -',letter)<jupyter_output><empty_output><jupyter_text>**A1.5.1.5 Задание 5**Напишите программу, которая последовательно выводит **нечётные числа**, которые делятся на **`3`** или **`5`**, от первого введённого числа (**`num_1`**) до второго введённого числа (**`num_2`**) включительно. Если **второе число меньше первого** или **первое число меньше нуля**, выведите "**Введён неверный диапазон чисел**".Для проверки используйте **`num_1 = 25`**, **`num_2 = 45`**.<jupyter_code>num_1 = 25
num_2 = 45
if num_1 > num_2 or num_1<0:
    print('Введён неверный диапазон чисел')
else:
    for i in range(num_1, num_2+1):
        if (i%3 == 0 or i%5 == 0) and i%2 == 1:
            print(i)<jupyter_output><empty_output><jupyter_text>А1.5.2 Вычисления в циклах Часто по ходу выполнения цикла бывает нужно не только вывести какую-то информацию, но и провести трансформацию данных. Например, могут быть интересны не сами числа из интервала чисел, а их степени или корни. Циклы, конечно, способны получить и такую информацию.Например, если нам нужно получить сумму корней чисел для диапазона чисел, с этим поможет цикл:<jupyter_code>sum_squares = 0
for i in range(20, 30):
    sum_squares += i**(1/2)
print(sum_squares)<jupyter_output><empty_output><jupyter_text>В этом примере для каждого числа от `20` до `29` включительно выполняется тело цикла, в данном случае это прибавление к переменной **`sum_squares`** корня числа **`i`**, после чего сумма корней выводится на экран.Иногда бывает нужно узнать, когда цикл закончился, например, когда он очень долго выполняется.Для этого можно использовать **`else`**.<jupyter_code>for x in range(6):
    print(x)
else:
    print("Цикл завершен!")<jupyter_output><empty_output><jupyter_text>Здесь тело цикла выполняется для каждого целочисленного _**`x`**_ от **`0`** до **`5`** включительно, а когда цикл завершает свою работу, программа выводит на экран сообщение "**Цикл завершен!**".  Дополнительные примеры1. Для ряда целых чисел от **`10`** до **`25`** нужно вычислить сумму квадратов чисел, делящихся на `2`, и кубов чисел, делящихся на `3`, после чего вывести эти суммы на экран.<jupyter_code>sum_2 = 0
sum_3 = 0
for i in range(10, 26):
    if i%2 == 0:
        sum_2 += i**2
    if i%3 == 0:
        sum_3 += i**3
else:
    print(sum_2, sum_3)<jupyter_output><empty_output><jupyter_text>2. Найти факториал введённого натурального числа.<jupyter_code>number = int(input())

factorial = 1
for i in range(1, number + 1):
    factorial = factorial*i 
else:
    print('Факториал числа', number, 'равен', factorial)<jupyter_output><empty_output><jupyter_text>___**А1.5.2.1 Задание 1**Выведите таблицу квадратов и кубов для чисел от **`1`** до **`10`** включительно. Каждая новая строчка распечатывается через _`print()`_ и имеет формат '**`2 4 8`**', то есть число, затем его квадрат, а затем его куб.<jupyter_code>for i in range(1, 11):
    print(i, i**2, i**3)<jupyter_output><empty_output><jupyter_text>**А1.5.2.2 Задание 2**Напишите программу, которая получает на вход число ( _**`number`**_ ) и последовательно в порядке возрастания выводит все его делители на экран (само число тоже является своим делителем).Для проверки используйте **`number = 84`**.<jupyter_code>#number = int(input())
number = 84
for i in range (1,number+1):
    if number%i==0:
        print(i)<jupyter_output><empty_output><jupyter_text>**А1.5.2.3 Задание 3**Написать программу, которая ищет все общие (**`не равные 1`**) делители двух чисел (**`num_1`** и **`num_2`**), введённых пользователем, и последовательно в порядке возрастания выводит их на экран. Если общих делителей нет, не выводит на экран ничего.Для проверки используйте **`num_1 = 12`** и **`num_2 = 38`**.<jupyter_code>#num_1 = int(input())
#num_2 = int(input())
num_1 = 12
num_2 = 38
# Определим минимальное из чисел, т.к. общий делитель необходимо искать ДО минимального числа
k=num_2+1
if num_1<num_2:
    k=num_1+1
for i in range(2, k):
    if num_2%i==0 and num_1%i==0:
        print(i)<jupyter_output><empty_output><jupyter_text>**А1.5.2.4 Задание 4**Написать программу, которая на вход получает натуральное число **`n`** и выводит **`n-е число ряда Фибоначчи`** на экран.Для проверки используйте **`n = 10`**.**Пояснение**: последовательность Фибоначчи — это ряд чисел, в котором первые два элемента равны 1, а каждый следующий элемент равен сумме двух предыдущих: 1, 1, 2, 3, 5, 8, 13, 21, ...<jupyter_code>n = 10
fib_1=1
fib_2=1
for i in range (1,n+1):
    if i==1 or i==2:
        sum_fib=fib_1
    else:
        sum_fib=fib_1+fib_2
        fib_1=fib_2
        fib_2=sum_fib
print(sum_fib)<jupyter_output><empty_output><jupyter_text>**А1.5.2.5 Задание 5**Напишите программу, которая выводит таблицу умножения от **`1`** до **`10`** для выбранного целого числа (**`number`**). Если **`number = 15`**, то строка таблицы имеет вид "**`15 X 3 = 45`**".Для проверки используйте **`number = 15`**.<jupyter_code>number=15
for i in range(1,11):
    print(number,'X',i,'=',number*i)<jupyter_output><empty_output><jupyter_text>А1.5.3 Управление выполнением цикла Иногда на работу программы может повлиять внешний фактор. В таких случаях программа может прекратить выполнение цикла или пропустить цикл. Для этого используются операторы _**break**_ и _**continue**_.В _Python_ оператор _**break**_ позволяет прервать цикл при возникновении внешнего фактора. Оператор _**break**_ нужно поместить сразу после оператора цикла (обычно после выражения _**if**_ ).<jupyter_code>for i in range(5):
    i = i+1
    if i == 3:
        break
    print('Идёт итерация цикла  №', i)
print('Выполнение цикла закончено')<jupyter_output><empty_output><jupyter_text>В этой программе запускается цикл для **`i`** от **`0`** до **`4`**. Каждый цикл выводит на экран информацию о том, какая итерация идёт в текущий момент. Оператор _**if**_ определяет условие прерывания цикла (в данном случае это равенство **`i`** **`3`**). После цикла идёт ещё один _**print()**_ , который информирует нас о завершении работы цикла. Как только значение **`i`** достигает **`3`**, выполнение цикла прекращается оператором _**break**_ .  Оператор _**continue**_ позволяет пропустить часть цикла при возникновении внешнего фактора и перейти к следующей итерации цикла. То есть текущая итерация прерывается, после чего программа возвращается в начало цикла. Оператор _**continue**_ располагается в блоке кода после оператора цикла (обычно после _**if**_ ).Вернёмся к предыдущему примеру и попробуем использовать оператор _**continue**_ вместо _**break**_ .<jupyter_code>for i in range(5):
    i = i+1
    if i == 3:
        continue
    print('Идёт итерация цикла  №', i)
print('Выполнение цикла закончено')<jupyter_output><empty_output><jupyter_text>В отличие от _**break**_ при использовании оператора _**continue**_ код будет выполняться даже после прерывания цикла, когда переменная **`i = 3`**.Операторы _**break**_ и _**continue**_  можно использовать вместо вложенного условного кода или для оптимизации цикла. **А1.5.3.1 Задание 1**Напишите программу, которая ищет **наибольший (не равный 1)** общий делитель двух чисел, введённых пользователем (**`num_1`**, **`num_2`**), и выводит его на экран. Если общих делителей нет, выводит на экран "**Общих делителей не найдено**".Для проверки используйте **`num_1 = 1812`**, **`num_2 = 2500`** и **не меняйте их** в ходе решения.**PS**: Если использовать _**break**_ в цикле **`for - else`**, то при прерывании цикла код после _**else**_ выполняться не будет.<jupyter_code>#num_1 = int(input())
#num_2 = int(input())
num_1=1812
num_2=2500
# Определим минимальное из чисел, т.к. наибольший общий делитель необходимо искать начиная с минимального числа
k=num_2
if num_1<num_2:
    k=num_1
for i in range(k,0,-1):
    if num_1%i==0.0 and num_2%i==0.0:
        break
if i!=1:
    print(i)
else:
    print('Общих делителей не найдено')<jupyter_output><empty_output><jupyter_text>**А1.5.3.2 Задание 2**Напишите программу с использованием оператора _**continue**_, которая принимает на вход строку (**`string`**), после чего выводит её посимвольно, но без букв **`а`**, **`б`**, **`в`**. Пример: ввод "**`арбуз`**", вывод "**`руз`**".Для проверки используйте **`string = 'абстракция'`**.**PS**: Чтобы выводить побуквенно в одну строчку, в фукнции _**print()**_ предусмотрен параметр **`end`**. Если написать _**print('Hello!', end='')**_ , следующий _**print()**_ продолжит вывод не с новой строки.<jupyter_code>#string = input()
string = 'абстракция'
for i, letter in enumerate(string):
    if letter in 'абв':
        continue
    print(letter,end='')<jupyter_output><empty_output><jupyter_text>**А1.5.3.3 Задание 3**Напишите программу, которая анализирует ответы пользователя на вопрос "**Любите ли вы Python?**". Если ответ пользователя (**`string`**) - "**`Да`**", то программа отвечает: "**Это отлично!**", иначе программа отвечает: "**Увы, это неправильный ответ**". Программа должна "**спросить**" пользователя **максимум 5 раз**. При пяти ответах "**Нет**" выводит: "**Это безнадёжно!**".Для проверки используйте **`string = 'Нет'`**, а на каждой итерации цикла **не меняйте значение переменной**.Команду, выводящую на экран вопрос: "**Любите ли вы Python?**", в код **включать НЕ нужно**.<jupyter_code>string='Нет'
quest_count=5
for i in range(quest_count):
    i=i+1
    if string=='Да':
        print('Это отлично!')
        break
    elif i<quest_count:
        print('Увы, это неправильный ответ')
        continue
    else:
        print('Увы, это неправильный ответ')
        print('Это безнадёжно!')<jupyter_output><empty_output><jupyter_text>**А1.5.3.4 Задание 4**Напишите программу, которая проверяет, является ли введённое число (**`number`**) простым. Если число простое, то программа выводит "**Простое**", иначе "**Не является простым**".Для проверки используйте **`number = 173`**.<jupyter_code>number=173
for i in range(2, number+1):
    if number%i==0 and i<number:
        print('Не является простым')
        break
    elif i==number:
        print('Простое')
    else:
        continue<jupyter_output><empty_output><jupyter_text>**А1.5.3.5 Задание 5**Напишите программу, которая проверяет введённую пользователем строку (**`string`**) на соответствие правилу: **у строки нет ни одной гласной русской маленькой буквы на каждой чётной позиции**. Пример подходящей строки: "**пока!**" (в _Python_ первый символ является нулевым, поэтому мы считаем **первый символ чётным**). Если строка подходит, программа выводит на экран "**Какая хорошая строка!**", а иначе — "**Строка мне не нравится!**".Для проверки используйте **`string = 'прелестная строка'`**.<jupyter_code>string='прелестная строка'
string='пока!'
count=len(string)
for i, letter in enumerate(string):
    if i%2==0:
        if letter in 'аоиеёэыуюя':
            print('Строка мне не нравится!')
            break
else:
    print('Какая хорошая строка!')<jupyter_output>Какая хорошая строка!<jupyter_text>А1.5.4 Цикл whileПредположим, что мы положили деньги в банк под **6** процентов годовых. Через сколько лет деньги удвоятся? Такую задачу сложно решить с помощью цикла _**for**_, однако с ней нам поможет  цикл _**while**_ . Цикл _**while**_ (**`«пока»`**) позволяет выполнить одну и ту же последовательность действий, пока проверяемое условие истинно. Условие записывается до тела цикла и проверяется до выполнения тела цикла. Как правило, цикл _**while**_ используется, когда невозможно определить точное значение количества проходов исполнения цикла.Вернёмся к задаче и решим её с помощью цикла _**while**_ :<jupyter_code>money = 1
year = 0
yearly_multiplier = 1.06

while money < 2:
    money = money*yearly_multiplier
    year += 1
else:
    print('Деньги удвоятся через', year, 'лет')<jupyter_output><empty_output><jupyter_text>Каждую итерацию цикла проверяется условие того, что **`money = 2`**, цикл перестаёт выполняться, и выполняется блок кода после **`else`**, который выводит нужное количество лет.Синтаксис оператора _**while**_ достаточно простой:_**while**_ условие:    тело цикла_**else:**_    код, выполняющийся при завершении цикла. В цикле _**while**_, как и в цикле _**for**_, можно применять операторы _**break**_ и _**continue**_.Несмотря на удобность для некоторых задач, цикл _**while**_ таит в себе и опасность. Если условие цикла _**while**_ всегда выполняется (например, _**while True:**_ ), то цикл не будет завершаться, произойдёт "**зацикливание**". В таком случае тело цикла будет выполняться бесконечное количество раз. Если мы этого не хотим, то можно использовать дополнительно счётчик, который будет прерывать цикл при достаточно большом количестве итераций.<jupyter_code>counter=0
while 1: #Условие верно всегда
    print('Что хочу, то и делаю!')
    counter += 1
    if counter > 10000:
        print(counter)
        break<jupyter_output><empty_output><jupyter_text>В этом примере тело цикла будет выполняться до тех пор, пока счётчик не станет равен **`10000`**, после чего с помощью оператора _**break**_ цикл будет прерван. **А1.5.4.1 Задание 1** Клиент банка открыл вклад под **`10%`** годовых и положил на этот счёт **`Y рублей`**. Напишите программу, позволяющую определить, через сколько лет клиент будет иметь на счету сумму не менее **`Z рублей`**. На вход программе идут два числа - **`Y`**, **`Z`**.Для проверки используйте **`Y = 170000`**, Z = **`1000000`**. В результате работы программа должна вывести на экран число лет, которое потребуется для накопления требуемой суммы. Ответ должен быть выведен на экран в виде целого числа без какого-либо дополнительного поясняющего текста.**Внимание**: в процессе выполнения программы **изменяйте** переменную **`Y`**.<jupyter_code>#Y = int(input())
#Z = int(input())
Y = 170000
Z = 1000000
year=0
while Y<Z:
    year+=1
    Y=Y*1.1
else:
    print(year)<jupyter_output><empty_output><jupyter_text>**А1.5.4.2 Задание 2** Пассажирский лифт имеет ограничение на перевозку: **`не более 400 кг`** единовременно. Пусть на вход программе поступает вес (**`weight`**) входящих в лифт людей, а в случае, когда возникает перевес, программа выдаёт предупреждение: "**Перевес ... кг**". Например, при перевесе в **`15 кг`** должно быть выведено сообщение: "**Перевес 15 кг**". Обратите внимание, что в эталонной фразе не используются знаки препинания.Для проверки используйте **`weight = 77`** и **не меняйте** его по ходу цикла.<jupyter_code>weight = 77
sum_weight = 0
while sum_weight <400:
    sum_weight = sum_weight + weight
else:
    print('Перевес', sum_weight-400, 'кг')<jupyter_output><empty_output><jupyter_text>**А1.5.4.3 Задание 3** Вы играете в компьютерную игру, дошли до схватки с финальным боссом, но вот беда: ваш компьютер "заглючил", и вы не можете управлять персонажем в игре. Босс атакует и каждую секунду наносит один удар, который **отнимает** у вас **`80` единиц** здоровья. На схватку с боссом вы вышли с **`500` единицами** здоровья. Создайте цикл, позволяющий понять, через **сколько секунд** босс вас убьет.В результате работы программа должна вывести на экран число секунд, в течение которых будет длиться схватка. Ответ должен быть выведен на экран в виде **целого числа** без какого-либо дополнительного поясняющего текста.Для проверки используйте переменную **`current_health`** для сохранения текущего уровня здоровья и **изменяйте её по ходу цикла**, и — переменную **`attack = 80`** для хранения значения атаки Босса.<jupyter_code>current_health = 500
attack = 80
sec = 0
while current_health >0:
    sec+=1
    current_health = current_health - attack
else:
    print(sec)<jupyter_output><empty_output><jupyter_text>**А1.5.4.4 Задание 4** На банковской карте хранятся **`10 000` рублей**. Хозяин карты написал программу, в которую вводит свои расходы (**`spent`**), после чего программа показывает баланс (**`balance`**). Баланс выводится в виде целого числа без каких-либо дополнительных сообщений. **Например**, при остатке **`3500` рублей** на экран выводится число **`3500`**. Когда сумма средств на карте становится ниже нуля, программа выводит сообщение: "**Слишком большие расходы**".Напишите программу, которая выводит на экран **начальный баланс** карты (число **`10000`**), **баланс после каждого списания** и сообщение "**Слишком большие расходы**" при достижении **отрицательного баланса**.Для проверки используйте переменную **`spent = 2800`** и **НЕ меняйте её** по ходу цикла. Переменная **`balance` должна меняться** после каждого шага цикла.<jupyter_code>balance=10000
spent = 2800
while balance > 0:
    print(balance)
    balance = balance - spent
else:
    print('Слишком большие расходы')<jupyter_output><empty_output><jupyter_text>**А1.5.4.5 Задание 5** Представьте, что перед вами большая цистерна объёмом **`1000` литров**, которую необходимо заполнить водой. У вас есть робот, который доставляет в цистерну **сначала `5` литров**, а затем **каждый раз на `5` литров больше**, чем в предыдущий. Изначально в цистерне нет воды. Через сколько заходов робота **вода польётся через край**?В результате работы программа должна вывести на экран число заходов, необходимых роботу для заполнения цистерны до краёв. Ответ должен быть выведен на экран в **виде целого числа** без какого-либо дополнительного поясняющего текста.Для проверки используйте переменную **`volume`**, равную свободному объёму в цистерне, и **меняйте её по ходу цикла** (на последнем шаге она **должна быть меньше нуля**).<jupyter_code>volume = 1000
counter = 0
step = 0
while volume > 0:
    counter+=1
    step+=5
    volume = volume - step
else:
    print(counter)<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.12538185085354897, 'fraction_numerical': 0.025741239892183288, 'mean_word_length': 5.077259077259077, 'pattern_counts': {'":': 0, '<': 128, '<?xml version=': 0, '>': 128, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 20, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 6, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '30', 'dir': 'jupyter-structured-clean-dedup', 'id': '602176', 'license': 'MIT', 'n_tokens_mistral': 9410, 'n_tokens_neox': 10602, 'n_words': 2551, 'path': 'DATA_ANALYST/Primer/Notebook-Python-1-cycles.ipynb', 'repo_name': 'stuit/I-am-data-scientist', 'size': '22260'}