Циклы for и while в Python: полное руководство с задачами

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

Например, если вы хотите вывести на экран числа от 1 до 10, вместо того чтобы написать десять отдельных строк с командой print(), можно использовать цикл for. Вот как это можно сделать:

for i in range(1, 11):
    print(i)

Этот код создает цикл for, который перебирает числа от 1 до 10 (включительно) и выводит каждое число на экран. Это намного эффективнее, чем написание десяти отдельных команд print(), и может сократить объем кода.

Еще один пример использования циклов — это обработка данных в списке или другой последовательности. Например, если у вас есть список имен людей и вы хотите вывести каждое имя с приветствием, можно использовать цикл for для перебора списка и вывода каждого имени. Вот как это может выглядеть:

names = ['Андрей', 'Мария', 'Иван', 'Ольга']

for name in names:
    print('Привет, ' + name + '!')

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

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

Содержание

Итерация, итерируемый объект

Итерация — это один шаг или повторение цикла.

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

Итерируемый объект — это что-то, по чему можно проходиться итерациями.

Например, строка — это итерируемый объект, потому что мы можем выполнить итерацию для каждого символа в строке.

Основные типы циклов в Python

В Python есть два основных типа циклов: цикл for и цикл while.

Цикл for используется для перебора элементов в последовательности (например, в списке или строке) и выполнения одних и тех же действий для каждого элемента. Синтаксис цикла for выглядит так:

for variable in sequence:
    statement(s)

Где variable — это переменная, которая будет использоваться для хранения текущего элемента последовательности, sequence — это последовательность элементов, которые нужно перебрать, а statement(s) — это команды, которые будут выполняться для каждого элемента последовательности.

Цикл while используется для повторения действий до тех пор, пока выполняется определенное условие. Синтаксис цикла while выглядит так:

while condition:
    statement(s)

Где condition — это условие, которое должно быть выполнено для продолжения выполнения цикла, а statement(s) — это команды, которые будут выполняться до тех пор, пока условие не перестанет выполняться.

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

Цикл for в Python

Синтаксис цикла for

Синтаксис цикла for в Python выглядит следующим образом:

for variable in sequence:
    statement(s)

Где:

variable — это переменная, которая будет использоваться для хранения текущего элемента последовательности;
sequence — это последовательность элементов, которые нужно перебрать;
statement(s) — это команды, которые будут выполняться для каждого элемента последовательности.

Цикл for используется для перебора элементов в последовательности, например, в списке или строке. Для каждого элемента в последовательности переменная variable будет хранить значение этого элемента, и затем будут выполнены команды statement(s).

Пример использования цикла for для перебора элементов в списке:

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

В этом примере мы создаем список fruits, содержащий три элемента. Затем мы используем цикл for для перебора всех элементов списка fruits. Переменная fruit будет хранить значение каждого элемента, начиная с первого элемента списка. Затем мы выводим каждый элемент списка на экран с помощью функции print(). В результате выполнения этого кода на экране будет выведено:

apple
banana
cherry

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

Функция range()

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

Синтаксис функции range() выглядит следующим образом:

range(start, stop, step)

Где:

start — необязательный аргумент, который указывает начальное значение последовательности. По умолчанию он равен 0.
stop — обязательный аргумент, который указывает конечное значение последовательности. Оно не включается в последовательность.
step — необязательный аргумент, который указывает шаг, с которым генерируются числа в последовательности. По умолчанию он равен 1.

Пример использования функции range() для генерации числовых последовательностей в цикле for:

for i in range(5):
    print(i)

В этом примере мы используем функцию range() для генерации последовательности чисел от 0 до 4. Цикл for используется для перебора каждого элемента в этой последовательности. На каждой итерации значение i будет увеличиваться на 1, и мы будем выводить это значение на экран с помощью функции print(). В результате выполнения этого кода на экране будет выведено:

Мы также можем использовать функцию range() для генерации последовательности чисел с другим начальным значением и шагом:

for i in range(1, 10, 2):
    print(i)

В этом примере мы используем функцию range() для генерации последовательности чисел от 1 до 9 с шагом 2. Цикл for используется для перебора каждого элемента в этой последовательности, и на каждой итерации мы будем выводить это значение на экран с помощью функции print(). В результате выполнения этого кода на экране будет выведено:

Функция range() также позволяет генерировать последовательности чисел в обратном порядке с помощью отрицательного шага. Например:

for i in range(10, 0, -1):
    print(i)

В этом примере мы используем функцию range() для генерации последовательности чисел от 10 до 1 с шагом -1. Цикл for используется для перебора каждого элемента в этой последовательности, и на каждой итерации мы будем выводить это значение на экран с помощью функции print(). В результате выполнения этого кода на экране будет следующее:

Функция range() с одним аргументом

Функция range() с одним аргументом используется для генерации последовательности чисел от 0 до заданного значения. Формат вызова функции выглядит следующим образом:

range(stop)

Где:

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

Пример использования функции range() с одним аргументом в цикле for:

for i in range(5):
    print(i)

