Итерации по парам в списке (круговой) в Python

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

Я подумал о двух непитонистских способах этого:

def pairs(lst):
    n = len(lst)
    for i in range(n):
        yield lst[i],lst[(i+1)%n]

и

def pairs(lst):
    return zip(lst,lst[1:]+[lst[:1]])

ожидаемый вывод:

>>> for i in pairs(range(10)):
    print i

(0, 1)
(1, 2)
(2, 3)
(3, 4)
(4, 5)
(5, 6)
(6, 7)
(7, 8)
(8, 9)
(9, 0)
>>>

любые предложения о более питоническом способе сделать это? может быть, есть предопределенная функция, о которой я не слышал?

также может быть интересна более общая n-кратная (с тройками, квартетами и т.д. вместо пар) версия.

ОТВЕТЫ

Ответ 1

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

def ntuples(lst, n):
    return zip(*[lst[i:]+lst[:i] for i in range(n)])

Версия itertools должна быть достаточно эффективной даже для больших списков...

from itertools import *
def ntuples(lst, n):
    return izip(*[chain(islice(lst,i,None), islice(lst,None,i)) for i in range(n)])

И версия для неиндексируемых последовательностей:

from itertools import *
def ntuples(seq, n):
    iseq = iter(seq)
    curr = head = tuple(islice(iseq, n))
    for x in chain(iseq, head):
        yield curr
        curr = curr[1:] + (x,)

В любом случае, спасибо всем за ваши предложения!: -)

Ответ 2

def pairs(lst):
    i = iter(lst)
    first = prev = item = i.next()
    for item in i:
        yield prev, item
        prev = item
    yield item, first

Работает в любой непустой последовательности, не требуется индексация.

Ответ 3

I, как всегда, как tee:

from itertools import tee, izip, chain

def pairs(iterable):
    a, b = tee(iterable)
    return izip(a, chain(b, [next(b)]))

Ответ 4

Это может быть удовлетворительным:

def pairs(lst):
    for i in range(1, len(lst)):
        yield lst[i-1], lst[i]
    yield lst[-1], lst[0]

>>> a = list(range(5))
>>> for a1, a2 in pairs(a):
...     print a1, a2
...
0 1
1 2
2 3
3 4
4 0

Если вам нравится этот материал, посмотрите статьи python на wordaligned.org. Автор имеет особую любовь к генераторам в python.

Ответ 5

Я бы сделал это так (в основном потому, что я могу это прочитать):

class Pairs(object):
    def __init__(self, start):
        self.i = start
    def next(self):
        p, p1 = self.i, self.i + 1
        self.i = p1
        return p, p1
    def __iter__(self):
        return self

if __name__ == "__main__":
    x = Pairs(0)
    y = 1
    while y < 20:
        print x.next()
        y += 1

дает:

(0, 1)
(1, 2)
(2, 3)
(3, 4)
(4, 5)
(5, 6)
(6, 7)
(7, 8)
(8, 9)

Ответ 6

[(i,(i+1)%len(range(10))) for i in range(10)]

замените диапазон (10) на нужный вам список.

В целом "круговое индексирование" довольно просто в python; просто используйте:

a[i%len(a)]

Ответ 7

Чтобы ответить на ваш вопрос о решении для общего случая:

import itertools

def pair(series, n):
    s = list(itertools.tee(series, n))
    try:
        [ s[i].next() for i in range(1, n) for j in range(i)]
    except StopIteration:
        pass
    while True:
        result = []
        try:
            for j, ss in enumerate(s):
                result.append(ss.next())
        except StopIteration:
            if j == 0:
                break
            else:
                s[j] = iter(series)
                for ss in s[j:]:
                    result.append(ss.next())
        yield result

Вывод выглядит следующим образом:

>>> for a in pair(range(10), 2):
...     print a
...
[0, 1]
[1, 2]
[2, 3]
[3, 4]
[4, 5]
[5, 6]
[6, 7]
[7, 8]
[8, 9]
[9, 0]
>>> for a in pair(range(10), 3):
...     print a
...
[0, 1, 2]
[1, 2, 3]
[2, 3, 4]
[3, 4, 5]
[4, 5, 6]
[5, 6, 7]
[6, 7, 8]
[7, 8, 9]
[8, 9, 0]
[9, 0, 1]

