检测“for”中最后一个元素的Pythonic方法是什么？环形？

Question

使用 for 循环进行迭代时，如何特殊处理输入的最后一个元素？特别是，如果有代码应该只出现在元素“之间”（而不是最后一个元素“之后”），我该如何构建代码？

目前，我编写的代码如下：

for i, data in enumerate(data_list):
    code_that_is_done_for_every_element
    if i != len(data_list) - 1:
        code_that_is_done_between_elements

如何简化或改进它？

Answer 1

大多数时候，将第一个迭代作为特殊情况而不是最后一个迭代会更容易（而且更便宜）：

first = True
for data in data_list:
    if first:
        first = False
    else:
        between_items()

    item()

这适用于任何可迭代，即使对于那些没有 len( )：

file = open('/path/to/file')
for line in file:
    process_line(line)
    
    # No way of telling if this is the last line!

除此之外，我认为没有一个普遍优越的解决方案，因为这取决于您想要做什么。例如，如果您要从列表构建字符串，那么使用 str.join() 自然比使用“特殊情况”的 for 循环更好。

---

使用相同的原理但更紧凑：

for i, line in enumerate(data_list):
    if i > 0:
        between_items()
    item()

看起来很熟悉，不是吗？ :)

---

对于 @ofko 和其他真正需要找出不带 len() 的可迭代对象的当前值是否是最后一个值的人，您需要向前看：

def lookahead(iterable):
    """Pass through all values from the given iterable, augmented by the
    information if there are more values to come after the current one
    (True), or if it is the last value (False).
    """
    # Get an iterator and pull the first value.
    it = iter(iterable)
    try:
        last = next(it)
    except StopIteration:
        return
    # Run the iterator to exhaustion (starting from the second value).
    for val in it:
        # Report the *previous* value (more to come).
        yield last, True
        last = val
    # Report the last value.
    yield last, False

然后您可以像这样使用它这：

>>> for i, has_more in lookahead(range(3)):
...     print(i, has_more)
0 True
1 True
2 False

Answer 2

如果项目是唯一的：

for x in list:
    #code
    if x == list[-1]:
        #code

其他选项：

pos = -1
for x in list:
    pos += 1
    #code
    if pos == len(list) - 1:
        #code


for x in list:
    #code
#code - e.g. print x


if len(list) > 0:
    for x in list[:-1]:
        #process everything except the last element
    for x in list[-1:]:
        #process only last element

Answer 3

虽然这个问题很老了，但我通过谷歌来到这里，发现了一个非常简单的方法：列表切片。假设您想添加一个“&”所有列表条目之间。

s = ""
l = [1, 2, 3]
for i in l[:-1]:
    s = s + str(i) + ' & '
s = s + str(l[-1])

这将返回 '1 & 2& 3'。

Answer 4

“代码之间”是头尾模式的一个示例。

您有一个项目，后面跟着一系列 ( Between, item ) 对。您还可以将其视为一系列（项目，之间）对，后跟一个项目。通常，将第一个元素视为特殊元素并将所有其他元素视为“标准”情况会更简单。

此外，为了避免重复代码，您必须提供一个函数或其他对象来包含您不想重复的代码。在循环中嵌入一个 if 语句，除了一次之外总是为假，这是一种愚蠢的行为。

def item_processing( item ):
    # *the common processing*

head_tail_iter = iter( someSequence )
head = next(head_tail_iter)
item_processing( head )
for item in head_tail_iter:
    # *the between processing*
    item_processing( item )

这更可靠，因为它更容易证明，它不会创建额外的数据结构（即列表的副本），并且不需要大量浪费的 if 条件执行除了一次之外，这总是错误的。

Answer 5

如果您只是想修改 data_list 中的最后一个元素，那么您可以简单地使用符号：

L[-1]

但是，看起来您所做的不止于此。你的方式并没有什么问题。我什至快速浏览了一些 Django 代码他们的模板标签，他们基本上做你正在做的事情。

Answer 6

您可以使用以下代码确定最后一个元素：

for i,element in enumerate(list):
    if (i==len(list)-1):
        print("last element is" + element)

Answer 7

这类似于 Ants Aasma 的方法，但不使用 itertools 模块。它也是一个滞后迭代器，它向前查找迭代器流中的单个元素：

