python - Python评估和逻辑运算符

Question

我有一个JSON“数据库”-它是一个JSON对象的python列表：

[{'_id': 'TRANSACTION0', 'Offer': {'From': 'merchant1', 'To': 'customer1', 'Item': 'Car', 'Price': 1000, 'Timestamp': 2}, 'Accept': {'Quantity': 1, 'Address': '123 Fake Street', 'Timestamp': 5}},
{'_id': 'TRANSACTION1', 'Offer': {'From': 'merchant1', 'To': 'customer2', 'Item': 'Computer', 'Price': 500, 'Timestamp': 5}},
{'_id': 'TRANSACTION2', 'Offer': {'From': 'merchant3', 'To': 'customer3', 'Item': 'Garbage bin', 'Price': 10, 'Timestamp': 0}, 'Accept': {'Quantity': 2, 'Address': '456 MadeUp Road', 'Timestamp': 1}},
{'_id': 'TRANSACTION3', 'Offer': {'From': 'merchant2', 'To': 'customer1', 'Item': 'Car', 'Price': 2000, 'Timestamp': 3}, 'Accept': {'Quantity': 2, 'Address': 'The White House', 'Timestamp': 3}},
{'_id': 'TRANSACTION4', 'Offer': {'From': 'merchant3', 'To': 'customer3', 'Item': 'Pens', 'Price': 2, 'Timestamp': 0}, 'Accept': {'Quantity': 4, 'Address': 'Houses of Parliment', 'Timestamp': 1}},
{'_id': 'TRANSACTION5', 'Offer': {'From': 'merchant4', 'To': 'customer1', 'Item': 'Headphones', 'Price': 200, 'Timestamp': 4}},
{'_id': 'TRANSACTION6', 'Offer': {'From': 'merchant1', 'To': 'customer2', 'Item': 'Water Bottle', 'Price': 1, 'Timestamp': 1}, 'Accept': {'Quantity': 3, 'Address': 'Timbuktu', 'Timestamp': 14}},
{'_id': 'TRANSACTION7', 'Offer': {'From': 'merchant2', 'To': 'customer3', 'Item': 'Laptop', 'Price': 900, 'Timestamp': 0}},
{'_id': 'TRANSACTION8', 'Offer': {'From': 'merchant4', 'To': 'customer1', 'Item': 'Chair', 'Price': 80, 'Timestamp': 3}, 'Accept': {'Quantity': 1, 'Address': 'Mordor', 'Timestamp': 3}},
{'_id': 'TRANSACTION9', 'Offer': {'From': 'merchant3', 'To': 'customer3', 'Item': 'Garbage bin', 'Price': 5, 'Timestamp': 2}, 'Accept': {'Quantity': 2, 'Address': 'The wall', 'Timestamp': 2}}]

我的目的是对这个数据库使用将存储在字典中的查询。在本例中，字典包含：

a_dict = {"query1": "'Offer' and 'Accept'"}

注意，字典将包含更多的查询和更复杂的查询（例如(cond1 and cond2) or (cond2 and cond3)），但是我需要理解为什么Python要做它正在做的事情（以及如何克服它），而不是仅仅解决方案是什么。
我需要一些评估和正确运行query1的东西。我的错误执行目前是：

if (eval(a_dict["query1"]) + "in i"):

这与：

if 'Offer' and 'Accept' in i:

由于短路，这评估为仅检查Accept是否在i中。在这个例子中，每次有一个Accept都有一个Offer，但情况并非总是如此。
合法的if语句是：

if 'Offer' in i and 'Accept' in i:

然而，从我可能拥有的潜在查询类型来看，这并不容易组合。理想情况下，我希望有一个优雅的解决方案是“即插即用”，类似于上面给出的我的evalif语句。
有没有可能从字典中获取特定的查询，将其插入到if语句中，然后按照我的意图运行if语句（假设所有查询都有逻辑意义）？
https://www.python.org/dev/peps/pep-0308/这篇文章说FAQ 4.16提供了替代方案，但我似乎在任何地方都找不到

Answer 1

