深入理解Python的`if __name__ == ‘__main__‘`：它到底做了什么？

闲人编程2025-09-29 21:53

目录

  • 深入理解Python的`if name == 'main'`：它到底做了什么？
      1. 引言：一个无处不在的"魔法语句"
      1. Python脚本的执行方式与`name`属性
      • 2.1 Python模块的两种角色
      • 2.2 `name`：模块的"身份证"
      • 2.3 实践验证：观察`name`的变化
      1. `if name == 'main'` 的作用与原理
      • 3.1 解决什么问题？------避免导入时的副作用
      • 3.2 正确的做法：使用"保护语句"
      1. 深入应用场景与最佳实践
      • 4.1 场景一：模块的单元测试与自检
      • 4.2 场景二：创建命令行工具
      • 4.3 场景三：作为应用程序的入口点
      1. 常见误区与疑难解答
      • 5.1 误区一：认为它是程序的"开始"
      • 5.2 误区二：在函数内部使用
      • 5.3 `main`模块的命名空间
      1. 完整代码示例：一个综合性的迷你项目
      • 代码说明与自查
      1. 总结

『宝藏代码胶囊开张啦！』------ 我的 CodeCapsule 来咯！✨

写代码不再头疼！我的新站点 CodeCapsule 主打一个 "白菜价"+"量身定制"！无论是卡脖子的毕设/课设/文献复现，需要灵光一现的算法改进，还是想给项目加个"外挂"，这里都有便宜又好用的代码方案等你发现！低成本，高适配，助你轻松通关！速来围观 👉 CodeCapsule官网

版权声明：本文为CSDN博主「闲人编程」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

原文链接：https://blog.csdn.net/qq_42568323/article/details/152121340

深入理解Python的if __name__ == '__main__'：它到底做了什么？

1. 引言：一个无处不在的"魔法语句"

在学习Python的过程中，无论是阅读他人的代码，还是编写自己的脚本，你几乎总会遇到下面这段看似有些"神秘"的代码：

python 复制代码 
# 一些函数和类的定义...

if __name__ == '__main__':
    # 在这里写一些代码
    main()

这段代码，特别是 if __name__ == '__main__' 这个条件判断，是Python编程中一个极其重要且基础的概念。对于初学者来说，它可能像一个未解之谜：这个 __name__ 和 __main__ 到底是什么？为什么要把主要的执行逻辑放在这个if语句块里？

理解这个语句，是区分Python新手和成熟开发者的一个标志。它直接关系到代码的组织方式、可重用性以及模块化设计。本文将深入剖析这条语句背后的机制，解释其存在的必要性，并通过丰富的示例展示其最佳实践。

本博客目标：读完本文，你将彻底明白：

  • __name__ 是什么？
  • 为什么需要 if __name__ == '__main__'？
  • 如何在实际项目中有效地使用它？

2. Python脚本的执行方式与__name__属性

要理解 if __name__ == '__main__'，首先必须了解Python解释器执行代码的两种主要方式以及一个关键的内置属性 __name__。

2.1 Python模块的两种角色

一个Python文件（以.py为后缀）可以被看作一个模块（Module）。这个模块可以扮演两种角色：

  1. 作为主程序直接执行 ：当你通过命令行（如 python my_script.py）运行一个脚本时，该脚本就是作为主程序执行的。
  2. 作为模块被导入到其他代码中 ：当一个模块被另一个模块使用 import 语句引入时（如 import my_module），它扮演的是被导入模块的角色。

2.2 __name__：模块的"身份证"

Python为每个模块都定义了一个内置的字符串属性 __name__。这个属性的值决定了该模块当前扮演的角色。

  • 当一个模块作为主程序直接执行时 ，Python解释器会将该模块的 __name__ 属性设置为字符串 '__main__'。
  • 当一个模块被导入到其他模块中时 ，Python解释器会将该模块的 __name__ 属性设置为其模块名 （即文件名去掉.py后缀）。

我们可以通过一个简单的实验来验证这一点。

2.3 实践验证：观察__name__的变化

创建两个Python文件：module_a.py 和 module_b.py。

文件：module_a.py

python 复制代码 
# module_a.py
print(f"在 module_a 中，__name__ 的值是：'{__name__}'")

文件：module_b.py

python 复制代码 
# module_b.py
print(f"在 module_b 中，__name__ 的值是：'{__name__}'")

print("正在导入 module_a...")
import module_a

