Получить последний элемент списка Python
В этом посте мы обсудим, как получить последний элемент списка в Python.
В Python индексы также могут быть отрицательными числами, чтобы начать отсчет справа. Поскольку отрицательные индексы начинаются с -1 , a[-1] получить последний элемент списка a , a[-2] получить предпоследний элемент списка a , и так далее. Это действительно самое короткое и самое Pythonic решение.
Ниже приведен простой пример, демонстрирующий использование этого:
результат:
Last element of list is 5
Если список пуст или индекс находится за пределами списка, он вызовет IndexError . Чтобы быть в безопасности, всегда обрабатывайте ошибку изящно:
Rukovodstvo
статьи и идеи для разработчиков программного обеспечения и веб-разработчиков.
Python: получить последний элемент в списке
Введение В этом руководстве мы рассмотрим некоторые из наиболее распространенных способов найти последний элемент в списке в Python. Сначала мы рассмотрим самый простой и самый питонический способ, а затем покажем некоторые другие альтернативные решения. Давайте посмотрим на список, который мы будем использовать: exampleList = [1, 2, «Three», [«Four», 5], 6] Примечание. Список в Python — это набор элементов, которые не обязательно являются того же типа. Один список может содержать элементы, которые являются числами, строками, множеством элементов.
Время чтения: 7 мин.
Вступление
В этом руководстве мы рассмотрим некоторые из наиболее распространенных способов найти последний элемент в списке в Python. Сначала мы рассмотрим самый простой и наиболее питонический способ, а затем покажем некоторые другие альтернативные решения.
Давайте посмотрим на список, который мы будем использовать:
Примечание. Список в Python — это набор элементов, которые не обязательно одного типа. Один список может содержать элементы, которые являются числами, строками, вложенными списками и т. Д.
Как получить последний элемент в списке Python
Есть несколько способов получить последний элемент списка в Python — некоторые из них более интуитивно понятны и практичны, чем другие, а некоторые из них фактически изменяют исходный список на месте:
- Использование отрицательной индексации — лучший подход
Лучшее решение — использование отрицательной индексации
Python поддерживает понятие отрицательной индексации как метод доступа к элементам списка. Это означает, что мы можем получить доступ к элементам в обратном порядке , используя оператор []
Как работает индексация в списках, хорошо известно:
Первый элемент имеет индекс 0 , второй имеет индекс 1 , а n й элемент имеет индекс n-1 .
Отрицательная индексация следует той же логике, но в обратном порядке. Последний элемент имеет индекс -1 , предпоследний элемент имеет индекс -2 и так далее:
Отрицательная индексация не изменяет исходный список. Это всего лишь способ доступа к элементам без каких-либо изменений в исходном списке.
Это, безусловно, самое простое и наиболее подходящее для Python решение.
Использование индексации
Простая индексация обычно используется для доступа к элементам в списке в исходном порядке с помощью оператора [] Как описано выше, первый элемент имеет индекс 0 , второй элемент имеет индекс 1 и так далее. Зная это, мы можем сделать вывод, что последний элемент имеет индекс len(exampleList)-1 :
Помимо отрицательной индексации, метод индексации используется только для доступа к элементам списка без внесения каких-либо изменений в исходный список.
Использование метода pop ()
В Python метод pop() используется для удаления последнего элемента данного списка и возврата удаленного элемента.
Метод pop() может дополнительно принимать целочисленный аргумент. Это индекс элемента, который мы хотим удалить, поэтому, если мы вызовем exampleList.pop(0) , первый элемент будет удален и возвращен.
Если аргумент — отрицательное число, будет выполнена логика отрицательной индексации, чтобы определить, какой элемент удалить. Вызов exampleList.pop(-1) приведет к удалению последнего элемента examleList .
Хотя, поскольку метод pop() по умолчанию уже выталкивает последний элемент , нет никакой реальной необходимости использовать индексацию:
Обратите внимание, что метод pop() по определению изменяет исходный список , удаляя всплывающий элемент.
Использование нарезки
В Python нотация срезов используется для получения подсписка списка. Сама запись довольно проста:
Это означает, что мы можем получить exampleList с индексами, начиная с startIndex , вплоть до endIndex с шагом indexStep .
endIndex и indexStep — необязательные аргументы. Если мы оставим поле endIndex пустым, его значение по умолчанию будет концом исходного списка. Значение по умолчанию для indexStep — 1 .
Если у нас есть список l=[‘a’, ‘b’, ‘c’, ‘d’, ‘e’] и нарезать его, используя l[1:3] результирующий подсписок будет [‘b’, ‘c’, ‘d’] . Это означает, что мы выбираем элементы lits l с индексами 1, 2, and 3 .
l[0:4:2] вернет подсписок, содержащий только элементы с четными индексами — 0, 2, 4 .
Ключевой особенностью нотации срезов, которую мы будем использовать, является то, что она поддерживает отрицательную индексацию.
Это означает, что l[-1:] можно интерпретировать как: получить все элементы в списке l , от последнего элемента до конца списка l . Результирующий подсписок будет содержать только последний элемент исходного списка:
Метод нарезки используется только для доступа к элементам списка и для создания нового списка с их помощью — без внесения каких-либо изменений в исходный список.
Использование обратного итератора
Python имеет две встроенные функции, которые мы будем использовать в этом методе — reversed() и next() .
reversed() принимает список в качестве аргумента и возвращает обратный итератор для этого списка, что означает, что итерация отменяется, начиная с последнего элемента до первого элемента. next() принимает итератор и возвращает следующий элемент из итератора:
Обратный метод итератора используется только для доступа к элементам списка в обратном порядке — без внесения каких-либо изменений в исходный список.
Использование метода reverse ()
Метод reverse() используется для переворота элементов списка . Он не принимает никаких аргументов и не возвращает никакого значения, вместо этого он меняет исходный список на место . Это означает, что мы можем перевернуть список и получить доступ к новому первому элементу:
Метод reverse() по определению изменяет исходный список, меняя порядок его элементов. Имейте в виду, что такой подход может оказаться действительно неэффективным излишеством, так как для переворота списка требуется время.
Использование itemgetter ()
Модуль operator предоставляет множество эффективных методов, выполняющих все основные операции в Python, такие как математические и логические операции, а также другие операции сравнения объектов и последовательности.
Метод itemgetter() — один из многих методов в модуле operator Он принимает одно или несколько целых чисел в качестве аргумента и возвращает вызываемый объект, который можно рассматривать как тип специальной функции.
Когда мы вызываем operator.itemgetter(0) , результирующий объект будет функцией, которая получит первый элемент в коллекции. Мы также можем присвоить этому объекту имя:
Теперь мы можем передать список в getFirstElement(l) , который возвращает первый элемент из списка l .
Оператор itemgetter() поддерживает отрицательную индексацию, поэтому получение последнего элемента сводится к следующему:
Этот подход не изменяет исходный список — он генерирует вызываемый объект, который обращается к нему с помощью индексов.
Использование петель
Теперь гораздо более ручной и элементарный подход будет использовать циклы. Мы можем перебирать список, используя длину списка в качестве последнего шага. Затем, на len(l)-1 мы можем просто вернуть этот элемент:
Это также не меняет список вообще, а просто получает доступ к элементу.
Заключение
Есть много способов получить последний элемент в списке в Python. Основное беспокойство при выборе правильного для вас способа — погода или нет, вы хотите, чтобы последний элемент был удален.
Если вам нужно получить последний элемент без внесения каких-либо изменений в исходный список, то метод отрицательной индексации является явным победителем. Это самый простой и самый питонический способ решить эту проблему.
С другой стороны, если вам нужно удалить последний элемент, а также получить к нему доступ, вам, вероятно, следует использовать метод pop() , который является встроенным методом для выполнения именно этого поведения.
Как вывести последний элемент списка python
python — Получение последнего элемента списка в Python
В Python, как вы получаете последний элемент списка?
Чтобы просто получить последний элемент,
- без изменения списка и
- Предполагая, что вы знаете, что список имеет последний элемент (т.е. он не пуст)
передать -1 в индексную нотацию:
Индексы и срезы могут принимать отрицательные целые числа в качестве аргументов.
Я изменил пример из документации , чтобы указать, какой элемент в последовательности ссылается на каждый индекс, в этом случае в строке "Python" , -1 ссылается на последний элемент, символ, ‘n’ :
| P | y | t | h | o | n |
Я бы хотел, чтобы у Python была функция для first() и last(), как Lisp. она избавилась бы от множества ненужных лямбда-функций.
Это было бы довольно просто определить:
Или используйте operator.itemgetter :
Если вы делаете что-то более сложное, вы можете обнаружить, что он более эффективен, чтобы получить последний элемент несколькими разными способами.
Если вы новичок в программировании, вам следует избегать этого раздела, потому что он вместе соединяет семантически разные части алгоритмов. Если вы измените свой алгоритм в одном месте, это может иметь непреднамеренное воздействие на другую строку кода.
Я пытаюсь предоставить предостережения и условия как можно полнее, но я, возможно, что-то пропустил. Прошу прокомментировать, если вы думаете, что я оставляю предупреждение.
Слайд списка возвращает новый список, поэтому мы можем отрезать от -1 до конца, если мы хотим, чтобы этот элемент появился в новом списке:
Это имеет недостаток, если не пуст, если список пуст:
В то время как попытка доступа по индексу вызывает IndexError , который необходимо обработать:
Traceback (most recent call last):
IndexError: list index out of range
Но опять же, нарезка для этой цели должна выполняться только в случае необходимости:
- создан новый список
- и новый список будет пустым, если предыдущий список пуст.
Как функция Python, внутри цикла for нет внутреннего охвата.
Если вы выполняете полную итерацию по списку, последний элемент по-прежнему будет ссылаться на имя переменной, назначенное в цикле:
>>> def do_something(arg): pass
>>> for item in a_list:
Это не семантически последнее в списке. Это семантически последнее, что связано с именем item .
>>> def do_something(arg): raise Exception
>>> for item in a_list:
Traceback (most recent call last):
File "<stdin>", line 1, in do_something
Таким образом, это нужно использовать только для получения последнего элемента, если вы
- уже зацикливаются, а
- вы знаете, что цикл завершится (не прерывается или не выходит из-за ошибок), в противном случае он укажет на последний элемент, на который ссылается цикл.
Получение и удаление
Мы также можем изменить наш исходный список, удалив и вернув последний элемент:
Но теперь исходный список изменен.
( -1 фактически является аргументом по умолчанию, поэтому list.pop может использоваться без аргумента индекса):
Только это, если
- вы знаете, что в списке есть элементы в нем или готовы обрабатывать исключение, если оно пустое, и
- вы намерены удалить последний элемент из списка, рассматривая его как стек.
Это допустимые прецеденты, но не очень распространенные.
Сохранение остальной части реверса для последующего использования:
Я не знаю, почему вы это сделали, но для полноты, поскольку reversed возвращает iterator (который поддерживает протокол итератора), вы можете передать его результат в next :
Так как это делает обратное:
Но я не могу придумать вескую причину для этого, если позже вам не понадобится остальная часть обратного итератора, которая, вероятно, будет выглядеть примерно так:
How do I get the last element of a list?
In fact, you can do much more with this syntax. The some_list[-n] syntax gets the nth-to-last element. So some_list[-1] gets the last element, some_list[-2] gets the second to last, etc, all the way down to some_list[-len(some_list)] , which gives you the first element.
You can also set list elements in this way. For instance:
Note that getting a list item by index will raise an IndexError if the expected item doesn’t exist. This means that some_list[-1] will raise an exception if some_list is empty, because an empty list can’t have a last element.
If your str() or list() objects might end up being empty as so: astr = » or alist = [] , then you might want to use alist[-1:] instead of alist[-1] for object «sameness».
The significance of this is:
Where the distinction being made is that returning an empty list object or empty str object is more «last element»-like then an exception object.
You can also do:
It depends on what you want to do with your list because the pop() method will delete the last element.
The simplest way to display last element in python is
there are many other method to achieve such a goal but these are short and sweet to use.
In Python, how do you get the last element of a list?
To just get the last element,
- without modifying the list, and
- assuming you know the list has a last element (i.e. it is nonempty)
pass -1 to the subscript notation:
Explanation
Indexes and slices can take negative integers as arguments.
I have modified an example from the documentation to indicate which item in a sequence each index references, in this case, in the string «Python» , -1 references the last element, the character, ‘n’ :
Assignment via iterable unpacking
This method may unnecessarily materialize a second list for the purposes of just getting the last element, but for the sake of completeness (and since it supports any iterable — not just lists):
The variable name, head is bound to the unnecessary newly created list:
If you intend to do nothing with that list, this would be more apropos:
Or, really, if you know it’s a list (or at least accepts subscript notation):
In a function
A commenter said:
I wish Python had a function for first() and last() like Lisp does. it would get rid of a lot of unnecessary lambda functions.
These would be quite simple to define:
Or use operator.itemgetter :
Special cases
If you’re doing something more complicated, you may find it more performant to get the last element in slightly different ways.
If you’re new to programming, you should avoid this section, because it couples otherwise semantically different parts of algorithms together. If you change your algorithm in one place, it may have an unintended impact on another line of code.
I try to provide caveats and conditions as completely as I can, but I may have missed something. Please comment if you think I’m leaving a caveat out.
Slicing
A slice of a list returns a new list — so we can slice from -1 to the end if we are going to want the element in a new list:
This has the upside of not failing if the list is empty:
Whereas attempting to access by index raises an IndexError which would need to be handled:
But again, slicing for this purpose should only be done if you need:
- a new list created
- and the new list to be empty if the prior list was empty.
for loops
As a feature of Python, there is no inner scoping in a for loop.
If you’re performing a complete iteration over the list already, the last element will still be referenced by the variable name assigned in the loop:
This is not semantically the last thing in the list. This is semantically the last thing that the name, item , was bound to.
Thus this should only be used to get the last element if you
- are already looping, and
- you know the loop will finish (not break or exit due to errors), otherwise it will point to the last element referenced by the loop.
Getting and removing it
We can also mutate our original list by removing and returning the last element:
But now the original list is modified.
( -1 is actually the default argument, so list.pop can be used without an index argument):
Only do this if
- you know the list has elements in it, or are prepared to handle the exception if it is empty, and
- you do intend to remove the last element from the list, treating it like a stack.
These are valid use-cases, but not very common.
Saving the rest of the reverse for later:
I don’t know why you’d do it, but for completeness, since reversed returns an iterator (which supports the iterator protocol) you can pass its result to next :
So it’s like doing the reverse of this:
But I can’t think of a good reason to do this, unless you’ll need the rest of the reverse iterator later, which would probably look more like this: