Genera un elenco di numeri e le loro controparti negative in Python

Esiste un pratico one-liner per generare un elenco di numeri e le loro controparti negative in Python?

Ad esempio, supponiamo di voler generare un elenco con i numeri da 6 a 9 e da -6 a -9.

Il mio approccio attuale è:

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

Un semplice "one-liner" sarebbe:

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

Tuttavia, generare due elenchi e poi unirli insieme sembra scomodo.

Non sono sicuro che l'ordine sia importante, ma potresti creare una tupla e scompattarla in una lista di comprensione.

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 funzione piacevole e leggibile:

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

Uso:

list(range_with_negatives(6, 10))

Ecco come ottenere una comoda fodera per qualsiasi cosa. Evita di provare a sembrare un hacker di magia professionale.

Direi che la soluzione più semplice è decomprimere due intervalli in un elenco utilizzando l' *operatore di decompressione:

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

Non solo questa è la risposta più breve ancora proposta, è anche la più performante, perché costruisce solo un singolo elenco e non comporta chiamate di funzioni oltre le due ranges.

Ho verificato questo testando tutte le risposte a questa domanda utilizzando il timeitmodulo:

ID risposta Metodo timeit risultato
-------------------------------------------------- ------------------------------------------------
(in questione) [x per x nell'intervallo (6,10)] + [y per y nell'intervallo (-9, -5)] 0,843 usec per loop
(questa risposta) [* range (6, 10), * range (-9, -5)] 0,509 usec per loop
61348876 [y per x in range (6,10) per y in (x, -x)] 0,754 usec per loop
61349149 list (range_with_negatives (6, 10)) 0,795 usec per loop
61348914 list (itertools.chain (range (6, 10), range (-9, -5))) 0.709 usec per loop
61366995 [segno * x per segno, x in itertools.product ((- 1, 1), intervallo (6, 10))] 0,899 usec per loop
61371302 elenco (intervallo (6, 10)) + elenco (intervallo (-9, -5)) 0,729 usec per loop
61367180 list (range_with_negs (6, 10)) 1,95 usec per loop

^{(test di timeit eseguiti con Python 3.6.9 sul mio computer (specifiche medie))}

È possibile utilizzare itertools.chain()per concatenare i due intervalli.

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

È possibile utilizzare itertools.product, che è il prodotto cartesiano.

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

Questo potrebbe essere più lento perché usi la moltiplicazione, ma dovrebbe essere facile da leggere.

Se desideri una soluzione puramente funzionale, puoi anche importare itertools.starmape operator.mul:

from itertools import product, starmap
from operator import mul

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

Tuttavia, questo è meno leggibile.

Sei molto vicino, con la combinazione di due rangeoggetti. Ma c'è un modo più semplice per farlo:

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

Cioè, converti ciascun rangeoggetto in un elenco, quindi concatena i due elenchi.

Un altro approccio, usando itertools:

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

itertools.chain()è come un generalizzato +: invece di aggiungere due liste, incatena un iteratore dopo l'altro per creare un "super iteratore". Quindi passalo a list()e otterrai un elenco concreto, con tutti i numeri che desideri in memoria.

Pesando con l'ennesima possibilità.

Se vuoi la leggibilità, il tuo one-liner originale era piuttosto buono, ma cambierei gli intervalli in modo che siano uguali a quanto penso che i limiti negativi rendano le cose meno chiare.

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

IMO l'approccio utilizzato itertools.chainpresentato in un paio di altre risposte è sicuramente il più pulito di quelli forniti finora.

Tuttavia, poiché nel tuo caso l'ordine dei valori non ha importanza , puoi evitare di definire due rangeoggetti espliciti e quindi evitare di fare tutti i calcoli off-by-one necessari per l' rangeindicizzazione negativa , usando 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 po 'prolisso, ma abbastanza leggibile.

Un'altra opzione simile è usare il disimballaggio di tuple / argomento con plain chain:

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

Più conciso, ma trovo più difficile disimballare la tupla da ingannare in una scansione veloce.

Questa è una variazione su un tema (vedi la risposta di @Derte Trdelnik ) seguendo la filosofia di doveitertools

i blocchi di costruzione dell'iteratore [...] sono utili da soli o in combinazione.

L'idea è che, mentre stiamo definendo una nuova funzione, potremmo anche renderla generica:

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

e applicalo a un particolare rangeiteratore:

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

Se vuoi mantenere l'ordine che hai specificato, puoi usare il generatore di range integrato di Python con un condizionale:

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

Che ti dà l'output:

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

E funziona anche con 0 come inizio per l'intera gamma.

Ci possono essere diversi modi per portare a termine il lavoro.

Variabili fornite: 1. start = 6 2. stop = 10

Puoi provare anche questo, per un approccio diverso:

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)

Proprio come le simmetrie.

a = 6 b = 10

nums = [x + y per x in (- (a + b-1), 0) per y nell'intervallo (a, b)]

Il risultato dovrebbe essere -9, -8, ..., 8, 9.

Credo che l'espressione numerica possa essere migliorata, ciò che segue "in" e "range" mi sembra ancora squilibrato.