如何运行python文件中的所有方法，并返回是否有任何方法返回true？

如何运行python文件中的所有方法，并返回是否有任何方法返回true

我尝试的是如下所示：

def rule1(content):
    if content has a value1:
        return true
    return false

def rule2(content):
    if content has a value2:
        return true
    return false

...

def main(content):
    return rule1(content) or rule2(content) or ... or ruleN(content)  #The code line that I don't like

这个wll将被导入到另一个python文件中，并被称为：

import rules.py

...

def foo():
    ...
    if(rules.main(content)):
        some action

规则将不断添加，因此main方法中的行看起来不太好

即使添加了新规则，我是否可以使主方法在以后不必更改

---

谢谢：

像这样的东西应该有用。只需使用inspect获取当前模块中以rule开头的所有函数，然后调用这些函数

import sys
import inspect


# All your functions...


def main(content):
    for name, ref in inspect.getmembers(sys.modules[__name__]):
        if callable(ref) and name.startswith("rule") and ref(content):
            return True
    return False

---

这样的办法应该行得通。只需使用inspect获取当前模块中以rule开头的所有函数，然后调用这些函数

import sys
import inspect


# All your functions...


def main(content):
    for name, ref in inspect.getmembers(sys.modules[__name__]):
        if callable(ref) and name.startswith("rule") and ref(content):
            return True
    return False

---

你必须把所有的规则组织在一起。这可以通过将它们放入列表来实现，手动更新，可能不需要，标记它们您可以使用装饰器来标记它们，以相同的方式命名它们，所有这些都从规则开始，或者将它们放置在类中。我认为使用类是最直接的方法

class rules:
   def rule1(self,content):
      ...
   def rule2(self,content):
      ...

def main(content):
    r = rules()
    return all(getattr(r,m)(content) for m in dir(r) if not m.startswith('_'))

---

如果您不想要self，那么使用@staticmethod

您必须将所有规则组织在一起。这可以通过将它们放入列表来实现，手动更新，可能不需要，标记它们您可以使用装饰器来标记它们，以相同的方式命名它们，所有这些都从规则开始，或者将它们放置在类中。我认为使用类是最直接的方法

class rules:
   def rule1(self,content):
      ...
   def rule2(self,content):
      ...

def main(content):
    r = rules()
    return all(getattr(r,m)(content) for m in dir(r) if not m.startswith('_'))

---

如果您不想要self，那么使用@staticmethod

这似乎是一个非常愚蠢的攻击，但您可以将所有规则函数移动到主函数的作用域内，然后通过内置的局部变量返回的dict循环调用每个函数

def main(content):
    def rule1(content):
        return content == 1

    def rule2(content):
        return content == 2

    funcs = [loc for _, loc in locals().items() if type(loc)==type(rule1)]
    return any([func(content) for func in funcs])

print(main(1))
print(main(2))
print(main(3))

---

这似乎是一个非常愚蠢的攻击，但您可以将所有规则函数移动到主函数的作用域内，然后通过内置的局部函数返回的dict循环调用每个函数

def main(content):
    def rule1(content):
        return content == 1

    def rule2(content):
        return content == 2

    funcs = [loc for _, loc in locals().items() if type(loc)==type(rule1)]
    return any([func(content) for func in funcs])

print(main(1))
print(main(2))
print(main(3))

您还可以使用来获取包含dunder函数的列表。假设您使用的类似规则的东西只在您想要的函数中使用，那么下面的方法就可以了

Rules.py

def规则1内容： 如果内容不是无： 返回真值 返回错误 def规则2内容： 如果内容不是无： 返回真值 返回错误 rule_master.py

导入zzMisc.rules def foocontent=None： func_list=dirzzMisc.rules 对于功能列表中的功能项： 如果功能项中有“规则”： func_to_run=getattrzzMisc.rules，func_项 printf'func_item}的结果为->{func_to_runcontent}' 富‘有内容’ 福 结果:

result for rule1 is --> True
result for rule2 is --> True
result for rule1 is --> False
result for rule2 is --> False

您还可以使用来获取包含dunder函数的列表。假设您使用的类似规则的东西只在您想要的函数中使用，那么下面的方法就可以了

Rules.py

def规则1内容： 如果内容不是无： 返回真值 返回错误 def规则2内容： 如果内容不是无： 返回真值 返回错误 rule_master.py