def last_iter(it):
    # Ensure it's an iterator and get the first field
    it = iter(it)
    prev = next(it)
    for item in it:
        # Lag by one item so I know I'm not at the end
        yield 0, prev
        prev = item
    # Last item
    yield 1, prev

def test(data):
    result = list(last_iter(data))
    if not result:
        return
    if len(result) > 1:
        assert set(x[0] for x in result[:-1]) == set([0]), result
    assert result[-1][0] == 1

test([])
test([1])
test([1, 2])
test(range(5))
test(xrange(4))

for is_last, item in last_iter("Hi!"):
    print is_last, item

Answer 8

我们可以使用 for-else

cities = [
  'Jakarta',
  'Surabaya',
  'Semarang'
]

for city in cities[:-1]:
  print(city)
else:
  print(' '.join(cities[-1].upper()))

输出来实现这一点：

Jakarta
Surabaya
S E M A R A N G

这个想法是我们只使用 for-else 循环直到 n-1 索引，然后在for 已耗尽，我们使用 [-1] 直接访问最后一个索引。

Answer 9

您可以在输入数据上使用滑动窗口来查看下一个值，并使用哨兵来检测最后一个值。这适用于任何可迭代对象，因此您无需事先知道长度。成对实现来自 itertools Recipe。

from itertools import tee, izip, chain

def pairwise(seq):
    a,b = tee(seq)
    next(b, None)
    return izip(a,b)

def annotated_last(seq):
    """Returns an iterable of pairs of input item and a boolean that show if
    the current item is the last item in the sequence."""
    MISSING = object()
    for current_item, next_item in pairwise(chain(seq, [MISSING])):
        yield current_item, next_item is MISSING:

for item, is_last_item in annotated_last(data_list):
    if is_last_item:
        # current item is the last item

Answer 10

我将提供一种更优雅、更健壮的方式，如下，使用拆包：

def mark_last(iterable):
    try:
        *init, last = iterable
    except ValueError:  # if iterable is empty
        return

    for e in init:
        yield e, True
    yield last, False

测试：

for a, b in mark_last([1, 2, 3]):
    print(a, b)

结果是：

1 正确
2 真实
3 错误

Answer 11

特殊情况：输入末尾有一个已知的“哨兵”值，或者已知值是不同的

在这种情况下，我们可以简单地检查最后一个输入的值。

特殊情况：仅对最后一个元素执行一些额外的操作

Python 的 for 循环不会创建单独的作用域，这是设计的。因此，只需在循环之后编写“额外”代码：

for element in iterable:
    do_normal_thing(element)
do_extra_thing(element)

特殊情况：在每个元素“之间”做一些额外的事情

通常，人们将此问题设想为：在每次迭代中做一些正常的事情，然后做一些额外的事情，除了在最后一次迭代中跳过额外的部分。正如 S.Lott 的回答中所述，这使得问题变得过于复杂。检测 for 循环的第一次迭代很简单 - 例如，通过使用一个简单的标志变量 - 这也可以解决问题：做一些事情在每次迭代中都会有额外的部分，然后是正常的部分，除了在第一次迭代中跳过额外的部分。因此：（

first = True
for element in iterable:
    if first:
        first = False
    else:
        do_extra_thing(element)
    do_normal_thing(element)

当然，有些情况甚至更特殊。例如，如果“做一些正常的事情”意味着“将元素附加到输出字符串”，而“做一些额外的事情”意味着“将分隔符字符串附加到输出” ”，那么我们真正要做的是用分隔符连接元素。）

特殊情况：处理重叠的元素

对有时需要循环输入中重叠的元素对的人会将其设想为：循环除最后一个元素之外的每个元素；对于每个元素，对该元素及其后面的元素执行一些操作。

这实际上是描述问题的一种非常尴尬的方式，因为从元素获取“下一个元素”不起作用。我们需要输入的迭代器或索引值（对于序列）。

这个问题最好被视为一个完全不同的问题，这里详细介绍：如何迭代重叠（当前，下一个）列表中的值对？。

一般情况：对最后一个元素做一些特殊的事情

如果问题与上述任何一种特殊情况都不匹配，则有必要采取更严格的方法。以下是一些选项：

通过索引验证最后一个元素

如果输入是一个序列（即，它具有已知的长度），则确定最后一个元素的索引很简单。通过使用enumerate访问索引，那么解决问题就变得很简单了。例如：

