2

假设我有一个包含一堆方法的文件，如 bundle_methods.py：

def one(x):
  return int(x)

def two(y)
  return str(y)

有没有办法通过导入整个模块或选择方法来获取该组方法，并将导入的方法转换为类？

例如伪明智的

def make_class_from_module(which_module_or_listing_of_methods):
    class = turn_module_to_class(which_module_or_listing_of_methods)
    return class

所以

BunchClass = make_class_from_module(bunch_methods)

在我看来听起来很合法，但它的可行性如何？如果我应该这样做，我将如何开始做这样的事情，或者我的替代方案是什么？

我为什么要这样做？现在这是一个心理和学习练习，但我的具体用途是采取方法并创建烧瓶级的 FlaskView 类。我想可能会采取一些方法，并可能在 FlaskView 的不同上下文中使用和重用它们

4

4 回答 4

2

这是一个简单（但很长）的单线lambda，可以做你想做的事（部分灵感来自Bakuriu）。

classify = lambda module: type(module.__name__, (), {key: staticmethod(value) if callable(value) else value for key, value in ((name, getattr(module, name)) for name in dir(module))})

您可能会发现以下函数更易于阅读，并且循环更容易在推导中看到。

def classify(module):
    return type(module.__name__, (),
                {key: staticmethod(value) if callable(value) else value
                 for key, value in ((name, getattr(module, name))
                                    for name in dir(module))})

正如您在与口译员交谈时看到的那样，用法实际上与Bakuriu 的答案相同。

>>> import math
>>> MathClass = classify(math)
>>> MathClass.sin(5)
-0.9589242746631385
>>> instance = MathClass()
>>> instance.sin(5)
-0.9589242746631385
>>> math.sin(5)
-0.9589242746631385
>>>

附录：

在实现了将模块转换为类的一种用途后，编写了以下示例程序，展示了如何将转换后的模块用作基类。该模式可能不推荐用于常见用途，但确实显示了该概念的有趣应用。在下面显示的版本中，该classify功能也应该更容易阅读。

import math


def main():
    print(Point(1, 1) + Point.polar(45, Point.sqrt(2)))


def classify(module):
    return type(module.__name__, (), {
        key: staticmethod(value) if callable(value) else value
        for key, value in vars(module).items()
    })


class Point(classify(math)):

    def __init__(self, x, y):
        self.__x, self.__y = float(x), float(y)

    def __str__(self):
        return str((self.x, self.y))

    def __add__(self, other):
        return type(self)(self.x + other.x, self.y + other.y)

    @property
    def x(self):
        return self.__x

    @property
    def y(self):
        return self.__y

    @classmethod
    def polar(cls, direction, length):
        radians = cls.radians(direction)
        x = round(cls.sin(radians) * length, 10)
        y = round(cls.cos(radians) * length, 10)
        return cls(x, y)


if __name__ == '__main__':
    main()
于 2013-05-23T16:31:16.067 回答
1

不知道为什么要这样做，但一个简单的方法可能是：

def to_class(module):
    class TheClass(object): pass
    for attr in dir(module):
        val = getattr(module, attr)
        if callable(val):
            setattr(TheClass, attr, staticmethod(val))
    return TheClass

用法：

>>> import math
>>> Math = to_class(math)
>>> m = Math()
>>> m.sin(5)
-0.9589242746631385
>>> math.sin(5)
-0.9589242746631385
>>> Math.sin(5)
-0.9589242746631385

如果模块也有一些变量，您可以增强它以将不可调用的对象也添加到类中：

def to_class(module):
    class TheClass(object): pass
    for attr in dir(module):
        val = getattr(module, attr)
        if callable(val):
            setattr(TheClass, attr, staticmethod(val))
        else:
            setattr(TheClass, attr, val)
    return TheClass

然而，做更多的事情变得非常困难和丑陋，你必须有一个很好的理由这样做，否则就是浪费精力。

于 2013-05-23T15:17:18.533 回答
1

您也可以使用type元类来解决这个问题。用于生成类的格式type如下：

type(name of the class, 
   tuple of the parent class (for inheritance, can be empty), 
   dictionary containing attributes names and values)

首先，我们需要重新编写函数以将类作为第一个属性。

def one(cls, x):
    return int(x)

def two(cls, y):
    return str(y)

将其保存为 bundle_method.py，现在我们可以如下构造我们的类。

>>> import bunch_methods as bm
>>> Bunch_Class = type('Bunch_Class', (), bm.__dict__)
>>> bunch_object = Bunch_Class()
>>> bunch_object.__class__
<class '__main__.Bunch_Class'>
>>> bunch_object.one(1)
1
>>> bunch_object.two(1)
'1'

有关元类的优秀（和长）指南，请参阅以下帖子。 Python 中的元类是什么？

于 2013-05-23T15:39:12.483 回答
0

我不知道你为什么想要这个，因为你已经可以将模块用作一个类，但无论如何：

import bunch_methods as bm

print bm.one('1')
print bm.two(1)

class BunchClass:
    def __init__(self, methods):
        self.__dict__.update(methods.__dict__)

bc = BunchClass(bm)

print bc.one('2')
print bc.two(2)
于 2013-05-23T15:20:16.640 回答