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

Question

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

Answer 1

some_list[-1] 是最短和最Pythonic.

实际上,您可以使用此语法执行更多操作.该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[-1]如果some_list为空则会引发异常,因为空列表不能包含最后一个元素.

Answer 2

如果您str()或list()对象可能最终为空:astr = ''或者alist = [],那么您可能希望使用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

区别在于返回空列表对象或空str对象更像是"最后一个元素",然后是异常对象.

Answer 3

你也可以这样做:

alist.pop()

这取决于您要对列表执行的操作,因为该pop()方法将删除最后一个元素.

Answer 4

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

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

有许多其他方法可以实现这样的目标,但这些方法简短易用.

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有一个函数用于first()和last(),就像Lisp一样......它将摆脱许多不必要的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

Answer 6

这是您查询的解决方案。

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

Answer 7

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'

Answer 8

some_list = [1,2,3]

方法1:

some_list.reverse() 
some_list[0]

方法2:

some_list.reverse() 
some_list[0]

方法3:

some_list.reverse() 
some_list[0]

Answer 9

为了防止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'

Answer 10

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

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

Answer 11

如果不想在列表为空时获取IndexError，也可以使用下面的代码。

next(reversed(some_list), None)

Answer 12

奇怪的是还没人发布这个：

>>> l = [1, 2, 3]
>>> *x, last_elem = l
>>> last_elem
3
>>> 

只需打开包装即可。

Answer 13

好的,但几乎每种语言都有共同点items[len(items) - 1]吗？这是IMO获取最后一个元素的最简单方法,因为它不需要任何pythonic知识.

Answer 14

方法一：

L = [8, 23, 45, 12, 78]
print(L[len(L)-1])

方法二：

L = [8, 23, 45, 12, 78]
print(L[-1])

方法三：

L = [8, 23, 45, 12, 78]
L.reverse() 
print(L[0])

方法四：

L = [8, 23, 45, 12, 78]
print(L[~0])

方法5：

L = [8, 23, 45, 12, 78]
print(L.pop())

全部输出78