Как найти последний элемент массива python

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

Getting the last element of the list is tricky while tracking each element, here we will discuss multiple methods to get the last element of the list. So we have given a list n, Our task is to get the last element of the list.

Example:

Input: [1, 2, 3, 4, 5, 5]
Output: 5

Input: ["Hello", "World"]
Output: World

Approaches to get the last element of list:

• Using Reverse Iterator
• Using negative indexing
• Using list.pop()
• Using reversed() + next() 
• Using slicing
• Using itemgetter

Using Reverse Iterator to get the last item of a list

To get the last element of the list using the naive method in Python. There can be 2-naive methods to get the last element of the list. 

• Iterating the whole list and getting, the second last element.
• Reversing the list and printing the first element.

Output :

The original list is : [1, 4, 5, 6, 3, 5]
The last element of list using loop : 5
The last element of list using reverse : 5

Using Negative Indexing to get the last element of list

To get last element of the list using the [] operator, the last element can be assessed easily if no. of elements in the list are already known. There is 2 indexing in Python that points to the last element in the list.

• list[ len – 1 ] : This statement returns the last index if the list.
• list[-1] : Negative indexing starts from the end.

Output :

The original list is : [1, 4, 5, 6, 3, 5]
The last element using [ len -1 ] is : 5
The last element using [ -1 ] is : 5

Get the last item of a list using list.pop()

To get the last element of the list using list.pop(), the list.pop() method is used to access the last element of the list. The drawback of this approach is that it also deletes the list’s last element, hence is only encouraged to use when the list is not to be reused. 

Output :

The original list is : [1, 4, 5, 6, 3, 5]
The last element using pop() is : 5

Get the last item of a list using reversed() + next() 

To get the last element of the list using reversed() + next(), the reversed() coupled with next() can easily be used to get the last element, as, like one of the naive methods, the reversed method returns the reversed ordering of list as an iterator, and next() method prints the next element, in this case, last element. 

Output :

The original list is : [1, 4, 5, 6, 3, 5]
The last element using reversed() + next() is : 5

Get the last item of a list by slicing

In this example, we will use list slicing to get the last element from the list.

Output:

The original list is : [1, 4, 5, 6, 3, 5]
The last element using slicing is :  5

Get the last item of a list using itemgetter

The itemgetter can be used instead of lambda functions.  In terms of performance over time, itemgetter is better than lambda functions. When accessing many values, it appears more concise than lambda functions. Here, we will use itemgetter to get out the last element in the list.

Output:

The original list is : [1, 4, 5, 6, 3, 5]
The last element using itemgetter is :  5

Using deque from the collections module:

Algorithm:

1. Convert the given list to a deque object.
2. Use the pop() method to remove and return the last element of the deque object.
3. Return the popped element as the result.

The original list is : [1, 4, 5, 6, 3, 5]
The last element using deque is : 5

Complexity Analysis: The above code returns the last element of the given list using the deque.pop() method from the collections module. The time complexity of this approach is O(1) since the pop() operation on deque takes constant time, and the space complexity is O(n) since the deque object is created to store the list elements.

Last Updated :
22 Apr, 2023

Like Article

Save Article

В этом посте мы обсудим, как получить последний элемент списка в Python.

В Python индексы также могут быть отрицательными числами, чтобы начать отсчет справа. Поскольку отрицательные индексы начинаются с -1, a[-1] получить последний элемент списка a, a[-2] получить предпоследний элемент списка a, и так далее. Это действительно самое короткое и самое Pythonic решение.

Ниже приведен простой пример, демонстрирующий использование этого:

Скачать  Выполнить код

результат:

Last element of list is 5

 
Если список пуст или индекс находится за пределами списка, он вызовет IndexError. Чтобы быть в безопасности, всегда обрабатывайте ошибку изящно:

Скачать  Выполнить код

результат:

Index outside the bounds of the list

Вот и все, что касается получения последнего элемента списка в Python.

Спасибо за чтение.

Пожалуйста, используйте наш онлайн-компилятор размещать код в комментариях, используя C, C++, Java, Python, JavaScript, C#, PHP и многие другие популярные языки программирования.

Как мы? Порекомендуйте нас своим друзьям и помогите нам расти. Удачного кодирования