В этом примере функция range() генерирует последовательность чисел от 0 до 4, которая используется в цикле for для перебора элементов. На каждой итерации значение i будет увеличиваться на 1, и мы будем выводить его на экран с помощью функции print(). В результате выполнения этого кода на экране будет выведено:

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

for i in range(6):
    print(i)

Таким образом, функция range() с одним аргументом очень удобна, когда мы хотим сгенерировать последовательность целых чисел от 0 до некоторого заданного значения и использовать её в цикле for.

range() с двумя аргументами

Функция range() с двумя аргументами используется для генерации последовательности чисел с определенным шагом. Формат вызова функции выглядит следующим образом:

range(start, stop)

Где:

start — опциональный параметр, определяющий значение первого элемента последовательности. По умолчанию равен 0.
stop — обязательный параметр, определяющий значение верхней границы последовательности (не включается в неё).

Пример использования функции range() с двумя аргументами в цикле for:

for i in range(2, 10):
    print(i)

В этом примере функция range() генерирует последовательность чисел от 2 до 9, которая используется в цикле for для перебора элементов. На каждой итерации значение i будет увеличиваться на 1, и мы будем выводить его на экран с помощью функции print(). В результате выполнения этого кода на экране будет выведено:

range() с тремя аргументами

Функция range() с тремя аргументами используется для создания последовательности чисел с определенным шагом (инкрементом). Три аргумента функции range() задают начальное значение, конечное значение и шаг.

Синтаксис:

range(start, stop, step)

start — начальное значение (включительно). По умолчанию равно 0.
stop — конечное значение (исключительно). Обязательный аргумент.
step — шаг. По умолчанию равен 1.

Примеры использования:

# Печать чисел от 1 до 10 с шагом 2
for i in range(1, 11, 2):
    print(i, end=' ')

# Печать чисел от 10 до 1 с шагом -1
for i in range(10, 0, -1):
    print(i, end=' ')

В первом примере цикл for проходит по значениям от 1 до 10 (включительно) с шагом 2 и печатает каждое значение. Результат выполнения кода:

1 3 5 7 9

Во втором примере цикл for проходит по значениям от 10 до 1 (не включительно) с шагом -1 и печатает каждое значение. Результат выполнения кода:

10 9 8 7 6 5 4 3 2 1

range() с отрицательными аргументами

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

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

for i in range(10, 0, -1):
    print(i, end=' ')

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

10 9 8 7 6 5 4 3 2 1

Аналогично, мы можем напечатать числа от 5 до -5 в порядке убывания с шагом -1:

for i in range(5, -6, -1):
    print(i, end=' ')

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

5 4 3 2 1 0 -1 -2 -3 -4 -5

Заметим, что в данном случае конечное значение равно -6, а не -5, поскольку последовательность не включает в себя значение -5.

Перебор последовательностей с помощью цикла for

В Python можно перебирать элементы различных последовательностей, таких как строки, списки, кортежи, с помощью цикла for.

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

Рассмотрим пример. Предположим, у нас есть список my_list с элементами [1, 2, 3, 4, 5]. Мы можем перебрать этот список следующим образом:

my_list = [1, 2, 3, 4, 5]

for element in my_list:
    print(element)

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

Здесь мы определяем переменную element, которая будет хранить значения элементов списка my_list на каждой итерации цикла for. В теле цикла мы просто печатаем значение этой переменной с помощью функции print().

Точно так же мы можем перебрать и символы в строке. Например, у нас есть строка "hello world". Мы можем перебрать ее символы следующим образом:

my_string = "hello world"

for char in my_string:
    print(char)

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

h
e
l
l
o

w
o
r
l
d

Здесь мы также определяем переменную char, которая будет хранить значения символов строки my_string на каждой итерации цикла for. В теле цикла мы печатаем значение этой переменной с помощью функции print().

Функция enumerate()

Мы также можем использовать функцию enumerate() для получения индексов элементов при переборе последовательности. Например:

my_list = [1, 2, 3, 4, 5]

for index, element in enumerate(my_list):
    print(f"Index: {index}, Element: {element}")

Index: 0, Element: 1
Index: 1, Element: 2
Index: 2, Element: 3
Index: 3, Element: 4
Index: 4, Element: 5

Здесь мы использовали функцию enumerate(), которая возвращает пару значений — индекс элемента и сам элемент на каждой итерации цикла for. Мы определяем две переменные — index и element, которые будут хранить соответствующие значения, и затем печатаем их.

Использование параметров sep и end функции print() в цикле for

Функция print() в Python имеет два параметра, которые могут быть использованы в цикле for: sep и end.

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

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

Пример использования параметров sep и end в цикле for:

numbers = [1, 2, 3, 4, 5]

for num in numbers:
    print(num, end=', ', sep='')

# Вывод: 1, 2, 3, 4, 5,

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

Таким образом, использование параметров sep и end в цикле for может значительно упростить форматирование вывода на экран.

Задания для закрепления

Задание 1. Вывести на экран все четные числа от 0 до 20

Решение

for i in range(0, 21, 2):
    print(i)

Здесь мы используем range() с тремя аргументами, чтобы генерировать последовательность четных чисел от 0 до 20 с шагом 2. Затем мы просто выводим каждое число на экран.

Задание 2. Посчитать сумму первых 10 натуральных чисел

Решение

sum = 0
for i in range(1, 11):
    sum += i
print(sum)

Здесь мы используем range() с двумя аргументами, чтобы генерировать последовательность чисел от 1 до 10. Затем мы движемся по этой последовательности, на каждой итерации (шаге) добавляя текущее число к переменной sum. В конце мы выводим сумму на экран.

Задание 3. Вывести на экран таблицу умножения от 1 до 10

Решение

for i in range(1, 11):
    for j in range(1, 11):
        print(i * j, end='\t')
    print()

Здесь мы используем вложенные циклы for, чтобы итерироваться по числам от 1 до 10. Внешний цикл движется по первым множителям, а внутренний цикл движется по вторым множителям. На каждой итерации мы выводим произведение множителей на экран, разделяя их табуляцией. В конце каждой строки мы выводим символ перевода строки, чтобы перейти на следующую строку таблицы.

Задание 4. Вывести на экран последовательность чисел в обратном порядке

Решение

for i in range(10, 0, -1):
    print(i)

Здесь мы используем range() с тремя аргументами и отрицательным шагом, чтобы генерировать последовательность чисел от 10 до 1 в обратном порядке. Затем мы просто выводим каждое число на экран.

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

Решение

text = "abc123xyz789"
for char in text:
    if char.isdigit():
        print(char)

Цикл while

Цикл while в Python позволяет выполнять набор инструкций до тех пор, пока выполняется заданное условие. Он отличается от цикла for тем, что не требует указания последовательности элементов, по которой нужно пройтись, а лишь проверяет условие и выполняет инструкции в теле цикла до тех пор, пока условие верно.

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

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

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

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

Синтаксис цикла

Цикл while в Python позволяет выполнять повторяющиеся блоки кода до тех пор, пока выполняется определенное условие. Синтаксис цикла while выглядит следующим образом:

while условие:
    блок кода

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

Один из примеров использования цикла while — это чтение ввода пользователя с клавиатуры. Например, мы можем написать цикл, который запрашивает у пользователя числа, пока он не введет число 0:

sum = 0
num = 1
while num != 0:
    num = int(input("Введите число (введите 0 для выхода): "))
    sum += num
print("Сумма введенных чисел равна", sum)

В этом примере мы создаем переменную sum и переменную num, которая будет использоваться для чтения ввода пользователя. Затем мы начинаем цикл while, который будет выполняться, пока значение переменной num не станет равным 0. Внутри цикла мы запрашиваем у пользователя ввод числа, преобразуем его в целое число с помощью функции int(), добавляем его к переменной sum, и затем проверяем условие, чтобы определить, продолжать ли цикл. Если пользователь введет число 0, то условие num != 0 станет ложным, и цикл завершится. Мы выводим сумму введенных чисел на экран с помощью функции print().

Условие выхода из цикла

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

Синтаксис условия выхода из цикла while выглядит так:

while условие:
    # блок инструкций

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

Например, давайте рассмотрим пример использования цикла while для подсчета суммы чисел от 1 до 10:

i = 1
summa = 0
while i <= 10:
    summa += i
    i += 1
print(summa)

В этом примере мы инициализируем переменную i со значением 1 и переменную summa со значением 0. Затем мы используем цикл while для перебора значений от 1 до 10, пока i меньше или равно 10. Внутри цикла мы добавляем значение i к переменной summa и увеличиваем i на 1. После того, как i достигнет значения 11, условие станет ложным, цикл завершится, и сумма чисел от 1 до 10 будет выведена на экран.

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

Однако, если заранее известно количество итераций, то в этом случае лучше использовать цикл for.

Задание для закрепления

Задание 6. Написать программу, которая будет запрашивать у пользователя пароли до тех пор, пока он не введет правильный пароль. Правильный пароль задан заранее и равен «qwerty». После ввода правильного пароля программа должна вывести сообщение «Добро пожаловать!».

Решение

# Запрашиваем у пользователя пароли, пока он не введет правильный пароль
password = ""
while password != "qwerty":
    password = input("Введите пароль: ")

# Выводим на экран сообщение об успешной авторизации
print("Добро пожаловать!")

Инструкции управления циклом

break

Инструкция break в Python используется для принудительного выхода из цикла. Как только интерпретатор Python достигает инструкции break, выполнение цикла прекращается, и управление передается на следующую инструкцию после цикла.

Синтаксис использования break простой. Вы можете поместить эту инструкцию внутри цикла, и если какое-либо условие выполняется, то цикл немедленно завершается:

while условие:
    if some_condition:
        break
    # остальной код

или

for элемент in последовательность:
    if some_condition:
        break
    # остальной код

Здесь some_condition — это условие, которое, если оно становится истинным, приводит к прерыванию цикла.

Вот пример использования break в цикле while, который выходит из цикла, если пользователь вводит слово "stop":

while True:
    user_input = input("Введите что-нибудь: ")
    if user_input == "stop":
        break
    print("Вы ввели:", user_input)
print("Цикл завершен.")

Как только пользователь вводит слово «stop», программа выходит из цикла и продолжает выполнение кода после цикла.

Инструкция break также может использоваться в циклах for. В следующем примере цикл for перебирает элементы списка и завершается, как только находит первый элемент, который делится нацело на 5:

numbers = [1, 3, 5, 7, 10, 12]
for num in numbers:
    if num % 5 == 0:
        print("Первый элемент, который делится нацело на 5, это", num)
        break

Здесь, как только мы находим элемент, который делится нацело на 5, мы выводим его на экран и прерываем цикл.

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

continue

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

Синтаксис continue прост: когда интерпретатор Python встречает эту инструкцию внутри цикла, он переходит к следующей итерации, игнорируя все операторы, которые находятся ниже.

Пример использования continue:

for i in range(1, 6):
    if i == 3:
        continue
    print(i)

В этом примере цикл for перебирает числа от 1 до 5. Если число равно 3, то оператор continue переводит выполнение программы к следующей итерации, пропуская вывод числа 3. Таким образом, вывод программы будет:

В этом примере мы использовали continue, чтобы пропустить вывод числа 3 и перейти к выводу 4. Если бы мы не использовали continue, то число 3 также было бы выведено в консоль на экран.

Использование else в цикле

Инструкция else в теле цикла — это опциональный (не обязательный) блок кода, который выполняется после того, как цикл завершается. Она выполняется только в том случае, если цикл завершился естественным путем, то есть без использования инструкций break. Синтаксис выглядит следующим образом:

while <условие>:
    <блок кода>
else:
    <блок кода>

или

for <переменная> in <итерируемый объект>:
    <блок кода>
else:
    <блок кода>

Здесь блок кода после else будет выполнен, когда завершится цикл. Если же цикл был прерван инструкцией break, блок кода после else не будет выполнен.

Пример:

numbers = [1, 2, 3, 4, 5]

for num in numbers:
    if num == 3:
        print("Число 3 найдено.")
        break
else:
    print("Число 3 не найдено.")

В этом примере мы создали список чисел и проходимся по нему с помощью цикла for. Если в списке встретится число 3, то будет выполнен блок кода внутри if, который выведет на экран «Число 3 найдено.» Затем выполнится инструкция break, которая прервет цикл.

Если же в списке не будет числа 3, то инструкция break не выполнится и цикл завершится нормально. Тогда выполнится блок кода внутри инструкции else, который выведет на экран «Число 3 не найдено.»

pass

Инструкция pass в Python — это оператор-заглушка, который не делает ничего. Он используется, когда синтаксически требуется оператор, но никакой действительной работы не нужно выполнять.

Например, если вы пишете функцию или цикл, но еще не определили тело, вы можете использовать pass в качестве временной заглушки, чтобы избежать ошибок синтаксиса:

def my_function():
    pass
    
for i in range(10):
    pass

return и циклы

Инструкция return используется для возврата значения из функции. В циклах return используется для выхода из цикла и возврата значения из функции. Когда оператор return выполняется внутри цикла, цикл останавливается и управление передается обратно в вызывающую функцию.

Например, если вы хотите выйти из цикла, когда определенное условие выполняется, вы можете использовать return:

def find_number(numbers, target):
    for num in numbers:
        if num == target:
            return True
    return False

В этой функции find_number мы проходимся по каждому элементу списка numbers и проверяем, равен ли он целевому числу target. Если мы находим его, мы возвращаем значение True. Если мы проходимся по всем элементам списка и не находим целевое число, мы возвращаем False.

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

Задания для закрепления

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

Решение

# Запрашиваем у пользователя числа, пока он не введет отрицательное число
sum = 0
while True:
    num = int(input("Введите целое число: "))
    if num < 0:
        break
    sum += num

# Выводим на экран сумму положительных чисел
print("Сумма положительных чисел: ", sum)

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

Решение

# Запрашиваем у пользователя строки, пока он не введет пустую строку
max_length = 0
while True:
    string = input("Введите строку: ")
    if string == "":
        break
    length = len(string)
    if length > max_length:
        max_length = length

# Выводим на экран длину самой длинной строки
print("Самая длинная строка имеет длину ", max_length, " символов.")

Вложенные циклы

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

Синтаксис вложенных циклов аналогичен синтаксису обычных циклов. Внутренний цикл выполнится для каждой итерации внешнего цикла.

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

for i in range(1, 6):
    for j in range(1, 6):
        print(i, j)

В этом примере внешний цикл перебирает значения i от 1 до 5, а внутренний цикл перебирает значения j от 1 до 5 для каждого значения i. В результате мы получим все возможные комбинации чисел от 1 до 5.

Особенности использования break и continue в случае вложенных циклов

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

Когда break используется внутри вложенного цикла, он прерывает выполнение только этого цикла и переходит к следующей строке кода после этого цикла. Если вложенных циклов несколько, то break прерывает только самый внутренний цикл.

Рассмотрим пример, где используется вложенный цикл для поиска простых чисел от 2 до 10. Для этого мы будем проверять, делится ли каждое число от 2 до 10 на все числа от 2 до этого числа. Если делитель находится, значит число не простое, и мы переходим к следующему числу. Если же делителя не нашлось, то число простое и мы выводим его на экран.

for i in range(2, 10):
    for j in range(2, i):
        if i % j == 0:
            break
    else:
        print(i, " - простое число")

В этом примере, если мы находим делитель, то инструкция break прерывает вложенный цикл for j. Если делителя нет, то выполняется инструкция else, которая выводит на экран простое число.

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

for i in range(10, 100):
    for j in range(10, 100):
        num = i * j
        str_num = str(num)
        if str_num == str_num[::-1]:
            print(num, " - палиндромное число")
            break
    else:
        continue
    break

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

Задания для закрепления

Задание 9. Напишите программу, которая выводит на экран следующую последовательность чисел:

Решение

for i in range(1, 6):
    for j in range(1, i+1):
        print(j, end='')
    print()

Задание 10. Напишите программу, которая выводит на экран следующую последовательность чисел:

Решение

for i in range(1, 6):
    for j in range(i):
        print(i, end='')
    print()

Задание 11. Напишите программу, которая выводит на экран следующую последовательность чисел:

Решение

count = 1
for i in range(1, 5):
    for j in range(i):
        print(count, end='')
        count += 1
    print()

Задание 12. Напишите программу, которая выводит на экран следующую последовательность символов:

*
**
***
****
*****
****
***
**
*

Решение

for i in range(1, 6):
    for j in range(i):
        print('*', end='')
    print()

for i in range(4, 0, -1):
    for j in range(i):
        print('*', end='')
    print()

Множественное присваивание в Python

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

a, b = 1, 2

В данном примере происходит множественное присваивание переменным a и b значений 1 и 2 соответственно. Это эквивалентно выполнению двух отдельных присваиваний:

a = 1
b = 2

С помощью множественного присваивания можно легко поменять значения двух переменных местами, не используя третью переменную:

a, b = b, a

В этом случае значения переменных a и b поменяются местами.

Также множественное присваивание может использоваться в циклах, например, для перебора последовательностей:

my_list = [1, 2, 3, 4, 5]
for i, value in enumerate(my_list):
    print(i, value)

В данном примере enumerate() возвращает пару (i, value) для каждого элемента списка my_list, которые затем распаковываются в переменные i и value с помощью множественного присваивания.

Видеоурок по циклам

Задания для закрепления работы с циклами

Задание 13. Дано два числа: a и b, a<b. Напечатать в столбик и строчку все числа от a до b включительно, а также квадраты этих чисел.

Решение

Для решения этой задачи можно использовать цикл for для перебора чисел от a до b и вывода каждого числа и его квадрата. Можно также использовать функцию range для генерации последовательности чисел.

Вот код решения задачи:

a = 1
b = 10

# Вывод чисел в столбик
for i in range(a, b+1):
    print(i, i**2)

# Вывод чисел в строку
for i in range(a, b+1):
    print(i, i**2, end=" ")

Задание 14. Дано два целых числа: a1 и a2. Если a1<a2, то напечатайте числа от a1 до a2 в порядке возрастания. В противном случае, напечатайте числа от a1 до a2 в порядке убывания.

Решение

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

Затем, в зависимости от порядка, нужно выбрать соответствующий цикл: цикл for для порядка возрастания и цикл while для порядка убывания.

Вот код, который решает данную задачу:

a1 = int(input("Введите первое число: "))
a2 = int(input("Введите второе число: "))

if a1 < a2:
    for i in range(a1, a2+1):
        print(i)
else:
    while a1 >= a2:
        print(a1)
        a1 -= 1

Сначала пользователь вводит два числа. Затем мы проверяем, какое число больше, и выбираем соответствующий цикл. Если a1 < a2, то мы используем цикл for, который выводит числа в порядке возрастания, начиная с a1 и заканчивая a2. Если a1 >= a2, то мы используем цикл while, который выводит числа в порядке убывания, начиная с a1 и уменьшая его на 1 на каждой итерации, пока a1 не станет меньше a2.

Задание 15. Дано 20 чисел. Посчитайте их среднее арифметическое. Числа вводятся пользователем с клавиатуры

Решение

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

# инициализируем счетчики и сумму
count = 0
sum = 0

# вводим числа до тех пор, пока не наберем 20
while count < 20:
    num = int(input("Введите число: "))
    sum += num
    count += 1

# вычисляем среднее арифметическое
avg = sum / 20

# выводим результат
print("Среднее арифметическое:", avg)

В этом коде мы используем переменную count, чтобы отслеживать количество введенных чисел, и переменную sum, чтобы хранить сумму этих чисел. Затем мы вычисляем среднее арифметическое, деля сумму на количество чисел. И, наконец, мы выводим результат с помощью функции print().

Задание 16. Дано число k. Вычислите сумму квадратов нечетных чисел от 1 до k.

