Последний элемент с четным номером как найти

Вступление

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

Давайте посмотрим на список, который мы будем использовать:

 exampleList = [1, 2, "Three", ["Four", 5], 6] 

Примечание. Список в Python – это набор элементов, которые не
обязательно одного типа. Один список может содержать элементы, которые
являются числами, строками, вложенными списками и т. Д.

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

Есть несколько способов получить последний элемент списка в Python –
некоторые из них более интуитивно понятны и практичны, чем другие, а
некоторые из них фактически изменяют исходный список на месте:

• Использование отрицательной
  индексации – лучший
  подход
• Использование индексации
• Использование метода pop()
• Использование нарезки
• Использование обратного итератора
• Использование метода reverse()
• Использование itemgetter
• Использование петель

Лучшее решение – использование отрицательной индексации

Python поддерживает понятие отрицательной индексации как метод
доступа к элементам списка. Это означает, что мы можем получить доступ к
элементам в обратном порядке , используя оператор []

Как работает индексация в списках, хорошо известно:

 firstElement = exampleList[0] 
 nthElement = exampleList[n-1] 
 ... 

Первый элемент имеет индекс 0 , второй имеет индекс 1 , а n й
элемент имеет индекс n-1 .

Отрицательная индексация следует той же логике, но в обратном порядке.
Последний элемент имеет индекс -1 , предпоследний элемент имеет индекс
-2 и так далее:

 lastElement = exampleList[-1] 
 print("Last element: ", lastElement) 
 
 print("exampleList: ", exampleList) 
 
 secondToLast = exampleList[-2] 
 print("Second to last element: ", secondToLast) 

Какие выходы:

 Last element: 6 
 exampleList: [1, 2, 'Three', ['Four', 5], 6] 
 Second to last element: ['Four', 5] 

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

Это, безусловно, самое простое и наиболее подходящее для Python решение.

Использование индексации

Простая индексация обычно используется для доступа к элементам в списке
в исходном порядке с помощью оператора [] Как описано выше, первый
элемент имеет индекс 0 , второй элемент имеет индекс 1 и так далее.
Зная это, мы можем сделать вывод, что последний элемент имеет индекс
len(exampleList)-1 :

 lastElement = exampleList[len(exampleList)-1] 
 print("Last element: ", lastElement) 
 
 print("exampleList: ", exampleList) 
 
 secondToLast = exampleList[len(exampleList)-2] 
 print("Second to last element: ", secondToLast) 

Какие выходы:

 Last element: 6 
 exampleList: [1, 2, 'Three', ['Four', 5], 6] 
 Second to last element: ['Four', 5] 

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

Использование метода pop ()

В Python метод pop() используется для удаления последнего элемента
данного списка и возврата удаленного элемента.

Метод pop() может дополнительно принимать целочисленный аргумент.
Это индекс элемента, который мы хотим удалить, поэтому, если мы
вызовем exampleList.pop(0) , первый элемент будет удален и
возвращен.

Если аргумент – отрицательное число, будет выполнена логика
отрицательной индексации, чтобы определить, какой элемент удалить.
Вызов exampleList.pop(-1) приведет к удалению последнего элемента
examleList .

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

 lastElement = exampleList.pop() 
 print("Last element: ", lastElement) 
 
 print("exampleList: ", exampleList) 

Какие выходы:

 Last element: 6 
 exampleList: [1, 2, 'Three', ['Four', 5]] 

Обратите внимание, что метод pop() по определению изменяет исходный
список , удаляя всплывающий элемент.

Использование нарезки

В Python нотация срезов используется для получения подсписка списка.
Сама запись довольно проста:

 exampleList[startIndex:[endIndex[:indexStep]]] 

Это означает, что мы можем получить 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 .
Результирующий подсписок будет содержать только последний элемент
исходного списка:

 lastElement = exampleList[-1:][0] 
 # exampleList[-1:] alone will return the sublist - [6] 
 # exampleList[-1:][0] will return the last element - 6 
 print("Last element: ", lastElement) 
 
 print("exampleList: ", exampleList) 

Какие выходы:

 Last element: 6 
 exampleList: [1, 2, 'Three', ['Four', 5], 6] 

Метод нарезки используется только для доступа к элементам списка и для
создания нового списка с их помощью – без внесения каких-либо изменений
в исходный список.

Использование обратного итератора

Python имеет две встроенные функции, которые мы будем использовать в
этом методе – reversed() и next() .

reversed() принимает список в качестве аргумента и возвращает обратный
итератор для этого списка, что означает, что итерация отменяется,
начиная с последнего элемента до первого элемента. next() принимает
итератор и возвращает следующий элемент из итератора:

 reversedIterator = reversed(exampleList) 
 
 lastElement = next(reversedIterator) 
 print("Last element: ", lastElement) 

Какие выходы:

 Last element: 6 
 exampleList: [1, 2, 'Three', ['Four', 5], 6] 

Обратный метод итератора используется только для доступа к элементам
списка в обратном порядке – без внесения каких-либо изменений в исходный
список.

Использование метода reverse ()

Метод reverse() используется для переворота элементов списка . Он
не принимает никаких аргументов и не возвращает никакого значения,
вместо этого он меняет исходный список на место . Это означает, что мы
можем перевернуть список и получить доступ к новому первому элементу:

 # Update the original list by reversing its' elements 
 exampleList.reverse() 
 
 # Access the first element of the updated list 
 lastElement = exampleList[0] 
 print("Last element: ", lastElement) 
 
 print("exampleList: ", exampleList) 

Какие выходы:

 Last element: 6 
 exampleList: [6, ['Four', 5], 'Three', 2, 1] 

Метод reverse() по определению изменяет исходный список, меняя порядок
его элементов. Имейте в виду, что такой подход может оказаться
действительно неэффективным излишеством, так как для переворота списка
требуется время.

Использование itemgetter ()

Модуль operator предоставляет множество эффективных методов,
выполняющих все основные операции в Python, такие как математические и
логические операции, а также другие операции сравнения объектов и
последовательности.

Метод itemgetter() – один из многих методов в модуле operator Он
принимает одно или несколько целых чисел в качестве аргумента и
возвращает вызываемый объект, который можно рассматривать как тип
специальной функции.

Когда мы вызываем operator.itemgetter(0) , результирующий объект будет
функцией, которая получит первый элемент в коллекции. Мы также можем
присвоить этому объекту имя:

 getFirstElement = operator.itemgetter(0) 

Теперь мы можем передать список в getFirstElement(l) , который
возвращает первый элемент из списка l .

Оператор itemgetter() поддерживает отрицательную индексацию,
поэтому получение последнего элемента сводится к следующему:

 import operator 
 
 getLastElement = operator.itemgetter(-1) 
 lastElement = getLastElement(exampleList) 
 print("Last element: ", lastElement) 
 
 print("exampleList: ", exampleList) 

Какие выходы:

 Last element: 6 
 exampleList: [1, 2, 'Three', ['Four', 5], 6] 

Этот подход не изменяет исходный список – он генерирует вызываемый
объект, который обращается к нему с помощью индексов.

Использование петель

Теперь гораздо более ручной и элементарный подход будет использовать
циклы. Мы можем перебирать список, используя длину списка в качестве
последнего шага. Затем, на len(l)-1 мы можем просто вернуть этот
элемент:

 for i in range(0, len(exampleList)): 
 if i == (len(exampleList)-1) : lastElement = exampleList[i] 
 
 print("Last element: ", lastElement) 
 print("exampleList: ", exampleList) 

Какие выходы:

 Last element: 6 
 exampleList: [1, 2, 'Three', ['Four', 5], 6] 

Это также не меняет список вообще, а просто получает доступ к элементу.

Заключение

Есть много способов получить последний элемент в списке в Python.
Основное беспокойство при выборе правильного для вас способа – погода
или нет, вы хотите, чтобы последний элемент был удален.

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

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