Vergleichen Sie die Geschwindigkeit von Python Append und Map

Ich werde nachdrucken, was ich für das Unternehmen geschrieben habe

Zweck

Überprüfen Sie den Unterschied zwischen der Verarbeitungsgeschwindigkeit und der Speichernutzung des Codes, den Sie zuerst geschrieben haben (mithilfe von Anhängen), und dem Code, auf den in der Überprüfung hingewiesen wurde (mithilfe von Map)

Verifizierungs-Schlüssel

Bereiten Sie ein Programm vor, das die beiden Arrays zusammenführt und ausgibt. (Ursprünglich war es ein Programm, das aus der Datenbank abgerufene Felder und Zeilen zusammenführt und als json ausgibt.)

Die zur Messung verwendeten Werkzeuge sind wie folgt.

--memory_profiler: Sie können die Zunahme oder Abnahme des Speichers zeilenweise messen. Sie können auch die aktuelle Verwendung und das Inkrement überprüfen --line_profiler: Die Verarbeitungsgeschwindigkeit kann zeilenweise gemessen werden.

Überprüfung 1

from memory_profiler import profile
from line_profiler import LineProfiler


@profile(precision=8)
def main():
    a = [1, 2, 3]
    b = ['1', '2', '3']

    results = []
    for _ in range(1000):
        results.append(dict(zip(a, b)))

    for r in results:
        print(r)　# {1: '1', 2: '2', 3: '3'}


if __name__ == "__main__":
    #Beim Messen des Speichers
    #    main()
    
    #Beim Vergleich der Verarbeitungsgeschwindigkeiten
    prof = LineProfiler()
    prof.add_function(main)
    prof.runcall(main)
    prof.print_stats(output_unit=1e-9)

Überprüfung 2

Mit Ausnahme des Inhalts der Methode entspricht sie der Validierung 1 und wird daher weggelassen.

def main():
    a = [1, 2, 3]
    b = ['1', '2', '3']

    results = map(dict, (zip(a, b) for _ in range(1000)))

    for r in results:
        print(r) # {1: '1', 2: '2', 3: '3'}

Ergebnis

Die Datenmenge war anfangs gering, aber der Unterschied war spürbar.

Verarbeitungsgeschwindigkeit

• Verifikation 2 war ungefähr 0,02 Sekunden schneller.
• Es scheint, dass der Grund, warum Verifikation 2 länger anstelle von "für r in den Ergebnissen" war, darin besteht, dass der Iterator zu diesem Zeitpunkt jedes Mal auf die Daten zugegriffen hat. Aber es war immer noch schneller als der Code, den ich zum Anhängen verwendet habe.

Überprüfung 1

Total time: 0.087002 s
File: append.py
Function: main at line 6

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
     6                                           def main():
     7         1       4000.0   4000.0      0.0      a = [1, 2, 3]
     8         1       1000.0   1000.0      0.0      b = ['1', '2', '3']
     9                                           
    10         1          0.0      0.0      0.0      results = []
    11      1001     395000.0    394.6      0.5      for _ in range(1000):
    12      1000    1973000.0   1973.0      2.3          results.append(dict(zip(a, b)))
    13                                           
    14      1001    5854000.0   5848.2      6.7      for r in results:
    15      1000   78775000.0  78775.0     90.5          print(r)

Überprüfung 2

Total time: 0.069483 s
File: map.py
Function: main at line 7

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
     7                                           def main():
     8         1       4000.0   4000.0      0.0      a = [1, 2, 3]
     9         1       1000.0   1000.0      0.0      b = ['1', '2', '3']
    10                                           
    11         1       2000.0   2000.0      0.0      results = map(dict, (zip(a, b) for _ in range(1000)))
    12                                           
    13      1001    8476000.0   8467.5     12.2      for r in results:
    14      1000   61000000.0  61000.0     87.8          print(r)

Speichernutzung

• Im Vergleich war die Karte insgesamt kleiner als "0,16 MB".
• Es stellte sich heraus, dass die Schreibmethode von Verifikation 2 nicht mehr Speicher als erforderlich verwendet. (Wichtig hier!)

Überprüfung 1

Line #    Mem usage    Increment   Line Contents
================================================
     5  38.28125000 MiB  38.28125000 MiB   @profile(precision=8)
     6                             def main():
     7  38.28515625 MiB   0.00390625 MiB       a = [1, 2, 3]
     8  38.28515625 MiB   0.00000000 MiB       b = ['1', '2', '3']
     9                             
    10  38.28515625 MiB   0.00000000 MiB       results = []
    11  38.38671875 MiB   0.00390625 MiB       for _ in range(1000):
    12  38.38671875 MiB   0.00390625 MiB           results.append(dict(zip(a, b)))
    13                             
    14  38.39453125 MiB   0.00000000 MiB       for r in results:
    15  38.39453125 MiB   0.00781250 MiB           print(r)

Überprüfung 2

Line #    Mem usage    Increment   Line Contents
================================================
     5  38.22656250 MiB  38.22656250 MiB   @profile(precision=8)
     6                             def main():
     7  38.23046875 MiB   0.00390625 MiB       a = [1, 2, 3]
     8  38.23046875 MiB   0.00000000 MiB       b = ['1', '2', '3']
     9                             
    10  38.23828125 MiB   0.00000000 MiB       results = map(dict, (zip(a, b) for _ in range(1000)))
    11                             
    12  38.23828125 MiB   0.00000000 MiB       for r in results:
    13  38.23828125 MiB   0.00781250 MiB           print(r)

abschließend

• Ich habe zuerst erfahren, dass es ein solches Überprüfungswerkzeug gibt. Es macht Spaß, jede Codezeile zu sehen ...!
• Es ist nicht nur schnell und langsam, sondern im Fall einer großen Datenmenge, die aus der Datenbank abgerufen wird, wie ich es diesmal wollte. Wenn Sie nicht mit einer Karte schreiben, die nicht mehr als den erforderlichen Speicher benötigt, ist dies zum Zeitpunkt der Produktionsausführung ein Hindernis Ich hatte das Gefühl, dass ich vorsichtig sein musste, weil dies zu einer Verbindung führen könnte.

Bitte lassen Sie mich wissen, wenn es etwas Seltsames gibt.