### 2. Ветвление по условию – управляющая инструкция if.
- Операции определения значения dohod:
- dohod:
``` python
>>>porog = 5
>>>rashod1 = 8
@ -74,7 +74,7 @@ else: # Игнорируется
Общее правило написания:
for <Объект-переменная цикла> in <объект>:
<отступы><Блок инструкций 1 – тело цикла>
[else:
else:
<отступы ><Блок инструкций 2 – если в цикле не сработал break>]
@ -94,18 +94,17 @@ for <Объект-переменная цикла> in <объект>:
``` python
>>>sps = [2, 15, 14, 18]
>>>for k in sps:
if len(sps) <= 10: sps.append(sps[0])
if len(sps) <= 10:
sps.append(sps[0])
else: break
>>>sps
[2, 15, 14, 18, 2, 2, 2, 2, 2, 2, 2]
```
Как видно, в конец цикла добавляется двойка до тех пор, пока длина не превысит 10. Важно
понимать, что sps - это и объект, по которому проходит k, и объект, изменяющийся
внутри цикла. То есть k будет двигаться по циклу бесконечно, и выполнение останавливается
именно из-за условия if - else.
(При этом else в данном случае относится к if, а не к for (это можно понять не только по
смыслу, но и по табуляции)
Цикл идет по списку `sps`, который **меняется** во время выполнения, потому что мы добавляем туда элементы через `.append(sps[0])`.
- Это значит, что по мере роста списка цикл будет продолжаться, пока не сработает `break`. Если бы не было ограничения, цикл стал бы бесконечным.
- Итерация происходит по "живому" списку, который удлиняется прямо во время обхода.
``` python
>>>sps = [2, 15, 14, 8]
@ -115,44 +114,24 @@ for k in sps[:]:
>>>sps
[2, 15, 14, 8, 2, 2, 2, 2]
```
Отличия от предыдущего случая:
- Итерация происходит по фиксированной копии, а не по изменяемому списку.
- Создание копии: При входе в цикл создаётся копия текущего списка sps
- Изменение оригинала: Внутри цикла изменяется оригинальный список sps
- Количество итераций фиксировано: Определяется длиной изначальной копии
- С `[:]` создаётся копия, и цикл не видит добавленные элементы: работает ровно столько раз, сколько длина оригинала
#### 3.3. : Cоздание списка с 10 целыми случайными числами из диапазона от 1 до 100. При этом, если сумма чисел не превышает 500, эта сумма должна быть отображена на экране.
``` python
>>>import random as rn
>>>sps5 = []
>>>for i in range(10):
sps5.append(rn.randint(1, 100))
ss = sum(sps5)
if ss > 500: break
else:
print(ss)
# Программа ничего не вывела
>>>ss
512
>>>sps5
[47, 92, 92, 54, 52, 78, 67, 30]
```
После того, как прошло девять итераций, сумма элементов списка уже была больше 500, поэтому
цикл закончился из-за if, а не из-за окончания диапазона range(10).
Попробуем обнулить список и выполнить ту же программу еще раз:
``` python
>>>sps5 = []
>>>for i in range(10):
import random as rn
sps5 = []
for i in range(10):
sps5.append(rn.randint(1, 100))
ss = sum(sps5)
if ss > 500: break
else:
print(ss)
419
print(ss)
435
>>> sps5
[10, 98, 65, 13, 56, 26, 1, 88, 55, 23]
```
В этот раз программа вывела ответ, следовательно сработал else и break не сработал.
#### 3.4. Пример с символьной строкой
``` python
@ -163,11 +142,11 @@ else:
>>>print(stroka1)
Э т о – а в т о м а т и з и р о в а н н а я с и с т е м а
```
Переменная stroka содержит исходную строку: "Это – автоматизированная система".
Переменная stroka1 инициализируется как пустая строка.
В цикле for происходит перебор каждого символа ss из строки stroka.
На каждой итерации к stroka1 добавляется пробел и текущий символ ss.
После обработки всех символов в stroka1 формируется новая строка, где каждый символ исходной строки разделён пробелом.
Переменная **stroka** содержит исходную фразу: _"Это – автоматизированная система"_.
Переменная **stroka1** изначально пустая.
Далее в цикле **for** мы последовательно перебираем каждый символ строки **stroka**.
На каждом шаге к **stroka1** добавляется пробел и текущий символ.
В итоге получается новая строка, в которой каждый символ исходного текста выведен через пробел — поэтому вывод выглядит «растянутым».
#### 3.5. Конструкция list comprehension.
@ -276,12 +255,14 @@ else:
print(chislo, ' является простым!')
267 имеет множитель 89
```
Программа работает так: переменная kandidat отвечает за потенциальный делитель заданного
числа. Изначально мы задаем половину от заданного числа, потому что у числа не может быть
делителя большего, чем половина от него. Далее мы последовательно уменьшаем потенциальный
множитель, каждый раз проверяя, получилось ли поделить без остатка. Если получилось, то
число непростое, и цикл можно прекращать досрочно. Если цикл отработал до конца, не
прервавшись, то число простое.
Программа работает так: переменная **kandidat** — это возможный делитель числа.
Мы начинаем проверку с половины числа, потому что делитель не может быть больше этого значения.
Дальше в цикле мы уменьшаем **kandidat** и на каждом шаге проверяем:
делится ли число на kandidat без остатка.
Если делится — значит число **составное**, и мы сразу выходим из цикла.
Если же цикл дошёл до конца и ни разу не нашёл делитель, значит число **простое**.
Дополним программу так, чтобы выявить все простые числа в диапазоне от 250 до 300.
