Цикли: обхід, а не лічильник

У темі 05 ми рахували, у що обходиться += над рядками, і чесно писали: «циклів ми ще не вчили, це тема 12». У темі 06 правильний рецепт таблиці [[0] * 3 for _ in range(3)] лишився замовлянням, яке треба було просто запамʼятати. У темі 08 біля .items() стояла врізка: «найчастіше це використовують у циклі — обходити ти навчишся за чотири теми». Чотири теми минуло.

Ця лекція нічого нового про структури даних не розповідає. Вона знімає обмеження: усе, що ми складали в списки, кортежі, словники й множини, нарешті можна пройти елемент за елементом і щось із кожним зробити. Наскрізний приклад лишається той самий, що й у темі 06, — кошик покупок:

01 / ОбхідГоловна відмінність від інших мов

У багатьох мовах цикл — це лічильник. Ти заводиш змінну, ставиш їй початкове значення, пишеш умову зупинки, пишеш, як її збільшувати, а потім всередині вручну дістаєш елемент за номером. Приблизно так це виглядає в C або Java:

У Python for влаштований інакше, і це не косметична різниця. Він не рахує. Він просить у колекції наступний елемент — і кладе його в імʼя:

Читається буквально як речення: «для кожної назви в покупках — надрукуй назву». Ніякого i, ніякої довжини, ніякого покупки[i]. Розберімо рядок по частинах:

• for — ключове слово. Далі йде імʼя змінної циклу: ти вигадуєш його сам, і Python на кожному кроці перечіплює його на черговий елемент.
• in — той самий оператор, що й у перевірці "мед" in покупки, але тут він частина синтаксису for, а не питання. Після нього стоїть те, що обходимо.
• Двокрапка в кінці — обовʼязкова. Її забувають частіше за все інше.
• Відступ у наступних рядках — це і є тіло циклу. Рівно як в умовах з теми 11: не дужки, а чотири пробіли ліворуч визначають, що саме повторюється.

Тіло виконується один раз на кожен елемент. Коли елементи скінчились, цикл завершується сам — писати умову зупинки не треба, бо колекція сама знає, де в неї кінець. Перший рядок без відступу після циклу виконається вже після всіх повторень.

Найкорисніше, що можна зробити в циклі, — накопичувати. Заводимо змінну до циклу й на кожному кроці її доповнюємо:

Змінна разом оголошена зовні, і це принципово: якби рядок разом = 0 стояв усередині з відступом, він виконувався б на кожному кроці й обнуляв би все зроблене. Пройди цей код покроково — і перемкни колекцію, щоб побачити, що механіка не залежить від того, що ми обходимо.

02 / ОбіцянкиЩо саме можна обходити

Тепер найприємніше. Оскільки for нічого не рахує, а просить наступний елемент, йому байдуже, у кого просити. Обходиться будь-що, що вміє віддавати елементи по черзі, — такі обʼєкти називають ітерованими (iterable). Пройдімось по всьому, що ми вже вивчили.

Список — елементи в порядку зберігання

Порядок гарантований: список упорядкований, і обхід іде зліва направо.

Рядок — по одному символу

Це та сама послідовність, що й у темі 05, тільки тепер ми йдемо по ній замість брати зріз. Тут же ховається класична помилка: for слово in "мед і хліб" дасть символи, а не слова. Щоб отримати слова, спершу поділи рядок: for слово in "мед і хліб".split().

Множина — без порядку

Обхід працює, але порядок не визначений — множина з теми 09 зберігає елементи так, як їй зручно за хешем. Покладатись на порядок виводу тут не можна. Потрібен передбачуваний порядок — обходь sorted(знижки).

Словник — і три його вікна

Ось обіцянка з теми 08, яку ми нарешті виконуємо. Сам словник обходиться по ключах:

Але майже завжди тобі потрібне й значення. Тут і стають у пригоді три методи-вікна, з якими ми познайомились, але не могли скористатись:

Форма for назва, ціна in ... — це не особлива магія словника, а розпакування з теми 07. .items() віддає пари ('хліб', 28.5), а for одразу розкладає кожну пару на два імені. Так само працює обхід будь-якого списку кортежів.

03 / rangeКоли потрібні саме числа

А що, як обходити треба не колекцію, а просто «п'ять разів»? Для цього є range — обʼєкт, який видає цілі числа за арифметичним правилом:

Три форми виклику, і всі три варто знати напамʼять:

• range(стоп) — від нуля до стоп, не включаючи його. range(5) — це 0, 1, 2, 3, 4: п'ять чисел, останнє на одиницю менше за п'ять.
• range(старт, стоп) — від старт включно до стоп невключно.
• range(старт, стоп, крок) — те саме, але додаємо крок. Крок може бути відʼємним — тоді йдемо вниз.

Правило «стоп не входить» здається примхою, поки не помітиш, що воно робить довжину очевидною: у range(0, 5) рівно 5 значень, а range(a, b) має рівно b − a значень. Загальна формула кількості — з округленням угору:

Підстав range(2, 12, 3): (12 − 2) / 3 = 3.33…, угору — 4. І справді 2, 5, 8, 11 — чотири числа, останнє менше за 12. Покрути повзунки й перевір формулу на будь-яких значеннях, включно з відʼємним кроком і порожнім результатом:

Тепер найважливіше про range, і це те, що майже ніколи не пояснюють новачкам. range — не список. Він не зберігає числа, а обчислює чергове за формулою старт + i · крок у момент, коли його попросили. Перевір напряму:

Мільйон чисел у range займає 48 байтів — стільки ж, скільки й пʼять чисел. Він тримає лише старт, стоп і крок. Той самий мільйон у списку — вісім мегабайтів. Тому for i in range(1_000_000) запускається миттєво й не їсть памʼять, а for i in list(range(1_000_000)) спершу чесно збудує весь список.

04 / Париenumerate і zip

Іноді індекс усе-таки потрібен — наприклад, щоб надрукувати пронумерований чек. Для цього є enumerate: він бере ітерований обʼєкт і віддає пари «номер, елемент».

Нумерація починається з нуля, як усюди в Python. Але людям звичніше з одиниці — тому в enumerate є другий аргумент: enumerate(покупки, start=1) дасть 1, 2, 3, 4, 5. Важливо: start зсуває лише лічильник, а не початок обходу. Перший елемент усе одно буде «хліб», просто з номером 1.

Друга ситуація — треба йти двома наборами одночасно. Назви лежать в одному списку, кількості в другому, і потрібні вони парами. Для цього є zip — назва від застібки-блискавки, яка зчіплює два ряди зубців:

І тут ховається поведінка, яку треба знати заздалегідь, бо мовчки вона нічого не скаже: zip зупиняється на найкоротшому наборі. Якщо кількостей чотири, а покупок пʼять, ти отримаєш чотири пари — і жодного попередження про те, що «сіль» лишилась без пари. Подивись, як утворюються пари в обох випадках:

05 / Керуванняbreak і continue

Іноді проходити всю колекцію до кінця не треба. Два ключові слова змінюють хід циклу, і плутають їх постійно:

• break — вийти з циклу зовсім. Решта елементів не буде розглянута ніколи. Виконання продовжиться з першого рядка після циклу.
• continue — перейти до наступного елемента. Решта тіла на цьому кроці пропускається, але сам цикл живий і йде далі.

Найкраще різниця видно, коли той самий цикл виконати тричі, міняючи лише одне слово. Рахуємо суму цін, але дорогі позиції (понад 100 грн) хочемо обійти:

Слово pass — це офіційна заглушка «нічого не роби»: Python вимагає, щоб у тілі if був хоч один рядок, і pass цю вимогу задовольняє, не роблячи нічого. Тепер підстав по черзі всі три варіанти:

06 / elseГілка, яку майже всі розуміють неправильно

У Python у циклу може бути else. Конструкція рідкісна, і майже кожен, хто бачить її вперше, читає її неправильно — як «якщо цикл не виконався» або «якщо колекція порожня». Обидва прочитання хибні.

Правило одне, і воно просте: else виконується тоді, коли цикл завершився природно — тобто без break. Якщо break спрацював, гілка else пропускається.

Через це багато хто пропонує читати це слово не як «інакше», а як «якщо не перервали» — або, ще точніше, «nobreak». Класичне застосування — пошук:

Без else довелось би заводити окрему змінну-прапорець (знайдено = False, потім знайдено = True перед break, потім перевірка після циклу). Гілка else робить те саме без зайвої змінної. Зверни увагу на відступ: else вирівняно з for, а не з if — це else саме циклу.

07 / whileКоли кількість кроків невідома

for добрий, коли є що обходити. Але буває інакше: кроків стільки, скільки треба, і скільки саме — заздалегідь невідомо. Тоді береться while — «поки». Він повторює тіло, доки умова залишається істинною:

Умова перевіряється перед кожним повторенням, у тому числі перед найпершим. Якщо вона хибна одразу, тіло не виконається жодного разу. Правила істинності — ті самі, що в темі 11: порожній список у while хибний, непорожній — істинний.

І тут зʼявляється єдина справжня небезпека циклів. Умова сама себе не змінить. Якщо в тілі немає нічого, що рухає її до хибності, — цикл не завершиться ніколи. Програма зависне, вентилятор загуде, і зупинити її доведеться через Ctrl+C. Постав крок у нуль і подивись, що станеться:

Профілактика проста і складається з трьох звичок:

1. Перед тим як писати while, скажи вголос, що саме в тілі наближає умову до хибності. Не можеш назвати рядок — цикл нескінченний.
2. Перевір крайні значення. Нуль, відʼємне, порожній список — саме там ламається.
3. Обмеж кількість спроб, якщо умова залежить від зовнішнього світу: while спроб < 5 and not вдалось:.

Окремо варто знати цілком легальну ідіому while True: — нескінченний цикл навмисне, з виходом через break усередині. Так пишуть, коли умову зручніше перевіряти не на початку, а посередині тіла: наприклад, спершу спитати щось у користувача, а потім вирішити, чи виходити. Різниця з випадковим зациклюванням одна: тут вихід є, і він видимий у коді.

08 / ВкладеніЦикл усередині циклу

Тіло циклу — звичайний код, отже, в ньому може стояти інший цикл. Внутрішній проходить повністю на кожен крок зовнішнього. Якщо зовнішній робить 3 кроки, а внутрішній 4, тіло внутрішнього виконається 3 × 4 = 12 разів.

Класична демонстрація — таблиця множення:

Тут добре видно розподіл ролей: внутрішній print має відступ у вісім пробілів і належить внутрішньому циклу — він друкує клітинки. А print() з відступом у чотири пробіли належить зовнішньому циклу: він виконується один раз на рядок і переносить каретку. Помилка на один рівень відступу тут одразу видно в результаті — і це найкращий спосіб відчути, що відступ у Python не оформлення, а синтаксис.

У нашому кошику вкладені цикли дадуть прайс «скільки коштує k штук»:

Про вкладені цикли треба знати одну неприємну річ: вони множать роботу. Два вкладені цикли по n кроків — це n² повторень тіла. На n = 100 це 10 тисяч, ще терпимо; на n = 10 000 це вже сто мільйонів, і програма думатиме хвилини. Коли бачиш вкладений цикл по тих самих даних — варто спитати, чи не можна замінити внутрішній пошук на множину або словник, де перевірка коштує O(1). Це рівно та розмова, яку ми вели в темі 10.

09 / ПасткаЗміна колекції під час обходу

А тепер найдорожча помилка цієї теми. Виглядає вона абсолютно природно: обходимо список і викидаємо з нього те, що не потрібне.

Помилки немає, програма не впала, результат неправильний. Це найгірший вид бага — той, що мовчить.

Причина в тому, як for ходить по списку. Усередині він тримає прихований лічильник позиції: віддав елемент 0, збільшив на одиницю, віддав елемент 1, збільшив… Коли ти видаляєш елемент, усі, хто стояв правіше, зсуваються вліво на одну комірку — а лічильник про це не знає й однаково йде вперед. Один елемент проскакує повз. Пройди покроково й подивись на прихований індекс:

Правильних способів три, і всі три варто знати:

Перший — найкоротший і найчастіший: квадратні дужки [:] роблять поверхневу копію (тема 06), цикл іде по ній, а remove псує оригінал — і ці двоє більше не заважають одне одному. Другий — найчесніший: нічого не ламаємо, а будуємо новий список. Саме він у темі 13 перетвориться на один рядок.

10 / УсерединіІтератор, і чому він одноразовий

Розділ для тих, кому мало «працює — і добре». Ми весь час казали «for просить наступний елемент». У кого саме він просить?

Насправді за цим стоять два різні поняття. Ітерований обʼєкт (iterable) — це той, у кого можна попросити ітератор: список, рядок, словник, множина, range. Ітератор (iterator) — маленький обʼєкт із єдиним умінням: віддати наступний елемент і запамʼятати, де він зупинився. Цикл for — це синтаксичний цукор над трьома діями:

З цієї механіки випливають три речі, які пояснюють раніші дивацтва.

Ітератор одноразовий. Він не вміє повертатись на початок — позиція тільки росте. Це не видно на списку (бо for щоразу просить новий ітератор), але одразу видно на zip чи enumerate, які самі є ітераторами:

Другий цикл не впаде з помилкою — він просто не зробить жодного кроку, бо перший next() одразу дасть StopIteration. Це одна з найпідступніших несподіванок Python. Ліки: якщо результат потрібен двічі, зафіксуй його списком — пари = list(zip(покупки, кількості)).

Прихований лічильник — це поле ітератора. Ось звідки береться пастка з розділу 09: list_iterator тримає позицію, а не копію списку. Видалив елемент — список зсунувся, позиція лишилась. Тепер зрозуміло, чому обхід копії лікує: у копії ніхто нічого не зсуває.

І звідси ж — вирок конструкції for i in range(len(покупки)). Вона працює, але робить зайве коло: замість того щоб узяти елемент, який ітератор і так має віддати, ти береш число, а потім ідеш по нього в список ще раз. Порівняй три записи однієї задачі:

Єдиний випадок, де range(len(...)) справді доречний, — коли індекс потрібен не для читання, а для запису в той самий список: покупки[i] = покупки[i].upper(). Ітератор віддає значення, а не комірку, тож присвоїти через змінну циклу неможливо — і тоді номер комірки справді потрібен.

11 / ПідсумокЩо забрати з теми

Одна конструкція, яка знімає обмеження з усього попереднього блоку:

• for обходить, а не рахує. Він просить наступний елемент, тому працює однаково зі списком, кортежем, рядком, множиною й словником. Індекси при цьому не потрібні.
• Словник обходиться трьома вікнами. Сам по собі — по ключах, .values() — по значеннях, .items() — парами, які for одразу розпаковує у дві змінні.
• range — не список. Він тримає три числа й обчислює решту на льоту; мільйон значень коштує 48 байтів. Стоп ніколи не входить.
• enumerate дає номер, zip зчіплює набори — і мовчки зупиняється на найкоротшому, якщо не поставити strict=True.
• break виходить із циклу, continue — лише з поточного кроку. Обидва діють на найближчий цикл, не на всі.
• else у циклі — це «якщо не було break». На порожній колекції він теж спрацює: кроків не було, перерви теж не було.
• while — коли кроків невідомо. Умова сама себе не змінить: якщо в тілі немає рядка, що веде її до хибності, цикл нескінченний.
• Не змінюй колекцію, поки її обходиш. Список тихо перескочить елемент, словник кине RuntimeError. Обходь копію (покупки[:], list(ціни)) або збирай новий набір.

У темі 13 ми візьмемо найчастіший цикл із усіх — той, що збирає новий список з наявного, — і запишемо його одним рядком. Це спискове включення, і саме звідти беруться ті [[0] * 3 for _ in range(3)], які ми двічі просили просто запамʼятати. Тепер у тебе є все, щоб зрозуміти, чому цей рядок означає рівно те, що означає.