Réserver de la mémoire pour la liste en Python?

Lors de la programmation en Python, est-il possible de réserver de la mémoire pour une liste qui sera rempli avec un certain nombre d'éléments, de sorte que la liste ne sera pas réattribué à plusieurs reprises lors de la construction il? J'ai regardé à travers les docs pour une liste Python de type, et n'ai rien trouvé qui semble le faire. Cependant, ce type de bâtiment de liste montre en quelques points chauds de mon code, donc je veux la rendre aussi efficace que possible.

Edit: Aussi, est-il encore un sens pour faire quelque chose comme cela dans un langage comme Python? Je suis assez programmeur expérimenté, mais Python et toujours avoir une idée de sa façon de faire les choses. Python en interne allouer tous objets dans le segment séparé des espaces, défaisant le but d'essayer de réduire les allocations, ou sont primitives comme ints, des flotteurs, etc. stockées directement dans les listes?

  • Ne pas prématurément optimiser.
  • Le point est que ce a montré dans les hotspots. Dans ces lieux, bâtiment de liste était à l'origine un important, dans le monde réel goulot d'étranglement, le genre que vous devez optimiser.
  • double possible de Python - Créer une liste de capacité initiale
InformationsquelleAutor dsimcha | 2009-02-11
  1. 34

    Voici quatre variantes:

    • un différentiel de création d'une liste
    • "pré-alloué" liste
    • tableau.array()
    • numpy.les zéros()

     

    python -mtimeit -s"N=10**6" "a = []; app = a.append;"\
    "for i in xrange(N):  app(i);"
10 loops, best of 3: 390 msec per loop

python -mtimeit -s"N=10**6" "a = [None]*N; app = a.append;"\
    "for i in xrange(N):  a[i] = i"
10 loops, best of 3: 245 msec per loop

python -mtimeit -s"from array import array; N=10**6" "a = array('i', [0]*N)"\
    "for i in xrange(N):" "  a[i] = i"
10 loops, best of 3: 541 msec per loop

python -mtimeit -s"from numpy import zeros; N=10**6" "a = zeros(N,dtype='i')"\
    "for i in xrange(N):" "  a[i] = i"
10 loops, best of 3: 353 msec per loop

    Il montre que [None]*N est la manière la plus rapide et array.array est le plus lent dans ce cas.

    • Je pense que array.array est utilisé dans un sous-optimale façon ici, voir ma réponse.
    • bonne trouvaille. array('i', [0])*n est 10 fois plus rapide que array('i', [0]*n) qu'il est encore plus lent que [0]*n variante si vous ajoutez de l'initialisation de la boucle. Le point de la réponse: mesurez d'abord. Les exemples de code sont d'autres réponses à la fois.
    • Cela semble un peu injuste numpy et tableau puisque vous êtes, y compris l'heure d'importation, qui auraient probablement pu être amortis sur beaucoup d'appels. @MikhailKorobov résultats semblent suggérer que numpy, une fois importé, est beaucoup plus rapide.
    • le import n'est pas inclus, avis -s
    • à l'aide d'un = [0]*n tous les éléments ont la même référence, c'est à dire si je fais un[0] = 1, je vais arriver a = [1]*n. Ce que je veux savoir, c'est les résultats sont quand même la nouvelle mémoire est alloué? Ou suis-je en train de faire quelque chose de mal?
    • ce n'est pas la façon Python, les listes de travail. Seulement un[0] est changé. Essayez-la.

    InformationsquelleAutor jfs
  2. 13

    vous pouvez créer une liste de longueur connue comme ceci:

    >>> [None] * known_number
    InformationsquelleAutor SilentGhost
  3. 8

    Prendre un coup d'oeil à ceci:

    In [7]: %timeit array.array('f', [0.0]*4000*1000)
1 loops, best of 3: 306 ms per loop

In [8]: %timeit array.array('f', [0.0])*4000*1000
100 loops, best of 3: 5.96 ms per loop

In [11]: %timeit np.zeros(4000*1000, dtype='f')
100 loops, best of 3: 6.04 ms per loop

