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

以下是使用Python编写的将给定正则表达式转换为NFA的完整代码。它可以将正则表达式转换为NFA，然后将NFA以文本的形式输出，并且可以使用graphviz进行可视化。

import re
from graphviz import Digraph

class NFA:
    def __init__(self):
        self.states = set()
        self.start_state = None
        self.final_states = set()
        self.transitions = {}

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

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

    def add_final_state(self, state):
        self.final_states.add(state)
        self.add_state(state)

    def add_transition(self, from_state, symbol, to_state):
        self.add_state(from_state)
        self.add_state(to_state)
        if (from_state, symbol) in self.transitions:
            self.transitions[(from_state, symbol)].add(to_state)
        else:
            self.transitions[(from_state, symbol)] = set([to_state])

    def get_epsilon_closure(self, states):
        stack = list(states)
        closure = set(states)
        while stack:
            state = stack.pop()
            for epsilon_transition in self.transitions.get((state, None), []):
                if epsilon_transition not in closure:
                    closure.add(epsilon_transition)
                    stack.append(epsilon_transition)
        return frozenset(closure)

    def get_next_states(self, states, symbol):
        next_states = set()
        for state in states:
            state_transition = self.transitions.get((state, symbol), set())
            next_states |= state_transition
        return self.get_epsilon_closure(next_states)

    def is_final_state(self, states):
        return bool(self.final_states & set(states))

    def to_dfa(self):
        dfa = DFA()
        dfa.set_alphabet(self.get_alphabet())
        start_state = self.get_epsilon_closure([self.start_state])
        dfa.set_start_state(start_state)
        unmarked_states = [start_state]
        while unmarked_states:
            current_state = unmarked_states.pop()
            for symbol in dfa.get_alphabet():
                next_state = self.get_next_states(current_state, symbol)
                if not next_state:
                    continue
                if next_state not in dfa.states:
                    unmarked_states.append(next_state)
                dfa.add_transition(current_state, symbol, next_state)
            if self.is_final_state(current_state):
                dfa.add_final_state(current_state)
        return dfa

    def get_alphabet(self):
        alphabet = set()
        for transition in self.transitions:
            if transition[1] is not None:
                alphabet.add(transition[1])
        return frozenset(alphabet)

class DFA:
    def __init__(self):
        self.states = set()
        self.start_state = None
        self.final_states = set()
        self.transitions = {}
        self.alphabet = set()

    def set_alphabet(self, alphabet):
        self.alphabet = alphabet

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

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

    def add_final_state(self, state):
        self.final_states.add(state)
        self.add_state(state)

    def add_transition(self, from_state, symbol, to_state):
        self.add_state(from_state)
        self.add_state(to_state)
        self.transitions[(from_state, symbol)] = to_state

    def is_final_state(self, state):
        return state in self.final_states

    def run_with_input_string(self, input_string):
        current_state = self.start_state
        for symbol in input_string:
            current_state = self.transitions.get((current_state, symbol), None)
            if current_state is None:
                return False
        return self.is_final_state(current_state)

def parse_re_to_postfix(re_string):
    infix = re_string.replace(" ", "")
    infix = list(infix)
    postfix = []
    stack = []
    for symbol in infix:
        if symbol == "(":
            stack.append(symbol)
        elif symbol == ")":
            while stack and stack[-1] != "(":
                postfix.append(stack.pop())
            stack.pop()
        elif symbol in "|*":
            while stack and stack[-1] != "(" and (stack[-1] != "|" or symbol == "*"):
                postfix.append(stack.pop())
            stack.append(symbol)
        else:
            postfix.append(symbol)
    while stack:
        postfix.append(stack.pop())
    return postfix

def postfix_to_nfa(postfix):
    stack = []
    for symbol in postfix:
        if symbol == "|":
            nfa1 = stack.pop()
            nfa2 = stack.pop()
            nfa = NFA()
            nfa.set_start_state((nfa1.start_state, nfa2.start_state))
            nfa.add_final_state((nfa1.final_states, nfa2.final_states))
            for state in nfa1.states:
                for symbol in nfa1.get_alphabet():
                    nfa.add_transition((state, None), symbol, (state, ))
            for state in nfa2.states:
                for symbol in nfa2.get_alphabet():
                    nfa.add_transition((state, None), symbol, (state, ))
            stack.append(nfa)
        elif symbol == "*":
            nfa1 = stack.pop()
            nfa = NFA()
            nfa.set_start_state(nfa1.start_state)
            nfa.add_final_state(nfa1.start_state)
            nfa.add_final_state(nfa1.final_states)
            for state in nfa1.states:
                for symbol in nfa1.get_alphabet():
                    nfa.add_transition((state, None), symbol, (state, ))
            nfa.add_transition((nfa1.final_states, None), None, (nfa1.start_state, ))
            stack.append(nfa)
        else:
            nfa = NFA()
            nfa.set_start_state(symbol)
            nfa.add_final_state(symbol)
            stack.append(nfa)
    return stack.pop()

def nfa_to_dot(nfa, filename):
    dot = Digraph(comment='NFA')
    for state in nfa.states:
        shape = 'doublecircle' if nfa.is_final_state(state) else 'circle'
        dot.node(str(state), str(state), shape=shape)
    dot.node('', shape='none')
    dot.edge('', str(nfa.start_state))
    for (from_state, symbol), to_states in nfa.transitions.items():
        for to_state in to_states:
            if symbol is None:
                dot.edge(str(from_state), str(to_state), label='ε')
            else:
                dot.edge(str(from_state), str(to_state), label=symbol)
    dot.render(filename, view=True)

def main():
    re_string = "(a|b)(a|(ba)*)a"
    postfix = parse_re_to_postfix(re_string)
    nfa = postfix_to_nfa(postfix)
    nfa_to_dot(nfa, 'nfa.gv')

if __name__ == '__main__':
    main()

这个程序使用了 `re` 和 `graphviz` 两个库。在 `main` 函数中，我们可以更改 `re_string` 变量以使用不同的正则表达式。

程序首先将正则表达式转换为后缀表示法。然后使用后缀表达式构造NFA。最后，使用Graphviz将NFA渲染为图形，以便进行可视化。