Python: ist es eine C-artige for-Schleife verfügbar?

Kann ich etwas tun, wie dieses in Python?

for (i = 0; i < 10; i++):
  if someCondition:
     i+=1
  print i

Ich muss in der Lage sein zu überspringen, einige Werte basierend auf einer Bedingung

EDIT: Alle die Lösungen, die bisher empfehlen beschneiden der ersten Reihe in die eine oder andere Weise, basierend auf einem bereits bekannten Zustand. Dies ist nicht nützlich für mich, so lassen Sie mich erklären, was ich tun will.

Möchte ich manuell (also nicht getopt) analysieren einige cmd-line args, wo jeder "keyword" hat eine bestimmte Anzahl von Parametern, so etwas wie dieses:

for i in range(0,len(argv)):
    arg = argv[i]
    if arg == '--flag1':
       opt1 = argv[i+1]
       i+=1
       continue
    if arg == '--anotherFlag':
       optX = argv[i+1]
       optY = argv[i+2]
       optZ = argv[i+3]
       i+=3
       continue

    ...

was bist du eigentlich machen willst?
aktualisierte Frage mit mehr info...
Es ist immer while für Sie.

InformationsquelleAutor Cristi Diaconescu | 2010-07-28

for-loop python

7

Gibt es zwei Dinge, die Sie tun könnten, um Ihr problem zu lösen:
- erfordern, durch Komma getrennte Argumente, die gruppiert werden in den folgenden Wert der option, die Sie nutzen könnten getopt oder andere Modul dann.
- oder mehr tun fragile eigenen Verarbeitung:
```
sys.argv.pop()
cmd = {}
while sys.argv:
    arg = sys.argv.pop(0)
    if arg == '--arg1':
        cmd[arg] = sys.argv.pop(0), sys.argv.pop(0)
    elif:
        pass
print(cmd)
```
Die Idee der Verwendung von argv wie ein stack ist ideal für meine Bedürfnisse, und es entfernt den indizierten Zugriff auf die Liste.

InformationsquelleAutor SilentGhost
20

Ja, das ist, wie ich es tun würde,
```
>>> for i in xrange(0, 10):
...     if i == 4:
...         continue
...     print i,
...
0 1 2 3 5 6 7 8 9
```
BEARBEITEN

Basierend auf das update zu deiner ursprünglichen Frage... ich würde vorschlagen, Sie nehmen einen Blick auf optparse

+1 für optparse. Parsen von Kommandozeilen-Argumenten manuell ist völlig unnötig.
Offenbar optparse wurde in 2.7 und die neue Geschmacksrichtung ist genannt argparse. Sie beide scheinen in der Lage zu tun, was ich brauche, aber ich Frage mich, ob es lohnt sich die Lernkurve. Trotzdem, +1 für den Hinweis auf dieses Modul.

InformationsquelleAutor sberry
6
```
for (i = 0; i < 10; i++)
   if someCondition:
      i+=1
print i
```
In python geschrieben wäre, wie
```
i = 0
while i < 10
   if someCondition
      i += 1
   print i
   i += 1
```
dort gehen Sie, das ist, wie zu schreiben Sie ein c-for-Schleife in python.

Wenn somecondition wahr ist, erhöhen Sie i zweimal...
aber das war ja in der original-Beispiel-code in der Frage, so dass ich dachte, dass war es, was er wollte.

InformationsquelleAutor Netzsooc

Seltsame Weise:

for x in (x for x in xrange(10) if someCondition):
    print str(x)

InformationsquelleAutor Charles Beattie

3

Sollten Sie verwenden continue zu überspringen, ein Wert, in C und Python.
```
for i in range(10):
  if someCondition:
     continue
  print(i)
```
InformationsquelleAutor kennytm
2

Werden Sie wahrscheinlich nicht wirklich brauchen, die Indizes sind, müssen Sie wahrscheinlich die eigentlichen Elemente. Eine bessere Lösung wäre wahrscheinlich wie dieses:
```
sequence = 'whatever'
for item in sequence:
    if some_condition:
        continue
    do_stuff_with(item)
```
Ich würde liebend verwenden Sie einen iterator über eine for-Schleife zu jeder Zeit des Tages, aber ich kann nicht denken, ein Weg, um die iteration in meiner situation - siehe aktualisierte Frage

InformationsquelleAutor Christian Oudard
1

Könnten Sie zuerst schalten Sie die argv-Liste in einen generator:
```
def g(my_list):
    for item in my_list:
        yield item
```
Könnte man dann Schritt für Schritt durch die Elemente, die Anrufung des Generators erforderlich:
```
my_gen = g(sys.argv[1:]):
while True:
   try:
      arg = my_gen.next()
      if arg == "--flag1":
         optX = my_gen.next()
         opyY = my_gen.next()
         --do something
      elif arg == "--flag2":
         optX = my_gen.next()
         optY = my_gen.next()
         optZ = my_gen.next()
         --do something else
      ...
    except StopIteration:
       break
```
wie ist das anders als bei der Iteration über eine Liste? nur mehr ärger.
Die Idee ist gut, aber warum konvertieren sys.argv[1:] zu einem generator Instanz eher als ein iterator? E. g. my_gen = iter(sys.argv[1:]) erhalten Sie die gleichen Ergebnisse wie Ihre Funktion g.
Auch, anstelle von while mit try: except StopIteration: einer for-Schleife erreichen die gleiche Sache. Ganz einfach: for arg in my_gen. Sie können immer noch my_gen.next() in der Schleife.

InformationsquelleAutor Larry

-1

 for i in xrange(0, 10):
    if i % 3 == 0
        continue
    print i

Nur Werte, die nicht durch 3 teilbar.

InformationsquelleAutor Teodor Pripoae

-1

Wenn Sie brauchen, um die Iteration über etwas, und ein index benötigt, verwenden Sie aufzählen()
```
for i, arg in enumerate(argv):
    ...
```
die nicht die gleiche wie die Fragesteller die
```
for i in range(0,len(argv)):
    arg = argv[i]
```
InformationsquelleAutor catchmeifyoutry
-1

Dein problem scheint zu sein, dass Sie sollten die Schleife nicht raw-Parameter, sondern analysierten Parameter. Ich schlage vor, Sie prüfen, ändern Sie Ihre Entscheidung, nicht die Verwendung von standard-Modul (wie die anderen).

InformationsquelleAutor Tony Veijalainen
-1
```
increament = 4                 #say
for i in range(n):
    #write your code here
    n=n+increment
```
das könnte die einfache Lösung für das problem, wenn Sie nur wollen, um eine Iteration durch das array durch überspringen von 4 Mitgliedern

InformationsquelleAutor Rushikesh Shinde

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.