逆向思维的构造电路
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类的代码段，setNextPin(self, source)函数的设置原理，与 self.pinA.getFrom().getoutput()不是很了解，有呢为大神帮解释一下，也可讲解一下此代码的思路 在这段代码中， conector 类用于连接两个逻辑门。 setNextPin(self, source) 函数的作用是将一个逻辑门对象作为参数 source 传入，并将其设置为当前逻辑门对象的输入接口。
具体来说， setNextPin(self, source) 函数的实现逻辑如下：
· 首先，判断当前逻辑门对象的 pinA 属性是否为空。如果为空，说明该逻辑门对象的第一个输入接口还未连接，将 source 赋值给 pinA 属性。
· 如果 pinA 属性不为空，则判断 pinB 属性是否为空。如果为空，说明该逻辑门对象的第二个输入接口还未连接，将 source 赋值给 pinB 属性。
· 如果 pinB 属性也不为空，则抛出一个 RuntimeError 异常，表示不能再连接更多的输入接口。
这样，通过不断调用 setNextPin(self, source) 函数，可以将多个逻辑门对象连接起来，形成一个逻辑电路。
关于 self.pinA.getFrom().getoutput() ，这是一个链式调用的方式。假设 self.pinA 是一个连接到当前逻辑门对象的输入接口的连接器对象，那么 self.pinA.getFrom() 会返回连接器对象的起始逻辑门对象，而 getoutput() 方法则会返回该逻辑门对象的输出值。
总体来说，这段代码实现了逆向思维的构造电路，通过连接不同的逻辑门对象，可以实现各种逻辑功能的电路。 你的代码中涉及了逻辑门和连接器的模拟实现，让我来为你解释一下其中涉及到的一些概念和代码段。
首先，让我们先梳理一下主要的类和它们的关系：
1. `logicalgate` 类是一个通用的逻辑门类，拥有标签 (`label`) 和输出值 (`output`) 属性，以及获取标签和输出值的方法 (`getlabel` 和 `getoutput`)。
2. `Binarygate` 类继承了 `logicalgate` 类，表示一个有两个输入的逻辑门。它额外包含两个属性 `pinA` 和 `pinB`，分别代表两个输入接口。
3. `Unarygate` 类也继承了 `logicalgate` 类，表示一个只有一个输入的逻辑门，它包含一个属性 `pin` 代表输入接口。
4. `AndGate` 类继承了 `Binarygate` 类，表示一个与门，其 `performgatelogic` 方法实现了与门的逻辑，即只有当两个输入都为1时，输出为1。
5. `conector` 类用于连接两个逻辑门，它有一个构造函数 `__init__`，接受两个逻辑门对象作为参数，并将自己作为连接器连接到目标逻辑门上。
下面我们来解释一下你提到的两个代码段：
1. `self.pinA.getFrom().getoutput()`：
这段代码在 `Binarygate` 类中的 `getpinA` 和 `getpinB` 方法中用到。它的作用是获取当前输入接口 `pinA` 或 `pinB` 对应的逻辑门的输出值。解释步骤如下：
- `self.pinA` 或 `self.pinB` 代表当前的输入接口对象。
- `getFrom()` 方法返回连接器的起始逻辑门对象。
- `getoutput()` 方法返回起始逻辑门的输出值。
2. `setNextPin(self, source)`：
这是在 `AndGate` 类中的方法，用于将连接器连接到逻辑门的输入接口上。解释如下：
- `source` 是一个连接器对象，它连接了两个逻辑门。
- `if self.pinA == None:` 检查当前的 `pinA` 是否为空，如果是的话，将 `source` 赋值给 `pinA`，表示连接到了第一个输入接口。
- 否则，检查 `pinB` 是否为空，如果是的话，将 `source` 赋值给 `pinB`，表示连接到了第二个输入接口。
- 如果 `pinA` 和 `pinB` 都不为空，抛出运行时错误。
总的来说，这段代码实现了一个简单的逻辑门模拟器，可以创建不同类型的逻辑门，并通过连接器将它们连接起来。连接器负责将一个逻辑门的输出连接到另一个逻辑门的输入，从而模拟逻辑电路的运行。
页:
[1]