Практические задачи по циклам Python

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

Решения подходят для Python 3.12 и 3.13. В добавленном разделе приведены проверенные компактные версии самых популярных задач и разобраны ошибки, из-за которых программа выдает неверный ответ на граничных значениях вроде 0, 1 или 1900 года. Сначала попробуйте решить задачу сами, затем сверьтесь с кодом.

• Четное или не четное число
• Проверка Високосного года
• Самое большее из трех чисел
• Печать всех простых чисел
• Поиск факториала числа
• Таблица умножения
• Число Фибоначчи
• Сумма натуральных чисел
• Итерация по словарю
• Реверс числа

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

Что бы хорошо разобраться в приведенных ниже примерах, вам необходимо знать следующие темы:

• Переменные Python
• Python if..else

Python четность числа

И так, для нахождения четности числа, мы будем действовать следующим образом. Делим нужное нам число на 2, с использованием оператора %, который вычисляет остаток. В случае если остаток числа равен нулю, то число четное.

num = int(input("Введи число: "))
if (num % 2) == 0:
   print('Число ',num,' четное')
else:
   print('Число ', num,' нечетное')
Результат работы:

Введи число: 43
Число 43 нечетное

Введи число: 8
Число 8 четное

Что происходит в данном коде? В сам начале, мы просим пользователя ввести число, затем делим это число, и смотри на остаток, если остаток равен нулю, то число четное, если не равен нулю, то число нечетное.

Проверка на високосный год

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

• Переменные Python
• if..else оператор

Вычисление високосного года происходит следующим образом:

Високосный год делится без остатка на 4, за исключением столетий (года заканчивающиеся на 00). Столетние года, мы будем делить на 400, если делится без остатка, то этот год является високосным. При делении как и в предыдущем примере, мы будем использовать оператор %. Пример:

2017 год не является високосным
1900 год не високосный
2012 год високосный
2000 год-високосный

Код программы:

year = int(input())
if (year % 4) == 0:
   if (year % 100) == 0:
       if (year % 400) == 0:
           print(year, "год високосный")
       else:
           print(year,'Не високосный')
   else:
       print(year,'год високосный')
else:
   print(year,' Не високосный')

Наибольшее из трех чисел

Продолжаем разбирать примеры с условиями, и на очереди у нас пример с нахождением наибольшего числа из трех. Что бы понять это пример, нам необходимо хорошо знать следующие темы:

• Переменные Python
• Ввод вывод и импорт Python

В приведенном примере, все три числа хранятся в переменных num1,num2, и num3 соответственно. Мы используем конструкцию if....elif...else.

num1 = float(input("Введи первое число: "))
num2 = float(input("Введи второе число: "))
num3 = float(input("Введи третье число: "))
if (num1 >= num2) and (num1 >= num3):
   largest = num1
elif (num2 >= num1) and (num2 >= num3):
   largest = num2
else:
   largest = num3
print("Наибольшее число из трех чисел", largest)

Выводим все простые числа в интервале

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

• if...else оператор
• Циклы Python
• Break and Continue

Простые числа, это те числа, которые делятся без остатка только на 1 и на само себя. Самое маленькое простое число, это 2. И так, приступим к коду.

lower = 900
upper = 1000
print("Диапазон чисел между", lower, "и", upper)
for num in range(lower, upper + 1):
   if num > 1:
       for i in range(2, num):
           if (num % i) == 0:
               break
       else:
           print(num)

Для более наглядного теста, попробуйте изменить значение переменных lower и upper. А в качестве дополнительного практического задания, попробуйте переделать эту задачу бы после запуска программы, пользователь сам мог ввести значение.

Python факториал числа

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

• if...else Python
• Циклы Python

Факториал числа - это произведение всех целых чисел от 1 до искомого числа. К примере, факториал числа 6 равен 1*2*3*4*5*6 = 720.

num = int(input("Введи число: "))
factorial = 1
if num < 0:
   print("Для отрицательных чисел факториал не определен")
elif num == 0:
   print("Факториал 0 равен 1")
else:
   for i in range(1,num + 1):
       factorial = factorial*i
   print("Факториал",num,"равен",factorial)

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

Python таблица умножения

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

• Циклы Python
• Ввод, вывод и импорт Python

Код программы

num = int(input("Display multiplication table of? "))
for i in range(1, 11):
   print(num, 'x', i, '=', num*i)

Как видите, программа в несколько строчек, благодаря циклам способна вывести всю таблицу умножения. В этой программе, мы используем цикл for, вместе с функцией range().

Числа фибоначчи python

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

• if...else оператор
• Цикл while

Для начала, последовательность Фибоначчи - это целочисленная последовательность, где следующее число равно сумме двух предыдущих. Приведу небольшой пример, n-ый член последовательности, это сумма (n-1) и (n-2), выглядит это следующим образом: 0,1,1,2,3,5,8,13....

Исходный код:

nterms = int(input("Количество последовательностей "))
# первые две последовательности
n1, n2 = 0, 1
count = 0
# check if the number of terms is valid
if nterms <= 0:
   print("Пожалуйста, введите положительное число")
# если существует только одна последовательность, вернуть n1
elif nterms == 1:
   print("Последовательность Фибоначчи",nterms,":")
   print(n1)
# Генерирование последовательности Фибоначчи
else:
   print("Последовательность Фибоначчи:")
   while count < nterms:
       print(n1)
       nth = n1 + n2
       # Обновляем значения
       n1 = n2
       n2 = nth
       count += 1

Разберем вышеописанный код: В переменной nterms, мы храним количество последовательностей. В самом начале мы инициализируем 0 и 1. В случае если последовательность больше 2-х, мы запускаем цикл while, для того, что бы найти следующий элемент путем сложения двух предыдущих, затем обновляем значения переменных, и возвращаемся в начало цикла.

Сумма натуральных чисел Python

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

• if...else оператор
• Цикл while

Код программы

num = int(input())
if num < 0:
   print("Введите положительное число")
else:
   sum = 0
   # use while loop to iterate until zero
   while(num > 0):
       sum += num
       num -= 1
   print("Сумма: ", sum)

Python перебор словаря

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

• Цикл for
• Словарь Python

Доступ к ключу и значению с помощью элементов

dt = {'a': 'Фрукты', 'b': 'Яблоки', 'c': 'Груши'}
for key, value in dt.items():
    print(key, value)
Результаты:
a Фрукты
b Яблоки
c Груши

Получаем ключи и значения

dt = {'a': 'Фрукты', 'b': 'Яблоки', 'c': 'Груши'}
for key in dt.keys():
    print(key)
for value in dt.values():
    print(value)

Для явного возвращения ключа или значения, вы всегда можете воспользоваться keys или value соответственно.

Реверс числа Python

В этом примере мы научимся делать реверс числа, то есть переворачивать число наоборот. Для более лучшего понимания вам необходимо знать следующие темы:

• Переменные Python
• Работа со строками

num = 123456
print(str(num)[::-1])
Результат:
654321

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

Проверенные решения и ошибки на граничных значениях

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

Високосный год одной проверкой

def is_leap(year: int) -> bool:
    return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)

for y in (1900, 2000, 2024, 2026):
    print(y, is_leap(y))
# -> 1900 False, 2000 True, 2024 True, 2026 False

Типичная ошибка: проверять только деление на 4. Тогда 1900 год окажется високосным, хотя это не так.

Простые числа без лишних делений

def is_prime(n: int) -> bool:
    if n < 2:
        return False
    d = 2
    while d * d <= n:
        if n % d == 0:
            return False
        d += 1
    return True

print([n for n in range(1, 30) if is_prime(n)])
# -> [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

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

Факториал и Фибоначчи

def factorial(n: int) -> int:
    if n < 0:
        raise ValueError("Факториал отрицательного числа не определен")
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result

def fibonacci(count: int) -> list[int]:
    a, b = 0, 1
    seq = []
    for _ in range(count):
        seq.append(a)
        a, b = b, a + b
    return seq

print(factorial(0), factorial(6))   # -> 1 720
print(fibonacci(10))   # -> [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

Обратите внимание на range(2, n + 1): верхняя граница не включается, и без + 1 факториал 6 окажется равен 120. Для Фибоначчи обмен a, b = b, a + b избавляет от временной переменной.

Реверс числа арифметикой

n, rev = 12340, 0
while n > 0:
    rev = rev * 10 + n % 10
    n //= 10
print(rev)   # -> 4321

Вариант через строку int(str(n)[::-1]) короче, но арифметический показывает работу цикла и операторов % и //.

Как проверять свое решение

Прежде чем считать задачу решенной, прогоните код на наборе граничных значений из таблицы ниже. Хорошая привычка - оформить решение функцией, которая принимает число и возвращает результат, а не печатает его. Тогда проверку легко автоматизировать строками вида assert is_leap(1900) is False: если ответ неверный, программа сразу остановится с AssertionError и покажет строку с ошибкой. Ввод через input() добавляйте в самом конце, когда логика уже проверена. Также удобно сравнивать свою функцию с готовой из стандартной библиотеки, например math.factorial(), на сотне случайных чисел.

Частые вопросы

Здесь собраны вопросы, с которыми обычно сталкиваются на практике, и короткие ответы на них.

Когда выбирать for, а когда while?

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

Как проверить четность отрицательного числа?

Так же, через n % 2 == 0. В Python остаток от деления на положительное число всегда неотрицательный, поэтому -3 % 2 равно 1, и проверка работает корректно.

Есть ли готовая функция для факториала?

Да, math.factorial(n). Она быстрее ручного цикла и сама проверяет некорректные значения. Ручную версию пишут в учебных целях, чтобы понять работу накопителя в цикле.

Почему программа с простыми числами работает очень медленно?

Скорее всего, проверка идет до самого числа, а не до корня из него, и цикл не прерывается после первого найденного делителя. Добавьте условие d * d <= n и выход через return или break. Для поиска всех простых в большом диапазоне используйте решето Эратосфена.