字典或替代品中的自我参考

Question

我正在尝试将规则放入字典列表中，其中每个字典都包含条件和规则本身。 问题是在这种情况下，没有简单的方法可以在字典中进行自我引用。

在我的示例中，我使用dict['condition_1']但这当然是错误的代码，将其视为占位符。

那么这个问题有什么聪明的解决方案吗？ 恐怕我只是坚持使用 dicts 列表的错误概念，并且看不到一些更明显和简单的替代方案。

rules = [
    {
        'condition_1': ['Lorem', 'ipsum'],
        'rule': (lambda message: any(word in message for word in dict['condition_1']))
    },
    {
        'condition_1': ['quis', 'nostrud'],
        'condition_2': ['dolor', 'sit', 'amet'],
        'rule': (lambda message: (any(word in message for word in dict['condition_1'])
                              and all(word in message for word in dict['condition_2'])))
    },
    ...
]

Answer 1

我建议使用 class 作为替代方案：

class Rules_One:
    def __init__(self, condition, message):
        self.condition = condition
        self.message = message
    
    def __str__(self):
        return "Rules_One"
    
    def run_rule(self):
        return any(word in self.message for word in self.condition)

class Rules_Two:
    def __init__(self, condition1, condition2, message):
        self.condition1 = condition1
        self.condition2 = condition2
        self.message = message
    
    def __str__(self):
        return "Rules_Two"
    
    def run_rule(self):
        return any(word in self.message for word in self.condition1) and all(word in self.message for word in self.condition2)

rules = [
    Rules_One(['Lorem', 'ipsum'], "This is ipsum"), 
    Rules_Two(['quis', 'nostrud'], ['dolor', 'sit', 'amet'], "dolor sit amet quis")
]

print("Result:")
for i in rules:
    print(i, "is", i.run_rule())

#Outputs

Result:
Rules_One is True
Rules_Two is True

Answer 2

子类dict怎么样？ 然后，您可以在构造函数中分配值，但仍然具有dict的所有功能。 规则以字符串的形式传入并在get方法中执行，以便您得到正确的东西。

class DerivedDict(dict)
    def __init__(self, *args, rule="", condition_1=[], condition_2=[], **kwargs)
        dict.__init__(*args, **kwargs)

        self["condition_1"] = condition_1
        self["condition_2"] = condition_2
        self["rule"] = rule
    
    def __str__(self):
        # This method is for cases as str(derived_dict_object), which, by default, would give <DerivedDict at 0x88ha65bc23afat> or something similar
        return "DerivedDict(" + self["rule"] + ", " + self["condition_1"] + ", " + self["condition_2"] + ")"
    
    def get(self):
        eval("return " + self["rule"]) # convert rule string to code

用法：

message = "Lorem"
rules = [
    DerivedDict(
        condition_1=['Lorem', 'ipsum'],
        # The rule MUST be in quotes !
        rule="any(word in message for word in self['condition_1'])"
        # Note the self['condition_1'] : self will be the created dict later
    ),
    DerivedDict(
        condition_1=['quis', 'nostrud'],
        condition_2=['dolor', 'sit', 'amet'],
        rule="(any(word in message for word in dict['condition_1']) and all(word in message for word in self['condition_2'])))"
    )
]
for rule in rules:
    print(rule.get())

编辑：我的解决方案可用于数百个不同的规则，而无需创建数百个不同的类 (;) @Santee) ！

Answer 3

好吧，这是我刚刚从 IT 乌克兰公会的 Semplar 那里得到的答案。 它已经过测试，无需任何额外结构即可正常工作，应予以考虑。

rules = [
    {
        'condition_1': ['Lorem', 'ipsum'],
        'rule': (lambda message, rules, i: any(word in message for word in rules[i]['condition_1']))
    },
    {
        'condition_1': ['quis', 'nostrud'],
        'condition_2': ['dolor', 'sit', 'amet'],
        'rule': (lambda message, rules, i: (any(condition in message for condition in rules[i]['condition_1'])
                                        and all(condition in message for condition in rules[i]['condition_2']))),
    },
    # ...
]

然后您可以通过规则列表 go 并检查触发了什么规则：

for i, r in enumerate(rules):
    if rules[i]['rule'](message, rules, i):
        print(f"it's rule {i}")