Ответ 8

Это бесконечно циклично, хорошо или плохо, но алгоритмически очень ясно.

from itertools import tee, cycle

def nextn(iterable,n=2):
    ''' generator that yields a tuple of the next n items in iterable.
    This generator cycles infinitely '''
    cycled = cycle(iterable)
    gens = tee(cycled,n)

    # advance the iterators, this is O(n^2)
    for (ii,g) in zip(xrange(n),gens):
        for jj in xrange(ii):
            gens[ii].next()

    while True:
        yield tuple([x.next() for x in gens])


def test():
    data = ((range(10),2),
        (range(5),3),
        (list("abcdef"),4),)
    for (iterable, n) in data:
        gen = nextn(iterable,n)
        for j in range(len(iterable)+n):
            print gen.next()            


test()

дает:

(0, 1)
(1, 2)
(2, 3)
(3, 4)
(4, 5)
(5, 6)
(6, 7)
(7, 8)
(8, 9)
(9, 0)
(0, 1)
(1, 2)
(0, 1, 2)
(1, 2, 3)
(2, 3, 4)
(3, 4, 0)
(4, 0, 1)
(0, 1, 2)
(1, 2, 3)
(2, 3, 4)
('a', 'b', 'c', 'd')
('b', 'c', 'd', 'e')
('c', 'd', 'e', 'f')
('d', 'e', 'f', 'a')
('e', 'f', 'a', 'b')
('f', 'a', 'b', 'c')
('a', 'b', 'c', 'd')
('b', 'c', 'd', 'e')
('c', 'd', 'e', 'f')
('d', 'e', 'f', 'a')

Ответ 9

Даже более короткая версия решения Fortran zip * range (с lambda на этот раз;):

group = lambda t, n: zip(*[t[i::n] for i in range(n)])

group([1, 2, 3, 3], 2)

дает:

[(1, 2), (3, 4)]

Ответ 10

Здесь версия, которая поддерживает необязательный начальный индекс (например, чтобы вернуть (4, 0) в качестве первой пары, используйте start = -1:

import itertools

def iterrot(lst, start = 0):

    if start == 0:
        i = iter(lst)
    elif start > 0:
        i1 = itertools.islice(lst, start, None)
        i2 = itertools.islice(lst, None, start)
        i = itertools.chain(i1, i2)
    else:
        # islice doesn't support negative slice indices so...
        lenl = len(lst)
        i1 = itertools.islice(lst, lenl + start, None)
        i2 = itertools.islice(lst, None, lenl + start)
        i = itertools.chain(i1, i2)
    return i


def iterpairs(lst, start = 0):

    i = iterrot(lst, start)     

    first = prev = i.next()
    for item in i:
        yield prev, item
        prev = item
    yield prev, first


def itertrios(lst, start = 0):

    i = iterrot(lst, start)     

    first = prevprev = i.next()
    second = prev = i.next()
    for item in i:
        yield prevprev, prev, item
        prevprev, prev = prev, item

    yield prevprev, prev, first
    yield prev, first, second

Ответ 11

def pairs(ex_list):
    for i, v in enumerate(ex_list):
        if i < len(list) - 1:
            print v, ex_list[i+1]
        else:
            print v, ex_list[0]

Enumerate возвращает кортеж с номером индекса и значением. Я печатаю значение и следующий элемент списка ex_list[i+1]. Если i < len(list) - 1 означает, что v является не последним членом списка. Если это: print v и первый элемент списка print v, ex_list[0].

Изменить:

Вы можете заставить его вернуть список. Просто добавьте напечатанные кортежи в список и верните его.

def pairs(ex_list):
    result = []
    for i, v in enumerate(ex_list):
        if i < len(list) - 1:
            result.append((v, ex_list[i+1]))
        else:
            result.append((v, ex_list[0]))
    return result

Ответ 12

Конечно, вы всегда можете использовать deque:

from collections import deque
from itertools import *

def pairs(lst, n=2):
    itlst = iter(lst)
    start = list(islice(itlst, 0, n-1))
    deq = deque(start, n)
    for elt in chain(itlst, start):
        deq.append(elt)
        yield list(deq)

Ответ 13

i=(range(10))

for x in len(i):
    print i[:2]
    i=i[1:]+[i[1]]

больше pythonic, чем это невозможно