Question

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

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过程还有什么我可以做的，以满足＆＃34;松耦合＆＃34;治？
谢谢你的帮助。

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

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

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

def serial_connect（self，engine，serial_port，serial_baudrate）

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

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

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，从而强制执行所有抽象方法，从而实现适配器。

这可能不是最多＆＃34; pythonic＆＃34;做事的方式，但从OOP的角度来看，你可以这样做，以获得最高水平的松散耦合（在我看来）

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

什么是正确的做法＆＃34;松耦合＆＃34;在python？

1 个答案: