Python 逻辑门原理与代码实现详解

周末不加班

发布时间：2026-10-12| 3人浏览过

原创

本文详细介绍在 Python 中如何实现并验证七种基本逻辑门（与、或、非、与非、或非、异或、同或）。通过封装函数与打印真值表的完整代码示例，帮助开发者理解布尔代数基础、掌握条件判断逻辑，并为后续学习数字电路及底层算法提供直观的编程映射方案。

逻辑门核心原理与 Python 映射

逻辑门是数字电路的基本构建块，通常接收一或多个二进制输入（高电平 1 / 低电平 0），并根据预设规则输出单个二进制结果。在软件工程中，逻辑门可直接映射为布尔运算与条件分支，用于构建复杂的决策树、状态机及底层算法。以下通过 Python 代码逐一对应实现七种标准逻辑门，并提供完整的真值表输出便于核对。

1. 与门（AND Gate）

当且仅当两个输入均为 1 时，输出为 1；其余情况输出为 0。它是最基础的布尔合取运算。

def AND(a, b):
    return bool(a == 1 and b == 1)

if __name__ == '__main__':
    print(AND(1, 1))
    print("+---------------+--------+")
    print(" | AND Table | Result |")
    print("+---------------+--------+")
    print(f"| A=0 B=0     | {AND(0, 0)}      |")
    print(f"| A=0 B=1     | {AND(0, 1)}      |")
    print(f"| A=1 B=0     | {AND(1, 0)}      |")
    print(f"| A=1 B=1     | {AND(1, 1)}      |")
    print("+---------------+--------+")

True
+---------------+--------+
| AND Table | Result |
+---------------+--------+
| A=0 B=0 | False |
| A=0 B=1 | False |
| A=1 B=0 | False |
| A=1 B=1 | True |
+---------------+--------+

2. 与非门（NAND Gate）

与门的反相形式。仅在两个输入同时为 1 时输出 0，其他组合均输出 1。它是通用逻辑门，可单独组合实现任意布尔函数。

def NAND(a, b):
    return not bool(a == 1 and b == 1)

if __name__ == '__main__':
    print(NAND(1, 0))
    print("+---------------+--------+")
    print(" | NAND Table | Result |")
    print("+---------------+--------+")
    print(f"| A=0 B=0     | {NAND(0, 0)}      |")
    print(f"| A=0 B=1     | {NAND(0, 1)}      |")
    print(f"| A=1 B=0     | {NAND(1, 0)}      |")
    print(f"| A=1 B=1     | {NAND(1, 1)}      |")
    print("+---------------+--------+")

True
+---------------+--------+
| NAND Table | Result |
+---------------+--------+
| A=0 B=0 | True |
| A=0 B=1 | True |
| A=1 B=0 | True |
| A=1 B=1 | False |
+---------------+--------+

3. 或门（OR Gate）

只要有一个输入为 1，输出即为 1；仅当双输入均为 0 时输出 0。对应布尔析取运算。

def OR(a, b):
    return bool(a == 1 or b == 1)

if __name__ == '__main__':
    print(OR(0, 0))
    print("+---------------+--------+")
    print(" | OR Table | Result |")
    print("+---------------+--------+")
    print(f"| A=0 B=0     | {OR(0, 0)}      |")
    print(f"| A=0 B=1     | {OR(0, 1)}      |")
    print(f"| A=1 B=0     | {OR(1, 0)}      |")
    print(f"| A=1 B=1     | {OR(1, 1)}      |")
    print("+---------------+--------+")

False
+---------------+--------+
| OR Table | Result |
+---------------+--------+
| A=0 B=0 | False |
| A=0 B=1 | True |
| A=1 B=0 | True |
| A=1 B=1 | True |
+---------------+--------+

4. 异或门（XOR Gate）

两个输入不同则输出 1，相同则输出 0。常用于奇偶校验、无进位加法及加密基础运算。

def XOR(a, b):
    return int(a != b)

if __name__ == '__main__':
    print(XOR(5, 5))
    print("+---------------+--------+")
    print(" | XOR Table | Result |")
    print("+---------------+--------+")
    print(f"| A=0 B=0     | {XOR(0, 0)}      |")
    print(f"| A=0 B=1     | {XOR(0, 1)}      |")
    print(f"| A=1 B=0     | {XOR(1, 0)}      |")
    print(f"| A=1 B=1     | {XOR(1, 1)}      |")
    print("+---------------+--------+")

