如何在Python中实现具有节点特定计算的图？

Question

我正在尝试实现类似于树的东西。有基本节点（数据输入）和计算节点（这些节点可以同时基于基本节点和计算节点）。 由于一个节点可以有多个父节点，因此它不再是一棵树。

基本上，计算节点的值是其子节点的总和或乘积。但它也可以是更复杂的计算（根、幂等以及各种组合）。 问题一：对于特殊计算，必须在每种情况下调整类的代码，并且必须调整计算函数。

我尝试了以下方法：

import numpy as np

class Node:
    def __init__(self, node_id, calc = 'sum'):
        
        self.id = node_id
        self.calc = calc
        self.children = set([])
        self.val = np.nan
        
    def add_child(self, c_id): self.children.add(c_id)
    def get_val(self): return self.val
    def set_val(self, value): self.val = value
    
    def calc_node(self):
        if bool(self.children):
            if self.calc == 'sum':
                val = 0
                for child in self.children:
                    val += child.get_val()
            elif self.calc == 'prod':
                val = 1
                for child in self.children:
                    val *= child.get_val()
            elif self.calc == 'calc_3':
                val = all_nodes['raw_1'].get_val() * \
                            all_nodes['raw_3'].get_val() + \
                            all_nodes['calc_1'].get_val()
            self.val = val

all_nodes = {'raw_1': Node('raw_1'),'raw_2': Node('raw_2'),
            'raw_3': Node('raw_3'),
            'calc_1': Node('calc_1', 'prod'),'calc_2': Node('calc_2'),
            'calc_3': Node('calc_3','calc_3')}

all_nodes['raw_1'].set_val(10.0)
all_nodes['raw_2'].set_val(5.0)
all_nodes['raw_3'].set_val(2.5)

all_nodes['calc_1'].add_child(all_nodes['raw_1'])
all_nodes['calc_1'].add_child(all_nodes['raw_2'])
all_nodes['calc_1'].calc_node()

all_nodes['calc_2'].add_child(all_nodes['raw_1'])
all_nodes['calc_2'].add_child(all_nodes['raw_2'])
all_nodes['calc_2'].calc_node()

#children of calc_3 are only relevant to determine children
all_nodes['calc_3'].add_child(all_nodes['raw_3'])
all_nodes['calc_3'].add_child(all_nodes['calc_1'])
all_nodes['calc_3'].add_child(all_nodes['calc_2'])
all_nodes['calc_3'].calc_node()

print(all_nodes['calc_1'].get_val())
print(all_nodes['calc_2'].get_val())
print(all_nodes['calc_3'].get_val())

问题二：该类使用全局变量all_nodes。这可以通过将 self.children 定义为有序集来解决。或者有更好的解决方案吗？

第一个问题可以通过简单地合并基本算术运算（包括幂、根等）并添加一个额外的节点（计算 calc_2 中使用的乘积的中间节点）来解决。但如果计算复杂，这很快就会变得令人困惑。这里还有其他的可能性吗？或者使用字符串作为 self.calc 并使用 eval() 来计算值是否有意义？我认为这不是一个好的编码风格，如果有大量节点，可能会很慢。

从角度来看，我想将计算集成到 GUI（Tkinter？PyQt5？）中，我可以自己定义节点，而无需自定义代码。如果您说这没有意义，而仅代码解决方案更有意义，那么我将重点关注仅代码解决方案。

由于我是面向对象编程的新手，因此我将不胜感激任何建议或类似的示例。非常感谢！

Answer 1

问题 1 可以通过将函数作为参数传递给构造函数来解决。由于 python 中的所有内容都是对象，因此函数可以传递到对象中并设置为属性，而不会出现问题。

问题2，这实际上取决于你想如何使用这个类。如果您希望能够通过 ID 在任何点访问任何节点，那么您需要一个字典。如果只需要计算树底部的值，那么您实际上不需要任何系统，您可以将较高的节点留在较低节点的子节点中的某个位置。

另外，我建议使用一个系统，其中调用 get_val 尝试递归地评估其子节点的值，这样您就不需要手动评估每个节点。

import numpy as np

def sum_child(children): return sum([x.get_val() for x in children])

class Node:
   def __init__(self, calc=sum_child):
      self.calc_node = calc
      self.children = set([])

   def get_val(self):
      try :
         return self.val
      except AttributeError:
         return self.calc_node(self.children)

   def add_child(self, child):
      self.children.add(child)

raw_1 = Node(lambda self: 10)
raw_2 = Node(lambda self: 5)
raw_3 = Node(lambda self: 2.5)

def product(children):
   val = 1
   for child in children :
      val *= child.get_val()
   return val
      
calc_1 = Node(product)
calc_2 = Node()

calc_1.add_child(raw_1)
calc_1.add_child(raw_2)

calc_2.add_child(raw_1)
calc_2.add_child(raw_2)

print(calc_1.get_val())
print(calc_2.get_val())

这是我对这个系统的尝试。我不太确定你想用 calc_3 做什么，因为它实际上并不是基于子节点并且总是解析为一个常量，所以我把它排除在外。