Lặp lại một danh sách dưới dạng cặp (hiện tại, tiếp theo) trong Python

Đôi khi tôi cần lặp lại một danh sách trong Python để xem phần tử "hiện tại" và phần tử "tiếp theo". Tôi có, cho đến bây giờ, đã làm như vậy với mã như:

for current, next in zip(the_list, the_list[1:]):
    # Do something

Điều này hoạt động và làm những gì tôi mong đợi, nhưng có một cách thành ngữ hay hiệu quả hơn để làm điều tương tự?

Đây là một ví dụ có liên quan từ các tài liệu mô-đun itertools :

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

Đối với Python 2, bạn cần itertools.izipthay vì zip:

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

Cách thức hoạt động:

Đầu tiên, hai trình lặp song song avà bđược tạo ( tee()cuộc gọi), cả hai đều trỏ đến phần tử đầu tiên của lần lặp ban đầu. Vòng lặp thứ hai, bđược di chuyển 1 bước về phía trước (lệnh next(b, None))). Tại thời điểm này chỉ ađến s0 và btrỏ đến s1. Cả hai avà bcó thể đi qua bộ lặp ban đầu một cách độc lập - hàm izip lấy hai bộ lặp và tạo các cặp phần tử được trả về, tiến lên cả hai bộ lặp với cùng tốc độ.

Một cảnh báo: tee()hàm tạo ra hai vòng lặp có thể tiến độc lập với nhau, nhưng nó có chi phí. Nếu một trong các trình vòng lặp tiến xa hơn các trình lặp khác, thì tee() cần phải giữ các phần tử đã tiêu thụ trong bộ nhớ cho đến khi trình vòng lặp thứ hai quay lại chúng (nó không thể 'tua lại' trình vòng lặp gốc). Ở đây không có vấn đề gì vì một trình vòng lặp chỉ đi trước một bước so với trình lặp khác, nhưng nói chung, thật dễ dàng để sử dụng nhiều bộ nhớ theo cách này.

Và vì tee()có thể lấy một ntham số, nên nó cũng có thể được sử dụng cho nhiều hơn hai trình lặp song song:

def threes(iterator):
    "s -> (s0,s1,s2), (s1,s2,s3), (s2, s3,4), ..."
    a, b, c = itertools.tee(iterator, 3)
    next(b, None)
    next(c, None)
    next(c, None)
    return zip(a, b, c)

Cuộn của riêng bạn!

def pairwise(iterable):
    it = iter(iterable)
    a = next(it, None)

    for b in it:
        yield (a, b)
        a = b

Vì the_list[1:]thực sự tạo một bản sao của toàn bộ danh sách (không bao gồm phần tử đầu tiên của nó) và zip()tạo một danh sách các bộ dữ liệu ngay lập tức khi được gọi, trong tổng số ba bản sao của danh sách của bạn được tạo. Nếu danh sách của bạn rất lớn, bạn có thể thích

from itertools import izip, islice
for current_item, next_item in izip(the_list, islice(the_list, 1, None)):
    print(current_item, next_item)

mà không sao chép danh sách cả.

Tôi chỉ đưa ra điều này, tôi rất ngạc nhiên không ai nghĩ đến việc liệt kê ().

for (index, thing) in enumerate(the_list):
    if index < len(the_list):
        current, next_ = thing, the_list[index + 1]
        #do something

Lặp lại theo chỉ mục có thể làm điều tương tự:

#!/usr/bin/python
the_list = [1, 2, 3, 4]
for i in xrange(len(the_list) - 1):
    current_item, next_item = the_list[i], the_list[i + 1]
    print(current_item, next_item)

Đầu ra:

(1, 2)
(2, 3)
(3, 4)

Đây là một Nhập khẩu đơn giản kể từ ngày 16 tháng 5 năm 2020

from more_itertools import pairwise
for current, next in pairwise(your_iterable):
  print(f'Current = {current}, next = {nxt}')

Tài liệu cho nhiều itertools Dưới mui xe, mã này giống như trong các câu trả lời khác, nhưng tôi thích nhập khẩu hơn khi có sẵn.

Nếu bạn chưa cài đặt thì: pip install more-itertools

Thí dụ

Chẳng hạn, nếu bạn có trình tự fftimenacci, bạn có thể tính tỷ lệ của các cặp tiếp theo là:

from more_itertools import pairwise
fib= [1,1,2,3,5,8,13]
for current, nxt in pairwise(fib):
    ratio=current/nxt
    print(f'Curent = {current}, next = {nxt}, ratio = {ratio} ')

Các cặp từ một danh sách sử dụng một sự hiểu biết danh sách

the_list = [1, 2, 3, 4]
pairs = [[the_list[i], the_list[i + 1]] for i in range(len(the_list) - 1)]
for [current_item, next_item] in pairs:
    print(current_item, next_item)

Đầu ra:

(1, 2)
(2, 3)
(3, 4)

Tôi thực sự ngạc nhiên không ai đề cập đến giải pháp chung ngắn hơn, đơn giản hơn và quan trọng nhất :

Con trăn 3:

from itertools import islice

def n_wise(iterable, n):
    return zip(*(islice(iterable, i, None) for i in range(n)))

Con trăn 2:

from itertools import izip, islice

def n_wise(iterable, n):
    return izip(*(islice(iterable, i, None) for i in xrange(n)))

Nó hoạt động cho phép lặp theo cặp bằng cách vượt qua n=2, nhưng có thể xử lý bất kỳ số nào cao hơn:

>>> for a, b in n_wise('Hello!', 2):
>>>     print(a, b)
H e
e l
l l
l o
o !

>>> for a, b, c, d in n_wise('Hello World!', 4):
>>>     print(a, b, c, d)
H e l l
e l l o
l l o
l o   W
o   W o
  W o r
W o r l
o r l d
r l d !

Một giải pháp cơ bản:

def neighbors( list ):
  i = 0
  while i + 1 < len( list ):
    yield ( list[ i ], list[ i + 1 ] )
    i += 1

for ( x, y ) in neighbors( list ):
  print( x, y )

code = '0016364ee0942aa7cc04a8189ef3'
# Getting the current and next item
print  [code[idx]+code[idx+1] for idx in range(len(code)-1)]
# Getting the pair
print  [code[idx*2]+code[idx*2+1] for idx in range(len(code)/2)]