Seule La Ligne De Boucles For Imbriquées

A écrit cette fonction en python qui transpose une matrice:

def transpose(m):
    height = len(m)
    width = len(m[0])
    return [ [ m[i][j] for i in range(0, height) ] for j in range(0, width) ]

Dans le processus, j'ai réalisé que je ne comprends pas tout à la façon dont seule la ligne de boucles for imbriquées exécuter. S'il vous plaît aidez-moi à comprendre en répondant aux questions suivantes:

Qu'est-ce que l'ordre dans lequel cette boucle for s'exécute?
Si j'avais un triple imbriqués pour la boucle, dans quel ordre serait-il exécuter?
Ce serait égale l'égalité de désemboîtées pour la boucle?

Donné,

[ function(i,j) for i,j in object ]

Ce type d'objet doit être dans l'ordre de la structure de boucle?
Qu'est-ce que l'ordre dans lequel i et j sont attribuées à des éléments de l'objet?
Peut-il être simulé par un autre pour la structure de boucle?
Cette boucle imbriqué avec un semblable ou différente de la structure de la boucle? Et comment serait-il chercher?

Des informations supplémentaires sont aussi bien appréciés.

InformationsquelleAutor Asher Garland | 2013-06-09

135

La meilleure source d'information est le officiel de Python tutoriel sur les interprétations de la liste. Interprétations de la liste sont pratiquement les mêmes que pour les boucles (certainement toute compréhension de liste peut être écrite comme une boucle for), mais ils sont souvent plus rapide que d'utiliser une boucle for.

Oeil à cette liste plus longue de la compréhension du tutoriel (le if partie des filtres de la compréhension, seules les parties qui passent si l'instruction sont passés dans la dernière partie de la compréhension de liste (ici (x,y)):
```
>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
```
C'est exactement le même que celui de la imbriqués pour la boucle (et, comme le tutoriel dit, notez comment la afin de pour et si sont les mêmes).
```
>>> combs = []
>>> for x in [1,2,3]:
...     for y in [3,1,4]:
...         if x != y:
...             combs.append((x, y))
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
```
Les principaux différence entre une compréhension de liste et d'une boucle for, c'est que la dernière partie de la boucle for (où vous faites quelque chose) vient au début plutôt qu'à la fin.

À vos questions:

Ce type d'objet doit être dans l'ordre de la structure de boucle?

Un itérable. N'importe quel objet qui peut générer un (finie) de l'ensemble des éléments. Ces derniers comprennent tout conteneur des, listes, ensembles, groupes électrogènes, etc.

Qu'est-ce que l'ordre dans lequel i et j sont attribuées à des éléments de l'objet?

Ils sont affectés exactement dans le même ordre qu'ils sont générés à partir de chaque liste, comme s'ils étaient dans une étude pour la boucle (pour votre première compréhension que vous obtenez 1 de l'élément de i, puis pour chaque valeur de j, 2e élément dans i, alors chaque valeur de j, etc.)

Peut-il être simulé par un autre pour la structure de boucle?

Oui, déjà indiqué ci-dessus.

Cette boucle imbriqué avec un semblable ou différente de la structure de la boucle? Et comment serait-il chercher?

Sûr, mais c'est pas une bonne idée. Ici, par exemple, vous donne une liste de listes de caractères:
```
[[ch for ch in word] for word in ("apple", "banana", "pear", "the", "hello")]
```
- Je me demande qui l'a guidé leur choix de commander le double de nidification. - Je trouver les autres de façon plus naturelle (pour y puis pour x dans votre exemple). Je viens de réaliser qu'après 3 ans de python (pas beaucoup mais quand même...) et de l'utilisation de ces types de boucles !!
- bien dit, merci!
InformationsquelleAutor Jeff Tratner
25

Vous pourriez être intéressé par itertools.produit, qui retourne un objet iterable rendement des n-uplets de valeurs de tous les iterables vous passer. C'est, itertools.product(A, B) les rendements de toutes les valeurs de la forme (a, b), où la a valeurs viennent de A et la b valeurs viennent de B. Par exemple:
```
import itertools

A = [50, 60, 70]
B = [0.1, 0.2, 0.3, 0.4]

print [a + b for a, b in itertools.product(A, B)]
```
Cette affiche:
```
[50.1, 50.2, 50.3, 50.4, 60.1, 60.2, 60.3, 60.4, 70.1, 70.2, 70.3, 70.4]
```
Remarquez comment le dernier argument passé à itertools.product est le "intérieure" un. Généralement, itertools.product(a₀, a₁, ... a_n) est égal à [(i₀, i₁, ... i_n) for i_n in a_n for i_n-1 in a_n-1 ... for i₀ in a₀]

InformationsquelleAutor Lynn
2

Tout d'abord, votre premier code ne nécessite pas l'utilisation d'une boucle for en soi, mais un compréhension de liste.
1. Serait équivalent à
  
  for j in range(0, largeur):
  for i in range(0, hauteur):
  m[i][j]
2. De la même manière, il est généralement nids comme pour les boucles, de droite à gauche. Mais la liste de compréhension de la syntaxe est plus complexe.
3. Je ne suis pas sûr de ce qui est demandé
1. Importe quel itérable objet qui rapporte de l'itérable objets qui donnent exactement deux objets (ce que d'une bouchée - je.e [(1,2),'ab'] serait valide )
2. L'ordre dans lequel l'objet produit par itération. i va à la première rendement, j la seconde.
3. Oui, mais pas aussi jolie. Je crois qu'il est fonctionnellement équivalent à:
```
l = list() 
pour i,j dans l'objet: 
l'.append(function(i,j)) 
```
  ou encore mieux utiliser carte:
```
map(function, object)
```
  Mais évidemment fonction serait d'obtenir i, j lui-même.
4. N'est-ce pas la même question 3?
InformationsquelleAutor korylprince

Vous devez vous connecter pour publier un commentaire.