python.tableau versus numpy.tableau

Si vous créez un tableau 1d en Python est-il un avantage à l'utilisation de la NumPy paquet?

InformationsquelleAutor Hortitude | 2008-09-21
  1. 64

    Tout dépend de ce que vous comptez faire avec la matrice. Si tout ce que vous faites est de créer des tableaux de types de données simples et faire des I/O, la tableau module fera l'amende juste.

    Si, d'autre part, vous voulez faire toute sorte de calcul numérique, la matrice de module ne fournit pas de vous aider. NumPy (et SciPy) vous donner une grande variété d'opérations entre des ensembles et des fonctions spéciales qui sont utiles non seulement pour le travail scientifique, mais pour des choses comme les avancées de manipulation de l'image ou en général tout ce laquelle vous devez effectuer efficace des calculs avec de grandes quantités de données.

    Numpy est aussi beaucoup plus souple, par exemple, il prend en charge des tableaux de n'importe quel type d'objets Python, et est également capable d'interagir "nativement" avec vos propres objets s'ils sont conformes à la tableau de l'interface.

    • Dans la défense de tableau.tableau, je pense qu'il est important de noter qu'il est également beaucoup plus léger que numpy.tableau, et que dire "fera l'amende juste" pour un tableau 1D devrait vraiment être beaucoup plus petit et plus rapide, et travaille à pypy/cython sans problèmes.' J'aime NumPy, mais pour de simples matrices de la matrice.tableau module est en fait mieux.
    • n'ayant jamais utilisé un tableau.tableau dans ma vie, serait l'esprit de vous donner un cas d'utilisation lorsqu'il est véritablement mieux (peut-être que je suis trop np.ndarray)?
    • Le lien vers le tableau de module est mort. Connaissez-vous son nouvel emplacement?
    • Devrait être corrigé maintenant.
    InformationsquelleAutor dF.
  2. 2

    Petit amorçage pour le bénéfice de celui qui pourrait trouver cela utile (à la suite de l'excellente réponse par @dF.):

    import numpy as np
from array import array

# Fixed size numpy array
def np_fixed(n):
    q = np.empty(n)
    for i in range(n):
        q[i] = i
    return q

# Resize with np.resize
def np_class_resize(isize, n):
    q = np.empty(isize)
    for i in range(n):
        if i>=q.shape[0]:
            q = np.resize(q, q.shape[0]*2)        
        q[i] = i
    return q    

# Resize with the numpy.array method
def np_method_resize(isize, n):
    q = np.empty(isize)
    for i in range(n):
        if i>=q.shape[0]:
            q.resize(q.shape[0]*2)
        q[i] = i
    return q

# Array.array append
def arr(n):
    q = array('d')
    for i in range(n):
        q.append(i)
    return q

isize = 1000
n = 10000000

    La sortie donne:

    %timeit -r 10 a = np_fixed(n)
%timeit -r 10 a = np_class_resize(isize, n)
%timeit -r 10 a = np_method_resize(isize, n)
%timeit -r 10 a = arr(n)

1 loop, best of 10: 868 ms per loop
1 loop, best of 10: 2.03 s per loop
1 loop, best of 10: 2.02 s per loop
1 loop, best of 10: 1.89 s per loop

    Il semble que tableau.tableau est un peu plus rapide et la " api " vous permet d'économiser quelques soucis, mais si vous avez besoin de plus que juste le stockage de doubles puis numpy.redimensionner n'est pas un mauvais choix, après tout (si utilisé correctement).

    • Je pense que la question fait référence à python.array au lieu de liste.
    InformationsquelleAutor nivniv
  3. -1

    Vous trouverez que la vitesse de Numpy est beaucoup plus rapide que Python tableau:

    import time
import numpy as np

size_of_vec = 1000

def pure_python_version():
    t = time.time()
    X = range(size_of_vec)
    Y = range(size_of_vec)
    Z = [X[i] + Y[i] for i in range(len(X)) ]
    return time.time() - t

def numpy_version():
    t1 = time.time()
    X = np.arange(size_of_vec)
    Y = np.arange(size_of_vec)
    Z = X + Y
    return time.time() - t

t1 = pure_python_version()
t2 = numpy_version()
print(t1, t2)
print("Numpy is in this example " + str(t1/t2) + " faster!")

    De sortie:

    0.00024366378784179688 0.002840280532836914
Numpy is in this example 0.08578863426508856 faster!
    • Pourquoi faites-vous t1 / t2? Ne devriez-vous pas prendre la différence des temps? Aussi, veuillez indenter ton code correctement.
    • Merci de me le rappeler. Je veux juste comparer la façon dont rapidement la numpy par rapport à python tableau. Vous pouvez obtenir les différents temps lors de l'exécution du code ci-dessus.
    • Depuis t1/t2 est <1, cela signifie que Numpy est en fait plus lentement que python tableaux (comme démontré par @nivniv dans leur réponse).
    InformationsquelleAutor nhanhoangle