装饰器改变函数行为

Question

我发现我有两个不相关的函数，它们以不同的方式实现相同的行为。我现在想知道是否有办法通过装饰器有效地处理这个问题，以避免在其他地方添加行为时一遍又一遍地编写相同的逻辑。

基本上我在两个不同的类中有两个函数，它们有一个名为exact_match 的标志。这两个函数都在它们所属的对象中检查某种类型的等价性。 exact_match 标志强制函数检查浮点比较，而不是使用容差。你可以在下面看到我是如何做到这一点的。

def is_close(a, b, rel_tol=1e-09, abs_tol=0.0):
    return abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)


def _equal(val_a, val_b):
"""Wrapper for equality test to send in place of is_close."""
    return val_a == val_b

    @staticmethod
def get_equivalence(obj_a, obj_b, check_name=True, exact_match=False):
    equivalence_func = is_close
    if exact_match:
        # If we're looking for an exact match, changing the function we use to the equality tester.
        equivalence_func = _equal

    if check_name:
        return obj_a.name == obj_b.name

    # Check minimum resolutions if they are specified
    if 'min_res' in obj_a and 'min_res' in obj_b and not equivalence_func(obj_a['min_res'], obj_b['min_res']):
        return False

    return False

如您所见，标准过程让我们在不需要完全匹配时使用函数 is_close，但在需要时我们换掉函数调用。现在另一个函数需要同样的逻辑，换出函数。当我知道可能需要换出特定的函数调用时，有没有办法使用装饰器或类似的东西来处理这种类型的逻辑？

Answer 1

我想出了一个可能不太正确的替代解决方案，但答案让我按照我最初想要的方式解决问题。

我的解决方案使用一个实用程序类，它可以用作类的成员或作为该类的 mixin，以方便地提供实用程序功能。下面，函数_equals 和is_close 在别处定义，因为它们的实现并不重要。

class EquivalenceUtil(object):
    def __init__(self, equal_comparator=_equals, inexact_comparator=is_close):
        self.equals = equal_comparator
        self.default_comparator = inexact_comparator

    def check_equivalence(self, obj_a, obj_b, exact_match=False, **kwargs):
        return self.equals(obj_a, obj_b, **kwargs) if exact_match else self.default_comparator(obj_a, obj_b, **kwargs)

这是一个简单的类，可以这样使用：

class BBOX(object):
    _equivalence = EquivalenceUtil()

    def __init__(self, **kwargs):
        ...

    @classmethod
    def are_equivalent(cls, bbox_a, bbox_b, exact_match=False):
        """Test for equivalence between two BBOX's."""
        bbox_list = bbox_a.as_list
        other_list = bbox_b.as_list
        for _index in range(0, 3):
            if not cls._equivalence.check_equivalence(bbox_list[_index], 
                                                      other_list[_index], 
                                                      exact_match=exact_match):
            return False
        return True

对于用户来说，这个解决方案对于如何在幕后检查事情更加不透明，这对我的项目很重要。此外，它非常灵活，可以在一个类中以多种方式重用，并且可以轻松添加到新类中。

在我原来的例子中，代码可以变成这样：

class TileGrid(object):

    def __init__(self, **kwargs):
        ...

    @staticmethod
    def are_equivalent(grid1, grid2, check_name=False, exact_match=False):
        if check_name:
            return grid1.name == grid2.name
        # Check minimum resolutions if they are specified
        if 'min_res' in grid1 and 'min_res' in grid2 and not cls._equivalence.check_equivalence(grid1['min_res'], grid2['min_res'], exact_match=exact_match):
            return False

        # Compare the bounding boxes of the two grids if they exist in the grid
        if 'bbox' in grid1 and 'bbox' in grid2:
            return BBOX.are_equivalent(grid1.bbox, grid2.bbox, exact_mach=exact_match)

        return False

我不能在一般情况下推荐这种方法，因为我不禁觉得它有一些代码味道，但它完全符合我的需要，并且会为我当前的代码库解决很多问题.我们有特定的要求，这是一个特定的解决方案。 chepner 的解决方案可能最适合让用户决定函数应如何测试等效性的一般情况。

Answer 2

不需要装饰器；只需将所需的函数作为参数传递给get_equivalence（现在只不过是一个适用的包装器 论点）。

def make_eq_with_tolerance(rel_tol=1e-09, abs_tol=0.0):
    def _(a, b):
        return abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)
    return _    

# This is just operator.eq, by the way
def _equal(val_a, val_b-):
    return val_a == val_b

def same_name(a, b):
    return a.name == b.name

现在get_equivalence 接受三个参数：要比较的两个对象 以及在这两个参数上调用的函数。

@staticmethod
def get_equivalence(obj_a, obj_b, equivalence_func):

    return equivalence_func(obj_a, obj_b)

一些示例调用：

get_equivalence(a, b, make_eq_with_tolerance())
get_equivalence(a, b, make_eq_with_tolerance(rel_tol=1e-12))  # Really tight tolerance
get_equivalence(a, b, _equal)
get_equivalence(a, b, same_name)