Как получить последний элемент списка?

avatar
Janusz
30 мая 2009 в 19:28
2648721
18
2448

Как в Python получить последний элемент списка?

Источник

Ответы (18)

avatar
Sasha Chedygov
30 мая 2009 в 19:29
3603

some_list[-1] - самый короткий и самый питонический.

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

Обратите внимание, что получение элемента списка по индексу вызовет IndexError, если ожидаемый элемент не существует. Это означает, что some_list[-1] вызовет исключение, если some_list пуст, поскольку в пустом списке не может быть последнего элемента.

Dmitry P.
20 января 2020 в 15:41
47

Мне не хватает чего-то вроде some_list.last - это была бы красивая строчка кода

avatar
Underoos
23 июня 2021 в 17:18
0

Не удалось найти ответ, в котором упоминалось бы об этом. Итак, добавляем.

Вы также можете попробовать some_list[~0].

Это символ тильды

avatar
Gunjan
4 июня 2021 в 04:15
1

Доступ к последнему элементу из списка в Python:

1: получить доступ к последнему элементу с отрицательной индексацией -1

>> data = ['s','t','a','c','k','o','v','e','r','f','l','o','w']
>> data[-1]
'w'

2. Доступ к последнему элементу с помощью метода pop ()

>> data = ['s','t','a','c','k','o','v','e','r','f','l','o','w']
>> data.pop()
'w'

Однако метод pop удалит последний элемент из списка.

Wondercricket
8 июня 2021 в 16:15
1

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

avatar
Muneeb Ahmad Khurram
9 мая 2021 в 19:03
3

Пифонический путь

Итак, давайте рассмотрим, что у нас есть список a = [1,2,3,4], в Python List можно манипулировать, чтобы предоставить нам его часть или его элемент, используя следующую команду, можно легко получить последний элемент.

print(a[-1])
avatar
AI Nerd
7 мая 2021 в 15:35
1

Вам просто нужно взять индекс и поставить [-1]. Например:

list=[0,1,2]
last_index=list[-1]
print(last_index)

На выходе вы получите 2.

avatar
HASAN HÜSEYİN YÜCEL
23 марта 2021 в 05:28
1

Чтобы избежать «IndexError: индекс списка вне допустимого диапазона», вы можете использовать этот фрагмент кода.

list_values = [12, 112, 443]

def getLastElement(lst):
    if len(lst) == 0:
        return 0
    else:
        return lst[-1]

print(getLastElement(list_values))
raulmd13
29 марта 2021 в 06:13
0

Проблема с этим решением заключается в том, что в случае len(lst) == 0 он вернет строку, когда вы ждете int.

HASAN HÜSEYİN YÜCEL
29 марта 2021 в 18:25
0

Зафиксированный..........

raulmd13
30 марта 2021 в 06:06
0

Я хотел сказать, что этот метод работает с заданным типом данных. Его нельзя использовать для всех типов списков. Но это неплохой ответ.

avatar
Hadi Mir
26 декабря 2020 в 17:51
0

Если вы сделаете my_list[-1], это вернет последний элемент списка. Индексы отрицательной последовательности представляют позиции от конца массива. Отрицательная индексация означает начало с конца, -1 относится к последнему элементу, -2 относится к второму последнему элементу и т. Д.

avatar
Code Carbonate
3 июля 2020 в 05:47
2

Вот решение вашего запроса.

a=["first","middle","last"] # A sample list
print(a[0]) #prints the first item in the list because the index of the list always starts from 0.
print(a[-1]) #prints the last item in the list.
print(a[-2]) #prints the last second item in the list.

Вывод:

>>> first
>>> last
>>> middle
avatar
Valentin Podkamennyi
13 апреля 2019 в 04:11
23

Чтобы предотвратить 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'
avatar
pylang
1 августа 2018 в 01:57
12

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'
avatar
Aaron Hall
23 июня 2017 в 22:05
73

Как получить последний элемент списка в 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
avatar
Yavuz Mester
2 июня 2017 в 13:23
8

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

next(reversed(some_list), None)
avatar
Sondering Narcissist
7 октября 2016 в 02:21
8

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

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

Aaron
1 декабря 2016 в 11:34
5

Вероятно, неправильно предполагать, что изменение исходного списка обычно не рекомендуется, потому что, в конце концов, это очень часто выполняется.

avatar
Sanjay Pradeep
10 января 2016 в 12:32
11

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

some_list.reverse() 
some_list[0]
say_my_name
8 июня 2021 в 04:20
0

