Início / user-1480131

Pablo's questions

Martin Hope
Pablo
Asked: 2025-04-15 22:43:50 +0800 CST
  • 7

Considere este exemplo em que tenho 3 tarefas de trabalho que enviam resultados para uma fila e uma tarefa que lida com os dados enviados.


async def worker1(queue: asyncio.Queue):
    while True:
        res = await do_some_work(param=1)

        await queue.put(res)

async def worker2(queue: asyncio.Queue):
    while True:
        res = await do_some_work(param=2)

        await queue.put(res)

async def worker3(queue: asyncio.Queue):
    while True:
        res = await do_some_work(param=3)

        await queue.put(res)

async def handle_results(queue: asyncio.Queue):

    while True:
        res = await queue.get()
        await handle_result(res)
        queue.task_done()

async def main():
    queue = asyncio.Queue()
    t1 = asyncio.create_task(worker1(queue))
    t2 = asyncio.create_task(worker2(queue))
    t3 = asyncio.create_task(worker3(queue))

    handler = asyncio.create_task(handle_result(queue))

    while True:
        # do some other stuff

        ....

asyncio.run(main())

A documentação diz que asyncio.Queuenão é thread-safe, mas isso não deveria se aplicar aqui, pois todas as tarefas estão sendo executadas na mesma thread. Mas preciso de um asyncio.Lockpara proteger a fila quando tenho 3 tarefas que enviam para a mesma fila? Observando a implementação em Python 3.12 (que cria um putterfuture e aguarda por ele antes de enviar para a fila), eu diria que não , mas não tenho certeza, e a documentação não menciona o que aconteceria neste caso. Então, o asyncio.Lockneste caso é necessário?

python
Martin Hope
Pablo
Asked: 2024-01-30 04:58:52 +0800 CST
  • 5

Eu sei que com TypeVarvocê você pode definir o tipo de retorno de uma função dependendo do tipo de um de seus argumentos. No entanto, quero o tipo baseado no conteúdo de um argumento.

Por exemplo, a função openretorna tipos diferentes dependendo do conteúdo do modeargumento:

a = open("/etc/fstab", "r")
b = open("/etc/fstab", "rb")

Neste caso, my pyrightdiz que aé a TextIOWrappere bé a BufferedReader.

Também percebi que meu direito autoral infere o tipo correto com este código:

mode = "rb"
a = open("/etc/fstab", mode)

mas se eu fizer:

def funny(mode: str):
    a = open("/ect/fstab", mode)

então o direito autoral infere IO[Any]. Portanto, claramente os direitos autorais levam em consideração mais do que o valor literal de mode. Então, como o direito autoral está inferindo o tipo corretamente? Isso ocorre porque o tipo sugere openou é algum tipo de "codificação" de direitos autorais para a função open?

python