Как найти последний положительный элемент массива питон

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:

>>> a_list = ['zero', 'one', 'two', 'three']
>>> a_list[-1]
'three'

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

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
   0   1   2   3   4   5 
  -6  -5  -4  -3  -2  -1

>>> p = 'Python'
>>> p[-1]
'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):

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

The variable name, head is bound to the unnecessary newly created list:

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

If you intend to do nothing with that list, this would be more apropos:

*_, last = a_list

Or, really, if you know it’s a list (or at least accepts subscript notation):

last = a_list[-1]

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:

def last(a_list):
    return a_list[-1]

def first(a_list):
    return a_list[0]

Or use operator.itemgetter:

>>> import operator
>>> last = operator.itemgetter(-1)
>>> first = operator.itemgetter(0)

In either case:

>>> last(a_list)
'three'
>>> first(a_list)
'zero'

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:

>>> a_slice = a_list[-1:]
>>> a_slice
['three']

This has the upside of not failing if the list is empty:

>>> empty_list = []
>>> tail = empty_list[-1:]
>>> if tail:
...     do_something(tail)

Whereas attempting to access by index raises an IndexError which would need to be handled:

>>> empty_list[-1]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

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:

>>> def do_something(arg): pass
>>> for item in a_list:
...     do_something(item)
...     
>>> item
'three'

This is not semantically the last thing in the list. This is semantically the last thing that the name, item, was bound to.

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

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:

>>> a_list.pop(-1)
'three'
>>> a_list
['zero', 'one', 'two']

But now the original list is modified.

(-1 is actually the default argument, so list.pop can be used without an index argument):

>>> a_list.pop()
'two'

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:

>>> next(reversed([1,2,3]))
3

So it’s like doing the reverse of this:

>>> next(iter([1,2,3]))
1

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:

reverse_iterator = reversed([1,2,3])
last_element = next(reverse_iterator)

use_later = list(reverse_iterator)

and now:

>>> use_later
[2, 1]
>>> last_element
3

Getting the last element of the list is tricky while tracking each element, here we will discuss multiple methods to get the last element of the list. So we have given a list n, Our task is to get the last element of the list.

Example:

Input: [1, 2, 3, 4, 5, 5]
Output: 5

Input: ["Hello", "World"]
Output: World

Approaches to get the last element of list:

• Using Reverse Iterator
• Using negative indexing
• Using list.pop()
• Using reversed() + next() 
• Using slicing
• Using itemgetter

Using Reverse Iterator to get the last item of a list

To get the last element of the list using the naive method in Python. There can be 2-naive methods to get the last element of the list. 

• Iterating the whole list and getting, the second last element.
• Reversing the list and printing the first element.

Output :

The original list is : [1, 4, 5, 6, 3, 5]
The last element of list using loop : 5
The last element of list using reverse : 5

Using Negative Indexing to get the last element of list

To get last element of the list using the [] operator, the last element can be assessed easily if no. of elements in the list are already known. There is 2 indexing in Python that points to the last element in the list.

• list[ len – 1 ] : This statement returns the last index if the list.
• list[-1] : Negative indexing starts from the end.

Output :

The original list is : [1, 4, 5, 6, 3, 5]
The last element using [ len -1 ] is : 5
The last element using [ -1 ] is : 5

Get the last item of a list using list.pop()

To get the last element of the list using list.pop(), the list.pop() method is used to access the last element of the list. The drawback of this approach is that it also deletes the list’s last element, hence is only encouraged to use when the list is not to be reused. 

Output :

The original list is : [1, 4, 5, 6, 3, 5]
The last element using pop() is : 5

Get the last item of a list using reversed() + next() 

To get the last element of the list using reversed() + next(), the reversed() coupled with next() can easily be used to get the last element, as, like one of the naive methods, the reversed method returns the reversed ordering of list as an iterator, and next() method prints the next element, in this case, last element. 

Output :

The original list is : [1, 4, 5, 6, 3, 5]
The last element using reversed() + next() is : 5

Get the last item of a list by slicing

In this example, we will use list slicing to get the last element from the list.

Output:

The original list is : [1, 4, 5, 6, 3, 5]
The last element using slicing is :  5

Get the last item of a list using itemgetter

