我有这段代码：
fields = ['name','email']
def clean_name():
pass
def clean_email():
pass
如何动态调用clean_name()和clean_email()？
例如：
for field in fields:
clean_{field}()
我使用了花括号，因为它是我以前在PHP中使用它的方式，但显然不起作用。
如何使用Python做到这一点？
答案 0 :(得分：54)
如果不想使用globals, vars并且不想创建单独的模块和/或类来封装要动态调用的函数，可以将它们称为当前模块的属性：< / p>
import sys
...
getattr(sys.modules[__name__], "clean_%s" % fieldname)()
答案 1 :(得分：34)
拥有这些功能的字典比查看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()的支票。
答案 2 :(得分：32)
使用global是一种非常非常糟糕的方法。你应该这样做：
fields = {'name':clean_name,'email':clean_email}
for key in fields:
fields[key]()
将函数映射到字典中的值。
同样使用vars()[]也是错误的。
答案 3 :(得分：6)
globals()将为您提供全局命名空间的dict。从这里你可以得到你想要的功能：
f = globals()["clean_%s" % field]
然后叫它：
f()
答案 4 :(得分：4)
这是另一种方式：
myscript.py：
def f1():
print 'f1'
def f2():
print 'f2'
def f3():
print 'f3'
test.py：
import myscript
for i in range(1, 4):
getattr(myscript, 'f%d' % i)()
答案 5 :(得分：2)
for field in fields:
vars()['clean_' + field]()
答案 6 :(得分：2)
这是另一种方式：定义函数然后定义一个名称为键的dict：
>>> 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的字符串。
请注意，任何需要构建字符串以进行评估的方法都被视为kludgy。
答案 7 :(得分：2)
我已经两次遇到这个问题，最后提出了一个安全和不难看的解决方案（以我的拙见）。
重新获得以前的答案：
globals 是一种简单，快捷且简便的方法，但是您必须与函数名超级一致，如果变量被覆盖，它可能会在运行时中断。也是非Python的，不安全的，不道德的，yadda yadda ...
字典（即字符串到函数的映射）更安全且易于使用...但是让我无休止的是，我不得不将字典分配分散到我的文件中，即容易忘记。
装饰器为我提供了词典解决方案。装饰器是将副作用和转换附加到函数定义的一种不错的方法。
示例时间
fields = ['name', 'email', 'address']
# set up our function dictionary
cleaners = {}
# this function will add stuff into the dictionary
def add_cleaner(key):
# this is a parametered decorator, it returns the actual decorator
def actual_decorator(func):
# add func to the dictionary
cleaners[key] = func
return func
return actual_decorator
每当定义一个清洁函数时，请将其添加到声明中：
@add_cleaner('email')
def email_cleaner(email):
#do stuff here
return result
函数一旦被解析就被添加到字典中，可以这样调用：
cleaned_email = cleaners['email'](some_email)
您可能想在脚本的底部添加这一行，以确保您不会忘记这一行。 ;）
assert(set(cleaners.keys()).issubset(fields))
答案 8 :(得分：1)
我会使用一个将字段名称映射到清理功能的字典。如果某些字段没有相应的清理功能，则可以通过为这些情况提供某种默认功能来使处理它们的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的相应函数来动态构造函数字典。您可能只需执行一次，因为只要字段列表或可用的清理功能未更改，它就会保持不变。
答案 9 :(得分：1)
我需要根据作为输入传递的方法名称列表（用于在 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)
答案 10 :(得分：0)
如果您有很多功能和不同数量的参数。
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