现在，我们分别运行它们：

  1. 直接运行 module_a.py：

    bash 复制代码 
    python module_a.py

    输出：

    复制代码 
    在 module_a 中，__name__ 的值是：'__main__'

    因为 module_a.py 是直接运行的主程序 ，所以其 __name__ 为 '__main__'。

  2. 直接运行 module_b.py：

    bash 复制代码 
    python module_b.py

    输出：

    复制代码 
    在 module_b 中，__name__ 的值是：'__main__'
正在导入 module_a...
在 module_a 中，__name__ 的值是：'module_a'

    首先，module_b.py 作为主程序，其 __name__ 为 '__main__'。接着，它导入了 module_a。在导入过程中，module_a.py 的代码被执行，但此时它的角色是被导入的模块 ，所以其 __name__ 是它的模块名 'module_a'。

这个简单的实验清晰地展示了 __name__ 属性如何根据模块的执行方式而变化。

3. if __name__ == '__main__' 的作用与原理

现在，我们已经掌握了 __name__ 属性的行为规律。if __name__ == '__main__' 这个条件判断的原理就变得非常简单了。

它的核心作用就是：判断当前模块是否是正在被直接运行的主程序。

  • 如果条件为真（True） ：意味着这个文件是被直接运行的（python this_file.py）。那么，if 语句块内的代码将会被执行。
  • 如果条件为假（False） ：意味着这个文件是被导入的（import this_file）。那么，if 语句块内的代码不会被执行。

3.1 解决什么问题？------避免导入时的副作用

这个机制最主要的价值在于，它允许我们编写既可以独立运行，又可以被其他模块安全导入的代码，而不会在导入时产生意外的"副作用"。

让我们看一个反面教材 ，如果不使用 if __name__ == '__main__' 会发生什么。

假设我们有一个工具模块 math_utils.py，它包含一个计算圆面积的函数。我们还希望测试这个函数，所以直接在文件底部调用了它。

文件：math_utils_bad.py（有问题的版本）

python 复制代码 
# math_utils_bad.py

def calculate_circle_area(radius):
    """计算圆的面积"""
    area = 3.14159 * radius ** 2
    return area

# 直接调用函数进行测试
result = calculate_circle_area(5)
print(f"半径为5的圆面积是：{result}")

现在，如果我们直接运行它，一切正常：

bash 复制代码 
python math_utils_bad.py

输出：

复制代码 
半径为5的圆面积是：78.53975

但是，如果另一个项目需要复用这个强大的 calculate_circle_area 函数，问题就来了。

文件：my_project.py

python 复制代码 
# my_project.py
print("我的项目开始运行...")
print("导入 math_utils_bad 模块...")

import math_utils_bad # 注意这里导入了有问题的模块

print("导入完成。")
# ... 使用 math_utils_bad.calculate_circle_area(10) 进行其他计算

运行 my_project.py：

bash 复制代码 
python my_project.py

输出：

复制代码 
我的项目开始运行...
导入 math_utils_bad 模块...
半径为5的圆面积是：78.53975 # <-- 意外的输出！
导入完成。

看到了吗？我们只是想在 my_project.py 中导入 math_utils_bad 模块来使用其函数，但导入这个动作本身，就触发了那个测试性的 print 语句。这就是所谓的"副作用"。在大型项目中，如果每个模块都这样，会导致输出混乱、性能下降，甚至逻辑错误。

3.2 正确的做法：使用"保护语句"

现在，我们用 if __name__ == '__main__' 来修复上面的 math_utils.py。

文件：math_utils_good.py（正确的版本）

python 复制代码 
# math_utils_good.py

def calculate_circle_area(radius):
    """计算圆的面积"""
    area = 3.14159 * radius ** 2
    return area

# 将测试代码放在保护语句内
if __name__ == '__main__':
    result = calculate_circle_area(5)
    print(f"半径为5的圆面积是：{result}")

让我们再次测试两种场景：

  1. 直接运行：行为不变。

    bash 复制代码 
    python math_utils_good.py

    输出：

    复制代码 
    半径为5的圆面积是：78.53975

  2. 被导入 ：副作用消失了！
    文件：my_project_fixed.py

    python 复制代码 
    # my_project_fixed.py
print("我的项目开始运行...")
print("导入 math_utils_good 模块...")

import math_utils_good

print("导入完成。")
# 可以安全地使用函数了
area = math_utils_good.calculate_circle_area(10)
print(f"使用导入的函数计算面积：{area}")

    运行：

    bash 复制代码 
    python my_project_fixed.py

    输出：

    复制代码 
    我的项目开始运行...
导入 math_utils_good 模块...
导入完成。
使用导入的函数计算面积：314.159

完美！测试代码只在模块被直接运行时执行，而在被导入时保持"安静"。这使得 math_utils_good.py 成为了一个可重用的、专业的模块。

4. 深入应用场景与最佳实践

if __name__ == '__main__' 的应用远不止于简单的测试。下面介绍几种常见且重要的应用场景。

4.1 场景一：模块的单元测试与自检

这是最经典的用法，如前所示。将模块的测试代码、示例代码放在保护语句内，是Python社区的一种标准实践。著名的Python项目，如Requests、NumPy等，其源码中大量使用了这种模式。

进阶示例：一个更复杂的自检模块。

python 复制代码 
# advanced_math.py
import math

def quadratic_formula(a, b, c):
    """解一元二次方程 ax^2 + bx + c = 0"""
    discriminant = b**2 - 4*a*c
    if discriminant < 0:
        return None, None  # 无实数根
    x1 = (-b + math.sqrt(discriminant)) / (2*a)
    x2 = (-b - math.sqrt(discriminant)) / (2*a)
    return x1, x2

def test_quadratic_formula():
    """测试quadratic_formula函数"""
    test_cases = [
        (1, -3, 2),  # x^2 - 3x + 2 = 0, 根为 1 和 2
        (1, 2, 1),   # x^2 + 2x + 1 = 0, 根为 -1 (重根)
        (1, 0, 1),   # x^2 + 1 = 0, 无实数根
    ]
    
    print("开始自检...")
    for i, (a, b, c) in enumerate(test_cases):
        x1, x2 = quadratic_formula(a, b, c)
        print(f"测试用例 {i+1}: a={a}, b={b}, c={c} -> 根: x1={x1}, x2={x2}")
    print("自检完成！")

if __name__ == '__main__':
    # 当模块直接运行时，执行全面的自检
    test_quadratic_formula()
    
    # 也可以提供简单的命令行交互
    print("\n你也可以自行输入系数来求解方程：")
    try:
        a = float(input("请输入a: "))
        b = float(input("请输入b: "))
        c = float(input("请输入c: "))
        x1, x2 = quadratic_formula(a, b, c)
        if x1 is None:
            print("该方程无实数根。")
        else:
            print(f"方程的解为: x1 = {x1:.2f}, x2 = {x2:.2f}")
    except ValueError:
        print("输入无效，请输入数字。")

4.2 场景二：创建命令行工具

许多Python脚本被设计成命令行工具。if __name__ == '__main__' 块是放置解析命令行参数和执行主要逻辑的理想位置。通常会配合 argparse 库使用。

示例：一个简单的文件行数统计工具。

python 复制代码 
# line_counter.py
import argparse
import os
import sys

def count_lines(filename):
    """统计文件的行数"""
    try:
        with open(filename, 'r', encoding='utf-8') as f:
            lines = f.readlines()
            return len(lines)
    except FileNotFoundError:
        print(f"错误：文件 '{filename}' 未找到。")
        return None
    except Exception as e:
        print(f"读取文件时发生错误：{e}")
        return None

def main():
    """主函数，处理命令行参数和逻辑"""
    # 1. 创建参数解析器
    parser = argparse.ArgumentParser(description='统计文本文件的行数。')
    parser.add_argument('filename', help='要统计行数的文件路径')
    parser.add_argument('-v', '--verbose', action='store_true', 
                        help='显示详细信息')
    
    # 2. 解析命令行参数
    args = parser.parse_args()
    
    # 3. 执行业务逻辑
    line_count = count_lines(args.filename)
    
    # 4. 输出结果
    if line_count is not None:
        if args.verbose:
            print(f"文件 '{args.filename}' 的总行数为：{line_count}")
        else:
            print(line_count)
    else:
        sys.exit(1)  # 非正常退出

# 保护语句确保只有在直接运行时才执行main()
if __name__ == '__main__':
    main()

这样，这个脚本就可以在命令行中使用了：

bash 复制代码 
# 简单使用
python line_counter.py myfile.txt

# 使用详细模式
python line_counter.py myfile.txt -v

4.3 场景三：作为应用程序的入口点

在大型应用程序或包（Package）中，通常会有一个主要的入口脚本。这个脚本的 if __name__ == '__main__' 块是整个应用程序的启动器。