Решение

Для решения этой задачи можно использовать цикл for. Необходимо пройти циклом по всем нечетным числам от 1 до k и прибавлять к сумме квадрат текущего числа.

Вот код решения:

k = int(input("Введите число: "))
sum_of_squares = 0

for i in range(1, k+1, 2):
    sum_of_squares += i**2

print("Сумма квадратов нечетных чисел от 1 до", k, ":", sum_of_squares)

Сначала мы считываем число k с помощью функции input(). Затем инициализируем переменную sum_of_squares нулем, в которую будем добавлять квадраты нечетных чисел.

Далее, с помощью цикла for мы проходим по всем нечетным числам от 1 до k с шагом 2 (используя третий аргумент функции range()). Если текущее число нечетное, то мы добавляем его квадрат к переменной sum_of_squares.

Наконец, мы выводим результат с помощью функции print().

Задание 17. Дано число n. Мы вводим это число, а затем ровно n натуральных чисел. Посчитать, сколько среди этих чисел кратных трем

Решение

Для решения данной задачи мы можем использовать цикл for и оператор условия if. Необходимо сначала ввести число n, затем в цикле for запрашивать у пользователя n чисел. При каждом вводе числа мы проверяем, делится ли оно на 3 без остатка, и если да, увеличиваем на 1 счетчик кратных трём чисел. В конце программы выводим количество кратных трём чисел.

Пример решения:

n = int(input("Введите количество чисел: "))
count = 0

for i in range(n):
    num = int(input("Введите число: "))
    if num % 3 == 0:
        count += 1

print("Количество чисел, кратных трем:", count)

Для проверки работы программы можно ввести, например, такую последовательность чисел: 5, 9, 12, 17, 21. В этом случае программа должна вывести количество чисел, кратных трем: 3.

Задание 18. Дано число n. Мы вводим это число, а затем ровно n слов, каждое с новой строки. Посчитать, сколько в этих словах сочетаний букв «ла».

Решение

Для решения данной задачи можно использовать цикл while и метод строки count(), который возвращает количество вхождений заданной подстроки в строку.

Пример решения:

n = int(input("Введите количество слов: "))
count = 0
i = 1

while i <= n:
    word = input(f"Введите слово №{i}: ")
    count += word.count("ла")
    i += 1

print(f"Количество сочетаний 'ла': {count}")

Сначала мы запрашиваем у пользователя количество слов n. Затем мы объявляем переменную count, которая будет хранить общее количество сочетаний «ла» во всех словах. Также мы объявляем переменную i, которая будет использоваться для перебора слов.

Затем мы запускаем цикл while, который будет повторяться n раз. На каждой итерации цикла мы запрашиваем у пользователя слово с помощью функции input(). Затем мы используем метод строки count() для подсчета количества сочетаний «ла» в текущем слове и добавляем это значение к переменной count.

После того, как цикл завершен, мы выводим общее количество сочетаний «ла» во всех словах на экран с помощью функции print().

Задание 19. Дано число n>100. Напечатайте все числа, чьи кубы не превышают n

Решение

Для решения этой задачи мы можем использовать цикл while, в котором будем проверять, не превысил ли куб текущего числа значение n. Если куб числа не превышает n, то мы будем выводить это число, а затем увеличивать его на 1. Если же куб числа уже превышает n, то мы выходим из цикла.

Вот код, который решает данную задачу:

n = int(input("Введите число n: "))
num = 1
while num ** 3 <= n:
    print(num)
    num += 1

Мы начинаем со значения num = 1 и проверяем, не превышает ли куб этого числа значение n. Если не превышает, то мы выводим число и увеличиваем его на 1. Если превышает, то мы выходим из цикла. Таким образом, мы будем выводить все числа, чьи кубы не превышают значение n.

Задание 20. Простым числом называется натуральное число, большее единицы, которое имеет ровно два делителя: единицу и само себя. Дано число n. Определите, является ли число простым.

Решение

Для определения, является ли число n простым, необходимо проверить, есть ли у него делители кроме 1 и самого себя. Для этого достаточно перебрать все числа от 2 до n-1 и проверить, делится ли n на каждое из них без остатка. Если найдется делитель, то число не является простым. Если после проверки всех чисел делителей не найдено, то число является простым.

n = int(input("Введите число: "))

if n < 2:
    print(n, "не является простым числом")
else:
    is_prime = True
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            is_prime = False
            break
    if is_prime:
        print(n, "является простым числом")
    else:
        print(n, "не является простым числом")

Сначала мы получаем число n от пользователя и проверяем, меньше ли оно 2. Если n меньше 2, то это не является простым числом.

Если n больше или равно 2, мы создаем флаг is_prime и устанавливаем его значение на True. Затем мы запускаем цикл for от 2 до корня из n + 1. Для каждого значения i в этом диапазоне мы проверяем, делится ли n на i без остатка. Если это так, то n не является простым числом, и мы устанавливаем is_prime в значение False и выходим из цикла с помощью break.

