transpuesta - recorrer una matriz en python

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

Question

Necesito crear una matriz NumPy de longitud n , cada elemento de la cual es v .

¿Hay algo mejor que:

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

Sé que los zeros y ones funcionarían para v = 0, 1. Podría usar v * ones(n) , pero no funcionará cuando v es None , y también sería mucho más lento.

Answer 1

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

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

En orden de velocidad descendente:

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, intente descubrir y use lo que es más rápido en su plataforma.

Answer 2

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

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

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

Answer 3

NumPy 1.8 introdujo np.full() , que es un método más directo que empty() seguido de fill() para crear una matriz llena con un cierto valor:

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

Podría decirse que es la manera de crear una matriz llena de ciertos valores, porque describe explícitamente lo que se está logrando (y en principio puede ser muy eficiente ya que realiza una tarea muy específica).

Answer 4

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

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

Answer 5

tuve

numpy.array(n * [value])

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

Aquí está la comparación completa con perfplot (un proyecto mío favorito).

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

Código para generar 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(23)],
xlabel=''len(a)'',
logx=True,
logy=True,
)

Answer 6

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

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

En orden de velocidad descendente:

%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