继承的逻辑门实现

最新推荐文章于 2025-03-06 23:43:58 发布

原创最新推荐文章于 2025-03-06 23:43:58 发布 · 482 阅读

2 ·

本内容遵循CC 4.0 BY-SA版权协议

本文通过Python展示了逻辑门（与门、或门、非门）的继承实现，包括父类逻辑门的设计，二元门和一元门的抽象，以及具体的门类。文章还讨论了逻辑门的属性、输入输出方法，并给出了连接器的概念，用于在逻辑门之间传递数据。

前言

本文的编程语言是 Python, 但是继承的思想大致相同，其他面向对象语言可以借鉴。

逻辑门的说明

逻辑门

逻辑门有三种：

与门
或门
非门

在Python里面有直接体现，分别为and、or、not。在C/C++中为 &&、||、!。

逻辑门的抽象

可以知道与门和或门的输入端都是两项，非门的输入端只有一个。那么就可以在这一层进行抽象，将逻辑门分类为

二元门
一元门

再次抽象就是顶部的逻辑门了，所以对抽象的倒推就可以得出逻辑门的继承关系如图：

继承关系

逻辑门的属性

一个逻辑门首先肯定是会得到输入，无论是一元还是二元。为了统计所有的输入，可以使用一个列表储存输入。

然后是会有一个输出，这个输出可以是直接使用方法返回，也可以是运行对象的方法后，特地的获取这个属性。为了简短代码，这里选择直接用方法返回。

最后，一些无关紧要的属性。比如逻辑门的编号或者名字。

逻辑门的方法

在下面代码具体说明。

代码

父类逻辑门

基本结构

按照标准流程创建一个父类 LogicGate，并且构建基本属性，以及一个返回名字的方法。

class LogicGate(object):
    def __init__(self, name):
        '''
            name : 逻辑门的名字
        '''
        super().__init__()
        self.name = name
        sele.Pins = []
    

    def getLogicGateName(self):
        return self.name

输入方法

由于在前面我使用的是一个列表来存储所有的输入，那么在方法中就可以使用一个循环来遍历列表内所有的输入接口，并且提示用户输入和存储用户的输入。

def getPin(self):
    # 用户输入接口
    Pins_ = self.Pins[:] ## 在对列表遍历时不能修改列表的值，所以复制一个列表来遍历
    for i, Pin in enumerate(Pins_):
        self.Pins[i] = int(input("{}.Pin{} ->".format(self.getLogicGateName(), i)))

输出方法

def getFinalResult(self):
    return self.operationResult()

可以发现我并没有写下operationResult方法，因为这会用来处理具体的逻辑门，每一个逻辑门都是不同的，但是这里可以未定义先使用，因为这个方法最后会继承到每一个具体逻辑门上。

一、二元逻辑门

一、二元逻辑门不会有具体的方法，但是属性会更加具体，也就是会规定输入的端口数

class BinaryGate(LogicGate):
    def __init__(self, name):
        super().__init__(name)

        self.Pins = [None, None]


class UnaryGate(LogicGate):
    def __init__(self, name):
        super().__init__(name)

        self.Pins = [None]

一二元逻辑门都是继承自父类 LogicGate。所以调用super().__init__()将超类的属性初始化，其实也就是 name 属性。

具体的门

最后继承到具体的门，只剩下前面提到过的operationResult()方法。那么就可以根据各种具体的门来集体写出逻辑。

class AndGate(BinaryGate):
    ''' 与 '''
    def __init__(self, name):
        super().__init__(name)
    
    
    def operationResult(self):

        self.getPin()

        return self.Pins[0] and self.Pins[1]


class OrGate(BinaryGate):
    ''' 或 '''
    def __init__(self, name):
        super().__init__(name)
    
    def operationResult(self):

        self.getPin()

        return self.Pins[0] or self.Pins[1]


class NotGate(UnaryGate):
    ''' 非 '''
    def __init__(self, name):
        super().__init__(name)

    
    def operationResult(self):
        self.getPin()

        return not self.Pins[0]

注意前两个和第三个所继承的父类是不同的，但他们都需要调用超类的初始化方法，来初始化继承的属性。在具体的操作方法里面需要先调用输入方法，这也是从超类中继承下来的，但是在具体的门里面会根据名字和列表（也就是输入端的储存）的不同而有不同的操作。

运行情况


a1 = AndGate("A1")
print(a1.getFinalResult())

## 运行结果
A1.Pin0 ->1
A1.Pin1 ->0
0

其他

如果想要构建一个逻辑框架，比如

逻辑框架

首先需要一个连接器来连接两个逻辑门之间的数据传输。其次对逻辑门本身需要一些修改使得它本身可以接收连接器的数据。最后修改原本的输入方式，已经被连接器修改的数据不会对用户发起询问。

连接器

class Connector(object):
    def __init__(self, source, target):
        self.source = source
        self.target = target

        target.getFromConnector(self)

    
    def getFromResult(self):
        return self.source.getFinalResult()

在连接器中，需要接收来源逻辑门以及目标逻辑门，并且立马对目标逻辑门的输入端进行修改，对输入端占位。而这个函数就是暴露出来的接口，实现方法如下

## class LogicGate
def getFromConnector(self, connector):
    Pins_ = self.Pins[:]
    for i, Pin in enumerate(Pins_):
        if self.Pins[i] == None:
            self.Pins[i] = connector.getFromResult()
            break
    
    else:
        raise RuntimeError("Error : 满了")

这个其实和原本的输入大同小异，除了只可以输入一次，因为连接器只能传输一次数据。

因为在原本操作数据中必然会调用一次用户输入，为了连接器数据不被修改，所以需要在用户输入加一条限制条件。

def getPin(self):
        # 用户输入接口
        Pins_ = self.Pins[:]
        for i, Pin in enumerate(Pins_):
            if self.Pins[i] == None: ## 新加的条件
                self.Pins[i] = int(input("{}.Pin{} ->".format(self.getLogicGateName(), i)))

最后就可以试一下上图所示的逻辑图

a1 = AndGate("A1")
a2 = AndGate("A2")
o1 = OrGate("O1")
n1 = NotGate("N1")

c1 = Connector(a1, o1)
c2 = Connector(a2, o1)
c3 = Connector(o1, n1)

print(n1.getFinalResult())

# 运行结果
A1.Pin0 ->1
A1.Pin1 ->0
A2.Pin0 ->0
A2.Pin1 ->1
True

完整代码

class LogicGate(object):
    def __init__(self, name):
        '''
            name : 逻辑门的名字
        '''
        super().__init__()
        self.name = name
        self.Pins = []


    def getLogicGateName(self):
        return self.name


    def getFinalResult(self):
        return self.operationResult()
    

    def getPin(self):
        # 用户输入接口
        Pins_ = self.Pins[:]
        for i, Pin in enumerate(Pins_):
            if self.Pins[i] == None:
                self.Pins[i] = int(input("{}.Pin{} ->".format(self.getLogicGateName(), i)))
    

    def getFromConnector(self, connector):
        Pins_ = self.Pins[:]
        for i, Pin in enumerate(Pins_):
            if self.Pins[i] == None:
                self.Pins[i] = connector.getFromResult()
                break
        
        else:
            raise RuntimeError("Error : 满了")


class BinaryGate(LogicGate):
    ''' 二元 '''
    def __init__(self, name):
        super().__init__(name)

        self.Pins = [None, None]


class UnaryGate(LogicGate):
    ''' 一元 '''
    def __init__(self, name):
        super().__init__(name)

        self.Pins = [None]
    

class AndGate(BinaryGate):
    ''' 与 '''
    def __init__(self, name):
        super().__init__(name)
    
    
    def operationResult(self):

        self.getPin()

        return self.Pins[0] and self.Pins[1]


class OrGate(BinaryGate):
    ''' 或 '''
    def __init__(self, name):
        super().__init__(name)
    
    def operationResult(self):

        self.getPin()

        return self.Pins[0] or self.Pins[1]


class NotGate(UnaryGate):
    ''' 非 '''
    def __init__(self, name):
        super().__init__(name)

    
    def operationResult(self):
        self.getPin()

        return not self.Pins[0]


class Connector(object):
    ''' 连接器 '''
    def __init__(self, source, target):
        self.source = source
        self.target = target

        target.getFromConnector(self)

    
    def getFromResult(self):
        return self.source.getFinalResult()


a1 = AndGate("A1")
a2 = AndGate("A2")
o1 = OrGate("O1")
n1 = NotGate("N1")

c1 = Connector(a1, o1)
c2 = Connector(a2, o1)
c3 = Connector(o1, n1)

print(n1.getFinalResult())