编写一个可以将正规式：((ab)|b)(a|(ba)*)a转化为NFA图的python代码

以下是一个简单的 Python 代码示例，实现将给定的正则表达式转换为NFA图：

class State:
    """
    状态类
    """
    def __init__(self, label):
        self.label = label
        self.edges = []
        self.epsilon_edges = []
        self.accepts = False

class NFA:
    """
    NFA类
    """
    def __init__(self, regex):
        self.start = None # 开始状态
        self.end = None # 结束状态
        self.states = [] # 所有状态
        self.build(regex)

    def build(self, regex):
        """
        构建NFA图
        """
        stack = []
        index = 0
        while index < len(regex):
            if regex[index] == '(':
                stack.append(index)
            elif regex[index] == ')':
                start_index = stack.pop()
                if len(stack) == 0:
                    if start_index == 0 and index == len(regex) - 1:
                        # 整个正则表达式都被括号包含
                        self.build(regex[1:-1])
                        return
                    else:
                        # 括号内的表达式
                        self.build(regex[start_index+1:index])
            elif regex[index] == '|':
                if len(stack) == 0:
                    # 添加新状态
                    state1 = State(len(self.states))
                    state2 = State(len(self.states) + 1)
                    self.states.append(state1)
                    self.states.append(state2)
                    # 连接状态
                    state1.epsilon_edges.append(state2)
                    if self.start is None:
                        self.start = state1
                    if len(stack) == 0:
                        self.end = state2
                    else:
                        stack.append(len(self.states) - 1)
            elif regex[index] == '*':
                # 添加新状态
                state1 = State(len(self.states))
                state2 = State(len(self.states) + 1)
                self.states.append(state1)
                self.states.append(state2)
                # 连接状态
                if len(stack) == 0:
                    state1.epsilon_edges.append(state2)
                    state1.epsilon_edges.append(self.start)
                    self.start = state1
                    self.end = state2
                else:
                    state1.epsilon_edges.append(state2)
                    state1.epsilon_edges.append(self.states[stack[-1]])
                    self.states[stack[-1]].epsilon_edges.append(state1)
                    stack[-1] = len(self.states) - 1
            else:
                # 添加新状态
                state1 = State(len(self.states))
                state2 = State(len(self.states) + 1)
                self.states.append(state1)
                self.states.append(state2)
                # 连接状态
                state1.edges.append((regex[index], state2))
                if self.start is None:
                    self.start = state1
                if len(stack) == 0:
                    self.end = state2
            index += 1
        # 设置结束状态
        if self.end is not None:
            self.end.accepts = True

    def match(self, string):
        """
        匹配字符串
        """
        current_states = set()
        next_states = set()
        current_states.add(self.start)
        for char in string:
            next_states.clear()
            for state in current_states:
                for edge in state.edges:
                    if edge[0] == char:
                        next_states.add(edge[1])
            current_states.clear()
            current_states.update(next_states)
        return self.end in current_states

    def print(self):
        """
        打印NFA图
        """
        print('Start: ', self.start.label)
        for state in self.states:
            if state.accepts:
                print('Accept: ', state.label)
            for edge in state.edges:
                print(state.label, ' --', edge[0], '--> ', edge[1].label)
            for epsilon_edge in state.epsilon_edges:
                print(state.label, ' --epsilon--> ', epsilon_edge.label)

# 测试
nfa = NFA('((ab)|b)(a|(ba)*)a')
nfa.print()
print(nfa.match('aba')) # True
print(nfa.match('baa')) # True
print(nfa.match('bbba')) # False

该代码使用了栈来处理括号和或运算符，使用了状态来表示NFA图中的节点，并使用边和 epsilon 边来表示节点之间的连接。在构建NFA图时，每遇到一个字符或星号就会创建两个新状态，并将它们连接起来。在处理或运算符时，将创建两个新状态并将它们与前面的状态连接起来。最后，添加一个结束状态来表示匹配的终点。可以使用 `match` 方法来测试给定字符串是否匹配NFA图。