请问python同一个项目的两个类之间和不同项目的进程之间如何通讯

DummerSM

我需要完成一个比较复杂的信号传递。
在项目1的main.py里，我需要在main.py运行之后，项目1的logger_send.py里面的sender类也同步运行，并且main.py需要发送列表形式的信号比如["info","程序启动"]，然后logger_send.py的sender类接受到这个["info","程序启动"]信号之后，
发送给项目2的logger.py[这个py程序一直在作为独立进程运行]，然后项目2的logger.py执行对应的操作[比如生成一个log文件]
=====================
其实简言之就是一个项目的mian主程序启动这个项目下的一个sender类，并且可以向其传递参数，在sender类收到这个函数之后连接到有写入log文件的进程，并把参数传递给这个进程
能够达到这个功能就行，也不一定必须要sender类一直运行，sender也可以是一个模块

isdkz

可以使用Python内置的multiprocessing模块来实现不同进程之间的通信。具体实现可以按照以下步骤进行：

1. 在项目1的main.py中，启动一个子进程，运行logger_send.py中的sender类。可以使用multiprocessing.Process来创建子进程，将sender类作为参数传入。例如：

1. import multiprocessing
2. from logger_send import sender
4. if __name__ == '__main__':
5.     p = multiprocessing.Process(target=sender)
6.     p.start()

复制代码

2. 在main.py中，使用multiprocessing.Queue来创建一个队列，将需要发送的信号放入队列中。例如：

1. from multiprocessing import Queue
3. signal_queue = Queue()
4. signal_queue.put(["info", "程序启动"])

复制代码

3. 在sender类中，使用multiprocessing.Pipe来创建一个管道，连接到项目2的logger.py进程。例如：

1. from multiprocessing import Pipe
3. conn1, conn2 = Pipe()

复制代码

4. 在sender类中，使用multiprocessing.Queue.get方法从队列中获取信号，然后使用conn2.send方法将信号发送到logger.py进程。例如：

1. signal = signal_queue.get()
2. conn2.send(signal)

复制代码

5. 在logger.py中，使用conn1.recv方法从管道中接收信号，然后执行相应的操作。例如：

1. signal = conn1.recv()
2. if signal[0] == "info":
3.     # 执行生成log文件的操作

复制代码

通过这种方式，可以实现不同进程之间的通信，并且可以在不同项目之间传递数据。

陶远航

你可以在项目1的main.py中使用multiprocessing模块来启动一个新进程，并将需要传递的参数作为参数传给该进程。如下所示：

1. import multiprocessing
   
2. from logger_send import Sender
   
3. 
   
4. if __name__ == '__main__':
   
5.     signal = ["info", "程序启动"]
   
6.     sender_process = multiprocessing.Process(target=Sender, args=(signal,))
   
7.     sender_process.start()

复制代码

在上述代码中，我们首先导入了multiprocessing模块和Sender类，然后在if __name__ == '__main__':语句块中创建了一个名为signal的列表，里面存储了需要传递的参数。接下来，我们利用multiprocessing.Process函数创建了一个新的进程，并在其中运行Sender类，同时将signal作为参数传递给该进程。

在项目1的logger_send.py文件中，我们定义了Sender类来读取并发送传递过来的信号。具体实现如下：

1. import time
   
2. from multiprocessing.connection import Client
   
3. 
   
4. class Sender:
   
5.     def __init__(self, signal):
   
6.         self.signal = signal
   
7.    
   
8.     def send_signal(self):
   
9.         address = ('localhost', 6000) # 指定log进程的地址和端口号
   
10.         with Client(address, authkey=b'secret password') as conn:
    
11.             conn.send(self.signal)
    
12.             conn.close()
    
13. 
    
14. if __name__ == '__main__':
    
15.     sender = Sender(signal)
    
16.     sender.send_signal()

复制代码

在上述代码中，我们首先导入了time模块和multiprocessing.connection.Client类，然后定义了Sender类来读取并发送传递过来的信号。在__init__函数中，我们初始化了一个名为signal的实例变量，该变量存储了从主进程中传递过来的参数。接下来，在send_signal函数中，我们指定了log进程的地址和端口号（在此处假设为localhost:6000），并利用multiprocessing.connection.Client类建立了一个连接。然后，我们将信号发送给log进程，并关闭连接。

在项目2的logger.py文件中，我们需要先启动log进程，然后在其中定义一个Receiver类来接受并处理从main进程发来的信号。具体实现如下：

1. import logging
   
2. from multiprocessing import Process, connection
   
3. 
   
4. class Receiver:
   
5.     def __init__(self):
   
6.         self.listener = connection.Listener(('localhost', 6000), authkey=b'secret password')
   
7.    
   
8.     def start(self):
   
9.         logger = logging.getLogger(__name__)
   
10.         logger.setLevel(logging.DEBUG)
    
11.         formatter = logging.Formatter('%(asctime)s %(levelname)s: %(message)s')
    
12.         file_handler = logging.FileHandler('my.log')
    
13.         file_handler.setFormatter(formatter)
    
14.         logger.addHandler(file_handler)
    
15.         
    
16.         while True:
    
17.             conn = self.listener.accept()
    
18.             signal = conn.recv()
    
19.             conn.close()
    
20.             logger.info(signal[1])
    
21. 
    
22. if __name__ == '__main__':
    
23.     receiver = Receiver()
    
24.     receiver.start()

复制代码

在上述代码中，我们首先导入了logging模块和multiprocessing.Process、multiprocessing.connection模块中的Listener和connection类。然后，在Receiver类中，我们初始化了一个名为listener的实例变量，该变量用于监听连接到log进程的sender进程。在start函数中，我们首先配置了logger对象，指定了日志级别、格式和输出文件。接下来，我们使用一个无限循环来不断接受从sender进程传递过来的信号，并将其存储到signal变量中。最后，我们利用logger对象记录日志。

在项目2的main.py文件中，我们可以直接调用logging模块来记录日志，例如：

1. import logging
   
2. 
   
3. if __name__ == '__main__':
   
4.     logging.info('程序启动')

复制代码

这样一来，当我们运行项目1的main.py时，会自动启动一个新的sender进程，并将参数传递给log进程，log进程收到参数后会生成对应的日志文件。

DummerSM

陶远航 发表于 2023-6-3 21:21
你可以在项目1的main.py中使用multiprocessing模块来启动一个新进程，并将需要传递的参数作为参数传给该进 ...

太感谢了，那么细心回复，我一会试试，谢谢

陶远航

DummerSM 发表于 2023-6-3 22:01
太感谢了，那么细心回复，我一会试试，谢谢

好好

DummerSM

isdkz 发表于 2023-6-3 21:17
可以使用Python内置的multiprocessing模块来实现不同进程之间的通信。具体实现可以按照以下步骤进行：

1.  ...

万分感谢！那么细心回复，我一会试试，谢谢

DummerSM

isdkz 发表于 2023-6-3 21:17
可以使用Python内置的multiprocessing模块来实现不同进程之间的通信。具体实现可以按照以下步骤进行：

1.  ...

你好
请问是否可以添加一下您的QQ，对于这个参数的传递我还是有点问题，可否指教

DummerSM

isdkz 发表于 2023-6-3 21:17
可以使用Python内置的multiprocessing模块来实现不同进程之间的通信。具体实现可以按照以下步骤进行：

1.  ...

2629895779

isdkz

DummerSM 发表于 2023-6-3 22:36
2629895779

加你了

DummerSM

现在的问题是，我可能需要pywin32来创建命名管道，请问该怎么操作