💻 Практические примеры

Пример 1. Округление вверх и вниз

Программа принимает число с плавающей запятой и выводит результат округления вверх и вниз.

import math

number = 4.3  # результат float(input("Введите число: "))
ceil_value = math.ceil(number)
floor_value = math.floor(number)

print(f"Округление вверх: {ceil_value}")
print(f"Округление вниз: {floor_value}")
# Округление вверх: 5
# Округление вниз: 4

Что происходит: math.ceil округляет к ближайшему большему целому, math.floor — к меньшему. Для отрицательных чисел направление то же самое: math.floor(-1.2) даёт -2, а не -1.

Пример 2. Факториал двумя способами

Одну и ту же величину можно посчитать вручную в цикле или встроенной функцией — и сравнить результаты.

import math

number = 5  # результат int(input("Введите число: "))
factorial = 1
i = 1
while i <= number:
    factorial *= i
    i += 1

factorial2 = math.factorial(number)

print(f"Факториал числа {number} первым способом: {factorial}")
print(f"Факториал числа {number} вторым способом: {factorial2}")
print(f"Результаты равны? {factorial == factorial2}")
# Факториал числа 5 первым способом: 120
# Факториал числа 5 вторым способом: 120
# Результаты равны? True

Почему так: ручной цикл умножает числа от 1 до number включительно; math.factorial делает то же самое, но быстрее и без риска ошибиться в границах цикла — в реальном коде предпочтителен второй способ, ручной вариант полезен как учебное упражнение.

Пример 3. Числа Фибоначчи

Вывод первых n чисел Фибоначчи с помощью цикла while и параллельного присваивания.

n = 7  # результат int(input("Введите количество чисел: "))
a, b = 0, 1
i = 0

while i < n:
    print(a, end=" ")
    a, b = b, a + b
    i += 1
print()
# 0 1 1 2 3 5 8

Что происходит: a, b = b, a + b — параллельное присваивание: сначала вычисляются оба новых значения (по старым a и b), и только потом происходит одновременное присваивание. Порядок важен: без параллельности пришлось бы заводить временную переменную.

Пример 4. Симулятор кассы

Пользователь вводит цены товаров до тех пор, пока не введёт 0. Программа считает сумму, округляет её и определяет, сколько купюр по 100 евро нужно передать.

import math

prices = [45.50, 29.99, 22.49, 0]  # результаты float(input("Введите цену товара: "))
total = 0.0
index = 0

while True:
    price = prices[index]
    index += 1
    if price == 0:
        break
    total += price

rounded_total = round(total)
payment = math.ceil(rounded_total / 100) * 100
change = payment - rounded_total

print(f"Сумма покупки: {rounded_total} евро")
print(f"Покупатель передал: {payment} евро")
print(f"Сдача: {change} евро")
# Сумма покупки: 98 евро
# Покупатель передал: 100 евро
# Сдача: 2 евро

Что происходит: while True с break — стандартный паттерн «читаем, пока не введут стоп-значение». Сумма округляется до целого через round (банковское округление), а число купюр по 100 евро — math.ceil, чтобы оплата всегда покрывала сумму.

Пример 5. Учёт доходов и расходов

Тот же паттерн «читаем до стоп-значения», но с разветвлением: положительные числа — доход, отрицательные — расход.

entries = [15000, -5000, -3000, 0]  # результаты float(input("Доход, расход или '0': "))
income = 0
expenses = 0
entry_index = 0

while True:
    value = entries[entry_index]
    entry_index += 1
    if value == 0:
        break
    if value > 0:
        income += value
    else:
        expenses += abs(value)

balance = income - expenses
print(f"Доходы: {income}")
print(f"Расходы: {expenses}")
print(f"Итоговый баланс: {balance}")
# Доходы: 15000
# Расходы: 8000
# Итоговый баланс: 7000

Что происходит: положительные значения добавляются к income, отрицательные — к expenses через abs(), чтобы хранить расход как положительное число. Баланс — простая разница.

Пример 6. Число Армстронга

Число Армстронга равно сумме своих цифр, возведённых в степень, равную количеству цифр. Классический пример на разбор числа по цифрам через % 10 и // 10.

def is_armstrong(number):
    original_number = number
    num_digits = 0
    temp = number
    while temp > 0:
        num_digits += 1
        temp //= 10

    sum_of_powers = 0
    temp = number
    while temp > 0:
        digit = temp % 10
        sum_of_powers += digit ** num_digits
        temp //= 10

    return original_number == sum_of_powers

for candidate in (153, 123):  # результаты int(input("Введите число: "))
    if is_armstrong(candidate):
        print(f"Число {candidate} является числом Армстронга.")
    else:
        print(f"Число {candidate} не является числом Армстронга.")
# Число 153 является числом Армстронга.
# Число 123 не является числом Армстронга.

Почему так: 153 = 1³ + 5³ + 3³ = 1 + 125 + 27 = 153 — совпадает с исходным числом. Для 123: 1³ + 2³ + 3³ = 1 + 8 + 27 = 36 ≠ 123.