Это простой метод, при котором вы можете проделать ту же операцию и на O(n), даже если у вас есть возможность сделать это в O(1).

avatar
Radek Anuszewski
7 октября 2015 в 17:22
4

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

Dan Gayle
10 октября 2015 в 00:25
4

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

Michael Wu
27 октября 2015 в 03:35
25

так как вы пишете Python, вам действительно стоит попытаться быть более Pythonic

Radek Anuszewski
31 октября 2015 в 14:13
6

@MichaelWu Нет смысла это делать. Метод Pythonic часто не требует пояснений, требует большего внимания, когда вам нужно вводить новых людей в проект, и, конечно, не будет работать, когда вам нужно переключиться на другие языки, такие как Java - вы не можете использовать специальные знания Python. Когда вы опускаете питонический путь, насколько это возможно, тогда намного проще вернуться к проекту через несколько месяцев / лет.

Matthew Purdon
3 декабря 2015 в 15:30
7

@Pneumokok Вы подчеркиваете, но я бы сказал, что индексирование списков - это очень базовый метод Python по сравнению, скажем, с генераторами. Кроме того, зачем использовать что-либо, кроме C или, возможно, javascript, если вы не собираетесь использовать отдельные языковые инструменты и синтаксис? Тогда вы сможете постоянно делать все жестко во всех своих проектах.

Byron Filer
4 ноября 2016 в 21:08
0

Хотя это не очень питонично, я думаю, что в некоторых отношениях это лучше, чем подход some_list[-1], потому что он более логичен и показывает, что он на самом деле делает лучше, чем some_list[-1], на мой взгляд.

avatar
Atul Arvind
20 августа 2012 в 17:41
89

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

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

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

anon01
15 февраля 2018 в 18:42
3

если длина вашего списка равна нулю, это решение работает, а list[-1] приведет к ошибке.

avatar
DevPlayer
9 ноября 2010 в 23:26
291

Если ваши объекты 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 больше похож на "последний элемент", чем на объект исключения.

Stan Kurdziel
7 июня 2015 в 06:27
36

Проголосовали против, потому что я считаю, что суть этого ответа неверна. Получение списка, когда вам нужен элемент, только откладывает неизбежный «индекс списка вне допустимого диапазона» - и это то, что должно произойти при попытке получить элемент из пустого списка. Для строк astr [-1:] может быть подходящим подходом, поскольку он возвращает тот же тип, что и astr [-1], но я не думаю, что ':' помогает иметь дело с пустыми списками (и вопрос касается списков) . Если идея состоит в том, чтобы использовать «alist [-1:]» как условное выражение вместо «len (alist)> 0», я думаю, что гораздо удобнее использовать последнее. (рад проголосовать, если что-то пропустил)

DevPlayer
8 июня 2015 в 20:58
10

Ваш голос "против" понятен и действителен. Однако я обнаружил, что есть два основных лагеря в отношении того, для чего предназначены объекты исключений. Несомненно, исключения останавливают работу вашего приложения. Один лагерь использует исключения в предложениях try, поскольку другой лагерь будет использовать вместо этого структуру if len (alist)> 0 :. В любом случае исключения - это объекты, которые останавливают ваш код. И, как таковой, для меня меньше объектов последовательности, таких как возвращаемые "нулевые" -последовательности, которые не останавливают ваш код. Я предпочитаю использовать предложения IF для проверки «нулевых» объектов вместо объектов, которые останавливают мой код, который я вытесняю с помощью предложения try.

Mark Mullin
5 марта 2017 в 20:16
6

Проголосовали за, потому что синтаксис среза заслуживает обсуждения, однако я согласен с @StanKurdziel в том, что морфология неправильная, вы просто перемещаете стойку ворот - я обнаружил, что мое собственное решение было связано с основным использованием 'добавить это в список, если вы этого не сделали «еще не добавлен» (дельта-линейные графики), поэтому комбинированное выражение if len(my_vector) == 0 or my_vector[-1] != update_val является работоспособным шаблоном. но это, конечно, не глобальное решение - было бы неплохо иметь синтаксическую форму, в которой результатом было None

Gabriel
28 апреля 2018 в 02:35
24

xs[-1] if xs else None

Chris Johnson
1 августа 2018 в 02:18
4

Почему бы вам «избежать» IndexError? Если вы попытаетесь проиндексировать пустой список или строку, вы получите исключение. Если вы хотите обработать это исключение, используйте try / except - для этого он нужен.

avatar
Taurus Olson
30 мая 2009 в 22:21
121

Вы также можете:

last_elem = alist.pop()

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