将复杂的树结构转换为Json Python

Question

我需要转换具有以下类结构的树：

Class Tree:     
    def __init__(self, data):         
        self.data = data         
        self.and_objects = []         
        self.or_objects = []

数据是：

Class Data:     
    def __init__(self, var, operator, value):
        self.var = var
        self.operator = operator
        self.value = value
    def to_json(self):
        return {"var": self.var, "operator": self.operator, "value": self.value}

数据结构的简化示例：

Root
  andChildren
    x = 0
      andChildren
         a = 1
         b = 2 
    y = 10
      andChildren
         a = 3   
      orChildren
         y = 3
            andChildren
               a = 2
         
  orChildren
    Empty

此评估为：

（（x == 0和（a == 1 and B == 2）） ）和（（y == 10和（a == 3））或（y == 3和a == 2））

我需要将树数据结构转换为：

{
   "Search":{
      "Root":{
         "compare_operator":"and",
         "values":[
            {
               "compare_operator":"and",
               "values":[
                  {
                     "var":"x",
                     "operator":"=",
                     "value":"0"
                  },
                  {
                     "compare_operator":"and",
                     "values":[
                        {
                           "var":"a",
                           "operator":"=",
                           "value":"1"
                        },
                        {
                           "var":"b",
                           "operator":"=",
                           "value":"2"
                        }
                     ]
                  }
               ]
            },
            {
               "compare_operator":"or",
               "values":[
                  {
                     "compare_operator":"and",
                     "values":[
                        {
                           "var":"y",
                           "operator":"=",
                           "value":"10"
                        },
                        {
                           "var":"a",
                           "operator":"=",
                           "value":"3"
                        }
                     ]
                  },
                  {
                     "compare_operator":"and",
                     "values":[
                        {
                           "var":"y",
                           "operator":"=",
                           "value":"3"
                        },
                        {
                           "var":"a",
                           "operator":"=",
                           "value":"2"
                        }
                     ]
                  }
               ]
            }
         ]
      }
   }
}

有人有任何提示/方法关于如何将这棵树数据结构转换为此JSON

结构

？

Class Tree:     
    def __init__(self, data="root"):         
        self.data = data         
        self.and_objects = []         
        self.or_objects = []
        
Class Data:     
    def __init__(self, var, operator, value):
        self.var = var
        self.operator = operator
        self.value = value
    def to_json(self):
        return {"var": self.var, "operator": self.operator, "value": self.value}
        
def create_search(var, operator, value, parent, comparision="and")
    data = Data(var, operator, value)
    child = Tree(data)
    if comparision == "and":
        parent.and_objects.append(child)
    else:
        parent.or_objects.append(child)
    return child
    
if __name__ == "__main__":
    root_tree = Tree()
    x_temp = create_search("x", "=", "0", root_tree)
    create_search("a", "=", "1", x_temp)
    create_search("b", "=", "2", x_temp)
    
    y_temp = create_search("y", "=", "10", root_tree)
    create_search("a", "=", "3", root_tree, y_temp)
    nested_y_temp = create_search("y", "=", "3", root_tree, y_temp, "or")
    create_search("a", "=", "2", root_tree, nested_y_temp)
    
    # tree data is on root_tree

Answer 1

我会选择不同的初始结构。在您的结构中，AND 或 OR 运算符需要有一个 Data 实例作为父级。数据实例与依赖于它的两者以及 AND 和 OR 列表组合在一起。

我建议允许顶级 AND 或 OR 运算符将其所有操作数作为子项。您还可以为 AND 和 OR 运算符以及 EQUALITY 运算符创建单独的类。

将

class Logical():
    def __init__(self, operator, operands):
        self.operands = operands
        self.operator = operator

    def __str__(self):
        return f" {self.operator} ".join(map(str, self))

    def asdict(self):
        return { 
            "compare_operator": self.operator, 
            "values": [operand.asdict() for operand in self.operands]
        }

class And(Logical):
    def __init__(self, *operands):
        super().__init__("and", operands)

class Or(Logical):
    def __init__(self, *operands):
        super().__init__("or", operands)


class Condition:
    def __init__(self, var, operator, value):
        self.var = var
        self.operator = operator
        self.value = value
        
    def asdict(self):
        return {
            "var": self.var, 
            "operator": self.operator, 
            "value": self.value
        }

class Equal(Condition):
    def __init__(self, var, value):
        super().__init__(var, "=", value)

结构的创建示例：

expression = And(
    And(
        Equal("x", 0), 
        And(
            Equal("a", 1), 
            Equal("b", 2), 
        ),
    ),
    Or(
        And(
            Equal("y", 10), 
            Equal("a", 3)
        ),
        And(
            Equal("y", 3),
            Equal("a", 2)
        )
    )
)

其转换为 JSON：

import json

result = {
    "Search": {
        "Root": expression.asdict()
    }
}

print(json.dumps(result, indent=4))

这将打印：

{
    "Search": {
        "Root": {
            "compare_operator": "and",
            "values": [
                {
                    "compare_operator": "and",
                    "values": [
                        {
                            "var": "x",
                            "operator": "=",
                            "value": 0
                        },
                        {
                            "compare_operator": "and",
                            "values": [
                                {
                                    "var": "a",
                                    "operator": "=",
                                    "value": 1
                                },
                                {
                                    "var": "b",
                                    "operator": "=",
                                    "value": 2
                                }
                            ]
                        }
                    ]
                },
                {
                    "compare_operator": "or",
                    "values": [
                        {
                            "compare_operator": "and",
                            "values": [
                                {
                                    "var": "y",
                                    "operator": "=",
                                    "value": 10
                                },
                                {
                                    "var": "a",
                                    "operator": "=",
                                    "value": 3
                                }
                            ]
                        },
                        {
                            "compare_operator": "and",
                            "values": [
                                {
                                    "var": "y",
                                    "operator": "=",
                                    "value": 3
                                },
                                {
                                    "var": "a",
                                    "operator": "=",
                                    "value": 2
                                }
                            ]
                        }
                    ]
                }
            ]
        }
    }
}