Inicialización de matriz NumPy (rellenar con valores idénticos)

Actualizado para Numpy 1.7.0: (Hat-tip para @Rolf Bartstra.)

a=np.empty(n); a.fill(5) es el más rápido.

En orden descendente de velocidad:

%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

Creo fill es la forma más rápida de hacer esto.

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

También debe evitar siempre iterar como lo está haciendo en su ejemplo. Un simple a[:] = v logrará lo que tu iteración hace usando numpy broadcasting.

Aparentemente, no solo las velocidades absolutas sino también la velocidad orden (según lo informado por user1579844) dependen de la máquina; esto es lo que encontré:

a=np.empty(1e4); a.fill(5) es el más rápido;

En orden descendente de velocidad:

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!)

Por lo tanto, tratar de averiguar, y utilizar lo que es más rápido en su plataforma.

Tenía

numpy.array(n * [value])

En mente, pero aparentemente eso es más lento que todas las otras sugerencias para lo suficientemente grande n.

Aquí hay una comparación completa con perfplot (un proyecto favorito mío).

Las dos alternativas empty siguen siendo las más rápidas (con NumPy 1.12.1). full capturas para matrices grandes.

Código para generar el gráfico:

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,
    )

Puede usar numpy.tile, por ejemplo:

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]])

Aunque tile está destinado a 'tile' una matriz (en lugar de un escalar, como en este caso), hará el trabajo, creando matrices precargadas de cualquier tamaño y dimensión.

Sin numpy

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