迹忆客 专注技术分享

Python 中以块的形式遍历列表：

1. 使用一个步骤迭代列表的长度范围。
2. 在每次迭代中返回一个长度为 N 的项目。
3. 使用 for 循环遍历分块列表。

def chunk_iterable(iterable, size):
    return [
        iterable[idx: idx + size] for idx in
        range(0, len(iterable), size)
    ]


a_list = ['a', 'b', 'c', 'd', 'e', 'f']

new_list = chunk_iterable(a_list, 2)
print(new_list)  # 👉️ [['a', 'b'], ['c', 'd'], ['e', 'f']]

for sublist in new_list:
    # ['a', 'b']
    # ['c', 'd']
    # ['e', 'f']
    print(sublist)

我们使用 range 类来获取一系列索引，这些索引代表每个块中的第一项。

a_list = ['a', 'b', 'c', 'd', 'e', 'f']

size = 2

# 👇️ [0, 2, 4]
print(list(range(0, len(a_list), size)))

range 类通常用于在 for 循环中循环特定次数，并采用以下参数：

• start 表示范围开始的整数（默认为 0）
• stop 直到，但不包括提供的整数
• step 范围将由从开始到结束的每 N 个数字组成（默认为 1）

列表切片的语法是 a_list[start:stop:step] 。

start 索引是包含的，stop 索引是排他的（直到，但不包括）。

在每次迭代中，我们从 range 内的当前项获取开始索引，并通过将 start 索引与所需的块长度相加来计算 stop 索引。

def chunk_iterable(iterable, size):
    return [
        iterable[idx: idx + size] for idx in
        range(0, len(iterable), size)
    ]


a_list = ['a', 'b', 'c', 'd', 'e', 'f']

new_list = chunk_iterable(a_list, 2)
print(new_list)  # 👉️ [['a', 'b'], ['c', 'd'], ['e', 'f']]

for sublist in new_list:
    # ['a', 'b']
    # ['c', 'd']
    # ['e', 'f']
    print(sublist)

如果列表的长度为奇数，则列表中的最后一项将包含较少的项目。

def chunk_iterable(iterable, size):
    return [
        iterable[idx: idx + size] for idx in
        range(0, len(iterable), size)
    ]


a_list = ['a', 'b', 'c', 'd', 'e', 'f', 'g']

new_list = chunk_iterable(a_list, 2)
# 👇️ [['a', 'b'], ['c', 'd'], ['e', 'f'], ['g']]
print(new_list)

for sublist in new_list:
    # ['a', 'b']
    # ['c', 'd']
    # ['e', 'f']
    # ['g']
    print(sublist)

这种方法也可以用于分块其他可迭代对象，例如 一个字符串。

def chunk_iterable(iterable, size):
    return [
        iterable[idx: idx + size] for idx in
        range(0, len(iterable), size)
    ]


a_string = 'abcdef'

new_list = chunk_iterable(a_string, 2)
print(new_list)  # 👉️ ['ab', 'cd', 'ef']

for sublist in new_list:
    # ab
    # cd
    # ef
    print(sublist)

或者，我们可以使用 while 循环。

使用 while 循环迭代 Chunks 中的列表

以块的形式遍历列表：

1. 使用 while 循环将列表拆分为固定大小的块。
2. 使用 for 循环遍历分块列表。

a_list = ['a', 'b', 'c', 'd', 'e', 'f']

list_copy = a_list.copy()

new_list = []

n = 2

while list_copy:
    new_list.append(list_copy[:n])
    list_copy = list_copy[n:]

# 👇️ [['a', 'b'], ['c', 'd'], ['e', 'f']]
print(new_list)

for sublist in new_list:
    # ['a', 'b']
    # ['c', 'd']
    # ['e', 'f']
    print(sublist)

我们声明了第二个变量来存储完全相同的列表。

在 while 循环的每次迭代中，我们将复制列表的前 n 项附加到新列表，并从复制列表中删除前 n 项。

最后一步是使用 for 循环遍历分块列表。

或者，我们可以使用 more_itertools.chunked 方法。

使用 more_itertools.chunked() 以 Chunks 的形式迭代列表

以块的形式遍历列表：

1. 使用 more_itertools.chunked() 方法将列表拆分为固定大小的块。
2. 使用 for 循环遍历分块列表。

from more_itertools import chunked

a_list = ['a', 'b', 'c', 'd', 'e', 'f']

n = 2

new_list = list(chunked(a_list, n))

# 👉️ [['a', 'b'], ['c', 'd'], ['e', 'f']]
print(new_list)

for sublist in new_list:
    # ['a', 'b']
    # ['c', 'd']
    # ['e', 'f']
    print(sublist)

通过运行 pip install more-itertools 命令确保安装了 more-itertools 包。

$ pip install more-itertools
$ pip3 install more-itertools

more_itertools.chunked 方法接受一个可迭代对象和 n，并将可迭代对象拆分为长度为 n 的列表。

如果列表的长度不能被 n 整除，则新列表将包含少于 n 个元素。

from more_itertools import chunked


a_list = ['a', 'b', 'c', 'd', 'e', 'f', 'g']

n = 2

new_list = list(chunked(a_list, n))

# 👉️ [['a', 'b'], ['c', 'd'], ['e', 'f'], ['g']]
print(new_list)

for sublist in new_list:
    # ['a', 'b']
    # ['c', 'd']
    # ['e', 'f']
    # ['g']
    print(sublist)

如果要在列表长度不能被 n 整除的情况下指定填充值，请使用 more_itertools.grouper() 方法。

from more_itertools import grouper


a_list = ['a', 'b', 'c', 'd', 'e', 'f', 'g']

n = 2

new_list = list(
    grouper(a_list, n, incomplete='fill', fillvalue='-')
)

# 👉️ [('a', 'b'), ('c', 'd'), ('e', 'f'), ('g', '-')]
print(new_list)

for sublist in new_list:
    # ('a', 'b')
    # ('c', 'd')
    # ('e', 'f')
    # ('g', '-')
    print(sublist)

more_itertools.grouper 方法将 iterable 中的元素分组为长度为 n 的固定大小的组。

如果列表不能被 n 整除，则 fillvalue 参数可用于用特定值填充最后一组。