Getting the last element of a list in Python

问题:

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

回答1:

some_list[-1] is the shortest and most Pythonic.

In fact, you can do much more with this syntax. The some_list[-n] syntax gets the nth-to-last element. So some_list[-1] gets the last element, some_list[-2] gets the second to last, etc, all the way down to some_list[-len(some_list)], which gives you the first element.

You can also set list elements in this way. For instance:

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

Note that getting a list item by index will raise an IndexError if the expected item doesn\'t exist. This means that some_list[-1] will raise an exception if some_list is empty, because an empty list can\'t have a last element.

回答2:

If your str() or list() objects might end up being empty as so: astr = \'\' or alist = [], then you might want to use alist[-1:] instead of alist[-1] for object \"sameness\".

The significance of this is:

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

Where the distinction being made is that returning an empty list object or empty str object is more \"last element\"-like then an exception object.

回答3:

You can also do:

alist.pop()

It depends on what you want to do with your list because the pop() method will delete the last element.

回答4:

The simplest way to display last element in python is

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

there are many other method to achieve such a goal but these are short and sweet to use.

回答5:

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

To just get the last element,

• without modifying the list, and
• assuming you know the list has a last element (i.e. it is nonempty)

pass -1 to the subscript notation:

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

Explanation

Indexes and slices can take negative integers as arguments.

I have modified an example from the documentation to indicate which item in a sequence each index references, in this case, in the string \"Python\", -1 references the last element, the character, \'n\':

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

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

Assignment via iterable unpacking

This method may unnecessarily materialize a second list for the purposes of just getting the last element, but for the sake of completeness (and since it supports any iterable - not just lists):

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

The variable name, head is bound to the unnecessary newly created list:

>>> head
[\'zero\', \'one\', \'two\']

If you intend to do nothing with that list, this would be more apropos:

*_, last = a_list

Or, really, if you know it\'s a list (or at least accepts subscript notation):

last = a_list[-1]

In a function

A commenter said:

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

These would be quite simple to define:

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

def first(a_list):
    return a_list[0]

Or use operator.itemgetter:

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

In either case:

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

Special cases

If you\'re doing something more complicated, you may find it more performant to get the last element in slightly different ways.

If you\'re new to programming, you should avoid this section, because it couples otherwise semantically different parts of algorithms together. If you change your algorithm in one place, it may have an unintended impact on another line of code.

I try to provide caveats and conditions as completely as I can, but I may have missed something. Please comment if you think I\'m leaving a caveat out.

Slicing

A slice of a list returns a new list - so we can slice from -1 to the end if we are going to want the element in a new list:

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

This has the upside of not failing if the list is empty:

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

Whereas attempting to access by index raises an IndexError which would need to be handled:

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

But again, slicing for this purpose should only be done if you need:

• a new list created
• and the new list to be empty if the prior list was empty.

for loops

As a feature of Python, there is no inner scoping in a for loop.

If you\'re performing a complete iteration over the list already, the last element will still be referenced by the variable name assigned in the loop:

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

This is not semantically the last thing in the list. This is semantically the last thing that the name, item, was bound to.

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

Thus this should only be used to get the last element if you

• are already looping, and
• you know the loop will finish (not break or exit due to errors), otherwise it will point to the last element referenced by the loop.

Getting and removing it

We can also mutate our original list by removing and returning the last element:

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

But now the original list is modified.

(-1 is actually the default argument, so list.pop can be used without an index argument):

>>> a_list.pop()
\'two\'

Only do this if

• you know the list has elements in it, or are prepared to handle the exception if it is empty, and
• you do intend to remove the last element from the list, treating it like a stack.

These are valid use-cases, but not very common.

Saving the rest of the reverse for later:

I don\'t know why you\'d do it, but for completeness, since reversed returns an iterator (which supports the iterator protocol) you can pass its result to next:

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

So it\'s like doing the reverse of this:

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

But I can\'t think of a good reason to do this, unless you\'ll need the rest of the reverse iterator later, which would probably look more like this:

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

use_later = list(reverse_iterator)

and now:

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

回答6:

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())

回答7:

if you want to just get the last value of list, you should use :

your_list[-1]

BUT if you want to get value and also remove it from list, you can use :

your_list.pop()

OR: you can pop with index too...

your_list.pop(-1)

回答8:

some_list = [1, 2, 3]

Method 1:

some_list[-1]

Method 2:

**some_list.reverse()** 

**some_list[0]**

Method 3:

some_list.pop() 

回答9:

Ok, but what about common in almost every language way items[len(items) - 1]? This is IMO the easiest way to get last element, because it does not require anything pythonic knowledge.

回答10:

Date: 2017-12-06

alist.pop()

I make an exhaustive cheatsheet of all list\'s 11 methods for your reference.

{\'list_methods\': {\'Add\': {\'extend\', \'append\', \'insert\'},
                  \'Entire\': {\'clear\', \'copy\'},
                  \'Search\': {\'count\', \'index\'},
                  \'Sort\': {\'reverse\', \'sort\'},
                  \'Subtract\': {\'remove\', \'pop\'}}}

回答11:

list[-1] will retrieve the last element of the list without changing the list. list.pop() will retrieve the last element of the list, but it will mutate/change the original list. Usually, mutating the original list is not recommended.

Alternatively, if, for some reason, you\'re looking for something less pythonic, you could use list[len(list)-1], assuming the list is not empty.

回答12:

lst[-1] is the best approach, but with general iterables, consider more_itertools.last:

Code

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

回答13:

Python list supports negative indexes.

a = [1, 2, 3]

a[-1] # gives the last elements with negative indexes

OR

a[len(a) - 1] # gives the last elements len function

回答14:

You can also use the code below, if you do not want to get IndexError when the list is empty.

next(reversed(some_list), None)