Le lieu à évaluer peut être différent entre la notation d'inclusion de carte et de liste

Lors de l'utilisation de python2.7.10

Quand j'ai essayé d'utiliser un tel script, Le résultat est que la vitesse de traitement de la carte est plus rapide si elle est simple. (L'utilisation de la mémoire est délicate)

import sys

@profile
def which_is_good():
    print sys.version

    l = range(100000)

    mapped = map(lambda d: chr(65 + d%127), l)
    m_stringed = str(mapped[:])
    del mapped
    del m_stringed

    comped = [chr(65 + d%127) for d in l]
    c_stringed = str(comped[:])
    del comped
    del c_stringed

    mapped, comped = (), ()

which_is_good()

kernprof -vl run.py

2.7.10 (default, Jul 13 2015, 12:05:58) 
[GCC 4.2.1 Compatible Apple LLVM 6.1.0 (clang-602.0.53)]
Wrote profile results to run.py.lprof
Timer unit: 1e-06 s

Total time: 0.155445 s
File: run.py
Function: which_is_good at line 3

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
     3                                           @profile
     4                                           def which_is_good():
     5         1           33     33.0      0.0      print sys.version
     6                                           
     7         1         2086   2086.0      1.3      l = range(100000)
     8                                           
     9         1        49070  49070.0     31.6      mapped = map(lambda d: chr(65 + d%127), l)
    10         1        21482  21482.0     13.8      m_stringed = str(mapped[:])
    11         1          150    150.0      0.1      del mapped
    12         1           23     23.0      0.0      del m_stringed
    13                                           
    14    100001        68510      0.7     44.1      comped = [chr(65 + d%127) for d in l]
    15         1        13911  13911.0      8.9      c_stringed = str(comped[:])
    16         1          152    152.0      0.1      del comped
    17         1           27     27.0      0.0      del c_stringed
    18                                           
    19         1            1      1.0      0.0      mapped, comped = (), ()

python -m memory_profiler run.py

2.7.10 (default, Jul 13 2015, 12:05:58) 
[GCC 4.2.1 Compatible Apple LLVM 6.1.0 (clang-602.0.53)]
Filename: run.py

Line #    Mem usage    Increment   Line Contents
================================================
     3   19.551 MiB    0.000 MiB   @profile
     4                             def which_is_good():
     5   19.555 MiB    0.004 MiB       print sys.version
     6                             
     7   22.660 MiB    3.105 MiB       l = range(100000)
     8                             
     9   23.426 MiB    0.766 MiB       mapped = map(lambda d: chr(65 + d%127), l)
    10   28.496 MiB    5.070 MiB       m_stringed = str(mapped[:])
    11   28.246 MiB   -0.250 MiB       del mapped
    12   27.996 MiB   -0.250 MiB       del m_stringed
    13                             
    14   28.730 MiB    0.734 MiB       comped = [chr(65 + d%127) for d in l]
    15   28.840 MiB    0.109 MiB       c_stringed = str(comped[:])
    16   28.590 MiB   -0.250 MiB       del comped
    17   28.340 MiB   -0.250 MiB       del c_stringed
    18                             
    19   28.340 MiB    0.000 MiB       mapped, comped = (), ()

Recommended Posts

Le lieu à évaluer peut être différent entre la notation d'inclusion de carte et de liste
[Introduction à Python] Quelle est la différence entre une liste et un taple?
[Introduction à Udemy Python3 + Application] 60. Notation d'inclusion de liste
L'opérateur and de l'expression d'évaluation de Python semble être évalué à partir de l'expression de gauche
Le moment auquel la valeur de l'argument par défaut est évaluée diffère entre Ruby et Python.
[Python] J'ai essayé de résumer le tableau, la méthode de génération du dictionnaire, la méthode de boucle, la notation d'inclusion de liste
Extraire et lister les noms des personnes et des lieux dans le texte
Comment utiliser argparse et la différence entre optparse
[Python] Il peut être utile de lister les trames de données
Comprendre la différence entre l'affectation cumulative aux variables et l'affectation cumulative aux objets
[Python] Notation inclusive. Écrivez une déclaration simple pour. (Une collection est la différence entre un itérable et un itérateur)