Guia para filas em Python

Republicado por Platão

seguidores: 0

Introdução

Do armazenamento de números inteiros simples ao gerenciamento de fluxos de trabalho complexos, as estruturas de dados estabelecem a base para aplicações robustas. Entre eles, o fila muitas vezes surge como intrigante e onipresente. Pense nisso – um fila no banco, aguardando sua vez em um balcão de fast-food ou armazenando tarefas em um sistema de computador – todos esses cenários ressoam com a mecânica de uma fila.

A primeira pessoa da fila é atendida primeiro e os novos chegam no final. Este é um exemplo real de uma fila em ação!

guia para filas em python-01.png

Para desenvolvedores, especialmente em Python, as filas não são apenas construções teóricas de um livro de ciência da computação. Eles formam a arquitetura subjacente em muitos aplicativos. Desde o gerenciamento de tarefas em uma impressora até a garantia de fluxos de dados contínuos em transmissões ao vivo, as filas desempenham um papel indispensável.

Neste guia, nos aprofundaremos no conceito de filas, explorando suas características, aplicações do mundo real e, o mais importante, como implementá-las e usá-las de maneira eficaz em Python.

O que é uma estrutura de dados de fila?

Navegando pelo cenário das estruturas de dados, frequentemente encontramos contêineres que possuem regras distintas para entrada e recuperação de dados. Entre estes, o fila destaca-se pela elegância e simplicidade.

O Princípio FIFO

Em sua essência, uma fila é uma estrutura de dados linear que adere ao Primeiro a entrar, primeiro a sair (FIFO) princípio. Isso significa que o primeiro elemento adicionado à fila será o primeiro a ser removido. Para compará-lo a um cenário identificável: considere uma fila de clientes em um balcão. A pessoa que chega primeiro recebe o seu bilhete primeiro, e os que chegam subsequentemente fazem fila no final, aguardando a sua vez.

Observação: Uma fila tem duas extremidades – traseira e dianteira. A frente indica de onde os elementos serão removidos e a traseira significa onde novos elementos serão adicionados.

Operações básicas de fila

Enfileirar - O ato de acrescentando um elemento até o final (traseiro) da fila.
Desenfileirar - O ato de removendo um elemento do frente da fila.
Espiar ou Frente – Em muitas situações, é benéfico apenas observar o elemento frontal sem removê-lo. Esta operação nos permite fazer exatamente isso.
IsEmpty – Uma operação que ajuda a determinar se a fila possui algum elemento. Isso pode ser crucial em cenários em que as ações dependem de a fila ter dados.

Observação: Embora algumas filas tenham um tamanho limitado (filas limitadas), outras podem crescer potencialmente enquanto a memória do sistema permitir (filas ilimitadas).

A simplicidade das filas e suas regras claras de operação as tornam ideais para uma variedade de aplicações no desenvolvimento de software, especialmente em cenários que exigem processamento ordenado e sistemático.

No entanto, compreender a teoria é apenas o primeiro passo. À medida que avançamos, nos aprofundaremos nos aspectos práticos, ilustrando como implementar filas em Python.

Como implementar filas em Python – Listas vs. Deque vs. Módulo de filas

Python, com sua rica biblioteca padrão e sintaxe amigável, fornece vários mecanismos para implementar e trabalhar com filas. Embora todos sirvam ao propósito fundamental do gerenciamento de filas, eles apresentam nuances, vantagens e possíveis armadilhas. Vamos dissecar cada abordagem, ilustrando sua mecânica e melhores casos de uso.

Observação: Sempre verifique o status da sua fila antes de realizar operações. Por exemplo, antes de retirar da fila, verifique se a fila está vazia para evitar erros. Da mesma forma, para filas limitadas, certifique-se de que haja espaço antes de enfileirar.

Usando listas Python para implementar filas

Usar as listas integradas do Python para implementar filas é intuitivo e direto. Não há necessidade de bibliotecas externas ou estruturas de dados complexas. No entanto, esta abordagem pode não ser eficiente para grandes conjuntos de dados. Removendo um elemento do início de uma lista (pop(0)) leva tempo linear, o que pode causar problemas de desempenho.

Observação: Para aplicações que exigem alto desempenho ou que lidam com um volume significativo de dados, mude para collections.deque para complexidade de tempo constante para enfileiramento e desenfileiramento.

Vamos começar criando uma lista para representar nossa fila:

queue = []

O processo de adicionar elementos ao final da fila (enfileiramento) nada mais é do que anexá-los à lista:


queue.append('A')
queue.append('B')
queue.append('C')
print(queue)

Além disso, remover o elemento do início da fila (desenfileirar) equivale a apenas remover o primeiro elemento da lista:


queue.pop(0)
print(queue)

utilização coleções.deque implementar filas

Esta abordagem é altamente eficiente, pois deque é implementado usando um lista duplamente ligada. Ele suporta acréscimos e pops rápidos O(1) de ambas as extremidades. A desvantagem desta abordagem é que é levemente menos intuitivo para iniciantes.

Primeiramente, importaremos o deque objeto do collections módulo e inicialize nossa fila:

from collections import deque queue = deque()

Agora, podemos usar o append() método para enfileirar elementos e o popleft() método para retirar elementos da fila:

Confira nosso guia prático e prático para aprender Git, com práticas recomendadas, padrões aceitos pelo setor e folha de dicas incluída. Pare de pesquisar comandos Git no Google e realmente aprender -lo!


queue.append('A')
queue.append('B')
queue.append('C')
print(queue) queue.popleft()
print(queue)

Usando o Python fila Módulo para Implementar Filas

A queue O módulo na biblioteca padrão do Python fornece uma abordagem mais especializada para gerenciamento de filas, atendendo a vários casos de uso:

SimpleQueue – Uma fila FIFO básica
LifoQueue – Uma fila LIFO, essencialmente uma pilha
Fila de prioridade – Os elementos são retirados da fila com base na prioridade atribuída

Observação: Opte pelo queue módulo, que foi projetado para ser thread-safe. Isso garante que as operações simultâneas na fila não levem a resultados imprevisíveis.

Essa abordagem é ótima porque foi projetada explicitamente para operações de fila. Mas, para ser totalmente honesto, pode ser um exagero para cenários simples.

Agora, vamos começar a usar o queue módulo importando-o para nosso projeto:

import queue

Como estamos implementando uma fila FIFO simples, inicializaremos ela usando o comando SimpleQueue() construtor:

q = queue.SimpleQueue()

As operações de enfileiramento e desenfileiramento são implementadas usando put() e get() métodos do queue módulo:


q.put('A')
q.put('B')
q.put('C')
print(q.queue) q.get()
print(q.queue)

Observação: As operações de fila podem gerar exceções que, se não tratadas, podem interromper o fluxo do seu aplicativo. Para evitar isso, envolva suas operações de fila em try-except blocos.

Por exemplo, lidar com o queue.Empty exceção ao trabalhar com o queue módulo:

import queue q = queue.SimpleQueue() try: item = q.get_nowait()
except queue.Empty: print("Queue is empty!")

Qual implementação escolher?

Sua escolha de implementação de fila em Python deve estar alinhada com os requisitos do seu aplicativo. Se você estiver lidando com um grande volume de dados ou precisar de desempenho otimizado, collections.deque é uma escolha convincente. No entanto, para aplicativos multithread ou quando as prioridades entram em jogo, o queue módulo oferece soluções robustas. Para scripts rápidos ou quando você está apenas começando, as listas do Python podem ser suficientes, mas sempre tenha cuidado com as possíveis armadilhas de desempenho.

Observação: Reinventando a roda implementando operações de fila de forma personalizada quando o Python já fornece soluções integradas poderosas.
Antes de criar soluções personalizadas, familiarize-se com as ofertas integradas do Python, como deque e os votos de queue módulo. Na maioria das vezes, eles atendem a uma ampla gama de requisitos, economizando tempo e reduzindo possíveis erros.

Mergulhe mais fundo: conceitos avançados de fila em Python

Para aqueles que compreenderam a mecânica básica das filas e estão ansiosos para se aprofundar, o Python oferece uma infinidade de conceitos e técnicas avançadas para refinar e otimizar operações baseadas em filas. Vamos descobrir alguns desses aspectos sofisticados, oferecendo um arsenal de ferramentas para enfrentar cenários mais complexos.

Filas Duplas com de que

Embora já tenhamos explorado deque como uma fila FIFO, ela também suporta operações LIFO (Last-In-First-Out). Ele permite anexar ou destacar elementos de ambas as extremidades com complexidade O(1):

from collections import deque dq = deque()
dq.appendleft('A') dq.append('B') dq.pop() dq.popleft()

PrioridadeQueu Em ação

Usar uma fila FIFO simples quando a ordem de processamento depende da prioridade pode levar a ineficiências ou resultados indesejados; portanto, se sua aplicação exigir que certos elementos sejam processados antes de outros com base em alguns critérios, empregue uma fila FIFO simples. PriorityQueue. Isso garante que os elementos sejam processados com base nas prioridades definidas.

Dê uma olhada em como definimos prioridades para os elementos que adicionamos à fila. Isso requer que passemos uma tupla como argumento do put() método. A tupla deve conter a prioridade como primeiro elemento e o valor real como segundo elemento:

import queue pq = queue.PriorityQueue()
pq.put((2, "Task B"))
pq.put((1, "Task A")) pq.put((3, "Task C")) while not pq.empty(): _, task = pq.get() print(f"Processing: {task}")

Isso nos dará o seguinte:

Processing: Task A
Processing: Task B
Processing: Task C

Observe como adicionamos elementos em uma ordem diferente daquela armazenada na fila. Isso se deve às prioridades que atribuímos no put() método ao adicionar elementos à fila de prioridade.

Implementando uma fila circular

Uma fila circular (ou buffer de anel) é uma estrutura de dados avançada onde o último elemento é conectado ao primeiro, garantindo um fluxo circular. deque pode imitar esse comportamento usando seu maxlen propriedade:

from collections import deque circular_queue = deque(maxlen=3)
circular_queue.append(1)
circular_queue.append(2)
circular_queue.append(3) circular_queue.append(4)
print(circular_queue)

Conclusão

As filas, fundamentais, porém poderosas, encontram sua essência em uma variedade de aplicações e problemas computacionais do mundo real. Desde o agendamento de tarefas em sistemas operacionais até o gerenciamento do fluxo de dados em spoolers de impressão ou solicitações de servidores web, as implicações das filas são de longo alcance.

Python traz para a mesa uma rica paleta de ferramentas e bibliotecas para trabalhar com filas. Desde filas simples baseadas em lista para scripts rápidos até filas altamente eficientes deque para aplicativos de desempenho crítico, a linguagem realmente atende a uma variedade de necessidades.

Conteúdo com tecnologia de SEO e distribuição de relações públicas. Seja amplificado hoje.
PlatoData.Network Gerativa Vertical Ai. Capacite-se. Acesse aqui.
PlatoAiStream. Inteligência Web3. Conhecimento Amplificado. Acesse aqui.
PlatãoESG. Carbono Tecnologia Limpa, Energia, Ambiente, Solar, Gestão de resíduos. Acesse aqui.
PlatoHealth. Inteligência em Biotecnologia e Ensaios Clínicos. Acesse aqui.
Fonte: https://stackabuse.com/guide-to-queues-in-python/