Python泛型方法作用域

我有一个类，它用一些元数据包装函数，特别是与其他实例的父关系：

class Foo(object):
    def __init__(self, func, parent):
        self.func = func
        self.parent = parent
        self.parent_func = self.parent.func

在一些情况下，我想使用

Foo

包装一个函数，该函数在内部调用另一个Foo的函数：

def f(x): return str(x).title()
def g(x): return self.parent_func(x)
a = Foo(f)
b = Foo(g, a)
print b.func("april is the cruellest month")
>>> April Is The Cruellest Month

问题是

g

在

b

运行

Foo.\uuuuu init\uuuuu

之前实际上不是一个方法，所以它没有一个self

我假设在范围界定、对象方法或函数的一流公民身份方面，我缺少一些基本的东西，我非常希望在正确的方向上找到一点

---

编辑：看起来我上面的泛化示例让人很反感，所以我在下面添加了一个更具体的示例。此类的思想是，每个实例都是一个整数属性（素性、完美性、因子列表等），并包含一个函数，用于测试该属性的整数（返回布尔值或答案，视情况而定）

---

调用对象方法时，将使用self作为第一个参数进行调用

def f(self,x): return str(x).title()
def g(self,x): return self.parent_func(x)

正如马修所说，“父母关系”将指向继承。但如果你想/必须这样做，你可以使用：

---

您的问题似乎归结为“如何动态地向对象添加方法”，简短的答案是“不要这样做”（1）。对象可以有属性，这些属性可以是函数，这很好，但是这些函数不会变成方法，也不会像方法那样工作。例如，如果

foo.attr是sum

，那么

foo.attr（x）

与

sum（x）

相同，而不是

sum（foo，x）

你的问题有某种功能性的“芳香”，如果你想放弃类/对象的东西，走完全功能性的路线，你可以这样做：

def identity(x):
    return x

def f(n):
    return [i for i in range(1, 10) if (n % i == 0)]

def s(factors):
    return (len(factors) == 2)

def foo(func, helper=identity):
    def innerfunc(n):
        return func(helper(n))
    return innerfunc

a = foo(f)
print a(6)
# [1, 2, 3, 6]
b = foo(s, a)
print b(5)
# True

如果您对此不感兴趣，我建议您将

Foo

类上的

func

和

parent

属性视为附加到对象的数据，而不是方法，然后从中解决问题。与类关联的逻辑应该存在于适当的方法中。这些方法可以根据需要引用数据。下面是我的一个非常简单的例子：

class Foo(object):
    def __init__(self, func, parent=None):
        self.func = func
        self.parent = parent

    def run(self, n):
        if self.parent is None:
            return self.func(n)
        else:
            return self.func(self.parent.run(n))

a = Foo(f)
print a.run(6)
# [1, 2, 3, 6]
b = Foo(s, a)
print b.run(5)
# True

---

（1） 方法属于一个类而不是一个对象，所以问题应该是如何将行为类似于方法的东西附加到我的对象上。

Hi Bi Rico:非常感谢您的详细回答。你们都发现了我的误解（方法属于类而不是实例）以及导致误解的更深层次的问题（将函数编程习惯混入我的OOP）。

def identity(x):
    return x

def f(n):
    return [i for i in range(1, 10) if (n % i == 0)]

def s(factors):
    return (len(factors) == 2)

def foo(func, helper=identity):
    def innerfunc(n):
        return func(helper(n))
    return innerfunc

a = foo(f)
print a(6)
# [1, 2, 3, 6]
b = foo(s, a)
print b(5)
# True

class Foo(object):
    def __init__(self, func, parent=None):
        self.func = func
        self.parent = parent

    def run(self, n):
        if self.parent is None:
            return self.func(n)
        else:
            return self.func(self.parent.run(n))

a = Foo(f)
print a.run(6)
# [1, 2, 3, 6]
b = Foo(s, a)
print b.run(5)
# True