for index, element in enumerate(sequence):
    if index == len(sequence) - 1:
        do_something_special(element)
    else:
        do_something_normal(element)

对输入进行切片

同样，如果输入是一个序列，我们可以采用一个 切片，其中包含除最后一个元素之外的所有元素，迭代在此之上，然后处理最后一个元素：

for element in sequence[:-1]:
    do_something_normal(element)
do_something_special(sequence[-1])

这假设至少有一个元素（否则， element[-1] 将引发 IndexError）。这可以通过通常的方式处理（通过提前显式检查，或使用标准异常处理）；或者我们可以迭代两个单独的切片以避免错误：

for element in sequence[:-1]:
    do_something_normal(element)
for element in sequence[-1:]:
    do_something_special(element)

这是有效的，因为切片不关心“丢失”元素；如果 sequence 为空，则 sequence[-1:] 将只是一个空列表。

无法对没有确定长度的迭代进行切片，因为只能通过一次查看一个元素来处理它们，并且仅查看一个元素并不能确定它是否是最后一个元素。 itertools.islice 无法解决此问题（因此明确不允许切片的停止点为负值）。

使用lookahead

请参阅Ferdinand Beyer 的回答中的lookahead 迭代器实现；这允许我们编写如下代码：

for element, is_last in lookahead(sequence):
    if is_last:
        do_something_special(element)
    else:
        do_something_normal(element)

这个想法的另一个实现是Ants Aasma的答案。这基本上将问题重新构建为“迭代重叠对”问题，除了添加了一个哨兵值，以便最后一个值输入有一个“对”，然后循环可以简单地检查该哨兵。

Answer 12

是否不可能迭代除最后一个元素之外的所有元素，并将最后一个元素放在循环之外？毕竟，创建循环的目的是执行与循环遍历的所有元素类似的操作；如果一个元素需要一些特殊的东西，它不应该在循环中。

（另请参阅这个问题：does-the- last-element-in-a-loop-deserve-a-separate-treatment）

编辑：由于问题更多是关于“之间”，所以第一个元素是特殊的其中之一是它没有前任元素，或者 last 元素是特殊的，因为它没有后继元素。

Answer 13

使用切片和 is 检查最后一个元素：

for data in data_list:
    <code_that_is_done_for_every_element>
    if not data is data_list[-1]:
        <code_that_is_done_between_elements>

买者自负：只有当列表中的所有元素实际上都不同（在内存中具有不同的位置）时，这才有效。在底层，Python 可以检测相同的元素并为它们重用相同的对象。例如，对于相同值的字符串和公共整数。

Answer 14

对我来说，处理列表末尾的特殊情况的最简单和Python式的方法是：

for data in data_list[:-1]:
    handle_element(data)
handle_special_element(data_list[-1])

当然，这也可以用于以特殊方式处理第一个元素。

Answer 15

除了向上计数之外，您还可以向下计数：

  nrToProcess = len(list)
  for s in list:
    s.doStuff()
    nrToProcess -= 1
    if nrToProcess==0:  # this is the last one
      s.doSpecialStuff()

Answer 16

我喜欢 @ethan-t 的方法，但从我的角度来看，while True 是危险的。

data_list = [1, 2, 3, 2, 1]  # sample data
L = list(data_list)  # destroy L instead of data_list
while L:
    e = L.pop(0)
    if L:
        print(f'process element {e}')
    else:
        print(f'process last element {e}')
del L

这里，data_list 使得最后一个元素的值等于列表的第一个元素。 L 可以与 data_list 交换，但在这种情况下，循环后结果为空。如果您在处理之前检查列表不为空或者不需要检查（哎呀！），也可以使用 while True 。

data_list = [1, 2, 3, 2, 1]
if data_list:
    while True:
        e = data_list.pop(0)
        if data_list:
            print(f'process element {e}')
        else:
            print(f'process last element {e}')
            break
else:
    print('list is empty')

好的部分是它很快。坏处 - 它是可破坏的（data_list 变为空）。

最直观的解决方案：

data_list = [1, 2, 3, 2, 1]  # sample data
for i, e in enumerate(data_list):
    if i != len(data_list) - 1:
        print(f'process element {e}')
    else:
        print(f'process last element {e}')

哦，是的，你已经提出了！

Answer 17

如果您正在循环 List，
使用 enumerate 函数是最好的尝试之一。

