receber Obtendo o último elemento de uma lista em Python




receber uma lista em python (12)

Em Python, como você obtém o último elemento de uma lista?


Se seus objetos str() ou list() podem acabar sendo vazios da seguinte forma: astr = '' ou alist = [] , então você pode querer usar alist[-1:] invés de alist[-1] para o objeto " mesmice ".

O significado disso é:

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

Onde a distinção sendo feita é que retornar um objeto de lista vazio ou um objeto str vazio é mais um "último elemento" do que um objeto de exceção.


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

A maneira mais simples de exibir o último elemento em python é

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

Existem muitos outros métodos para atingir esse objetivo, mas estes são curtos e fáceis de usar.


lst[-1] é a melhor abordagem, mas com more_itertools.last gerais, considere more_itertools.last :

Código

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'

Ok, mas o que dizer de comum em quase todos os items[len(items) - 1] maneira de linguagem items[len(items) - 1] ? Esta é a maneira mais fácil de obter o último elemento, porque ele não requer nada de conhecimento pythonic .


Você também pode usar o código abaixo, se não quiser obter IndexError quando a lista estiver vazia.

next(reversed(some_list), None)

Você também pode fazer:

alist.pop()

Depende do que você quer fazer com sua lista, porque o método pop() excluirá o último elemento.


Em Python, como você obtém o último elemento de uma lista?

Para apenas pegar o último elemento,

  • sem modificar a lista, e
  • supondo que você saiba que a lista tem um último elemento (ou seja, não é vazio)

passe -1 para a notação subscrita:

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

Explicação

Índices e fatias podem ter inteiros negativos como argumentos.

Eu modifiquei um exemplo da documentação para indicar qual item em uma sequência cada índice referencia, neste caso, na string "Python" , -1 referencia o último elemento, o caractere, 'n' :

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

>>> p = 'Python'
>>> p[-1]
'n'

Atribuição via desempacotamento iterável

Este método pode materializar desnecessariamente uma segunda lista com a finalidade de apenas obter o último elemento, mas por uma questão de completude (e uma vez que suporta qualquer iterável - não apenas listas):

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

O nome da variável, head, está ligado à lista desnecessária recém-criada:

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

Se você pretende fazer nada com essa lista, isso seria mais apropriado:

*_, last = a_list

Ou, na verdade, se você sabe que é uma lista (ou pelo menos aceita notação de subscrito):

last = a_list[-1]

Em uma função

Um comentarista disse:

Eu queria que o Python tivesse uma função para first () e last () como o Lisp faz ... ele iria se livrar de muitas funções lambda desnecessárias.

Estes seriam bastante simples de definir:

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

def first(a_list):
    return a_list[0]

Ou use operator.itemgetter :

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

Em ambos os casos:

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

Casos especiais

Se você está fazendo algo mais complicado, você pode achar mais útil obter o último elemento de maneiras ligeiramente diferentes.

Se você é iniciante em programação, você deve evitar esta seção, porque ela une partes de algoritmos semanticamente diferentes. Se você alterar seu algoritmo em um só lugar, isso poderá ter um impacto indesejado em outra linha de código.

Eu tento fornecer advertências e condições tão completamente quanto posso, mas posso ter perdido alguma coisa. Por favor, comente se você acha que estou deixando uma ressalva.

Fatiamento

Uma fatia de uma lista retorna uma nova lista - assim, podemos dividir de -1 até o final se quisermos incluir o elemento em uma nova lista:

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

Isso tem a vantagem de não falhar se a lista estiver vazia:

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

Considerando que a tentativa de acesso por índice gera um IndexError que precisaria ser tratado:

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

Mas, novamente, fatiar para esse propósito só deve ser feito se você precisar de:

  • uma nova lista criada
  • e a nova lista ficará vazia se a lista anterior estiver vazia.

for laços

Como uma característica do Python, não há escopo interno em um loop for .

Se você já estiver executando uma iteração completa sobre a lista, o último elemento ainda será referenciado pelo nome da variável atribuído no loop:

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

Isso não é semanticamente a última coisa na lista. Esta é semanticamente a última coisa que o nome, item , estava vinculado.

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

Assim, isso só deve ser usado para obter o último elemento se você

  • já estão em loop e
  • você sabe que o loop vai terminar (não quebrar ou sair devido a erros), caso contrário, ele apontará para o último elemento referenciado pelo loop.

Obtendo e removendo

Também podemos alterar nossa lista original removendo e retornando o último elemento:

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

Mas agora a lista original é modificada.

( -1 é na verdade o argumento padrão, então list.pop pode ser usado sem um argumento de índice):

>>> a_list.pop()
'two'

Só faça isso se

  • você sabe que a lista tem elementos ou está preparada para lidar com a exceção se estiver vazia e
  • você pretende remover o último elemento da lista, tratando-o como uma pilha.

Estes são casos de uso válidos, mas não muito comuns.

Salvando o resto do reverso para mais tarde:

Eu não sei por que você faria isso, mas por completo, como reversed retorna um iterador (que suporta o protocolo iterador) você pode passar seu resultado para o next :

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

Então é como fazer o contrário disso:

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

Mas não consigo pensar em uma boa razão para fazer isso, a menos que você precise do resto do iterador reverso mais tarde, o que provavelmente seria mais ou menos assim:

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

use_later = list(reverse_iterator)

e agora:

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

some_list[-1] é o mais curto e mais pythonico.

Na verdade, você pode fazer muito mais com essa sintaxe. A sintaxe some_list[-n] obtém o elemento n-to-last. Então some_list[-1] obtém o último elemento, some_list[-2] obtém o penúltimo, etc, até a some_list[-len(some_list)] , que lhe dá o primeiro elemento.

Você também pode definir elementos da lista dessa maneira. Por exemplo:

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

Observe que a obtenção de um item de lista por índice gerará um IndexError se o item esperado não existir. Isso significa que some_list[-1] irá gerar uma exceção se some_list estiver vazio, porque uma lista vazia não pode ter um último elemento.


Data: 2017-12-06

alist.pop()

Eu faço uma cheatsheet exaustiva de todos os 11 métodos da lista para sua referência.

{'list_methods': {'Add': {'extend', 'append', 'insert'},
                  'Entire': {'clear', 'copy'},
                  'Search': {'count', 'index'},
                  'Sort': {'reverse', 'sort'},
                  'Subtract': {'remove', 'pop'}}}

some_list = [1, 2, 3]

Método 1:

some_list[-1]

Método 2:

**some_list.reverse()** 

**some_list[0]**

Método 3:

some_list.pop() 

list[-1] recuperará o último elemento da lista sem alterar a lista. list.pop() recuperará o último elemento da lista, mas alterará / alterará a lista original. Geralmente, a alteração da lista original não é recomendada.

Alternativamente, se, por alguma razão, você estiver procurando por algo menos pythonic, você poderia usar list[len(list)-1] , assumindo que a lista não está vazia.





indexing