Comment puis-je donner du sens de l ` "autre" clause de Python boucles?

(Ce qui est inspirée par @Mark Tolonen de la réponse.)

Un if instruction s'exécute ses else clause si sa condition est false.
De manière identique, un while boucle s'exécute la clause else si sa condition est false.

Cette règle correspond au comportement que vous avez décrit:

• En exécution normale, la boucle s'exécute tant que la condition est false, et donc naturellement la sortie de la boucle s'exécute la clause else.
• Lorsque vous exécutez une break déclaration, vous sortir de la boucle sans évaluation de la condition, de sorte que la condition ne peut pas évaluer de faux et vous ne faites jamais fonctionner la clause else.
• Lorsque vous exécutez une continue déclaration, vous l'évaluation de l'état de nouveau, et faire exactement ce que vous le feriez normalement au début d'une itération de boucle.
  Donc, si la condition est vraie, vous gardez en boucle, mais si il est faux d'exécuter la clause else.
• D'autres méthodes de sortir de la boucle, comme return, ne permettent pas d'évaluer l'état et, par conséquent, de ne pas exécuter la clause else.

for boucles se comportent de la même manière. Il suffit de considérer l'état comme vrai si l'itérateur a plus d'éléments, ou false sinon.

Quand un if exécuter une else? Lors de sa condition est fausse. C'est exactement le même pour la while/else. Ainsi, vous pouvez penser de while/else comme un if qui maintient l'exécution de sa véritable condition, jusqu'à ce qu'elle renvoie la valeur faux. Un break ne change pas. Il saute de l'contenant boucle avec aucune évaluation. Le else est exécuté seulement si l'évaluation la if/while condition est fausse.

La for est similaire, à l'exception de ses fausses condition est épuisant son itérateur.

continue et break ne pas exécuter else. Ce n'est pas leur fonction. Le break quitte le contenant de la boucle. Le continue remonte vers le haut de la boucle, où la condition de la boucle est évaluée. C'est l'acte de l'évaluation de if/while false (ou for n'a pas plus d'éléments) qui s'exécute else et pas d'autre moyen.

Si vous pensez à votre boucle comme une structure similaire à ceci (un peu de pseudo-code):

loop:
if condition then

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

il pourrait faire un peu plus de sens. Une boucle est essentiellement juste un if instruction est répétée jusqu'à ce que la condition est false. Et c'est le point important. La boucle vérifie son état et voit que c'est false, ainsi exécute la else (tout comme un normal if/else) et puis la boucle est terminée.

Donc d'avis que le else seulement est exécutée lorsque la condition est vérifiée. Cela signifie que si vous quittez le corps de la boucle dans le milieu de l'exécution avec par exemple un return ou un break, puisque la condition n'est pas vérifié à nouveau, le else cas ne sera pas exécutée.

Un continue sur l'autre main, elle arrête l'exécution, puis saute en arrière pour vérifier l'état de la boucle de nouveau, c'est pourquoi la else peut être atteint dans ce scénario.

Habituellement, j'ai tendance à penser à une structure de boucle comme ceci:

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

À être un peu comme un nombre variable de if/elif états:

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])

Dans ce cas, le else déclaration sur la boucle fonctionne exactement comme le else déclaration sur la chaîne de elifs, il s'exécute uniquement si aucune des conditions avant d'évaluer la valeur True. (ou la rupture d'exécution avec return ou une exception) Si ma boucle ne correspond pas à cette spécification habituellement j'ai choisi de ne pas utiliser for: else pour la raison exacte que vous avez posté cette question: il est non-intuitive.

Dans Développement piloté par les tests (ATS), lors de l'utilisation de la La Transformation De Priorité Prémisse paradigme, vous le traitez de boucles comme une généralisation des instructions conditionnelles.

Cette approche combine bien avec cette syntaxe, si vous considérez que de simples if/else (pas de elif) déclarations:

if cond:
    # 1
else:
    # 2

généralise à:

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

bien.

Dans d'autres langues, TDD étapes à partir d'un seul cas à cas, avec des collections nécessitent plus de refactoring.

---

Voici un exemple de 8thlight blog:

Dans l'article lié à 8thlight blog, le retour de kata est considéré comme: l'ajout des sauts de ligne à cordes (le s variable dans les extraits ci-dessous) pour les adapter à une largeur (la length variable dans les extraits ci-dessous). A un moment, la mise en œuvre se présente comme suit (en Java):

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

et le test suivant, qui, actuellement, ne parvient pas est:

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

Nous avons donc le code qui fonctionne de manière conditionnelle: lorsqu'une condition particulière est remplie, un saut de ligne est ajouté. Nous voulons améliorer le code pour gérer plusieurs sauts de ligne. La solution présentée dans l'article propose d'appliquer le (si->alors que) transformation, cependant, l'auteur fait un commentaire que:

Tandis que les boucles ne peuvent pas avoir else clauses, donc nous avons besoin d'éliminer le else chemin en faisant moins dans le if chemin. Encore une fois, c'est un refactoring.

ce qui oblige à faire plus de modifier le code dans le contexte d'un test en échec:

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

En TDD nous voulons écrire moins de code possible de faire des tests passent. Grâce à Python syntaxe de la transformation suivante est possible:

à partir de:

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

Pense de la else clause comme étant la partie de la boucle de construire, break des pauses hors de la boucle de construire entièrement, et donc ignore le else clause.

Mais vraiment, mon mental mapping est simplement que c'est le 'structurés' version du modèle C/C++ pattern:

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

Donc quand je rencontre des for...else ou l'écrire moi-même, plutôt que de comprendre qu'il directement, je me mis à le traduire dans la compréhension de la structure et ensuite travailler sur les parties de la syntaxe de python carte à certaines parties du motif.

(J'ai mis 'structurés' dans guillemets parce que la différence n'est pas de savoir si le code est structuré ou non, mais simplement de savoir si il ya des mots-clés et de la grammaire dédié à la structure particulière)

Si vous essayez de paire else avec for dans votre esprit, il peut être source de confusion. Je ne pense pas que le mot-clé else était un bon choix pour cette syntaxe, Mais si vous avez une paire else avec break, vous pouvez le voir il fait réellement sens.

Permettez-moi de le démontrer dans le langage humain.

for chaque personne dans un groupe de suspects if quelqu'un est le criminel
break l'enquête. else une défaillance de l'état.

else est à peine utile si il n'y avait pas break dans le for boucle de toute façon.