For-Schleifen (Anfänger)

Ich habe vor kurzem angefangen zu lernen, Python, und das Konzept der for-Schleifen ist immer noch ein wenig verwirrend für mich. Ich verstehe, dass es, folgt in der Regel das format for x in y, wo y nur einige der Liste.

Die for-each-Schleife for (int n: someArray)
wird for n in someArray,

Und die for-Schleife for (i = 0; i < 9; i-=2) dargestellt werden kann, durch for i in range(0, 9, -2)

Angenommen, anstelle einer Konstanten Schrittweite, wollte ich i*=2 oder sogar i*=i. Ist das möglich, oder würde ich mit einer while-Schleife statt?

Ihre for i in range(0,9,-2) nicht rückwärts Durchlaufen, wenn die erste Nummer, wenn weniger als die zweite.
Genauer gesagt, die range() cant ein array mit einem negativen Schritt für einen positiven Wert. Es ist eine unendliche Schleife.
wollen Sie diese als die Werte von i: 1 2, 4, 8, 16, 32....
Letztere for Schleife hat kein richtiges Ende-Bedingung, wenn i ist ein int und das ist, C. In jedem Fall ist es nicht der Bereich, den Sie sagte.

InformationsquelleAutor user1320925 | 2012-05-03

11

Wie Sie sagen, ein for Schleife iteriert durch die Elemente einer Liste. Die Liste kann enthalten alles, was Sie wollen, so können Sie eine Liste erstellen, dass vorher enthält jeden Schritt.

Einen for Schleife kann auch Durchlaufen eine "generator", das ist ein kleines Stück code anstelle der eigentlichen Liste. In Python range() ist eigentlich ein generator (in Python 2.x obwohl range() zurückgegeben wird eine Liste, während xrange() war der generator).

Beispiel:
```
def doubler(x):
    while True:
        yield x
        x *= 2

for i in doubler(1):
    print i
```
Den oben for Schleife drucken
```
1
2
4
8
```
und so weiter, bis du Strg+C drücken.
- Ich würde sagen, einen standalone-generator ist overkill für diese - einen generator-Ausdruck würde wahrscheinlich tun es genauso gut. E. g: for i in (x*2 for x in range(10)):
- Ja, Sie kann schreiben, den code kompakter. Aber ich denke, es ist lehrreich, um zu zeigen, ein Geschmack von dem, was ein allgemeiner generator tun können.
- Es ist zwar schön zu wissen, dass Sie tun können, mehr mit ihm, es ist nicht gut, zu raten, zu überkompliziert Dinge. Erläuterung der generator-Ausdruck syntax sowie würde wahrscheinlich gut sein, um zu vermeiden, dass der Fragesteller aus einem sehr einfachen Generatoren als voller Funktionen.
- Ich ermutige Sie, hinzufügen eine Antwort Demonstration der generator-Ausdruck syntax.
- Getan, und +1 für Euch - es ist eine gute Antwort, die man tun kann Magie mit Generatoren.
InformationsquelleAutor Greg Hewgill
8

Können Sie eine generator-Ausdruck dies zu tun, effizient und mit wenig überflüssigen code:
```
for i in (2**x for x in range(10)): #In Python 2.x, use `xrange()`.
    ...
```
Generator-Ausdrücke funktioniert genauso wie das definieren einer manuellen generator (wie in Greg Hewgill Antwort), mit einer syntax ähnlich zu einer Liste erfassen. Sie werden ausgewertet, träge - was bedeutet, dass Sie nicht erzeugen einer Liste am Anfang des Vorgangs, der kann eine viel bessere Leistung auf große iterables.

Also dieser generator funktioniert, indem Sie warten, bis es aufgefordert wird, einen Wert, dann Fragen range(10) für einen Wert, verdoppeln Sie diesen Wert, und übergeben Sie es zurück an die for Schleife. Er tut dies wiederholt, bis die range() generator liefert keine Werte mehr.
- Ich glaube nicht, dass es weniger lesbar. Wenn Sie wirklich wollten, könnten Sie das tun doubles = (x*2 for x in range(10)) Schleife über doubles. Wenn Sie vergleichen Sie mit Ihrer Antwort - eine Liste Verständnis - wir sind buchstäblich ein Gespräch über unterschiedliche Halterungen, die außerhalb des Ausdrucks. Wie ist das weniger lesbar oder wartbar?
- Meine Antwort ist ein Einzeiler - und zu empfehlen, dass eine einzelne Zeile ist immer besser als mehrere Zeilen ist der Wahnsinn. Manchmal mehrere Linien sind besser lesbar. Als Debuggen wird härter, das ist einfach nicht wahr. Wie ich schon in meinem anderen Kommentar - es gibt einen Grund, warum alle von Python 3 gelieferten sind jetzt faul, wo im 2.x Sie erzeugt Listen.
- Ich glaube, der OP will 2,4,8,16,32... und Ihre Lösung gibt 2,4,6,8,10....
- Hoppla, ist gefixt.
InformationsquelleAutor Gareth Latty
5

Beachten Sie, dass die 'Liste' - Teil von Python können beliebige wiederholenden Sequenz.

Beispiele:

String:
```
for c in 'abcdefg':
   # deal with the string on a character by character basis...
```
Datei:
```
with open('somefile','r') as f:
    for line in f:
         # deal with the file line by line
```
Wörterbuch:
```
d={1:'one',2:'two',3:'three'}
for key, value in d.items():
   # deal with the key:value pairs from a dict
```
Einer Scheibe eine Liste:
```
l=range(100)
for e in l[10:20:2]:
    # ever other element between 10 and 20 in l 
```
etc etc etc etc

Also es ist wirklich viel tiefer, als 'nur einige Liste'

Wie andere bereits gesagt haben, setzen Sie einfach die iterierbar zu sein, was Sie wollen, dass es für dein Beispiel Fragen:
```
 for e in (i*i for i in range(10)):
     # the squares of the sequence 0-9...

 l=[1,5,10,15]
 for i in (i*2 for i in l):
     # the list l as a sequence * 2...
```
- +1 - Das ist ein guter Punkt. For-Schleifen gehen über alle durchsuchbar, nicht nur Listen.
- Ich sehe nicht, wie das die Frage beantwortet.
- Wijsman: Die OP-Mitgliedstaaten the concept of for loops is still a little confusing for me. I understand that it generally follows the format for x in y, where y is just some list. ich war klargestellt, dass y ist eine Menge mehr als nur einige-Liste"
- Das war nicht klar aus deiner Antwort, vielen Dank.
InformationsquelleAutor
1