The itemgetter can be used instead of lambda functions.  In terms of performance over time, itemgetter is better than lambda functions. When accessing many values, it appears more concise than lambda functions. Here, we will use itemgetter to get out the last element in the list.

Output:

The original list is : [1, 4, 5, 6, 3, 5]
The last element using itemgetter is :  5

Using deque from the collections module:

Algorithm:

1. Convert the given list to a deque object.
2. Use the pop() method to remove and return the last element of the deque object.
3. Return the popped element as the result.

The original list is : [1, 4, 5, 6, 3, 5]
The last element using deque is : 5

Complexity Analysis: The above code returns the last element of the given list using the deque.pop() method from the collections module. The time complexity of this approach is O(1) since the pop() operation on deque takes constant time, and the space complexity is O(n) since the deque object is created to store the list elements.

Last Updated :
22 Apr, 2023

Like Article

Save Article

Как создать список?

Списки объявляются в квадратных скобках [ ].

z = [3, 7, 4, 2]  # Создание списка

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

# Создание списка с разными типам данных 
heterogenousElements = [3, True, 'Витя', 2.0] 

Этот список содержит int, bool, string и float.

Доступ к элементам списка

Каждый элемент имеет присвоенный ему индекс. Важно отметить, в python индекс первого элемента в списке — 0.

z = [3, 7, 4, 2]  # создаем список 
# обращение к первому элементу списка с индексом 0
print(z[0]) 
# элемент с индексом 0 -> 3

Также поддерживается отрицательная индексация. Отрицательная индексация начинается с конца. Иногда её удобнее использовать для получения последнего элемента в списке, потому что не нужно знать длину списка, чтобы получить доступ к последнему элементу.

# выведите последний элемент списка 
>>> print(z[-1])
2

Вы также можете получить доступ к одному и тому же элементу с использованием положительных индексов (как показано ниже). Альтернативный способ доступа к последнему элементу в списке z.

Срезы(slice) списка

Срезы хороши для получения подмножества значений с вашего списка. На примере кода, приведенного ниже, он вернет список с элементами из индекса 0 и не включая индекс 2.

# Создайте список
z = [3, 7, 4, 2]
# Вывод элементов с индексом от 0 до 2 (не включая 2)
print(z[0:2]) 
# вывод: [3, 7]

# Все, кроме индекса 3
>>> print(z[:3])
[3, 7, 4]

Код, указанный ниже возвращает список с элементами начиная с индекса 1 до конца.

# начиная с индекса 1 до конца списка
>>> print(z[1:])
[7, 4, 2]

Изменение элементов в списке

Списки в Python изменяемы. Это означает, что после создания списка можно обновить его отдельные элементы.

z = [3, 7, 4, 2]  # Создание списка
# Изменяем элемент с индексом 1 на строку 'fish'
z[1] = 'fish'
print(z)

[3, 'fish', 4, 2]

У списков Python есть разные методы, которые помогают в программировании. В этом разделе рассматриваются все методы списков.

Метод Index

Метод index возвращает положение первого индекса, со значением х. В указанном ниже коде, он возвращает назад 0.

# Создайте список
>>> z = [4, 1, 5, 4, 10, 4]
>>> print(z.index(4))
0

Вы также можете указать, откуда начинаете поиск.

>>> print(z.index(4, 3))
3

Метод Count

Метод count работает так, как звучит. Он считает количество раз, когда значение появляется в списке.

>>> random_list = [4, 1, 5, 4, 10, 4]
>>> print(random_list.count(4))
3

Метод Sort

Метод sort сортирует и меняет исходный список.

z = [3, 7, 4, 2]
z.sort()
print(z)

[2, 3, 4, 7]

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

# Сортировка и изменение исходного списка от наивысшего к наименьшему
z.sort(reverse = True)
print(z)

[7, 4, 3, 2]

Следует отметить, что вы также можете отсортировать список строк от А до Я (или A-Z) и наоборот.

# Сортировка списка строками
names = ["Стив", "Рейчел", "Майкл", "Адам", "Джессика", "Лестер"]
names.sort()
print(names)

['Адам', 'Джессика', 'Лестер', 'Майкл', 'Рейчел', 'Стив']

Метод Append

Метод append добавляет элемент в конец списка. Это происходит на месте.

z = [7, 4, 3, 2]
z.append(3)
print(z)

[7, 4, 3, 2, 3]

