Como visto anteriormente, ficamos sabendo que as tuplas são variáveis compostas que usamos para guardar vários dados. Por exemplo, colocamos uma tupla lanche dessa forma:
lanche = ("hambúrguer", "suco", "pizza", "pudim")
print(lanche[2]) # Exibirá a pizza
Mas se criarmos uma nova atribuição à qualquer posição da tupla, ele não aceitará, pelo fato da tupla ser imutável.
Nesse caso usamos as listas, que podem ser modificadas, dessa forma:
lanche = ["hambúrguer", "suco", "pizza", "pudim"]
lanche[3] = "picolé"
print(lanche)
Visualmente, a diferença é que a lista usa colchetes, enquanto a tupla usava parênteses. Na verdade, as listas são mais próximas aos arrays em outras linguagens.
PS: Nas listas também podemos colocar variáveis de diferentes tipos na mesma lista.
Só que para adicionar um novo item à lista, usamos métodos do objeto de lista, o append() para colocar itens no final, e o insert() para colocar numa posição especifica, por exemplo:
lanche = ["hambúrguer", "suco", "pizza", "pudim"]
lanche[3] = "picolé"
lanche.append("cookie") # Adiciona uma nova posição no final
lanche.insert(0, "cachorro-quente") # Adiciona o item na posição especificada
print(lanche)
E para excluir um elemento, podemos usar del, pop ou remove, dessas formas:
del lanche[3] # del() é usado para excluir objetos
lanche.pop(3) # pop() exclui o último elemento quando não tem parâmetro de índices
lanche.remove("pizza") # remove() exclui pelo nome do item
PS: O pop() é usado pra remover o último item da lista, mas pode receber como parâmetro a posição do índice. Sem parâmetros, ele remove o último item da lista.
Podemos usar um if para verificar se existe um item:
lanche = ["hambúrguer", "suco", "pizza", "pudim"]
lanche[3] = "picolé"
if "pizza" in lanche:
lanche.remove("pizza")
print(lanche)
Assim como as tuplas, podemos também fazer o fatiamento, onde ele mostra apenas parte dos elementos da lista, assim:
lanche = ["hambúrguer", "suco", "pizza", "pudim"]
print(lanche[0:2])
PS: No caso acima, ele não mostrará o elemento 2, e sim parará nesse elemento, no caso ele exibe os elementos 0 e 1 (hambúrguer e suco).
Temos também outros tipos de fatiamento assim:
lanche = ["hambúrguer", "suco", "pizza", "pudim"]
print(lanche[1:]) # Mostra do elemento 1 até o final
print(lanche[-1]) # Mostra o último elemento, se for -2 é o penúltimo e etc.
Podemos também usar o list() para criar listas, e usar um range() para preencher ela, veja um exemplo onde ele é usado:
valores = list(range(4, 11)) # Preenche a lista com valores de 4 até 10, não confunda com as posições
print(valores)
Podemos também ordenar os valores numéricos de um array com o método sort(), assim:
valores = [8, 2, 5, 4, 9, 3, 0]
valores.sort()
print(valores)
PS: Pra ordenar em ordem inversa, passe um parâmetro no sort(), assim:
valores.sort(reverse = True)
Podemos usar também o len() pra retornar a quantidade de índices da lista:
len(valores)
E normalmente, podemos utilizar outros elementos assim:
print(valores.count(5))
print(valores.index(2))
O método count, só lembrando, ele conta quantas vezes determinado elemento aparece numa variável composta. O index mostra a posição da primeira ocorrência do elemento.
Se tentarmos mudar uma tupla o valor de índice de uma tupla, ela dará erro, por exemplo:
num = (2, 5, 9, 1) # Tupla
num[2] = 3 # Dará Erro
print(num)
Mas uma lista podemos mudar normalmente, dessa forma:
num = [2, 5, 9, 1] # Lista
num[2] = 3
print(num)
Só que, diferente dos arrays em outras linguagens como o PHP e Javascript, não podemos adicionar valores dessa forma:
num = [2, 5, 9, 1]
num[2] = 3
num[4] = 7 # Dará Erro
print(num)
Nesse caso, usamos o append(), assim:
num = [2, 5, 9, 1]
num[2] = 3
num.append(7)
print(num)
E podemos ordenar tudo depois com o sort():
num = [2, 5, 9, 1]
num[2] = 3
num.append(7)
num.sort()
print(num)
Podemos também reverter o sort(), inserir um valor novo numa posição (no caso a 2) com o insert() e exibir os elementos dela com o len(), assim:
num = [2, 5, 9, 1]
num[2] = 3
num.append(7)
num.sort(reverse = True)
num.insert(2, 0) # Valor 0 na posição 2
print(num)
print(f"Essa lista tem {len(num)} valores.")
E eliminando valores também, com o pop():
num = [2, 5, 9, 1]
num[2] = 3
num.append(7)
num.sort(reverse = True)
num.insert(2, 0) # Valor 0 na posição 2
num.pop() # Remove o último
num.pop(2) # Remove o valor da posição 2
print(num)
print(f"Essa lista tem {len(num)} valores.")
Também podemos usar o remove() pra remover procurando pelo conteúdo:
num.remove(2)
PS: Ele só remove o primeiro elemento encontrado, caso tenha mais um 2 na lista, ele não eliminará os outros, apenas o primeiro. Mas podemos usar um laço para remover todos, por exemplo:
for i in range(0, len(num)):
if 2 in num:
num.remove(2)
Além disso, podemos usar as condições para ele verificar se existe um elemento, por exemplo:
num = [2, 5, 9, 1, 2, 2, 2]
num[2] = 3
num.append(7)
num.sort(reverse = True)
num.insert(2, 0) # Valor 0 na posição 2
if 4 in num:
num.remove(4)
else:
print("Não Achei o Número 4!")
print(num)
Basicamente, uma lista vazia pode ser criada dessas duas formas:
valores = []
valores = list()
Podemos mudar a exibição dos valores, assim:
valores = []
valores.append(5)
valores.append(9)
valores.append(4)
for v in valores:
print(f"{v}...", end="")
Ou usando o enumerate, que pega os valores das posições da lista:
valores = list()
valores.append(5)
valores.append(9)
valores.append(4)
for c, v in enumerate(valores):
print(f"Na posição {c} encontramos o valor {v}!")
Podemos ler valores do teclado também, assim:
valores = list()
for cont in range(0, 5):
valores.append(int(input("Digite um valor: ")))
print("\n")
for c, v in enumerate(valores):
print(f"Na posição {c} encontramos o valor {v}!")
Para excluir todos os itens de uma lista, use o método clear(), assim:
valores.clear()
Podemos atribuir o conteúdo de uma lista a outra, assim:
a = [2, 3, 4, 7]
b = a
b[2] = 8
print(f"Lista A: {a}")
print(f"Lista B: {b}")
Só que tem um detalhe, nesse método acima, ele faz uma ligação, e altera tanto o valor da mesma posição na lista a quanto da b.
Para simplesmente copiar uma lista sem ligação, coloque um [:] depois da variável da lista a ser copiada, por exemplo:
a = [2, 3, 4, 7]
b = a[:]
b[2] = 8
print(f"Lista A: {a}")
print(f"Lista B: {b}")
Uma maneira muito elegante de criar uma lista é usando a list comprehension. Também chamada de listcomp, é uma forma pythônica de criar uma lista com uso de um objeto iterável.
Esse tipo de técnica é utilizado quando, dada uma sequência, deseja-se criar uma nova sequência, porém com as informações originais transformadas ou filtradas por um critério.
Os comandos for-in são obrigatórios.
As variáveis item e lista dependem do nome dado no programa. Veja um exemplo de sintaxe utilizando a listcomp:
print([2 * x for x in range(10)])
Como sabemos, uma lista é mutável, e ela é declarada assim:
dados = list()
Sabemos também que usamos o append() para adicionar elementos, independente do tipo delas:
dados.append("Sérgio")
dados.append(25)
E também sabemos que um print com o índice do elemento da lista, assim:
print(dados[0])
print(dados[1])
Mas vamos aprender um novo método de copiar estruturas de listas, no caso, a estrutura toda, fazemos dessa forma:
pessoas = list()
pessoas.append(dados[:])
Nesse caso, quando colocamos apenas os dois pontos dentro dos colchetes, ele copia toda a lista e coloca dentro dessa lista (ou seja, uma lista dentro de outra).
PS: Lembre do método de fatiamento de elementos usando os dois pontos, como já fizemos em strings, por exemplo.
E da mesma forma, podemos colocar outros elementos em outros índices da lista pessoa.
Podemos fazer também dessa forma:
pessoas = [["Sérgio", 25], ["Maria", 19], ["João", 32]]
Pode ver que esse negócio de listas compostas é bem parecido com as matrizes de outras linguagens de programação.
Dessa forma, para exibir, usamos dois índices, o índice da lista "de fora" primeiro e a "de dentro" depois:
print(pessoas[0][0])
print(pessoas[1][1])
print(pessoas[2][0])
Se dermos apenas um índice para exibição, ele vai entender que o índice é a lista externa, e tudo que tiver dentro desse índice será exibido (no caso, a lista interna dentro dele):
print(pessoas[1])
Vamos considerar um programa onde declaramos uma lista simples, e adicionamos um nome e um número:
teste = list()
teste.append("Gustavo")
teste.append(40)
print(teste)
E criaremos uma outra lista, denominada galera, que recebera dentro dela a lista teste:
teste = list()
teste.append("Gustavo")
teste.append(40)
galera = list()
galera.append(teste)
print(galera)
Dessa forma, criamos uma lista composta.
Só que tem um detalhe, caso mudemos os elementos da lista teste (a interna) e depois damos outro append, ele mudará o elemento nas duas posições da lista galera, como podem ver:
teste = list()
teste.append("Gustavo")
teste.append(40)
galera = list()
galera.append(teste)
teste[0] = "Maria"
teste[1] = 22
galera.append(teste)
print(galera)
Isso nós já vimos anteriormente, porque as duas listas criam uma ligação através do append, por isso, é necessário colocar os colchetes com os dois pontos pra copiar a lista completamente.
teste = list()
teste.append("Gustavo")
teste.append(40)
galera = list()
galera.append(teste[:])
teste[0] = "Maria"
teste[1] = 22
galera.append(teste[:])
print(galera)
No caso acima sim, dá certo.
Essa é uma forma de declaração de listas compostas, e também as formas de exibir a mesma:
galera = [["João", 19], ["Ana", 33], ["Joaquim", 13], ["Maria", 45]]
print(galera) # Exibe a lista composta toda
print(galera[0]) # Exibe a lista dentro do índice 0 da galera.
print(galera[0][0]) # Exibe o primeiro item do índice 0 da galera.
Podemos usar laços for para exibir as listas:
galera = [["João", 19], ["Ana", 33], ["Joaquim", 13], ["Maria", 45]]
for p in galera:
print(p)
print("")
for p in galera:
print(p[0])
Incluindo for aninhado:
galera = [["João", 19], ["Ana", 33], ["Joaquim", 13], ["Maria", 45]]
for l in range(0, 4):
for c in range(0, 2):
if c < 2 - 1:
print(galera[l][c], end=" ")
else:
print(galera[l][c])
Podemos também fazer assim, onde galera tem dados da lista dado dentro:
galera = list()
dado = list()
for c in range(0, 5):
dado.append(str(input("Nome: ")))
dado.append(int(input("Idade: ")))
galera.append(dado[:])
dado.clear()
print(galera)
PS: Não esqueça do índice com dois pontos para copiar.
Veja o programa acima com mais recursos:
galera = list()
dado = list()
mai = men = 0 # Atribuição dupla, só permitida em variáveis simples.
for c in range(0, 5):
dado.append(str(input("Nome: ")))
dado.append(int(input("Idade: ")))
galera.append(dado[:])
dado.clear()
for p in galera:
if p[1] >= 18:
print(f"{p[0]} é maior de idade!")
mai += 1
else:
print(f"{p[0]} é menor de idade!")
men += 1
print(f"\nTemos {mai} maiores e {men} menores.")