Создать список чисел и их отрицательных аналогов в Python

Есть ли в Python удобный однострочный список для генерации списка чисел и их отрицательных аналогов?

Например, скажем, я хочу создать список с номерами от 6 до 9 и от -6 до -9.

Мой текущий подход:

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

Простой «однострочник» будет:

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

Однако создание двух списков и последующее их объединение кажется неудобным.

Я не уверен, имеет ли значение порядок, но вы могли бы создать кортеж и распаковать его в понимании списка.

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

Создайте красивую и читаемую функцию:

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

Применение:

list(range_with_negatives(6, 10))

Так вы получаете удобную однострочку для чего угодно. Старайтесь не выглядеть как волшебный профессиональный хакер.

Я бы сказал, что самое простое решение - распаковать два диапазона в список с помощью *оператора распаковки:

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

Это не только самый короткий предложенный ответ, но и самый эффективный, потому что он создает только один список и не включает никаких вызовов функций, кроме двух range.

Я проверил это, протестировав ответы на все вопросы с помощью timeitмодуля:

Метод идентификатора ответа timeit результат
-------------------------------------------------- ------------------------------------------------
(в вопросе) [x для x в диапазоне (6,10)] + [y для y в диапазоне (-9, -5)] 0,843 мкс / цикл
(этот ответ) [* диапазон (6, 10), * диапазон (-9, -5)] 0,509 мкс на цикл
61348876 [y для x в диапазоне (6,10) для y в (x, -x)] 0,754 мкс на цикл
61349149 список (range_with_negatives (6, 10)) 0,795 мкс на цикл
61348914 список (itertools.chain (диапазон (6, 10), диапазон (-9, -5))) 0,709 пользователя на цикл
61366995 [знак * x для знака, x в itertools.product ((- 1, 1), диапазон (6, 10))] 0,899 мксек на цикл
61371302 список (диапазон (6, 10)) + список (диапазон (-9, -5)) 0,729 мксек на цикл
61367180 список (range_with_negs (6, 10)) 1,95 usec за цикл

^{(тестирование timeit, выполненное с Python 3.6.9 на моем собственном компьютере (средние характеристики))}

Вы можете использовать itertools.chain()для объединения двух диапазонов.

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

Вы можете использовать itertools.product, который является декартовым произведением.

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

Это может быть медленнее, потому что вы используете умножение, но должно быть легко читаемым.

Если вы хотите чисто функциональное решение, вы также можете импортировать itertools.starmapи operator.mul:

from itertools import product, starmap
from operator import mul

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

Однако это менее читабельно.

Вы действительно близки, комбинируя два rangeобъекта. Но есть более простой способ сделать это:

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

То есть преобразовать каждый rangeобъект в список, а затем объединить два списка.

Другой подход, использующий itertools:

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

itertools.chain()похоже на обобщенный +: вместо добавления двух списков он создает один итератор за другим, чтобы создать «супер-итератор». Затем передайте это, list()и вы получите конкретный список со всеми нужными числами в памяти.

Взвешивание с еще одной возможностью.

Если вы хотите удобочитаемости, ваш оригинальный однострочный текст был довольно хорошим, но я бы изменил диапазоны на те же, что и на мой взгляд, отрицательные границы делают вещи менее ясными.

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

ИМО подход, использующий itertools.chainпредставленный в нескольких других ответах, является определенно самым чистым из предоставленных до сих пор.

Тем не менее, поскольку в вашем случае порядок значений не имеет значения , вы можете избежать необходимости определять два явных rangeобъекта и, таким образом, избегать выполнения математических операций, необходимых для отрицательной rangeиндексации, используя 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]

Немного многословно, но достаточно читабельно.

Другой подобный вариант - использовать распаковку кортежей / аргументов с помощью plain chain:

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

Более кратко, но я обнаружил, что распаковка кортежа сложнее в быстром сканировании.

Это вариация на тему (см @Derte Trdelnik «s ответ ) , следуя философии , itertoolsгде

Строительные блоки итератора [...] полезны сами по себе или в сочетании.

Идея состоит в том, что, хотя мы определяем новую функцию, мы могли бы также сделать ее общей:

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

и применить его к конкретному rangeитератору:

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

Если вы хотите сохранить указанный вами порядок, вы можете использовать встроенный в Python генератор диапазонов с условным условием:

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

Что дает вам вывод:

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

А также работает с 0 в качестве начала для полного диапазона.

Там могут быть разные способы сделать работу.

Заданные переменные: 1. start = 6 2. stop = 10

Вы можете попробовать это также для другого подхода:

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)

Я просто люблю симметрии.

а = 6 б = 10

nums = [x + y для x in (- (a + b-1), 0) для y в диапазоне (a, b)]

Результат должен быть -9, -8, ..., 8, 9.

Я считаю, что выражение чисел может быть улучшено, то, что следует за "в" и "диапазоне", все еще выглядит мне неуравновешенным.