Aula 10: Lista - estrutura sequencial indexada

Tópicos

• listas: o tipo list, índices, referências, clones,
• as funções len() e método append();
• concatenação de listas usando +;
• repetição de listas usando *;
• testar a pertinência a uma lista (if item in lista:);
• comandos for:
• for i in range(início,fim,passo):;
• for item in lista:.

Listas

Até aqui, trabalhamos com variáveis simples, capazes de armazenar apenas um tipo, como bool, float e int.

Uma lista (tipo list) em Python é uma sequência de valores de qualquer tipo ou classe tais como int, float, bool, str e até mesmo o próprio list, entre outros.

Existem várias maneiras de criarmos uma lista. A maneira mais simples é envolver os elementos da lista por colchetes ([ e ]). Por exemplo, podemos criar uma lista contendo os anos de obtenção das cinco primeiras conquistas do Brasil em Copas do Mundo de Futebol da seguinte maneira:

Observe o uso de colchetes de abertura ([) para marcar o início e o colchetes de fechamento (]) para marcar o final da lista, e os elementos separados por vígula.

Ao contrário do conceito de vetores em linguagem C, que são coleções indexadas homogêneas de dados (todos elementos do vetor são de um mesmo tipo), as listas em Python podem conter vários tipos de dados, sendo, portanto, possível armazenar coleções heterogêneas de dados. Exemplo:

Na lista filme acima, o primeiro elemento representa o nome do filme "De Volta Para O Futuro" do tipo str, o segundo elemento representa o ano 1985 de estréia do filme do tipo int, o terceiro elemento representa o diretor do filme "Robert Zemeckis" do tipo str e o quarto elemento ["ficção científica", "aventura"] representa a lista de gêneros do filme do tipo list.

Índices

O acesso a elementos da lista pode ser feito através da sintaxe: nome_da_lista[índice].

Veja os exemplos abaixo digitados no Python Shell:

Índices negativos indicam elementos em ordem inversa, ou seja, da direita para a esquerda ao invés de da esquerda para a direita, sendo o último elemento indicado pelo índice -1. Veja os exemplos abaixo digitados no Python Shell:

Um erro comum em programas é a utilização de índices inválidos, o que gera a mensagem de erro: list index out of range. Veja os exemplos abaixo digitados no Python Shell:

Comprimento de uma lista

Modificando elementos de uma lista

Adicionando elementos a uma lista (método append)

Referências VS clones

Cada objeto em Python, incluindo listas, possui um identificador exclusivo (número inteiro único) que pode ser acessado usando a função id() do Python. Observe que no exemplo acima, as listas A e B possuem o mesmo identificador, confirmando que elas correspondem à mesma lista na memória.
O teste id(A) == id(B) pode ser igualmente obtido através do comando A is B.

Em algumas situações, no entanto, precisamos, de fato, criar uma réplica/clone na memória de uma lista existente.
Para isso podemos usar o comando B = list(A). Note que nesse caso alterações posteriores em uma das listas não afetam a sua cópia.

Concatenação de listas usando +

Note que a concatenação não possui propriedade comutativa, pois a ordem dos elementos na lista de saída depende da ordem dos operandos.

Se as duas listas A e B possuem elementos em comum, após a concatenação, estes serão repetidos na lista produzida (veja o caso dos elementos 3, 5 e 7 no exemplo abaixo).

Método append VS concatenação de listas

Apesar deles produzirem o mesmo resultado, nesse caso é preferível utilizar o método append(), pois a concatenação gera uma cópia da lista toda e a variável sabores passa a referenciar essa nova lista criada, sendo, portanto, uma operação mais custosa.

Repetição de listas usando *

Laços para percorrer os elementos de uma lista

Note, no entanto, que podemos usar um variável inteira para indicar o índice, de modo que podemos usar a seguinte construção para percorrer os elementos da lista anos_conquistas = [1958, 1962, 1970, 1994, 2002].

i = 0
while i < len(anos_conquistas):
    print(anos_conquistas[i])
    i += 1
  

Repetições com for

for ano in anos_conquistas:
    print(ano)
  

Em programas em que se faz necessário o uso de índices, ainda podemos usar o comando de repetição for. Por exemplo, com relação à lista anos_conquistas, se quisermos imprimir o texto abaixo:

for i in [0,1,2,3,4]:
    print("%do. título:"%(i+1),anos_conquistas[i])
#fim
  

Felizmente, o Python possui um comando que permite a construção de uma lista de inteiros de tamanho arbitrário, com elementos seguindo uma regra de formação de acordo com uma progressão aritmética. Teste no Python Shell os seguintes comandos:

