[INF1025] Resumo Lista

Prévia do material em texto

INF1025: Introdução à Programação 
Monitor: André Vicente Pessanha 
Resumo Lista: 
 
*************************************************************************************************** 
 
OBS:​ Essa matéria cai na P2 e P3! 
 
*************************************************************************************************** 
 
- Definição: 
 
Lista é um conjunto formado por elementos de qualquer tipo. (Int, float, str, etc) 
Assim como int e float, também existe um tipo de variável lista chamado >> ​list​ <<! 
 
OBS:​ Bem semelhante ao conceito de Vetor usado em outras linguagens como C. A 
principal diferença é que Vetor só pode armazenar elementos de um >> único << tipo! 
 
 
- Como criar uma lista? 
 
pets = [] #Criando uma lista vazia. 
pets = [“Dog”, “Cat”, “Bird”] #Lista com 3 elementos do tipo String. 
nums = [1, 2, 3, 4, 5] # Criando uma Lista com >> 5 << elementos do tipo int. 
vals = [ 1, [2,3,4] , 5] # Criando uma Lista com >> 3 << elementos. 
 
Notou que o segundo elemento da lista vals também é uma lista? :) 
Por isso são só 3 elementos e não 5! Essa lista é formado por 3 elementos, sendo o 
segundo, um elemento do tipo ​list​! 
 
dados = ​[​ ​[​“Dog”, “Cat”, “Bird” ​]​, ​[​10.5, 25.7​ ]​ , ​[​1, 2, 3​]​ ​] 
 
Sim! Podemos colocar elementos de vários tipos e cada elemento da lista tb pode ser uma 
lista! :O 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
- Como alterar um elemento da lista? 
 
Temos a seguinte lista de pets e queremos trocar a string “Bird” por “Pombo” 
 
pets = [“Bird”, “Dog”, “Cat”] 
 
pets[0] = “Pombo” 
 
print(pets) # Exibe [“Pombo”, “Dog”, “Cat”] 
OBS: ​Lembrando que >> Não << podemos fazer isso com strings. Mas em Listas isso é 
possível, pois listas são >> ​Mutáveis​ <<! 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
- Funções úteis em Lista: 
 
1)​ A função ​len()​ retorna a quantidade de elementos que a lista possui. 
 
vals = [10, 20, 30] 
print( len (vals) ) #Quantidade de elementos: 3 
 
2)​ O método​ index ​retorna o índice de um elemento da lista. 
 
vals = [10, 20, 30] 
print( vals.index(20))​ #Elemento 20 está no índice 1 
 
3)​ O método ​max​ retorna o maior valor de uma lista: 
 
vals = [10, 20, 50, 30] 
print (​max (vals) ​) # Exibe o valor 50 
 
OBS​: A função >> ​min​ << é o mesmo esquema, só que retorna o >> ​menor​ << valor! 
 
4)​ O método ​append​ insere um elemento no >> ​Final​ << da lista. 
 
pets = [“Cat”, “Dog”] 
pets.append(“Pombo”] 
print(pets) # Exibe [“Cat”, “Dog”, “Pombo”] 
 
5) ​O método ​insert ​recebe como parâmetro o índice e o elemento que queremos inserir na 
lista. 
 
pets = [“Cat”, “Dog”] 
pets.insert(1, “Esquilo”] 
print(pets) # Exibe [“Cat”, “Esquilo”, “Dog”] 
 
OBS:​ Lembrando que o primeiro índice de uma lista é zero! 
 
6)​ O método ​count​ retorna a quantidade de ocorrências de um determinado elemento x na 
lista. 
 
pets = [“Pombo”, “Cat”, “Esquilo”, “Pombo”] 
 
print( ​pets.count(“Pombo”)​ ) # Encontrou 2 ocorrências da string “Pombo” :) 
 
 
7)​ O método ​reverse ​inverte os elementos da lista. 
 
vals = [1,2,3] 
vals.reverse() 
print(vals) # Exibe [3, 2, 1] 
 
8) ​O método ​sort ​ordena a lista. 
 
vals = [10, 50, 2, 30] 
vals.sort() 
print(vals) # Exibe [2, 10, 30, 50] 
 