Möchten Sie Liste Verstehens für diese
```
print [x**2 for x in xrange(10)] # X to the 2nd power.
```
und
```
print [x**x for x in xrange(10)] # X to the Xth power.
```
Die list comprehension syntax ist wie folgt:
```
[EXPRESSION for VARIABLE in ITERABLE if CONDITION]
```
Unter der Haube, es wirkt ähnlich wie die map-und filter-Funktion:
```
def f(VARIABLE): return EXPRESSION
def c(VARIABLE): return CONDITION

filter(c, map(f, ITERABLE))
```
Beispiel gegeben:
```
def square(x): return x**2

print map(square, xrange(10))
```
und
```
def hypercube(x): return x**x

print map(hypercube, xrange(10))
```
Kann verwendet werden, als alternativer Ansatz wenn Sie nicht wie die Liste Verstehens.
Könntest du auch eine for-Schleife verwenden, aber das würde Schritt Weg von der Python-Redewendungen...
- Eine Liste erstellen und dann Durchlaufen, es ist nicht optimal, und das ist nicht die syntax, um eine Liste comp (es ist ein Ausdruck, nicht eine Funktion, es ist ein durchsuchbar, nicht eine Liste, und es könnte sein, eine if-Anweisung am Ende).
- Es ist optimal, es ist das, was ein generator-Ausdruck wirkt. Beachten Sie, wie Ihre Antwort links zu Liste Verstehens... 😉
- Nicht wahr. Meine Antwort links zu einem video, das ich gemacht, der erklärt, Liste Verstehens neben der generator-Ausdrücke und dict und legen Verstehens. Generator-Ausdrücke sind faul, und daher sehr unterscheidet sich von der Liste Verständnis. Wenn wir eine Schleife, um fünf Millionen, wird Ihre Lösung erstellen Sie eine Liste von 0*2 durch 4999999*2, dann Schleife über Sie. Ein generator-Ausdruck wird berechnet, wie gebraucht.
- Eine Liste sein könnte, was er will, in dem Fall eine Liste Verständnis ist am besten, aber da er nicht so sagen, ich denke, es ist zu früh, um davon ausgehen also.
- Ich zitiere Donald Knuth: Programmers waste enormous amounts of time thinking about, or worrying about, the speed of noncritical parts of their programs, and these attempts at efficiency actually have a strong negative impact when debugging and maintenance are considered. We should forget about small efficiencies, say about 97% of the time: premature optimization is the root of all evil. Yet we should not pass up our opportunities in that critical 3%.
- Das ist ganz wahr, und doch in diesem Fall sprechen wir über einen anderen Satz von Klammern um einen Ausdruck. Es ist nicht wie diese Optimierung kostet uns Zeit, die Lesbarkeit oder sonst etwas, also warum es nicht tun? Das Zitat fällt nach unten, wenn wir über etwas sprechen, das kostet uns keine Zeit und Mühe, und gut in der Praxis oft bedeutet, dass Sie brauchen nicht zu befürchten, wenn es nicht egal.
- Sie sagen, 'bekannt sein' - das ist einfach nicht wahr. Es gibt einen Grund, warum in Python 3.x, änderten Sie alle built-in Operationen auf der lazy evaluation. Es ist in keiner Weise mehr schwierig zu Debuggen.
- Fühlen Sie sich frei, sich selbst zu beweisen, richtig. Die Beweislast ist auf die Ankläger. In welcher situation macht eine träge ausgewerteten Ausdrucks wodurch das Debuggen erschwert?
- Ich konnte nicht sehen, dass link, ich werde Sie Lesen.
- Dieser link ist nicht relevant. Es spricht nicht über das Debuggen wird härter, und es spricht für die Planung in Bezug auf die Sprache. Python verwaltet lazy evaluation für Sie durch den Einsatz von Generatoren. Zeigen Sie mir ein Beispiel code weniger wartbar oder debugfähiger in Python durch einen generator.
- Ich habe nicht downvoted alle anderen Antworten - in der Tat, ich von Ihnen positiv bewertet werden beide von den anderen. Die Realität ist, dass debugging in Python mit generator-Ausdrücke ist in Ordnung - debugging in Python ist fast immer mit print() Aussagen und so ist es nicht wirklich wichtig. Im Falle eines Falles können Sie nur wickeln Sie Ihre generator in list() zu sehen, ist es Ausgabe. Ich habe gedebuggt viele Probleme in Python-während der Verwendung von Generatoren. Wie, um es einfach zu halten, - einen generator-Ausdruck ist nicht komplexer als eine Liste Verständnis.
- Wie können die Klammern ersetzt werden, damit für das Debuggen (angenommen, dass die Existenz eines Debuggers, ob es existiert oder nicht), Stimme ich zu. Ich werde zurückkehren, meine down-vote mit magic...
- Naja, das schöne ist, dass unser Gespräch eigentlich dazu beigetragen, Wikipedia, wenn nicht die Menschen entscheiden, zu gehen, und Rollen Sie es zurück. Sorry und danke... 🙂
- Nichts falsch mit eine gute Diskussion - ich habe falsch gewesen, bevor viele eine Zeit, und ich werde in der Zukunft wieder - ich würde eher davon wissen als nicht. Wenn ich Recht habe, es ist nichts falsch mit dem wissen, warum Sie etwas denken, und hoffentlich jemand anderes profitiert.
- Die Kommentare entfernt wurden, basierend auf der falschen Tatsache. Das ist genau der Grund, warum ich nicht den Schritt Weg von einer guten Diskussion, es verbessert sich etwas in die eine oder andere Weise. Und auch nur das tut es zum üben der Diskussion, ist schon ein guter Grund. Wie lange er gehalten, den wissenschaftlichen und nicht nur zwei, Stroh mans, das ist leicht zu fallen ...
InformationsquelleAutor Tamara Wijsman

Nur für eine alternative, wie etwa die Verallgemeinerung der Iteration/Inkrement-operation, um eine lambda-Funktion, so können Sie etwas wie das hier tun:

for i in seq(1, 9, lambda x: x*2):
    print i
...
1
2
4
8

Wo seq unten definiert ist:

#!/bin/python
from timeit import timeit

def seq(a, b, f):
    x = a;
    while x < b:
        yield x
        x = f(x)

def testSeq():
    l = tuple(seq(1, 100000000, lambda x: x*2))
    #print l

def testGen():
    l = tuple((2**x for x in range(27)))
    #print l

testSeq();
testGen();

print "seq", timeit('testSeq()', 'from __main__ import testSeq', number = 1000000)
print "gen", timeit('testGen()', 'from __main__ import testGen', number = 1000000)

Den Unterschied in der Leistung ist nicht viel:

seq 7.98655080795
gen 6.19856786728

[BEARBEITEN]

Zur Unterstützung von reverse iteration und mit einem default-argument...

def seq(a, b, f = None):
    x = a;
    if b > a:
        if f == None:
            f = lambda x: x+1
        while x < b:
            yield x
            x = f(x)
    else:
        if f == None:
            f = lambda x: x-1
        while x > b:
            yield x
            x = f(x)

for i in seq(8, 0, lambda x: x/2):
    print i

Hinweis: Dies verhält sich anders zu range/xrange in die Richtung </> test wird gewählt, indem Sie das iterator-Zeichen, sondern als die Differenz zwischen start-und end-Werte.

InformationsquelleAutor jozxyqk

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.