Получение последнего элемента списка в Python

если 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 является более "последним элементом"-как тогда объект исключения.

вы также можете сделать:

alist.pop()

это зависит от того, что вы хотите сделать со своим списком, потому что pop() метод удалит последний элемент.

самый простой способ отображения последнего элемента в python -

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

есть много других методов для достижения такой цели, но они короткие и сладкие в использовании.

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

назначение через итерационную распаковку

этот метод может излишне материализовать второй список для целей просто получения последнего элемента ,но для полноты (и поскольку это поддерживает любые iterable - не только списки):

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

имя переменной, head привязано к ненужному вновь созданному списку:

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

если вы не собираетесь ничего делать с этим списком, это было бы более уместно:

*_, last = a_list

или, действительно, если вы знаете, что это список (или, по крайней мере, можно подстрочное обозначение):

last = a_list[-1]

функции

комментатор сказал:

я хотел бы, чтобы у Python была функция для первый () и последний (), как и Lisp... это избавило бы от множества ненужных лямбда-функций.

это было бы довольно просто определить:

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

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

Если вы хотите просто get последнее значение списка, вы должны использовать:

your_list[-1]

но если вы хотите get значением, а также удалить его из списка, вы можете использовать :

your_list.pop()

или: вы можете поп с индексом тоже...

your_list.pop(-1)

хорошо, но как насчет общего почти на всех языкахitems[len(items) - 1]? Это ИМО самый простой способ получить последний элемент, потому что он ничего не требует весть знаний.

some_list = [1, 2, 3]

Способ 1:

some_list[-1]

Способ 2:

**some_list.reverse()** 

**some_list[0]**

Способ 3:

some_list.pop() 

дата: 2017-12-06

alist.pop()

Я делаю исчерпывающий cheatsheet всех методов списка 11 для вашей справки.

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

list[-1] будет извлекать последний элемент списка без изменения списка. list.pop() будет извлекать последний элемент списка, но он будет мутировать/изменять исходный список. Обычно мутировать исходный список не рекомендуется.

кроме того, если по какой-то причине, вы ищете что-то менее подходящие для Python, вы могли бы использовать list[len(list)-1], предполагая, что список не пуст.

вы также можете использовать приведенный ниже код, если вы не хотите получать IndexError, когда список пуст.

next(reversed(some_list), None)

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'

список Python поддерживает отрицательные индексы.

a = [1, 2, 3]

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

или

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