基于Python开发Windows自动更新控制工具

本文主要是介绍基于Python开发Windows自动更新控制工具，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

《基于Python开发Windows自动更新控制工具》在当今数字化时代,操作系统更新已成为计算机维护的重要组成部分,本文介绍一款基于Python和PyQt5的Windows自动更新控制工具,有需要的可...

在当今数字化时代，操作系统更新已成为计算机维护的重要组成部分。然而，对于许多用户来说，Windows自动更新常常带来不便：意外的重启、更新过程中的系统卡顿，甚至有时更新会导致兼容性问题。本文介绍一款基于python和PyQt5的Windows自动更新控制工具，让用户能够彻底掌控系统更新行为。

设计原理与技术实现

系统架构概述

Windows自动更新涉及多个系统组件，包括服务、计划任务、注册表设置和组策略。要彻底控制更新行为，需要从以下四个层面进行操作：

服务层：禁用Windows Update相关服务
任务调度层：禁用自动更新相关的计划任务
注册表层：修改更新相关的注册表项
组策略层：配置本地组策略设置

数学建模

设系统更新状态为函数 S(t)，其中 t 表示时间。更新机制可以表示为：

S(t)=f(S_service，S_task，S_registry，S_policy）

其中：

S_service表示服务状态向量
S_task表示计划任务状态矩阵
S_registry表示注册表配置张量
S_policy表示组策略参数集合

我们的目标是找到控制函数 C，使得：C(S(t))=S_desired

其中S_desired是期望的更新状态（启用或禁用）。

工具界面

基于Python开发Windows自动更新控制工具

完整代码实现

以下是完整的Windows自动更新控制工具代码，该程序具有图形界面，支持彻底禁用和启用Windows更新功能。

import sys
import os
import subprocess
import winreg
import ctypes
from PyQt5.QtWidgets import (QApplication, QMainWindow, QvboxLayout, QHBoxLayout, 
                             QPushButton, QLabel, QTextEdit, QWidget, QMessageBox,
                             QGroupBox, QProgressBar, QCheckBox, QSystemTrayIcon, 
                             QMenu, QAction, QStyle)
from PyQt5.QtCore import QThread, pyqtSignal, QTimer, Qt
from PyQt5.QtGui import QFont, QIcon, QCloseEvent

class UpdateControlThread(QThread):
    """后台线程用于执行Windows更新控制操作"""
    output_signal = pyqtSignal(str)
    progress_signal = pyqtSignal(int)
    finished_signal = pyqtSignal(bool, str)
    
    def __init__(self, action, aggressive_mode=False):
        super().__init__()
        self.action = action  # 'disable' 或 'enable'
        self.aggressive_mode = aggressive_mode
    
    def run(self):
        try:
            if self.action == 'disable':
                success = self.disable_updates()
            else:
                success = self.enable_updates()
                
            if success:
                self.finished_signal.emit(True, f"Windows更新已成功{self.action}d")
            else:
                self.finished_signal.emit(False, "部分操作失败，请查看日志")
        except Exception as e:
            self.finished_signal.emit(False, f"操作失败: {str(e)}")
    
    def execute_command(self, cmd, ignore_errors=False):
        """执行命令并输出结果"""
        self.output_signal.emit(f"执行: {cmd}")
        try:
            # 使用CREATE_NO_WINDOW标志避免弹出命令窗口
            result = subprocess.run(cmd, shell=True, capture_output=True, 
                                  text=True, timeout=60, 
                                  creationflags=subprocess.CREATE_NO_WINDOW)
            if result.returncode == 0:
                if result.stdout:
                    self.output_signal.emit(result.stdout)
                return True
            else:
                if result.stderr:
                    error_msg = f"错误({result.returncode}): {result.stderr.strip()}"
                else:
                    error_msg = f"命令返回错误代码: {result.returncode}"
                
                self.output_signal.emit(error_msg)
                return ignore_errors
        except subprocess.TimeoutExpired:
            self.output_signal.emit("命令执行超时")
            return ignore_errors
        except Exception as e:
            self.output_signal.emit(f"执行异常: {str(e)}")
            return ignore_errors

    def disable_updates(self):
        """禁用Windows更新"""
        self.output_signal.emit("开始禁用Windows更新...")
        
        success_count = 0
        total_operations = 0
        
        # 1. 停止并禁用Windows更新相关服务
        services = [
            ("wuauserv", "Windows Update"),
            ("UsoSvc", "Update Orchestrator"), 
            ("WaaSMedicSvc", "Windows Update Medic"),
            ("BITS", "Background Intelligent Transfer Service")
        ]
        
        for service, description in services:
            total_operations += 1
            # 停止服务（忽略错误，因为服务可能未运行）
            self.execute_command(f"net stop {service}", ignore_errors=True)
            # 禁用服务
            if self.execute_command(f"sc config {service} start= disabled", ignore_errors=True):
                success_count += 1
                self.output_signal.emit(f"✓ {description}服务已禁用")
           javascript else:
                self.output_signal.emit(f"⚠ {description}服务禁用失败，尝试其他方法")
                
                # 尝试通过注册表禁用
                try:
                    key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, 
                                       f"SYSTEM\\CurrentControlSet\\Services\\{service}", 
                                       0, winreg.KEY_SET_VALUE)
                    winreg.SetValueEx(key, "Start", 0, winreg.REG_dwORD, 4)
                    winreg.CloseKey(key)
                    self.output_signal.emit(f"✓ 通过注册表禁用{description}服务")
                    success_count += 1
                except:
                    self.output_signal.emit(f"✗ 注册表方式也失败")
        
        # 2. 通过组策略禁用更新
        total_operations += 1
        if self.execute_command('reg add "HKLM\\SOFTWARE\\Policies\\Microsoft\\Windows\\WindowsUpdate\\AU" /v NoAutoUpdate /t REG_DWORD /d 1 /f'):
            success_count += 1
        if self.execute_command('reg add "HKLM\\SOFTWARE\\Policies\\Microsoft\\Windows\\WindowsUpdate\\AU" /v AUOptions /t REG_DWORD /d 1 /f'):
            success_count += 1
        
        # 3. 禁用Windows Update Medic服务
        total_operations += 1
        if self.execute_command('http://www.chinasem.cnreg add "HKLM\\SYSTEM\\CurrentControlSet\\Services\\WaaSMedicSvc" /v Start /t REG_DWORD /d 4 /f'):
            success_count += 1
        
        # 4. 禁用自动更新调度任务
        tasks = [
            "\\Microsoft\\Windows\\UpdateOrchestrator\\USO_UxBroker",
            "\\Microsoft\\Windows\\UpdateOrchestrator\\BackgroundWork", 
            "\\Microsoft\\Windows\\UpdateOrchestrator\\Reboot",
            "\\Microsoft\\Windows\\UpdateOrchestrator\\AC Power Install",
            "\\Microsoft\\Windows\\UpdateOrchestrator\\Maintenance Install"
        ]
        
        for task in tasks:
            total_operations += 1
            # 先检查任务是否存在
            if self.execute_command(f'schtasks /query /tn "{task}"', ignore_errors=True):
                if self.execute_command(f'schtasks /change /tn "{task}" /disable', ignore_errors=True):
                    success_count += 1
                    self.output_signal.emit(f"✓ 计划任务 {task} 已禁用")
                else:
                    self.output_signal.emit(f"⚠ 计划任务 {task} 禁用失败")
            else:
                self.output_signal.emit(f"⚠ 计划任务 {task} 不存在，跳过")
                success_count += 0.5  # 部分成功
        
        # 5. 激进模式：禁用更新相关驱动程序
        if self.aggressive_mode:
            self.output_signal.emit("启用激进模式...")
            # 禁用Windows Update相关的设备驱动程序
            driver_commands = [
                'reg add "HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\DriverSearching" /v SearchOrderConfig /t REG_DWORD /d 0 /f',
    China编程            'reg add "HKLM\\SOFTWARE\\Policies\\Microsoft\\Windows\\DriverSearching" /v DontPromptForWindowsUpdate /t REG_DWORD /d 1 /f',
                'reg add "HKLM\\SOFTWARE\\Policies\\Microsoft\\Windows\\DriverSearching" /v DriverUpdateWizardWuSearchEnabled /t REG_DWORD /d 0 /f'
            ]
            
            for cmd in driver_commands:
                total_operations += 0.5
                if self.execute_command(cmd, ignore_errors=True):
                    success_count += 0.5
        
        # 6. 刷新组策略
        self.execute_command("gpupdate /force", ignore_errors=True)
        
        success_rate = (success_count / total_operations) * 100 if total_operations > 0 else 100
        self.output_signal.emit(f"操作完成。成功率: {success_rate:.1f}%")
        
        return success_rate > 70  # 70%以上的操作成功就算总体成功
    
    def enable_updates(self):
        """启用Windows更新"""
        self.output_signal.emit("开始启用Windows更新...")
        
        success_count = 0
        total_operations = 0
        
        # 1. 启用Windows更新相关服务
        services = [
            ("wuauserv", "Windows Update"),
            ("UsoSvc", "Update Orchestrator"),
            ("WaaSMedicSvc", "Windows Update Medic"), 
            ("BITS", "Background Intelligent Transfer Service")
        ]
        
        for service, description in services:
            total_operations += 1
            # 启用服务
            if self.execute_command(f"sc config {service} start= demand", ignore_errors=True):
                success_count += 1
                # 启动服务
                self.execute_command(f"net start {service}", ignore_errors=True)
                self.output_signal.emit(f"✓ {description}服务已启用")
            else:
                self.output_signal.emit(f"⚠ {description}服务启用失败")
        
        # 2. 删除组策略设置
        total_operations += 1
        if self.execute_command('reg delete "HKLM\\SOFTWARE\\Policies\\Microsoft\\Windows\\WindowsUpdate" /f', ignore_errors=True):
            success_count += 1
        
        # 3. 启用Windows Update Medic服务
        total_operations += 1
        if self.execute_command('reg add "HKLM\\SYSTEM\\CurrentControlSet\\Services\\WaaSMedicSvc" /v Start /t REG_DWORD /d 2 /f'):
            success_count += 1
        
        # 4. 启用自动更新调度任务
        tasks = [
            "\\Microsoft\\Windows\\UpdateOrchestrator\\USO_UxBroker",
            "\\Microsoft\\Windows\\UpdateOrchestrator\\BackgroundWork",
            "\\Microsoft\\Windows\\UpdateOrchestrator\\Reboot", 
            "\\Microsoft\\Windows\\UpdateOrchestrator\\AC Power Install",
            "\\Microsoft\\Windows\\UpdateOrchestrator\\Maintenance Install"
        ]
        
        for task in tasks:
            total_operations += 1
            # 检查任务是否存在
            if self.execute_command(f'schtasks /query /tn "{task}"', ignore_errors=True):
                if self.execute_command(f'schtasks /change /tn "{task}" /enable', ignore_errors=True):
                    success_count += 1
                    self.output_signal.emit(f"✓ 计划任务 {task} 已启用")
                else:
                    self.output_signal.emit(f"⚠ 计划任务 {task} 启用失败")
            else:
                self.output_signal.emit(f"⚠ 计划任务 {task} 不存在，跳过")
                success_count += 0.5
        
        # 5. 刷新组策略
        self.execute_command("gpupdate /force", ignore_errors=True)
        
        success_rate = (success_count / total_operations) * 100 if total_operations > 0 else 100
        self.output_signal.emit(f"操作完成。成功率: {success_rate:.1f}%")
        
        return success_rate > 70