项目结构示例：

复制代码 
my_app/
│   README.md
│   requirements.txt
│
└───src/
    │   __init__.py
    │   main.py          # 入口脚本
    │   config.py        # 配置管理
    │   logger.py        # 日志设置
    │
    └───modules/
          data_loader.py
          processor.py
          exporter.py

文件：src/main.py

python 复制代码 
# src/main.py
from config import load_config
from logger import setup_logging
from modules.data_loader import DataLoader
from modules.processor import DataProcessor
from modules.exporter import ResultExporter

def run_pipeline(config_path):
    """运行整个数据处理流水线"""
    # 1. 加载配置
    config = load_config(config_path)
    
    # 2. 设置日志
    logger = setup_logging(config['log_level'])
    logger.info("应用程序启动")
    
    # 3. 初始化各个组件
    loader = DataLoader(config)
    processor = DataProcessor(config)
    exporter = ResultExporter(config)
    
    # 4. 执行流水线
    try:
        data = loader.load()
        processed_data = processor.process(data)
        exporter.export(processed_data)
        logger.info("应用程序成功完成")
    except Exception as e:
        logger.error(f"应用程序执行失败：{e}")
        raise

def main():
    """应用程序的主入口函数"""
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument('--config', default='config.json', help='配置文件路径')
    args = parser.parse_args()
    
    run_pipeline(args.config)

if __name__ == '__main__':
    main()  # 只有直接运行 main.py 时，才会启动整个应用

在这种结构下，其他模块也可以导入 main.py 中的函数（如 run_pipeline）而不会意外启动整个应用程序。

5. 常见误区与疑难解答

5.1 误区一：认为它是程序的"开始"

很多初学者认为程序是从 if __name__ == '__main__' 下面开始的。这是不准确的。Python解释器执行一个脚本时，是从文件的第一行开始，自上而下依次执行 的。当它执行到 if __name__ == '__main__' 这个条件判断时，只是决定是否要执行其内部的代码块。

5.2 误区二：在函数内部使用

if __name__ == '__main__' 应该放在模块的顶层作用域，而不是函数内部。因为它需要检查的是整个模块的 __name__ 属性。

错误示范：

python 复制代码 
def main():
    # ... 一些代码 ...

    if __name__ == '__main__': # 错误！这会在函数被调用时才判断。
        main()

正确示范：

python 复制代码 
def main():
    # ... 一些代码 ...

if __name__ == '__main__': # 正确！在模块层级判断。
    main()

5.3 __main__模块的命名空间

当模块作为主程序运行时，它被称为 __main__ 模块。在代码中，你可以通过 sys.modules['__main__'] 来访问这个模块对象。这在一些高级调试或元编程场景中可能有用。

6. 完整代码示例：一个综合性的迷你项目

为了将以上所有概念融会贯通，我们创建一个迷你项目："智能计算器"。它包含一个可作为库使用的模块，同时也是一个功能完整的命令行工具。

项目文件：smart_calculator.py

python 复制代码 
#!/usr/bin/env python3
"""
智能计算器 (Smart Calculator)
一个兼具库和命令行工具功能的Python模块。
支持基础运算和单位转换。
"""

import argparse
import sys

# --- 作为库的功能部分 ---
class Calculator:
    """计算器类，封装各种运算"""
    
    @staticmethod
    def add(a, b):
        """加法"""
        return a + b
    
    @staticmethod
    def subtract(a, b):
        """减法"""
        return a - b
    
    @staticmethod
    def multiply(a, b):
        """乘法"""
        return a * b
    
    @staticmethod
    def divide(a, b):
        """除法"""
        if b == 0:
            raise ValueError("除数不能为零！")
        return a / b
    
    @staticmethod
    def power(base, exponent):
        """幂运算"""
        return base ** exponent

# 单位转换函数 (使用字典实现查找表，提高可扩展性)
_CONVERSION_RATES = {
    'km_mi': 0.621371,   # 公里到英里
    'mi_km': 1.60934,    # 英里到公里
    'kg_lb': 2.20462,    # 千克到磅
    'lb_kg': 0.453592,   # 磅到千克
    'c_f': lambda c: (c * 9/5) + 32,  # 摄氏度到华氏度
    'f_c': lambda f: (f - 32) * 5/9,  # 华氏度到摄氏度
}

def convert_unit(value, from_unit, to_unit):
    """
    单位转换
    
    参数:
        value: 要转换的数值
        from_unit: 原单位
        to_unit: 目标单位
        
    返回:
        转换后的数值
        
    抛出:
        KeyError: 如果不支持该单位转换
    """
    key = f"{from_unit}_{to_unit}"
    if key not in _CONVERSION_RATES:
        raise KeyError(f"不支持从 '{from_unit}' 到 '{to_unit}' 的转换。")
    
    rate_or_func = _CONVERSION_RATES[key]
    if callable(rate_or_func):
        # 如果是函数（如温度转换），则调用它
        return rate_or_func(value)
    else:
        # 如果是比率，则相乘
        return value * rate_or_func

# --- 命令行界面部分 ---
def handle_calculation(args):
    """处理计算命令"""
    calc = Calculator()
    operations = {
        'add': calc.add,
        'sub': calc.subtract,
        'mul': calc.multiply,
        'div': calc.divide,
        'pow': calc.power,
    }
    
    try:
        a = float(args.x)
        b = float(args.y)
        result = operations[args.operation](a, b)
        print(f"结果: {result}")
    except ValueError as e:
        print(f"输入错误: {e}")
    except ZeroDivisionError:
        print("错误: 除数不能为零！")

def handle_conversion(args):
    """处理单位转换命令"""
    try:
        value = float(args.value)
        result = convert_unit(value, args.from_unit, args.to_unit)
        print(f"{value} {args.from_unit} = {result:.4f} {args.to_unit}")
    except ValueError:
        print("错误: 请输入一个有效的数字。")
    except KeyError as e:
        print(f"错误: {e}")

def setup_argparse():
    """设置并返回命令行参数解析器"""
    parser = argparse.ArgumentParser(prog='smart_calc', description='智能计算器')
    subparsers = parser.add_subparsers(dest='command', help='可用命令')
    
    # 计算子命令
    calc_parser = subparsers.add_parser('calc', help='执行数学运算')
    calc_parser.add_argument('operation', choices=['add', 'sub', 'mul', 'div', 'pow'], 
                            help='运算类型')
    calc_parser.add_argument('x', help='第一个操作数')
    calc_parser.add_argument('y', help='第二个操作数')
    
    # 转换子命令
    conv_parser = subparsers.add_parser('convert', help='单位转换')
    conv_parser.add_argument('value', help='要转换的数值')
    conv_parser.add_argument('from_unit', help='原单位')
    conv_parser.add_argument('to_unit', help='目标单位')
    
    return parser

def main():
    """主函数：命令行工具的入口点"""
    parser = setup_argparse()
    args = parser.parse_args()
    
    if not args.command:
        # 如果没有提供子命令，显示帮助信息并退出
        parser.print_help()
        sys.exit(1)
    
    # 根据子命令路由到相应的处理函数
    command_handlers = {
        'calc': handle_calculation,
        'convert': handle_conversion,
    }
    
    handler = command_handlers.get(args.command)
    if handler:
        handler(args)
    else:
        print(f"未知命令: {args.command}")
        sys.exit(1)

# --- 模块自检部分 ---
def run_self_test():
    """运行模块自检"""
    print("=== 智能计算器自检开始 ===")
    
    calc = Calculator()
    # 测试计算功能
    assert calc.add(2, 3) == 5, "加法测试失败"
    assert calc.subtract(5, 3) == 2, "减法测试失败"
    assert calc.multiply(2, 3) == 6, "乘法测试失败"
    assert calc.divide(6, 3) == 2, "除法测试失败"
    assert calc.power(2, 3) == 8, "幂运算测试失败"
    print("✓ 所有计算功能测试通过")
    
    # 测试单位转换
    assert abs(convert_unit(10, 'km', 'mi') - 6.21371) < 0.001, "公里到英里转换失败"
    assert abs(convert_unit(32, 'f', 'c') - 0) < 0.001, "华氏度到摄氏度转换失败"
    print("✓ 所有单位转换测试通过")
    
    print("=== 自检全部通过！ ===")

# --- 关键的保护语句 ---
if __name__ == '__main__':
    # 这个代码块只有在直接运行 smart_calculator.py 时才会执行
    
    # 如果用户提供了命令行参数，则作为命令行工具运行
    if len(sys.argv) > 1:
        main()
    else:
        # 否则，运行自检并进入交互模式
        run_self_test()
        print("\n进入交互模式（输入 'quit' 退出）:")
        
        while True:
            try:
                expr = input("计算表达式 (例如: 2 + 3) > ").strip()
                if expr.lower() in ('quit', 'exit', 'q'):
                    break
                
                # 简单的表达式求值（注意：实际应用中应使用更安全的方法）
                result = eval(expr)  # 仅用于演示，生产环境慎用eval！
                print(f"结果: {result}")
                
            except (KeyboardInterrupt, EOFError):
                print("\n再见！")
                break
            except Exception as e:
                print(f"错误: {e}")

