Rational hinter Python ist für Syntax bevorzugt

Question

Was ist der Grund für die befürwortende Verwendung der for i in xrange(...)-Stil Schleifenkonstrukte in Python? Für einfache Integer-Schleifen ist der Unterschied in den Gemeinkosten beträchtlich. Ich führte einen einfachen Test mit zwei Stücken Code:

Datei idiomatic.py:

#!/usr/bin/env python 

M = 10000 
N = 10000 

if __name__ == "__main__": 
    x, y = 0, 0 
    for x in xrange(N): 
     for y in xrange(M): 
      pass 

Datei cstyle.py:

#!/usr/bin/env python 

M = 10000 
N = 10000 

if __name__ == "__main__": 
    x, y = 0, 0 
    while x < N: 
     while y < M: 
      y += 1 
     x += 1 

Profil Ergebnisse waren wie folgt:

bash-3.1$ time python cstyle.py 

real 0m0.109s 
user 0m0.015s 
sys  0m0.000s 

bash-3.1$ time python idiomatic.py 

real 0m4.492s 
user 0m0.000s 
sys  0m0.031s 

ich kann verstehe, warum die Pythonic-Version langsamer ist - ich stelle es mir vor hat viel damit zu tun, xrange N mal anzurufen, vielleicht könnte das eliminiert werden, wenn es einen Weg gibt, einen Generator zurückzuspulen. Aber warum sollte man bei dieser Differenz in der Ausführungszeit lieber die Pythonic-Version verwenden?

Edit: führte ich die Tests erneut den Code mit Herrn Martelli zur Verfügung gestellt, und die Ergebnisse waren in der Tat besser jetzt:

Ich dachte, ich die Ergebnisse hier aus dem Thread aufzählen würde:

1) Viel Code im Modulbereich ist eine schlechte Idee, auch wenn der Code in einem if __name__ == "__main__": Block eingeschlossen ist.

2) * Merkwürdiger, den Code zu modifizieren, die thebadone meine falsche Version gehörte (lassen y ohne Zurücksetzen) erzeugte wenig Unterschied in der Leistung wachsen, auch für größere Werte von M und N.

Answer 1

Hier ist der richtige Vergleich, z.B. in loop.py:

M = 10000 
N = 10000 

def thegoodone(): 
    for x in xrange(N): 
     for y in xrange(M): 
      pass 

def thebadone(): 
    x = 0 
    while x < N: 
     y = 0 
     while y < M: 
      y += 1 
     x += 1 

Alle wesentlichen Code sollte immer in Funktionen sein - hundert Millionen Schlaufen an eines Moduls obersten Ebene zeigt rücksichtslose Missachtung für die Leistung und verhöhnt alle Versuche setzen bei Messung besagte Leistung.

Sobald Sie das getan haben, sehen Sie:

$ python -mtimeit -s'import loop' 'loop.thegoodone()' 
10 loops, best of 3: 3.45 sec per loop 
$ python -mtimeit -s'import loop' 'loop.thebadone()' 
10 loops, best of 3: 10.6 sec per loop 

So richtig gemessen, die schlechte Art und Weise, die Sie befürworten etwa 3-mal langsamer als die gute Art und Weise ist der Python fördert. Ich hoffe, dies bringt Sie dazu, Ihre falsche Befürwortung zu überdenken.

Answer 2

Sie zu vergessen Setze y nach der inneren Schleife auf 0 zurück.

#!/usr/bin/env python 
M = 10000 
N = 10000 

if __name__ == "__main__": 
    x, y = 0, 0 
    while x < N: 
     while y < M: 
      y += 1 
     x += 1 
     y = 0 

ed: 20.63s nach fix vs. 6.97s xrange

Answer 3

gut mit Strukturen über Daten Iterieren

Die for i in ... Syntax ist für über Datenstrukturen iteriert. In einer Sprache der unteren Ebene würden Sie im Allgemeinen über ein Array iterieren, das mit einem int indiziert ist, aber mit der Python-Syntax können Sie den Indexierungsschritt eliminieren.

Answer 4

Ich habe den Test von @Alex Martelli's answer wiederholt. Die idiomatische for-Schleife ist mal schneller als die while-Schleife:

python -mtimeit -s'from while_vs_for import while_loop as loop' 'loop(10000)' 
10 loops, best of 3: 9.6 sec per loop 
python -mtimeit -s'from while_vs_for import for_loop as loop' 'loop(10000)' 
10 loops, best of 3: 1.83 sec per loop 

while_vs_for.py:

def while_loop(N): 
    x = 0 
    while x < N: 
     y = 0 
     while y < N: 
      pass 
      y += 1 
     x += 1 

def for_loop(N): 
    for x in xrange(N): 
     for y in xrange(N): 
      pass 

auf Modulebene:

$ time -p python for.py 
real 4.38 
user 4.37 
sys 0.01 
$ time -p python while.py 
real 14.28 
user 14.28 
sys 0.01 

Answer 5

dies keine ist direkte Antwort auf die Frage, aber ich möchte den Dialog ein wenig mehr auf xrange() öffnen. zwei Dinge:

A. dort mit einem der OP Aussagen etwas nicht in Ordnung ist, dass niemand noch korrigiert hat (ja, zusätzlich zu dem Fehler im Code nicht y Zurücksetzen):

„Ich kann es sich vorstellen, viel mit Aufruf xrange N-mal ....“

im Gegensatz zu herkömmlichen Zählen for Loops, Python ist mehr wie ein Shell foreach ... Schleifen über ein abzählbaren zu tun. daher xrange() heißt genau einmal, nicht "N-mal."

B. xrange() ist der Name dieser Funktion in Python 2. Sie ersetzt und wird umbenannt in range() in Python 3, also beachten Sie dies beim Portieren. Wenn Sie das nicht bereits wissen, gibt xrange() einen Iterator (-ähnliches Objekt) zurück, während range() Listen zurückgibt. da letzteres ineffizienter ist, wurde es zugunsten von xrange(), das mehr Speicher-freundlich ist, veraltet. die Problemumgehung in Python 3, für alle diejenigen, die benötigen, um eine Liste zu haben, ist list(range(N)).