Python - Machine à états de traitement de texte

Une machine à états consiste à concevoir un programme pour contrôler le flux dans une application. c'est un graphe orienté, composé d'un ensemble de nœuds et d'un ensemble de fonctions de transition. Le traitement d'un fichier texte consiste très souvent en une lecture séquentielle de chaque morceau d'un fichier texte et en faisant quelque chose en réponse à chaque morceau lu. La signification d'un morceau dépend des types de morceaux qui étaient présents avant lui et des morceaux qui viennent après. La machine consiste à concevoir un programme pour contrôler le flux dans une application. c'est un graphe orienté, composé d'un ensemble de nœuds et d'un ensemble de fonctions de transition. Le traitement d'un fichier texte consiste très souvent en une lecture séquentielle de chaque morceau d'un fichier texte et en faisant quelque chose en réponse à chaque morceau lu. La signification d'un morceau dépend des types de morceaux qui étaient présents avant lui et des morceaux qui viennent après.

Considérons un scénario où le texte mis doit être une chaîne continue de répétition de séquence d'AGC (utilisée dans l'analyse des protéines). Si cette séquence spécifique est maintenue dans la chaîne d'entrée, l'état de la machine reste VRAI mais dès que la séquence dévie, l'état de la machine devient FALSE et reste FAUX après les wards. Cela garantit que le traitement ultérieur est arrêté même s'il peut y avoir plus de morceaux de séquences correctes disponibles plus tard.

Le programme ci-dessous définit une machine d'état qui a des fonctions pour démarrer la machine, prendre des entrées pour traiter le texte et parcourir le traitement.

class StateMachine:
# Initialize 
    def start(self):
        self.state = self.startState
# Step through the input
    def step(self, inp):
        (s, o) = self.getNextValues(self.state, inp)
        self.state = s
        return o
# Loop through the input		
    def feeder(self, inputs):
        self.start()
        return [self.step(inp) for inp in inputs]
# Determine the TRUE or FALSE state
class TextSeq(StateMachine):
    startState = 0
    def getNextValues(self, state, inp):
        if state == 0 and inp == 'A':
            return (1, True)
        elif state == 1 and inp == 'G':
            return (2, True)
        elif state == 2 and inp == 'C':
            return (0, True)
        else:
            return (3, False)
InSeq = TextSeq()
x = InSeq.feeder(['A','A','A'])
print x
y = InSeq.feeder(['A', 'G', 'C', 'A', 'C', 'A', 'G'])
print y

Lorsque nous exécutons le programme ci-dessus, nous obtenons la sortie suivante -

[True, False, False]
[True, True, True, True, False, False, False]

Dans le résultat de x, le modèle d'AGC échoue pour la deuxième entrée après le premier «A». L'état du résultat reste faux pour toujours après cela. Dans le résultat de Y, le modèle d'AGC continue jusqu'à la 4ème entrée. Par conséquent, l'état du résultat reste vrai jusqu'à ce point. Mais à partir de la 5e entrée, le résultat passe à False car G est attendu, mais C est trouvé.