Funções em Python: Como usar listas?
- #Python
1. Uso básico
Listas são as estruturas de dados mais básicas de Python. Elas são estruturas de dados que permitem armazenar uma coleção ordenada de valores de diferentes tipos.
Representamos uma lista colocando os valores separados por vírgulas entre [ e ].
[1, 2, 3, 4, 5]
Listas podem ser indexadas.
minhalista = [1, 2, 4, 8, 16, 32, 64]
minhalista[0], minhalista[3]
Com saída
(1, 8)
minhalista[2:5]
Com saída
[4, 8, 16]
Ao contrário de strings, as listas podem ser alteradas (elas são mutáveis). Uma forma de alterar é mudar um dos elementos da lista:
minhalista[0] = -1
minhalista
Com saída
[-1, 2, 4, 8, 16, 32, 64]
Outro forma de alterar é adicionar novos elementos no final usando o método append:
minhalista.append(128)
minhalista
Com saída
[-1, 2, 4, 8, 16, 32, 64, 128, 128]
Podemos também inserir em posições arbitrárias da lista, usando o método insert:
minhalista.insert(1, 0)
minhalista
Com saída
[-1, 0, 2, 4, 8, 16, 32, 64, 128, 128]
O uso de insert pode incorrer custo computacional maior do que o de append, então damos preferência a crescer a lista usando append, usando insert apenas quando necessário.
O método pop retorna o último objeto da lista e o retira da lista.
minhalista.pop()
Com saída
128
minhalista
Com saída
[-1, 0, 2, 4, 8, 16, 32, 64, 128]
Podemos retirar elementos em posições arbitrárias da lista usando o comando del:
del minhalista[1]
minhalista
Com saída
[-1, 2, 4, 8, 16, 32, 64, 128]
Novamente, a retirada em posições arbitrárias pode ter custo maior do que a retirada do final, então preferimos o uso de pop para diminuir a lista, quando possível.
A função len diz o número de objetos na lista.
len(minhalista)
Com saída
8
Como sempre, a indexação é verificada:
minhalista[8]
Com saída
IndexError: list index out of range
pois agora temos 8 elementos em que a contagem começa com 0 para o primeiro elemento até 7 o oitavo elemento da lista.
2. Semântica de referência
Como no caso de variáveis, as listas guardam apenas referências para objetos. Portanto, como variáveis, cada elemento da lista pode se referir a objetos de tipos distintos. Isto é, as listas podem ser mistas.
listamista = [1, 2.3, 2 + 3j, 'esquisito']
listamista
Com saída
[1, 2.3, (2+3j), 'esquisito']
Podemos inclusive colocar outras listas dentro de uma lista, formando uma estrutura aninhada.
listaesquisita = [3, 4, listamista, minhalista]
listaesquisita
Com saída
[3, 4, [1, 2.3, (2+3j), 'esquisito'], [-1, 2, 4, 8, 16, 32, 64, 128]]
listaesquisita[1]
Com saída
4
listaesquisita[2]
Com saída
[1, 2.3, (2+3j), 'esquisito']
listaesquisita[2][1]
Com saída
2.3
Lembre-se que nesses casos estamos guardando apenas referências para as listas aninhadas.
Se dentro da lista l3 guardamos uma referência para outra lista l2, então, ao alterarmos o conteúdo de l2 essa alteração será visível em l3.
l1 = [1, 2, 3]
l2 = [5, 4, 3]
l3 = [0, l1, l2]
l3
Com saída
[0, [1, 2, 3], [5, 4, 3]]
l2[1] = -1
l2
Com saída
[5, 4, 3]
l3
Com saída
[0, [1, 2, 3], [5, 4, 3]]
l1.append(4)
l3
Com saída
[0, [1, 2, 3, 4], [5, 4, 3]]
Em princípio, nada impede que façamos a inserção de uma referência para a lista dentro da própria lista. Nesse caso, tem-se que tomar cuidado ao manipular essa lista, para evitar problemas de código em loop infinito.
l4 = [1,2]
l4
Com saída
[1, 2]
l4.append(l4)
l4
Com saída
[1, 2, [...]]
O [...] que aparece acima é o interpretador Python evitando recursão infinita: ao perceber que a lista está dentro da própria lista, ele evita tentar imprimir o conteúdo novamente.
l4.append(3)
l4
Com saída
[1, 2, [...], 3]
par1 = [1, 2]
par2 = [3, 4]
par1.append(par2)
par2.append(par1)
par1
Com saída
[1, 2, [3, 4, [...]]]
par2
Com saída
[3, 4, [1, 2, [...]]]
Neste caso, temos uma recursão mútua entre as listas par1 e par2.
Lembre-se que se mais de uma variável referencia a mesma lista então ao alteramos a lista por meio de uma variável ela terá valor alterado quando acessada por outra variável.
x = [1,2,3]
y = x
x
Com saída
[1, 2, 3]
y
Com saída
[1, 2, 3]
x[2] = 4
x
Com saída
[1, 2, 4]
y
Com saída
[1, 2, 4]
Se quisermos evitar esse tipo de comportamento, precisamos fazer uma cópia da lista ao colocar em outra variável.
z = x.copy()
z
Com saída
[1, 2, 4]
Neste caso, é criado um novo objeto com um cópia dos valores do objeto referenciado por x, e uma referência para esse novo objeto é colocada em z, e portanto x e z estão referenciando objetos distintos.
x[2] = 3
x
Com saída
[1, 2, 3]
y
Com saída
[1, 2, 3]
z
Com saída
[1, 2, 4]
No caso de listas, uma outra forma de fazer cópia é simplesmente acessar um slice com todos os elementos.
z = x[:]
z
Com saída
[1, 2, 3]
O link com a documentação completa está disponível em: https://docs.python.org/pt-br/3/tutorial/datastructures.html
