Python脚本如何适配Linux系统

wen python案例 2026-06-27 228

本文目录导读：

Python脚本如何适配Linux系统

路径处理
Python解释器路径
权限处理
包管理适配
环境变量与配置
系统特定功能适配
进程与守护进程处理
文件监视（inotify）
脚本入口点
完整的适配示例
重要提示

我来详细介绍Python脚本适配Linux系统的主要方面：

路径处理

import os
import sys
from pathlib import Path
# 使用pathlib（推荐）
home = Path.home()
config_path = Path.home() / ".config" / "myapp"
data_path = Path("/usr/local/share/myapp")
# 路径分隔符统一处理
file_path = os.path.join("dir", "subdir", "file.txt")
# Linux: dir/subdir/file.txt

Python解释器路径

#!/usr/bin/env python3
# 或者指定特定版本
#!/usr/bin/python3.8

权限处理

import os
import stat
def check_permissions():
    """检查文件权限"""
    path = "/usr/local/bin/script"
    if os.path.exists(path):
        mode = os.stat(path).st_mode
        is_executable = bool(mode & stat.S_IXUSR)
        return is_executable
def ensure_permissions(path):
    """确保可执行权限"""
    if not os.access(path, os.X_OK):
        os.chmod(path, stat.S_IRWXU | stat.S_IRGRP | stat.S_IXGRP | stat.S_IROTH | stat.S_IXOTH)

包管理适配

# requirements.txt 写法
# 使用系统包管理器（可选）
import subprocess
def install_packages():
    """检查并安装依赖"""
    try:
        import some_module
    except ImportError:
        if sys.platform == "linux":
            subprocess.check_call([
                sys.executable, "-m", "pip", "install", "some-package"
            ])

环境变量与配置

import os
from pathlib import Path
class LinuxConfig:
    """Linux配置管理"""
    @staticmethod
    def get_config_dir():
        """获取配置目录"""
        xdg_config = os.environ.get('XDG_CONFIG_HOME')
        if xdg_config:
            return Path(xdg_config)
        return Path.home() / ".config"
    @staticmethod
    def get_data_dir():
        """获取数据目录"""
        xdg_data = os.environ.get('XDG_DATA_HOME')
        if xdg_data:
            return Path(xdg_data)
        return Path.home() / ".local" / "share"
    @staticmethod
    def get_cache_dir():
        """获取缓存目录"""
        xdg_cache = os.environ.get('XDG_CACHE_HOME')
        if xdg_cache:
            return Path(xdg_cache)
        return Path.home() / ".cache"

系统特定功能适配

import platform
import subprocess
import shutil
class LinuxSystemAdapter:
    """Linux系统功能适配器"""
    def __init__(self):
        self.system = platform.system()
        self.is_linux = self.system == "Linux"
    def get_package_manager(self):
        """检测包管理器"""
        managers = {
            'apt': 'dpkg',
            'yum': 'rpm',
            'dnf': 'rpm',
            'pacman': None
        }
        for manager in managers:
            if shutil.which(manager):
                return manager
        return None
    def install_system_package(self, package_name):
        """安装系统包"""
        pm = self.get_package_manager()
        if pm == 'apt':
            subprocess.run(['sudo', 'apt', 'install', '-y', package_name])
        elif pm == 'yum':
            subprocess.run(['sudo', 'yum', 'install', '-y', package_name])
        elif pm == 'dnf':
            subprocess.run(['sudo', 'dnf', 'install', '-y', package_name])
        elif pm == 'pacman':
            subprocess.run(['sudo', 'pacman', '-S', package_name])
    @staticmethod
    def get_linux_version():
        """获取Linux版本"""
        if platform.system() == "Linux":
            try:
                with open("/etc/os-release") as f:
                    info = {}
                    for line in f:
                        if "=" in line:
                            key, value = line.strip().split("=", 1)
                            info[key] = value.strip('"')
                    return info.get("PRETTY_NAME", "Unknown")
            except:
                return platform.platform()

进程与守护进程处理

