Як я можу зрозуміти пункт `else` циклів Python?

Багато програмістів Python, напевно, не знають, що синтаксис whileциклів і forциклів включає необов'язковий else:пункт:

for val in iterable:
    do_something(val)
else:
    clean_up()

Тіло elseпропозиції є хорошим місцем для певних видів очищення, і виконується при нормальному завершенні циклу: Тобто, виходить із циклу returnабо breakпропускає elseпункт; вихід після його continueвиконання. Я знаю , що це тільки тому , що я тільки що подивився його (ще раз), тому що я ніколи не можу пригадати , колиelse пропозиція виконується.

Завжди? Про "провал" циклу, як випливає з назви? Про регулярне припинення? Навіть якщо цикл закривається return? Я ніколи не можу бути повністю впевненим, не дивлячись на це.

Я звинувачую свою стійку невпевненість у виборі ключового слова: мені elseздається, що це семантика неймонічно. Моє запитання не в тому, "чому це ключове слово використовується для цієї мети" (яке я, мабуть, проголосую за закриття, хоч лише після прочитання відповідей та коментарів), а як я можу подумати про elseключове слово, щоб його семантика мала сенс, і я Ви можете, отже, пам'ятати про це?

Я впевнений, що про це було досить багато дискусій, і я можу уявити, що вибір був зроблений на узгодження з пунктом tryзаяви else:(який я також повинен шукати), і з метою не додавати до списку Застережені слова Python. Можливо, причини вибору elseз’ясують його функцію та зроблять її більш запам'ятовуваною, але я після того, як підключувати ім’я до функції, а не після історичного пояснення як такого.

Відповіді на це запитання , на яке моє запитання було коротко закрито, як дублікат, містять багато цікавої історії. Моє запитання має іншу спрямованість (як пов’язати конкретну семантику elseз вибором ключового слова), але я вважаю, що десь має бути посилання на це питання.

(На це надихає відповідь @Mark Tolonen.)

Оператор ifвиконує його elseзастереження, якщо його стан оцінюється як хибне. Ідентично whileцикл запускає інший пункт, якщо його стан оцінюється як хибний.

Це правило відповідає поведінці, яку ви описали:

• У звичайному виконанні цикл while декілька разів запускається до тих пір, поки умова не оціниться як false, і, отже, природно, що виходить з циклу, запускається інше.
• Виконуючи breakоператор, ви виходите з циклу, не оцінюючи умову, тому умова не може оцінюватися як хибна, і ви ніколи не запускаєте інше.
• Виконуючи continueоператор, ви знову оцінюєте умову і робите саме те, що зазвичай на початку ітерації циклу. Отже, якщо умова справжня, ви продовжуєте циклічно, але якщо вона помилкова, запускаєте інше.
• Інші методи виходу з циклу, такі як, наприклад return, не оцінюють стан і, отже, не виконують інше.

forпетлі ведуть себе так само. Просто вважайте умову істинною, якщо в ітераторі більше елементів, або в іншому випадку помилковим.

Краще подумати про це так: elseБлок завжди буде виконуватися, якщо в попередньому блоці все піде правильно, щоб досягти forвиснаження.

Правильно в цьому контексті буде означати ні exception, ні break, ні return. Будь-яке твердження, з якого здійснюється викрадення контролю, forпризведе до того, що elseблок буде обійти.

Загальний випадок використання знайдеться під час пошуку предмета в записі iterable, для якого пошук або відміняється, коли предмет знайдено, або "not found"прапор піднімається / друкується через наступний elseблок:

for items in basket:
    if isinstance(item, Egg):
        break
else:
    print("No eggs in basket")  

A continueне викрадає керування з for, тому контроль буде переходити до того, elseяк forвичерпано.

Коли ifвиконується виконання else? Коли його стан помилковий. Це точно те саме для while/ else. Таким чином, ви можете думати про while/ elseяк просто про ifте, що продовжує виконувати справжній стан, поки не оцінить помилкове. А breakце не змінить. Він просто вискакує з циклу, що містить, без оцінки. elseВиконується тільки при оцінці в if/ whileумова помилкова.

Схоже for, за винятком помилкового стану, що виснажує його ітератор.

continueі breakне виконувати else. Це не їхня функція. breakВиходить з містить петлі. continueСходить до верхньої частини , що містить петлі, де обчислюється умова циклу. Це акт оцінки if/ whileпомилкового (або forне має більше предметів), який виконується, elseі жодним іншим способом.

Це те, що по суті означає:

for/while ...:
    if ...:
        break
if there was a break:
    pass
else:
    ...

Це приємніший спосіб написання цього поширеного шаблону:

found = False
for/while ...:
    if ...:
        found = True
        break
