Qual è il modo più veloce per copiare i dati dall'array b all'array a, senza modificare l'indirizzo dell'array a. Ne ho bisogno perché una libreria esterna (PyFFTW) utilizza un puntatore al mio array che non può cambiare.
Per esempio:
a = numpy.empty(n, dtype=complex)
for i in xrange(a.size):
a[i] = b[i]
È possibile farlo senza loop?
Risposte:
Credo
a = numpy.empty_like (b)
a[:] = b
farà rapidamente una copia completa. Come menzionato da Funsi, anche le versioni recenti di numpy hanno la copytofunzione.
a = bcrea semplicemente un nuovo riferimento a b. a[:] = bsignifica "imposta tutti gli elementi di auguale a quelli di b". La differenza è importante perché gli array numpy sono tipi mutabili.
empty()è circa il 10% più veloce di zeros(). Sorprendentemente empty_like()è ancora più veloce. copyto(a,b)è più veloce della sintassi dell'array a[:] = b. Vedi gist.github.com/bhawkins/5095558
np.copyto(a, b)e quando a = b.astype(b.dtype)per un miglioramento della velocità, vedere la risposta di seguito: stackoverflow.com/a/33672015/3703716
empty_likeè molto più veloce di empty, soprattutto perché zeros_likeè più lento di zeros. A proposito, ho appena rieseguito il mio benchmark (ora aggiornato) e la differenza tra copyto(a,b)e a[:] = bsembra essere evaporata. gist.github.com/bhawkins/5095558
NumPy versione 1.7 ha la numpy.copytofunzione che fa quello che stai cercando:
numpy.copyto (dst, src)
Copia i valori da un array a un altro, trasmettendo se necessario.
Vedi: https://docs.scipy.org/doc/numpy/reference/generated/numpy.copyto.html
AttributeError: 'module' object has no attribute 'copyto'
a = numpy.array(b)
è persino più veloce delle soluzioni suggerite fino a numpy v1.6 e crea anche una copia dell'array. Tuttavia non ho potuto testarlo contro copyto (a, b), poiché non ho la versione più recente di numpy.
Per rispondere alla tua domanda, ho giocato con alcune varianti e le ho profilate.
Conclusione: per copiare i dati da un array numpy a un altro usa una delle funzioni numpy integrate numpy.array(src)o numpy.copyto(dst, src)dove possibile.
(Ma scegli sempre l'ultima se dstla memoria di è già allocata, per riutilizzare la memoria. Vedi la profilazione alla fine del post.)
configurazione della profilazione
import timeit
import numpy as np
import pandas as pd
from IPython.display import display
def profile_this(methods, setup='', niter=10 ** 4, p_globals=None, **kwargs):
if p_globals is not None:
print('globals: {0}, tested {1:.0e} times'.format(p_globals, niter))
timings = np.array([timeit.timeit(method, setup=setup, number=niter,
globals=p_globals, **kwargs) for
method in methods])
ranking = np.argsort(timings)
timings = np.array(timings)[ranking]
methods = np.array(methods)[ranking]
speedups = np.amax(timings) / timings
pd.set_option('html', False)
data = {'time (s)': timings,
'speedup': ['{:.2f}x'.format(s) if 1 != s else '' for s in speedups],
'methods': methods}
data_frame = pd.DataFrame(data, columns=['time (s)', 'speedup', 'methods'])
display(data_frame)
print()
codice di profilazione
setup = '''import numpy as np; x = np.random.random(n)'''
methods = (
'''y = np.zeros(n, dtype=x.dtype); y[:] = x''',
'''y = np.zeros_like(x); y[:] = x''',
'''y = np.empty(n, dtype=x.dtype); y[:] = x''',
'''y = np.empty_like(x); y[:] = x''',
'''y = np.copy(x)''',
'''y = x.astype(x.dtype)''',
'''y = 1*x''',
'''y = np.empty_like(x); np.copyto(y, x)''',
'''y = np.empty_like(x); np.copyto(y, x, casting='no')''',
'''y = np.empty(n)\nfor i in range(x.size):\n\ty[i] = x[i]'''
)
for n, it in ((2, 6), (3, 6), (3.8, 6), (4, 6), (5, 5), (6, 4.5)):
profile_this(methods[:-1:] if n > 2 else methods, setup,
niter=int(10 ** it), p_globals={'n': int(10 ** n)})
risultati per Windows 7 su CPU Intel i7, CPython v3.5.0, numpy v1.10.1.
Inoltre, vedere i risultati per una variante del profilo in cui la memoria della destinazione è già pre-allocata durante la copia del valore, poiché y = np.empty_like(x)fa parte della configurazione:
x.copy()è veloce quanto np.array(x)e mi piace molto di più la sintassi: $ python3 -m timeit -s "import numpy as np; x = np.random.random((100, 100))" "x.copy()"- 100000 loops, best of 3: 4.7 usec per loop. Ho risultati simili per np.array(x). Testato su Linux con un i5-4210U e numpy 1.10.4
np.copyè più indulgente: np.copy(False), np.copy(None)ancora lavoro, mentre a = None; a.copy()getta AttributeError: 'NoneType' object has no attribute 'copy'. Inoltre, siamo più precisi nel dichiarare ciò che vogliamo che accada in questa riga di codice utilizzando la funzione invece della sintassi del metodo.
np.copy(None)che non generi un errore è davvero poco mitico. Un motivo in più per utilizzarlo a.copy():)
y[:] = xora è leggermente più veloce di copyto(y, x). Codice e output su gist.github.com/bhawkins/7cdbd5b9372cb798e34e21f92279d2dc
puoi usare facilmente:
b = 1*a
questo è il modo più veloce, ma ha anche alcuni problemi. Se non si definisce direttamente il dtypedi ae inoltre non si controlla il dtypedi, bsi possono avere problemi. Per esempio:
a = np.arange(10) # dtype = int64
b = 1*a # dtype = int64
a = np.arange(10.) # dtype = float64
b = 1*a # dtype = float64
a = np.arange(10) # dtype = int64
b = 1. * a # dtype = float64
Spero di poter chiarire il punto. A volte cambierai il tipo di dati con una piccola operazione.
a = numpy.zeros(len(b))o a = numpy.empty(n,dtype=complex)creerà anche un nuovo array.
Ci sono molte cose diverse che puoi fare:
a=np.copy(b)
a=np.array(b) # Does exactly the same as np.copy
a[:]=b # a needs to be preallocated
a=b[np.arange(b.shape[0])]
a=copy.deepcopy(b)
Cose che non funzionano
a=b
a=b[:] # This have given my code bugs