Os comandos acima possuem uma dentre três possíveis formas:

1. list(range(fim))
2. list(range(início, fim))
3. list(range(início, fim, passo))

Com o uso do novo comando acima, podemos então reescrever o código anterior da seguinte forma:

for i in list(range(len(anos_conquistas))):
	print("%do. título:"%(i+1),anos_conquistas[i])
#fim
  

Para resolver esse problema podemos usar simplesmente:

for i in range(len(anos_conquistas)):
	print("%do. título:"%(i+1),anos_conquistas[i])
#fim
  

A série retornada pelo comando range(len(lista)) é um objeto iterável do tipo range e os elementos nela contidos serão gerados sob demanda durante o for, evitando o desperdício de memória.

Problema 1:

Dica: Criar uma lista vazia (seq = []) e usar append.

Solução 1:

Vamos fazer do modo tradicional, imprimindo dentro de um while.

n = int(input("Digite n: "))
seq = []
i = 0
while i < n:
    num = float(input("Digite o %do. num: "%(i+1)))
    seq.append(num)
    i += 1

i = n-1
while i >= 0:
    print(seq[i])
    i -= 1
  

Solução 2:

Solução alternativa usando índices negativos.

    n = int(input("Digite n: "))
    seq = []
    i = 0
    while i < n:
        num = float(input("Digite o %do. num: "%(i+1)))
        seq.append(num)
        i += 1

    i = -1
    while i >= -n:
        print(seq[i])
        i -= 1

Solução 3:

Solução alternativa usando o comando for.

n = int(input("Digite n: "))

seq = []
for i in range(n):
    num = float(input("Digite o %do. num: "%(i+1)))
    seq.append(num)

for i in range(n-1, -1, -1):
    print(seq[i])
  

Solução 4:

Outra solução alternativa usando o comando for com índices negativos.

n = int(input("Digite n: "))

seq = []
for i in range(n):
    num = float(input("Digite o %do. num: "%(i+1)))
    seq.append(num)

for i in range(-1, -n-1, -1):
    print(seq[i])
  

Solução 5:

No Python, é possível fazer: print(seq.reverse()).

n = int(input("Digite n: "))

seq = []
for i in range(n):
    num = float(input("Digite o %do. num: "%(i+1)))
    seq.append(num)

seq.reverse()
for x in seq:
    print(x)
  

Problema 2:

Dica: Criar uma lista com 37 zeros.

Solução 1:

Solução usando o comando while.

    n = int(input("Digite n: "))

    freq = []
    i = 0
    while i < 37:
        freq.append(0)
        i += 1

    i = 0
    while i < n:
        num = int(input("roleta: "))
        freq[num] += 1       
        i += 1

    i = 0
    while i < 37:
        print("freq.rel.(%d): %f"%(i,freq[i]/n))
        i += 1

Solução 2:

Solução mais compacta usando freq = [0]*37 para a criação da lista com 37 zeros.

    n = int(input("Digite n: "))

    freq = [0]*37
    i = 0
    while i < n:
        num = int(input("roleta: "))
        freq[num] += 1       
        i += 1

    i = 0
    while i < 37:
        print("freq.rel.(%d): %f"%(i,freq[i]/n))
        i += 1
  

Solução 3:

Solução alternativa usando o comando for.

n = int(input("Digite n: "))

freq = [0]*37

for i in range(n):
    num = int(input("roleta: "))
    freq[num] += 1

i = 0
for x in freq:
    print("freq.rel.(%d): %f"%(i,x/n))
    i += 1    
  

Solução 4:

Solução alternativa que simula a roleta usando o gerador de números pseudo-aleatórios do módulo random do Python, ao invés de solicitar a entrada manual dos n lançamentos.

import random
n = int(input("Digite n: "))

freq = [0]*37

for i in range(n):
    num = random.randrange(0, 37)
    freq[num] += 1

i = 0
for x in freq:
    print("freq.rel.(%d): %f"%(i,x/n))
    i += 1    
  

Problema 3:

Solução 1:

Solução usando while.

n = int(input("Digite n: "))

seq = []
for i in range(n):
    num = float(input("Digite o %do. num: "%(i+1)))
    rep = False
    j = 0
    while j < len(seq) and rep == False:
        if seq[j] == num:
            rep = True
        j += 1
    if rep == False: # if not rep:
        seq.append(num)

print(seq)
  

Solução 2:

Solução usando for.

n = int(input("Digite n: "))

