反向电路变为正向电路

davidmou

class logicalgate:
    def __init__(self, label):  # 这是最通用的类logicgate
        self.label = label
        self.output = None

    def getlabel(self):  # 逻辑门要有标签，要有能获得标签的方法，也要能获得输出值的方法,要有输出值
        return self.label

    def getoutput(self):
        self.output = self.performgatelogic()  # 目前还不用知道该函数的用法，因为每种逻辑门的算法都不一样
        return self.output


class Binarygate(logicalgate):  # 继承父类的方法
    # 逻辑门要有标签,logicgate的子类Binarygate也不列外，所以这里要调用其父类的创造标签的方法，即super().__init__（labe),super()为其父类，否则就不能创造标签。
    def __init__(self, label):
        # 调用super().__init__（labe)后，就默认有self.label = label，self.output = None,父类的方法（函数）也有继承
        super().__init__(label)
        self.pinA = None  # Binargate有两个输入接口，分别是self.pinA 和self.pinB，,默认为None,即没接入状态一个输出接口
        self.pinB = None

    def getpinA(self):  # 要得到此逻辑门的输出值
        if self.pinA == None:
            return int(input("Enter pinA -->" + self.label))
        else:
            # 返回变为connecor的接口的pinA ，取得其上一个逻辑门，再让上一个逻辑门执行getoutput
            return self.pinA.getFrom().getoutput()

    def getpinB(self):
        if self.pinB == None:
            return int(input("Enter pinB -->" + self.label))
        else:
            return self.pinB.getFrom().output()

    def getinput(self):
        return self.getpinA()


class Unarygate(logicalgate):  # 只有一个输入值，一个输出值，是logicalgate的子类
    def __init__(self, label):
        super().__init__(label)

        self.pin = None

    def getpin(self):
        return int(input("Enter pin -->" + self.label))


class AndGate(Binarygate):  # 要有两个输入值，并且只有都为一时才返回一
    def __init__(self, label):  # 其调用它的父类，他的父类有调用它的父类，所以共继承有两个输入值，一个输出值，一个标签，方法也有继承
        super().__init__(label)

    def performgatelogic(self):
        a = self.getpinA()
        b = self.getpinB()
        if a == 1 and b == 1:
            return 1
        else:
            return 0

    def setNextPin(self, source):  # source 这里指的是conector的是列对象
        if self.pinA == None:
            self.pinA = source
        else:
            if self.pinB == None:
                self.pinB = source
            else:
                raise RuntimeError("你是啥插拔")


class conector:

    def __init__(self, fgate, tgate):
        self.fgate = fgate
        self.tgate = tgate

        tgate.setNextPin(self)  # 把tgate的输入接口变为conector本身

    def getFrom(self):
        return self.fgate

    def getTo(self):
        return self.tgate


e = AndGate("rr")
d = AndGate("rrrrr")
k= AndGate("uu")
a = conector(e, d)  # 这里有参与运算，当a = conector(e, d)是，。。。。。
b = conector(k,e )
print(d.getoutput())# 从最后一个逻辑门开始运行，逆向思维

如代码所示，这是段逆向的电路，方向是k-->e--->d 可以直接print(d.getoutput())# 从最后一个逻辑门开始运行，逆向思维
想要将其变为正向电路，即输入k.getoutput(),可得出最后答案

isdkz

要将逆向电路变为正向电路，需要修改代码逻辑，将输入的方式改为直接调用方法获取输入值，而不是通过用户输入。修改后的代码如下：

class LogicalGate:
    def __init__(self, label):
        self.label = label
        self.output = None

    def get_label(self):
        return self.label

    def get_output(self):
        self.output = self.perform_gate_logic()
        return self.output


class BinaryGate(LogicalGate):
    def __init__(self, label):
        super().__init__(label)
        self.pin_a = None
        self.pin_b = None

    def get_pin_a(self):
        if self.pin_a is None:
            return self.pin_a
        else:
            return self.pin_a.get_from().get_output()

    def get_pin_b(self):
        if self.pin_b is None:
            return self.pin_b
        else:
            return self.pin_b.get_from().get_output()

    def get_input(self):
        return self.get_pin_a()


class UnaryGate(LogicalGate):
    def __init__(self, label):
        super().__init__(label)
        self.pin = None

    def get_pin(self):
        return self.pin


class AndGate(BinaryGate):
    def __init__(self, label):
        super().__init__(label)

    def perform_gate_logic(self):
        a = self.get_pin_a()
        b = self.get_pin_b()
        if a == 1 and b == 1:
            return 1
        else:
            return 0

    def set_next_pin(self, source):
        if self.pin_a is None:
            self.pin_a = source
        else:
            if self.pin_b is None:
                self.pin_b = source
            else:
                raise RuntimeError("无法插入更多的连接器")


class Connector:
    def __init__(self, from_gate, to_gate):
        self.from_gate = from_gate
        self.to_gate = to_gate
        to_gate.set_next_pin(self)

    def get_from(self):
        return self.from_gate

    def get_to(self):
        return self.to_gate


e = AndGate("rr")
d = AndGate("rrrrr")
k = AndGate("uu")
a = Connector(k, e)
b = Connector(e, d)
print(d.get_output())

修改后的代码将输入方式改为直接调用方法获取输入值，然后通过连接器将逻辑门连接起来，最后调用最后一个逻辑门的get_output()方法来获取正向电路的输出结果。

陶远航

你想要将这个逆向电路改成正向电路，即输入k的输出值来得到最终结果，对吗？如果是的话，你可以按照以下步骤进行修改：

在 conector 类中，修改 __init__ 方法，将 fgate 和 tgate 的顺序颠倒，即 self.fgate = tgate 和 self.tgate = fgate。这样，连接器的起始逻辑门就是 k，而目标逻辑门就是 e。

def __init__(self, fgate, tgate):
    self.fgate = tgate
    self.tgate = fgate
    tgate.setNextPin(self)

最后，输入 k.getoutput() 来获取最终结果。

print(k.getoutput())

这样，你就可以在正向的方向上运行你的电路了。