Comparez la vitesse d'ajout et de carte Python

Je vais réimprimer ce que j'ai écrit pour l'entreprise

Objectif

Vérifiez quelle est la différence entre la vitesse de traitement et l'utilisation de la mémoire du code que vous avez écrit en premier (en utilisant append) et le code indiqué dans l'examen (en utilisant la carte).

Code de vérification

Préparez un programme qui fusionne les deux tableaux et les génère. (À l'origine, c'était un programme qui fusionne les champs et les lignes extraits de la base de données et le produit en json)

Les outils utilisés pour la mesure sont les suivants.

--memory_profiler: Vous pouvez mesurer l'augmentation ou la diminution de la mémoire en unités de lignes. Vous pouvez également vérifier l'utilisation actuelle et l'incrémentation --line_profiler: la vitesse de traitement peut être mesurée ligne par ligne.

Vérification 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__":
    #Lors de la mesure de la mémoire
    #    main()
    
    #Lors de la comparaison des vitesses de traitement
    prof = LineProfiler()
    prof.add_function(main)
    prof.runcall(main)
    prof.print_stats(output_unit=1e-9)

Vérification 2

Sauf pour le contenu de la méthode, c'est le même que la validation 1, donc il sera omis.

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'}

résultat

La quantité de données était faible au départ, mais la différence était notable.

vitesse de traitement

• La vérification 2 était d'environ "0,02 s" plus rapide.
• Il semble que la raison pour laquelle la vérification 2 était plus longue à la place de for r in results: est que l'itérateur est allé accéder aux données à chaque fois à ce stade. Mais c'était toujours plus rapide que le code que j'ai utilisé pour append.

Vérification 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)

Vérification 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)

utilisation de la mémoire

• Par rapport au total, la carte était inférieure à "0,16 Mo".
• Il s'est avéré que la méthode d'écriture de vérification 2 n'utilise pas plus de mémoire que nécessaire. (Important ici!)

Vérification 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)

Vérification 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)

en conclusion

• J'ai d'abord appris qu'il existe un tel outil de vérification. C'est amusant de voir chaque ligne de code ...!
• Non seulement c'est rapide et lent, mais dans le cas d'une grande quantité de données extraites de la base de données comme le cas que je voulais faire cette fois, si vous n'écrivez pas en utilisant une carte qui n'utilise pas la mémoire plus que nécessaire, ce sera un obstacle au moment de l'exécution de la production J'ai senti que je devais faire attention car cela pouvait conduire à une connexion.

S'il vous plaît laissez-moi savoir s'il y a quelque chose d'étrange.