Python环境适配案例怎么编写？

wen python案例 2026-06-08 06:17:37 2

本文目录导读：

基础环境检测脚本
适配不同操作系统
Python版本兼容处理
依赖管理脚本
环境配置生成器
完整环境适配示例
使用建议

我来为您详细介绍Python环境适配案例的编写方法：

基础环境检测脚本

# env_check.py
import sys
import platform
import os
import importlib
def check_python_version():
    """检查Python版本"""
    required_version = (3, 8)
    current_version = sys.version_info[:2]
    if current_version >= required_version:
        print(f"✓ Python版本 {current_version} 满足要求")
        return True
    else:
        print(f"✗ Python版本 {current_version} 不满足要求，需要 >= 3.8")
        return False
def check_operating_system():
    """检查操作系统"""
    system = platform.system()
    print(f"✓ 当前操作系统: {system}")
    return system
def check_packages():
    """检查所需包"""
    required_packages = {
        'numpy': '1.19.0',
        'pandas': '1.2.0',
        'requests': '2.25.0',
        'flask': '2.0.0'
    }
    missing_packages = []
    for package, min_version in required_packages.items():
        try:
            module = importlib.import_module(package)
            installed_version = getattr(module, '__version__', 'unknown')
            print(f"✓ {package} {installed_version}")
        except ImportError:
            missing_packages.append(package)
            print(f"✗ {package} 未安装")
    return missing_packages
def check_cuda_availability():
    """检查CUDA可用性（可选）"""
    try:
        import torch
        cuda_available = torch.cuda.is_available()
        if cuda_available:
            print(f"✓ CUDA已启用")
            print(f"✓ GPU: {torch.cuda.get_device_name(0)}")
        else:
            print("ℹ CUDA未启用")
        return cuda_available
    except ImportError:
        print("ℹ torch未安装，跳过GPU检查")
        return False
if __name__ == "__main__":
    print("=" * 50)
    print("环境检测报告")
    print("=" * 50)
    check_python_version()
    check_operating_system()
    missing = check_packages()
    check_cuda_availability()
    if missing:
        print(f"\n缺少的包: {', '.join(missing)}")
        print("请运行: pip install " + " ".join(missing))

适配不同操作系统

# os_adapter.py
import os
import platform
import subprocess
from pathlib import Path
class SystemAdapter:
    """系统适配器"""
    def __init__(self):
        self.system = platform.system()
        self.path_separator = '\\' if self.system == 'Windows' else '/'
    def get_path(self, *paths):
        """获取适配平台的路径"""
        return os.path.join(*paths)
    def clear_screen(self):
        """清屏命令适配"""
        if self.system == 'Windows':
            os.system('cls')
        else:
            os.system('clear')
    def get_temp_dir(self):
        """获取临时目录"""
        if self.system == 'Windows':
            return os.environ.get('TEMP', 'C:\\Temp')
        else:
            return '/tmp'
    def run_command(self, command):
        """运行系统命令"""
        if self.system == 'Windows':
            return subprocess.run(['cmd', '/c'] + command, capture_output=True)
        else:
            return subprocess.run(command, capture_output=True)
    def get_process_info(self):
        """获取进程信息"""
        if self.system == 'Windows':
            return subprocess.run(['tasklist'], capture_output=True, text=True).stdout
        else:
            return subprocess.run(['ps', 'aux'], capture_output=True, text=True).stdout
# 使用示例
adapter = SystemAdapter()
print(f"临时目录: {adapter.get_temp_dir()}")
print(f"路径分隔符: {adapter.path_separator}")

Python版本兼容处理

# version_compat.py
import sys
import six  # 需要安装: pip install six
def compatible_open(filename, mode='r'):
    """兼容Python 2和3的文件操作"""
    if sys.version_info[0] == 2:
        return open(filename, mode + 'b')
    else:
        return open(filename, mode, encoding='utf-8')
def compatible_print(*args, **kwargs):
    """兼容的打印函数"""
    if sys.version_info[0] == 2:
        # Python 2
        print ' '.join(str(arg) for arg in args)
    else:
        # Python 3
        print(*args, **kwargs)
def compatible_unicode(text):
    """Unicode处理兼容"""
    if sys.version_info[0] == 2:
        return text.decode('utf-8') if isinstance(text, str) else text
    else:
        return text
def compatible_input(prompt=''):
    """输入处理兼容"""
    if sys.version_info[0] == 2:
        return raw_input(prompt)
    else:
        return input(prompt)
# 使用示例
with compatible_open('test.txt', 'w') as f:
    f.write('测试内容')
# 使用six库的兼容处理
from six.moves import range
for i in range(10):
    print(i)

依赖管理脚本