for index, element in enumerate(ListObj):
    # print(index, ListObj[index], len(ListObj) )

    if (index != len(ListObj)-1 ):
        # Do things to the element which is not the last one
    else:
        # Do things to the element which is the last one

Answer 18

你的方法没有任何问题，除非你有 100 000 个循环并且想要保存 100 000 个“if”语句。在这种情况下，你可以这样做：

iterable = [1,2,3] # Your date
iterator = iter(iterable) # get the data iterator

try :   # wrap all in a try / except
    while 1 : 
        item = iterator.next() 
        print item # put the "for loop" code here
except StopIteration, e : # make the process on the last element here
    print item

输出：

1
2
3
3

但实际上，就你的情况而言，我觉得这是矫枉过正。

无论如何，您可能会更幸运地进行切片 :

for item in iterable[:-1] :
    print item
print "last :", iterable[-1]

#outputs
1
2
last : 3

或只是 :

for item in iterable :
    print item
print iterable[-1]

#outputs
1
2
3
last : 3

最终，一种 KISS 方式来完成您的工作，并且这将适用于任何可迭代，包括那些没有 __len__ 的迭代：

item = ''
for item in iterable :
    print item
print item

输出：

1
2
3
3

如果感觉就像我会那样做，对我来说似乎很简单。

Answer 19

如果您正在浏览该列表，对我来说这也有效：

for j in range(0, len(Array)):
    if len(Array) - j > 1:
        notLast()

Answer 20

谷歌让我想到了这个老问题，我想我可以为这个问题添加不同的方法。

这里的大多数答案都会按照要求处理 for 循环控制的正确处理，但如果 data_list 是可破坏的，我建议您从列表中弹出项目，直到最终得到一个空列表：

while True:
    element = element_list.pop(0)
    do_this_for_all_elements()
    if not element:
        do_this_only_for_last_element()
        break
    do_this_for_all_elements_but_last()

您可以如果您不需要对最后一个元素执行任何操作，甚至可以使用 while len(element_list) 。我发现这个解决方案比处理 next() 更优雅。

Answer 21

将最后一项的特殊处理延迟到循环之后。

>>> for i in (1, 2, 3):
...     pass
...
>>> i
3

Answer 22

如果您乐于破坏该列表，那么可以选择以下内容。
我们将反转列表以加快从 O(n^2) 到 O(n) 的过程，因为 pop(0) 每次迭代都会移动列表 - 参见。 Nicholas Pipitone 在下面的评论

data_list.reverse()
while data_list:
   value = data_list.pop()
   code_that_is_done_for_every_element(value)
   if data_list:
       code_that_is_done_between_elements(value)
   else:
       code_that_is_done_for_last_element(value)

这适用于空列表和非唯一项目列表。
由于列表通常是暂时的，因此这种方法效果很好......但代价是破坏列表。

Answer 23

我刚刚遇到这个问题，我的通用解决方案使用迭代器：

from typing import TypeVar, Iterable
E = TypeVar('E')

def metait(i: Iterable[E]) -> Iterable[tuple[E, bool, bool]]:

    first = True
    previous = None
    for elem in i:
        if previous:
            yield previous, first, False
            first = False
        previous = elem

    if previous:
        yield previous, first, True

您将收到一个元组，其中包含第一个和最后一个项目的原始元素和标志。它可以与每个迭代一起使用：

d = {'a': (1,2,3), 'b': (4,5,6), 'c': (7,8,9)}

for (k,v), is_first, is_last in metait(d.items()):
    print(f'{k}: {v}  {is_first} {is_last}')

这将为您提供：

a: (1, 2, 3)  True False
b: (4, 5, 6)  False False
c: (7, 8, 9)  False True

Answer 24

假设输入作为迭代器，以下是使用 itertools 中的 tee 和 izip 的方法：

from itertools import tee, izip
items, between = tee(input_iterator, 2)  # Input must be an iterator.
first = items.next()
do_to_every_item(first)  # All "do to every" operations done to first item go here.
for i, b in izip(items, between):
    do_between_items(b)  # All "between" operations go here.
    do_to_every_item(i)  # All "do to every" operations go here.

演示：

>>> def do_every(x): print "E", x
...
>>> def do_between(x): print "B", x
...
>>> test_input = iter(range(5))
>>>
>>> from itertools import tee, izip
>>>
>>> items, between = tee(test_input, 2)
>>> first = items.next()
>>> do_every(first)
E 0
>>> for i,b in izip(items, between):
...     do_between(b)
...     do_every(i)
...
B 0
E 1
B 1
E 2
B 2
E 3
B 3
E 4
>>>

Answer 25

我想到的最简单的解决方案是：

for item in data_list:
    try:
        print(new)
    except NameError: pass
    new = item
print('The last item: ' + str(new))

因此，我们总是通过延迟处理一次迭代来向前看一项。为了在第一次迭代期间跳过某些操作，我只需捕获错误即可。

当然，您需要考虑一下，以便在您需要时引发 NameError。

还要保留 `construct

try:
    new
except NameError: pass
else:
    # continue here if no error was raised

这依赖于先前未定义的名称 new。如果您偏执，您可以使用以下方法确保 new 不存在：

try:
    del new
except NameError:
    pass

或者，您当然也可以使用 if 语句 (if notfirst: print(new) else: notfirst = True）。但据我所知，开销更大。

---

Using `timeit` yields:

    ...: try: new = 'test' 
    ...: except NameError: pass
    ...: 
100000000 loops, best of 3: 16.2 ns per loop

所以我预计开销是无法选择的。

Answer 26

计算一次项目并跟上剩余项目的数量：

remaining = len(data_list)
for data in data_list:
    code_that_is_done_for_every_element

    remaining -= 1
    if remaining:
        code_that_is_done_between_elements

这样您只需评估一次列表的长度。此页面上的许多解决方案似乎都假设长度无法提前获得，但这不是您问题的一部分。如果有长度，请使用它。

Answer 27

可以有多种方式。切片将是最快的。添加一个使用 .index() 方法的函数：

>>> l1 = [1,5,2,3,5,1,7,43]                                                 
>>> [i for i in l1 if l1.index(i)+1==len(l1)]                               
[43]

Answer 28

所以，这绝对不是“更短”的版本——如果“最短”和“Pythonic”实际上兼容的话，人们可能会离题。

但如果经常需要这种模式，只需将逻辑放入
10 行生成器 - 并获取与元素相关的任何元数据
直接定位在 for 调用上。这里的另一个优点是它会
与任意可迭代一起工作，而不仅仅是序列。

_sentinel = object()

def iter_check_last(iterable):
    iterable = iter(iterable)
    current_element = next(iterable, _sentinel)
    while current_element is not _sentinel:
        next_element = next(iterable, _sentinel)
        yield (next_element is _sentinel, current_element)
        current_element = next_element

In [107]: for is_last, el in iter_check_last(range(3)):
     ...:     print(is_last, el)
     ...: 
     ...: 
False 0
False 1
True 2

Answer 29

这是一个老问题，已经有很多很好的回应，但我觉得这很Pythonic：

def rev_enumerate(lst):
    """
    Similar to enumerate(), but counts DOWN to the last element being the
    zeroth, rather than counting UP from the first element being the zeroth.

    Since the length has to be determined up-front, this is not suitable for
    open-ended iterators.

    Parameters
    ----------
    lst : Iterable
        An iterable with a length (list, tuple, dict, set).

    Yields
    ------
    tuple
        A tuple with the reverse cardinal number of the element, followed by
        the element of the iterable.
    """
    length = len(lst) - 1
    for i, element in enumerate(lst):
        yield length - i, element

像这样使用：

for num_remaining, item in rev_enumerate(['a', 'b', 'c']):
    if not num_remaining:
        print(f'This is the last item in the list: {item}')

或者也许你想做相反的事情：

for num_remaining, item in rev_enumerate(['a', 'b', 'c']):
    if num_remaining:
        print(f'This is NOT the last item in the list: {item}')

或者，只是想知道你走的时候还剩下多少。 ..

for num_remaining, item in rev_enumerate(['a', 'b', 'c']):
    print(f'After {item}, there are {num_remaining} items.')

我认为现有 enumerate 的多功能性和熟悉性使其最具 Pythonic 风格。

需要注意的是，与 enumerate() 不同，rev_enumerate() 要求输入实现 __len__，但这包括列表、元组、字典和集合就可以了。

Answer 30

最简单的解决方案可能是：

from more_itertools import mark_ends

for _, is_last, data in mark_ends(data_list):
    code_that_is_done_for_every_element
    if not is_last:
        code_that_is_done_between_elements