OBS:​ Esses métodos >> ​Não​ << funcionam com sub listas e a ordenação só funciona com 
elementos do mesmo tipo! 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
-​ Operações em Lista​: 
 
1) Concatenação: 
 
l1 = [1,2,3,4] 
l2 = [-2, -1, 0, 1,2] 
 
l3 = l1 + l2 
print(l3) # Exibe [1, 2, 3, 4, -2, -1, 0, 1, 2] 
 
OBS:​ Observe que concatenação mantém elementos repetidos! E só funciona com listas! 
 
E se precisamos inserir um único elemento na lista usando concatenação? 
 
vals = [1,2,3,4] 
x = 20 
vals += [x] 
print(vals) 
 
OBS​: Nesse caso vamos precisar colocar a variável x obrigatoriamente entre colchetes! 
 
 
 
 
2) Replicar elementos da lista: (Atalho para Inicializar) 
 
Podemos usar o operador >> * << para criar uma lista com elementos duplicados. 
Uma das principais vantagens é criar uma lista inicializada com zero. 
 
Imagine um programa que contabiliza o total de votos pra cada um dos 5 candidatos de 
uma eleição. Como vamos precisar fazer um somatório à medida que vamos lendo os 
votos, então obrigatoriamente precisamos >> ​inicializar​ << a lista toda com zero! 
 
total = 5* [0] 
 
OBS: ​É o mesmo que escrever total = [0, 0, 0, 0, 0] só que mil vezes mais prático, pois 
imagine se fossem 300 candidatos. :D 
 
E além disso, também temos a opção de replicar uma lista: 
 
l1 = [1,2,3,4] 
l2 = 2*l1 
print(l2) # Exibe [1,2,3,4,1,2,3,4] 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
- Como criar uma lista com elementos ordenados? 
 
vals = list( range(2, 10) ) 
 
OBS: ​A função range sempre gera uma >> Sequência << de números, mas NÃO é do tipo 
lista! (Na verdade é do tipo Tupla, mas como esse tipo não será ensinado em prog 1, então 
“desleia” essa frase :D ) 
 
OBS:​ Útil pra gerar rapidamente uma lista pra testar o programa. O único problema é que 
só é capaz de gerar lista com sequência de valores ordenados! 
 
 
 
- Como gerar uma lista com elementos aleatórios? 
 
import random 
 
vals = ​random.sample (​range(10,101)​, 4) 
print(vals) 
 
OBS: ​Range gera uma sequência de números (De 10 até 100 no exemplo acima) e o 
segundo parâmetro é a quantidade de elementos que o método sample vai escolher! (A 
partir da sequência gerada pela range!) e >> ​SEM ​<<​ ​ordenação! 
 
OBS: ​Não precisamos converter para list! Pois os elementos escolhidos pela sample já 
formam uma lista! :) 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
 
Recursão em lista​: 
 
Não é recomendado usar recursão em lista devido ao alto custo de memória. (Dependendo 
do tamanho da lista) 
Então recursão em lista >> ​só ​<< será usada, se caso houver ​sub listas​ nos elementos da 
lista! Com isso, a recursão ficará encarregada de percorrer as sub listas. 
 
EX: Faça uma função recursiva que conta a quantidade de elementos de uma lista. 
Teste seu programa com a lista ​[1,2,3,4,5] ​e​ [1, [2,3,4], 5] 
 
def contElemRec(vals): 
if(not vals): 
 return 0 
return 1 + calcAlgRec(vals[1:]) 
 
l1 = [1,2,3,4,5] 
l2 = [1, [2,3,4], 5] 
 
print(calcAlgRec(l1)) # Exibe 5 
print(calcAlgRec(l2)) # Exibe 3 
 
 
EX: Faça uma função recursiva que retorna o somatório dos elementos da lista. 
 
def somaListRec(vals): 
 if(not vals): 
 return 0 
 elif(type(vals[0]) == list): 
 return somaListRec(vals[0])+ somaListRec(vals[1:]) 
 
 return vals[0] + somaListRec(vals[1:]) 
 
l1 = [1,2,3,4,5] 
l2 = [1,[2,3,4], 5] 
 
print(somaListRec(l1)) # Exibe 15 
print(somaListRec(l2)) # Exibe 15 
 
 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
 
- Busca em lista: 
 