# dependency_manager.py
import subprocess
import sys
import json
from typing import List, Dict
class DependencyManager:
    """依赖管理器"""
    def __init__(self, requirements_file='requirements.txt'):
        self.requirements_file = requirements_file
    def get_installed_packages(self) -> Dict[str, str]:
        """获取已安装的包"""
        result = subprocess.run(
            [sys.executable, '-m', 'pip', 'list', '--format=json'],
            capture_output=True, text=True
        )
        packages = {}
        try:
            data = json.loads(result.stdout)
            for package in data:
                packages[package['name'].lower()] = package['version']
        except:
            pass
        return packages
    def check_requirements(self) -> List[str]:
        """检查依赖完整性"""
        missing = []
        installed = self.get_installed_packages()
        try:
            with open(self.requirements_file, 'r') as f:
                for line in f:
                    line = line.strip()
                    if line and not line.startswith('#'):
                        package_name = line.split('==')[0].lower()
                        if package_name not in installed:
                            missing.append(line)
        except FileNotFoundError:
            print(f"警告: {self.requirements_file} 不存在")
        return missing
    def install_missing(self, packages: List[str]):
        """安装缺失的包"""
        if not packages:
            print("所有依赖已安装")
            return
        print(f"正在安装 {len(packages)} 个包...")
        for package in packages:
            try:
                subprocess.run(
                    [sys.executable, '-m', 'pip', 'install', package],
                    check=True
                )
                print(f"✓ {package} 安装成功")
            except subprocess.CalledProcessError:
                print(f"✗ {package} 安装失败")
# 使用示例
manager = DependencyManager()
missing_packages = manager.check_requirements()
if missing_packages:
    print(f"缺少以下包: {missing_packages}")
    manager.install_missing(missing_packages)

环境配置生成器

# env_config.py
import configparser
import os
import json
from pathlib import Path
class EnvironmentConfig:
    """环境配置生成器"""
    def __init__(self, config_file='config.ini'):
        self.config = configparser.ConfigParser()
        self.config_file = config_file
        self.load_config()
    def load_config(self):
        """加载配置"""
        if os.path.exists(self.config_file):
            self.config.read(self.config_file)
        else:
            self.create_default_config()
    def create_default_config(self):
        """创建默认配置"""
        self.config['General'] = {
            'debug': 'False',
            'log_level': 'INFO',
            'timeout': '30'
        }
        self.config['Database'] = {
            'host': 'localhost',
            'port': '3306',
            'name': 'test_db',
            'user': 'root',
            'password': ''
        }
        self.config['API'] = {
            'base_url': 'http://localhost:8000',
            'version': 'v1',
            'max_retries': '3'
        }
        self.save_config()
    def save_config(self):
        """保存配置"""
        with open(self.config_file, 'w') as f:
            self.config.write(f)
        print(f"配置已保存到 {self.config_file}")
    def get_database_url(self) -> str:
        """获取数据库URL"""
        db = self.config['Database']
        return f"mysql://{db['user']}:{db['password']}@{db['host']}:{db['port']}/{db['name']}"
    def export_env_vars(self):
        """导出环境变量"""
        env_vars = {}
        for section in self.config.sections():
            for key, value in self.config[section].items():
                env_name = f"{section.upper()}_{key.upper()}"
                env_vars[env_name] = value
        return env_vars
# 使用示例
config = EnvironmentConfig()
# 修改配置
config.config['General']['debug'] = 'True'
config.config['API']['max_retries'] = '5'
config.save_config()
# 导出环境变量
env_vars = config.export_env_vars()
print(json.dumps(env_vars, indent=2))

完整环境适配示例

# main.py - 完整的适配示例
import os
import sys
import logging
from datetime import datetime
class EnvironmentAdapter:
    """完整的环境适配器"""
    def __init__(self):
        self.setup_logging()
        self.check_environment()
    def setup_logging(self):
        """设置日志"""
        log_format = '%(asctime)s - %(levelname)s - %(message)s'
        if sys.version_info[0] == 2:
            # Python 2兼容
            logging.basicConfig(
                filename='app.log',
                format=log_format,
                level=logging.DEBUG
            )
        else:
            # Python 3
            logging.basicConfig(
                filename='app.log',
                format=log_format,
                level=logging.DEBUG,
                encoding='utf-8'
            )
        self.logger = logging.getLogger(__name__)
    def check_environment(self):
        """检查环境"""
        self.logger.info(f"Python版本: {sys.version}")
        self.logger.info(f"操作系统: {os.name}")
        self.logger.info(f"工作目录: {os.getcwd()}")
        # 检查必需的环境变量
        required_vars = ['DATABASE_URL', 'API_KEY', 'LOG_LEVEL']
        for var in required_vars:
            if var not in os.environ:
                self.logger.warning(f"环境变量 {var} 未设置")
    def get_config(self, key, default=None):
        """获取配置"""
        # 优先使用环境变量
        env_key = key.upper()
        if env_key in os.environ:
            return os.environ[env_key]
        # 回退到配置文件
        # 这里可以添加配置文件读取逻辑
        return default
    def run_with_compatibility(self):
        """兼容运行"""
        try:
            # 尝试导入common模块
            from common import utils
            self.logger.info("使用common.utils模块")
        except ImportError:
            # 兼容处理
            self.logger.warning("common.utils不可用，使用内置函数")
            # 实现兼容功能
        # 跨版本兼容
        if sys.version_info[0] < 3:
            # Python 2兼容代码
            pass
        else:
            # Python 3代码
            pass
if __name__ == "__main__":
    adapter = EnvironmentAdapter()
    print("环境适配完成")

使用建议

模块化设计：将不同功能封装成独立模块
错误处理：对可能的兼容性问题进行异常捕获
日志记录：记录所有适配过程中的问题
渐进式适配：优先使用新功能，降级兼容旧版本
测试覆盖：编写测试用例确保适配正确性

这些示例涵盖了Python环境适配的主要方面,您可以根据具体需求进行调整和扩展。

标签： Python环境适配案例

本文地址： https://www.dfhcn.com/post/2000.html

文章来源： wen