Преобразование списка в дублированный [дубликат]

for (i, k) in zip(l[::2], l[1::2]):
    print i, "+", k, "=", i+k

zip(*iterable) возвращает кортеж со следующим элементом каждого итерабельного.

l[::2] возвращает элемент 1-го, 3-го, 5-го и т. д. списка: первая двоеточие указывает, что срез начинается с начала, потому что за ним нет номера, второй двоеточие требуется только, если вы хотите «шаг в срезе» (в этом случае 2).

l[1::2] делает то же самое, но начинается во втором элементе списков, поэтому он возвращает элемент 2-го, 4-го, 6-го и т. д. исходного списка.

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

Из документации Python itertools :

from itertools import izip

def pairwise(iterable):
    "s -> (s0,s1), (s1,s2), (s2, s3), ..."
    a, b = tee(iterable)
    next(b, None)
    return izip(a, b)

Или, в более общем смысле:

from itertools import izip

def groupwise(iterable, n=2):
    "s -> (s0,s1,...,sn-1), (s1,s2,...,sn), (s2,s3,...,sn+1), ..."
    t = tee(iterable, n)
    for i in range(1, n):
        for j in range(0, i):
            next(t[i], None)
    return izip(*t)

Мы также можем просто сделать список набором кортежей

l = [(1,2),(3,4)]
l.append((5,6))
for r,c in l:
   print r,c

:

1 2
3 4
5 6

Ну, вам нужен набор из 2 элементов, поэтому

data = [1,2,3,4,5,6]
for i,k in zip(data[0::2], data[1::2]):
    print str(i), '+', str(k), '=', str(i+k)

Где:

• data[0::2] означает создание набора подмножеств элементов, которые (index % 2 == 0)
• zip(x,y) создает набор кортежей из x и y, которые собирают одинаковые элементы индекса.

Хотя все ответы с использованием zip верны, я обнаружил, что реализация самой функции приводит к более читаемому коду:

def pairwise(it):
    it = iter(it)
    while True:
        yield next(it), next(it)

Часть it = iter(it) гарантирует, что it на самом деле является итератор, а не просто итеративный. Если it уже является итератором, эта строка не работает.

Использование:

for a, b in pairwise([0, 1, 2, 3, 4, 5]):
    print(a + b)

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

def Johnsyweb(l):
    def pairwise(iterable):
        "s -> (s0, s1), (s2, s3), (s4, s5), ..."
        a = iter(iterable)
        return zip(a, a)

    for x, y in pairwise(l):
        pass

def Margus(data):
    for i, k in zip(data[0::2], data[1::2]):
        pass

def pyanon(l):
    list(zip(l,l[1:]))[::2]

def taskinoor(l):
    for i in range(0, len(l), 2):
        l[i], l[i+1]

def mic_e(it):
    def pairwise(it):
        it = iter(it)
        while True:
            try:
                yield next(it), next(it)
            except StopIteration:
                return

    for a, b in pairwise(it):
        pass

def MSeifert(it):
    for item1, item2 in grouper(it, 2):
        pass

from iteration_utilities import grouper
from simple_benchmark import benchmark_random_list

b = benchmark_random_list(
    [Johnsyweb, Margus, pyanon, taskinoor, mic_e, MSeifert],
    sizes=[2**i for i in range(1, 20)])

b.plot_both(relative_to=MSeifert)

Windows 10 64-разрядный Anaconda Python 3.6

Итак, если вам нужно самое быстрое решение без внешних зависимостей, вам, вероятно, следует просто использовать

Если вы не возражаете против дополнительной зависимости, то grouper из iteration_utilities, вероятно, будет немного быстрее, если вы не возражаете против дополнительной зависимости. .

Дополнительные мысли

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

Например, несколько решений работают только для последовательностей ( это списки, строки и т. д.), например решения Margus / pyanon / taskinoor, которые используют индексирование, в то время как другие решения работают над любым итерационным (то есть последовательностями и генераторами, итераторами), такими как решения Johnysweb / mic_e / my.

Затем Johnysweb также pr ovided решение, которое работает для других размеров, чем 2, в то время как другие ответы не соответствуют (хорошо, iteration_utilities.grouper также позволяет установить количество элементов в «группу»).

Затем возникает вопрос о том, что должно произойти, если в списке есть нечетное число элементов. Должен ли оставшийся пункт быть уволен? Должен ли список быть дополнен, чтобы сделать его даже размером? Должен ли оставшийся элемент быть возвращен как единый? Другой ответ не затрагивает эту точку напрямую, однако, если я не упускаю из виду что-либо, все они следуют подходу, согласно которому оставшийся элемент должен быть уволен (за исключением ответа на запрос, который фактически вызовет исключение).

С помощью grouper вы можете решить, что вы хотите сделать:

>>> from iteration_utilities import grouper

>>> list(grouper([1, 2, 3], 2))  # as single
[(1, 2), (3,)]

>>> list(grouper([1, 2, 3], 2, truncate=True))  # ignored
[(1, 2)]

>>> list(grouper([1, 2, 3], 2, fillvalue=None))  # padded
[(1, 2), (3, None)]

Название этого вопроса вводит в заблуждение, похоже, вы ищете последовательные пары, но если вы хотите перебрать множество всех возможных пар, это будет работать:

for i,v in enumerate(items[:-1]):
        for u in items[i+1:]:

Ближе всего к написанному вами коду:

l = [1,2,3,4,5,6]

for i,k in zip(l[::2], l[1::2]):
    print(str(i), '+', str(k), '=', str(i+k))

Выход:

1+2=3
3+4=7
5+6=11

>>> l = [1,2,3,4,5,6]

>>> zip(l,l[1:])
[(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)]

>>> zip(l,l[1:])[::2]
[(1, 2), (3, 4), (5, 6)]

>>> [a+b for a,b in zip(l,l[1:])[::2]]
[3, 7, 11]

>>> ["%d + %d = %d" % (a,b,a+b) for a,b in zip(l,l[1:])[::2]]
['1 + 2 = 3', '3 + 4 = 7', '5 + 6 = 11']