Python：带方法的高阶函数

在Python中，是否有向高阶函数传递方法的方法，就像传递常规函数一样

例如，假设我有一个字符串“str”，根据某些条件“cond”，我想对该字符串应用一些任意方法“meth”，并返回它。代码：

def func(str, meth, cond):
    ...
    if cond:
        str.meth()
    ...

现在，我知道上述方法不起作用。我也知道我可以写一些东西，比如：

def func(str, meth, cond):
    ...
    if cond:
        str = meth
    ...

然后像这样将我要执行的对象和方法传递给func:func（str，str.capitalize（），cond）。上述问题在于：

上面的代码没有明确说明函数的意图

例如，如果我想在应用该方法之前修改中的“str”，那么结果就不正确。考虑：

def func(str, meth, cond):
    ...
    str += "a"
    ...
    if cond:
        str = meth
    ...

不会按预期工作

---

那么，回到开头：是否有任何方法可以实现我想要的？还是我完全从错误的方向来处理这个问题？

这不允许您完全按照您的需要调用函数，但它非常接近，因此可能解决了您的问题

def函数（str、meth、cond）：
如果条件：
str=getattr（str，meth）（）
返回str
打印函数（“a”，“大写”，真）
打印函数（“a”、“大写”、“假”）

这不允许您完全按照自己的意愿调用函数，但它非常接近，因此可能解决了您的问题

def函数（str、meth、cond）：
如果条件：
str=getattr（str，meth）（）
返回str
打印函数（“a”，“大写”，真）
打印函数（“a”、“大写”、“假”）

您可以像传递任何函数一样将方法传递给高阶函数，只需将其作为

对象传递即可。方法

：

class Foo(object):
    def upper(self, s):
        return s.upper()

def func(s, method, cond):
    if cond:
        return method(s)
    else:
        return s

obj = Foo()
s = 'hello world'

print(func(s, obj.upper, 'hello' in s))   
print(func(s, obj.upper, 'goodbye' in s))

结果:

HELLO WORLD
hello world

或者，如果您可以尝试：

def func(s, method, cond):
    if cond:
        return method()
    else:
        return s

s = 'hello world'

print(func(s, s.upper, 'hello' in s))
print(func(s, s.upper, 'goodbye' in s))

---

但是，正如注释中指出的，如果函数中有一个语句为

s=s+'a'

，则第二种方法将不起作用，因为您只是将局部变量

s

绑定到一个新字符串，虽然

method

仍然绑定到最初传递给函数的字符串的

upper

方法。

可以像传递任何函数一样将方法传递给高阶函数，只需将其作为

对象传递。method

：

class Foo(object):
    def upper(self, s):
        return s.upper()

def func(s, method, cond):
    if cond:
        return method(s)
    else:
        return s

obj = Foo()
s = 'hello world'

print(func(s, obj.upper, 'hello' in s))   
print(func(s, obj.upper, 'goodbye' in s))

结果:

HELLO WORLD
hello world

或者，如果您可以尝试：

def func(s, method, cond):
    if cond:
        return method()
    else:
        return s

s = 'hello world'

print(func(s, s.upper, 'hello' in s))
print(func(s, s.upper, 'goodbye' in s))

---

但是，正如注释中指出的，如果函数中有一个语句为

s=s+'a'

，则第二种方法将不起作用，因为您只是将局部变量

s

绑定到一个新字符串，虽然

method

仍然绑定到最初传递给函数的字符串的

upper

方法。

我想你应该将meth作为一个无界方法传递，因此它可以动态绑定到另一个对象

>>> class C(object):
...     def foo(self):
...             print self
... 
>>> C.foo
<unbound method C.foo>
>>> C().foo
<bound method C.foo of <__main__.C object at 0xb708216c>>
>>> def func(obj, meth):
...     meth(obj)
... 
>>> c = C()
>>> func(c, C.foo)
<__main__.C object at 0xb70822ac>
>>> c
<__main__.C object at 0xb70822ac>

>>C类（对象）：
...     def foo（self）：
...             打印自我
... 
>>>C.foo
>>>C.foo
>>>def func（目标、方法）：
...     甲基苯丙胺（obj）
... 
>>>c=c（）
>>>func（c，c.foo）
>>>c

---

你可以把一个无界方法看作是一个规则，它必须把一个对象作为它的第一个参数

我想你应该把meth作为一个无界方法来传递，这样它就可以动态地绑定到另一个对象

>>> class C(object):
...     def foo(self):
...             print self
... 
>>> C.foo
<unbound method C.foo>
>>> C().foo
<bound method C.foo of <__main__.C object at 0xb708216c>>
>>> def func(obj, meth):
...     meth(obj)
... 
>>> c = C()
>>> func(c, C.foo)
<__main__.C object at 0xb70822ac>
>>> c
<__main__.C object at 0xb70822ac>

>>C类（对象）：
...     def foo（self）：
...             打印自我
... 
>>>C.foo
>>>C.foo
>>>def func（目标、方法）：
...     甲基苯丙胺（obj）
... 
>>>c=c（）
>>>func（c，c.foo）
>>>c

---

您可以将无界方法视为必须将对象作为其第一个参数的常规方法

不太确定您的要求，但您可以传递如下函数

def func(str, meth, cond):
    ...
    ...
    if cond:
        return meth(str)
    ...

然后像这样运行：（例如小写）

---

应该返回“abc”

我不太确定你在问什么，但是你可以传递如下函数

def func(str, meth, cond):
    ...
    ...
    if cond:
        return meth(str)
    ...

然后像这样运行：（例如小写）

---

应该返回“abc”

我认为除了解释您打算实现它之外，您还应该给出更多的示例，说明您想如何使用这个

func

？您打算

str=meth

做什么？我有一个你正在寻找的预感。我认为除了解释你打算实现什么，你还应该给出更多的例子，说明你想如何使用这个

func

？你打算做什么？我有一种预感，你在寻找。这正是我们想要做的。谢谢。在调用方法之前在“func”中修改字符串的情况下，建议使用“s.upper”的第二种替代方法是否有效？不，这是一个非常好的观点。字符串是不可变的，因此如果执行

s=s+'a'

，您只是将局部变量

s

绑定到一个新字符串，但是

method

仍然绑定到旧字符串的

s.upper

，而没有额外的“a”。这正是我们想要做的。谢谢。在调用方法之前在“func”中修改字符串的情况下，建议使用“s.upper”的第二种替代方法是否有效？不，这是一个非常好的观点。字符串是不可变的，因此如果执行

s=s+'a'

，则只需将局部变量

s

绑定到一个新字符串，但是

method

仍然绑定到旧字符串的

s.upper

，而不使用额外的“a”。