import signal
import daemon  # 需要安装: pip install python-daemon
class LinuxDaemon:
    """Linux守护进程"""
    def __init__(self, pid_file):
        self.pid_file = pid_file
    def run_as_daemon(self, func):
        """以守护进程运行"""
        with daemon.DaemonContext(
            pidfile=daemon.pidfile.PIDLockFile(self.pid_file),
            signal_map={
                signal.SIGTERM: self.cleanup,
                signal.SIGHUP: 'terminate',
            }
        ):
            func()
    def cleanup(self, signum, frame):
        """清理函数"""
        if os.path.exists(self.pid_file):
            os.remove(self.pid_file)
        sys.exit(0)

文件监视（inotify）

import inotify  # 需要安装: pip install inotify
class FileWatcher:
    """Linux文件监视器"""
    def __init__(self, path):
        self.path = path
        if sys.platform == 'linux':
            try:
                from inotify import adapters
                self.watcher = adapters.InotifyTree(path)
            except ImportError:
                # 回退到轮询方式
                self.watcher = None
    def watch(self, callback):
        """监视文件变化"""
        if self.watcher:
            for event in self.watcher.event_gen():
                if event is not None:
                    callback(event)
        else:
            # 使用轮询方式（跨平台）
            import time
            last_modified = os.path.getmtime(self.path)
            while True:
                current_mtime = os.path.getmtime(self.path)
                if current_mtime != last_modified:
                    last_modified = current_mtime
                    callback(None)
                time.sleep(1)

脚本入口点

#!/usr/bin/env python3
import sys
import argparse
def main():
    """主函数"""
    parser = argparse.ArgumentParser(description="Linux适配脚本")
    parser.add_argument("--version", action="version", version="1.0.0")
    parser.add_argument("-c", "--config", help="配置文件路径")
    parser.add_argument("-d", "--daemon", action="store_true", help="以守护进程运行")
    args = parser.parse_args()
    # 检查是否为Linux系统
    if sys.platform != "linux":
        print("警告: 此脚本专为Linux设计", file=sys.stderr)
    # 主要逻辑
    print("脚本运行在:", platform.system())
if __name__ == "__main__":
    main()

完整的适配示例

#!/usr/bin/env python3
"""
Linux系统适配完整示例
"""
import os
import sys
import platform
import logging
from pathlib import Path
# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)
class LinuxAdapter:
    """Linux系统适配器"""
    def __init__(self):
        self._check_environment()
    def _check_environment(self):
        """检查运行环境"""
        if platform.system() != "Linux":
            logger.warning("检测到非Linux系统，部分功能可能不可用")
        # 检查Python版本
        if sys.version_info < (3, 6):
            logger.error("需要Python 3.6+")
            sys.exit(1)
    def get_system_info(self):
        """获取系统信息"""
        return {
            'system': platform.system(),
            'release': platform.release(),
            'version': platform.version(),
            'python': sys.version,
            'architecture': platform.machine()
        }
    def ensure_directories(self):
        """确保必要目录存在"""
        dirs = [
            Path.home() / ".config" / "myapp",
            Path.home() / ".local" / "share" / "myapp",
            Path.home() / ".cache" / "myapp"
        ]
        for dir_path in dirs:
            dir_path.mkdir(parents=True, exist_ok=True)
            logger.info(f"创建目录: {dir_path}")
    def check_dependencies(self):
        """检查系统依赖"""
        dependencies = ['gcc', 'make', 'python3-dev']
        missing = []
        for dep in dependencies:
            if not self._is_command_available(dep):
                missing.append(dep)
        if missing:
            logger.warning(f"缺少系统依赖: {', '.join(missing)}")
            return False
        return True
    def _is_command_available(self, cmd):
        """检查命令是否可用"""
        import shutil
        return shutil.which(cmd) is not None
def main():
    """主函数"""
    adapter = LinuxAdapter()
    # 获取系统信息
    info = adapter.get_system_info()
    logger.info(f"系统信息: {info['system']} {info['release']}")
    # 确保目录结构
    adapter.ensure_directories()
    # 检查依赖
    adapter.check_dependencies()
    # 主要业务逻辑
    logger.info("脚本启动成功")
if __name__ == "__main__":
    main()