Comment voulez-vous créer une boucle avec une plage dynamique?

Je suis itérer sur une liste. Un élément peut être ajouté à cette liste au cours d'une itération. Donc, le problème, c'est que la boucle uniquement parcourt la longueur d'origine de cette liste.

Mon code:

    i = 1
    for p in srcPts[1:]:  # skip the first item.
        pt1 = srcPts[i - 1]["Point"]
        pt2 = p["Point"]

        d = MathUtils.distance(pt1, pt2)
        if (D + d) >= I:
            qx = pt1.X + ((I - D) / d) * (pt2.X - pt1.X)
            qy = pt1.Y + ((I - D) / d) * (pt2.Y - pt1.Y)
            q  = Point(float(qx), float(qy))
            # Append new point q.
            dstPts.append(q)
            # Insert 'q' at position i in points s.t. 'q' will be the next i.
            srcPts.insert(i, {"Point": q})
            D = 0.0
        else:
            D += d
        i += 1

J'ai essayé d'utiliser for i in range(1, len(srcPts)): mais là encore, la gamme reste la même, même après plus d'éléments ont été ajoutés à la liste.

OriginalL'auteur Tejen Shrestha | 2013-03-31

python

5

Le problème est que len(srcPts) est calculé uniquement une fois, quand vous le passer en argument à la range générateur. Si vous avez besoin d'avoir une condition d'arrêt qui évalue à plusieurs reprises à la longueur actuelle de srcPts lors de chaque itération. Il y a beaucoup de façons de le faire, tels que :
```
while i < len(srcPts):


  ....
```
Merci, je suis comme un Python de noob.

OriginalL'auteur Charles Salvia
9

Vous devez utiliser un while boucle plutôt dans ce cas:
```
i = 1
while i < len(srcPts):
    # ...
    i += 1
```
Un for boucle crée un itérateur pour votre liste, une fois. Et une fois créé, qui itérateur ne savez pas que vous avez modifié la liste dans la boucle. Le while variante illustrée ici recalcule la longueur de chaque temps de la place.

Eh bien, ce n'est pas vrai. Python permet de modifier la liste que vous avez à parcourir. En fait, lorsque vous ajouter à une liste, il analyse à travers cet élément ajouté, de même pour l'insertion d'éléments. Pour faire une copie de votre liste pour itérer sur elle, vous pouvez écrire for i in lst[:]: ou faire d'autres trucs. En savoir plus sur ce ici.
Je n'ai pas dit que Python ne vous permet pas de vous, je l'ai dit la for boucle ne connaît pas la liste a été modifiée. Notez que l'OP déjà utilisé le découpage ici. Il est en boucle sur une copie partielle (tous sauf le 1er élément).
Et c'est le point ici; l'OP veut la boucle d'inclure des éléments ajoutés, inséré dans le corps de la boucle.
Je vois. Je rappelle que la pour boucle sait que vous avez changé d'itérateur/liste lorsque vous ne créez pas une copie, et peut donc effectuer une itération sur ces nouveaux éléments ajoutés. Lorsque vous ne découpage cependant, vous créez une copie et ne peut pas effectuer une itération sur de nouveaux éléments.

OriginalL'auteur Martijn Pieters
1

Dans la ligne:
```
for p in srcPts[1:]:  # skip the first item.
```
découpage fait une nouvelle copie de scrPtrs, de sorte qu'il est de taille fixe.

Avertissement: Il se sent mal à modifier une liste itérateur sur, mais cela fonctionne...

Créer un itérateur sur la liste empêche la copie et permet encore des éléments à ajouter, et inséré:
```
L = [1,2,2,3,4,5,2,2,6]
it = iter(L)
next(it) # skip the first item
for i,p in enumerate(it,1):
    if p == 2:
        L.insert(i+1,7) # insert a 7 as the next item after each 2
    print(p)
```
De sortie:
```
2
7
2
7
3
4
5
2
7
2
7
6
```
OriginalL'auteur Mark Tolonen

Vous devez vous connecter pour publier un commentaire.