Podemos verificar se um elemento pertence a lista usando a seguinte condição: 
 
vals = [10, 3, 5] 
x = 3 
 
if( x in vals )​: 
 
Como o elemento 3 está na lista, essa condição if é True! 
 
if (not x in lista): 
 
OBS:​ Verifica se o elemento 3 >> Não << está na lista. 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
- Buscas com sub listas: 
 
l1 = [ [ 2,3], [1,2]] 
x = 3if(x in l1): # Essa condição if é False 
 
OBS:​ A busca >> Não << funciona em sub listas, pois a comparação é sempre entre 
elementos da lista e não com sub listas! 
 
 
A forma correta é comparar sub lista com sub listas: 
 
vals = [ [ 2,3], [1,2]] 
x = [2, 3] 
if(x in vals): #Agora a condição if é True 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
- Separar/Dividir/Fatiar uma lista​: 
 
vals = [10, 20, 30, 40] 
print( vals[1:3] ) # Exibe [20, 30] 
print( vals[ : 2] ) # Do índice 0 até 1 
print(vals[1: ] ) # Do índice 1 até o fim da lista. 
 
OBS:​ Exatamente da mesma forma como é feito em string! Lembrando que o passo padrão 
(Default) é sempre 1. 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
Repetição em lista: (for avançado) 
 
Existem três formas de percorrer listas com a repetição for: 
 
1ª opção:​ for que armazena elementos da lista. 
 
vals = [10,20,30,40] 
 
for x in vals: 
 print(“Elemento:”, ​x​) 
 
OBS:​ x armazena cada um dos >> ​Elementos​ << da lista. Essa é a forma mais usada. 
 
2ª opção: ​for que armazena os índices da lista. 
 
vals = [10,20,30,40] 
 
for i in range​(len(vals)): 
print("Índice:",​ i​) 
print("Elemento", ​lista[ i ]​ ) 
 
OBS:​ Lembrando que quando usamos a função >> ​range​ << obrigatoriamente a variável >> 
i ​<< assume os valores dos >>​ í​ndices << da lista! E sim! É justamente por isso que 
recomendo chamar a variável de ​i ​quando usar a função range! :) 
 
3ª opção: ​for que armazena os ​índices ​E​ ​os ​elementos​ da lista. 
 
vals = [10,20,30,40] 
 
for i, x in enumerate​(vals): 
print("Indice:",​ i​) 
print("Elemento", ​x​ ) 
 
Repetição Indeterminada em Listas: 
 
- Criar uma lista com nomes digitados pelo usuário. A leitura será encerrada caso 
seja digitado “fim”. 
 
nomes =[] 
nome = input("Digite o nome:”) 
while (nome != "fim"): 
 nomes += [nome] 
 nome = input("Digite o nome:") 
 
 
OBS:​ Como se trata de uma repetição indeterminada, precisamos de uma condição de 
parada que é justamente quando o usuário digitar a string ​“fim”​. (Ou poderíamos ter 
inventado qualquer outro critério de parada, senão a repetição vai funcionar infinitamente!) 
Observe que no final do bloco do while precisamos pedir pro usuário digitar o próximo valor 
e assim a verificação da condição do while será feita novamente. 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
- Diferença entre Clonar e Copiar Lista: 
 
l1 = [67, 167, 267, 367, 467] 
 
l2 = l1 
 
OBS:​ Comando de atribuição usado dessa forma funciona para >> ​Clonar​ << Lista! Dessa 
forma estamos fazendo uma cópia da referência da lista l1! Com isso, qualquer alteração 
feita na lista l2 também altera a lista l1!!! Muito cuidado, pois em 95% dos casos, não é isso 
que queremos fazer! =x 
 
l1 = [67, 167, 267, 367, 467] 
l2 = l1[ : ] 
 
OBS:​ Dessa forma estamos fazendo uma >> ​Cópia​ << mas >> ​Somente​ << uma cópia do 
conteúdo da lista original! E ​não​ uma cópia da referência! Então nesse caso l1 e l2 são 
listas >> DIFERENTES << apesar de possuírem os mesmos elementos. E sendo assim, 
alterações feitas numa lista nunca afeta a outra! 
 
 
------------------------------------------------------- // ------------------------------------------------------------