使用python编写完整的可以将正规式((ab)|b)(a|(ba)*)a转化成NFA的代码，并将NFA以文本的形式输出

以下是使用Python编写的将正则表达式转换为NFA的代码：

class State:
    def __init__(self, label=None):
        self.transitions = {}
        self.label = label
        self.epsilon_transitions = []
        self.final = False


class NFA:
    def __init__(self, start_state=None, end_state=None):
        self.start_state = start_state
        self.end_state = end_state

    def concatenate(self, nfa2):
        self.end_state.epsilon_transitions.append(nfa2.start_state)
        self.end_state = nfa2.end_state

    def alternate(self, nfa2):
        start_state = State()
        start_state.epsilon_transitions = [self.start_state, nfa2.start_state]
        end_state = State()
        self.end_state.epsilon_transitions.append(end_state)
        nfa2.end_state.epsilon_transitions.append(end_state)
        self.start_state = start_state
        self.end_state = end_state

    def closure(self):
        start_state = State()
        end_state = State()
        end_state.epsilon_transitions = [start_state]
        end_state.final = True
        start_state.epsilon_transitions = [self.start_state]
        self.end_state.epsilon_transitions = [self.start_state, end_state]
        self.start_state = start_state
        self.end_state = end_state

    def to_text(self):
        states = []
        transitions = []
        for state in self.__get_states():
            states.append(str(state.label) + ("" if not state.final else "f"))
            for symbol, destination_states in state.transitions.items():
                for dest in destination_states:
                    transitions.append(
                        f"{state.label} -> {dest.label} [ label=\"{symbol}\" ]"
                    )
            for dest in state.epsilon_transitions:
                transitions.append(f"{state.label} -> {dest.label} [ label=\"ε\" ]")

        return f"""digraph nfa {{
    rankdir=LR;
    node [shape = circle];
    {";".join(states)};
    node [shape = doublecircle];
    {self.end_state.label}f;
    node [shape = circle];
    {";".join(transitions)};
}}"""

    def __get_states(self):
        visited = set()
        stack = [self.start_state]
        while stack:
            state = stack.pop()
            if state in visited:
                continue
            visited.add(state)
            yield state
            for dest in state.epsilon_transitions:
                stack.append(dest)
            for destinations in state.transitions.values():
                for dest in destinations:
                    stack.append(dest)


def parse_regex(regex):
    stack = []
    for char in regex:
        if char == "(":
            stack.append("(")
        elif char == ")":
            if stack[-1] == "(":
                stack.pop()
            else:
                raise Exception("Invalid regex")
        elif char in ("*", "+", "|"):
            if len(stack) == 0:
                raise Exception("Invalid regex")
            elif char == "*":
                stack[-1].closure()
            elif char == "+":
                nfa2 = stack.pop()
                nfa2.concatenate(NFA(nfa2.start_state, nfa2.end_state))
            elif char == "|":
                nfa2 = stack.pop()
                stack[-1].alternate(nfa2)
        else:
            state1 = State()
            state2 = State()
            state1.transitions[char] = [state2]
            stack.append(NFA(state1, state2))

    if len(stack) != 1:
        raise Exception("Invalid regex")
    return stack.pop()


if __name__ == "__main__":
    regex = "(a|b)(a|(ba)*)a"
    nfa = parse_regex(regex)
    print(nfa.to_text())

代码中的核心是 `parse_regex()` 函数，它将正则表达式转换为 NFA。基本思路是使用栈来保存已经解析的表达式，遇到操作符（如 `*`、`+`、`|`）时从栈中弹出一个或多个表达式，并根据操作符将它们组合成一个新的 NFA。当解析完整个正则表达式后，栈中只剩下一个 NFA，这就是最终的结果。

最后一行代码将正则表达式 `(a|b)(a|(ba)*)a` 转换为 NFA 并输出为文本格式。你可以将输出的文本粘贴到任意支持 Graphviz 的工具中（如 Graphviz Online），就可以看到 NFA 的状态图了。