反向电路变为正向电路

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

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

1. class LogicalGate:
   
2.     def __init__(self, label):
   
3.         self.label = label
   
4.         self.output = None
   
5. 
   
6.     def get_label(self):
   
7.         return self.label
   
8. 
   
9.     def get_output(self):
   
10.         self.output = self.perform_gate_logic()
    
11.         return self.output
    
12. 
    
13. 
    
14. class BinaryGate(LogicalGate):
    
15.     def __init__(self, label):
    
16.         super().__init__(label)
    
17.         self.pin_a = None
    
18.         self.pin_b = None
    
19. 
    
20.     def get_pin_a(self):
    
21.         if self.pin_a is None:
    
22.             return self.pin_a
    
23.         else:
    
24.             return self.pin_a.get_from().get_output()
    
25. 
    
26.     def get_pin_b(self):
    
27.         if self.pin_b is None:
    
28.             return self.pin_b
    
29.         else:
    
30.             return self.pin_b.get_from().get_output()
    
31. 
    
32.     def get_input(self):
    
33.         return self.get_pin_a()
    
34. 
    
35. 
    
36. class UnaryGate(LogicalGate):
    
37.     def __init__(self, label):
    
38.         super().__init__(label)
    
39.         self.pin = None
    
40. 
    
41.     def get_pin(self):
    
42.         return self.pin
    
43. 
    
44. 
    
45. class AndGate(BinaryGate):
    
46.     def __init__(self, label):
    
47.         super().__init__(label)
    
48. 
    
49.     def perform_gate_logic(self):
    
50.         a = self.get_pin_a()
    
51.         b = self.get_pin_b()
    
52.         if a == 1 and b == 1:
    
53.             return 1
    
54.         else:
    
55.             return 0
    
56. 
    
57.     def set_next_pin(self, source):
    
58.         if self.pin_a is None:
    
59.             self.pin_a = source
    
60.         else:
    
61.             if self.pin_b is None:
    
62.                 self.pin_b = source
    
63.             else:
    
64.                 raise RuntimeError("无法插入更多的连接器")
    
65. 
    
66. 
    
67. class Connector:
    
68.     def __init__(self, from_gate, to_gate):
    
69.         self.from_gate = from_gate
    
70.         self.to_gate = to_gate
    
71.         to_gate.set_next_pin(self)
    
72. 
    
73.     def get_from(self):
    
74.         return self.from_gate
    
75. 
    
76.     def get_to(self):
    
77.         return self.to_gate
    
78. 
    
79. 
    
80. e = AndGate("rr")
    
81. d = AndGate("rrrrr")
    
82. k = AndGate("uu")
    
83. a = Connector(k, e)
    
84. b = Connector(e, d)
    
85. print(d.get_output())
    

复制代码

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

陶远航

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

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

1. def __init__(self, fgate, tgate):
   
2.     self.fgate = tgate
   
3.     self.tgate = fgate
   
4.     tgate.setNextPin(self)

复制代码

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

1. print(k.getoutput())

复制代码

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