投稿
  1. 首页
  2. python

与或非门——python逻辑电路

code • 2022-4-25 • python • 阅读 56

与或非门——python逻辑电路,第1张

逻辑电路（一）

1.逻辑门（LogicGate）​​​​​​​

2.单输入逻辑门（UnaryGate）

3.双输入逻辑门（BinaryGate）

4.非门（NOTGate）

5.与门（ANDGate）

6.或门（ORGate）

7.异或门（XORGate）

8.连接器（Connector）

9.简单逻辑电路实例（Simple logic circuit example）

10.完整代码（Complete code）

11.参考资料（reference material）​​​​​​​​​​​​​​

简单的逻辑电路通常是由门电路构成，而门电路是用以实现基本逻辑运算和复合逻辑运算的单位电路，常用的门电路在逻辑功能上有非门（NOT Gate）、与门（ANDGate）、与非门（NANDGate）、或门（ORGate）、或非门（NORGate）、异或门（XORGate）。

为了实现门电路，我们可以依次创建各个门类，而根据其的共性与特性，可以将其组织成继承层次结构。

根据输入数量，可分为单输入逻辑门（UnaryGate）和双输入逻辑门（BinaryGate）。

单、双输入逻辑门又可归类为具有一种逻辑的门即逻辑门（LogicGate）。

1.逻辑门（LogicGate）

为实现其逻辑功能，每个门电路应有输出的值。为获取输出的值，门电路需要根据输入的值进行合理的逻辑运算，即需要一个逻辑运算的方法。但是该方法不必在逻辑门类中实现，因为不同的门电路应有不同的方法。当然，每个门电路都还有一个用于识别的标志(label)。

class LogicGate:
    """逻辑门"""

    def __init__(self, n):
        self.label = n  # 识别标志
        self.output = None  # 输出的值

    def label(self):  # 获取识别标志的方法
        return self.label

    def getoutput(self):  # 获取输出的值的方法
        # 将输出值交给一个逻辑运算的方法，等待子类逻辑门实现
        self.output = self.donelogic()
        return self.output
2.单输入逻辑门（UnaryGate）

构造子类时，应继承父类(LogicGate)，调用父类的构造方法，同时定义接收输入值的变量pin和接收输入值的方法getpin()：

如果输入值为空，则要求主动输入；否则

如果构造类时传入了输出值，则输出值即为传入值；

否则应为上一门电路的输出值。

class UnaryGate(LogicGate):  # 继承父类
    """单输入逻辑门"""

    def __init__(self, n, pin=None):
        super().__init__(n)  # 调用父类的构造方法

        self.pin = pin  # 接收输入的变量pin

    def getpin(self):
        if self.pin is None:    # 如果输入值为空，则要求主动输入
            return eval(input("请输入{}的pin值-->".format(self.label)))
        else:
            if self.pin == 1:   # 如果构造类时传入了输出值，则输出值即为传入值
                return 1
            elif self.pin == 0:
                return 0
            else:               # 否则应为上一门电路的输出值
                return self.pin.getoutput()

同理可以构造双输入逻辑门

3.双输入逻辑门（BinaryGate） 
class BinaryGate(LogicGate):
    """双输入逻辑门"""

    def __init__(self, n, pinA=None, pinB=None):
        super().__init__(n)  # 调用父类的构造方法

        self.pinA = pinA  # 接收输入的变量pinA
        self.pinB = pinB  # 接收输入的变量pinB

    def getpinA(self):
        if self.pinA is None:    # 如果输入值为空，则要求主动输入
            return eval(input("请输入{}的pinA值-->".format(self.label)))
        else:
            if self.pinA == 1:   # 如果构造类时传入了输出值，则输出值即为传入值
                return 1
            elif self.pinA == 0:
                return 0
            else:               # 否则应为上一门电路的输出值
                return self.pinA.getoutput()

    def getpinB(self):
        if self.pinB is None:    # 如果输入值为空，则要求主动输入
            return eval(input("请输入{}的pinB值-->".format(self.label)))
        else:
            if self.pinB == 1:   # 如果构造类时传入了输出值，则输出值即为传入值
                return 1
            elif self.pinB == 0:
                return 0
            else:               # 否则应为上一门电路的输出值
                return self.pinB.getoutput()
4.非门（NOTGate）

在此构建具体门类时，实现了实现逻辑功能的方法donelogic，即通过输入值进行逻辑运算得到输出值。

class NOTGate(UnaryGate):
    """非门"""

    def __init__(self, n, pin=None):
        super().__init__(n, pin)

    def donelogic(self):    # 实现 实现逻辑功能的方法
        i = self.getpin()   # 获取输入值
        self.pin = i        # 存储输入值
        if i == 1:          # 逻辑运算
            return 0
        else:
            return 1

同理可以构造与门、或门、异或门等

5.与门（ANDGate） 
class ANDGate(BinaryGate):
    """与门"""

    def __init__(self, n, pinA=None, pinB=None):
        super().__init__(n, pinA, pinB)

    def donelogic(self):
        a = self.getpinA()
        self.pinA = a
        b = self.getpinB()
        self.pinB = b
        if a == 1 and b == 1:
            return 1
        else:
            return 0
6.或门（ORGate） 
class ORGate(BinaryGate):
    """或门"""

    def __init__(self, n, pinA=None, pinB=None):
        super().__init__(n, pinA, pinB)

    def donelogic(self):
        a = self.getpinA()
        self.pinA = a
        b = self.getpinB()
        self.pinB = b
        if a == 0 and b == 0:
            return 0
        else:
            return 1
7.异或门（XORGate） 
class XORGate(BinaryGate):
    """异或门"""

    def __init__(self, n, pinA=None, pinB=None):
        super().__init__(n, pinA, pinB)

    def donelogic(self):
        a = self.getpinA()
        self.pinA = a
        b = self.getpinB()
        self.pinB = b
        if a == b:
            return 0
        else:
            return 1
8.连接器（Connector）

然而，在创建了各个门电路类后，要想使用门电路组成逻辑电路，就需要一个连接器类(Connector)将前一门电路(fromgate)与后一门电路(togate)连接起来，从而实现值的传递。而在实现连接器类之前，每个门电路类应该有一个方法setNextpin使得自身的引脚pin接收前一门电路fromgate，从而实现门电路的连接。(以UnaryGate为例)

    def setNextPin(self, source):
        if self.pin is None:
            self.pin = source
        else:
            print("连接失败：输入已满")

这样就可以创建连接器类。显然，每一个连接器对象包含fromgate和togate两个门电路实例。

class Connector:
    """连接器"""

    def __init__(self, fgate, tgate):
        self.fromgate = fgate   # 前一门电路实例
        self.togate = tgate     # 后一门电路实例

        tgate.setNextPin(fgate)    # 将前后门电路连接起来

    def getfrom(self):
        return self.fromgate

    def getto(self):
        return self.togate
9.简单逻辑电路实例（Simple logic circuit example） 

g1 = ANDGate("g1", 1, 0)
g2 = ORGate("g2", 1, 1)
g3 = XORGate("g3")
g4 = NOTGate("g4")
c1 = Connector(g1, g3)
c2 = Connector(g2, g3)
c3 = Connector(g3, g4)
print(g4.getoutput())    # 输出结果为 0
10.完整代码（Complete code） 
class LogicGate:
    """逻辑门"""

    def __init__(self, n):
        self.label = n  # 识别标志
        self.output = None  # 输出的值

    def label(self):  # 获取识别标志的方法
        return self.label

    def getoutput(self):  # 获取输出的值的方法
        # 将输出值交给一个逻辑运算的方法，等待子类逻辑门实现
        self.output = self.donelogic()
        return self.output


class UnaryGate(LogicGate):  # 继承父类
    """单输入逻辑门"""

    def __init__(self, n, pin=None):
        super().__init__(n)  # 调用父类的构造方法

        self.pin = pin  # 接收输入的变量pin

    def getpin(self):
        if self.pin is None:    # 如果输入值为空，则要求主动输入
            return eval(input("请输入{}的pin值-->".format(self.label)))
        else:
            if self.pin == 1:   # 如果构造类时传入了输出值，则输出值即为传入值
                return 1
            elif self.pin == 0:
                return 0
            else:               # 否则应为上一门电路的输出值
                return self.pin.getoutput()

    def setNextPin(self, source):
        if self.pin is None:
            self.pin = source
        else:
            print("连接失败：输入已满")


class BinaryGate(LogicGate):
    """双输入逻辑门"""

    def __init__(self, n, pinA=None, pinB=None):
        super().__init__(n)  # 调用父类的构造方法

        self.pinA = pinA  # 接收输入的变量pinA
        self.pinB = pinB  # 接收输入的变量pinB

    def getpinA(self):
        if self.pinA is None:    # 如果输入值为空，则要求主动输入
            return eval(input("请输入{}的pinA值-->".format(self.label)))
        else:
            if self.pinA == 1:   # 如果构造类时传入了输出值，则输出值即为传入值
                return 1
            elif self.pinA == 0:
                return 0
            else:               # 否则应为上一门电路的输出值
                return self.pinA.getoutput()

    def getpinB(self):
        if self.pinB is None:    # 如果输入值为空，则要求主动输入
            return eval(input("请输入{}的pinB值-->".format(self.label)))
        else:
            if self.pinB == 1:   # 如果构造类时传入了输出值，则输出值即为传入值
                return 1
            elif self.pinB == 0:
                return 0
            else:               # 否则应为上一门电路的输出值
                return self.pinB.getoutput()

    def setNextPin(self, source):
        if self.pinA is None:
            self.pinA = source
        else:
            if self.pinB is None:
                self.pinB = source
            else:
                raise RuntimeError("连接失败：输入已满")


class NOTGate(UnaryGate):
    """非门"""

    def __init__(self, n, pin=None):
        super().__init__(n, pin)

    def donelogic(self):    # 实现 实现逻辑功能的方法
        i = self.getpin()   # 获取输入值
        self.pin = i        # 存储输入值
        if i == 1:          # 实现
            return 0
        else:
            return 1


class ANDGate(BinaryGate):
    """与门"""

    def __init__(self, n, pinA=None, pinB=None):
        super().__init__(n, pinA, pinB)

    def donelogic(self):
        a = self.getpinA()
        self.pinA = a
        b = self.getpinB()
        self.pinB = b
        if a == 1 and b == 1:
            return 1
        else:
            return 0


class NANDGate(BinaryGate):
    """与非门"""

    def __init__(self, n, pinA=None, pinB=None):
        super().__init__(n, pinA, pinB)

    def donelogic(self):
        a = self.getpinA()
        self.pinA = a
        b = self.getpinB()
        self.pinB = b
        if a == 1 and b == 1:
            return 0
        else:
            return 1


class ORGate(BinaryGate):
    """或门"""

    def __init__(self, n, pinA=None, pinB=None):
        super().__init__(n, pinA, pinB)

    def donelogic(self):
        a = self.getpinA()
        self.pinA = a
        b = self.getpinB()
        self.pinB = b
        if a == 0 and b == 0:
            return 0
        else:
            return 1


class XORGate(BinaryGate):
    """异或门"""

    def __init__(self, n, pinA=None, pinB=None):
        super().__init__(n, pinA, pinB)

    def donelogic(self):
        a = self.getpinA()
        self.pinA = a
        b = self.getpinB()
        self.pinB = b
        if a == b:
            return 0
        else:
            return 1


class Connector:
    """连接器"""

    def __init__(self, fgate, tgate):
        self.fromgate = fgate   # 前一门电路实例
        self.togate = tgate     # 后一门电路实例

        tgate.setNextPin(fgate)

    def getfrom(self):
        return self.fromgate

    def getto(self):
        return self.togate


g1 = ANDGate("g1", 1, 0)
g2 = ORGate("g2", 1, 1)
g3 = XORGate("g3")
g4 = NOTGate("g4")
c1 = Connector(g1, g3)
c2 = Connector(g2, g3)
c3 = Connector(g3, g4)
print(g4.getoutput())
11.参考资料（reference material）

https://baike.baidu.com/item/逻辑电路/446127?fr=aladdin

https://baike.baidu.com/item/逻辑门

https://baike.baidu.com/item/门电路

python数据结构与算法分析（第2版）

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/718274.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
code code 管理员组
0 0
上一篇 2022-04-25
下一篇 2022-04-25

发表评论

登录后才能评论

评论列表（0条）

保存