Question

我的代码存在于GUI之外的文件中，但生成了GUI调用的方法。例如，此文件包含如下所示的函数：

# old code
def fixDictionary(dictionary, key, new_value):
    def fix():
        dictionary[key] = new_value
    return fix

在闭包中包装dictionary的一般方法很好，但是这种方法导致了许多用于创建无参数函数的样板代码。我为我做了一个简单的装饰工具，如下所示。

# new code
from functools import wraps

def strip_args(function):
    def outer(*args, **kwargs):

        @wraps(function)
        def inner():
            function(*args, **kwargs)
        return inner

    return outer

@strip_args
def fixDictionary(dictionary, key, new_value):
    dictionary[key] = new_value

作为参考，此函数的用法类似于：

dictionary = {'key': 'old_value'}

fixer = fixDictionary(dictionary, 'key', 'new_value')
fixer()

print(dictionary) # {'key': 'new_value'}

然后，我的代码中还有一堆方法如下：

# old code
def checkDictionary(dictionary):
    errors = []
    for key, value in dictionary.items():
        if value == 'old_value':
            error.append(fixDictionary(dictionary, key, 'new_value'))
    return errors

如果不清楚，这些方法会检查对象是否有错误，然后返回GUI可以调用的匿名函数，以便纠正这些错误。但是，所有这些方法都初始化一个空容器，向其中添加项目，然后返回它。为了删除所有这些函数中重复的代码，我写了另一个装饰器：

# new code
def init_and_return(**init_dict):
    if len(init_dict) != 1:
        raise ValueError('Exactly one "name=type" pair should be supplied')

    _name, _type = init_dict.items()[0]

    def outer(function):

        @wraps(function)
        def inner(*args, **kwargs):
            _value = _type()
            function.func_globals[_name] = _value
            function(*args, **kwargs)
            return _value
        return inner

    return outer

@init_and_return(errors=list)
def checkDictionary(dictionary):
    for key, value in dictionary.items():
        if value == 'old_value':
            errors.append(fixDictionary(dictionary, key, 'new_value'))

现在，最终用法如下所示：

dictionary = {'key': 'old_value'}
errors = checkDictionary(dictionary) # [<function fixDictionary at 0x01806C30>]
errors[0]()
print(dictionary) # {'key': 'new_value'}

这也很有效，并且允许我避免为这些功能编写更多的样板。关于上述实施，我有两个问题：

是否有更多Pythonic方式来实现此功能？目的是消除每个函数的所有样板代码，但编写函数strip_args和init_and_return肯定会使大脑紧张。虽然不应该经常写这样的函数，但它们似乎与它们的实际行为分开很远。
行function.func_globals[_name] = _value有不良行为;它允许从全局范围访问errors。这不是世界末日，因为每次调用一个函数时都会重置变量，但是我还是要设置局部变量吗？我已尝试将此行更改为locals()[_name] = _value，但范围不会继续执行此功能。这种级别的元编程是否超出了Python的预期范围？

Answer 1

我找到了一种方法来解决我的第二个问题，在init_and_return函数中实现一些簿记代码，检查它是否覆盖全局变量，然后如果是这样的话还原它（或删除）如果没有）。

def init_and_return(**init_dict):

    # this could be extended to allow for more than one k-v argument
    if len(init_dict) != 1:
        raise ValueError('Exactly one "name=type" pair should be supplied')

    _name, _type = init_dict.items()[0]
    def outer(function):

        @wraps(function)
        def inner(*args, **kwargs):

            # instantiate a new container
            _value = _type()

            # used to roll-back the original global variable
            _backup, _check = None, False

            # store original global variable (if it exists)
            if _name in function.func_globals:
                _backup = function.func_globals[_name]
                _check = True

            # add container to global scope
            function.func_globals[_name] = _value

            function(*args, **kwargs)

            # roll-back if it existed beforehand, delete otherwise
            if _check:
                function.func_globals[_name] = _backup
            else:
                del function.func_globals[_name]

            return _value
        return inner
    return outer

Pythonic创建闭包的方法

1 个答案: