用Python获取列表的最后一个元素

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

some_list[-1]是最短的，也是最python化的。

事实上，您可以使用这种语法做更多的事情。some_list[-n]语法获取第n到最后一个元素。some_list[-1]获取最后一个元素，some_list[-2]获取倒数第二个元素，以此类推，一直到some_list[-len(some_list)]，这就得到了第一个元素。

您还可以以这种方式设置list元素。例如:

1
2
3
4
5

>>> 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]将引发异常，因为空列表不能有最后一个元素。

如果您的str()或list()对象最终可能是空的:astr = ''或alist = []，那么您可能想要使用alist[-1:]而不是alist[-1]来表示对象的"相同"。

其意义在于:

1
2
3
4
5
6

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

区别在于，返回空列表对象或空str对象更像是"最后一个元素"，而不是异常对象。

相关讨论

你也可以这样做:

1	alist.pop()

这取决于您想对列表做什么，因为pop()方法将删除最后一个元素。

在python中显示最后一个元素的最简单方法是

1
2
3
4

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

有很多其他的方法可以达到这样的目标，但是这些方法都很短，而且使用起来很方便。

相关讨论

In Python, how do you get the last element of a list?

为了得到最后一个元素，

不修改列表，并且假设您知道列表中有最后一个元素(即它是非空的)

将-1传递给下标符号:

1
2
3

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

解释

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

我从文档中修改了一个例子来说明每个索引引用序列中的哪一项，在本例中，在字符串"Python"中，-1引用了最后一个元素，字符'n':

1
2
3
4
5
6
7
8
9

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

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

赋值通过迭代解包

这个方法可能不必要地实现第二个列表，只是为了得到最后一个元素，但为了完整性(因为它支持任何可迭代的——不仅仅是列表):

1
2
3

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

变量名head绑定到不必要的新创建列表:

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

如果你不打算对这张清单做任何事情，这将是更合适的:

1	*_, last = a_list

或者，如果你知道它是一个列表(或者至少接受下标符号):

1	last = a_list[-1]

在

函数

一位评论者说:

I wish Python had a function for first() and last() like Lisp does... it would get rid of a lot of unnecessary lambda functions.

这些定义将非常简单:

1
2
3
4
5

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

def first(a_list):
return a_list[0]

或者使用operator.itemgetter:

1
2
3

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

在这两种情况下:

1
2
3
4

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

特殊情况

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

如果您是新手，应该避免使用这一节，因为它将算法的不同部分在语义上结合在一起。如果在一个地方更改算法，可能会对另一行代码产生意想不到的影响。

我尽量提供完整的说明和条件，但我可能遗漏了一些东西。如果你认为我遗漏了一个警告，请评论。

切片

一个切片的列表返回一个新的列表-所以我们可以切片从-1到结束，如果我们想要的元素在一个新的列表:

1
2
3

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

这有一个好处，如果列表是空的，则不会失败:

1
2
3
4

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

然而，试图按索引访问会产生IndexError，需要处理:

1
2
3
4

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

但是，只有在需要的时候，才可以为这个目的进行切片:

创建一个新列表如果之前的列表为空，则新列表为空。

for循环

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

如果你已经对列表执行了完整的迭代，最后一个元素仍然会被循环中分配的变量名引用:

1
2
3
4
5
6

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

从语义上讲，这并不是列表中的最后一项。从语义上讲，这是名称item绑定到的最后一个对象。

1
2
3
4
5
6
7
8
9
10

>>> 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'

因此，如果您需要，这应该只用于获取最后一个元素

已经在循环了您知道循环将结束(不会因为错误而中断或退出)，否则它将指向循环引用的最后一个元素。获取并删除它

我们还可以通过删除和返回最后一个元素来修改原始列表:

1
2
3
4

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

但是现在原来的列表被修改了。

(-1实际上是默认参数，所以list.pop可以在没有索引参数的情况下使用):

1 2	>>> a_list.pop() 'two'

只有在

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

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

将后面的代码保存为:

我不知道你为什么这么做，但是为了完整性，因为reversed返回一个迭代器(它支持迭代器协议)，你可以把它的结果传递给next:

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

这就像反过来做:

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

但是我想不出这样做的好理由，除非您稍后需要使用反向迭代器的其余部分，它可能看起来更像这样:

1
2
3
4

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

use_later = list(reverse_iterator)

现在:

1
2
3
4

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

mylist = [ 1 , 2 , 3 , 4 , 5]

#------------------------------------
# Method-1 : Last index
#------------------------------------

print(mylist[-1])

#------------------------------------
# Method-2 : Using len
#------------------------------------

print(mylist[len(mylist) - 1])

#------------------------------------
# Method-3 : Using pop, pop will remove the last
# element from the list.
#------------------------------------

print(mylist.pop())

如果你想要得到list的最后一个值，你应该使用:

1	your_list[-1]

但如果你想获得值，并将其从列表中删除，你可以使用:

1	your_list.pop()

或者:你也可以用index弹出…

1	your_list.pop(-1)

some_list = [1, 2, 3]

方法1:

1	some_list[-1]

方法2:

1
2
3

**some_list.reverse()**

**some_list[0]**

方法3:

1	some_list.pop()

相关讨论

lst[-1]是最好的方法，但是对于一般迭代器，请考虑more_itertools.last:

代码

1
2
3
4
5
6
7
8
9
10
11

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'

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

或者，如果由于某种原因，您正在寻找一些不那么python化的东西，您可以使用list[len(list)-1]，假设列表不是空的。

相关讨论

好吧，但是在几乎所有的语言中通用的items[len(items) - 1]呢?在我看来，这是获得最后一个元素最简单的方法，因为它不需要任何python知识。

相关讨论

如果您不想在列表为空时获得ind火用ror，也可以使用下面的代码。

1	next(reversed(some_list), None)