Pregunta simple aquí:

Estoy tratando de obtener una matriz que alterne valores (1, -1, 1, -1 .....) para una longitud determinada. np.repeat solo me da (1, 1, 1, 1, -1, -1, -1, -1). Pensamientos?

17
mike 23 ago. 2011 a las 03:22

7 respuestas

La mejor respuesta

Me gusta la solución de @ Benjamin. Sin embargo, una alternativa es:

import numpy as np
a = np.empty((15,))
a[::2] = 1
a[1::2] = -1

Esto también permite listas de longitud impar.

EDITAR: también solo para observar las velocidades, para una matriz de 10000 elementos

import numpy as np
from timeit import Timer

if __name__ == '__main__':

    setupstr="""
import numpy as np
N = 10000
"""

    method1="""
a = np.empty((N,),int)
a[::2] = 1
a[1::2] = -1
"""

    method2="""
a = np.tile([1,-1],N)
"""

    method3="""
a = np.array([1,-1]*N)   
"""

    method4="""
a = np.array(list(itertools.islice(itertools.cycle((1,-1)), N)))    
"""
    nl = 1000
    t1 = Timer(method1, setupstr).timeit(nl)
    t2 = Timer(method2, setupstr).timeit(nl)
    t3 = Timer(method3, setupstr).timeit(nl)
    t4 = Timer(method4, setupstr).timeit(nl)

    print 'method1', t1
    print 'method2', t2
    print 'method3', t3
    print 'method4', t4

Resultados en tiempos de:

method1 0.0130500793457
method2 0.114426136017
method3 4.30518102646
method4 2.84446692467

Si N = 100, las cosas comienzan a nivelarse, pero comenzar con las matrices vacías todavía es significativamente más rápido (nl cambió a 10000)

method1 0.05735206604
method2 0.323992013931
method3 0.556654930115
method4 0.46702003479

Las matrices Numpy son objetos impresionantes especiales y no deben tratarse como listas de python.

23
JoshAdel 23 ago. 2011 a las 03:18

Solo los arrojaré porque podrían ser más útiles en algunas circunstancias.

Si solo quieres alternar entre positivo y negativo:

[(-1)**i for i in range(n)]

O para una solución más general

nums = [1, -1, 2]
[nums[i % len(nums)] for i in range(n)]
0
machine yearning 22 ago. 2011 a las 23:48

Si desea una solución eficiente en memoria, intente esto:

def alternator(n):
    for i in xrange(n):
        if i % 2 == 0:
            yield 1
        else:
            yield -1

Luego puede iterar sobre las respuestas de esta manera:

for i in alternator(n):
    # do something with i
4
Kristoff vdH 22 ago. 2011 a las 23:32

Usar multiplicación:

[1,-1] * n
4
Foo Bah 22 ago. 2011 a las 23:28

Use resize ():

In [38]: np.resize([1,-1], 10) # 10 is the length of result array
Out[38]: array([ 1, -1,  1, -1,  1, -1,  1, -1,  1, -1])

Puede producir una matriz de longitud impar:

In [39]: np.resize([1,-1], 11)
Out[39]: array([ 1, -1,  1, -1,  1, -1,  1, -1,  1, -1,  1])
12
HYRY 23 ago. 2011 a las 02:39

¡Usa numpy.tile!

import numpy
a = numpy.tile([1,-1], 15)
7
Benjamin 22 ago. 2011 a las 23:28

¿Quizás estás buscando itertools.cycle?

list_ = (1,-1,2,-2)  # ,3,-3, ...

for n, item in enumerate(itertools.cycle(list_)):
    if n==30:
        break

    print item
2
PabloG 22 ago. 2011 a las 23:33