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

Ответ 1

some_list[-1] - самый короткий и самый Pythonic.

На самом деле, вы можете сделать гораздо больше с этим синтаксисом. some_list[-n] получает элемент nth-to-last. Таким образом, some_list[-1] получает последний элемент, some_list[-2] получает второй до последнего и т.д. some_list[-len(some_list)] до 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[-1] вызовет исключение, если some_list пуст, потому что пустой список не может иметь последний элемент.

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

Ответ 3

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

alist.pop()

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

Ответ 4

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

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

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

Ответ 5

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

Чтобы просто получить последний элемент,

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

передать -1 в -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 была функция для first() и last(), как это делает 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 можно использовать без аргумента index):

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

Ответ 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

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

your_list[-1]

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

your_list.pop()

ИЛИ: вы можете открыть индекс тоже...

your_list.pop(-1)

Ответ 8

Другой метод:

some_list.reverse() 
some_list[0]

Ответ 9

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'

Ответ 10

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

В качестве альтернативы, если по какой-то причине вы ищете что-то меньшее, чем pythonic, вы можете использовать list[len(list)-1], считая, что список не пуст.

Ответ 11

Чтобы предотвратить 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'

Ответ 12

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

Ответ 13

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

next(reversed(some_list), None)

Ответ 14

popes = ['john paul II', 'benedict XIV', 'francis I']
current_pope = []
for pope in popes:
     current_pope = pope

после цикла for вы получите последний элемент в переменной current_pope.