Initialisation du tableau NumPy (remplir avec des valeurs identiques)

J'ai besoin de créer un tableau NumPy de longueur n, dont chaque élément est v.

Y a-t-il quelque chose de mieux que:

a = empty(n)
for i in range(n):
    a[i] = v

Je sais zeroset onesfonctionnerais pour v = 0, 1. Je pourrais utiliser v * ones(n), mais cela ne fonctionnera pas quand il vest None, et serait également beaucoup plus lent.

NumPy 1.8 introduit np.full(), qui est une méthode plus directe que celle empty()suivie fill()pour créer un tableau rempli d'une certaine valeur:

>>> np.full((3, 5), 7)
array([[ 7.,  7.,  7.,  7.,  7.],
       [ 7.,  7.,  7.,  7.,  7.],
       [ 7.,  7.,  7.,  7.,  7.]])

>>> np.full((3, 5), 7, dtype=int)
array([[7, 7, 7, 7, 7],
       [7, 7, 7, 7, 7],
       [7, 7, 7, 7, 7]])

C'est sans doute la façon de créer un tableau rempli de certaines valeurs, car il décrit explicitement ce qui est réalisé (et il peut en principe être très efficace car il effectue une tâche très spécifique).

Mise à jour pour Numpy 1.7.0: (Pointe du chapeau à @Rolf Bartstra.)

a=np.empty(n); a.fill(5) est le plus rapide.

Par ordre de vitesse décroissante:

%timeit a=np.empty(1e4); a.fill(5)
100000 loops, best of 3: 5.85 us per loop

%timeit a=np.empty(1e4); a[:]=5 
100000 loops, best of 3: 7.15 us per loop

%timeit a=np.ones(1e4)*5
10000 loops, best of 3: 22.9 us per loop

%timeit a=np.repeat(5,(1e4))
10000 loops, best of 3: 81.7 us per loop

%timeit a=np.tile(5,[1e4])
10000 loops, best of 3: 82.9 us per loop

Je pense que fillc'est le moyen le plus rapide de le faire.

a = np.empty(10)
a.fill(7)

Vous devez également toujours éviter d'itérer comme vous le faites dans votre exemple. Un simple a[:] = vaccomplira ce que fait votre itération en utilisant la diffusion numpy .

Apparemment, non seulement les vitesses absolues mais aussi l' ordre de vitesse (tel que rapporté par user1579844) dépendent de la machine; voici ce que j'ai trouvé:

a=np.empty(1e4); a.fill(5) est le plus rapide;

Par ordre de vitesse décroissante:

timeit a=np.empty(1e4); a.fill(5) 
# 100000 loops, best of 3: 10.2 us per loop
timeit a=np.empty(1e4); a[:]=5
# 100000 loops, best of 3: 16.9 us per loop
timeit a=np.ones(1e4)*5
# 100000 loops, best of 3: 32.2 us per loop
timeit a=np.tile(5,[1e4])
# 10000 loops, best of 3: 90.9 us per loop
timeit a=np.repeat(5,(1e4))
# 10000 loops, best of 3: 98.3 us per loop
timeit a=np.array([5]*int(1e4))
# 1000 loops, best of 3: 1.69 ms per loop (slowest BY FAR!)

Alors, essayez de découvrir et d'utiliser ce qui est le plus rapide sur votre plate-forme.

j'ai eu

numpy.array(n * [value])

à l'esprit, mais apparemment, c'est plus lent que toutes les autres suggestions pour assez grand n .

Voici une comparaison complète avec perfplot (un de mes projets favoris ).

Les deux emptyalternatives sont toujours les plus rapides (avec NumPy 1.12.1). fullrattrape pour les grands tableaux.

Code pour générer le tracé:

import numpy as np
import perfplot


def empty_fill(n):
    a = np.empty(n)
    a.fill(3.14)
    return a


def empty_colon(n):
    a = np.empty(n)
    a[:] = 3.14
    return a


def ones_times(n):
    return 3.14 * np.ones(n)


def repeat(n):
    return np.repeat(3.14, (n))


def tile(n):
    return np.repeat(3.14, [n])


def full(n):
    return np.full((n), 3.14)


def list_to_array(n):
    return np.array(n * [3.14])


perfplot.show(
    setup=lambda n: n,
    kernels=[empty_fill, empty_colon, ones_times, repeat, tile, full, list_to_array],
    n_range=[2 ** k for k in range(27)],
    xlabel="len(a)",
    logx=True,
    logy=True,
)

Vous pouvez utiliser numpy.tile, par exemple:

v = 7
rows = 3
cols = 5
a = numpy.tile(v, (rows,cols))
a
Out[1]: 
array([[7, 7, 7, 7, 7],
       [7, 7, 7, 7, 7],
       [7, 7, 7, 7, 7]])

Bien qu'il tilesoit destiné à «tuiler» un tableau (au lieu d'un scalaire, comme dans ce cas), il fera le travail, créant des tableaux pré-remplis de toutes tailles et dimensions.

sans engourdissement

>>>[2]*3
[2, 2, 2]