Generar una lista de números y sus contrapartes negativas en Python

¿Hay una línea conveniente para generar una lista de números y sus contrapartes negativas en Python?

Por ejemplo, digamos que quiero generar una lista con los números 6 a 9 y -6 a -9.

Mi enfoque actual es:

l = [x for x in range(6,10)]
l += [-x for x in l]

Un simple "one-liner" sería:

l = [x for x in range(6,10)] + [y for y in range(-9, -5)]

Sin embargo, generar dos listas y luego unirlas parece inconveniente.

No estoy seguro de si el orden es importante, pero podría crear una tupla y descomprimirla en una lista de comprensión.

nums = [y for x in range(6,10) for y in (x,-x)]
print(nums)
[6, -6, 7, -7, 8, -8, 9, -9]

Crea una función agradable y legible:

def range_with_negatives(start, end):
    for x in range(start, end):
        yield x
        yield -x

Uso:

list(range_with_negatives(6, 10))

Así es como obtienes una línea conveniente para cualquier cosa. Evita tratar de parecer un hacker profesional mágico.

Yo diría que la solución más simple es descomprimir dos rangos en una lista usando el *operador de desempaquetado:

>>> [*range(6, 10), *range(-9, -5)]
[6, 7, 8, 9, -9, -8, -7, -6]

No solo es la respuesta más corta propuesta hasta ahora, sino que también es la más eficaz, ya que solo construye una lista única y no involucra llamadas de función más allá de las dos ranges.

Verifiqué esto probando todas las respuestas de esta pregunta usando el timeitmódulo:

Respuesta ID Método timeit result
-------------------------------------------------- ------------------------------------------------
(en cuestión) [x para x en el rango (6,10)] + [y para y en el rango (-9, -5)] 0.843 usec por ciclo
(esta respuesta) [* rango (6, 10), * rango (-9, -5)] 0.509 usec por ciclo
61348876 [y para x en el rango (6,10) para y en (x, -x)] 0.754 usec por ciclo
61349149 list (range_with_negatives (6, 10)) 0.795 usec por ciclo
61348914 list (itertools.chain (range (6, 10), range (-9, -5))) 0.709 usec por ciclo
61366995 [signo * x para signo, x en itertools.product ((- 1, 1), rango (6, 10))] 0.899 usec por ciclo
61371302 lista (rango (6, 10)) + lista (rango (-9, -5)) 0.729 usec por ciclo
61367180 list (range_with_negs (6, 10)) 1.95 usec por ciclo

^{(Pruebas de timeit realizadas con Python 3.6.9 en mi propia computadora (especificaciones promedio))}

Puede usar itertools.chain()para concatenar los dos rangos.

import itertools
list(itertools.chain(range(6, 10), range(-9, -5)))

Puedes usar itertools.product, que es el producto cartesiano.

[sign*x for sign, x in product((-1, 1), range(6, 10))]
[-6, -7, -8, -9, 6, 7, 8, 9]

Esto podría ser más lento porque usa la multiplicación, pero debería ser fácil de leer.

Si desea una solución puramente funcional, también puede importar itertools.starmapy operator.mul:

from itertools import product, starmap
from operator import mul

list(starmap(mul, product((-1, 1), range(6, 10))))

Sin embargo, esto es menos legible.

Estás muy cerca, combinando dos rangeobjetos. Pero hay una manera más fácil de hacerlo:

>>> list(range(6, 10)) + list(range(-9, -5))
[6, 7, 8, 9, -9, -8, -7, -6]

Es decir, convierta cada rangeobjeto en una lista y luego concatene las dos listas.

Otro enfoque, usando itertools:

>>> list(itertools.chain(range(6, 10), range(-9, -5)))
[6, 7, 8, 9, -9, -8, -7, -6]

itertools.chain()es como un generalizado +: en lugar de agregar dos listas, encadena un iterador tras otro para hacer un "súper iterador". Luego pase eso list()y obtendrá una lista concreta, con todos los números que desee en la memoria.

Pesando con otra posibilidad más.

Si desea legibilidad, su línea original era bastante buena, pero cambiaría los rangos para que sean los mismos, ya que creo que los límites negativos hacen que las cosas sean menos claras.

[x for x in range(6, 10)] + [-x for x in range(6, 10)]

En mi opinión, el enfoque que se itertools.chainpresenta en un par de otras respuestas es definitivamente el más claro de los proporcionados hasta ahora.

Sin embargo, dado que en su caso el orden de los valores no importa , puede evitar tener que definir dos rangeobjetos explícitos y, por lo tanto, evitar hacer todos los cálculos matemáticos necesarios para la rangeindexación negativa , utilizando itertools.chain.from_iterable:

>>> import itertools
>>> list(itertools.chain.from_iterable((x, -x) for x in range(6, 10)))
[6, -6, 7, -7, 8, -8, 9, -9]

Un poco detallado, pero lo suficientemente legible.

Otra opción similar es utilizar el desempaquetado de tuplas / argumentos con plain chain:

>>> list(itertools.chain(*((x, -x) for x in range(6, 10))))
[6, -6, 7, -7, 8, -8, 9, -9]

Más conciso, pero creo que desempacar las tuplas es más difícil de asimilar en un escaneo rápido.

Esta es una variación de un tema (ver @Derte trdelník 's respuesta ) siguiendo la filosofía de itertoolsdonde

Los bloques de construcción iteradores [...] son ​​útiles por sí mismos o en combinación.

La idea es que, mientras definimos una nueva función, también podríamos hacerla genérica:

def interleaved_negatives(it):
    for i in it:
        yield i
        yield -i

y aplicarlo a un rangeiterador particular :

list(interleaved_negatives(range(6, 10)))

Si desea mantener el orden que ha especificado, puede utilizar el generador de rango incorporado de Python con un condicional:

def range_with_negs(start, stop):
    for value in range(-(stop-1), stop):      
        if (value <= -start) or (value >= start):
            yield value

Lo que te da la salida:

In [1]: list(range_with_negs(6, 10))
Out[1]: [-9, -8, -7, -6, 6, 7, 8, 9]

Y también funciona con 0 como inicio para el rango completo.

Puede haber diferentes formas de hacer el trabajo.

Variables dadas: 1. inicio = 6 2. parada = 10

Puede probar esto también, para un enfoque diferente:

def mirror_numbers(start,stop):
  if start<stop:
    val=range(start,stop)
    return [j if i < len(val) else -j for i,j in enumerate([x for x in val]*2) ]

mirror_numbers(6,10)

Me gustan las simetrías.

a = 6 b = 10

nums = [x + y para x en (- (a + b-1), 0) para y en rango (a, b)]

El resultado debe ser -9, -8, ..., 8, 9.

Creo que la expresión nums se puede mejorar, lo que sigue "en" y "rango" todavía no me parece equilibrado.