Получение последнего элемента списка в 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'

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

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

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

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

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

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

*_, last = a_list

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

last = a_list[-1]

функции

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

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

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

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