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

Question

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

首选哪种方式？

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

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

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

你也可以这样做：

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

解释

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

我修改了一个示例 from the documentation 以指示每个索引引用序列中的哪一项，在这种情况下，在字符串 "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

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'

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.reverse() 
some_list[0]

Answer 9

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

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

Answer 10

这是您查询的解决方案。

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 11

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

next(reversed(some_list), None)

Answer 12

好的，但是在几乎所有语言中都很常见 items[len(items) - 1] 呢？这是 IMO 获取最后一个元素的最简单方法，因为它不需要任何东西蟒蛇式的知识。

Answer 13

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

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

打开包装。

Answer 14

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

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

Answer 15

Pythonic 方式

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

print(a[-1])

Answer 16

在 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 方法将从列表中删除最后一个元素。

Answer 17

方法一：

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

Answer 18

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

list_values = [12, 112, 443]

def getLastElement(lst):
    if len(lst) == 0:
        return 0
    else:
        return lst[-1]

print(getLastElement(list_values))

Answer 19

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

last_elem = arr[len(arr) - 1]

如果列表为空，您将获得 IndexError 异常，但您也可以使用 arr[-1] 获得该异常。

Answer 20

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

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

结果

9

Answer 21

如果你这样做 my_list[-1] 这将返回列表的最后一个元素。负序列索引表示从数组末尾开始的位置。负索引表示从末尾开始，-1 表示最后一项，-2 表示倒数第二项，依此类推。

Answer 22

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

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

您将得到 2 作为输出。

Answer 23

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

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

Answer 24

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

另一个简单的解决方案

Answer 25

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

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

那是代字号象征