Ecrire un tokenizer en Python

Je veux concevoir un générateur de jetons module en Python qui permet aux utilisateurs de spécifier générateur de jetons(s) à utiliser pour l'entrée. Par exemple, considérons le code suivant:

Q: qu'est Ce qu'un bon moyen pour y parvenir? Un: je ne suis pas si sûr. Je pense que je
va utiliser Python.

Je veux être en mesure de fournir NLTK de la segmentation de la phrasesent_tokenize() comme une option, car il fonctionne bien dans de nombreux cas, et je ne veux pas ré-inventer la roue. En plus de cela, je tiens également à fournir un grain plus fin de la segmentation du générateur de (quelque chose le long des lignes d'un règle-moteur). Laissez-moi vous expliquer:

Supposer que j'fournisseur d'un couple de des générateurs de jetons:

SENTENCE # Tokenizes the given input by using sent_tokenize()
WORD # Tokenizes the given input by using word_tokenize()
QA # Tokenizes using a custom regular expression. E.g., Q: (.*?) A: (.*?)

Je veux soutenir règles comme suit:

QA -> PHRASE: Appliquer l'assurance de la qualité générateur de jetons en premier, suivi par la phrase tokenizer
QA: Appliquer seulement l'assurance de la qualité tokenizer

Par conséquent, la sortie attendue est comme suit:

1. QA -> PHRASE

[
  ('QUESTION', 
             ('SENTENCE', 'What is a good way to achieve this?'), 
  ),
  ('ANSWER', 
             ('SENTENCE', 'I am not so sure', 'I think I will use Python')
  )
]

2. QA

[
  ('QUESTION', 'What is a good way to achieve this?'),
  ('ANSWER', 'I am not so sure. I think I will use Python')
]

Qu'est ce qu'un bon design pour y parvenir?

source d'informationauteur Legend

Que la segmentation est facile en Python, je me demandais ce que votre module est prévu pour fournir.
Je veux dire que lors du démarrage d'un morceau de logiciel d'une bonne conception plutôt provient de la réflexion sur les scénarios d'usage de considérer que les structures de données en premier.

Vos exemples de résultats attendus sont un peu confus.
Je suppose que vous voulez le des générateurs de jetons de retour nom sur le côté gauche et une liste de jetons sur le côté droit.
J'ai joué un peu pour obtenir des résultats similaires, mais l'utilisation de listes pour faciliter la manipulation:

import re
# some tokenizers
def tokzr_WORD(txt): return ('WORD', re.findall(r'(?ms)\W*(\w+)', txt))  # split words
def tokzr_SENT(txt): return ('SENTENCE', re.findall(r'(?ms)\s*(.*?(?:\.|\?|!))', txt))  # split sentences
def tokzr_QA(txt):
l_qa = []
for m in re.finditer(r'(?ms)^[\s#\-\*]*(?:Q|Question)\s*:\s*(?P<QUESTION>\S.*?\?)[\s#\-\*]+(?:A|Answer)\s*:\s*(?P<ANSWER>\S.*?)$', txt):  # split (Q, A) sequences
for k in ['QUESTION', 'ANSWER']:
l_qa.append(m.groupdict()[k])
return ('QA', l_qa)
def tokzr_QA_non_canonical(txt):  # Note: not supported by tokenize_recursively() as not canonical.
l_qa = []
for m in re.finditer(r'(?ms)^[\s#\-\*]*(?:Q|Question)\s*:\s*(?P<QUESTION>\S.*?\?)[\s#\-\*]+(?:A|Answer)\s*:\s*(?P<ANSWER>\S.*?)$', txt):  # split (Q, A) sequences
for k in ['QUESTION', 'ANSWER']:
l_qa.append((k, m.groupdict()[k]))
return l_qa
dict_tokzr = {  # control string: tokenizer function
'WORD'    : tokzr_WORD,
'SENTENCE': tokzr_SENT,
'QA'      : tokzr_QA,
}
# the core function
def tokenize_recursively(l_tokzr, work_on, lev=0):
if isinstance(work_on, basestring):
ctrl, work_on = dict_tokzr[l_tokzr[0]](work_on)  # tokenize
else:
ctrl, work_on = work_on[0], work_on[1:]  # get right part
ret = [ctrl]
if len(l_tokzr) == 1:
ret.append(work_on)  # add right part
else:
for wo in work_on:  # dive into tree
t = tokenize_recursively(l_tokzr[1:], wo, lev + 1)
ret.append(t)
return ret
# just for printing
def nestedListLines(aList, ind='    ', d=0):
""" Returns multi-line string representation of \param aList.  Use \param ind to indent per level. """
sRet = '\n' + d * ind + '['
nested = 0
for i, e in enumerate(aList):
if i:
sRet += ', '
if type(e) == type(aList):
sRet += nestedListLines(e, ind, d + 1)
nested = 1
else:
sRet += '\n' + (d + 1) * ind + repr(e) if nested else repr(e)
sRet += '\n' + d * ind + ']' if nested else ']'
return sRet
# main()
inp1 = """
* Question: I want try something.  Should I?
* Answer  : I'd assume so.  Give it a try.
"""
inp2 = inp1 + 'Q: What is a good way to achieve this?  A: I am not so sure. I think I will use Python.'
print repr(tokzr_WORD(inp1))
print repr(tokzr_SENT(inp1))
print repr(tokzr_QA(inp1))
print repr(tokzr_QA_non_canonical(inp1))  # Really this way?
print
for ctrl, inp in [  # example control sequences
('SENTENCE-WORD', inp1),
('QA-SENTENCE', inp2)
]:
res = tokenize_recursively(ctrl.split('-'), inp)
print nestedListLines(res)

Btw. Python/Lib/tokenize.py (pour le code Python lui-même) pourrait être intéressant de regarder comment gérer les choses.

4

Si je comprends correctement à la question, puis je ne pense que vous devriez réinventer la roue. Je voudrais mettre en œuvre des machines d'état pour les différents types de segmentation en unités que vous voulez et utiliser python dictionnaires pour sauver les jetons.

http://en.wikipedia.org/wiki/Finite-state_machine

Exemple de l'état de la machine qui va prendre une phrase avec des espaces et d'imprimer les mots, bien sûr, vous pourriez faire spécifiques, par exemple dans des moyens plus faciles! Mais avec l'état de machines, en général, vous obtenez le temps linéaire, et peut-costumize facilement!
```
while 1:
if state == "start":
if i == len(text):
state = "end"
elif text[i] == " ":
state = "new word"
i = i - 1
else:
word.append(text[i])
elif state == "new word":
print(''.join(word))
del word[:]
state = "start"
elif state == "end":
print(''.join(word))
break
i = i + 1
```
http://docs.python.org/2/library/collections.html#collections.Counter

Ensuite, vous pouvez par exemple utiliser ce python structure de données pour l'enregistrement de vos jetons. Je pense que c'est parfaitement adapté à vos besoins!

Espère que c'était de l'aide.
1

J'ai écrit cette simple générateur de jetons aujourd'hui, le point est à l'appui d'une simple DSL qui a des expressions telles que:
- a = a + b
- funcCall(b,c)
- a < b and b > c
et de soutien pas de nidification de l'arithmétique plus profond que le précédent. En d'autres termes, le langage le plus simple de telle sorte que vous pouvez spécifier à la fois la flèche conditions et les codes d'accès de la machine d'état. J'ai essayé les solutions plus complexes, mais a échoué. Pourquoi avoir indéfiniment récursive expression de soutien si vous savez qu'il y a 100% de chance qu'il ne sera pas utilisé? De même, je suis en limitant la and's sur un bord de 5, sinon la machine de l'etat semble unweildy. or est géré par la machine de l'etat lui-même: les flèches ont naturellement alternative ou or logique.
```
Comment, Float, Int, CmpOp, ArithOp, ElemFunc, FuncCall, Ident, TokenTypes = range(9)
tokenRegex = {
Comment: re.compile(r"/\*.*\*/"),
Float: re.compile(r"[-+]?\d*\.\d+"),
Int: re.compile(r"[-+]?\d+"),
CmpOp: re.compile(r">=|<=|!=|==|<|>"),
ArithOp: re.compile(r"\+|-|\*|%|/|>>|<<"),
ElemFunc: re.compile("(sin|cos|tan|exp|pow|log|ln)\((.*)\)"),
FuncCall: re.compile("(^[^\d\W]\w*\Z)\((.*)\)"),
Ident: re.compile(r"^[^\d\W]\w*\Z")
}
def tokenize(text):
inputs = [(text, 0)]            # index is where to insert into tokens rel end
tokens = []
while inputs:
text_elem = inputs.pop(0)
string = text_elem[0]
index = text_elem[1]
for tok_type, regex in tokenRegex.items():
match = regex.search(string)
if match:
tokens.insert(len(tokens) - index, (match, tok_type))
prefix = string[:match.start()]
if prefix != '':  inputs.insert(index, (prefix, index + 1))
suffix = string[match.end():]
if suffix != '':  inputs.insert(index+1, (suffix, index))
break
return tokens
```
Ce n'est pas complètement testé, mais sur 1 < 0 and 0 > 1 (oui, une déclaration qui est toujours faux, je suis à l'aide d'un assortiment aléatoire de la flèche de texte par défaut pour les aider dans leur travail), les jetons sont retournés dans l'ordre correct.

Si ils finissent par ne pas être renvoyé dans le bon ordre, il a à voir avec la façon dont je gère la index var qui est censé être l'endroit où ils devraient obtenir inséré dans les jetons (par rapport à la fin). J'ai essayé de garder la liste des jetons et les entrées de la liste, dans la même liste, et c'était un grand désordre. Cette version semble assez décent.

Je ne sais pas si il sera la suite de vos besoins, mais il est clair que je suis en train de faire de l'utiliser, alors peut-être que d'autres en feront de même.

Ma demande a un ensemble fixe de types de jeton, mais cela peut être utilisé pour ce que vous voulez: le code de l'utilisateur insère simplement un nouveau type de jeton (l'ordre est important) avec expression régulière.

Vous devez vous connecter pour publier un commentaire.