如何将字符串对象及文本文件树结构转为Python的Node对象？

Let's break down your two requirements with practical, safe solutions that work for most common scenarios:

1. Converting String-Type Objects to Python Objects #

If your string represents a standard Python data structure (like dicts, lists, tuples), you’ve got two reliable, safe options:

• Use ast.literal_eval(): This is the go-to choice because it only evaluates Python literals—no arbitrary code execution, which makes it way safer than eval(). Perfect if your string looks something like "{ 'name': 'Root', 'children': [] }".
  Example code:

  import ast
  
  obj_str = '{"name": "Root", "children": [{"name": "Child1"}]}'
  python_obj = ast.literal_eval(obj_str)
  print(type(python_obj))  # Output: <class 'dict'>
  

• Use json.loads(): If your string follows strict JSON syntax (double quotes for keys/strings, no trailing commas), this works seamlessly. Just note that JSON doesn’t support Python-specific types like tuples or None (use null instead), so adjust your string format if needed.
  Example code:

  import json
  
  json_str = '{"name": "Root", "children": [{"name": "Child1"}]}'
  python_obj = json.loads(json_str)
  

2. Loading Tree Structure from a Text File into Node Objects #

First, let’s assume your Node class follows a standard structure (tweak this to match your actual implementation):

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

The solution depends on how your A.txt is formatted—here are two common cases:

Case 1: Text file has a Python-like nested literal (e.g., nested dicts) #

If your A.txt content looks like this:

{"name": "Root", "children": [{"name": "Child1", "children": [{"name": "Grandchild1"}]}]}

You can parse the string into a dict with ast.literal_eval(), then recursively convert it to Node objects:

import ast

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

def dict_to_node(node_dict):
    # Create a Node from the dict
    node = Node(node_dict['name'])
    # Recursively convert child dicts to Node objects
    node.children = [dict_to_node(child) for child in node_dict.get('children', [])]
    return node

# Read and parse the file
with open('A.txt', 'r') as f:
    tree_str = f.read().strip()

tree_dict = ast.literal_eval(tree_str)
root_node = dict_to_node(tree_dict)

Case 2: Text file uses indentation to show hierarchy #

If your file uses indentation to represent parent-child relationships (like this):

Root
  Child1
    Grandchild1
  Child2

You can parse line by line, tracking indent levels to build the tree:

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

def load_tree_from_file(file_path):
    root = None
    stack = []  # Tracks the current hierarchy of nodes
    
    with open(file_path, 'r') as f:
        for line in f:
            stripped_line = line.strip()
            if not stripped_line:
                continue  # Skip empty lines
            
            # Calculate indent level (assuming 2 spaces per indent—adjust if needed)
            indent_level = (len(line) - len(line.lstrip())) // 2
            node = Node(stripped_line)
            
            if indent_level == 0:
                # This is the root node
                root = node
                stack = [node]
            else:
                # Pop the stack until we find the parent node (indent level -1)
                while len(stack) > indent_level:
                    stack.pop()
                parent = stack[-1]
                parent.children.append(node)
                stack.append(node)
    
    return root

# Load the tree
root_node = load_tree_from_file('A.txt')

Why converting to .py didn’t work (and better alternatives) #

Converting the text file to a .py and importing it is risky (it executes arbitrary code in the file) and error-prone—if the file has even a tiny syntax mistake, it’ll fail. Using ast.literal_eval() or custom parsing is safer, more maintainable, and gives you full control over how the data is converted to your Node objects.

内容的提问来源于stack exchange，提问作者SriniShine