seq = []
for i in range(n):
    num = float(input("Digite o %do. num: "%(i+1)))
    rep = False
    for x in seq:
        if x == num:
            rep = True
    if rep == False: # if not rep:
        seq.append(num)

print(seq)
  

Solução 3:

Solução compacta, aproveitando o fato de que o Python permite testar diretamente se um elemento não faz parte de uma lista,
através do comando if num not in seq:

n = int(input("Digite n: "))

seq = []
for i in range(n):
    num = float(input("Digite o %do. num: "%(i+1)))
    if num not in seq:
        seq.append(num)

print(seq)
  

Problema 4:

Sugestão: Imagine uma situação real, por exemplo, dois fichários de uma biblioteca.

Solução 1:

Cada sequência ordenada fornecida é lida em uma lista correspondente já eliminando possíveis elementos repetidos, usando a solução empregada no problema anterior. As duas listas resultantes seq1 e seq2 são então percorridas, usando as variáveis i e j como seus respectivos índices, copiando de modo intercalado para uma lista de saída seq3 sempre o menor valor entre seq1[i] e seq2[j].

n = int(input("Digite n: "))
seq1 = []
for i in range(n):
    num = int(input("Digite o %do. num: "%(i+1)))
    if num not in seq1:
        seq1.append(num)    

m = int(input("Digite m: "))
seq2 = []
for i in range(m):
    num = int(input("Digite o %do. num: "%(i+1)))
    if num not in seq2:
        seq2.append(num)    

seq3 = []
i,j = 0,0
while i < len(seq1) and j < len(seq2):
    if seq1[i] < seq2[j]:
        seq3.append(seq1[i])
        i += 1
    elif seq2[j] < seq1[i]:
        seq3.append(seq2[j])
        j += 1
    else:   # seq1[i] == seq2[j]
        seq3.append(seq1[i])
        i += 1
        j += 1

while i < len(seq1):
    seq3.append(seq1[i])
    i += 1

while j < len(seq2):
    seq3.append(seq2[j])
    j += 1

print(seq3)
  

Solução 2:

Solução similar à anterior, porém durante o processo de intercalação, os casos em que i ou j excedem o último índice válido de suas respectivas listas é tratado diretamente dentro do mesmo laço que trata os demais casos em que os dois índices são válidos.

n = int(input("Digite n: "))
seq1 = []
for i in range(n):
    num = int(input("Digite o %do. num: "%(i+1)))
    if num not in seq1:
        seq1.append(num)    

m = int(input("Digite m: "))
seq2 = []
for i in range(m):
    num = int(input("Digite o %do. num: "%(i+1)))
    if num not in seq2:
        seq2.append(num)    

seq3 = []
i,j = 0,0
while i < len(seq1) or j < len(seq2):
    if i == len(seq1):
        seq3.append(seq2[j])
        j += 1
    elif j == len(seq2):
        seq3.append(seq1[i])
        i += 1
    elif seq1[i] < seq2[j]:
        seq3.append(seq1[i])
        i += 1
    elif seq2[j] < seq1[i]:
        seq3.append(seq2[j])
        j += 1
    else:   # seq1[i] == seq2[j]
        seq3.append(seq1[i])
        i += 1
        j += 1

print(seq3)
  

Solução 3:

Idêntica à solução anterior, exceto que exploramos o fato de que as duas sequências fornecidas estão ordenadas, de modo que para eliminar seus elementos repetidos durante o laço de leitura, basta comparar com o último valor já lido na lista.

n = int(input("Digite n: "))
num = int(input("Digite o 1o. num: "))
seq1 = [num]
for i in range(1,n):
    num = int(input("Digite o %do. num: "%(i+1)))
    if num != seq1[len(seq1)-1]:  #compara com o último valor inserido em seq1.
        seq1.append(num)    
 
m = int(input("Digite m: "))
num = int(input("Digite o 1o. num: "))
seq2 = [num]
for i in range(1,m):
    num = int(input("Digite o %do. num: "%(i+1)))
    if num != seq2[len(seq2)-1]:  #compara com o último valor inserido em seq2.
        seq2.append(num)    
 
seq3 = []
i,j = 0,0
while i < len(seq1) or j < len(seq2):
    if i == len(seq1):
        seq3.append(seq2[j])
        j += 1
    elif j == len(seq2):
        seq3.append(seq1[i])
        i += 1
    elif seq1[i] < seq2[j]:
        seq3.append(seq1[i])
        i += 1
    elif seq2[j] < seq1[i]:
        seq3.append(seq2[j])
        j += 1
    else:   # seq1[i] == seq2[j]
        seq3.append(seq1[i])
        i += 1
        j += 1
        
print(seq3)