Question

我在Python上有点新鲜，我正在开发一个机器人项目。我的问题的简短形式是我试图找到最佳方式（对于我的情况）一次运行多个python程序。

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

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

我做了一些研究，我发现了一些关于多线程和API的信息以及类似的东西，虽然我无法确定哪一个实际上是我正在寻找的东西。

澄清一下，我只需指出正确的方向。这似乎似乎就像一个非常高级的东西，我知道那里肯定有教程，我真的很困惑，从哪里开始，因为我在教我自己。

Answer 1

我认为multiproccessing库可能是一个解决方案。当每个进程可以执行特定的工作，同时向对方发送数据时，您将能够并行运行多个进程。

您可以查看example

这是通用目录walker，它具有扫描目录树并将数据传递给其他进程的进程，该进程扫描已发现文件夹中的文件。所有这些都是并行完成的。

Answer 2

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

这是我为服务器制作的课程：

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()

这是我为客户制作的课程：

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和端口（不是指客户端上的最后一个变量），然后使用发送和接收函数来回传递数据。

再次，这些并不是那么好，事实上使用这种方法会出现很多问题，但是对于一个简单的任务，他们完成了工作。我设置握手来打印正在发生的事情的验证，但是如果那些令人讨厌，你可以删除那些线。

希望这有帮助！

Answer 3

这可能有点超出了您的项目范围，但您是否考虑过使用ROS？它允许您通过发布和订阅主题来同时运行一堆不同的节点（可以是Python脚本）。它们可以位于同一系统（即机器人上的一个或多个节点）或不同系统（即机器人上的一个节点，PC上的多个节点）上。 ROS还有许多非常棒的内置工具和库，专门用于机器人系统，如可视化，映射，测距等。这里有一些启动信息：

https://en.wikipedia.org/wiki/Robot_Operating_System

http://wiki.ros.org/ROS/StartGuide

它通常用于比您似乎描述的更大的框架，并且提防需要花费相当多的时间（根据我的经验）来实现，但它很容易扩展一次它的启动和运行。就像我说的，这一切都取决于你的项目范围！

祝你好运！

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

3 个答案: