Python: la Poursuite de la prochaine itération dans la boucle externe

Je voulais savoir si il y a tout intégré dans les moyens de continuer à la prochaine itération dans la boucle externe en python. Par exemple, considérez le code:

for ii in range(200):
    for jj in range(200, 400):
        ...block0...
        if something:
            continue
    ...block1...

Je veux que cette instruction continue pour quitter le jj boucle et goto élément suivant dans la partie ii de la boucle. Je peux mettre en œuvre cette logique d'une autre façon (par la définition d'une variable d'indicateur), mais est-il un moyen facile de faire cela, ou est-ce trop demander?

Il existe réellement un travail instruction goto pour Python: entrian.com/goto. Il a été libéré comme un poisson d'avril :-), mais est censé fonctionner.
Oh, s'il vous plaît ne pas l'utiliser goto blague! Il est remarquablement intelligent, mais vous serez triste, plus tard, si vous le mettez dans votre code.

InformationsquelleAutor Sahas | 2009-12-07

loops python

53
```
for i in ...:
    for j in ...:
        for k in ...:
            if something:
                # continue loop i
```
Dans un cas général, lorsque vous avez plusieurs niveaux de lecture en boucle et break ne fonctionne pas pour vous (parce que vous souhaitez continuer à l'une de la partie supérieure de boucles, pas celui qui est juste au-dessus de celui en cours), vous pouvez effectuer l'une des opérations suivantes

Refactoriser les boucles que vous voulez échapper dans une fonction
```
def inner():
    for j in ...:
        for k in ...:
            if something:
                return


for i in ...:
    inner()
```
L'inconvénient est que vous devrez peut-être passer à cette nouvelle fonction de certaines variables, qui étaient auparavant dans la portée. Vous pouvez soit passer comme paramètres, de les rendre variables d'instance d'un objet (créer un nouvel objet juste pour cette fonction, si elle fait sens), ou des variables globales, les singletons, quoi (euh, euh).

Ou vous pouvez définir inner comme une fonction imbriquée et laissez simplement capturer ce dont il a besoin (peut-être plus lent?)
```
for i in ...:
    def inner():
        for j in ...:
            for k in ...:
                if something:
                    return
    inner()
```
Utiliser les exceptions

Philosophiquement, c'est ce que font exception, brisant le déroulement du programme, par le biais de la programmation structurée blocs de construction (if, for, while) lorsque cela est nécessaire.

L'avantage est que vous n'avez pas à briser le seul morceau de code en plusieurs parties. C'est bon si c'est une sorte de calcul que vous êtes à la conception de tout écrit en Python. L'introduction des abstractions à ce stade précoce peut vous ralentir.

Mauvaise chose avec cette approche est que l'interpréteur/compilateur auteurs postulent que les exceptions sont exceptionnelles et d'optimiser en conséquence.
```
class ContinueI(Exception):
    pass


continue_i = ContinueI()

for i in ...:
    try:
        for j in ...:
            for k in ...:
                if something:
                    raise continue_i
    except ContinueI:
        continue
```
Créer une exception de classe pour cela, de sorte que vous ne risquez pas accidentellement taire certaines autres exceptions.

Quelque chose d'autre entièrement

Je suis sûr qu'il existe encore d'autres solutions.
- Ne peux pas croire que je ne pense pas que d'un déplacement de mon deuxième boucle à une autre méthode. Je suis lent
- Pour moi, à l'aide d'Exceptions est un bon moyen d'y parvenir. Je suis d'accord avec @user7610 - "du point de vue philosophique, c'est ce que les exceptions sont pour".
InformationsquelleAutor user7610
132
```
for ii in range(200):
    for jj in range(200, 400):
        ...block0...
        if something:
            break
    else:
        ...block1...
```
Break va casser la boucle interne, et bloc1 ne sera pas exécutée (il sera exécuté que si la boucle intérieure est sorti normalement).
- Salut, existe-il d'autres options comme cela? Parce que je veux faire une autre boucle for dans bloc1, et comme ça mon code irait à 3 niveaux de profondeur. Situation bizarre.
- Pour moi, cela sonne comme vous essayez de faire quelque chose avec des boucles for qui serait la meilleure façon d'aborder d'une manière différente...
- Oui. C'est pourquoi je n'ai pas utiliser le pour..le reste de la structure. Maintenant, j'aurais quand même besoin pour les boucles, mais je vais utiliser le drapeau des variables pour les détourner de contrôle.
- for...else est souvent utile de construire, même si elle peut être source de confusion. Rappelez-vous juste que else signifie "pas de rupture" dans ce contexte.
- Cela semble être limitée à seulement deux couches de boucles. J'ai besoin de mise à jour du code, qui dispose de trois boucles imbriquées, et un nouveau client exigence signifie que, dans certaines circonstances, le plus intime de la boucle besoin de continuer à la prochaine itération de la boucle ultrapériphérique. Je suppose que votre suggestion ne s'appliquerait pas à ce scénario.
- Plus de détails sur la façon dont cela fonctionne: python-notes.curiousefficiency.org/en/latest/python_concepts/...
InformationsquelleAutor culebrón
40

Dans d'autres langues vous pouvez étiquette de la boucle et de la pause de la étiquetés de la boucle. Python Amélioration de la Proposition (PEP) 3136 a suggéré d'ajouter ces Python mais Guido rejeté:
Cependant, je suis de rejet sur la base de ce code si compliqué à
besoin de cette fonctionnalité est très rare. Dans la plupart des cas, il existe des
des solutions de rechange que produire du code propre, par exemple à l'aide de "retour".
Alors que je suis sûr qu'il y a quelques (rares) cas réels où la clarté de l'
code souffrirait d'un refactoring qui rend possible l'utilisation d'
de retour, cela est compensé par deux questions:
1. De la complexité ajoutée à la langue, en permanence. Cela affecte pas
  seulement toutes les implémentations de Python, mais aussi la source de l'outil d'analyse,
  plus de cours tous les documents de la langue.
2. M'attends à ce que la fonctionnalité sera abusé plus que
  utilisé correctement, conduisant à une nette diminution dans le code de la clarté (mesurée à travers
  tous les code Python écrit désormais). Paresseux programmeurs sont partout,
  et avant que vous savez que vous avez un incroyable désordre sur vos mains de
  inintelligible code.
Donc si c'est ce que vous espériez, vous êtes hors de la chance, mais regardez l'une de l'autre les réponses qu'il y a de bonnes options.
- Intéressant. Je suis d'accord avec Guido ici. Alors qu'il serait bien pour certains cas, il serait abusé. Une autre raison pour ne pas mettre en œuvre, c'est que pour l'instant il est assez simple de code de port de retour et vient entre le C et le Python. Une fois que Python commence à ramasser des fonctionnalités que d'autres langues de l'absence cela devient plus difficile. Prenez par exemple le fait que vous pouvez avoir une autre déclaration sur une boucle for en Python... ce qui rend le code moins portable à d'autres langues.
- Je te salue, Guido notre BDFL
- Ce n'est plus un rouge-heiring qu'un bon contre-argument, mais il me semble que le comportement de for-else est plus compliqué, plus difficile à lire, et probablement plus abusé (si ce n'est carrément une erreur) que nommé boucles serait. Je pense que j'aurais utilisé un autre mot-clé que else - peut-être quelque chose comme resume aurait été bon? Vous break dans la boucle et la resume est à droite après il?
- Cela me rend triste. Je ne peux pas croire à quel point je l'aime et la déteste Python en même temps. Tellement beau et tellement wtf.
- Surtout wtf pour moi. Parfois, je pense qu'il veut être différent pas pour but légitime, mais juste pour être différent. C'est un bon exemple. Je tombe sur la nécessité de briser les boucles externes assez souvent.
InformationsquelleAutor Dave Webb
12

Je pense que vous pourriez faire quelque chose comme ceci:
```
for ii in range(200):
    restart = False
    for jj in range(200, 400):
        ...block0...
        if something:
            restart = True
            break
    if restart:
        continue
    ...block1...
```
- -1: L'OP a clairement déclaré qu'ils savaient qu'ils pouvaient faire quelque chose comme cela, et cela ressemble à un messier version de la accepté de répondre (ce qui est antérieure à la vôtre en 8 mois, donc il ne pouvait en être que vous avez raté de peu la accepté de répondre).
- L'on a accepté la réponse n'est pas claire si vous ne l'avez jamais vu for, else avant (et je pense même que la plupart des gens qui ont ne peut pas se souvenir sur le dessus de leur tête, comment il fonctionne).
InformationsquelleAutor asmeurer

Une autre façon de traiter ce genre de problème est l'utilisation d'Exception().

for ii in range(200):
    try:
        for jj in range(200, 400):
            ...block0...
            if something:
                raise Exception()
    except Exception:
        continue
    ...block1...

Par exemple:

for n in range(1,4):
    for m in range(1,4):
        print n,'-',m

résultat:

En supposant que nous avons envie de sauter à l'extérieur de la n de la boucle de boucle m si m =3:

for n in range(1,4):
    try:
        for m in range(1,4):
            if m == 3:
                raise Exception()            
            print n,'-',m
    except Exception:
        continue

résultat:

Lien de référence:http://www.programming-idioms.org/idiom/42/continue-outer-loop/1264/python

InformationsquelleAutor Patrick

1

Nous voulons trouver quelque chose et puis arrêtez l'intérieur de l'itération. J'utilise un système de drapeau.
```
for l in f:
    flag = True
    for e in r:
        if flag==False:continue
        if somecondition:
            do_something()
            flag=False
```
- Je ne sais pas pourquoi votre solution est downvoted; quelqu'un a posté fondamentalement exactement la même chose et a obtenu upvoted 10 fois
- Je ne suis pas très chanceux avec stackoverflow.
- Peut-être parce qu'il est fondamentalement exactement la même chose déjà posté ici, je suppose... Et la False:continue, c'est... rare de mise en forme. Comme c'est souvent le cas dans "naturelle" des systèmes où l'exponentielle sont la norme, vous n'avez qu'à avoir de la chance à quelques reprises sur AFIN d'amasser quantité importante de points de réputation. De toute façon, mes "meilleures" réponses sont généralement les moins populaires.
InformationsquelleAutor Esther

Je pense que l'un des moyens les plus simples d'y parvenir est de remplacer "continuer" avec "break" de l'énoncé,c'est à dire

for ii in range(200):
 for jj in range(200, 400):
    ...block0...
    if something:
        break
 ...block1...

Pour exemple, voici le code facile de voir comment il va sur:

for i in range(10):
    print("doing outer loop")
    print("i=",i)
    for p in range(10):
        print("doing inner loop")
        print("p=",p)
        if p==3:
            print("breaking from inner loop")
            break
    print("doing some code in outer loop")

InformationsquelleAutor Khelina Fedorchuk

0

J'ai juste fait quelque chose comme cela. Ma solution était de remplacer l'intérieur de la boucle avec une compréhension de liste.
```
for ii in range(200):
    done = any([op(ii, jj) for jj in range(200, 400)])
    ...block0...
    if done:
        continue
    ...block1...
```
où op est certains opérateur booléen agissant sur une combinaison de ii et jj. Dans mon cas, si l'une de ces opérations a renvoyé true, j'ai été fait.

Ce n'est vraiment pas différent de casser le code dans une fonction, mais je pensais qu'en utilisant le "tout" de l'opérateur de faire un OU logique sur une liste de booléens et de faire de la logique dans une seule ligne a été intéressant. Il évite aussi l'appel de la fonction.

InformationsquelleAutor cagem12

Vous devez vous connecter pour publier un commentaire.

Refactoriser les boucles que vous voulez échapper dans une fonction

Utiliser les exceptions

Quelque chose d'autre entièrement