0
+---------------+--------+
| XOR Table | Result |
+---------------+--------+
| A=0 B=0 | 0 |
| A=0 B=1 | 1 |
| A=1 B=0 | 1 |
| A=1 B=1 | 0 |
+---------------+--------+

5. 非门（NOT Gate）

单输入反相器。输入为 1 时输出 0，输入为 0 时输出 1。是构建所有复合逻辑门的基础组件。

def NOT(a):
    return not a

if __name__ == '__main__':
    print(NOT(0))
    print("+---------+--------+")
    print(" | NOT Table | Result |")
    print("+---------+--------+")
    print(f"| A=0     | {NOT(False)}      |")
    print(f"| A=1     | {NOT(True)}      |")
    print("+---------+--------+")

1
+---------+--------+
| NOT Table | Result |
+---------+--------+
| A=0 | True |
| A=1 | False |
+---------+--------+

6. 或非门（NOR Gate）

或门的反相形式。仅当两个输入均为 0 时输出 1，其余情况输出 0。同样具备逻辑完备性。

def NOR(a, b):
    return not bool(a == 0 or b == 0)

if __name__ == '__main__':
    print(NOR(0, 0))
    print("+---------------+--------+")
    print(" | NOR Table | Result |")
    print("+---------------+--------+")
    print(f"| A=0 B=0     | {NOR(0, 0)}      |")
    print(f"| A=0 B=1     | {NOR(0, 1)}      |")
    print(f"| A=1 B=0     | {NOR(1, 0)}      |")
    print(f"| A=1 B=1     | {NOR(1, 1)}      |")
    print("+---------------+--------+")

True
+---------------+--------+
| NOR Table | Result |
+---------------+--------+
| A=0 B=0 | True |
| A=0 B=1 | False |
| A=1 B=0 | False |
| A=1 B=1 | False |
+---------------+--------+

7. 同或门（XNOR Gate）

异或门的反相形式。两输入相同时输出 1，不同时输出 0。常用于相等比较电路与数据一致性校验。

def XNOR(a, b):
    return int(a == b)

if __name__ == '__main__':
    print(XNOR(1, 1))
    print("+---------------+--------+")
    print(" | XNOR Table | Result |")
    print("+---------------+--------+")
    print(f"| A=0 B=0     | {XNOR(0, 0)}      |")
    print(f"| A=0 B=1     | {XNOR(0, 1)}      |")
    print(f"| A=1 B=0     | {XNOR(1, 0)}      |")
    print(f"| A=1 B=1     | {XNOR(1, 1)}      |")
    print("+---------------+--------+")

1
+---------------+--------+
| XNOR Table | Result |
+---------------+--------+
| A=0 B=0 | 1 |
| A=0 B=1 | 0 |
| A=1 B=0 | 0 |
| A=1 B=1 | 1 |
+---------------+--------+

验证执行与常见排错

上述代码均可在任意安装了 Python 3.6+ 的环境中直接保存为 `.py` 文件运行。若遇到输出类型不符或断言失败，请注意：

布尔值与整数混用：Python 中 bool 是 int 的子类，True == 1 为真。对比逻辑门阈值时建议统一转为 int() 或显式使用布尔值，避免隐式转换干扰判断。
空字符串或 None 传入：若外部数据源可能传入非 0/1 值，应在函数入口添加异常捕获或数据清洗：a = int(a) if a in (0, 1) else raise ValueError。
终端乱码对齐：部分老旧环境对制表符解析不一致，可将 f-string 替换为固定宽度占位符或使用格式化库控制列宽。

总结

通过封装独立的逻辑门函数并打印完整真值表，可以将抽象的数字电路规则直观转化为可执行的 Python 代码。这不仅巩固了对布尔运算的理解，也为后续编写硬件描述语言仿真、状态机跳转判断以及底层位操作提供了标准化参考。以上就是 Python 逻辑门原理与代码实现详解的详细内容，更多关于 Python 布尔运算与数字逻辑的资料请关注本站其它相关文章！