class WindowsUpdateController(QMainWindow):
    def __init__(self):
        super().__init__()
        self.tray_icon = None
        self.init_ui()
        self.control_thread = None
    
    def init_ui(self):
        self.setWindowTitle('Windows更新控制器 - 专业版')
        self.setFixedSize(800, 700)
        
        # 设置窗口图标
        self.setWindowIcon(self.style().standardIcon(QStyle.SP_ComputerIcon))
        
        # 创建中央部件和布局
        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        layout = QVBoxLayout(central_widget)
        
        # 标题
        title_label = QLabel('Windows更新控制器 - 专业版')
        title_label.setFont(QFont('Arial', 18, QFont.Bold))
        title_label.setStyleSheet('color: #2c3e50; margin: 15px;')
        title_label.setAlignment(Qt.AlignCenter)
        layout.addWidget(title_label)
        
        # 说明文字
        desc_label = QLabel('此工具基于多层级系统控制原理，通过服务、任务、注册表和组策略四个维度彻底控制Windows更新行为。')
        desc_label.setFont(QFont('Arial', 10))
        desc_label.setStyleSheet('color: #7f8c8d; margin: 10px; padding: 10px; background-color: #f8f9fa; border-radius: 5px;')
        desc_label.setWordWrap(True)
        layout.addWidget(desc_label)
        
        # 选项区域
        options_group = QGroupBox('控制参数设置')
        options_group.setFont(QFont('Arial', 11, QFont.Bold))
        options_layout = QVBoxLayout()
        
        self.aggressive_checkbox = QCheckBox('启用激进模式（深度控制系统更新组件）')
        self.aggressive_checkbox.setFont(QFont('Arial', 10))
        self.aggressive_checkbox.setToolTip('此模式会禁用更多更新相关组件，包括驱动程序更新，提供更彻底的控制')
        options_layout.addWidget(self.aggressive_checkbox)
        
        options_group.setLayout(options_layout)
        layout.addWidget(options_group)
        
        # 按钮区域
        button_layout = QHBoxLayout()
        
        self.disable_btn = QPushButton('彻底禁用系统更新')
        self.disable_btn.setFont(QFont('Arial', 11, QFont.Bold))
        self.disable_btn.setStyleSheet('''
            QPushButton { 
                background-color: #e74c3c; 
                color: white; 
                font-weight: bold; 
                padding: 12px; 
                border-radius: 5px;
                border: 2px solid #c0392b;
            }
            QPushButton:hover { 
                background-color: #c0392b; 
                border: 2px solid #a93226;
            }
            QPushButton:disabled { 
                background-color: #95a5a6; 
                border: 2px solid #7f8c8d;
            }
        ''')
        self.disable_btn.clicked.connect(self.disable_updates)
        button_layout.addWidget(self.disable_btn)
        
        self.enable_btn = QPushButton('恢复系统更新')
        self.enable_btn.setFont(QFont('Arial', 11, QFont.Bold))
        self.enable_btn.setStyleSheet('''
            QPushButton { 
                background-color: #2ecc71; 
                color: white; 
                font-weight: bold; 
                padding: 12px; 
                border-radius: 5px;
                border: 2px solid #27ae60;
            }
            QPushButton:hover { 
                background-color: #27ae60; 
                border: 2px solid #229954;
            }
            QPushButton:disabled { 
                background-color: #95a5a6; 
                border: 2px solid #7f8c8d;
            }
        ''')
        self.enable_btn.clicked.connect(self.enable_updates)
        button_layout.addWidget(self.enable_btn)
        
        layout.addLayout(button_layout)
        
        # 进度条
        self.progress_bar = QProgressBar()
        self.progress_bar.setVisible(False)
        self.progress_bar.setStyleSheet('''
            QProgressBar {
                border: 2px solid grey;
                border-radius: 5px;
                text-align: center;
            }
            QProgressBar::chunk {
                background-color: #3498db;
                width: 20px;
            }
        ''')
        layout.addWidget(self.progress_bar)
        
        # 输出区域
        output_group = QGroupBox('系统操作日志')
        output_group.setFont(QFont('Arial', 11, QFont.Bold))
        output_layout = QVBoxLayout()
        self.output_text = QTextEdit()
        self.output_text.setReadOnly(True)
        self.output_text.setFont(QFont('Consolas', 9))
        self.output_text.setStyleSheet('background-color: #2c3e50; color: #ecf0f1; padding: 10px;')
        output_layout.addWidget(self.output_text)
        output_group.setLayout(output_layout)
        layout.addWidget(output_group)
        
        # 状态栏
        self.statusBar().showMessage('系统就绪 - 等待用户操作')
        
        # 创建系统托盘图标
        self.create_tray_icon()
    
    def create_tray_icon(self):
        """创建系统托盘图标"""
        if QSystemTrayIcon.isSystemTrayAvailable():
            self.tray_icon = QSystemTrayIcon(self)
            self.tray_icon.setIcon(self.style().standardIcon(QStyle.SP_ComputerIcon))
            
            tray_menu = QMenu()
            
            show_action = QAction("显示窗口", self)
            show_action.triggered.connect(self.show)
            tray_menu.addAction(show_action)
            
            disable_action = QAction("禁用更新", self)
            disable_action.triggered.connect(self.disable_updates)
            tray_menu.addAction(disable_action)
            
            enable_action = QAction("启用更新", self)
            enable_action.triggered.connect(self.enable_updates)
            tray_menu.addAction(enable_action)
            
            tray_menu.addSeparator()
            
            quit_action = QAction("退出", self)
            quit_action.triggered.connect(self.quit_application)
            tray_menu.addAction(quit_action)
            
            self.tray_icon.setContextMenu(tray_menu)
            self.tray_icon.activated.connect(self.tray_icon_activated)
            self.tray_icon.show()
    
    def tray_icon_activated(self, reason):
        """托盘图标激活事件"""
        if reason == QSystemTrayIcon.DoubleClick:
            self.show()
            self.activateWindow()
    
    def quit_application(self):
        """退出应用程序"""
        if self.control_thread and self.control_thread.isRunning():
            self.control_thread.terminate()
            self.control_thread.wait()
        QApplication.quit()
    
    def closeEvent(self, event):
        """重写关闭事件，实现最小化到托盘"""
        if self.tray_icon and self.tray_icon.isVisijavascriptble():
            self.hide()
            event.ignore()
        else:
            self.quit_application()
    
    def disable_updates(self):
        """禁用更新确认对话框"""
        reply = QMessageBox.question(self, '系统更新控制确认', 
                                    '您确定要彻底禁用Windows自动更新吗？\n\n'
                                    '⚠️ 安全提醒：禁用更新可能会导致系统安全风险。\n'
                                    ' 技术原理：本操作将通过服务、任务、注册表、组策略四层控制实现彻底禁用。',
                                    QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
        
        if reply == QMessageBox.Yes:
            self.start_control_thread('disable')
    
    def enable_updates(self):
        """启用更新确认对话框"""
        reply = QMessageBox.question(self, '系统更新恢复确认', 
                                    '您确定要恢复Windows自动更新功能吗？\n\n'
                                    '✅ 系统将恢复所有更新相关组件。\n'
                                    ' 建议在恢复后立即检查并安装重要安全更新。',
                                    QMessageBox.Yes | QMessageBox.No, QMessageBox.Yes)
        
        if reply == QMessageBox.Yes:
            self.start_control_thread('enable')
    
    def start_control_thread(self, action):
        """启动控制线程"""
        # 禁用按钮
        self.disable_btn.setEnabled(False)
        self.enable_btn.setEnabled(False)
        
        # 显示进度条
        self.progress_bar.setVisible(True)
        self.progress_bar.setRange(0, 0)  # 无限进度条
        
        # 清空输出
        self.output_text.clear()
        
        # 启动线程
        aggressive = self.aggressive_checkbox.isChecked()
        self.control_thread = UpdateControlThread(action, aggressive)
        self.control_thread.output_signal.connect(self.append_output)
        self.control_thread.finished_signal.connect(self.operation_finished)
        self.control_thread.start()
        
        action_text = "禁用" if action == "disable" else "启用"
        mode_text = "（激进模式）" if aggressive else ""
        self.statusBar().showMessage(f'正在{action_text}Windows系统更新{mode_text}...')
    
    def append_output(self, text):
        """追加输出到日志"""
        self.output_text.append(text)
        # 自动滚动到底部
        cursor = self.output_text.textCursor()
        cursor.movePosition(cursor.End)
        self.output_text.setTextCursor(cursor)
    
    def operation_finished(self, success, message):
        """操作完成回调"""php
        # 启用按钮
        self.disable_btn.setEnabled(True)
        self.enable_btn.setEnabled(True)
        
        # 隐藏进度条
        self.progress_bar.setVisible(False)
        
        # 显示结果消息
        if success:
            QMessageBox.information(self, '系统操作成功', 
                                  f'{message}\n\n'
                                  ' 建议重启计算机以确保所有更改生效。')
            self.statusBar().showMessage('操作成功完成')
            
            # 更新托盘图标提示
            if self.tray_icon:
                self.tray_icon.showMessage('操作完成', message, QSystemTrayIcon.Information, 3000)
        else:
            QMessageBox.warning(self, '系统操作失败', 
                              f'{message}\n\n'
                              '❌ 请检查系统权限或查看详细日志。')
            self.statusBar().showMessage('操作执行失败')

def is_admin():
    """检查是否以管理员权限运行"""
    try:
        return ctypes.windll.shell32.IsUserAnAdmin()
    except:
        return False

def main():
    """主函数"""
    # 检查管理员权限
    if not is_admin():
        # 如果没有管理员权限，请求提升权限
        try:
            ctypes.windll.shell32.ShellExecuteW(None, "runas", sys.executable, " ".join(sys.argv), None, 1)
            sys.exit(0)
        except:
            QMessageBox.critical(None, "系统权限错误", 
                               "此程序需要管理员权限才能运行。\n\n"
                               " 请右键点击程序，选择\"以管理员身份运行\"。")
            return
    
    # 创建应用实例
    app = QApplication(sys.argv)
    app.setApplicationName('Windows更新控制器')
    app.setApplicationVersion('2.0')
    app.setQuitOnLastWindowClosed(False)  # 允许窗口关闭时不退出应用
    
    # 设置应用样式
    app.setStyle('Fusion')
    
    # 创建并显示主窗口
    window = WindowsUpdateController()
    window.show()
    
    # 进入主循环
    sys.exit(app.exec_())

if __name__ == '__main__':
    main()

结果如下

基于Python开发Windows自动更新控制工具

技术深度分析

多层级控制理论

Windows更新控制系统可以建模为一个多层级的控制体系。设系统状态为 SSS，控制输入为 UUU，则系统动态可以表示为：

dS/dt=F(S,U)

其中控制输入 U 包含四个分量：

U=[U_service,U_task,U_registry,U_policy]^T

每个分量对应不同层级的控制策略。

服务层控制

服务控制策略基于服务状态转移矩阵。设服务状态 si 可以取值为 0,1,2,3,4分别对应停止、启动、自动、手动、禁用状态。服务状态转移可以表示为：

s_i(t+1)=T_i⋅s_i(t)+B_i⋅u_i

其中 T_i是状态转移矩阵，B_i是控制输入矩阵。

注册表控制策略

注册表控制采用键值对模型。设注册表项为 R=(k_i,v_i)，控制策略为映射函数：

f_R:R→R′

通过修改关键注册表项的值，实现对系统行为的精确控制。

使用说明与最佳实践

安装依赖

pip install pyqt5

运行程序

python windows_update_controller.py

操作建议

定期检查：建议每月运行一次程序检查更新状态

安全平衡：在禁用更新期间，确保使用其他安全措施

备份策略：重要操作前创建系统还原点

验证方法

禁用更新后，可以通过以下命令验证效果：

# 检查服务状态
sc query wuauserv
# 检查组策略
gpresult /h report.html
# 验证更新功能
UsoClient StartInteractiveScan

结语

本文介绍的Windows自动更新控制工具基于深入的系统原理分析，通过多层级控制策略实现了对系统更新行为的精确控制。工具采用数学模型指导设计，确保控制效果的可靠性和彻底性。

该工具不仅提供了实用的功能，还展示了如何通过系统编程技术实现深层次的系统控制。通过理解和使用这个工具，用户能够真正成为自己电脑的主人，在便利性和安全性之间找到最佳平衡点。

基于Python开发Windows自动更新控制工具

其中 Ci 表示各层级的控制函数，最终实现系统状态的完全控制。

到此这篇关于基于Python开发Windows自动更新控制工具的文章就介绍到这了,更多相关Python Windows自动更新控制内容请搜索China编程(www.chinasem.cn)以前的文章或继续浏览下面的相关文章希望大家以后多多支持China编程(www.chinasem.cn)！

这篇关于基于Python开发Windows自动更新控制工具的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

基于Python开发Windows自动更新控制工具

目录

设计原理与技术实现

系统架构概述

数学建模

工具界面

完整代码实现

技术深度分析

多层级控制理论

服务层控制

注册表控制策略

使用说明与最佳实践

安装依赖

运行程序

操作建议

验证方法

结语

相关文章

Python+FFmpeg实现视频自动化处理的完整指南

python中的flask_sqlalchemy的使用及示例详解

Python实现快速扫描目标主机的开放端口和服务

Python轻松实现Word到Markdown的转换

Python中4大日志记录库比较的终极PK

C++,C#,Rust,Go,Java,Python,JavaScript的性能对比全面讲解

Python海象运算符:=的具体实现

python项目环境切换的几种实现方式

python项目打包成docker容器镜像的两种方法实现

Python + Streamlit项目部署方案超详细教程(非Docker版)