博客

详解Python 函子和应用型函子

  • Post category:Python

我们先从函子开始讲起。

Python函子详解

什么是函子？

在计算机科学中，函子（Functor）是一种对象，可将某些类型的对象（例如函数）映射到其他类型的对象。函子通常用于高阶编程，其中函数被视为第一类的对象，可以像任何其他对象一样来操作。函子可看作是可在其对象上运行的函数类型。

简而言之，函子是一种数据结构，它提供了将某个函数应用于函子数据结构内部每个元素的简单方法。

函子的实现

函子实现时需要实现__init__()、__repr__()、__call__()方法：

class Functor():
    def __init__(self, value):
        self.value = value

    def __repr__(self):
        return f"Functor({self.value})"

    def __call__(self, function):
        return Functor(function(self.value))

上面这个函子做的事情简单，它只是将函数应用于输入的值。

函数组合

函数组合（Function Composition）是指将一个函数作为参数传递给另一个函数，以产生新的函数。这称为函数组合，是一种主要的高阶函数技巧。在函数式编程中，函数组合非常常见。

例如，第一个函数f()将其输入加倍，而第二个函数g()将其输入加2。我们可以将它们组合在一起，以创建一个新函数，它首先将输入成倍，然后加上2。

def f(x):
    return x * 2

def g(x):
    return x + 2

def fg(x):
    return g(f(x))

print(fg(3))  # 8

上面这个代码块中，函数fg()首先将输入加倍，然后将其加2，并返回结果。我们可以使用函数组合更好地实现这个过程。

def f(x):
    return x * 2

def g(x):
    return x + 2

def compose(f, g):
    return lambda x: f(g(x))

fg = compose(f, g)

print(fg(3))  # 8

上面这个代码块中，我们定义了一个新函数compose()，使用lambda函数将两个函数f()和g()组合起来。然后，我们可以使用compose()函数轻松地定义新函数fg()。

应用型函子

应用型函子是一种特殊的函子实现，它是用于将函数应用于带有上下文的值的函子。它们在处理I/O操作时非常有用。应用型函子的一些常见示例包括Maybe、IO、List等。

我们以Maybe函子为例进行说明。

Maybe函子

Maybe函子表示可能存在的可选值的容器。如果该值存在，则返回Just包装的值，否则返回Nothing。考虑到Python中已经有了None，我们可以使用None表示Nothing，并用类似于Optional包装值的方法。

class Maybe:
    def __init__(self, value):
        self.__value = value

    def __repr__(self):
        if self.__value is None:
            return "Nothing"
        else:
            return f"Just({self.__value})"

    def __call__(self, func):
        if self.__value is None:
            return Maybe(None)
        else:
            try:
                return Maybe(func(self.__value))
            except Exception as e:
                return Maybe(None)

上述代码块中实现了Maybe函子，可封装可选值。如果值存在，则使用Just包装，否则返回Nothing。代码中的__call__()方法将函数应用于Maybe，因此如果Maybe中的值存在，则函数会返回Just包装的结果，否则返回Nothing。

接下来我们来看一下Maybe函子的应用。

def add_two(x):
    return x + 2

m1 = Maybe(2)
m2 = Maybe(None)

print(m1(add_two))  # Just(4)
print(m2(add_two))  # Nothing

上述代码块中，我们定义了一个简单的函数add_two()，它将输入加2。然后，我们将2和None封装到Maybe中，并将add_two()函数应用于它们。对于m1，结果为Just(4)，因为可能值是2；m2的结果为Nothing，因为封装的值为None。

另一个Maybe的例子是使用Maybe函子来从数据库中获取值：

class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email

    def __repr__(self):
        return f"User(name={self.name}, email={self.email})"

class UserRepository: 
    def __init__(self, db):
        self.db = db

    def find_by_email(self, email):
        return self.db.get(email)

class Database:
    def __init__(self, data):
        self.data = data

    def get(self, key):
        return self.data.get(key)

db = Database({
    "alice@example.com": {"name": "Alice", "email": "alice@example.com"},
    "bob@example.com": {"name": "Bob", "email": "bob@example.com"},
    "eve@example.com": {"name": "Eve", "email": "eve@example.com"},
})

user_repo = UserRepository(db)

may_email = Maybe("alice@example.com")
may_user = may_email(user_repo.find_by_email)
print(may_user(User))  # Just(User(name=Alice, email=alice@example.com))

may_email = Maybe("foo@example.com")
may_user = may_email(user_repo.find_by_email)
print(may_user(User))  # Nothing

上述代码块中定义了一个非常简单的用户模型，包含姓名和电子邮件字段，以及一个简单的用户库和数据源。然后，我们使用Maybe函子从数据库中获取可能存在的用户。如果在数据库中找到了输入的电子邮件，则返回包含用户信息的Just对象，否则返回Nothing对象。我们在每个结果之后输出该对象作为User对象的回调函数，并使用Python的特性实现。因此，对于存在于数据库中的值，将返回编号与输入电子邮件相同的用户信息：Just(User(name=Alice, email=alice@example.com))；对于不存在于库中的电子邮件，将返回Nothing。

Tags: