Python兼容工具案例如何封装版本兼容

本文目录导读：

1. 基础版本兼容装饰器
2. 具体兼容性实现示例
3. 高级封装类
4. 使用示例
5. 项目集成示例

我来为你提供一个完整的Python版本兼容工具封装案例,涵盖常见的兼容性场景：

基础版本兼容装饰器

# version_compat.py
import sys
import functools
from typing import Any, Callable, TypeVar, Tuple
F = TypeVar('F', bound=Callable[..., Any])
class VersionCompat:
    """版本兼容工具类"""
    @staticmethod
    def python_version():
        """获取Python版本信息"""
        return {
            'major': sys.version_info.major,
            'minor': sys.version_info.minor,
            'micro': sys.version_info.micro,
            'releaselevel': sys.version_info.releaselevel,
            'serial': sys.version_info.serial
        }
    @staticmethod
    def version_compare(min_version: str) -> bool:
        """比较当前版本是否满足最低版本要求"""
        current = sys.version_info[:2]
        required = tuple(map(int, min_version.split('.')))
        return current >= required
# 版本要求装饰器
def requires_version(min_version: str):
    """装饰器：要求最低Python版本"""
    def decorator(func: F) -> F:
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            if not VersionCompat.version_compare(min_version):
                raise RuntimeError(
                    f"需要Python {min_version}+，当前版本: "
                    f"{'.'.join(map(str, sys.version_info[:3]))}"
                )
            return func(*args, **kwargs)
        return wrapper  # type: ignore
    return decorator
# 多版本支持装饰器
def version_dispatcher(version_map: dict):
    """根据版本分发到不同实现"""
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            current_ver = f"{sys.version_info.major}.{sys.version_info.minor}"
            # 查找最匹配的版本
            matched_ver = None
            for ver in version_map:
                if current_ver.startswith(ver):
                    matched_ver = ver
                    break
            if matched_ver:
                return version_map[matched_ver](*args, **kwargs)
            return func(*args, **kwargs)
        return wrapper
    return decorator

具体兼容性实现示例

# compat_implementations.py
from version_compat import requires_version, version_dispatcher, VersionCompat
import sys
from typing import List, Any, Union
class StringIOCompat:
    """StringIO版本兼容封装"""
    @staticmethod
    def create_stringio():
        """创建StringIO对象"""
        if sys.version_info.major == 2:
            from StringIO import StringIO  # Python 2
        else:
            from io import StringIO  # Python 3+
        return StringIO()
class ConfigParserCompat:
    """ConfigParser版本兼容封装"""
    @staticmethod
    def create_parser():
        """创建ConfigParser对象"""
        if sys.version_info.major == 2:
            from ConfigParser import SafeConfigParser
            return SafeConfigParser()
        else:
            import configparser
            # Python 3.2+ 使用 ConfigParser
            return configparser.ConfigParser()
class UnicodeCompat:
    """Unicode处理版本兼容"""
    @staticmethod
    def is_str(obj: Any) -> bool:
        """检查是否为字符串"""
        if sys.version_info.major == 2:
            return isinstance(obj, (str, unicode))  # noqa: F821
        return isinstance(obj, str)
    @staticmethod
    def to_unicode(text: Union[str, bytes], encoding: str = 'utf-8') -> str:
        """转换为Unicode字符串"""
        if sys.version_info.major == 2:
            if isinstance(text, str):
                return text.decode(encoding)
            return text
        else:
            if isinstance(text, bytes):
                return text.decode(encoding)
            return text
class ItertoolsCompat:
    """itertools工具版本兼容"""
    @staticmethod
    def zip_longest(*iterables, fillvalue=None):
        """兼容版本的zip_longest"""
        if sys.version_info.major == 2:
            from itertools import izip_longest
            return izip_longest(*iterables, fillvalue=fillvalue)
        else:
            from itertools import zip_longest
            return zip_longest(*iterables, fillvalue=fillvalue)
    @staticmethod
    def accumulate(iterable, func=None):
        """兼容版本的accumulate (Python 3.2+)"""
        if sys.version_info >= (3, 2):
            from itertools import accumulate
            return accumulate(iterable, func)
        else:
            # 手动实现
            result = []
            iterator = iter(iterable)
            try:
                total = next(iterator)
            except StopIteration:
                return
            result.append(total)
            for element in iterator:
                total = func(total, element) if func else total + element
                result.append(total)
            return result

高级封装类

# advanced_compat.py
import sys
import inspect
from typing import Any, Dict, Optional, Callable
from functools import wraps
class AdvancedVersionCompat:
    """高级版本兼容封装"""
    def __init__(self):
        self._compat_map: Dict[str, Any] = {}
        self._rules: list = []
    def register(self, name: str, 
                 min_version: Optional[str] = None,
                 max_version: Optional[str] = None,
                 exact_version: Optional[str] = None):
        """注册兼容实现"""
        def decorator(func: Callable) -> Callable:
            @wraps(func)
            def wrapper(*args, **kwargs):
                # 检查版本条件
                if min_version and not self._check_min_version(min_version):
                    raise VersionError(f"需要Python {min_version}+")
                if max_version and self._check_min_version(max_version):
                    raise VersionError(f"仅支持Python {max_version}以下")
                if exact_version and not self._check_exact_version(exact_version):
                    raise VersionError(f"需要精确的Python {exact_version}")
                return func(*args, **kwargs)
            self._compat_map[name] = wrapper
            return wrapper
        return decorator
    def _check_min_version(self, version: str) -> bool:
        """检查最低版本"""
        current = sys.version_info[:2]
        required = tuple(map(int, version.split('.')))
        return current >= required
    def _check_exact_version(self, version: str) -> bool:
        """检查精确版本"""
        current = f"{sys.version_info.major}.{sys.version_info.minor}"
        return current == version
    def get_implementation(self, name: str) -> Optional[Callable]:
        """获取兼容实现"""
        return self._compat_map.get(name)
    def add_rule(self, condition: Callable, 
                 action: Callable,
                 version_specific: bool = False):
        """添加兼容规则"""
        self._rules.append({
            'condition': condition,
            'action': action,
            'version_specific': version_specific
        })
class VersionError(Exception):
    """版本错误异常"""
    pass
class CompatibleDict(dict):
    """兼容性字典"""
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._version_map = {}
    def set_version_value(self, key: str, value: Any, 
                          min_version: str = '0.0',
                          max_version: str = '99.99'):
        """设置版本特定值"""
        if key not in self._version_map:
            self._version_map[key] = []
        self._version_map[key].append({
            'value': value,
            'min_version': tuple(map(int, min_version.split('.'))),
            'max_version': tuple(map(int, max_version.split('.')))
        })
    def __getitem__(self, key):
        """获取适合当前版本的值"""
        if key in self._version_map:
            current = sys.version_info[:2]
            for entry in self._version_map[key]:
                if entry['min_version'] <= current <= entry['max_version']:
                    return entry['value']
        return super().__getitem__(key)

使用示例

# usage_example.py
from version_compat import requires_version, version_dispatcher
from compat_implementations import StringIOCompat, UnicodeCompat
from advanced_compat import AdvancedVersionCompat, CompatibleDict
# 1. 使用版本要求装饰器
@requires_version('3.6')
def modern_feature():
    """需要Python 3.6+的特性"""
    print("使用f-string")
    name = "World"
    return f"Hello, {name}!"
# 2. 版本分发
@version_dispatcher({
    '2.7': lambda x: f"Python 2.7: {x}",
    '3.6': lambda x: f"Python 3.6+: {x}"
})
def process_data(data):
    return f"默认处理: {data}"
# 3. 使用兼容工具类
def write_to_string():
    """使用兼容的StringIO"""
    buffer = StringIOCompat.create_stringio()
    buffer.write("Hello, Compatibility!")
    return buffer.getvalue()
# 4. 使用高级兼容器
compat = AdvancedVersionCompat()
@compat.register('process_data', min_version='3.6')
def modern_processor(data):
    return data.upper()
@compat.register('process_data', max_version='2.7')
def legacy_processor(data):
    return data.upper() + " (legacy)"
# 5. 使用兼容字典
compat_dict = CompatibleDict()
compat_dict['default'] = "默认值"
compat_dict.set_version_value('api_url', 'http://api.legacy.com', 
                              min_version='2.7', max_version='3.5')
compat_dict.set_version_value('api_url', 'http://api.modern.com',
                              min_version='3.6', max_version='99.99')
# 测试
if __name__ == "__main__":
    print(f"Python版本: {'.'.join(map(str, sys.version_info[:3]))}")
    try:
        result = modern_feature()
        print(f"Modern feature: {result}")
    except RuntimeError as e:
        print(f"版本不兼容: {e}")
    # 测试版本分发
    print(process_data("test data"))
    # 测试StringIO
    string_content = write_to_string()
    print(f"StringIO内容: {string_content}")
    # 测试兼容字典
    print(f"API URL: {compat_dict['api_url']}")

项目集成示例

# project_integration.py
from typing import Any, Dict, Optional
import sys
import json
class CompatibleProject:
    """兼容性项目封装示例"""
    def __init__(self, config_path: Optional[str] = None):
        self.config = self._load_config(config_path)
        self._init_compat_layer()
    def _load_config(self, config_path: Optional[str]) -> Dict[str, Any]:
        """加载配置"""
        default_config = {
            'encoding': 'utf-8',
            'use_new_features': False
        }
        if config_path:
            try:
                with open(config_path, 'r') as f:
                    loaded = json.load(f)
                default_config.update(loaded)
            except Exception:
                pass
        return default_config
    def _init_compat_layer(self):
        """初始化兼容层"""
        self.compat = AdvancedVersionCompat()
        # 注册兼容方法
        @self.compat.register('file_reader', min_version='3.0')
        def modern_file_reader(path: str) -> str:
            with open(path, 'r', encoding=self.config.get('encoding', 'utf-8')) as f:
                return f.read()
        @self.compat.register('file_reader', max_version='2.7')
        def legacy_file_reader(path: str) -> str:
            with open(path, 'r') as f:
                return f.read()
    def read_file(self, path: str) -> str:
        """读取文件（自动版本兼容）"""
        reader = self.compat.get_implementation('file_reader')
        if reader:
            return reader(path)
        raise NotImplementedError("没有可用的文件读取实现")
    def detect_environment(self) -> Dict[str, Any]:
        """检测运行环境"""
        return {
            'python_version': f"{sys.version_info.major}.{sys.version_info.minor}",
            'platform': sys.platform,
            'supports_fstrings': sys.version_info >= (3, 6),
            'supports_type_hints': sys.version_info >= (3, 5),
            'config': self.config
        }
# 使用示例
def main():
    project = CompatibleProject()
    env_info = project.detect_environment()
    print("环境信息:", json.dumps(env_info, indent=2))
    try:
        content = project.read_file("test.txt")
        print("文件内容:", content[:100] if content else "空文件")
    except Exception as e:
        print(f"读取失败: {e}")
if __name__ == "__main__":
    main()

这个封装案例提供了：

1. 基础兼容工具：版本检查、装饰器
2. 具体实现兼容：StringIO、ConfigParser等
3. 高级封装：规则系统、动态分发
4. 完整集成：配置文件、环境检测

使用时根据需要选择合适的兼容级别,确保代码在不同Python版本间平滑运行。