Générer une liste de nombres et leurs homologues négatifs en Python

Existe-t-il un one-liner pratique pour générer une liste de nombres et leurs homologues négatifs en Python?

Par exemple, disons que je veux générer une liste avec les nombres 6 à 9 et -6 à -9.

Mon approche actuelle est:

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

Un simple "one-liner" serait:

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

Cependant, générer deux listes, puis les réunir, semble peu pratique.

Je ne sais pas si la commande est importante, mais vous pouvez créer un tuple et le déballer dans une liste de compréhension.

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

Créez une fonction agréable et lisible:

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

Usage:

list(range_with_negatives(6, 10))

C'est ainsi que vous obtenez une doublure pratique pour tout. Évitez d'essayer de ressembler à un pirate pro magique.

Je dirais que la solution la plus simple consiste à déballer deux plages dans une liste à l'aide de l' *opérateur de déballage:

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

Non seulement c'est la réponse la plus courte proposée à ce jour, mais c'est aussi la plus performante, car elle ne construit qu'une seule liste et n'implique aucun appel de fonction au-delà des deux. range s.

J'ai vérifié cela en testant toutes les réponses à cette question en utilisant le timeit module:

Answer ID Method timeit result
-------------------------------------------------- ------------------------------------------------
(en question) [x pour x dans la plage (6,10)] + [y pour y dans la plage (-9, -5)] 0,843 usec par boucle
(cette réponse) [* plage (6, 10), * plage (-9, -5)] 0,509 usec par boucle
61348876 [y pour x dans la plage (6,10) pour y dans (x, -x)] 0,754 usec par boucle
61349149 liste (range_with_negatives (6, 10)) 0,795 usec par boucle
61348914 liste (itertools.chain (plage (6, 10), plage (-9, -5))) 0,709 usec par boucle
61366995 [signe * x pour signe, x dans itertools.product ((- 1, 1), range (6, 10))] 0,899 usec par boucle
61371302 liste (plage (6, 10)) + liste (plage (-9, -5)) 0,729 usec par boucle
Liste 61367180 (range_with_negs (6, 10)) 1,95 usec par boucle

^{(test de timeit effectué avec Python 3.6.9 sur mon propre ordinateur (spécifications moyennes))}

Vous pouvez utiliser itertools.chain()pour concaténer les deux plages.

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

Vous pouvez utiliser itertools.product, qui est le produit cartésien.

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

Cela peut être plus lent car vous utilisez la multiplication, mais devrait être facile à lire.

Si vous souhaitez une solution purement fonctionnelle, vous pouvez également importer itertools.starmapet operator.mul:

from itertools import product, starmap
from operator import mul

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

Cependant, cela est moins lisible.

Vous êtes vraiment proche, avec la combinaison de deux rangeobjets. Mais il existe un moyen plus simple de le faire:

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

Autrement dit, convertissez chaque rangeobjet en une liste, puis concaténez les deux listes.

Une autre approche, en utilisant itertools:

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

itertools.chain()c'est comme un généralisé +: au lieu d'ajouter deux listes, il enchaîne un itérateur après l'autre pour en faire un "super-itérateur". Passez ensuite cela à list()et vous obtenez une liste concrète, avec tous les numéros que vous voulez en mémoire.

Pesant avec encore une autre possibilité.

Si vous voulez la lisibilité, votre doublure d'origine était plutôt bonne, mais je changerais les plages pour qu'elles soient les mêmes car je pense que les limites négatives rendent les choses moins claires.

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

L'OMI, l'approche utilisée itertools.chaindans quelques autres réponses est certainement la plus propre de celles fournies jusqu'à présent.

Cependant, comme dans votre cas, l'ordre des valeurs n'a pas d'importance , vous pouvez éviter d'avoir à définir deux rangeobjets explicites , et ainsi éviter de faire toutes les mathématiques off-by-one nécessaires à une rangeindexation négative , en utilisant 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 verbeux, mais assez lisible.

Une autre option similaire consiste à utiliser le décompactage tuple / argument avec plain chain:

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

Plus concis, mais je trouve que le déballage des tuples est plus difficile à analyser dans un scan rapide.

Ceci est une variation sur un thème (voir @Derte trdelník de réponse ) suivant la philosophie de itertoolslaquelle

les blocs de construction de l'itérateur [...] sont utiles seuls ou en combinaison.

L'idée est que, pendant que nous définissons une nouvelle fonction, nous pouvons aussi bien la rendre générique:

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

et l'appliquer à un rangeitérateur particulier :

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

Si vous souhaitez conserver l'ordre que vous avez spécifié, vous pouvez utiliser le générateur de plage intégré de Python avec un conditionnel:

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

Ce qui vous donne la sortie:

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

Et fonctionne également avec 0 comme point de départ pour la gamme complète.

Il peut y avoir différentes façons de faire le travail.

Variables données: 1. début = 6 2. arrêt = 10

Vous pouvez également essayer ceci, pour différentes approches:

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)

Tout comme les symétries.

a = 6 b = 10

nums = [x + y pour x dans (- (a + b-1), 0) pour y dans la plage (a, b)]

Le résultat doit être -9, -8, ..., 8, 9.

Je crois que l'expression nums peut être améliorée, ce qui suit "in" et "range" me semble toujours déséquilibré.