主页 / 问题 / 1316758
Accepted
Radzhab
Asked:2022-08-12 15:57:55 +0000 UTC2022-08-12 15:57:55 +0000 UTC

如何创建一个类来存储分层数据

  • 772

有一个清单。如何在类中存储这些数据？

input= [
    (None, 'a'),
    (None, 'b'),
    (None, 'c'),
    ('a', 'a1'),
    ('a', 'a2'),
    ('a2', 'a21'),
    ('a2', 'a22'),
    ('b', 'b1'),
    ('b1', 'b11'),
    ('b11', 'b111'),
    ('b', 'b2'),
    ('c', 'c1'),
]

一个示例类是这样的。不清楚如何设置父元素

class Node(object):
    def __init__(self):
        self.children = []

    def add_child(self, obj):
        self.children.append(obj)
python

2 个回答

  1. Best Answer

    添加了名称，结构的父级，启动了一个特殊节点 - 根元素

    在填充元素时，我使用了字典来简化元素的搜索

    为了检查结构的操作，我做了一个Node.print递归显示元素及其所有子元素的方法

    class Node:
    def __init__(self, name: str, parent: 'Node' = None):
        self.name = name
        self.parent = parent
        self.children = []

    def add_child(self, obj: 'Node'):
        self.children.append(obj)

    @property
    def parent_name(self) -> str:
        return self.parent.name if self.parent else None

    def __repr__(self) -> str:
        return f'Node(name={self.name!r}, parent={self.parent_name!r}, children_len={len(self.children)})'

    def print(self):
        def _print(node: Node, level=0):
            print('    ' * level + f'{node.name} ({len(node.children)})')
            for child in node.children:
                _print(child, level + 1)

        _print(self)


source = [
    (None, 'a'),
    (None, 'b'),
    (None, 'c'),
    ('a', 'a1'),
    ('a', 'a2'),
    ('a2', 'a21'),
    ('a2', 'a22'),
    ('b', 'b1'),
    ('b1', 'b11'),
    ('b11', 'b111'),
    ('b', 'b2'),
    ('c', 'c1'),
]

name_by_node = dict()
name_by_node[None] = Node('ROOT', None)

for parent, child in source:
    parent_node = name_by_node[parent]
    if child not in name_by_node:
        name_by_node[child] = Node(child, parent_node)

    parent_node.add_child(name_by_node[child])

name_by_node[None].print()

    递归输出：

    ROOT (3)
    a (2)
        a1 (0)
        a2 (2)
            a21 (0)
            a22 (0)
    b (2)
        b1 (1)
            b11 (1)
                b111 (0)
        b2 (0)
    c (1)
        c1 (0)

    UPD。

    要生成字典，您需要添加一个方法：

        def to_dict(self) -> dict:
        def _to_dict(node: Node):
            return {
                'name': node.name,
                'parent': node.parent_name,
                'children': [_to_dict(child) for child in node.children],
            }

        return _to_dict(self)

    我们调用（为方便起见，我们以 json 格式显示）：

    data = name_by_node[None].to_dict()
print(json.dumps(data, indent=4, ensure_ascii=False))

    结果：

    {
    "name": "ROOT",
    "parent": null,
    "children": [
        {
            "name": "a",
            "parent": "ROOT",
            "children": [
                {
                    "name": "a1",
                    "parent": "a",
                    "children": []
                },
                {
                    "name": "a2",
                    "parent": "a",
                    "children": [
                        {
                            "name": "a21",
                            "parent": "a2",
                            "children": []
                        },
                        {
                            "name": "a22",
                            "parent": "a2",
                            "children": []
                        }
                    ]
                }
            ]
        },
        {
            "name": "b",
            "parent": "ROOT",
            "children": [
                {
                    "name": "b1",
                    "parent": "b",
                    "children": [
                        {
                            "name": "b11",
                            "parent": "b1",
                            "children": [
                                {
                                    "name": "b111",
                                    "parent": "b11",
                                    "children": []
                                }
                            ]
                        }
                    ]
                },
                {
                    "name": "b2",
                    "parent": "b",
                    "children": []
                }
            ]
        },
        {
            "name": "c",
            "parent": "ROOT",
            "children": [
                {
                    "name": "c1",
                    "parent": "c",
                    "children": []
                }
            ]
        }
    ]
}
    • 4

  2. 如果需要显式存储父元素，则需要多一个字段：

    class Node(object):
    def __init__(self, parent):
        self.parent = parent
        parent.add_child(self) 
        self.children = []

    def add_child(self, obj):
        self.children.append(obj)
    • 2

相关问题