优化嵌套类方法的输入验证，避免重复校验

针对你给出的类结构，要实现输入验证不重复执行，这里提供几个实用方案：

方案1：添加私有验证标记参数 #

给每个类方法增加一个默认值为False的私有参数（比如_verified），仅在内部调用时手动传入True，表示该值已通过验证。这样只有当外部直接调用方法时，才会执行验证逻辑。

修改后的代码示例：

class MyClass:
    @classmethod
    def _verify(cls, value):
        print(f"Verifying value: {value}")
        # 这里写实际的验证逻辑，比如检查类型、范围等
        if not isinstance(value, int):
            raise TypeError("Value must be an integer")

    @classmethod
    def method1(cls, value, _verified=False):
        if not _verified:
            cls._verify(value)
        print(f'method1 called with value: {value}')
        cls.method2(value, _verified=True)
        cls.method3(value, _verified=True)

    @classmethod
    def method2(cls, value, _verified=False):
        if not _verified:
            cls._verify(value)
        print(f'method2 does something with supplied value: {value}')

    @classmethod
    def method3(cls, value, _verified=False):
        if not _verified:
            cls._verify(value)
        print(f'method3 does something with supplied value: {value}')

这个方案实现简单，完全可控，不会影响类的全局状态，外部调用者不需要知道这个私有参数的存在。

方案2：使用上下文管理器管理验证状态 #

如果验证逻辑更复杂，或者需要处理多个值的验证，可以用上下文管理器来临时标记验证状态，避免重复校验。结合线程本地存储，还能避免多线程环境下的状态混乱。

代码示例：

import threading

class MyClass:
    # 线程本地存储，每个线程维护独立的验证状态
    _local = threading.local()

    @classmethod
    def _verify(cls, value):
        print(f"Verifying value: {value}")
        if not isinstance(value, int):
            raise TypeError("Value must be an integer")

    @classmethod
    def _verified_context(cls, value):
        cls._verify(value)
        # 标记当前值已验证
        cls._local.verified_values = {value}
        try:
            yield
        finally:
            # 退出上下文时清除标记，避免影响后续调用
            del cls._local.verified_values

    @classmethod
    def method1(cls, value):
        # 检查值是否已验证，未验证则进入上下文执行
        if not hasattr(cls._local, 'verified_values') or value not in cls._local.verified_values:
            with cls._verified_context(value):
                cls._method1_inner(value)
        else:
            cls._method1_inner(value)

    @classmethod
    def _method1_inner(cls, value):
        print(f'method1 called with value: {value}')
        cls.method2(value)
        cls.method3(value)

    @classmethod
    def method2(cls, value):
        if not hasattr(cls._local, 'verified_values') or value not in cls._local.verified_values:
            with cls._verified_context(value):
                print(f'method2 does something with supplied value: {value}')
        else:
            print(f'method2 does something with supplied value: {value}')

    @classmethod
    def method3(cls, value):
        if not hasattr(cls._local, 'verified_values') or value not in cls._local.verified_values:
            with cls._verified_context(value):
                print(f'method3 does something with supplied value: {value}')
        else:
            print(f'method3 does something with supplied value: {value}')

这个方案适合多线程场景，每个线程的验证状态独立，不会互相干扰，还能灵活处理多个值的验证需求。

方案3：装饰器结合线程本地存储 #

用装饰器封装验证逻辑，自动处理重复验证问题，让业务代码和验证逻辑解耦，代码更简洁。

代码示例：

import threading
from functools import wraps

class MyClass:
    _local = threading.local()

    @classmethod
    def _verify(cls, value):
        print(f"Verifying value: {value}")
        if not isinstance(value, int):
            raise TypeError("Value must be an integer")

    @classmethod
    def verify_once(cls, func):
        @wraps(func)
        def wrapper(value, *args, **kwargs):
            # 初始化线程本地的验证集合和调用计数器
            if not hasattr(cls._local, 'verified'):
                cls._local.verified = set()
            if not hasattr(cls._local, 'call_count'):
                cls._local.call_count = 0
            
            # 未验证过的话执行验证
            if value not in cls._local.verified:
                cls._verify(value)
                cls._local.verified.add(value)
            
            cls._local.call_count += 1
            try:
                return func(value, *args, **kwargs)
            finally:
                cls._local.call_count -= 1
                # 最外层调用结束后清除验证标记，避免影响后续调用
                if cls._local.call_count == 0:
                    cls._local.verified.clear()
                    del cls._local.call_count
        return wrapper

    @classmethod
    @verify_once
    def method1(cls, value):
        print(f'method1 called with value: {value}')
        cls.method2(value)
        cls.method3(value)

    @classmethod
    @verify_once
    def method2(cls, value):
        print(f'method2 does something with supplied value: {value}')

    @classmethod
    @verify_once
    def method3(cls, value):
        print(f'method3 does something with supplied value: {value}')

装饰器方案让业务代码更干净，线程本地存储保证了多线程环境下的安全性，计数器则用来在最外层调用结束后自动清理验证标记，不会影响后续的方法调用。

内容的提问来源于stack exchange，提问作者Silverwilly