python 的构造电路

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):#继承父类的方法
    def __init__(self, label):#逻辑门要有标签,logicgate的子类Binarygate也不列外，所以这里要调用其父类的创造标签的方法，即super().__init__（labe),super()为其父类，否则就不能创造标签。
        super().__init__(label)#调用super().__init__（labe)后，就默认有self.label = label，self.output = None,父类的方法（函数）也有继承
        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:
            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()

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)


    def getFrom(self):
        return self.fgate

    def getTo(self):
        return self.tgate
   
      


        
e = AndGate("rr")
d = AndGate("rrrrr")
a = conector(e, d)
print(d.getoutput()) #从最后一个逻辑门开始运行，逆向思维

本人对于conector类的代码段不是很了解，有呢为大神帮解释一下，也可讲解一下此代码的思路

isdkz

conector类是用于连接两个逻辑门的类。它有两个属性：fgate和tgate，分别表示连接的起始逻辑门和目标逻辑门。在初始化时，通过调用tgate的setNextPin方法，将自身作为参数传递给tgate，从而建立起连接关系。

conector类还有两个方法：getFrom和getTo。getFrom方法返回fgate，即连接的起始逻辑门；getTo方法返回tgate，即连接的目标逻辑门。

在代码的最后，通过创建一个AndGate对象e和一个AndGate对象d，然后使用conector类将它们连接起来。最后打印d的输出值，即从最后一个逻辑门d开始运行，逆向思维。

整个代码的思路是建立一个逻辑门的类层次结构，包括父类logicalgate和其子类Binarygate和Unarygate。每个逻辑门类都有自己的标签、输入接口和输出接口。通过继承和重写方法，实现不同类型逻辑门的具体逻辑运算。通过conector类将多个逻辑门连接起来，形成一个电路。最后通过调用逻辑门的getoutput方法，从最后一个逻辑门开始运行整个电路，得到最终的输出值。

陶远航

你的代码是一个简单的逻辑门模拟器，它可以模拟与门（And Gate）的行为。我来解释一下你的代码中的关键部分：

1. **logicalgate 类**:
   - 这是一个通用的逻辑门类，它有一个标签和一个输出值。它有两个方法，`getlabel` 用于获取标签，`getoutput` 用于获取输出值。`getoutput` 方法依赖于 `performgatelogic` 方法，但这个方法在 `logicalgate` 中并没有具体的实现，因为每种逻辑门的算法都不一样。

2. **Binarygate 类**:
   - 这是 `logicalgate` 类的子类，它继承了父类的方法。
   - 它新增了两个属性 `pinA` 和 `pinB`，分别表示两个输入接口。
   - `getpinA` 和 `getpinB` 方法用于获取输入值，如果输入接口未连接，则会要求用户输入值。
  
3. **Unarygate 类**:
   - 这也是 `logicalgate` 类的子类，但是它只有一个输入接口。
   - 它新增了一个属性 `pin` 表示输入接口。
   - `getpin` 方法用于获取输入值，如果输入接口未连接，则会要求用户输入值。

4. **AndGate 类**:
   - 这是 `Binarygate` 类的子类，表示与门。
   - 它实现了 `performgatelogic` 方法，用于执行与门的逻辑运算。
   - `setNextPin` 方法用于将连接器连接到与门的输入接口。

5. **conector 类**:
   - 这是用于连接两个逻辑门的类。
   - 它在初始化时接收两个逻辑门作为参数，并将目标逻辑门的输入接口连接到源逻辑门上。
   - `getFrom` 方法返回连接器的源逻辑门。
   - `getTo` 方法返回连接器的目标逻辑门。

在你的示例中，你创建了两个与门 `e` 和 `d`，然后用连接器 `a` 将它们连接起来。最后，你打印了逻辑门 `d` 的输出。

如果你有关于 `conector` 类的疑惑，它的作用是用来连接两个逻辑门，让一个逻辑门的输出成为另一个逻辑门的输入。在这个例子中，`a` 连接了 `e` 和 `d`，使得 `e` 的输出成为 `d` 的输入。这样，当你调用 `d.getoutput()` 时，它会首先获取 `e` 的输出作为自己的输入，然后进行与门的逻辑运算得到最终的输出。