什么是正确的做法"松耦合"在python?

时间:2015-05-14 06:20:38

标签: python python-2.7 loose-coupling

您好我写了一些代码来使用pySerial获取数据,如下所示 我的课程取决于系列课程,它不符合"松散耦合"规则。
我应该使用界面来解耦我的班级吗? 非常感谢您的指导。

import serial

class ArduinoConnect:  

    def __init__(self):
        pass

    def serial_connect(self, serial_port, serial_baudrate):

        self._serial_port = serial_port
        try:
           self.ser = serial.Serial(
                port=self._serial_port,
                baudrate=serial_baudrate,
                parity=serial.PARITY_NONE,
                stopbits=serial.STOPBITS_ONE,
                bytesize=serial.EIGHTBITS,
            )
        except serial.serialutil.SerialException, e:
            print str(e)

    def serial_disconnect(self):
        self.ser.close()

    def get_quaternion(self, number_of_data=50):

        buff = []
        self.ser.write('q')
        self.ser.write(chr(number_of_data))
        for j in range(number_of_data):
            in_string = self.ser.readline()
            buff_line = in_string.split(",")
            buff_line.pop()
            buff_line = self.hex_to_quaternion(buff_line)
            buff.append(list(buff_line))
        return buff

    def hex_to_quaternion(self, list_of_hex=None):
        #......
        pass

arduino = ArduinoConnect()
arduino.serial_connect(serial_port="COM5", serial_baudrate=115200)
print arduino.get_quaternion()
arduino.serial_disconnect()

我按照建议修改了我的代码 DI有助于分离串行过程,工厂方法有助于封装DI过程 还有什么我可以做的,以满足"松耦合"治?
谢谢你的帮助。

import serial

class ArduinoConnect:
    def __init__(self, serial_to_arduino):
        self._serial_to_arduino = serial_to_arduino

    def get_quaternion(self, number_of_data=50):
        buff = []
        self._serial_to_arduino.write('q')
        self._serial_to_arduino.write(chr(number_of_data))
        for j in range(number_of_data):
            in_string = self._serial_to_arduino.readline()
            buff_line = in_string.split(",")
            buff_line.pop()
            buff_line = self.hex_to_quaternion(buff_line)
            buff.append(list(buff_line))
        return buff

    def hex_to_quaternion(self, list_of_hex):
        ......

    def __getattr__(self, attr):
        return getattr(self._serial_to_arduino, attr)


class SerialToArduino:
    def __init__(self):
        pass

    def serial_connect(self, serial_port="COM5", serial_baudrate=115200):
        self._serial_port = serial_port
        try:
            self.ser = serial.Serial(
                port=self._serial_port,
                baudrate=serial_baudrate,
                parity=serial.PARITY_NONE,
                stopbits=serial.STOPBITS_ONE,
                bytesize=serial.EIGHTBITS,
            )
        except serial.serialutil.SerialException, e:
            print str(e)

    def serial_disconnect(self):
        self.ser.close()

    def readline(self):
        return self.ser.readline()

    def write(self, data):
        self.ser.write(data=data)


def get_ArduinoConnect():
    'factory method'
    return ArduinoConnect(serial_to_arduino=SerialToArduino())


arduino = get_ArduinoConnect()
arduino.serial_connect(serial_port="COM5", serial_baudrate=115200)
print arduino.get_quaternion()
arduino.serial_disconnect()

1 个答案:

答案 0 :(得分:4)

我可以想到两种可能的解决方案

  1. 实施"适配器"将方法暴露给主类并隐藏Serial的实现。这样你的主类就可以避免依赖于具体的类Serial
  2. 执行依赖注入,有点喜欢这个

    def serial_connect(self,engine,serial_port,serial_baudrate)

  3. 更新1:我提到http://en.wikipedia.org/wiki/Adapter_pattern,当您想要将具体实现与抽象分开时,常用它。可以把它想象成旅行插头适配器。

    对于像Java这样具有严格界面和一切的语言特别有用。在你的情况下,因为在Python中我们没有" interface",你可以使用抽象类来模拟它

    class AbstractAdapter():
          def serial_connect(self, serial_port="COM5", serial_baudrate=115200):
              raise("Needs implementation")
          # do the same thing for the rest of the methods
    

    然后在ArduinoConnect中,您可以检查类型

    def __init__(self, serial_to_arduino):
        if not isinstance(serial_to_arduino, AbstractAdapter):
            raise("Wrong type")
    

    这会强制你的serial_to_arduino扩展AbstractAdapter,从而强制执行所有抽象方法,从而实现适配器。

    这可能不是最多" pythonic"做事的方式,但从OOP的角度来看,你可以这样做,以获得最高水平的松散耦合(在我看来)

    P / s:实际上,我认为在这种情况下正确的模式应该是策略,它们在实现方面都非常相似,但它们用于不同的目的。您可以阅读更多关于一些模式,如策略,代理,命令,介体,这些模式通常用于实现松散耦合