En python est-il un moyen plus facile d'écrire des 6 boucles for imbriquées?

Ce problème a été faire chez moi pour un certain temps maintenant. Est-il un moyen plus facile d'écrire imbriquée for boucles en python? Par exemple si mon code est allé quelque chose comme ceci:

  for y in range(3):
    for x in range(3):
      do_something()
      for y1 in range(3):
        for x1 in range(3):
          do_something_else()

y aurait-il un moyen plus facile de faire cela? Je sais que ce code fonctionne, mais lorsque vous tiret au lieu d'utiliser 2 espaces, comme moi, il peut arriver à être un problème.

Oh dans l'exemple il n'y avait que 4 imbriquée for boucles pour faciliter les choses.

Voir aussi.

InformationsquelleAutor saleh | 2009-08-14

57

Si vous êtes souvent une itération sur un produit Cartésien comme dans votre exemple, vous pourriez vouloir étudier La version 2.6 de Python est itertools.produit -- ou écrire votre propre si vous êtes dans un précédent Python.
```
from itertools import product
for y, x in product(range(3), repeat=2):
  do_something()
  for y1, x1 in product(range(3), repeat=2):
    do_something_else()
```
- Si l'imbrication de boucle comme ceci: for y in range(3): do_something1() for x in range(3): do_something() comment puis-je utiliser le produit
- Sans indentation, il est impossible de dire ce que vous essayez de faire. Je vous conseille de le demander une nouvelle StackOverflow question plutôt que d'essayer d'obtenir de l'aide dans les commentaires.
InformationsquelleAutor Alice Purcell
14

Cette situation est assez courante quand passa au-dessus des espaces multidimensionnels. Ma solution est:
```
xy_grid = [(x, y) for x in range(3) for y in range(3)]

for x, y in xy_grid:
    # do something
    for x1, y1 in xy_grid:
        # do something else
```
- Aussi, si vous avez un grand nombre d'éléments de la boucle à travers, il pourrait être préférable d'utiliser un générateur d'expression c'est à dire xy_grid = ((x,y) for x in range(30000) for y in range(30000)).
InformationsquelleAutor tom10
10

Lorsqu'ils sont confrontés à ce genre de logique de programme, je serais probablement briser la séquence de la boucle en deux ou plus de deux fonctions distinctes.

Une autre technique en Python est d'utiliser interprétations de la liste si possible, au lieu d'une boucle.

InformationsquelleAutor Greg Hewgill
8

En supposant que chaque boucle a une sorte de signification autonome, les sortir dans des fonctions nommées:
```
def do_tigers():
    for x in range(3):
        print something

def do_lions():
    do_lionesses()
    for x in range(3):
        do_tigers()

def do_penguins():
    for x in range(3):
        do_lions()

..etc.
```
Je pourrais peut-être mieux choisir les noms. 😎
- Oh, pas de chatons 🙁
- Je ferais le club si j'étais un lion.
- Eh bien, c'est une façon d'avoir des chatons... Si, un peu plus gros que ce que j'avais à l'esprit.
InformationsquelleAutor RichieHindle
5

Techniquement, vous pouvez utiliser itertools.product pour obtenir un produit cartésien de N séquences, et d'itérer sur que:
```
 for y, x, y1, x1 in itertools.product(range(3), repeat=4):
   do_something_else()
```
Mais je ne pense pas que gagne véritablement quelque chose de lisibilité-sage.

InformationsquelleAutor Pavel Minaev
4

Python itérateurs, générateurs et, en particulier, existe exactement pour permettre à la belle refactoring d'ailleurs compliqué de boucles. Bien sûr, il est difficile d'obtenir une abstraction à partir d'un exemple simple, mais en supposant que le 3 doit être un paramètre (peut-être l'ensemble de la range(3) devrait l'être?), et les deux fonctions que vous appelez besoin de certains paramètres qui sont les variables de boucle, vous pouvez refactoriser le code:
```
  for y in range(3):
    for x in range(3):
      do_something(x, y)
      for y1 in range(3):
        for x1 in range(3):
          do_something_else(x, y, x1, y1)
```
dans, par exemple:
```
def nestloop(n, *funcs):
  head = funcs[0]
  tail = funcs[1:]
  for y in range(n):
    for x in range(n):
      yield head, x, y
      if tail:
        for subtup in nestloop(n, *tail):
           yield subtup[:1] + (x, y) + subtup[1:]

for funcandargs in nestloop(3, do_something, do_something_else):
  funcandargs[0](*funcandargs[1:])
```
Exactement le type de refactoring aurez sans doute besoin d'être modifié pour votre exacte, mais le point de vue général que les itérateurs (et en fait de simples générateurs de moyens très agréable refactorings de boucles demeure, tous les le bouclage de la logique va à l'intérieur du générateur, et le niveau de l'application du code est à gauche avec de simples for boucles d'application pertinent pour le traitement des éléments a donné dans les boucles for.

InformationsquelleAutor Alex Martelli
3

Mon argument serait que vous êtes susceptible de faire quelque chose de mal, si vous avez des 6 boucles imbriquées...

Cela dit, décomposition fonctionnelle est ce que vous cherchez. Refactoriser de sorte que certaines des boucles d'arriver à séparer les appels de fonction, puis d'appeler ces fonctions.
- Voici les cas d'utilisation où je n'ai eu que de nombreuses boucles imbriquées: Imaginez l'application d'une 3D gaussienne "flou" filtre 3D dataset; vous avez résument dans les trois directions pour le filtre (3 boucles), et itérer sur tous les points dans les trois directions de l'appliquer (plus de 3 boucles). Oh, et les données que j'ai été le filtrage a été vitesses, donc il y avait trois composants pour effectuer une itération sur (1 final de la boucle).
InformationsquelleAutor Matthew Scharley
3

À partir de votre code, il semble que vous souhaitez effectuer une opération avec chaque paire de points où x et y sont dans la plage 0..2.

À faire:
```
for x1,y1,x2,y2 in itertools.product(range(3), repeat=4):
    do_something_with_two_points(x1,y1,2,y2)
```
L'opération do_something_with_two_points sera appelé 81 fois - une fois pour chaque combinaison possible de points.

InformationsquelleAutor Triptych
2

Avez-vous regardé dans Interprétations De La Liste?

Quelque chose comme:
```
[do_something() for x in range(3) for y in range(3)]
```
InformationsquelleAutor Yancy
2

De cette façon l'air assez simple et facile. Êtes-vous dites que vous voulez généraliser à de multiples niveaux de boucles.... pouvez-vous donner un exemple concret?

Une autre option que je pouvais penser, serait d'utiliser une fonction pour générer les paramètres et ensuite il suffit de les appliquer dans une boucle
```
def generate_params(n):
    return itertools.product(range(n), range(n))

for x,y in generate_params(3):
    do_something()
```
InformationsquelleAutor Joe Koberg
2

vous pouvez également utiliser le map() la fonction

InformationsquelleAutor jle

Vous devez vous connecter pour publier un commentaire.