Python 3.x 如何以异步方式执行ZeroMQ推/拉原型？

我想在一个端口中启动一个

PULL

，并想从其他端口接收到我的

PULL

端口。在

拉入

端口的情况下，它异步侦听，当接收到消息时，它只在控制台中打印消息。为此，我在

Push

-类中编写了一个方法，它将消息发送到

PULL

端口

我的代码如下：

import random
import zmq
import time
import sys
import string
import asyncio
import zmq.asyncio

class Push():
    def __init__(self, port, addr='localhost'):
        self.port = port
        self.addr = addr

        self.ctx = zmq.Context()
        self.scoket = self.ctx.socket(zmq.PUSH)
        self.scoket.connect(f'tcp://{self.addr}:{selfa.port}')

    def send(self):
        chars = string.ascii_uppercase + string.ascii_lowercase
        message = ''.join(random.choice(chars) for _ in range(4))
        self.scoket.send(bytes(message, 'utf-8'))
        print(f'sending: {message}')

class Pull():
    def __init__(self, port, addr='*'):
        self.port = port
        self.addr = addr

        self.ctx = zmq.Context()
        self.socket = self.ctx.socket(zmq.PULL)
        self.socket.bind(f'tcp://{self.addr}:{self.port}')

    async def listen(self, listener):
        while True:
            string = await self.socket.recv()
            listener(string)


if __name__ == '__main__':
    push = Push('55501')

    async def send():
        while True:
            await asyncio.sleep(5)
            print('Sending...')
            push.send()

    pull = Pull('55501')

    try:
        asyncio.run(
            pull.listen(print),
            send(),
        )
    except KeyboardInterrupt:
        print('exiting...')
        exit()

上面的代码没有运行。代码在listen方法处停止

#ADAPTED FROM PYMATA EXPRESS EXAMPLE CONCURRENTTAKS
#https://github.com/MrYsLab/pymata-express/
import asyncio
import zmq
import json
import zmq.asyncio as zmq_asyncio
from pymata_express.pymata_express import PymataExpress


class ConcurrentTasks:

    def __init__(self, board):


        self.loop = board.get_event_loop()
        self.board = board

        self.ctxsync = zmq.Context()
        self.context = zmq.asyncio.Context()
        self.rep = self.context.socket(zmq.REP)
        self.rep.bind("tcp://*:5558")

        self.trigger_pin = 53
        self.echo_pin = 51

        loop.run_until_complete(self.async_init_and_run())

    ### START:  NEW CODE THAT RESOLVED THE ISSUE
    async def pingsonar(self):
        value = await self.board.sonar_read(self.trigger_pin)
        return value

    async def readsonar(self):
        while True:
            rep_recv = await self.rep.recv() 
            value = await asyncio.wait([self.pingsonar()])
            valuesonar = list(value[0])[0].result()
            json_data = json.dumps(valuesonar) 
            await self.rep.send(json_data.encode()) 
            await asyncio.sleep(1 / 1000) #maybe this line isn't necessary

    ### END : NEW CODE THAT RESOLVED THE ISSUE

    async def async_init_and_run(self):

        await self.board.set_pin_mode_sonar(self.trigger_pin, self.echo_pin)

        readsonar = asyncio.create_task(self.readsonar())
        await readsonar

        # OTHER CREATED_TASK GO HERE, (removed them in the MVE, but they work fine)


if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    my_board = PymataExpress()
    try:
        ConcurrentTasks(my_board)
    except (KeyboardInterrupt, RuntimeError):
        loop.run_until_complete(my_board.shutdown())
        print('goodbye')
    finally:
        loop.close()

上面的代码没有运行

代码正在运行，
但是源代码中有错误（在概念上）和打字错误

按原样编写的代码禁止了推送类成为连接类，因此拉送类没有人可以交谈

---

解决方案 1）
修复此错误（+更好，明确检测并处理所有潜在错误状态）

2）
纠正这一概念-混合低挂果实（同时使用多个异步框架，一个框架与所有其他框架相互作用）是对专业工程在足够可靠和健壮方面责任的肤浅理解的标志（控制概念上的缺陷，如阿波罗11号登月期间，或相反，切尔诺贝利式的错误管理系统+心态，是干净的、鼓舞人心的，足以警示人们不良行为（如果不加以禁止+发现+纠正+惩罚）会一次又一次地造成伤害）

---

如果您从未使用过ZeroMQ，您可能会喜欢在深入了解更多细节之前先看一看

---

最好的下一步

---

如果真的想达到专业水平，请从Pieter Hintjens的书“代码连接，第1卷”开始-值得花时间，值得努力，值得理解这些讨论的概念。

类内推送发送方法是同步的，但类内拉听方法是异步的。在主函数中，我将发送方法转换为异步的，以便连续推送字符串。我希望异步发送和接收，但这不会发生。@Sushabandbnath让发送和侦听或接收异步。我使用了pymataexpress。恕我直言，问题在源代码中的其他地方+通过将原始问题重新包装到另一个抽象层（使用另一个框架的另一层）来“解决”一个可解决的问题是一个糟糕的工程设计的标志。ZeroMQ本身是一个异步、高性能、低延迟的优化框架，因此没有正确使用其工具是问题的根本原因。将一个制作欠佳的代码重新包装到另一个框架中可能会缓解一些问题，但在维护su时，性能更差、错误跟踪能力更差会带来巨大的成本和损失智能清洁设计实践是正确的解决方案，而不是将一个有问题的概念（用一段代码表示）隐藏在另一个黑盒子中

self.scoket.connect(f'tcp://{self.addr}:{selfa.port}') # this will NEVER FLY
#--------------------------------------------^
self.scoket.connect(f'tcp://{self.addr}:{self.port}')  # this will ... ( + detect Error-state(s)