Метод Remove

z = [7, 4, 3, 2, 3]
z.remove(2)
print(z)

Код удаляет первое вхождение значения 2 из списка z.

[7, 4, 3, 3]

Метод Pop

Метод pop удаляет элемент в указанном индексе. Этот метод также вернет элемент, который был удален из списка. В случае, если вы не указали индекс, он по умолчанию удалит элемент по последнему индексу.

z = [7, 4, 3, 3]
print(z.pop(1))
print(z)

4
[7, 3, 3]

Метод Extend

Метод extend расширяет список, добавляя элементы. Преимущество над append в том, что вы можете добавлять списки.
Добавим [4, 5] в конец z:

z = [7, 3, 3]
z.extend([4,5])
print(z)

[7, 3, 3, 4, 5]

То же самое можно было бы сделать, используя +.

>>> print([1,2] + [3,4])
[7, 3, 3, 4, 5]

Метод Insert

Метод insert вставляет элемент перед указанным индексом.

z = [7, 3, 3, 4, 5]
z.insert(4, [1, 2])
print(z)

[7, 3, 3, 4, [1, 2], 5]

Простые операции над списками

Примеры использование функций со списками:

>>> list1 = [2, 3, 4, 1, 32]
>>> 2 in list1  # 2 в list1?
True
>>> 33 not in list1  # 33 не в list1?
True
>>> len(list1)  # количество элементов списка
5
>>> max(list1)  # самый большой элемент списка
32
>>> min(list1)  # наименьший элемент списка
1
>>> sum(list1)  # сумма чисел в списке
42
# генератор списков python (list comprehension)
>>> x =  [i for i in range(10)]
>>> print(x)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> print(list1.reverse()) # разворачивает список
[32, 1, 4, 3, 2]

Операторы + и * для списков

+ объединяет два списка.

list1 = [11, 33]
list2 = [1, 9]
list3 = list1 + list2
print(list3)

[11, 33, 1, 9]

* копирует элементы в списке.

list4 = [1, 2, 3, 4]
list5 = list4 * 3
print(list5)

[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]

Оператор in и not in

Оператор in проверяет находится ли элемент в списке. При успешном результате он возвращает True, в случае неудачи, возвращает False .

>>> list1 = [11, 22, 44, 16, 77, 98]
>>> 22 in list1
True

Аналогично not in возвращает противоположный от оператора in результат.

>>> 22 not in list1
False

Итерация по списку с использованием цикла for

Список — последовательность. Ниже способ, которые вы можете использовать для цикла, чтобы перебрать все элементы списка.

list1 = [1,2,3,4,5]
for i in list1:
    print(i, end=" ")

1 2 3 4 5

Преобразование списка в строку

Как преобразовать список в строку?
Для преобразования списка в строку используйте метод join(). В Python это выглядит так:
",".join(["a", "b", "c"]) -> "a,b,c".
Разделитель пишут в кавычках перед join, в список должен состоять из строк.

Вот несколько полезных советов для преобразования списка в строку (или любого другого итерабельного, такого как tuple).

Во-первых, если это список строк, вы можете просто использовать join() следующим образом.

mylist = ['spam', 'ham', 'eggs']
print(', '.join(mylist))

spam, ham, eggs

Используя тот же метод, вы можете также сделать следующее:

>>> print('n'.join(mylist))
spam
ham
eggs

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

list_of_ints = [80, 443, 8080, 8081]
print(str(list_of_ints).strip('[]'))

80, 443, 8080, 8081

Или же этот, если ваши объекты содержат квадратные скобки:

>>> print(str(list_of_ints)[1:-1])
80, 443, 8080, 8081

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

>>> print(', '.join(map(str, list_of_ints)))
80, 443, 8080, 8081
>>> print('n'.join(map(str, list_of_ints)))
80
443
8080
8081

Тест на знание списков в Python

a = [ 1, 342, 223, 'Африка', 'Очки']
print(a[-3])

sample = [10, 20, 30]
sample.append(60)
sample.insert(3, 40)
print(sample)

lake = ["Python", 51, False, "22"]
lake.reverse()
lake.reverse()
print(lake[-2])

a = ['foo', 'bar', 'baz', 'qux', 'quux']

x = [10, [3.141, 20, [30, 'baz', 2.718]], 'foo']