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


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


1351


источник


Ответы:


some_list[-1]является самым коротким и наиболее Pythonic.

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

2156



Если ваш 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 является более «последним элементом», например, объектом исключения.


178



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

alist.pop()

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


66



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

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

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


52



В 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
['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может использоваться без аргумента индекса):

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

18



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

6



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


4



some_list = [1, 2, 3]

Method 1:

some_list[-1]

Method 2:

**some_list.reverse()** 

**some_list[0]**

Method 3:

some_list.pop() 

4



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)

4



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

3



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.


2



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)

0