2017-01-08 1 views
0

Nehmen wir an, dass wir die Länge einer Liste in bestimmten Berechnungen in einer Schleife verwenden müssen. Was wäre schneller, mit len(list_) in jeder Berechnung oder Speichern der Länge length = len(list_) und dann length? Zum Beispiel:Wird die Länge einer Liste einmal vor einer Schleife schneller berechnet als innerhalb der Schleife neu berechnet?

for x in range(n): 
    print(len(list_) + 1) 

Versus

length = len(list_) 
for x in range(n): 
    print(length + 1) 

eine allgemeine Situation Angenommen (n kann einen beliebigen Wert sein).

+5

Warum testen Sie es nicht mit 'time.time()' und berichten Sie uns? – blacksite

+5

Noch besser, es gibt ein ganzes [timeit] (https://docs.python.org/3.6/library/timeit.html) Modul, das entwickelt wurde, um dabei zu helfen, was viele der Probleme vermeidet, die nur 'time.time () 'kann einführen. – DSM

+3

Der einzige Unterschied zwischen diesen Codeblöcken besteht darin, auf eine Variable zuzugreifen und sie als Funktion mit einer anderen Variablen aufzurufen, auf die zugegriffen wird, oder einfach auf eine Variable zuzugreifen. Der einzige Unterschied besteht darin, dass ersterer eine Funktion aufruft und auf eine zweite Variable zugreift, während letzterer nicht funktioniert. Was denkst du ist schneller? Nachdem Sie eine fundierte Schätzung gemacht haben, führen Sie einige Tests durch und finden Sie heraus. Dann ignoriere das Ergebnis und benutze den Code, der sauberer aussieht. – TigerhawkT3

Antwort

2

Hier ist ein einfacher Test timeit als @DSM mit vorgeschlagen:

def direct_len(lst): 
    total = 0 
    for x in range(1000): 
     total += len(lst) + 1 

def precalc(lst): 
    length = len(lst) 
    total = 0 
    for x in range(1000): 
     total += length + 1 

if __name__ == '__main__': 
    import timeit 
    print(timeit.timeit("direct_len(list(range(100)))", setup="from __main__ import direct_len", number=10000)) 
    print(timeit.timeit("precalc(list(range(100)))", setup="from __main__ import precalc", number=10000)) 

Mit oben ich mit Python 3.5 auf Windows 8 folgendes Ergebnis:

1.3909554218576217 
0.8262501212985289 
+0

Ich wusste es. Der erste sieht so aus, als müsste er diese 'len' Funktion für' n' mehrmals wiederholen. – akinjide

+1

Beachten Sie, dass Sie eine Menge identischer Overhead-Daten zeitlich abstimmen, wodurch der Leistungsunterschied im Code, der sich tatsächlich unterscheidet, maskiert wird. – TigerhawkT3

+0

Aus Interesse Ich frage mich, ob es viel Unterschied in den Ergebnissen machen würde, wenn Sie dieses Programm mit einem der Tests auskommentiert und wieder mit dem anderen Test auskommentiert und die Ergebnisse auf diese Weise verglichen. – Tagc

-1

Pythons Liste speichert ihre Länge in einer Variablen, es gibt also keinen großen Unterschied auf diese Weise.

Die erste erhält die Länge (die nur eine Variable ist, gibt es keine Berechnung in len() -Funktion) jedes Mal in der Schleife, die zweite nur die Funktion einmal. Die Zeit ist in meinem Test gleich.

+3

Warum erzählst du uns nicht, was dein Test war, damit wir sehen können, warum sie gleich waren? In meinem Test war der Zugriff auf eine gespeicherte Länge ungefähr viermal schneller als das wiederholte Aufrufen von 'len'. – TigerhawkT3

0

eine einzige gespeicherte Variable Zugriff auf viel schneller als auf eine Funktion zuzugreifen und ihr eine zugegriffene Variable zu übergeben.

>>> import timeit 
>>> timeit.timeit('x', setup='x=len([1,2])') 
0.024496269777304097 
>>> timeit.timeit('len(x)', setup='x=[1,2]') 
0.10009170159894687 

jedoch, wie ich in meinem comment above, es spielt keine Rolle. Es kann wichtig sein, ob die Funktion, die Sie anrufen, extrem teuer ist, aber das ist diesmal nicht der Fall. Verwenden Sie, was Ihren Code sauberer erscheinen lässt.

Verwandte Themen