导入zzMisc.rules def foocontent=None： func_list=dirzzMisc.rules 对于功能列表中的功能项： 如果功能项中有“规则”： func_to_run=getattrzzMisc.rules，func_项 printf'func_item}的结果为->{func_to_runcontent}' 富‘有内容’ 福 结果:

result for rule1 is --> True
result for rule2 is --> True
result for rule1 is --> False
result for rule2 is --> False

---

仅基于您的帖子描述，此类设计可以实现如下目的：

def rule1(content):
    value = 'a'
    if value in content:
        return True
    return False

def rule2(content):
    value = 'b'
    if value in content:
        return True
    return False

def main(content):
    ret = False
    for fn in globals().values():
        if callable(fn) and fn != main: 
            ret = ret or fn(content)
    return ret

if __name__ == '__main__':
    assert main('ab') == True
    assert main('dc') == False

这不是一个理想的设计，因为：1如果您曾经需要在此处添加其他不应该在此或操作上挂接的函数，则需要将If验证的第二部分添加到不允许的函数列表中。2即使通配符导入本应避免，但有时也会发生，这也会破坏您的逻辑

对于更可靠的设计，我需要考虑每个关系检查的复杂程度：

1如果它们仍然像一个单独的小行验证，那么我将尝试使用map获取lambda列表：

2如果您的目的是使这种关系比较随着时间的推移变得更加复杂，但永远不会从一行程序中传递，那么我们可能需要一个lambda列表，并应用一个过滤器

3另一种方法是将这些函数分组为类方法。封装将为尝试索引此函数提供更高的安全性：

class RuleFilter(object):

    def rule1(self, content):
        value = 'a'
        if value in content:
            return True
        return False

    def rule2(self, content):
        value = 'b'
        if value in content:
            return True
        return False

    def apply(self, content):
        ret = False
        for attr in dir(self):
            field_obj = getattr(self, attr)
            if hasattr(field_obj, '__func__') and field_obj != self.apply:
                ret = ret or field_obj(content)
        return ret

def main(content):
    return RuleFilter().apply(content)

if __name__ == '__main__':
    assert main('ab') == True
    assert main('dc') == False

---

通过apply传递内容将避免将_init__标记为有界方法。如果您想通过初始值设定项传递内容，请记住扩展您的If以跳过它，就像我们对apply方法本身所做的那样。

仅基于您的帖子描述，这样的设计可以实现如下：

def rule1(content):
    value = 'a'
    if value in content:
        return True
    return False

def rule2(content):
    value = 'b'
    if value in content:
        return True
    return False

def main(content):
    ret = False
    for fn in globals().values():
        if callable(fn) and fn != main: 
            ret = ret or fn(content)
    return ret

if __name__ == '__main__':
    assert main('ab') == True
    assert main('dc') == False

这不是一个理想的设计，因为：1如果您曾经需要在这里添加其他功能，而这些功能不应该是这个或操作的钩子，那么您将需要将If验证的第二部分cat到 不允许的函数的列表。2即使通配符导入本应避免，但有时也会发生，这也会破坏您的逻辑

对于更可靠的设计，我需要考虑每个关系检查的复杂程度：

1如果它们仍然像一个单独的小行验证，那么我将尝试使用map获取lambda列表：

2如果您的目的是使这种关系比较随着时间的推移变得更加复杂，但永远不会从一行程序中传递，那么我们可能需要一个lambda列表，并应用一个过滤器

3另一种方法是将这些函数分组为类方法。封装将为尝试索引此函数提供更高的安全性：

class RuleFilter(object):

    def rule1(self, content):
        value = 'a'
        if value in content:
            return True
        return False

    def rule2(self, content):
        value = 'b'
        if value in content:
            return True
        return False

    def apply(self, content):
        ret = False
        for attr in dir(self):
            field_obj = getattr(self, attr)
            if hasattr(field_obj, '__func__') and field_obj != self.apply:
                ret = ret or field_obj(content)
        return ret

def main(content):
    return RuleFilter().apply(content)

if __name__ == '__main__':
    assert main('ab') == True
    assert main('dc') == False

通过apply传递内容将避免将_init__标记为有界方法。如果您想通过初始值设定项传递内容，那没关系，只要记住扩展If以跳过它，就像我们对apply方法本身所做的那样