Warum ist eine Liste, begreifen so viel schneller als das Anhängen an eine Liste?

Ich Frage mich, warum die list-comprehension ist so viel schneller als das Anhängen einer Liste an. Ich dachte, der Unterschied ist nur ausdrucksstark, aber es ist nicht.

>>> import timeit 
>>> timeit.timeit(stmt='''\
t = []
for i in range(10000):
    t.append(i)''', number=10000)
9.467898777974142

>>> timeit.timeit(stmt='t= [i for i in range(10000)]', number=10000)
4.1138417314859

Die Liste Verständnis ist 50% schneller. Warum?

InformationsquelleAutor rafaelc | 2015-05-14
  1. 67

    Liste Verständnis ist im Grunde nur ein "syntaktischer Zucker" für die regelmäßige for Schleife. In diesem Fall ist der Grund dafür, dass es besser ist, weil Sie nicht brauchen, um zu laden das append-Attribut von der Liste aus, und rufen Sie es als eine Funktion, die bei jedem Durchlauf. In anderen Worten und im Allgemeinen, Liste Verstehens führen schneller, weil die Aussetzung und die Wiederaufnahme der Funktion von Rahmen oder mehrere Funktionen in anderen Fällen ist langsamer als das erstellen einer Liste auf Nachfrage.

    Betrachten Sie die folgenden Beispiele :

    # Python-3.6

In [1]: import dis

In [2]: def f1():
   ...:     l = []
   ...:     for i in range(5):
   ...:         l.append(i)
   ...:         

In [3]: def f2():
   ...:     [i for i in range(5)]
   ...:     

In [4]: dis.dis(f1)
  2           0 BUILD_LIST               0
              3 STORE_FAST               0 (l)

  3           6 SETUP_LOOP              33 (to 42)
              9 LOAD_GLOBAL              0 (range)
             12 LOAD_CONST               1 (5)
             15 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
             18 GET_ITER
        >>   19 FOR_ITER                19 (to 41)
             22 STORE_FAST               1 (i)

  4          25 LOAD_FAST                0 (l)
             28 LOAD_ATTR                1 (append)
             31 LOAD_FAST                1 (i)
             34 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
             37 POP_TOP
             38 JUMP_ABSOLUTE           19
        >>   41 POP_BLOCK
        >>   42 LOAD_CONST               0 (None)
             45 RETURN_VALUE

In [5]: dis.dis(f2)
  2           0 LOAD_CONST               1 (<code object <listcomp> at 0x7fe48b2265d0, file "<ipython-input-3-9bc091d521d5>", line 2>)
              3 LOAD_CONST               2 ('f2.<locals>.<listcomp>')
              6 MAKE_FUNCTION            0
              9 LOAD_GLOBAL              0 (range)
             12 LOAD_CONST               3 (5)
             15 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
             18 GET_ITER
             19 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
             22 POP_TOP
             23 LOAD_CONST               0 (None)
             26 RETURN_VALUE

    Können Sie sehen, an offset 22 wir haben ein append - Attribut in der ersten Funktion, da wir nicht so etwas in der zweiten Funktion mit list comprehension. Alle diese zusätzlichen bytecodes wird das Anhängen Ansatz langsamer. Beachten Sie auch, dass Sie haben auch die append Attribut laden in jeder iteration das macht den code dauert etwa 2 mal langsamer als die zweite Funktion anhand einer Liste erfassen.

    • Ich glaube, die Demontage des zweiten Funktion zeigt nicht den bytecode für die aktuelle Liste-comp-Funktion, die verwirrend ist.
    InformationsquelleAutor Kasrâmvd
  2. 12

    Sogar das ausklammern der Zeit, die es nimmt, um zu suchen und laden Sie die append Funktion, die Liste Einsicht ist immer noch schneller, denn die Liste ist in C erstellt, anstatt gebaut bis ein Element in einer Zeit, in Python.

    # Slow
timeit.timeit(stmt='''
    for i in range(10000):
        t.append(i)''', setup='t=[]', number=10000)

# Faster
timeit.timeit(stmt='''
    for i in range(10000):
        l(i)''', setup='t=[]; l=t.append', number=10000)

# Faster still
timeit.timeit(stmt='t = [i for i in range(10000)]', number=10000)
    • die "Langsam" und "Schneller" code-Beispielen die Erstellung von Listen mit 100000000 Elemente (wenn wir fix den Einzug error) (setup wird nicht wiederholt für die number loop). Die list comprehension erstellt eine Liste mit 10000 Elemente 10000 mal. Sie könnte gemeint haben python -mtimeit "t=[]" "for i in range(10000): t.append(i)" vs. python -mtimeit "t=[]" "t_append=t.append" "for i in range(10000): t_append(i)" vs. python -mtimeit "t=[i for i in range(10000)]", Aber es ändert nichts an der Schlussfolgerung (langsam, schneller, schneller).
    • - Liste erstellt, in C, iteration führt bei C Hebel, etc. Dies ist eine der überzeugendsten, der absolut falsche Mythen über Python. Die Liste Verständnis ist schneller, da die Aussetzung und die Wiederaufnahme der Funktion frame ist langsam, nicht, weil es nichts besonderes über Liste Verstehens.
    • hm, also es ist eine falsche Aussage, die Liste Verstehens haben diese C zugrunde liegenden gewinnen? Das ist so eine wiederkehrende Aussage, wenn man über Liste Verstehens, die ich aufgenommen haben, es als absolute Wahrheit, ohne tatsächlich die Untersuchung noch tiefer. Jede gute Referenzen dazu?
    • Es ist "in C" in gewissem Sinne, als die list comprehension verwendet die LIST_APPEND Anleitung zum hinzufügen eines Elements zu der Liste, anstatt eine Funktion aufzurufen.
    • Wenn man sagen möchte, so auch alles in Python ist CPython-Implementierung in C. Der falschen Annahme über die Liste Verständnis ist, dass die Leute denken irgendwie auf Magische Weise führt er die loops direkt in C das ist nicht wahr. Es ist nicht wie ein buit-in-Funktion, die zuvor in C.
    • Ich weiß nicht, jede Bezugnahme auf diese, aber ich habe gelesen, der source-code vor. Wenn Sie wollen sicher sein, können Sie Lesen Sie die neuesten source-code wieder.
    • Überprüfen Sie die Ausgabe von dis.dis("[i for i in range(10000)]"). Wie LIST_APPEND implementiert ist, kann von der Implementierung abhängig sein, aber es ist verschiedenen aus aufzurufen t.append auf jedes element. (Was könnte das sein, was Sie sind zu beziehen durch "anhalten und fortsetzen einer Funktion frame".)

    InformationsquelleAutor chepner
  3. 6

    Unter Berufung auf diese Artikel, es ist, weil die append Attribut des list ist nicht gesucht, geladen und als Funktion aufgerufen, die Zeit und das summiert sich im Laufe der Iterationen.

    InformationsquelleAutor adarsh
Schreibe einen Kommentar