Если n является простым числом, то is_prime останется равным True. Мы выводим сообщение, указывающее, является ли n простым числом или нет.

Перебор чисел можно ограничить числом int(n**0.5) + 1, потому что если число n не имеет делителей меньше или равных квадратному корню из n, то его делители должны быть больше квадратного корня из n.

Например, если мы ищем делители числа 25, то первые два возможных делителя — это 1 и 25, а следующие два — это 5 и 5. Мы можем остановить поиск делителей после того, как мы перебрали все числа от 1 до 5, так как дальнейший поиск будет бессмысленен, так как мы уже рассмотрели все возможные делители.

Таким образом, если мы перебираем числа от 1 до int(n**0.5) + 1, то мы рассматриваем все возможные делители, меньшие или равные квадратному корню из n. Если мы не нашли делитель до этого числа, то n — простое число.

Задание 21. Каждый день Хоббит съедает на 20 грамм больше еды, чем в предыдущий день. В первый день Хоббит съел x грамм еды. Определите, сколько дней Хоббит будет кушать, чтобы съесть не менее y грамм еды. Программа получает на вход действительные числа x и y и должна вывести одно натуральное число.

Решение

Решение задачи с помощью Python:

x = float(input("Введите количество съеденной еды в первый день, грамм: "))
y = float(input("Введите общее количество съеденной еды, грамм: "))

day = 1  # количество дней
total_food = x  # общее количество съеденной еды

while total_food < y:
    x += 20  # с каждым днем Хоббит съедает на 20 грамм больше еды
    total_food += x  # добавляем количество еды, съеденной в текущий день к общему количеству еды
    day += 1  # увеличиваем количество дней на 1

print("Хоббит будет кушать", day, "дней.")

Пример вывода:

Введите количество съеденной еды в первый день, грамм: <strong>50</strong>
Введите общее количество съеденной еды, грамм: <strong>500</strong>
Хоббит будет кушать <strong>5 дней</strong>.

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

Решение

Вот решение задачи на Python:

count = 0  # переменная для хранения количества нулей
num = 0  # переменная для ввода чисел пользователем

while num >= 0:
    num = int(input("Введите неотрицательное число (для окончания введите отрицательное): "))
    if num == 0:
        count += 1  # увеличиваем счетчик нулей

print("Количество нулей в последовательности:", count)

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

Задание 23. Дана последовательность неотрицательных чисел. Последовательность вводится пользователем с клавиатуры, пока не будет введено отрицательное число. Посчитать среднее арифметическое всех чисел кратных 3.

Решение

Для решения этой задачи нам нужно вводить числа с клавиатуры и проверять каждое число на кратность 3. Если число кратно 3, то мы добавляем его к сумме всех чисел, кратных 3, и увеличиваем счетчик на 1. В конце мы делим сумму на количество чисел, чтобы получить среднее арифметическое.

Вот код на Python, который решает эту задачу:

count = 0
sum = 0
num = int(input("Введите число: "))
while num >= 0:
    if num % 3 == 0:
        count += 1
        sum += num
    num = int(input("Введите число: "))
if count == 0:
    print("В последовательности нет чисел, кратных 3")
else:
    average = sum / count
    print("Среднее арифметическое чисел, кратных 3, равно", average)

Здесь мы используем цикл while, чтобы вводить числа, пока не будет введено отрицательное число. Внутри цикла мы проверяем, является ли число кратным 3, и, если да, то добавляем его к сумме и увеличиваем счетчик на 1. После цикла мы проверяем, были ли введены числа, кратные 3, и, если да, то выводим среднее арифметическое. Если в последовательности не было чисел, кратных 3, то выводим сообщение об этом.

Задание 24. Дана последовательность неотрицательных чисел. Последовательность вводится пользователем с клавиатуры, пока не будет введено отрицательное число. Найдите максимальное число в последовательности и его позицию. Если максимальных чисел несколько, вывести позицию последнего из них. Номера позиции начинаются с нуля.:

Решение

max_num = -1
max_pos = -1
pos = 0
while True:
    num = int(input())
    if num < 0:
        break
    if num >= max_num:
        max_num = num
        max_pos = pos
    pos += 1
print(max_num)
print(max_pos)

В этом решении мы создаем переменную max_num, которая будет содержать максимальное число в последовательности, и переменную max_pos, которая будет содержать позицию этого числа. Мы начинаем сразу с -1 для обработки случая, когда первое число в последовательности будет 0. Мы также создаем переменную pos, которая будет использоваться для отслеживания текущей позиции в последовательности.

Затем мы используем бесконечный цикл while True, чтобы получить все числа из последовательности, введенные пользователем, пока не будет введено отрицательное число. Для каждого числа мы проверяем, больше ли оно или равно max_num. Если это так, мы обновляем max_num и max_pos соответствующим образом. Затем мы увеличиваем pos на единицу для следующего числа.

В конце мы печатаем максимальное число и его позицию в последовательности.

Задание 25. Дана последовательность неотрицательных чисел. Последовательность вводится пользователем с клавиатуры, пока не будет введено отрицательное число. Определите третье по величине число в последовательности.

Решение

Одним из способов решения данной задачи без использования составных типов данных является использование трех переменных:

max1 — максимальное число в последовательности
max2 — второе по величине число в последовательности
max3 — третье по величине число в последовательности

Алгоритм решения будет следующим:

Инициализируем переменные max1, max2, max3 значением -1
Вводим числа последовательности с клавиатуры до тех пор, пока не будет введено отрицательное число
Если введенное число num больше max1, то сначала значение max2 присваиваем текущему значению max1, затем значение max1 присваиваем num
Если введенное число между max1 и max2, то значение max2 присваиваем num
Если введенное число между max2 и max3, то значение max3 присваиваем num
После окончания ввода последовательности, выводим значение переменной max3

Пример решения на Python:

max1 = max2 = max3 = -1

while True:
    num = int(input("Введите число: "))
    if num < 0:
        break
    if num > max1:
        max2 = max1
        max1 = num
    elif max2 < num <= max1:
        max2 = num
    elif max3 < num <= max2:
        max3 = num

print("Третье по величине число в последовательности:", max3)

Пример работы программы:

Введите число: 5
Введите число: 8
Введите число: 2
Введите число: 10
Введите число: 3
Введите число: 6
Введите число: 7
Введите число: -1
Третье по величине число в последовательности: 7

Пример работы программы:

Введите число: 5
Введите число: 2
Введите число: 5
Введите число: 1
Введите число: 3
Введите число: 5
Введите число: -1
Количество чисел в последовательности равных минимальному значению: 1

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

Решение

Инициализируем переменные min_value и count_min_value первым введенным числом.
Считываем числа с клавиатуры до тех пор, пока не будет введено отрицательное число.
Если считанное число меньше min_value, то обновляем значения переменных min_value и count_min_value.
Если считанное число равно min_value, то увеличиваем значение переменной count_min_value на 1.
По окончании считывания выводим значение переменной count_min_value.

Вот код на Python:

min_value = count_min_value = int(input("Введите число: "))
if min_value >= 0:
    while True:
        number = int(input("Введите число: "))
        if number < 0:
            break
        if number < min_value:
            min_value = number
            count_min_value = 1
        elif number == min_value:
            count_min_value += 1
    print("Количество чисел в последовательности равных минимальному значению:", count_min_value)
else:
    print("Последовательность пуста")

Пример работы программы:

Введите число: 5
Введите число: 2
Введите число: 5
Введите число: 1
Введите число: 3
Введите число: 5
Введите число: -1
Количество чисел в последовательности равных минимальному значению: 1

Задание 27. Напишите программу, которая запрашивает у пользователя число n и выводит на экран первые n чисел Фибоначчи.

Числа Фибоначчи — это последовательность чисел, начинающаяся с 0 и 1, где каждое последующее число равно сумме двух предыдущих. То есть, первые числа Фибоначчи выглядят так: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 и т.д.

Решение

n = int(input("Введите количество чисел Фибоначчи: "))
a, b = 0, 1

if n <= 0:
    print("Введите число больше 0")
elif n == 1:
    print(a)
else:
    print(a, b, end=" ")
    for i in range(2, n):
        c = a + b
        print(c, end=" ")
        a = b
        b = c

Пример работы программы:

Введите количество чисел Фибоначчи: 10
0 1 1 2 3 5 8 13 21 34

В этой задаче мы используем цикл for для генерации последовательности чисел Фибоначчи. Мы начинаем с чисел a = 0 и b = 1, и затем в цикле вычисляем следующее число как сумму a и b, сохраняем его в переменную c, выводим на экран и перезаписываем значения a и b, чтобы продолжать генерацию последовательности. Если пользователь введет число меньше или равное 0, программа выведет сообщение об ошибке. Если пользователь введет 1, программа выведет только число 0.

Задание 28. Напечатать минимальное число, большее 400, которое нацело делится на 19.

Решение

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

Начнем с числа 400 и будем увеличивать его на 1 на каждой итерации цикла. Проверим, делится ли текущее число на 19 без остатка с помощью оператора %. Если да, то это и есть искомое число, и мы можем вывести его на экран и завершить цикл с помощью оператора break.

num = 400
while True:
    if num % 19 == 0:
        print(num)
        break
    num += 1

Пример работы программы:

Индивидуальное и групповое обучение «Python Junior»
Если вы хотите научиться программировать на Python, могу помочь. Запишитесь на мой курс «Python Junior» и начните свой путь в мир ИТ уже сегодня!

Контакты
Для получения дополнительной информации и записи на курсы свяжитесь со мной:

Телеграм: https://t.me/Vvkomlev
Email: victor.komlev@mail.ru

Объясняю сложное простыми словами. Даже если вы никогда не работали с ИТ и далеки от программирования, теперь у вас точно все получится! Проверено десятками примеров моих учеников.

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

Практическая направленность. 80%: практики, 20% теории. У меня множество авторских заданий, которые фокусируются на практике. Вы не просто изучаете теорию, а сразу применяете знания в реальных проектах и задачах.

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

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