对集合执行某些操作，然后返回与集合相同的类型

Question

我想将函数f应用于集合xs，但保留其类型。如果我使用map，我会得到一个“map object”：

def apply1(xs, f):
  return map(f, xs)

如果我知道xs类似于list或tuple，我可以强制它具有相同的类型：

def apply2(xs, f):
  return type(xs)(map(f, xs))

但是，对于namedtuple（我目前正在使用它）来说，这种情况很快就会崩溃——因为据我所知namedtuple需要用解包语法或调用它的_make函数来构造。而且，namedtuple是const，所以我不能遍历所有条目，而只是更改它们。你知道吗

使用dict会产生更多的问题。你知道吗

有没有一种通用的方法来表达这样一个apply函数，它适用于所有可iterable的东西？你知道吗

Answer 1

我有预感你是哈斯克尔人，对吗？（我猜是因为您使用f和xs作为变量名。）在Haskell中，您的问题的答案是“是的，它被称为fmap，但它只适用于定义了Functor实例的类型。”

另一方面，Python没有“Functor”的一般概念，所以严格地说，答案是否定的。要得到这样的东西，就必须依赖Python提供的其他抽象。你知道吗

ABCs救援

一种相当普遍的方法是使用abstract base classes。它们提供了一种结构化的方法来指定和检查特定的接口。Functor typeclass的Pythonic版本是一个抽象基类，它定义了一个特殊的fmap方法，允许单个类指定如何映射它们。但是没有这样的东西存在。（不过，我认为这将是对Python的一个非常酷的补充！）你知道吗

现在，您可以定义自己的抽象基类，这样就可以创建一个需要fmap接口的函子ABC，但是您仍然需要编写自己的list、dict等的所有函数化子类，所以这并不是很理想。你知道吗

更好的方法是使用现有接口拼凑出一个似乎合理的通用映射定义。您必须非常仔细地考虑需要组合现有接口的哪些方面。仅仅检查一个类型是否定义了__iter__是不够的，因为正如您已经看到的，类型的迭代定义不一定转化为构造定义。例如，对字典进行迭代只会得到关键字，但要以这种精确的方式映射字典，则需要对项进行迭代。你知道吗

具体例子

这里是一个抽象基类方法，它包括namedtuple的特殊情况和三个抽象基类Sequence、Mapping和Set。对于以预期方式定义上述任何接口的任何类型，它都将按预期的方式运行。然后返回到iterables的一般行为。在后一种情况下，输出的类型与输入的类型不同，但至少可以工作。你知道吗

from abc import ABC
from collections.abc import Sequence, Mapping, Set, Iterator

class Mappable(ABC):
    def map(self, f):
        if hasattr(self, '_make'):
            return type(self)._make(f(x) for x in self)
        elif isinstance(self, Sequence) or isinstance(self, Set):
            return type(self)(f(x) for x in self)
        elif isinstance(self, Mapping):
            return type(self)((k, f(v)) for k, v in self.items())
        else:
            return map(f, self)

我将其定义为ABC，因为这样可以创建从它继承的新类。但您也可以在任何类的现有实例上调用它，它的行为将与预期的一样。您也可以将上面的map方法用作独立函数。你知道吗

>>> from collections import namedtuple
>>> 
>>> def double(x):
...     return x * 2
... 
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(5, 10)
>>> Mappable.map(p, double)
Point(x=10, y=20)
>>> d = {'a': 5, 'b': 10}
>>> Mappable.map(d, double)
{'a': 10, 'b': 20}

定义ABC最酷的一点是，您可以将它用作“mix-in”。下面是一个MappablePoint派生自Point名称为duple的MappablePoint：

>>> class MappablePoint(Point, Mappable):
...     pass
... 
>>> p = MappablePoint(5, 10)
>>> p.map(double)
MappablePoint(x=10, y=20)

您还可以根据Azat Ibrakov's answer，使用functools.singledispatch装饰器稍微修改这种方法。（这对我来说是个新鲜事，他应该得到这部分答案的全部信任，但为了完整起见，我想我还是把它写下来吧。）

这看起来像下面这样。注意，我们仍然必须使用特殊情况namedtuple，因为它们破坏了元组构造函数接口。以前我并不介意，但现在我觉得这是一个非常恼人的设计缺陷。另外，我设置了一些东西，以便最终的fmap函数使用预期的参数顺序。（我想用mmap而不是fmap，因为“Mappable”比“Functor”IMO更像python，但是mmap已经是一个内置库了！该死的。）

import functools

@functools.singledispatch
def _fmap(obj, f):
    raise TypeError('obj is not mappable')

@_fmap.register(Sequence)
def _fmap_sequence(obj, f):
    if isinstance(obj, str):
        return ''.join(map(f, obj))
    if hasattr(obj, '_make'):
        return type(obj)._make(map(f, obj))
    else:
        return type(obj)(map(f, obj))

@_fmap.register(Set)
def _fmap_set(obj, f):
    return type(obj)(map(f, obj))

@_fmap.register(Mapping)
def _fmap_mapping(obj, f):
    return type(obj)((k, f(v)) for k, v in obj.items())

def fmap(f, obj):
    return _fmap(obj, f)

一些测试：

>>> fmap(double, [1, 2, 3])
[2, 4, 6]
>>> fmap(double, {1, 2, 3})
{2, 4, 6}
>>> fmap(double, {'a': 1, 'b': 2, 'c': 3})
{'a': 2, 'b': 4, 'c': 6}
>>> fmap(double, 'double')
'ddoouubbllee'
>>> Point = namedtuple('Point', ['x', 'y', 'z'])
>>> fmap(double, Point(x=1, y=2, z=3))
Point(x=2, y=4, z=6)

关于中断接口的最后说明

这两种方法都不能保证这将适用于所有被认为是Sequence的事物，以此类推，因为ABC机制不检查函数签名。这不仅是构造函数的问题，也是所有其他方法的问题。如果没有类型注释，这是不可避免的。你知道吗

但实际上，这可能并不重要。如果您发现自己使用的工具以奇怪的方式打破了接口约定，请考虑唱一首不同的歌。（实际上，我想说的是，namedtuple也是如此，因为我非常喜欢它们！）这就是许多Python设计决策背后的consenting adults哲学，在过去的几十年中，它一直运行得很好。你知道吗

Answer 2

看起来是^{} decorator的完美任务：

from functools import singledispatch


@singledispatch
def apply(xs, f):
    return map(f, xs)


@apply.register(list)
def apply_to_list(xs, f):
    return type(xs)(map(f, xs))


@apply.register(tuple)
def apply_to_tuple(xs, f):
    try:
        # handle `namedtuple` case
        constructor = xs._make
    except AttributeError:
        constructor = type(xs)
    return constructor(map(f, xs))

之后apply函数可以简单地使用如下

>>> apply([1, 2], lambda x: x + 1)
[2, 3]
>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(10, 5)
>>> apply(p, lambda x: x ** 2)
Point(x=100, y=25)

虽然我不知道dict对象需要什么样的行为，但是这种方法的伟大之处在于它很容易扩展。你知道吗