另一种方法：

some_list.reverse() 
some_list[0]

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

仅在以下情况下执行此操作

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

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

将后面的内容保存为以后：

我不知道为什么要这样做，但为了完整性，因为reverse返回迭代器（支持迭代器协议），所以可以将其结果传递给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

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

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

另一个简单的解决方案

方法1：

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

方法2：

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

方法3：

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

方法4：

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

方法5：

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

全部输出78

找不到任何提及此的答案。所以补充道。

您也可以尝试some_list[~0]。

那是波浪符号