Inizializzazione dell'array NumPy (riempire con valori identici)

Ho bisogno di creare un array NumPy di ​​lunghezza n, ciascuno dei quali è v.

C'è qualcosa di meglio di:

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

Lo so zerose onesfunzionerebbe per v = 0, 1. Potrei usare v * ones(n), ma non funzionerà quando vè None, e sarebbe anche molto più lento.

Introduzione di NumPy 1.8 np.full(), che è un metodo più diretto di quello empty()seguito fill()per creare un array riempito con un certo valore:

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

Questo è probabilmente il modo di creare un array pieno di determinati valori, perché descrive esplicitamente ciò che viene raggiunto (e in linea di principio può essere molto efficiente poiché svolge un compito molto specifico).

Aggiornato per Numpy 1.7.0: (Hat-tip a @Rolf Bartstra.)

a=np.empty(n); a.fill(5) è il più veloce.

In ordine decrescente di velocità:

%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

Credo che fillsia il modo più veloce per farlo.

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

Dovresti anche evitare sempre di iterare come stai facendo nel tuo esempio. Un semplice a[:] = vcompirà ciò che fa la tua iterazione usando la trasmissione numpy .

Apparentemente, non solo le velocità assolute ma anche l' ordine di velocità (come riportato dall'utente 1579844) dipendono dalla macchina; ecco cosa ho trovato:

a=np.empty(1e4); a.fill(5) è il più veloce;

In ordine decrescente di velocità:

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

Quindi, prova a scoprirlo e usa ciò che è più veloce sulla tua piattaforma.

avevo

numpy.array(n * [value])

in mente, ma a quanto pare è più lento di tutti gli altri suggerimenti abbastanza grandi n.

Ecco il confronto completo con perfplot (un mio progetto per animali domestici).

Le due emptyalternative sono ancora le più veloci (con NumPy 1.12.1). fullraggiunge grandi matrici.

Codice per generare la trama:

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

È possibile utilizzare numpy.tile, ad esempio:

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

Sebbene tileabbia lo scopo di "affiancare" un array (anziché uno scalare, come in questo caso), farà il lavoro, creando array pre-riempiti di qualsiasi dimensione e dimensione.

senza intorpidimento

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