Инструкция повторного выполнения инструкция которая появляется только в предложении

Еще одной важной инструкцией языка Python является цикл for/in, который можно смело назвать универсальным
итератором последовательностей, поскольку он позволяет выполнять обход элементов в любых объектах, поддерживающих возможность совершения итераций. При этом сюда относятся как встроенные объекты, например, строки,
списки или словари, так и объекты, создаваемые с помощью классов (о них чуть позже).

В общем виде для цикла for используется следующий синтаксис:

 for <Переменная> in <Итерируемый объект>:
    <Тело цикла>
 else:
    <Дополнительный блок инструкций> 

В ходе выполнения цикла for интерпретатор один за другим присваивает переменной заголовка элементы итерируемого объекта и выполняет для них инструкции
тела цикла (см. пример №1). Если цикл нужно прервать, используется ключевое слово break, которое передает управление
инструкции, следующей сразу за циклом. Кроме того, в цикле for разрешается использовать необязательный блок else,
набор инструкций которого выполняется только после удачного завершения цикла (т.е. при отсутствии ошибки или прерывания за счет использования инструкции
break).

# Формируем список.
li = [2, 5, 9, 4]
    
# Задаем начальную сумму.
sum = 0

# Запускаем цикл по элементам списка.
for elem in li:
    
    # Если сумма чисел меньше 8,
    if sum < 8:
        # наращиваем ее.    
        sum += elem
        # Выводим для наглядности на экран.
        print(sum)
    # Иначе
    else:    
        # выводим предупреждение и
        print("Превышен лимит суммы эл-тов!")                 
        # прерываем цикл.
        break
        
# Если цикл не был прерван.
else:
    # Выводим итоговое сообщение.
    print("Сумма эл-тов равна:", sum)
	
# Выводим сообщение о завершении проверки.
print("Проверка списка завершена!")

2
7
16
Превышен лимит суммы эл-тов!
Проверка списка завершена!






















		
			

Пример №1. Использование цикла for (часть 1).

В примере с помощью инструкции цикла for список проверяется на превышение лимита суммы его элементов. Для этого используется знакомая нам вложенная
условная инструкция if/else, которая и проверяет сумму на достижение лимита. Если в ходе очередной итерации цикла сумма не достигает указанного предела,
значение счетчика суммы sum увеличивается на значение переменной заголовка цикла elem, т.е.
sum += elem. После этого цикл переходит к следующей итерации и присваивает переменной elem значение следующего элемента
списка. И так до тех пор, пока не будет завершен обход всех элементов списка или не будет достигнут лимит суммы. Если лимит суммы достигнут не будет, сработает набор инструкций блока
else цикла, т.е. итоговая сумма будет выведена на экран. После этого будет выполнена инструкция, следующая за циклом. В случае достижения лимита,
сработает набор инструкций блока else условной инструкции if, т.е. будет выведено предупреждение, а цикл будет
прерван инструкцией break, которая передаст управление инструкции, опять же, следующей за циклом.

Обратите внимание, что в нашем примере были использованы два блока else: один принадлежит условной инструкции if,
а другой – инструкции цикла for/in. Отличить их легко по уровню отступов. Оба блока не являются обязательными в своих конструкциях, но в нашем
случае конструкция for/else, позволяет выводить итоговое сообщение не всегда, а только в случае успешного завершения цикла.

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

Давайте рассмотрим еще несколько наглядных вариаций цикла for/in, чтобы увидеть, как он используется на практике (см. пример
№2).

# Выводим символы строки.
name = 'Григорий'
for s in name: print(s, end=' ')
print('', end='nn')

# Используем функцию range(a, b, step).
for n in range(1, len(name), 2): 
    # Выводим каждую вторую букву имени. 
    print(name[n], end=' ')         
print('', end='nn')        

# Выводим ключи и значения словаря.
d = {'one': 1, 'two': 2}
for key in d: print(key, '->', d[key])                
print('', end='n')        

# Используем распаковывание кортежей.
d = [(1, 2), (3, 4), (5, 6)]
for x, y in d: print(x + y, end=' ')                
print('', end='nn')        

# А здесь расширенный синтаксис распаковывания.
d = [(1, 2, 3), (4, 5, 6)]
for x, *y in d: print(x, y, end=' ')

Г р и г о р и й 

р г р й 

one -> 1
two -> 2

3 7 11 

1 [2, 3] 4 [5, 6] 












		
			

Пример №2. Использование цикла for (часть 2).

Как видим, инструкция цикла for в Python действительно имеет весьма простой синтаксис и с легкостью позволяет
совершать обход элементов в любых итерируемых объектах, в особенности внутри упорядоченных последовательностей вроде строк или списков, в которых обход осуществляется поочередно
в порядке возрастания индексов их элементов.

Инструкция цикла while представляет собой универсальный цикл общего назначения. Он служит для повторного выполнения кода, расположенного в его теле,
до тех пор, пока условие цикла остается истинным, т.е. имеет значение True. В общем случае синтаксис цикла while в
Python можно представить в следующем виде:

 while <Условное выражение>:
    <Тело цикла>
 else:
    <Дополнительный блок инструкций> 

