Применение while: работа с числами – Учебник

4.3

О чём этот урок

Дано целое число – нужно найти сумму его цифр. Для 4726 человек считает в уме за секунду: 19. Программе же придётся объяснить, как добраться до каждой цифры по отдельности.

И тут же возникает главная трудность: количество цифр заранее неизвестно. Для 4726 нужно четыре шага, для 12 – два, для 1000000 – семь. Спрашивать «сколько раз повторить?» бесполезно – зато можно спросить «осталось ли ещё что разбирать?». Это ровно тот случай, ради которого нужен while: известно не число повторений, а условие остановки.

Разминка. Прежде чем читать дальше, попробуйте ответить сами на два вопроса: как получить последнюю цифру числа 4726, пользуясь только арифметикой? И как получить то же число без последней цифры? Обе операции уже были в уроке 1.6 – стоит вспомнить их самому.

В этом уроке: операции % и // как инструменты разбора числа, универсальный скелет цикла разбора, накопитель и чем он отличается от счётчика, одна заготовка для пяти разных задач и четыре ловушки – ноль, отрицательные числа, забытое изменение переменной и использование разобранного числа после цикла.

Два инструмента: % и //

Ответ – операции из урока 1.6, которые до сих пор выглядели второстепенными, а здесь становятся главными:

n % 10 – остаток от деления на 10, то есть последняя цифра;
n // 10 – целая часть от деления на 10, то есть число без последней цифры.

Посмотрим, что они дают, если применять их к числу 4726 снова и снова:

`n`	`n % 10`	`n // 10`
4726	6	472
472	2	47
47	7	4
4	4	0

Ради двух наблюдений эта таблица и нужна:

каждая строка – одно и то же действие с новым значением, то есть одна итерация;
в последней строке n // 10 даёт 0 – это и есть естественный сигнал «цифры кончились», готовое условие остановки.

Число 10 здесь не случайное: мы пользуемся десятичной записью, а десять – её основание. Если взять % 2 и // 2, тот же приём начнёт выдавать двоичные разряды – именно так устроено деление уголком из урока 2.5.

На каждом шаге от числа отделяется последняя цифра, а само число укорачивается; работа заканчивается, когда от числа остаётся ноль.

Скелет разбора числа

Переведём таблицу в цикл, опираясь на три части любого цикла со счётчиком:

Инициализация – число уже лежит в переменной n.
Условие продолжения – n > 0: пока от числа что-то осталось, есть что разбирать.
Изменение – n = n // 10 в теле. Без этой строки n не меняется, условие остаётся истинным навсегда, и цикл становится бесконечным.

Отдельно стоит проговорить: цифры выходят в обратном порядке – от последней к первой. Для суммы и количества это неважно (от перестановки слагаемых сумма не меняется), но если в задаче важен порядок цифр – про это придётся помнить.

Печатаем цифры по одной

n = 4726
while n > 0:
    digit = n % 10
    print(digit)
    n = n // 10

Пройдите этот код по шагам ниже. Следите не за цифрами, а за переменной n: как она тает на каждой итерации и в какой момент условие впервые становится ложным.

Накопитель: сумма цифр

Печатать цифры мало – их нужно складывать. Для этого заводят отдельную переменную:

Накопитель (аккумулятор) – переменная, созданная до цикла, в которую тело цикла на каждой итерации добавляет свой вклад.

Три обязательных момента:

накопитель создаётся до цикла – внутри он обнулялся бы на каждой итерации;
начальное значение для суммы – 0: прибавление нуля ничего не меняет;
меняется он внутри тела: total += n % 10.

Чем накопитель отличается от счётчика из урока 4.2? Счётчик двигали, чтобы цикл когда-нибудь закончился, – он часть механизма цикла. Накопитель на условие не влияет вообще, он просто копит ответ. В одном цикле спокойно живут обе роли.

Сумма цифр числа

n = int(input())
total = 0
while n > 0:
    total += n % 10
    n //= 10
print(total)

Что остаётся в переменной после разбора

Здесь прячется следствие, которое замечают не сразу: цикл разрушает n. После его окончания в переменной ноль – исходного числа больше нет. Если оно ещё понадобится (например, чтобы напечатать «в числе 4726 сумма цифр равна 19»), число нужно заранее сохранить в отдельную переменную, а разбирать копию.

Запись n //= 10 – та же краткая форма, что и += из урока 4.2: взять текущее значение, выполнить операцию, записать результат обратно в ту же переменную.

Одна заготовка – много задач

Главная мысль урока: скелет разбора числа не меняется от задачи к задаче. Меняется только тело цикла.

Задача	Что до цикла	Что в теле
Сумма цифр	`total = 0`	`total += n % 10`
Количество цифр	`count = 0`	`count += 1`
Произведение цифр	`p = 1`	`p *= n % 10`
Максимальная цифра	`best = 0`	`if n % 10 > best: best = n % 10`
Количество чётных цифр	`count = 0`	`if (n % 10) % 2 == 0: count += 1`

Два акцента к таблице:

начальное значение накопителя зависит от операции: для суммы 0, а для произведения 1 – единица не меняет результат умножения, а ноль обнулил бы всё;
в строках про максимум и чётность внутри цикла появился if из третьего блока. Циклы и ветвления работают вместе, никакого нового синтаксиса для этого не нужно.

Максимальная цифра и количество чётных

number = int(input())
n = number
best = 0
even = 0
while n > 0:
    digit = n % 10
    if digit > best:
        best = digit
    if digit % 2 == 0:
        even += 1
    n //= 10
print('Максимальная цифра:', best)
print('Чётных цифр:', even)

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

Четыре ловушки

Ноль. При n = 0 условие n > 0 ложно сразу, и цикл делает ноль итераций. Для суммы это верный ответ (сумма цифр нуля равна нулю), а вот количество цифр получится 0 вместо 1. Ноль приходится обрабатывать отдельным if.
Отрицательные числа. У -4726 условие n > 0 ложно с самого начала – цикл вообще не запустится. Лечится приведением к модулю: n = abs(n) до цикла.
Забытое n //= 10. Классический бесконечный цикл: n не меняется, условие истинно всегда. Остановить – Ctrl+C.
Использование n после цикла. Оно равно нулю. Не берите разобранную переменную как исходное число.

А нельзя ли через строку?

Можно: число превращается в строку, а строку можно перебрать по символам. Это рабочий способ, и в блоке 8 мы его увидим.

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

Коротко

Сумма цифр числа 4726 считается программой в пять строк – и эти же пять строк работают для числа любой длины, потому что цикл спрашивает не «сколько в числе цифр?», а «осталось ли ещё что разбирать?».

n % 10 – последняя цифра числа, n // 10 – число без последней цифры. Заменив 10 на другое основание, получим разбор в другой системе счисления – это и есть деление уголком из урока 2.5.
Скелет разбора: while n > 0: – в теле отделяем цифру и обязательно пишем n //= 10.
Цифры выходят в обратном порядке, от последней к первой. Для суммы и количества это неважно, для задач на порядок цифр – важно.
Накопитель заводится до цикла и растёт внутри; на условие выхода он не влияет, в отличие от счётчика. Начальное значение зависит от операции: для суммы 0, для произведения 1.
Меняется только тело цикла: total += n % 10 даёт сумму, count += 1 – количество цифр, if внутри – максимальную цифру или число чётных.
Четыре ловушки: n = 0 даёт ноль итераций (количество цифр получится 0 вместо 1); отрицательное число не запускает цикл вовсе (лечится abs()); забытое n //= 10 даёт бесконечный цикл; после цикла n равно нулю – исходное число нужно сохранять в отдельную переменную.