Question

我目前正在自学Python，我正在阅读“使用算法和数据结构解决问题”（Brad Miller，David Ranum）。我偶然发现了继承的基本例子。虽然我可以看到它的作用，但我需要一个解释，它实际上是如何工作的。守则如下：

class LogicGate:

    def __init__(self,n):
        self.name = n
        self.output = None

    def getName(self):
        return self.name

    def getOutput(self):
        self.output = self.performGateLogic()
        return self.output


class BinaryGate(LogicGate):

    def __init__(self,n):
        LogicGate.__init__(self,n)

        self.pinA = None
        self.pinB = None

    def getPinA(self):
        if self.pinA == None:
            return int(input("Enter Pin A input for gate "+self.getName()+"-->"))
        else:
            return self.pinA.getFrom().getOutput()

    def getPinB(self):
        if self.pinB == None:
            return int(input("Enter Pin B input for gate "+self.getName()+"-->"))
        else:
            return self.pinB.getFrom().getOutput()

    def setNextPin(self,source):
        if self.pinA == None:
            self.pinA = source
        else:
            if self.pinB == None:
                self.pinB = source
            else:
                print("Cannot Connect: NO EMPTY PINS on this gate")


class AndGate(BinaryGate):

    def __init__(self,n):
        BinaryGate.__init__(self,n)

    def performGateLogic(self):

        a = self.getPinA()
        b = self.getPinB()
        if a==1 and b==1:
            return 1
        else:
            return 0

class OrGate(BinaryGate):

    def __init__(self,n):
        BinaryGate.__init__(self,n)

    def performGateLogic(self):

        a = self.getPinA()
        b = self.getPinB()
        if a ==1 or b==1:
            return 1
        else:
            return 0

class UnaryGate(LogicGate):

    def __init__(self,n):
        LogicGate.__init__(self,n)

        self.pin = None

    def getPin(self):
        if self.pin == None:
            return int(input("Enter Pin input for gate "+self.getName()+"-->"))
        else:
            return self.pin.getFrom().getOutput()

    def setNextPin(self,source):
        if self.pin == None:
            self.pin = source
        else:
            print("Cannot Connect: NO EMPTY PINS on this gate")


class NotGate(UnaryGate):

    def __init__(self,n):
        UnaryGate.__init__(self,n)

    def performGateLogic(self):
        if self.getPin():
            return 0
        else:
            return 1


class Connector:

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

        tgate.setNextPin(self)

    def getFrom(self):
        return self.fromgate

    def getTo(self):
        return self.togate


def main():
   g1 = AndGate("G1")
   g2 = AndGate("G2")
   g3 = OrGate("G3")
   g4 = NotGate("G4")
   c1 = Connector(g1,g3)
   c2 = Connector(g2,g3)
   c3 = Connector(g3,g4)
   print(g4.getOutput())

main()

我对tgate.setNextPin(self)班Connector中的__init__语句感到非常怀疑。这是方法调用吗？如果是，为什么只用一个参数调用，setNexPin和UnaryGate类BinaryGate中的(self, source)函数实际需要两个参数？ fromgate变量如何最终成为source arrgument？这个陈述实际上是“初始化”的，是什么？

接下来让我烦恼的是，例如，在我声明print(type(g4))之前我g4.getOutput()，我得到<class '__main__.OrGate'>，但是当g4.getOutput()开始时，函数开始调用相互之间，为了调用getPin函数，如果我将print (self.pinA)放在return self.pinA.getFrom().getOutput()之前，我会得到<__main__.Connector object at 0x2b387e2f74d0>，尽管self.Pin是来自g4的变量{1}} OrGate个实例。如何从一个类实例中的一个变量成为另一个类的对象，而不继承它？这是否具有setNextPin()功能的作品？

有人可以向我解释这一点，因为我是OOP的新手并且被这段代码所困扰。谢谢。

Answer 1

关于您的第一个问题，tgate.setNextPin(self)是方法调用。 tgate是一个对象，可能是其中一种门类型的实例。当您访问instance.method时，Python会为您提供一个＆＃34;绑定方法＆＃34;对象，它的工作方式与函数非常相似，但在实际调用时将实例作为第一个参数。因此，tgate.setNextPin(self)实际上正在调用type(tgate).setNextPin(tgate, self)

你的第二个问题似乎反映了对什么属性的误解。不要求对象的属性属于自己的类型。在各种LogicGate子类中，pin / pinA / pinB属性要么是None（表示应该提示用户输入值）或Connector的实例（或其他具有getFrom方法的实例）。这些值都不是LogicGate实例。

至于您看到的Connector实例的来源，它将成为您创建的c1到c3值之一。 Connector个实例将自己安装到tgate参数的引脚上，并在第一个问题中询问您setNextPin call。我无法与您正在查看的g4门进行通话，因为它似乎与您在示例代码g4函数中创建的main()变量不同（它是一种不同的类型），但我怀疑它是按设计工作的，而且它有点令人困惑。尝试通过pinX访问g4.pinA属性，而不是在方法内部检查它们，这样可能会减少混淆。

这里有一些带有输出的代码可以帮助你更好地理解事情：

# create a few gates
g1 = AndGate("G1")
g2 = OrGate("G2")

# at this point, no connectors have been hooked up, so all pinX attrs are None:
print("G1 pins:", g1.pinA, g1.pinB) # "None, None"
print("G2 pins:", g2.pinA, g2.pinB) # "None, None"

# test that the gates work independently of each other:
print("G1 output:", g1.getOutput()) # will prompt for two inputs, then print their AND
print("G2 output:", g2.getOutput()) # will prompt for two inputs, then print their OR

# create a connection between the gates
c1 = Connector(g1, g2) # connects output of g1 to first available pin (pinA) of g2

# we can see that g2.pinA has changed
print("G2 pins after connection:", g2.pinA, g2.pinB)
   # "<__main__.Connector object at SomeHexAddress>, None"

# now, if we get g2's output, it will automatically request g1's output via the Connector
print("G2 output:", g2.getOutput())
   # will prompt for 2 G1 inputs, and one G2 input and print (G1_A AND G1_B) OR G2_B

如果您想更多地使用这些类，可能需要在某些或所有类中添加__str__（和/或__repr__）方法。 Python使用__str__在必要时将类的实例转换为字符串（例如，当您将其作为参数传递给print或str.format时）。这是__str__的快速Connector实施：

def __str__(self):
    return "Connector between {} and {}".format(self.fgate.name, self.tgate.name)

Python类继承/逻辑门＆amp;电路示例

1 个答案: