Python tableau numpy vs liste

J'ai besoin d'effectuer certains calculs d'une grande liste de nombres.

Faire tableau.tableau numpy ou.tableau d'offrir des performances plus typique des tableaux?

Je n'ai pas à faire de complexes manipulations sur les tableaux, j'ai juste besoin d'être en mesure d'accéder et de modifier des valeurs,

par exemple

import numpy
x = numpy.array([0] * 1000000)
for i in range(1,len(x)):
  x[i] = x[i-1] + i

Je ne vais donc pas vraiment besoin de concaténation, de découpage, etc.

Aussi, il ressemble tableau renvoie une erreur si j'essaie d'assigner des valeurs qui ne rentrent pas dans C long:

import numpy
a = numpy.array([0])
a[0] += 1232234234234324353453453
print(a)

Sur console j'obtiens:

a[0] += 1232234234234324353453453
OverflowError: Python int too large to convert to C long

Est-il une variation de tableau qui me permet de mettre en illimité Python entiers?
Ou serait-faire de cette façon emporter au point d'avoir des tableaux en premier lieu?

source d'informationauteur math4tots

  1. 8

    Votre premier exemple pourrait être la vitesse. Boucle Python et l'accès à des éléments dans un tableau numpy sont lents. Utilisation vectorisé opérations à la place:

    import numpy as np
x = np.arange(1000000).cumsum()

    Vous pouvez mettre illimitée Python entiers tableau numpy:

    a = np.array([0], dtype=object)
a[0] += 1232234234234324353453453

    Opérations arithmétiques par rapport à la taille fixe C des entiers serait plus lent dans ce cas.

  2. 11

    Vous devez d'abord comprendre la différence entre les tableaux et les listes.

    Un tableau est une contiguë bloc de mémoire composé d'éléments d'un certain type (par exemple, les entiers).

    Vous ne pouvez pas modifier la taille d'un tableau une fois qu'il est créé.

    Il s'ensuit donc que chaque élément entier dans un tableau a une taille fixe, par exemple, de 4 octets.

    D'autre part, un liste est simplement un "tableau" de adresses (qui ont également une taille fixe).

    Mais chaque élément contient l'adresse de quelque chose d'autre dans la mémoire, qui est le véritable entier que vous voulez travailler avec. Bien sûr, la taille de cet entier n'est pas pertinent à la taille de la matrice. Ainsi, vous pouvez toujours créer un nouveau (gros) entier et "remplacer" l'ancien sans affecter la taille de la matrice, ce qui ne fait que la adresse d'un entier.

    Bien sûr, cette commodité de la liste a un coût: Exécution de l'arithmétique sur les entiers exige maintenant un accès à la mémoire pour le tableau, plus une mémoire d'accès à l'entier lui-même, plus le temps qu'il faut allouer plus de mémoire (si nécessaire), plus le temps nécessaire pour supprimer l'ancienne entier (si nécessaire). Donc, oui, il peut être plus lent, vous devez donc faire attention à ce que vous êtes en train de faire avec chaque entier à l'intérieur d'un tableau.

  3. 2

    Pour la plupart des utilisations, les listes sont utiles. Parfois de travailler avec des tableaux numpy peut être plus commode par exemple. 

    a=[1,2,3,4,5,6,7,8,9,10]

b=[5,8,9]

    Tenir compte d'une liste 'a' et si vous voulez avoir accès aux éléments dans une liste au discrets indices donnés dans la liste "b"
    écrit 

    a[b]

    ne fonctionnera pas.

    mais lorsque vous les utilisez que des tableaux, vous pouvez simplement écrire

    a[b]

    pour obtenir le résultat sous la forme array([6,9,10]).

  4. 1

    Faire tableau.tableau numpy ou.tableau offre des résultats exceptionnels sur
    typique des tableaux?

    J'ai essayé de tester un peu avec le code suivant:

    import timeit, math, array
from functools import partial
import numpy as np
# from the question
def calc1(x):
for i in range(1,len(x)):
x[i] = x[i-1] + 1
# a floating point operation
def calc2(x):
for i in range(0,len(x)):
x[i] = math.sin(i)
L = int(1e5)
# np
print('np 1: {:.5f} s'.format(timeit.timeit(partial(calc1, np.array([0] * L)), number=20)))
print('np 2: {:.5f} s'.format(timeit.timeit(partial(calc2, np.array([0] * L)), number=20)))
# np but with vectorized form
vfunc = np.vectorize(math.sin)
print('np 2 vectorized: {:.5f} s'.format(timeit.timeit(partial(vfunc, np.arange(0, L)), number=20)))
# with list
print('list 1: {:.5f} s'.format(timeit.timeit(partial(calc1, [0] * L), number=20)))
print('list 2: {:.5f} s'.format(timeit.timeit(partial(calc2, [0] * L), number=20)))
# with array
print('array 1: {:.5f} s'.format(timeit.timeit(partial(calc1, array.array("f", [0] * L)), number=20)))
print('array 2: {:.5f} s'.format(timeit.timeit(partial(calc2, array.array("f", [0] * L)), number=20)))

    Et les résultats ont été cette liste s'exécute plus rapide ici (Python 3.3, NumPy 1.8):

    np 1: 2.14277 s
np 2: 0.77008 s
np 2 vectorized: 0.44117 s
list 1: 0.29795 s
list 2: 0.66529 s
array 1: 0.66134 s
array 2: 0.88299 s

    Qui semble contre-intuitif. Il ne semble pas être un avantage dans l'utilisation de numpy ou array sur list pour ces exemples simples.

  5. 0

    Faire tableau.tableau numpy ou.tableau d'offrir des performances plus typique des tableaux?

    Il peut, en fonction de ce que vous faites.

    Ou serait-faire de cette façon emporter au point d'avoir des tableaux en premier lieu?

    À peu près, oui.

  6. 0

    utilisation a=numpy.array(number_of_elements, dtype=numpy.int64) qui devrait vous donner un tableau d'entiers 64 bits. Ces peut stocker n'importe quel nombre entier compris entre -2^63 et (2^63)-1 (environ entre 10^19 et 10^19), qui est généralement plus que suffisant.