python - 在 python 中执行 "loose coupling"的正确方法是什么？

Question

我写了一些代码来使用 pySerial 获取数据，如下所示。
我的类依赖于不符合“松散耦合”规则的串行类。
我应该使用接口(interface)来解耦我的类吗？
非常感谢您的指导。

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

Answer 1

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

1. 实现一个“适配器”以向主类公开方法并隐藏 Serial 的实现。这样你的主类就可以避免对具体类Serial的依赖

2. 做依赖注入(inject)，像这样

   def serial_connect(self, engine, serial_port, serial_baudrate)

1 的更新:我提到了 http://en.wikipedia.org/wiki/Adapter_pattern当您想将具体实现与抽象分开时，通常会使用它。将其视为旅行插头适配器。

对于像Java这种接口(interface)严格什么都有的语言特别有用。在您的情况下，因为在 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:实际上，我认为在这种情况下正确的模式应该是 Strategy，它们在实现方面非常相似，但它们的目的不同。您可以阅读更多有关 Strategy、Proxy、Command、Mediator 等模式的更多信息，这些模式通常用于实现松散耦合