如何动态调用 Python 函数[重复]

问题描述：

我有这个代码：

fields = ['name','email']

def clean_name():
    pass

def clean_email():
    pass

我如何动态调用clean_name()和clean_email()？

例如：

for field in fields:
    clean_{field}()

我使用花括号，因为这是我在 PHP 中常用的方法，但显然不起作用。

如何用 Python 做到这一点？

解决方案 1：

如果不想使用globals, vars也不想创建单独的模块和/或类来封装您想要动态调用的函数，那么您可以将它们作为当前模块的属性来调用：

import sys
...
getattr(sys.modules[__name__], "clean_%s" % fieldname)()

解决方案 2：

使用global这种方法非常非常糟糕。你应该这样做：

fields = {'name':clean_name,'email':clean_email}

for key in fields:
    fields[key]()

将您的函数映射到字典中的值。

使用也是vars()[]错误的。

解决方案 3：

最好有一本此类函数的字典，而不是查找globals()。

通常的方法是编写一个具有此类功能的类：

class Cleaner(object):
    def clean_name(self):
        pass

然后使用getattr来访问它们：

cleaner = Cleaner()
for f in fields:
    getattr(cleaner, 'clean_%s' % f)()

你甚至可以更进一步做这样的事情：

class Cleaner(object):
    def __init__(self, fields):
        self.fields = fields

    def clean(self):
        for f in self.fields:
            getattr(self, 'clean_%s' % f)()

然后继承它并clean_<name>在继承的类上声明你的方法：

cleaner = Cleaner(['one', 'two'])
cleaner.clean()

实际上，这可以进一步扩展以使其更简洁。第一步可能是添加一个检查，看看hasattr()你的类中是否存在这种方法。

解决方案 4：

我现在已经遇到过两次这个问题，最后想出了一个安全而且不丑陋的解决方案（以我的拙见）。

回顾先前的答案：

globals是一种 hacky、快速且简单的方法，但你必须对函数名称保持高度一致，并且如果变量被覆盖，它可能会在运行时中断。此外，它不符合 Python 风格，不安全，不道德，等等等等……

字典（即字符串到函数的映射）更安全且易于使用......但它让我烦恼不已，因为我必须将字典分配分散到整个文件中，而这很容易丢失。

装饰器帮我找到了字典解决方案。装饰器是一种将副作用和转换附加到函数定义的好方法。

示例时间

fields = ['name', 'email', 'address']

# set up our function dictionary
cleaners = {}

# this is a parametered decorator
def add_cleaner(key):
    # this is the actual decorator
    def _add_cleaner(func):
        cleaners[key] = func
        return func
    return _add_cleaner

每当你定义一个更清晰的函数时，将其添加到声明中：

@add_cleaner('email')
def email_cleaner(email):
    #do stuff here
    return result
    

一旦函数定义被解析，它就会被添加到字典中，并且可以像这样调用：

cleaned_email = cleaners['email'](some_email)

PeterSchorn 提出的替代方案：

def add_cleaner(func):
    cleaners[func.__name__] = func
    return func

@add_cleaner
def email():
   #clean email

这使用更简洁方法的函数名称作为其字典键。虽然我认为方法名称变得有点尴尬，但它更简洁。选择您最喜欢的。

解决方案 5：

globals()将为您提供dict全局命名空间。从中您可以获得所需的函数：

f = globals()["clean_%s" % field]

然后调用它：

f()

解决方案 6：

这是另一种方法：

myscript.py：

def f1():
    print 'f1'

def f2():
    print 'f2'

def f3():
    print 'f3'

测试.py：

import myscript

for i in range(1, 4):
    getattr(myscript, 'f%d' % i)()

解决方案 7：

我有一个需求，根据作为输入传递的方法名称列表，在类本身的方法中调用类的不同方法（用于在 FastAPI 中运行定期任务）。对于执行 Python 类的方法，我扩展了 @khachik 提供的答案。以下是如何从类内部或外部实现它：

>>> class Math:
...   def add(self, x, y):
...     return x+y
...   def test_add(self):
...     print(getattr(self, "add")(2,3))
... 
>>> m = Math()
>>> m.test_add()
5
>>> getattr(m, "add")(2,3)
5

仔细看看如何在课堂内部使用如下方式完成self此操作：

getattr(self, "add")(2,3)

并从类外部使用类的对象，如下所示：

m = Math()
getattr(m, "add")(2,3)

解决方案 8：

这是另一种方法：定义函数，然后定义一个以名称作为键的字典：

>>> z=[clean_email, clean_name]
>>> z={"email": clean_email, "name":clean_name}
>>> z['email']()
>>> z['name']()

然后循环遍历名称作为键。

或者这个怎​​么样？构造一个字符串并使用 'eval'：

>>> field = "email"
>>> f="clean_"+field+"()"
>>> eval(f)

然后只需循环并构造用于 eval 的字符串。

请注意，任何需要构造字符串进行评估的方法都被视为笨拙的方法。

解决方案 9：

for field in fields:
    vars()['clean_' + field]()

解决方案 10：

如果您有很多功能和不同数量的参数。

class Cleaner:
    @classmethod
    def clean(cls, type, *args, **kwargs):
        getattr(cls, f"_clean_{type}")(*args, **kwargs)

    @classmethod
    def _clean_email(cls, *args, **kwargs):
        print("invoked _clean_email function")

    @classmethod
    def _clean_name(cls, *args, **kwargs):
        print("invoked _clean_name function")


for type in ["email", "name"]:
    Cleaner.clean(type)

输出：

invoked _clean_email function
invoked _clean_name function

解决方案 11：

我会使用一个将字段名称映射到清理函数的字典。如果某些字段没有相应的清理函数，for则可以通过为这些情况提供某种默认函数来简化处理它们的循环。我的意思是：

fields = ['name', 'email', 'subject']

def clean_name():
    pass
def clean_email():
    pass

# (one-time) field to cleaning-function map construction
def get_clean_func(field):
    try:
        return eval('clean_'+field)
    except NameError:
        return lambda: None  # do nothing
clean = dict((field, get_clean_func(field)) for field in fields)

# sample usage
for field in fields:
    clean[field]()

上面的代码通过确定clean_<field>列表中每个函数是否存在对应的函数来动态构建函数字典fields。您可能只需要执行一次，因为只要字段列表或可用的清理函数没有改变，它就会保持不变。