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 >> l​ ist​ <<!

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 l​ ist​!

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

​ inal​ << 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
​ EM ​<<​ ​ordenação!
partir da sequência gerada pela range!) e >> S

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 s​ ub 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=3

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

​ lementos​ << da lista. Essa é a forma mais usada.

OBS:​ x armazena cada um dos >> E

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 >> r​ ange​ << 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 >> C ​ lonar​ << 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!

------------------------------------------------------- // ------------------------------------------------------------