Пример 7. Проверка простого числа

Оптимизированная проверка: достаточно искать делители до квадратного корня из числа — если делителя нет до √number, его нет и после.

number = 29  # результат int(input("Введите число: "))

if number <= 1:
    print("Число должно быть больше 1.")
else:
    is_prime = True
    i = 2
    while i * i <= number:
        if number % i == 0:
            is_prime = False
            break
        i += 1

    if is_prime:
        print(f"Число {number} является простым.")
    else:
        print(f"Число {number} не является простым.")
# Число 29 является простым.

Пример 8. Упорядоченность цифр

Проверяем, идут ли цифры числа по неубыванию слева направо. Цифры удобно извлекать справа налево, поэтому сравнение идёт «в обратную сторону».

number = 1347  # результат int(input("Введите число: "))
previous_digit = number % 10
number //= 10
is_sorted = True

while number > 0:
    current_digit = number % 10
    if current_digit > previous_digit:
        is_sorted = False
        break
    previous_digit = current_digit
    number //= 10

if is_sorted:
    print("Цифры упорядочены по возрастанию.")
else:
    print("Цифры не упорядочены по возрастанию.")
# Цифры упорядочены по возрастанию.

Почему так: цифры читаются справа налево, поэтому «по возрастанию слева направо» означает, что каждая следующая (по чтению справа налево) цифра не больше предыдущей — отсюда сравнение current_digit > previous_digit, а не <. Перепутать знак — частая ошибка, см. пример 11.

Пример 9. Сумма цифр и перевёрнутое число

Два родственных задания используют один и тот же приём разбора числа по цифрам — их удобно решить одним циклом.

number = 12345  # результат int(input("Введите число: "))
original = number
digit_sum = 0
reversed_number = 0

while number > 0:
    digit = number % 10
    digit_sum += digit
    reversed_number = reversed_number * 10 + digit
    number //= 10

print(f"Число: {original}")
print(f"Сумма цифр: {digit_sum}")
print(f"Перевёрнутое число: {reversed_number}")
# Число: 12345
# Сумма цифр: 15
# Перевёрнутое число: 54321

Что происходит: digit_sum просто накапливает цифры. reversed_number на каждом шаге сдвигает уже накопленный результат на один разряд влево (* 10) и дописывает новую цифру справа — так последняя извлечённая цифра исходного числа становится первой в перевёрнутом.

Пример 10. Угадай число за 5 попыток

Компьютер загадывает число от 1 до 10, у пользователя 5 попыток. Для воспроизводимого вывода здесь зафиксирован random.seed(42) — в реальной игре его быть не должно.

import random

random.seed(42)  # для воспроизводимого вывода в примере; в игре — не нужен
secret_number = random.randint(1, 10)
attempts = 5
guesses = [4, 8, secret_number]  # результаты int(input("Попробуйте угадать число: "))
guess_index = 0

while attempts > 0:
    guess = guesses[guess_index]
    guess_index += 1
    if guess == secret_number:
        print("Поздравляем! Вы угадали число.")
        break
    attempts -= 1
    if attempts > 0:
        print(f"Неверно! У вас осталось {attempts} попытки.")
    else:
        print(f"Вы не угадали. Загаданное число было: {secret_number}.")
# Неверно! У вас осталось 4 попытки.
# Неверно! У вас осталось 3 попытки.
# Поздравляем! Вы угадали число.

Что происходит: с зафиксированным seed(42) загаданное число всегда 2; первые две попытки (4 и 8) неверны, третья совпадает с загаданным — цикл завершается через break.

Пример 11. Ловушка: continue до инкремента и путаница с break

Частая ошибка практикума: поставить continue раньше строки, которая меняет переменную цикла. Так как реальный «зависший» цикл нельзя безопасно запустить, здесь эффект показан со счётчиком-предохранителем.

# В реальном коде без safety-счётчика этот цикл зависает навсегда:
# при чётном i continue пропускает "i += 1", и i % 2 == 0 остаётся истинным.
i = 1
safety = 0
printed = []
while i <= 5 and safety < 20:
    safety += 1
    if i % 2 == 0:
        continue  # инкремент i ниже пропускается — ошибка
    printed.append(i)
    i += 1

print("Успело напечататься:", printed, "| цикл завис (сработал предохранитель):", safety >= 20)

# исправленная версия: инкремент переносим перед continue
i = 1
printed_fixed = []
while i <= 5:
    if i % 2 == 0:
        i += 1
        continue
    printed_fixed.append(i)
    i += 1

print("Исправленная версия:", printed_fixed)
# Успело напечататься: [1] | цикл завис (сработал предохранитель): True
# Исправленная версия: [1, 3, 5]

Почему так: при i = 2 срабатывает continue, и управление сразу возвращается к проверке условия while — строка i += 1 не выполняется, i остаётся равным 2 навсегда. Это отдельная ошибка от путаницы break/continue: break прерывает цикл целиком, а continue — только текущую итерацию.

Как запустить в VS Code