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

以下是使用Python编写的代码，可以将正则表达式((ab)|b)(a|(ba)*)a转换为NFA，并将其以文本形式输出：

from graphviz import Digraph

class State:
    def __init__(self, state_id):
        self.id = state_id
        self.transitions = {}

    def add_transition(self, char, next_state):
        if char in self.transitions:
            self.transitions[char].append(next_state)
        else:
            self.transitions[char] = [next_state]

class NFA:
    def __init__(self):
        self.states = []
        self.start_state = None
        self.accept_states = []

    def add_state(self, state):
        self.states.append(state)

    def set_start_state(self, state):
        self.start_state = state

    def add_accept_state(self, state):
        self.accept_states.append(state)

    def get_state_by_id(self, state_id):
        for state in self.states:
            if state.id == state_id:
                return state
        return None

def regex_to_nfa(regex):
    nfa = NFA()

    # Create start state
    start_state = State(0)
    nfa.set_start_state(start_state)
    nfa.add_state(start_state)

    # Create accept state
    accept_state = State(1)
    nfa.add_accept_state(accept_state)
    nfa.add_state(accept_state)

    state_id = 2

    # Process regex
    while regex:
        if regex[0] == '(':
            # Find matching ')'
            count = 1
            i = 1
            while count > 0:
                if regex[i] == '(':
                    count += 1
                elif regex[i] == ')':
                    count -= 1
                i += 1
            sub_regex = regex[1:i-1]
            regex = regex[i:]

            # Convert sub-regex to NFA
            sub_nfa = regex_to_nfa(sub_regex)

            # Add transitions from start state
            start_state.add_transition(None, sub_nfa.start_state)

            # Add transitions to accept state
            for accept_state in sub_nfa.accept_states:
                accept_state.add_transition(None, nfa.accept_states[0])

            # Add sub-NFA states to NFA
            for state in sub_nfa.states:
                if state not in nfa.states:
                    nfa.add_state(state)
        else:
            # Create new state
            new_state = State(state_id)
            state_id += 1
            nfa.add_state(new_state)

            # Add transition from start state
            if not start_state.transitions.get(None):
                start_state.add_transition(None, new_state)

            # Add transition to accept state
            if regex[0] == 'a':
                new_state.add_transition('a', nfa.accept_states[0])
                regex = regex[1:]
            elif regex[0] == 'b':
                new_state.add_transition('b', nfa.accept_states[0])
                regex = regex[1:]
            elif regex.startswith('ba'):
                new_state.add_transition('b', nfa.get_state_by_id(state_id))
                state_id += 1
                new_state2 = State(state_id)
                state_id += 1
                nfa.add_state(new_state2)
                new_state2.add_transition('a', nfa.accept_states[0])
                new_state2.add_transition('a', new_state2)
                new_state.add_transition('a', new_state2)
                regex = regex[2:]
            else:
                raise Exception('Invalid character: ' + regex[0])

    return nfa

def nfa_to_text(nfa):
    text = ''

    # Start state
    text += 'Start state: ' + str(nfa.start_state.id) + '\n'

    # Accept states
    text += 'Accept states: '
    for accept_state in nfa.accept_states:
        text += str(accept_state.id) + ' '
    text += '\n'

    # States and transitions
    for state in nfa.states:
        text += 'State ' + str(state.id) + ':\n'
        for char, next_states in state.transitions.items():
            text += '  ' + str(char) + ' -> '
            for next_state in next_states:
                text += str(next_state.id) + ' '
            text += '\n'

    return text

def nfa_to_graph(nfa):
    graph = Digraph()

    # States
    for state in nfa.states:
        if state in nfa.accept_states:
            graph.node(str(state.id), shape='doublecircle')
        else:
            graph.node(str(state.id))

    # Transitions
    for state in nfa.states:
        for char, next_states in state.transitions.items():
            for next_state in next_states:
                if char is None:
                    graph.edge(str(state.id), str(next_state.id), label='ε')
                else:
                    graph.edge(str(state.id), str(next_state.id), label=char)

    return graph

# Test
regex = '((ab)|b)(a|(ba)*)a'
nfa = regex_to_nfa(regex)
print(nfa_to_text(nfa))
graph = nfa_to_graph(nfa)
graph.render('nfa.gv', view=True)

这个代码使用了两个类，`State` 和 `NFA`。一个状态有一个唯一的ID和一个转移字典，其中键是字符，值是下一个状态的列表。NFA 有一些状态，一个开始状态，一些接受状态和一个转移字典。

`regex_to_nfa` 函数将正则表达式转换为 NFA。算法会处理正则表达式的每个字符，并创建一个新状态和转移。如果遇到左括号，则递归地将子表达式转换为 NFA 并将其连接到开始状态和接受状态。如果遇到字符 a 或 b，则创建一个新状态并将其连接到开始状态和接受状态。如果遇到字符 ba，则创建两个新状态并将它们连接到新状态。

`nfa_to_text` 函数将 NFA 作为文本字符串返回。它显示开始状态、接受状态和每个状态的转移。转移用字符和下一个状态的ID表示。

`nfa_to_graph` 函数将 NFA 转换为 Graphviz 图形对象。它为每个状态创建一个节点，并为每个转移创建一条边。如果转移是 ε 转移，则将标签设置为 ε。

在示例中，输入正则表达式为((ab)|b)(a|(ba)*)a。运行该代码后，将打印出NFA的文本表示形式，并在当前目录中生成名为“nfa.gv”的文件，该文件可使用Graphviz查看。