Работает цикл while следующим образом: каждый раз перед выполнением новой итерации, т.е. перед очередным выполнением блока инструкций в теле
цикла, происходит проверка его условия и, если результат будет иметь значение True, код в теле цикла выполняется; далее интерпретатор возвращается в начало цикла
и снова проверяет его условие, повторяя все процедуры заново до тех пор, пока условие цикла не вернет значение False; в этом случае интерпретатор прерывает
выполнение цикла и, пропустив блок инструкций в его теле, передает управление либо необязательному ключевому слову else, выполняя дополнительный блок
инструкций, либо инструкции, следующей за циклом. При этом следует иметь в виду, что набор инструкций блока else выполняется только тогда, когда выход из
цикла производится не инструкцией break (см. пример №3).

# Формируем список.
li = [2, 5, 9, 4]
    
# Задаем начальную сумму.
sum = 0

# Устанавливаем счетчик итераций.
k = 0
# Запускаем цикл по элементам списка.
while k < len(li):
    
    # Если сумма чисел меньше 8,
    if sum < 8:
        # наращиваем ее.    
        sum += li[k]
        # Отслеживаем показания счетчика и суммы.
        print(k, ':', sum)                
        # Счетчик увеличиваем на 1.
        k += 1
    # Иначе
    else:    
        # выводим предупреждение и
        print("Превышен лимит суммы эл-тов!")                 
        # прерываем цикл.
        break
        
# Если цикл не был прерван.
else:
    # Выводим итоговое сообщение.
    print("Сумма эл-тов равна:", sum)
    
# Выводим сообщение о завершении проверки.
print("Проверка списка завершена!")

0 : 2
1 : 7
2 : 16
Превышен лимит суммы эл-тов!
Проверка списка завершена!


























		
			

Пример №3. Использование цикла while (часть 1).

В нашем примере цикл совершил три итерации. На первых двух итерациях сумма элементов списка наращивалась, но не достигла допустимого предела. В результате этого цикл пошел на третий виток,
где сумма элементов все-таки превысила лимит. Это привело к тому, что цикл был прерван инструкцией break, а интерпретатор начал обрабатывать выражение
вызова функции print(), следующее за циклом. Если бы общая сумма всех элементов списка оказалась меньше допустимого лимита, цикл продолжил бы работу до
тех пор, пока переменная счетчика не стала бы равной четырем, а условие цикла не вернуло бы False. Далее интерпретатор пропустил бы блок инструкций тела
цикла и стал бы обрабатывать дополнительный набор инструкций его блока else. Попробуйте уменьшить значение элементов списка и убедитесь в этом.

Стоит заметить, что в языке Python отсутствует цикл do/while, имеющийся в других языках программирования. Однако его
можно имитировать, добавив в конец тела цикла условную инструкцию одновременно с инструкцией break (см. пример №4).

# Устанавливаем счетчик.
k = 1

# Запускаем бесконечный цикл.
while True:
    
    # Выводим номер итерации.
    print(k, end=' ')               
    # Счетчик увеличиваем на 1.
    k += 1
                
    # Имитируем условную часть цикла do/while.
    if k > 5: break

1 2 3 4 5 

Пример №4. Использование цикла while (часть 2).

Как видим, в данной имитации тело цикла при любом значении счетчика будет выполнено как минимум один раз, что является побочным эффектом проверки условия в конце цикла свойственного
реальной конструкции do/while.

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

Инструкции break и continue используются только внутри циклов и выполняют примерно те же функции, что и
в других языках программирования: break прерывает объемлющий цикл и передает управление следующей за циклом инструкции, а continue
прерывает только текущую итерацию и производит переход в начало цикла, т.е. в строку заголовка. При этом обе инструкции могут появляться в любом месте внутри тела цикла, но как правило,
их используют во вложенных в цикл условных инструкциях if, чтобы выполнить необходимое действие в ответ на некоторое условие (см. пример
№5).

# Устанавливаем счетчик.
k = 1

# Запускаем бесконечный цикл.
while True:
    
    # Задаем условие прерывания цикла.
    if k > 10: 
        # Прерываем цикл и идем дальше.
        break            
                
    # Отсеиваем четные числа.
    if k%2 == 0: 
        # Счетчик обязательно увеличиваем.
        k += 1
        # Пропускаем дальнейшие инструкции
        # и возвращаемся в заголовок цикла.
        continue
    
    # Выводим нечетные числа на экран.
    print(k, end=' ')               
    # Счетчик увеличиваем на 1.
    k += 1                        
      
# Инструкция после цикла.
print('nВывод нечетных чисел окончен!n')       


        
# Допустим, что имеется список чисел от 1 до 20.
li = list(range(1, 21))

# Запускаем цикл по элементам списка.
for k in li:
    
    # Задаем условие прерывания цикла.
    if k > 10: 
        # Прерываем цикл и идем дальше.
        break            
                
    # Отсеиваем четные числа.
    if k%2 == 0: 
        # Счетчик обязательно увеличиваем.
        k += 1
        # Пропускаем дальнейшие инструкции
        # и возвращаемся в заголовок цикла.
        continue
    
    # Выводим нечетные числа на экран.
    print(k, end=' ')               
    # Счетчик увеличиваем на 1.
    k += 1                        
      
