📥 Adição, Remoção, Filas e Pilhas

Seção 6.4–6.7 — Modificando listas e estruturas de dados clássicas

➕ 6.4 Adição de elementos

Uma das principais vantagens de trabalharmos com listas é poder adicionar novos elementos durante a execução. Para adicionar um elemento ao fim da lista, chamamos o método append:

Listagem 6.14 — Adição de elementos à lista>>> L = []
>>> L.append("a")
>>> L
['a']
>>> L.append("b")
>>> L
['a', 'b']
>>> L.append("c")
>>> L
['a', 'b', 'c']
>>> len(L)
3

Um programa simples capaz de ler um número indeterminado de valores e imprimi-los na mesma ordem:

Listagem 6.15 — Adição de elementos à listaL = []
while True:
    n = int(input("Digite um número (0 sai):"))
    if n == 0:
        break
    L.append(n)
x = 0
while x < len(L):
    print(L[x])
    x = x + 1

Outra forma de adicionar elementos é com a operação + entre listas. O método extend adiciona todos os elementos de uma lista a outra; já append com uma lista como parâmetro adiciona a lista inteira como um único elemento:

Listagem 6.16 — Adição de listas>>> L = []
>>> L = L + [1]
>>> L
[1]
>>> L += [2]
>>> L
[1, 2]
>>> L += [3, 4, 5]
>>> L
[1, 2, 3, 4, 5]

Listagem 6.17 — Adição de elementos e listas>>> L = ["a"]
>>> L.append("b")
>>> L.extend(["c"])
>>> L
['a', 'b', 'c']
>>> L.append(["d", "e"])
>>> L
['a', 'b', 'c', ['d', 'e']]
>>> L.extend(["f", "g", "h"])
>>> L
['a', 'b', 'c', ['d', 'e'], 'f', 'g', 'h']

Listagem 6.18 — Adição de elementos e listas com append>>> L = ["a"]
>>> L.append(["b"])
>>> L.append(["c", "d"])
>>> len(L)
3
>>> L[1]
['b']
>>> L[2]
['c', 'd']
>>> L[2][1]
'd'

Exercício 6.2

Faça um programa que leia duas listas e que gere uma terceira com os elementos das duas primeiras.

Exercício 6.3

Faça um programa que percorra duas listas e gere uma terceira sem elementos repetidos.

❌ 6.5 Remoção de elementos

Como o tamanho da lista pode variar, podemos também retirar alguns elementos ou mesmo todos eles. Para isso, utilizamos a instrução del. O elemento excluído não ocupa mais lugar na lista, fazendo com que os índices sejam reorganizados:

Listagem 6.19 — Remoção de elementos>>> L = ["a", "b", "c"]
>>> del L[1]
>>> L
['a', 'c']
>>> del L[0]
>>> L
['c']

Podemos apagar fatias inteiras de uma só vez:

Listagem 6.20 — Remoção de fatias>>> L = list(range(101))
>>> del L[1:99]
>>> L
[0, 99, 100]

🏦 6.6 Usando listas como filas

Uma lista pode ser utilizada como fila (FIFO — First In First Out): a inserção é sempre realizada no fim e as remoções são feitas no início. O método pop(0) retorna o valor do primeiro elemento e o exclui da lista:

Listagem 6.21 — Simulação de uma fila de bancoúltimo = 10
fila = list(range(1, último + 1))
while True:
    print("\nExistem %d clientes na fila" % len(fila))
    print("Fila atual:", fila)
    print("Digite F para adicionar um cliente ao fim da fila,")
    print("Ou A para realizar o atendimento. S para sair.")
    operação = input("Operação (F, A ou S):")
    if operação == "A":
        if len(fila) > 0:
            atendido = fila.pop(0)
            print("Cliente %d atendido" % atendido)
        else:
            print("Fila vazia! Ninguém para atender.")
    elif operação == "F":
        último += 1
        fila.append(último)
    elif operação == "S":
        break
    else:
        print("Operação inválida! Digite apenas F, A ou S!")

Exercício 6.4

O que acontece quando não verificamos se a lista está vazia antes de chamarmos o método pop?

Exercício 6.5

Altere o programa da Listagem 6.21 de forma a poder trabalhar com vários comandos digitados de uma só vez. Altere-o de forma a considerar operação como uma string. Exemplo: FFFAAAS significaria três chegadas de novos clientes, três atendimentos e, finalmente, a saída do programa.

Exercício 6.6

Modifique o programa para trabalhar com duas filas. Para facilitar seu trabalho, considere o comando A para atendimento da fila 1 e B para atendimento da fila 2. O mesmo para a chegada de clientes: F para fila 1 e G para fila 2.

🍵 6.7 Uso de listas como pilhas

Uma pilha tem uma política de acesso bem definida: novos elementos são adicionados ao topo e a retirada também é feita pelo topo (LIFO — Last In First Out). O método pop(-1) retira o último elemento:

Listagem 6.22 — Pilha de pratosprato = 5
pilha = list(range(1, prato + 1))
while True:
    print("\nExistem %d pratos na pilha" % len(pilha))
    print("Pilha atual:", pilha)
    print("Digite E para empilhar um novo prato,")
    print("ou D para desempilhar. S para sair.")
    operação = input("Operação (E, D ou S):")
    if operação == "D":
        if len(pilha) > 0:
            lavado = pilha.pop(-1)
            print("Prato %d lavado" % lavado)
        else:
            print("Pilha vazia! Nada para lavar.")
    elif operação == "E":
        prato += 1
        pilha.append(prato)
    elif operação == "S":
        break
    else:
        print("Operação inválida! Digite apenas E, D ou S!")

💡 Filas e pilhas são estruturas de dados fundamentais na ciência da computação. Filas (FIFO) são usadas em sistemas de impressão e atendimento. Pilhas (LIFO) são usadas em histórico de navegação e funções de desfazer.

Exercício 6.7

Faça um programa que leia uma expressão com parênteses. Usando pilhas, verifique se os parênteses foram abertos e fechados na ordem correta. Exemplos: (()) OK, ()()()() OK, ()) Erro.