Generieren Sie eine Liste der Zahlen und ihrer negativen Gegenstücke in Python

Gibt es einen praktischen Einzeiler, um eine Liste von Zahlen und ihren negativen Gegenstücken in Python zu erstellen?

Angenommen, ich möchte eine Liste mit den Nummern 6 bis 9 und -6 bis -9 erstellen.

Mein aktueller Ansatz ist:

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

Ein einfacher "Einzeiler" wäre:

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

Es erscheint jedoch unpraktisch, zwei Listen zu erstellen und diese dann zusammenzufügen.

Ich bin mir nicht sicher, ob die Reihenfolge wichtig ist, aber Sie können ein Tupel erstellen und es in einem Listenverständnis auspacken.

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

Erstellen Sie eine schöne und lesbare Funktion:

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

Verwendungszweck:

list(range_with_negatives(6, 10))

So erhalten Sie für alles einen praktischen Einzeiler. Vermeiden Sie es, wie ein magischer Profi-Hacker auszusehen.

Ich würde sagen, die einfachste Lösung besteht darin, zwei Bereiche mit dem *Entpackungsoperator in eine Liste zu entpacken :

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

Dies ist nicht nur die kürzeste vorgeschlagene Antwort, sondern auch die performanteste, da nur eine einzige Liste erstellt wird und keine Funktionsaufrufe über die beiden hinausgehen range.

Ich habe dies überprüft, indem ich alle Antworten dieser Frage mit dem timeitModul getestet habe :

Antwort ID Methode timeit Ergebnis
-------------------------------------------------- ------------------------------------------------
(in Frage) [x für x im Bereich (6,10)] + [y für y im Bereich (-9, -5)] 0,843 usec pro Schleife
(diese Antwort) [* Bereich (6, 10), * Bereich (-9, -5)] 0,509 usec pro Schleife
61348876 [y für x im Bereich (6,10) für y in (x, -x)] 0,754 usec pro Schleife
61349149 list (range_with_negatives (6, 10)) 0,795 usec pro Schleife
61348914 Liste (itertools.chain (Bereich (6, 10), Bereich (-9, -5))) 0,709 usec pro Schleife
61366995 [Vorzeichen * x für Vorzeichen, x in itertools.product ((- 1, 1), Bereich (6, 10))] 0,899 usec pro Schleife
61371302 Liste (Bereich (6, 10)) + Liste (Bereich (-9, -5)) 0,729 usec pro Schleife
61367180 Liste (range_with_negs (6, 10)) 1,95 usec pro Schleife

^{(Timeit-Tests mit Python 3.6.9 auf meinem eigenen Computer durchgeführt (durchschnittliche Spezifikationen))}

Sie können itertools.chain()die beiden Bereiche verketten.

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

Sie können verwenden itertools.product, welches das kartesische Produkt ist.

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

Dies ist möglicherweise langsamer, da Sie die Multiplikation verwenden, sollte jedoch leicht zu lesen sein.

Wenn Sie eine rein funktionale Lösung wünschen, können Sie auch importieren itertools.starmapund operator.mul:

from itertools import product, starmap
from operator import mul

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

Dies ist jedoch weniger lesbar.

Sie sind wirklich nah dran, wenn Sie zwei rangeObjekte kombinieren . Aber es gibt einen einfacheren Weg:

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

Konvertieren Sie also jedes rangeObjekt in eine Liste und verketten Sie dann die beiden Listen.

Ein anderer Ansatz, der itertools verwendet:

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

itertools.chain()ist wie eine Verallgemeinerung +: Anstatt zwei Listen hinzuzufügen, verkettet es einen Iterator nach dem anderen, um einen "Superiterator" zu erstellen. Übergeben Sie das dann an list()und Sie erhalten eine konkrete Liste mit allen gewünschten Zahlen im Speicher.

Mit einer weiteren Möglichkeit abwägen.

Wenn Sie Lesbarkeit wünschen, war Ihr ursprünglicher Einzeiler ziemlich gut, aber ich würde die Bereiche so ändern, dass sie der Meinung sind, dass die negativen Grenzen die Dinge weniger klar machen.

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

IMO ist der Ansatz, itertools.chainder in einigen anderen Antworten vorgestellt wird, definitiv der sauberste unter den bisher angebotenen.

Da in Ihrem Fall jedoch die Reihenfolge der Werte keine Rolle spielt , können Sie vermeiden, zwei explizite rangeObjekte definieren zu müssen , und somit vermeiden, die für die negative rangeIndizierung erforderliche Off-by-One-Mathematik durchzuführen, indem Sie Folgendes verwenden 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]

Tad ausführlich, aber lesbar genug.

Eine andere ähnliche Option ist das Entpacken von Tupeln / Argumenten mit plain chain:

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

Prägnanter, aber ich finde es schwieriger, Tupel auszupacken, um einen schnellen Scan durchzuführen.

Dies ist eine Variation über ein Thema (siehe @Derte Trdelnik ‚s Antwort ) im Anschluss an die Philosophie von itertoolswo

Iteratorbausteine ​​[...] sind für sich oder in Kombination nützlich.

Die Idee ist, dass wir, während wir eine neue Funktion definieren, sie genauso gut generisch machen können:

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

und wenden Sie es auf einen bestimmten rangeIterator an:

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

Wenn Sie die von Ihnen angegebene Reihenfolge beibehalten möchten, können Sie den in Python integrierten Bereichsgenerator mit einer Bedingung verwenden:

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

Welches gibt Ihnen die Ausgabe:

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

Und funktioniert auch mit 0 als Start für den gesamten Bereich.

Es gibt verschiedene Möglichkeiten, die Arbeit zu erledigen.

Angegebene Variablen: 1. Start = 6 2. Stopp = 10

Sie können dies auch für verschiedene Ansätze versuchen:

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)

Ich mag Symmetrien.

a = 6 b = 10

nums = [x + y für x in (- (a + b-1), 0) für y im Bereich (a, b)]

Das Ergebnis sollte -9, -8, ..., 8, 9 sein.

Ich glaube, dass der nums-Ausdruck verbessert werden kann. Was auf "in" und "range" folgt, erscheint mir immer noch unausgeglichen.