# Инструкция после цикла.
print('nВывод нечетных чисел окончен!')

1 3 5 7 9 
Вывод нечетных чисел окончен!

1 3 5 7 9 
Вывод нечетных чисел окончен!
















































		
			

Пример №5. Использование инструкций break и continue (часть 1).

Здесь хотелось бы обратить внимание на то, что все виды циклов в Python могут иметь другие вложенные циклы и условные инструкции, позволяя нужным образом
изменять дальнейший ход выполнения программы. Но дело в том, что каждая отдельная инструкция break или continue
относится только к одному ближайшему объемлющему циклу. Поэтому, например, выйти сразу из всех внешних циклов при помощи всего лишь одной инструкции break
расположенной в самом глубоком вложенном цикле не получится, нужно использовать инструкцию во всех циклах текущей иерархии (см. пример №6).

# Задаем стартовое значение счетчика.
y = 1                   
 
# Внешний цикл.
for x in range(1, 11):

    # Умножение на 1 пропускаем.
    if x == 1:          
        # Переходим в начало цикла for.
        continue 
  
    # Внутренний цикл.
    while True:         
        
        # Умножение на 1 пропускаем.
        if y == 1:          
            # Увеличиваем счетчик на единицу.
            y += 1    
            # Переходим в начало цикла while.
            continue                                     
                                      
        # Выводим произведение чисел.
        print('{} x {} = {}'.format(x, y, x*y))
        
        # При достижении значения y == 5.
        if y == 5:          
            # Переходим на новую строку.
            print()                     
            # Сбрасываем значение счетчика.
            y = 2                     
            # А внутренний цикл прерываем (внешний нет).
            break        
        
        # Увеличиваем счетчик на единицу.
        y += 1              
    
    # При достижении значения x == 5.
    if x == 5:          
        # Прерываем и внешний цикл.
        break            
  
# Выводим сообщение о завершении циклов.
print('Таблица умножения от 2 до 5 распечатана!')

2 x 2 = 4
2 x 3 = 6
2 x 4 = 8
2 x 5 = 10

3 x 2 = 6
3 x 3 = 9
3 x 4 = 12
3 x 5 = 15

4 x 2 = 8
4 x 3 = 12
4 x 4 = 16
4 x 5 = 20

5 x 2 = 10
5 x 3 = 15
5 x 4 = 20
5 x 5 = 25

Таблица умножения от 2 до 5 распечатана!




















		
			

Пример №6. Использование инструкций break и continue (часть 2).

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

• Для обхода элементов в любых объектах, поддерживающих возможность совершения итераций, в Python предназначен цикл
  for/in. В ходе выполнения этого цикла интерпретатор один за другим присваивает переменной заголовка элементы итерируемого объекта и выполняет для них
  инструкции тела цикла.
• Для многократного повторного выполнения кода (не только обхода элементов) служит универсальный цикл общего назначения while, который выполняет блок
  инструкций, расположенный в его теле, до тех пор, пока условие цикла остается истинным, т.е. имеет значение True.
• При необходимости в циклах for и while разрешается использовать необязательный блок
  else, набор инструкций которого выполняется только после удачного завершения цикла (т.е. при отсутствии ошибки или прерывания за счет использования
  инструкции break).
• При использовании счетчиков следует инициализировать их вне циклов, чтобы при каждой новой итерации их значения не сбрасывались циклом в первоначальное состояние.
• Для прерывания циклов в Python используется инструкция break, которая прерывает объемлющий цикл и передает управление
  следующей за циклом инструкции. Если нужно прервать только текущую итерацию, необходимо использовать инструкцию continue, которая после прерывания
  итерации производит переход в начало цикла, т.е. в строку заголовка. Обе инструкции могут появляться в любом месте внутри тела цикла, но как правило, их используют во вложенных
  в цикл условных инструкциях if, чтобы выполнить необходимое действие в ответ на некоторое условие.
• Следует помнить, что в Python разрешается использовать многоуровневые вложенные циклы, однако при этом отсутствует возможность использования конструкций
  вида break n или continue n, где n указывало бы на количество прерываний внешних
  циклов. Вместо этого необходимо использовать собственные инструкции для каждого из n циклов по отдельности.

# Сохраняем список в переменной.
li = [10, 20, 30]                   
 
# Организуем цикл по эл-там списка.
for elem in li:
    # Выводим значения на экран.
    print(elem, end=' ')              

# Сделаем отступ для цикла while.
print() 
              
# Инициализируем счетчик для цикла.  
k = 0
# Узнаем требуемое количество итераций.  
i = len(li)        

# Организуем цикл по эл-там списка.
while k < i:
    # Выводим значения на экран.
    print(li[k], end=' ')
    # Наращиваем значение счетчика.
    k += 1	

10 20 30 
10 20 30