正确的做法是什么；松耦合；用python？

我编写了一些代码来使用

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

---

我可以想出两种可能的解决办法

实现一个“适配器”以向主类公开方法并隐藏串行接口的实现。这样，您的主类就可以避免依赖于具体的串行类

做依赖注入，类似这样的事情

def串行_连接（自身、发动机、串行_端口、串行_波特率）

更新1：我提到了当您想要将具体实现与抽象分离时通常使用的方法。将其视为行程插头适配器

它对于像Java这样具有严格接口的语言和所有东西都特别有用。在您的例子中，因为Python中没有“接口”，所以您可以使用抽象类来模拟它

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\u to_arduino

扩展

AbstractAdapter

，从而强制实现所有抽象方法，从而实现适配器

这可能不是最“pythonic”的方式，但从面向对象的角度来看，您可以通过这种方式实现最高级别的松耦合（在我看来）

---

p/s：事实上，我认为在这种情况下，正确的模式应该是战略，两者在实施方面非常相似，但它们的目的不同。您可以阅读更多有关策略、代理、命令、中介等模式的信息，这些模式通常用于实现松耦合

您能详细说明1吗？更新了答案，因为注释部分太小，无法使用