if not found:
    ...

elseУмова не буде виконуватися , якщо є , returnтому що returnлистя функція, так як вона призначена для. Єдиний виняток із того, про що ви можете подумати, - це finallyмета бути впевненою, що вона завжди виконується.

continueне має нічого спільного з цим питанням. Це призводить до того, що поточна ітерація циклу закінчується, що може трапитися з цілим циклом, і, очевидно, у цьому випадку цикл не закінчився символом a break.

try/else подібний:

try:
    ...
except:
    ...
if there was an exception:
    pass
else:
    ...

Якщо ви думаєте про свої петлі як структуру, подібну до цієї (дещо псевдокод):

loop:
if condition then

   ... //execute body
   goto loop
else
   ...

це може мати трохи більше сенсу. Цикл - це по суті лише ifзаява, яке повторюється, поки умова не буде false. І це важливий момент. Цикл перевіряє його стан і бачить, що він є false, таким чином виконує else(як і нормальний)if/else ), а потім цикл робиться.

Тож зауважте, що else виконується лише те, коли перевіряється умова . Це означає, що якщо ви виходите з тіла циклу в середині виконання за допомогою, наприклад, a returnабо a break, оскільки умова не перевіряється ще раз,else справа не буде виконана.

А continueз іншого боку зупиняє поточне виконання, а потім стрибає назад, щоб знову перевірити стан циклу, через що elseможна досягти цього сценарію.

Моя ситуація з положенням циклу elseбула, коли я спостерігав за розмовою Реймонда Хеттінгера , який розповів історію про те, як він вважав, що його слід було викликати nobreak. Погляньте на наступний код: як ви думаєте, що це зробить?

for i in range(10):
    if test(i):
        break
    # ... work with i
nobreak:
    print('Loop completed')

Що б ти здогадався, що це робить? Ну, частина, яка говорить nobreak, буде виконуватися лише в тому випадку, якщо breakоператор не потрапив у цикл.

Зазвичай я схильний думати про подібну структуру:

for item in my_sequence:
    if logic(item):
        do_something(item)
        break

Щоб бути схожим на змінну кількість if/elifвисловлювань:

if logic(my_seq[0]):
    do_something(my_seq[0])
elif logic(my_seq[1]):
    do_something(my_seq[1])
elif logic(my_seq[2]):
    do_something(my_seq[2])
....
elif logic(my_seq[-1]):
    do_something(my_seq[-1])

У цьому випадку elseоператор на циклі for працює точно так само, як і elseу ланцюжку elifs, він виконується лише в тому випадку, якщо жодна з умов перед його оцінкою не відповідає True. (або розірвати виконання з returnвинятком) Якщо мій цикл не відповідає цій специфікації, я зазвичай вирішу відмовитися від використання саме for: elseз тієї причини, яку ви опублікували це питання: це не інтуїтивно зрозуміло.

Інші вже пояснили механіку while/for...else, і посилання на мову Python 3 має авторитетне визначення (див. Час і за ), але ось моя особиста мнемологія - FWIW. Я думаю, головним для мене було розбити це на дві частини: одну для розуміння значення терміна elseвідносно циклу та умову для розуміння управління циклом.

Я вважаю, що найпростіше почати з розуміння while...else:

whileу вас є більше предметів, робіть речі, elseякщо ви закінчитеся, робіть це

for...elseМнемонічні в основному те ж саме:

forкожен предмет, робити речі, але elseякщо ви закінчитеся, зробіть це

В обох випадках elseчастина досягається лише після того, як більше елементів не обробляється, а останній елемент обробляється регулярно (тобто немає breakабо return). continueПросто повертається і бачить , якщо є якісь - або інші елементи. Моя мнемонічність щодо цих правил застосовується як whileдо for:

коли breakING або returnING, немає нічого , elseщоб зробити,
і коли я кажу continue, що це «петля назад , щоб почати» для Вас

- маючи на увазі "цикл назад до початку", очевидно, початок циклу, де ми перевіряємо, чи є ще якісь елементи в ітерабелі, тому що elseстосується continueсправді , це взагалі не грає ніякої ролі.

У тестовій розробці (TDD), коли використовується пріоритет трансформації парадигми ви розглядаєте петлі як узагальнення умовних висловлювань.

Цей підхід добре поєднується з цим синтаксисом, якщо розглядати лише прості if/else(ні elif) твердження:

if cond:
    # 1
else:
    # 2

узагальнює:

while cond:  # <-- generalization
    # 1
else:
    # 2

чудово.

Іншими мовами, кроки TDD від одного випадку до справ зі збірниками потребують більшого рефакторингу.

Ось приклад з 8-го блогу :

