Passo 1 de 7
Implementar o fluxo FIFO
Construa uma fila sequencial com deque, inserindo à direita e retirando à esquerda para preservar a ordem de chegada.
Trilha de aprendizado · Nível 14 · Tutorial 6
Escolha deque para cargas com inserções e remoções nas extremidades, evitando deslocamentos repetidos de elementos em listas.
Implementar o fluxo FIFO
Construa uma fila sequencial com deque, inserindo à direita e retirando à esquerda para preservar a ordem de chegada. 2 min
Operar nas duas extremidades
Use os quatro métodos principais da deque para controlar por qual lado cada item entra e sai. 1 min
Comparar o custo de retirar do início
Entenda como os deslocamentos acumulados em uma lista tornam o esvaziamento mais caro do que em uma deque. 2 min
Usar maxlen sem perder itens indevidamente
Use uma deque limitada para históricos descartáveis e diferencie esse caso de uma fila de trabalho que precisa preservar todos os itens. 2 min
Reconhecer quando a lista é mais adequada
Escolha lista ou deque observando quais operações dominam a carga de trabalho. 2 min
Medir uma carga completa de entrada e saída
Compare localmente uma fila implementada com lista e outra com deque, incluindo criação, entradas e retiradas FIFO em cada medição. 3 min
Aplicação final: processar pendências e manter um histórico
Aplique deque e lista em um fluxo completo: atenda pendências em ordem, retenha somente o histórico permitido e guarde resultados para consulta por posição. 3 min
Passo 1 de 7
Construa uma fila sequencial com deque, inserindo à direita e retirando à esquerda para preservar a ordem de chegada.
FIFO significa primeiro a entrar, primeiro a sair. Em uma fila, os novos itens entram por uma extremidade e o item mais antigo sai pela extremidade oposta.
Com deque, vamos inserir à direita com append e atender pela esquerda com popleft.
Cada operação acontece em uma ponta específica da estrutura.
O item à esquerda é o próximo a sair; novos itens entram à direita.
deque pertence ao módulo collections, da biblioteca padrão: não é preciso instalar nada. Você pode começar vazia ou preencher a fila com um iterável.
from collections import deque
fila_vazia = deque()
fila = deque(["pedido-1", "pedido-2"])
fila.append("pedido-3") # entra à direita
proximo = fila.popleft() # sai pela esquerda
print(proximo) # pedido-1
print(fila) # deque(['pedido-2', 'pedido-3'])Dica
Após os comandos, pedido-2 ficou à esquerda porque é o mais antigo entre os que ainda aguardam. Portanto, será o próximo retorno de popleft().
Em um cenário sequencial, use while fila para consumir a fila até ela ficar vazia. Uma deque vazia é avaliada como falsa, então o laço para antes de uma retirada inválida.
from collections import deque
fila = deque(["validar", "calcular", "enviar"])
while fila:
tarefa = fila.popleft()
print(f"Processando: {tarefa}")
print(fila) # deque([])Atenção
Chamar fila.popleft() quando não há itens gera IndexError. O teste while fila evita esse erro ao consumir todos os elementos.
Partindo de uma deque vazia, ocorrem estas operações: append("A"), append("B"), popleft(), append("C"), popleft(), popleft(). Ordene os valores retornados pelos três popleft() պատասխանados.
Passo 2 de 7
Use os quatro métodos principais da deque para controlar por qual lado cada item entra e sai.
Uma deque tem extremidade esquerda e direita. No fluxo FIFO que você já usou, o item entra à direita com append e sai à esquerda com popleft.
Mas você pode escolher qualquer ponta para inserir ou retirar. A ordem final depende da combinação escolhida: retirar pela ponta oposta à entrada preserva a chegada; retirar pela mesma ponta traz primeiro o item mais recente.
Os quatro métodos atuam diretamente nas pontas da deque.
Entrada e saída podem ocorrer tanto à esquerda quanto à direita.
Exemplo
from collections import deque
itens = deque(["B", "C"])
itens.append("D") # direita: deque(["B", "C", "D"])
itens.appendleft("A") # esquerda: deque(["A", "B", "C", "D"])
ultimo = itens.pop() # retira "D" da direita
primeiro = itens.popleft() # retira "A" da esquerda
print(ultimo, primeiro) # D A
print(itens) # deque(["B", "C"])Dica
left significa esquerda. Portanto, appendleft insere à esquerda e popleft remove à esquerda. Sem left, append e pop operam à direita.
Se os itens entram sempre pela direita:
popleft() retira pela esquerda, a ponta oposta: sai o item que chegou primeiro (FIFO).pop() retira pela direita, a mesma ponta: sai o item que chegou por último.O mesmo raciocínio vale ao inverter os lados: entrada e saída em pontas opostas preservam a ordem de chegada.
Exemplo
from collections import deque
fila = deque(["A", "B", "C"])
print(fila.popleft()) # A: chegou primeiro
mais_recente = deque(["A", "B", "C"])
print(mais_recente.pop()) # C: chegou por últimoRelacione cada método ao que ele faz.
Toque em um item e depois no par correspondente.
Uma deque recebe "A", depois "B" e depois "C", sempre com append. Qual chamada retira "A" primeiro?
Passo 3 de 7
Entenda como os deslocamentos acumulados em uma lista tornam o esvaziamento mais caro do que em uma deque.
Em uma lista, os elementos ocupam posições consecutivas. Ao executar fila.pop(0), o primeiro item sai e todas as referências restantes precisam avançar uma posição para preencher o espaço vazio.
Assim, uma única retirada no início custa O(n): quanto mais itens restarem, mais deslocamentos serão necessários.
Compare o que acontece com os itens que permanecem após retirar o primeiro elemento.
Na lista, B, C e D mudam de posição; na deque, os itens restantes não precisam ser deslocados.
Exemplo
fila_lista = ["A", "B", "C", "D"]
fila_lista.pop(0) # remove "A"
# Restam ["B", "C", "D"]Para chegar ao novo estado, as referências de "B", "C" e "D" foram deslocadas.
Uma deque foi feita para operar nas duas extremidades. Nas pontas, append, appendleft, pop e popleft têm custo aproximadamente constante: O(1).
Portanto, popleft() remove o item à esquerda sem deslocar todos os itens que ainda estão na fila.
Exemplo
from collections import deque
fila = deque(["A", "B", "C", "D"])
fila.popleft() # remove "A"
# Restam deque(["B", "C", "D"])A retirada continua obedecendo à ordem FIFO, mas o trabalho da operação não cresce com a quantidade de itens pendentes.
Ao esvaziar uma lista com pop(0), a primeira retirada desloca quase todos os itens; a próxima desloca um pouco menos; e assim por diante. A soma se parece com:
(n − 1) + (n − 2) + ... + 1
Mesmo diminuindo a cada retirada, o total cresce em O(n²). Já n chamadas de popleft() com trabalho O(1) por chamada totalizam O(n).
Esvaziar uma lista com pop(0) custa O(n²) porque os itens restantes são repetidamente ___.
A diferença entre O(n²) e O(n) se torna mais importante conforme a fila cresce ou a operação se repete muitas vezes. Em uma fila muito pequena, ambos os códigos podem parecer igualmente rápidos na prática.
Ainda assim, se a carga prevê entradas e retiradas frequentes no início, usar deque evita que o custo cresça pelos deslocamentos repetidos.
Para retirar todos os itens de uma fila com n elementos, list.pop(0) repetido tem custo total _, enquanto deque.popleft() repetido tem custo total _.
Passo 4 de 7
Use uma deque limitada para históricos descartáveis e diferencie esse caso de uma fila de trabalho que precisa preservar todos os itens.
Ao criar uma deque, maxlen define a quantidade máxima de elementos que ela mantém. Isso é útil para um histórico recente: você aceita perder eventos antigos para conservar apenas os últimos.
Com inserções pela direita usando append, o elemento da esquerda é o mais antigo. Quando a deque já está cheia, uma nova entrada descarta automaticamente esse elemento mais antigo.
Em um histórico de capacidade 3, a nova entrada ocupa a direita e o item mais antigo sai pela esquerda.
Com append em uma deque cheia, o descarte acontece na extremidade oposta à inserção.
Execute este exemplo e observe o conteúdo após cada inserção.
from collections import deque
historico = deque(maxlen=3)
for evento in ["login", "busca", "pagamento", "logout"]:
historico.append(evento)
print(list(historico))
# ['login']
# ['login', 'busca']
# ['login', 'busca', 'pagamento']
# ['busca', 'pagamento', 'logout']O descarte não examina datas nem o conteúdo dos elementos. Ele ocorre sempre na extremidade oposta à inserção:
append(...) em deque cheia: descarta à esquerda.appendleft(...) em deque cheia: descarta à direita.A inserção acontece normalmente: maxlen não faz a deque esperar por espaço nem rejeita o novo item.
Agora o item inserido entra à esquerda; por isso, o item da direita é removido.
from collections import deque
ultimos = deque(["B", "C", "D"], maxlen=3)
ultimos.appendleft("A")
print(list(ultimos))
# ['A', 'B', 'C']Atenção
Uma fila de trabalho representa itens que ainda precisam ser atendidos. Se nenhum item pode ser perdido, não defina maxlen: ao atingir o limite, uma nova inserção descarta uma pendência sem avisar. Use maxlen somente quando essa perda de itens antigos fizer parte explícita do contrato.
Qual será o conteúdo de list(historico) ao final deste código?
from collections import deque
historico = deque(maxlen=3)
for evento in ["A", "B", "C", "D"]:
historico.append(evento)Você vai processar pedidos na ordem de chegada e cada pedido precisa ser atendido, mesmo que a quantidade cresça. Qual escolha é adequada?
Passo 5 de 7
Escolha lista ou deque observando quais operações dominam a carga de trabalho.
A deque é uma escolha forte quando inserir e retirar nas extremidades domina a carga. Mas, se o programa consulta muitas posições variadas — como dados[37], dados[850] ou dados[-12] — a lista costuma ser mais adequada.
Em uma lista, o acesso por índice é O(1). Em uma deque, acessar as extremidades é aproximadamente O(1), mas chegar a uma posição no meio custa O(n), pois a estrutura precisa percorrer elementos até ela.
Compare o caminho necessário para cada tipo de operação.
Lista favorece índices e fatias; deque favorece entradas e saídas nas extremidades.
Exemplo
leituras = [18, 21, 19, 23, 20, 22]
print(leituras[3]) # 23
print(leituras[1:4]) # [21, 19, 23]Listas oferecem acesso O(1) por índice e suporte direto a fatias. Uma deque aceita indexação, mas não aceita fatias diretamente: fila[1:4] gera TypeError.
Para uma pilha, os itens entram e saem pelo final. Nesse padrão, uma lista é eficiente: append adiciona no final e pop() retira do final, sem deslocar os demais elementos.
pilha = []
pilha.append("primeiro")
pilha.append("último")
print(pilha.pop()) # últimoO problema da lista surge ao usar pop(0) repetidamente para montar uma fila FIFO, não ao usar pop() no final para implementar uma pilha.
Um painel mantém medições em ordem e, a cada atualização, consulta muitos índices espalhados e extrai trechos como medicoes[100:120]. Qual estrutura é mais adequada?
Relacione cada padrão predominante à estrutura mais indicada.
Toque em um item e depois no par correspondente.
Passo 6 de 7
Compare localmente uma fila implementada com lista e outra com deque, incluindo criação, entradas e retiradas FIFO em cada medição.
Uma medição útil compara implementações que fazem o mesmo trabalho. Neste experimento, cada função:
0 até n - 1;Assim, criação, entrada e saída pertencem ao tempo medido. Cada chamada cria seu próprio estado: uma execução não reaproveita itens da anterior.
As duas rotas recebem os mesmos itens e precisam devolver a mesma sequência FIFO.
Meça o ciclo completo — criar, inserir e retirar — em vez de cronometrar apenas uma operação isolada.
Dica
A igualdade das saídas é uma verificação de correção, não parte do benchmark. Se as funções não devolvem o mesmo resultado, comparar seus tempos não responde qual implementação faz a mesma tarefa mais rápido.
Crie um arquivo chamado comparar_filas.py, copie o código e execute no terminal com python comparar_filas.py. Ele usa somente a biblioteca padrão.
from collections import deque
from timeit import Timer
def fila_lista(n: int) -> list[int]:
fila: list[int] = []
for item in range(n):
fila.append(item)
retirados: list[int] = []
while fila:
retirados.append(fila.pop(0))
return retirados
def fila_deque(n: int) -> list[int]:
fila: deque[int] = deque()
for item in range(n):
fila.append(item)
retirados: list[int] = []
while fila:
retirados.append(fila.popleft())
return retirados
def tempo_por_execucao(funcao, n: int, repeticoes: int = 3) -> float:
temporizador = Timer(lambda: funcao(n))
total = temporizador.timeit(number=repeticoes)
return total / repeticoes
for tamanho in (1_000, 5_000, 10_000):
esperado = list(range(tamanho))
# Correção fora da região cronometrada.
assert fila_lista(tamanho) == esperado
assert fila_deque(tamanho) == esperado
lista_s = tempo_por_execucao(fila_lista, tamanho)
deque_s = tempo_por_execucao(fila_deque, tamanho)
print(
f"n={tamanho:>6}: "
f"lista={lista_s:.6f} s | "
f"deque={deque_s:.6f} s"
)Compare os tempos por execução conforme n aumenta. É comum que a fila com deque cresça de forma bem mais favorável, porque popleft() evita os deslocamentos repetidos de pop(0) em uma lista.
Não procure uma razão fixa entre os números: máquina, versão do Python, carga do sistema e tamanhos escolhidos influenciam valores absolutos. O dado principal é a tendência em uma carga equivalente.
Este experimento evidencia tempo de execução, não consumo de memória. Trocar uma lista por deque não prova, por si só, que o programa usará menos memória.
Execute o código no seu computador. Relate os tempos observados para pelo menos dois tamanhos, confirme o que os asserts verificaram e interprete a tendência. Inclua por que seus números não permitem concluir nada, sozinhos, sobre memória.
Escreva pelo menos 180 caracteres (0/180).
Passo 7 de 7
Aplique deque e lista em um fluxo completo: atenda pendências em ordem, retenha somente o histórico permitido e guarde resultados para consulta por posição.
Você vai simular um atendimento de pendências. Todas as pendências devem ser atendidas na ordem de chegada, sem descarte. Em paralelo, o sistema deve mostrar somente os três últimos atendimentos. Por fim, os resultados precisam permitir consultas frequentes por índice, como resultados[0].
A fila preserva tudo; o histórico pode descartar o mais antigo; a lista favorece consultas por índice.
Dica
maxlen=3 pertence apenas ao histórico: perder atendimentos antigos ali é parte do contrato. A fila de pendências fica sem maxlen, pois nenhum trabalho pode desaparecer.
Crie um arquivo chamado atendimentos.py, copie o código abaixo e execute python atendimentos.py no terminal. As verificações com assert confirmam a ordem, a ausência de pendências e o descarte esperado no histórico.
from collections import deque
# Nenhuma pendência pode ser descartada.
pendencias = deque()
for tarefa in ["revisar cadastro", "emitir nota", "responder cliente", "fechar chamado"]:
pendencias.append(tarefa)
# Somente os três atendimentos mais recentes devem permanecer visíveis.
historico = deque(maxlen=3)
# O contrato pede consultas frequentes por índice.
resultados = []
while pendencias:
tarefa = pendencias.popleft()
resultado = f"Concluído: {tarefa}"
historico.append(tarefa)
resultados.append(resultado)
# Verificações fora de qualquer medição de desempenho.
assert resultados == [
"Concluído: revisar cadastro",
"Concluído: emitir nota",
"Concluído: responder cliente",
"Concluído: fechar chamado",
]
assert not pendencias
assert list(historico) == [
"emitir nota",
"responder cliente",
"fechar chamado",
]
assert resultados[2] == "Concluído: responder cliente"
print("Resultados:", resultados)
print("Pendências restantes:", list(pendencias))
print("Histórico recente:", list(historico))Exemplo
Resultados: ['Concluído: revisar cadastro', 'Concluído: emitir nota', 'Concluído: responder cliente', 'Concluído: fechar chamado']
Pendências restantes: []
Histórico recente: ['emitir nota', 'responder cliente', 'fechar chamado']
Após executar o programa, relate: qual foi a ordem de atendimento, quais itens ficaram no histórico e por que cada uma das três coleções é adequada ao seu papel.
Escreva pelo menos 100 caracteres (0/100).
Resumo
deque com append e popleft para uma fila FIFO: entradas e retiradas ocorrem nas extremidades.maxlen quando cada item pendente precisa ser preservado; o descarte automático é uma regra de negócio, não uma otimização neutra.deque(maxlen=...) quando o contrato permite manter somente os registros mais recentes.Parabéns! Você concluiu: Implementar filas eficientes com deque
Você integrou fila FIFO, histórico limitado e resultados indexáveis. Agora consegue escolher entre deque e lista conforme o padrão de acesso e a permissão de descarte.
Milhares de cursos online em vídeo, ebooks e áudiobooks.
Para testar seus conhecimentos no decorrer dos cursos online
Gerado diretamente na galeria de fotos do seu celular e enviado ao seu e-mail
Baixe nosso aplicativo pelo QR Code ou pelos links abaixo:.
Leve o conhecimento no seu bolso.
Baixe o aplicativo Cursa.
São centenas de Cursos gratuitos a disposição, com Certificado de conclusão gratuito que é salvo em sua galeria de imagens do celular.
Baixe o app para ter acesso ao Certificado de conclusão de Curso Gratuitamente.
+ de 10 milhões
de alunos
Certificado grátis e
válido em todo o Brasil
60 mil exercícios
gratuitos
4,8/5 classificação
nas lojas de apps
Cursos gratuitos em
vídeo, ebooks e audiobooks
