python - 这种情况下如何让多个python程序进行通信呢？

Question

我对 Python 有点陌生，我正在从事一个机器人项目。我的问题的简短形式是，我正在尝试找到最佳 方式(针对我的情况)一次运行多个 python 程序。

关于上下文，我的机器人是一个服务机器人平台，它能够使用图像算法跟踪标记和路径，还可以从远程计算机接收命令。我想有单独的程序来处理图像处理、驱动等，然后通过一个主程序来管理它们。我知道我不能使用像函数或类这样的基本东西，因为这些进程中的每一个都必须连续循环，而且我不想将所有代码组合起来在一个 while 循环中运行，因为它运行得非常慢而且它管理起来要困难得多。

那么，简而言之，如何让两个独立的循环程序“对话”？就像我希望成像程序将它看到的信息发送给驾驶和转向程序等。

我做了一些研究，发现了一些关于多线程和 API 以及类似内容的信息，但我无法真正分辨出我真正要找的是哪一个。

为了澄清，我只需要指出正确的方向。这似乎不是一个非常高层次的东西，而且我知道那里肯定有教程，我真的很困惑从哪里开始，因为我正在自学这个.

Answer 1

经过一番摸索，我发现使用 IPC 是一个很好的解决方案。我使用的过程并不太难，我只是制作了一些非常简单的服务器和客户端类，并让它们通过 Localhost IP 进行通信。毫无疑问，有更好的方法来做到这一点，但对于像我这样的初学者来说，这是一种无需过多修改代码即可让两个程序对话的简单方法。对于那些尝试做与我类似的事情的人，这是我为自己制作的类(class)。公平警告，它们并不完全原始甚至非常复杂，但它们完成了工作。

这是我为服务器创建的类:

import socket
from random import random
from time import sleep

class ServerObject:

    def __init__(self,host_address,port):

        self._host_address = host_address
        self._s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self._s.bind((self._host_address,port))

    def handshake(self):

        print "Server Started. Awaiting Connection"

        while True: 
            _data, _addr = self._s.recvfrom(1024)
            if str(self._s.recvfrom(1024)[0]) == 'marco':
                break

        print 'marco recieved. sending polo...'

        while True:
            self._s.sendto('polo',_addr)
            if str(self._s.recvfrom(1024)[0]) == 'confirm':
                break
            sleep(.5)

        print 'connection verified'

        self._addr = _addr

        return True

    def send(self,data):

        self._s.sendto(str(data),self._addr)

    def recieve(self,mode = 0):

        _data, _addr = self._s.recvfrom(1024)

        if mode == 0:
            return str(_data)
        if mode == 1:
            return int(_data)
        if mode == 2:
            return float(_data)
        if mode == 3:
            return tuple(_data)

    def change_port(self,port):

        self._s.bind((self._host_address,port))

    def close(self):
        self._s.close()
        print '_socket closed_'


if __name__ == '__main__':

    host = '127.0.0.1'

    talk = ServerObject(host,6003)
    talk.handshake()

这是我为客户制作的类(class):

import socket
from time import sleep

class ClientObject:

    def __init__(self,host_address,server_port,port = 0):

        self._server = (host_address,server_port)
        self._s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self._s.bind((host_address,port))


    def handshake(self):

        print ' sending marco'

        self._s.sendto('marco',self._server)
        sleep(.1)
        self._s.sendto('marco',self._server)

        while True:
            if str(self._s.recvfrom(1024)[0]) == 'polo':
                break

        #self._s.sendto('marco',self._server)
        #self._s.sendto('marco',self._server)

        print ' connection verified'
        self._s.sendto('confirm',self._server)

        self._s.setblocking(0)

        return True

    def recieve(self,mode = 0):

        _data, _addr = self._s.recvfrom(1024)

        if mode == 0:
            return str(_data)
        if mode == 1:
            return int(_data)
        if mode == 2:
            return float(_data)
        if mode == 3:
            return tuple(_data)

    def send(self,data):
        self._s.sendto(str(data),self._server)

    def close(self):
        self._s.close()
        print '_socket closed_'


if __name__ == '__main__':

    host = '127.0.0.1'
    port = 0

    talk = ClientObject(host,24603,port)
    talk.handshake()

    #while True:
        #print talk.recieve()

在主要发送数据的程序上使用 ServerObject 类，在主要接收数据的程序上使用 ClientObject 类。这些可以在许多情况下翻转，但我发现最好以这种方式来利用 UDP。客户端类有一个可选的端口变量，默认设置为 0。这是因为对于 UDP，客户端需要另一个端口来建立自己。 0 表示它将选择一个可用端口，但如果您指定一个端口，则可以在客户端离线时重新建立连接而无需重新启动两个程序。

首先在两个程序上使用握手，确保使用相同的 IP 和端口(不是指客户端上的最后一个变量)，然后使用发送和接收函数来回传递数据。

同样，这些都不是很好，实际上使用这种方法会出现很多问题，但是对于一个简单的任务，他们已经完成了工作。我设置了握手来打印正在发生的事情的验证，但如果这些变得烦人，你可以删除这些行。

希望这对您有所帮助!