代码说明与自查

  1. 结构清晰 ：代码分为库功能（类Calculator、函数convert_unit）、命令行界面（main, handle_*函数）和自检部分（run_self_test）。
  2. 注释完整：每个函数和关键部分都有清晰的文档字符串或注释。
  3. 错误处理：对除零、无效输入、不支持的转换等进行了异常捕获和处理。
  4. if __name__ == '__main__' 的灵活运用 ：
    • 检查命令行参数，决定是作为工具运行还是进入交互模式。
    • 确保模块在被导入时，不会执行任何交互或命令行逻辑。
  5. 可重用性 ：其他Python程序可以 from smart_calculator import Calculator, convert_unit 来使用其核心功能。

如何使用这个迷你项目？

  1. 作为库导入：

    python 复制代码 
    # 在另一个Python文件中
from smart_calculator import Calculator, convert_unit

calc = Calculator()
print(calc.multiply(4, 5))  # 输出：20
print(convert_unit(100, 'km', 'mi'))  # 输出：62.1371

  2. 作为命令行工具使用：

    bash 复制代码 
    # 计算
python smart_calculator.py calc add 10 20
# 单位转换
python smart_calculator.py convert 20 km mi

  3. 直接运行进行自检和交互：

    bash 复制代码 
    python smart_calculator.py

7. 总结

if __name__ == '__main__' 是Python模块化编程的基石。它通过检查内置变量 __name__ 来判断当前模块的执行方式，从而优雅地将可重用的库代码 与作为主程序的执行代码分离开来。

核心要点回顾：

  • __name__ 是Python为每个模块自动创建的属性。
  • 直接运行的模块，其 __name__ 为 '__main__'；被导入的模块，其 __name__ 为模块名。
  • 使用 if __name__ == '__main__' 可以防止模块在被导入时执行不必要的测试代码或产生副作用。
  • 它是构建命令行工具、编写可测试代码和创建复杂应用程序入口点的标准模式。

掌握这一概念，意味着你真正理解了Python代码的组织哲学，能够写出更专业、更健壮、更易于协作的Python程序。现在，你可以在自己的每一个Python脚本中自信地使用这条"魔法语句"了。

相关推荐
黑马金牌编程2 小时前
简易分析慢 SQL 的流程和方法
linux·数据库·mysql·性能优化·性能分析·慢日志
什么半岛铁盒3 小时前
C++项目：仿muduo库高并发服务器---------LoopThreadPool模块和TcpServer模块的实现
linux·服务器·c++·mysql·ubuntu
それども3 小时前
本地怎么远程调试服务器
运维·服务器
毕设源码-郭学长4 小时前
【开题答辩全过程】以 Python基于大数据的四川旅游景点数据分析与可视化为例，包含答辩的问题和答案
大数据·python·数据分析
Lin_Aries_04214 小时前
容器化 Flask 应用程序
linux·后端·python·docker·容器·flask
angushine4 小时前
Windows版本PostgreSQL定时备份
数据库·windows·postgresql
roman_日积跬步-终至千里4 小时前
【系统架构设计（38）】数据库规范化理论
数据库·系统架构
MediaTea4 小时前
Jupyter Notebook：基于 Web 的交互式编程环境
前端·ide·人工智能·python·jupyter
阿_旭4 小时前
基于深度学习的CT扫描图像肝脏肿瘤智能检测与分析系统【python源码+Pyqt5界面+数据集+训练代码】
人工智能·python·深度学习·肝脏肿瘤分割
热门推荐
01GitHub 镜像站点02UV 工具安装与国内镜像源配置指南03UV安装并设置国内源04Spec-Kit 使用指南05阿里最新开源Wan2.2-Animate-14B 本地部署教程：统一双模态框架，MoE架构赋能电影级角色动画与替换06OpenSpeedy简介07Linux下V2Ray安装配置指南08KGG转MP3工具|非KGM文件|解密音频0946个Nano-banana 精选提示词，持续更新中10VsCode远程Copilot无法使用Claude Agent问题