请不要使用eval进行查询。这肯定会在你没想到的时候在你脸上爆炸。也许您已经听说过SQL注入；使用eval构建查询的安全含义是巨大的。
基于过滤的查询系统
取而代之的是，先为常见查询编写筛选函数。这也将解决您的问题，并提供一种“即插即用”的方式来编写查询。
这里有一个关于如何实现它的指针：
把查询看作一个函数，它接受几个文本值（隐式地说，是一组记录）作为参数，并返回一组记录的结果。放弃列表并使用由您的记录id键入的结果集的set数据类型将大大提高性能。
然后“AND”变成一个函数，它接受两个（或更多）记录集并建立它们的集合交集，“or”变成一个函数，它接受两个（或更多）记录集并建立它们的并集。（不是整个记录集和一个或多个子集之间的集合差异）。
如果以这种方式构建函数，查询将成为函数调用的简单树，例如：

result = q_and(q_or(q_merchant_is('merchant2'), 
                    q_address_is('123 FakeStreet')), 
               q_quantity_above(3))

（格式化以提高可读性）
为将构建这样一个查询的简单查询语言编写解析器并不难，但是如果不需要为最终用户提供前端，则可能不需要自己的查询语言，因为上面所示的查询的python表示非常简单和清晰。如果您确实需要将查询表示为字典，那么，如果您选择一个与查询调用树的最终结构非常相似的结构，那么编写一个query_builder函数将dict查询之一转换为一个在调用时运行查询函数调用树的函数就很简单了。
注意：如您所见，q_merchant_is，q_quantity_above等不需要一组记录进行筛选。可以通过创建查询类并将完整集设置为实例属性来解决此问题，以便每个查询方法在需要时都可以访问完整记录集：

class Query(object):
    def __init__(self, all_records):
        self.records = all_records

    def merchant_is(self, name):
        result = set()
        for record in self.records:
            if record['Offer']['From'] == name:
               result.add(record['_id'])
        return result

    def q_and(self, *args):
        result = args[0]
        for i in range(1, len(args)):
            result = args[i].intersection(result)
        return result
    ...

q = Query(my_full_record_set)
result = q.q_and(q.q_or(q.merchant_is('merchant2').........))    

性能和指标
您可以看到，查询文本值的每个查询函数基本上都会扫描整个数据集以筛选它。如果查询包含许多这样的文字部分搜索，则将多次扫描数据集。对于大型数据集，这可能会变得令人望而却步。
一个简单的解决方案是将要查询的字段索引到每个字段的一个dict中。这将按数量级加快查询速度，但如果数据发生更改，则需要确保索引保持最新。
分类器查询系统
另一个解决方案是将查询函数构建为分类器，而不是过滤器，这意味着merchant_is将接受一个文本值和一个记录，并回答True或False，这取决于记录是否在正确的字段中包含该文本值。通过使用构建复合查询的工厂函数，我们可以使这一切高效地工作。
然后，来自filter部分的示例查询将变成：

query = q_and(q_or(q_merchant_is('merchant2'),
                   q_address_is('123 FakeStreet')),
              q_quantity_above(3))
result = perform_query(query, all_my_records)

q_merchant_is将变成以下内容：

def q_merchant_is(literal):
    return lambda record: record['Orders']['From'] == literal

注意你是如何返回一个函数的，当用一个记录调用时，
将对其进行分类。
q_or可能是这样的：

def q_or(*args):
    def or_template(record):
        for classifier in args:
            if classifier(record):
                return True
        return False
    return or_template

或者更简洁一点（我不确定这是否更有效）：

def q_or(*args):
    return lambda record: any([ classifier(record) for classifier in args])

q_or现在返回一个函数，该函数对作为参数传递的记录运行多个分类器，如果至少有一个分类器返回True，则返回True。q_and的工作方式与q_or类似，只是它只在每个分类器都返回True时才返回True。如果分类器返回False，q_not只会返回True，反之亦然。
现在你只需要：

def perform_query(query, all_records):
    return filter(query, all_records)

这将只在您的数据集上迭代一次，并且非常有效，因为它在python中不涉及eval、compile和exec，但是它比filter方法更难理解。
然而，从我可能拥有的潜在查询类型来看，这并不容易组合。理想情况下，我想有一个优雅的解决方案，即“即插即用”
使用过滤器和分类器系统，很容易用新的查询元素扩展系统。在过滤器示例中，向查询类添加方法。在分类器示例中，您添加了一个查询函数生成器，就像我为q_merchant_is编写的那样。通常需要两行python代码。