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]

请注意，如果期望的项目不存在，按索引获取列表项将引发#0。这意味着如果some_list为空，some_list[-1]将引发异常，因为空列表不能有最后一个元素。

你也可以这样做：

last_elem = alist.pop()

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

如果你的str()或list()对象最终可能是空的：astr = ''或alist = []，那么你可能希望使用alist[-1:]而不是alist[-1]来表示对象的“同一性”。

其意义在于：

alist = []alist[-1]   # will generate an IndexError exception whereasalist[-1:]  # will return an empty listastr = ''astr[-1]    # will generate an IndexError exception whereasastr[-1:]   # will return an empty str

这里的区别是返回一个空列表对象或空str对象更像是“最后一个元素”——然后是一个异常对象。

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

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

有许多其他的方法来实现这样的目标，但这些都是简短而甜蜜的使用。

好的，但是几乎所有语言中的通用方法items[len(items) - 1]呢？这是IMO获取最后一个元素的最简单方法，因为它不需要任何pythonic知识。

另一种方法：

some_list.reverse()some_list[0]

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

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

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

next(reversed(some_list), None)

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

变量name， 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_somethingException>>> 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_element3

lst[-1]是最好的方法，但对于一般的可迭代对象，请考虑#1：

代码

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'

要防止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'

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

a=["first","second","second from last","last"] # A sample listprint(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 listprint(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

如果您执行my_list[-1]，则返回列表的最后一个元素。负序索引表示数组末尾的位置。负索引意味着从末尾开始，-1指的是最后一项，-2指的是倒数第二项，等等。

为了避免“IndexError： list index out of range”，您可以使用这段代码。

list_values = [12, 112, 443]
def getLastElement(lst):if len(lst) == 0:return 0else:return lst[-1]
print(getLastElement(list_values))

您只需要获取并放置[-1]索引。例如：

list=[0,1,2]last_index=list[-1]print(last_index)

您将获得2作为输出。

Pythonic Way

因此，让我们考虑我们有一个列表a = [1,2,3,4]，在Python List中可以操纵它以给我们一部分或它的一个元素，使用以下命令可以轻松获取最后一个元素。

print(a[-1])

在Python中访问列表中的最后一个元素：

1：用负索引访问最后一个元素-1

>> data = ['s','t','a','c','k','o','v','e','r','f','l','o','w']>> data[-1]'w'

2.使用pop（）方法访问最后一个元素

>> data = ['s','t','a','c','k','o','v','e','r','f','l','o','w']>> data.pop()'w'

但是，pop方法将从列表中删除最后一个元素。

找不到任何提到这个的答案。所以添加。

你也可以试试some_list[~0]。

那是0号符号

您可以将它与next和iter一起使用[::-1]：

>>> a = [1, 2, 3]>>> next(iter(a[::-1]))3>>>

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

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

打开行李。

你也可以使用长度来获取最后一个元素：

last_elem = arr[len(arr) - 1]

如果列表为空，你会得到一个IndexError异常，但你也会得到arr[-1]。

array=[1,2,3,4,5,6,7]last_element= array[len(array)-1]last_element

另一个简单的解决方案

如果您使用负数，它将开始为您提供列表最后一个元素示例

lst=[1,3,5,7,9]print(lst[-1])

结果

9

您可以使用~运算符从end获取第i个元素（从0索引）。

lst=[1,3,5,7,9]print(lst[~0])

方法一：

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