如何获取列表的最后一个元素？

Question

如何获取列表的最后一个元素？

哪种方法更受欢迎？

alist[-1]
alist[len(alist) - 1]

- Janusz

Answer 1

some_list[-1]是最短且最具Python风格的方法。

实际上，你可以用这种语法做更多的事情。 some_list[-n] 语法获取倒数第 n 个元素。 所以 some_list[-1] 获取最后一个元素，some_list[-2] 获取倒数第二个元素，以此类推，一直到 some_list[-len(some_list)] ，它会给出第一个元素。

你也可以使用这种方式设置列表元素。例如：

>>> some_list = [1, 2, 3]
>>> some_list[-1] = 5 # Set the last element
>>> some_list[-2] = 3 # Set the second to last element
>>> some_list
[1, 3, 5]

请注意，通过索引获取列表项将在预期项不存在时引发 IndexError。这意味着如果some_list为空，则some_list[-1]会引发异常，因为空列表没有最后一个元素。

- Sasha Chedygov

---

您也可以使用反向方法，但在运行时会返回最后一个元素。 - kimiahdri

Answer 2

如果您的str()或list()对象最终可能为空，例如：astr = ''或alist = []，那么为了实现“sameness”，您可能会想要使用alist[-1:]而不是alist[-1]。

这样做的重要性在于：

alist = []
alist[-1]   # will generate an IndexError exception whereas 
alist[-1:]  # will return an empty list
astr = ''
astr[-1]    # will generate an IndexError exception whereas
astr[-1:]   # will return an empty str

所做的区分在于，返回一个空的列表对象或空的字符串对象比返回异常对象更像是最后一个元素。

- DevPlayer

---

因为我觉得这个答案的核心是不正确的，所以进行了下投票。当你想要一个元素而得到一个列表时，这只会推迟“列表索引超出范围”的错误出现，而在尝试从空列表中获取元素时应该出现这种错误。对于字符串 astr[-1:] 可能是一种有效的方法，因为它返回与 astr[-1] 相同类型的结果，但我认为“:”并没有帮助处理空列表（而问题是关于列表的）。如果想使用 "alist[-1:]" 作为条件而不是 "len(alist) > 0"，我认为后者更易读。（如果我漏掉了什么，很高兴给个赞） - Stan Kurdziel

你的“down vote”是可以理解和有效的。然而我发现有两个基本阵营对于异常对象的意图存在分歧。一个确定的事情是，异常会停止你的应用程序。一个阵营使用try语句中的异常，另一个阵营则使用类似于 if len(alist)>0: 的结构。无论如何，异常是停止你的代码的对象。因此，对我来说，它们比返回“null”序列（不会停止代码执行）的序列对象更不像。我的偏好是使用IF语句来测试“null”对象，而不是使用可能被try语句捕获的异常对象。 - DevPlayer

因为切片语法值得讨论，所以我点了赞。然而我同意@StanKurdziel的看法，这个单词形态是错的，你只是改变了目标。我发现自己的解决方案与“如果您还没有将此添加到列表中，请添加”（增量线图）的主要用途有关，因此合并表达式 if len(my_vector) == 0 or my_vector[-1] != update_val 是可行的模式。但这当然不是一个全局性的解决方案 - 如果有一个语法形式，其中None是结果，那就太好了。 - Mark Mullin

如果xs存在，则返回xs的最后一个元素，否则返回None。 - Gabriel

为什么要“避免”IndexError？如果您尝试对空列表或字符串进行索引，就会出现异常。如果您想处理该异常，请使用try/except——它的作用就在于此。 - Chris Johnson

Answer 3

你也可以这样做：

last_elem = alist.pop()

这取决于你想如何处理列表，因为 pop() 方法将删除最后一个元素。

- Taurus Olson

---

值得注意的是，这也会从列表中删除最后一个元素。 - Anis LOUNIS aka AnixPasBesoin

Answer 4

显示 Python 中最后一个元素的最简单方法是：

>>> list[-1:] # returns indexed value
    [3]
>>> list[-1]  # returns value
    3

有许多其他方法可以实现这样的目标，但这些方法简单又实用。

- Atul Arvind

---

如果您的列表长度为零，这个解决方案有效，而 list[-1] 将会出错。 - anon01

@anon01 但是要获取值，您必须访问返回的列表，并且会导致索引超出范围。因此，这个优势并不重要。 - Lakshith Nishshanke

这是一个弹出操作而不是查看操作。 - BigChief

这是一个查看操作而不是弹出操作。 - HelloWorld

Answer 5

在Python中，如何获取列表的最后一个元素？

要仅获取最后一个元素，而不修改列表，并且假设您知道列表有最后一个元素（即它非空），请将-1传递给下标符号：

>>> a_list = ['zero', 'one', 'two', 'three']
>>> a_list[-1]
'three'

说明

索引和切片可以接受负整数作为参数。

我修改了一个来自文档的示例，以指示每个索引引用序列中的哪个项目，在这种情况下，在字符串"Python"中，-1 引用最后一个元素，即字符'n'：

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
   0   1   2   3   4   5 
  -6  -5  -4  -3  -2  -1

>>> p = 'Python'
>>> p[-1]
'n'

通过可迭代对象解包进行赋值

为了完整起见（并且因为它支持任何可迭代对象 - 不仅仅是列表），此方法可能会不必要地将第二个列表实例化才能获取最后一个元素：

>>> *head, last = a_list
>>> last
'three'

变量名 head 被绑定到一个不必要的新建列表中：

>>> head
['zero', 'one', 'two']

如果你不打算对这个列表做任何操作，更适合使用以下代码：

*_, last = a_list

或者，如果您知道它是一个列表（或至少接受下标表示法）：

last = a_list[-1]

在一个函数中

一位评论者说：

我希望Python有像Lisp那样的first()和last()函数...这将消除很多不必要的lambda函数。

定义这些函数相当简单：

def last(a_list):
    return a_list[-1]

def first(a_list):
    return a_list[0]

或者使用 operator.itemgetter:

>>> import operator
>>> last = operator.itemgetter(-1)
>>> first = operator.itemgetter(0)

无论哪种情况：

>>> last(a_list)
'three'
>>> first(a_list)
'zero'

特殊情况

如果你正在做更复杂的事情，可能会发现以稍微不同的方式获取最后一个元素更具性能。

如果你是编程新手，应该避免使用本节，因为它将算法中本来语义不同的部分耦合在一起。如果你在一个地方改变了你的算法，它可能会对另一行代码产生意想不到的影响。

我尽可能全面地提供警告和条件，但可能有些遗漏。如果你认为我漏掉了某些注意事项，请评论指出。

切片

列表的切片返回一个新的列表 - 所以如果我们要在新列表中使用该元素，我们可以从-1到结尾进行切片：

>>> a_slice = a_list[-1:]
>>> a_slice
['three']

这种写法的好处是，如果列表为空也不会出错：

>>> empty_list = []
>>> tail = empty_list[-1:]
>>> if tail:
...     do_something(tail)

尝试按索引访问会引发IndexError，需要进行处理：

>>> empty_list[-1]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

但是，仅在需要以下情况时才应进行此目的的切片：

• 创建新列表
• 如果原始列表为空，则新列表必须为空。

for 循环

作为 Python 的一个特性，在 for 循环中没有内部作用域。

如果已经对列表执行了完整迭代，最后一个元素仍将由在循环中分配的变量名引用：

>>> def do_something(arg): pass
>>> for item in a_list:
...     do_something(item)
...     
>>> item
'three'

这不是列表中的语义上的最后一件事情。这是语义上绑定到名称item的最后一件事情。

>>> def do_something(arg): raise Exception
>>> for item in a_list:
...     do_something(item)
...
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
  File "<stdin>", line 1, in do_something
Exception
>>> item
'zero'

因此，这只应用于在循环中获取最后一个元素，并且您知道循环将完成（不会由于错误而中断或退出），否则它将指向循环引用的最后一个元素。

获取并删除它

我们还可以通过删除并返回最后一个元素来改变原始列表：

>>> a_list.pop(-1)
'three'
>>> a_list
['zero', 'one', 'two']

但现在这个原始列表已经被修改。

（实际上，-1是默认参数，所以list.pop可以不带索引参数使用）：

>>> a_list.pop()
'two'

只有在以下情况下才应该这样做：

• 您知道列表中有元素，或者已准备好处理如果列表为空时的异常，并且
• 您确实打算从列表中删除最后一个元素，将其视为堆栈。

这些是有效的用例，但并不常见。

稍后保存反转的其余部分：

我不知道为什么要这样做，但为了完整起见，由于 reversed 返回一个支持迭代器协议的迭代器，您可以将其结果传递给 next：

>>> next(reversed([1,2,3]))
3

那么这就像是做相反的事情：

>>> next(iter([1,2,3]))
1

但是我想不出有什么好的理由这样做，除非您以后需要使用其余的反向迭代器，那么代码可能会更像这样：

reverse_iterator = reversed([1,2,3])
last_element = next(reverse_iterator)

use_later = list(reverse_iterator)

现在：

>>> use_later
[2, 1]
>>> last_element
3

- Russia Must Remove Putin

---

这个答案因其高解决方案与字词比率而获得了我见过的最长答案奖励！ - CausingUnderflowsEverywhere

一个小问题：在Python中，索引通常被认为是在字符串字符之间使用的。 - kd4ttc

Answer 6

为了避免IndexError: list index out of range错误，请使用以下语法：

mylist = [1, 2, 3, 4]

# With None as default value:
value = mylist and mylist[-1]

# With specified default value (option 1):
value = mylist and mylist[-1] or 'default'

# With specified default value (option 2):
value = mylist[-1] if mylist else 'default'

- Valentin Podkamennyi

---

今天我学到了一个新的知识点：False or 'default' 等于 'default'。我本来以为它会被计算成 False or bool('default') 等于 True。但是，自从什么时候 False or 和 True and 返回最右边的元素而不是将所有元素转换为布尔值呢？这是一个逻辑运算，却不能返回布尔值，有些不太直观。 - Guimoute

Answer 7

这里是您查询的解决方案。

a=["first","second","second from last","last"] # A sample list
print(a[0]) #prints the first item in the list because the index of the list always starts from 0.
print(a[1]) #prints second item in list 
print(a[-1]) #prints the last item in the list.
print(a[-2]) #prints the second last item in the list.

输出：

>>> first
>>> second
>>> last
>>> second from last

- Code Carbonate

Answer 8

lst[-1] 是最佳的方法，但对于一般可迭代对象，考虑使用 more_itertools.last:

代码

import more_itertools as mit


mit.last([0, 1, 2, 3])
# 3

mit.last(iter([1, 2, 3]))
# 3

mit.last([], "some default")
# 'some default'

- pylang

Answer 9

另一种方法：

some_list.reverse() 
some_list[0]

- Sanjay Pradeep

---

这是一种简单的方法，即使您可以选择在O(1)中执行相同的操作，但您也可以在O(n)上执行。 - surya

我不理解为什么这个“如何获取最后一个元素？”的答案得到了20个赞。list(reversed(reversed(reversed(reversed(some_list)))))[-1]也可以工作，但这并不足以成为一个有效的答案。 - Guimoute

Answer 10

list[-1]将检索列表的最后一个元素，而不更改列表。 list.pop()将检索列表的最后一个元素，但它将改变原始列表。通常不建议更改原始列表。

或者，如果出于某种原因，您正在寻找更少的Pythonic东西，则可以使用list [len（list）-1]，假设列表不是空的。

- Sondering Narcissist

---

假设改变原始列表通常不被推荐可能是错误的，因为毕竟这是非常常见的操作。 - Aaron