У пов'язаній статті на 8-му блозі розглядаються ката програми Word Wrap: додавання рядків до рядків ( sзмінна у фрагментах нижче), щоб вони відповідали заданій ширині ( lengthзмінна у фрагментах нижче). В один момент реалізація виглядає наступним чином (Java):

String result = "";
if (s.length() > length) {
    result = s.substring(0, length) + "\n" + s.substring(length);
} else {
    result = s;
}
return result;

і наступний тест, який наразі не вдається, це:

@Test
public void WordLongerThanTwiceLengthShouldBreakTwice() throws Exception {
    assertThat(wrap("verylongword", 4), is("very\nlong\nword"));
    }

Отже, у нас є код, який працює умовно: коли виконується певна умова, додається розрив рядка. Ми хочемо вдосконалити код для обробки кількох розривів рядків. Рішення, представлене у статті, пропонує застосувати (якщо-> поки) трансформацію , однак автор робить коментар, що:

Хоча циклі не можуть мати elseпропозиції, тому нам потрібно усунути elseшлях, роблячи менше вif шляху. Знову ж таки, це рефакторинг.

що змушує зробити більше змін у коді в контексті одного невдалого тесту:

String result = "";
while (s.length() > length) {
    result += s.substring(0, length) + "\n";
    s = s.substring(length);
}
result += s;

У TDD ми хочемо написати якомога менше коду для проходження тестів. Завдяки синтаксису Python можливе наступне перетворення:

від:

result = ""
if len(s) > length:
    result = s[0:length] + "\n"
    s = s[length:]
else:
    result += s

до:

result = ""
while len(s) > length:
    result += s[0:length] + "\n"
    s = s[length:]
else:
    result += s

Я бачу це, else: спрацьовує, коли ви повторюєте повз кінець циклу.

Якщо ви breakабо returnчи raiseви не ітерація в кінці минулого циклу, ви перестаєте immeadiately, і , таким чином, else:блок не буде працювати. Якщо ви continueвсе-таки повторіть кінець циклу, оскільки продовжуйте просто переходити до наступної ітерації. Це не зупиняє цикл.

Подумайте, як цей elseпункт є частиною конструкції циклу; breakвиривається з циклу конструкції цілком, і таким чином пропускаєelse пункт.

Але насправді моє ментальне відображення просто в тому, що це "структурована" версія шаблону C / C ++ шаблону:

  for (...) {
    ...
    if (test) { goto done; }
    ...
  }
  ...
done:
  ...

Тож коли я сам стикаюся for...elseабо пишу це, а не розумію безпосередньо , я подумки перекладаю його на вищезгадане розуміння шаблону, а потім опрацьовую, які частини синтаксису пітона відображають на які частини шаблону.

(Я поклав "структурований" в лапки, тому що різниця полягає не в тому, чи код структурований чи неструктурований, а лише в тому, чи є ключові слова та граматика, присвячені конкретній структурі)

Якщо ви пару elseз for, це може бути заплутаним. Я не думаю, що ключове слово elseбуло чудовим вибором для цього синтаксису, але якщо ви поєднаєте його elseз ifвмістом break, ви можете побачити, що це насправді має сенс. elseледве корисний, якщо немає попередньогоif твердження, і я вважаю, що саме тому конструктор синтаксису обрав ключове слово.

Дозвольте продемонструвати це людською мовою.

forрозслідування ifзлочинців є кожною особою в групі підозрюваних кого-небудь break. elseповідомляти про збій.

Те, як я думаю про це, головне - це розглянути сенс, continueа неelse .

Інші ключові слова, які ви згадуєте, вириваються з циклу (виходять ненормально), в той час як continue це не так, вони просто пропускають залишок блоку коду всередині циклу. Той факт, що він може передувати закінченню циклу, є випадковим: завершення фактично робиться звичайним способом шляхом оцінки умовного виразу циклу.

Тоді вам просто потрібно пам’ятати, що elseстаття виконується після нормального завершення циклу.

# tested in Python 3.6.4
def buy_fruit(fruits):
    '''I translate the 'else' below into 'if no break' from for loop '''
    for fruit in fruits:
        if 'rotten' in fruit:
            print(f'do not want to buy {fruit}')
            break
    else:  #if no break
        print(f'ready to buy {fruits}')


if __name__ == '__main__':
    a_bag_of_apples = ['golden delicious', 'honeycrisp', 'rotten mcintosh']
    b_bag_of_apples = ['granny smith', 'red delicious', 'honeycrisp', 'gala', 'fuji']
    buy_fruit(a_bag_of_apples)
    buy_fruit(b_bag_of_apples)

'''
do not want to buy rotten mcintosh
ready to buy ['granny smith', 'red delicious', 'honeycrisp', 'gala', 'fuji']
'''