如何动态调用Python函数

我有以下代码：

fields = ['name','email']

def clean_name():
    pass

def clean_email():
    pass

如何动态调用

clean\u name（）

和

clean\u email（）

例如：

for field in fields:
    clean_{field}()

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

如何使用Python实现这一点？

globals（）

将为您提供全局名称空间的

dict

。由此，您可以获得所需的功能：

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

那就叫它：

f()

---

使用

global

是一种非常非常糟糕的方法。你应该这样做：

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

for key in fields:
    fields[key]()

将函数映射到字典中的值

---

使用

vars（）[]

也是错误的。

最好有一个这样函数的字典，而不是查看

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)()

cleaned_email = cleaners['email'](some_email)

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

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

然后继承它并在继承的类上声明您的

clean

方法：

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

实际上，这可以进一步扩展，使其更干净。如果类中存在这样的方法，第一步可能是使用hasattr（）添加一个检查。

下面是另一种方法：

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)()

---

另一种方法是：定义函数，然后定义一个名称为键的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的字符串

---

请注意，任何需要构造字符串进行求值的方法都被认为是拙劣的。

我将使用字典将字段名映射到清理函数。如果某些字段没有相应的清理功能，则可以通过为这些情况提供某种默认功能来简化对它们的

循环处理。我的意思是：

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
的对应函数来动态构造函数字典。您可能只需要执行一次，因为只要字段列表或可用的清理函数没有更改，它就会保持不变。
如果不想使用
全局变量，VAR
并且不想创建单独的模块和/或类来封装要动态调用的函数，您可以将它们称为当前模块的属性：

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

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

回顾以前的答案：

globals是一种简单、快速的方法，但必须与函数名保持超级一致，如果变量被覆盖，它可能在运行时中断。而且它是非蟒蛇式的，不安全的，不道德的，雅达雅达

字典（即字符串到函数的映射）更安全、更易于使用。。。但是，我不得不将字典作业分散到我的文件中，这让我非常恼火，因为这些作业很容易丢失

装饰师为我设计了字典解决方案。decorator是将副作用和转换附加到函数定义的一种非常好的方法

示例时间

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

每当定义cleaner函数时，请将其添加到声明中：

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

函数的定义一经解析就添加到字典中，可以这样调用：

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

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

cleaned_email = cleaners['email'](some_email)

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

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


PeterSchorn提出的备选方案：

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

@add_cleaner
def email():
   #clean email

这将使用cleaner方法的函数名作为其字典键。
它更简洁，尽管我认为方法名称变得有点笨拙。
如果您有很多函数和不同数量的参数，请选择您最喜欢的。

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

我需要根据作为输入传递的方法名列表（用于在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
这样的方法，仔细了解如何在课堂上做到这一点：

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

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

cleaned_email = cleaners['email'](some_email)

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

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

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

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

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

cleaned_email = cleaners['email'](some_email)

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

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

因为应该避免使用vars（）和globals（），所以它们被认为是非pythonic的，并且它们通常需要字符串操作或使问题过于复杂。这是解决您的问题的最简单答案。使用globals（）将公开该范围内及其上的所有内容，这可能会造成安全风险，使任何能够访问globals（）返回的词典的人都可以操纵其内容。为了访问范围中的几个成员，您将公开所有内容，如果您显式地将字典定义为只包含必要的函数，那么其他程序员将更安全、更容易理解。vars（）只是稍微好一点，因为它不会只公开当前作用域中的内容而公开作用域上方的所有内容。@EOL:有一点，即使使用globals（）也不会公开任何不希望以其他方式访问的属性。然而，字典将包含比它需要的更多的项，如果对这些键的迭代不局限于您想要调用的那些函数，那么。。。我不想找到那只虫子。我在编写代码时考虑到了那些将来必须阅读并添加到我的代码中的人，只返回您想要返回的项目，使用globals（）之类的东西动态获取十几个函数是过度的，在我看来是不安全的。我同意lewisblackfan的观点，编写代码时，应该始终将维护代码的人视为一个知道你住在哪里的精神病患者。坏代码=想杀死你的疯子，以及如何通过参数