In [9]: %timeit [0.0]*4000*1000
10 loops, best of 3: 32.4 ms per loop

    Ainsi ne jamais utiliser array.array('f', [0.0]*N), utilisez array.array('f', [0.0])*N ou numpy.zeros.

    • Si vous allez configurer les éléments du tableau plutôt que d'ajouter à eux, vous n'avez probablement pas besoin de zéros, juste un peu d'espace réservé pour chaque élément. Dans ce cas, le chemin à parcourir est np.empty en place de np.zeros. Avec ton test, c'est trois fois plus vite sur mon ordinateur.
    InformationsquelleAutor Mikhail Korobov
  4. 5

    Dans la plupart de tous les jours code, vous n'aurez pas besoin d'une telle optimisation.

    Toutefois, lorsque la liste de l'efficacité devient un problème, la première chose que vous devez faire est de remplacer la liste générique avec tapé un de array module qui est beaucoup plus efficace.

    Voici comment liste de 4 millions de nombres à virgule flottante pouvait être créé:

    import array
lst = array.array('f', [0.0]*4000*1000)
    • Qu'entendez-vous par "plus efficace"? array.array pourrait nécessitent moins de mémoire, mais une liste Python est plus rapide en plus (ce qui signifie à ceux que j'ai essayé) des cas.
    • Dans ce cas, il a même crée tout d'abord une liste et puis à partir de la liste dans un tableau. Ce n'est pas efficace.
    InformationsquelleAutor Alexander Lebedev
  5. 4

    Si vous êtes désireux de manipuler les nombres efficacement en Python alors jetez un oeil à NumPy (
    http://numpy.scipy.org/). Il vous permet de faire des choses extrêmement rapide tout en continuant d'utiliser Python.

    De faire ce que votre demande dans NumPy vous feriez quelque chose comme

    import numpy as np
myarray = np.zeros(4000)

    ce qui vous donne un tableau de nombres flottants initialisé à zéro. Vous pouvez alors faire très cool des choses comme multiplier l'ensemble des tableaux par un facteur unique ou par d'autres tableaux et d'autres choses (un peu comme dans Matlab si vous avez déjà utilisé ce) qui est très rapide (la plupart du travail se passe dans le C hautement optimisé partie de la bibliothèque NumPy).

    Si ce n'est pas que des tableaux de chiffres après alors vous n'allez probablement pas à trouver un moyen de faire ce que vous voulez en Python. Un Python de la liste d'objets est une liste de points d'objets en interne (je pense que de toute façon, je ne suis pas un expert en Python internes) de sorte qu'il en serait toujours à l'allocation de chacun de ses membres lors de leur création.

    • Comme je l'ai dit sur @Mikhail Korobov réponse, np.empty est préférable, à moins que vous vraiment besoin de votre tableau de commencer avec des zéros, en donnant le triple de la vitesse de mon ordinateur.
    InformationsquelleAutor Thomas Parslow
  6. 2

    En Python, tous les objets sont alloués sur le tas.

    Mais Python utilise un allocateur de mémoire donc malloc ne sera pas appelé à chaque fois que vous avez besoin d'un nouvel objet.

    Il y a aussi quelques optimisations pour les petits entiers (et autres) qui sont mis en cache; cependant, les types, et comment, est dépendant de l'implémentation.

    InformationsquelleAutor David Cournapeau
  7. 0

    pour Python3:

    import timeit
from numpy import zeros
from array import array

def func1():
    N=10**6
    a = []
    app = a.append
    for i in range(N):
        app(i)

def func2():
    N=10**6
    a = [None]*N
    app = a.append
    for i in range(N):
        a[i] = i

def func3():
    N=10**6
    a = array('i', [0]*N)
    for i in range(N):
        a[i] = i

def func4():
    N=10**6
    a = zeros(N,dtype='i')
    for i in range(N):
        a[i] = i

start_time = timeit.default_timer()
func1()
print(timeit.default_timer() - start_time)

start_time = timeit.default_timer()
func2()
print(timeit.default_timer() - start_time)

start_time = timeit.default_timer()
func3()
print(timeit.default_timer() - start_time)

start_time = timeit.default_timer()
func4()
print(timeit.default_timer() - start_time)

    résultat:

    0.1655518
0.10920069999999998
0.1935983
0.15213890000000002
    1. append()
    2. [None]*N
    3. à l'aide du module de la matrice de
    4. à l'aide du module numpy
    InformationsquelleAutor Vitaly Fadeev