Python - RegEx pour diviser le texte en phrases (phrase-tokenizing)

Je veux faire une liste de phrases à partir d'une chaîne, puis de les imprimer. Je ne veux pas utiliser NLTK pour ce faire. Il faut donc que ce split, sur une période à la fin de la phrase et non pas à des décimales ou des abréviations ou d'un titre, d'un nom ou si la phrase a un .com C'est la tentative de regex qui ne fonctionne pas.

import re

text = """\
Mr. Smith bought cheapsite.com for 1.5 million dollars, i.e. he paid a lot for it. Did he mind? Adam Jones Jr. thinks he didn't. In any case, this isn't true... Well, with a probability of .9 it isn't.
"""
sentences = re.split(r' *[\.\?!][\'"\)\]]* *', text)

for stuff in sentences:
        print(stuff)

Exemple de sortie de ce à quoi il devrait ressembler à

Mr. Smith bought cheapsite.com for 1.5 million dollars, i.e. he paid a lot for it. 
Did he mind?
Adam Jones Jr. thinks he didn't.
In any case, this isn't true...
Well, with a probability of .9 it isn't.

source d'informationauteur user3590149

  1. 17
    (?<!\w\.\w.)(?<![A-Z][a-z]\.)(?<=\.|\?)\s

    De l'essayer. diviser votre chaîne.Vous pouvez aussi vérifier démo.

    http://regex101.com/r/nG1gU7/27

  2. 22

    Ok, donc la phrase-des générateurs de jetons sont quelque chose que j'ai regardé dans un peu de détail, à l'aide de regexes, nltk, CoreNLP. Vous finissez par écrire votre propre et il dépend de l'application. Ce truc est délicat et précieux et que les gens ne se contente pas de donner leur tokenizer le code. (En fin de compte, la segmentation n'est pas une procédure déterministe, probabiliste, et dépend aussi très fortement sur votre corpus ou d'un domaine, par exemple dans les médias sociaux, les poteaux vs Yelp vs ...)

    En général, vous ne pouvez pas compter sur un seul Grand Blanc infaillible regexvous devez écrire une fonction qui utilise plusieurs regexes (à la fois positifs et négatifs); également un dictionnaire des abréviations, et certaines de base d'analyse de langage qui sait que, par exemple, 'I', 'USA', 'FCC', 'TARP' sont capitalisés en anglais.

    Pour illustrer combien il est facile, cela peut devenir compliqué sérieusement, nous allons essayer de vous écrire que la spécification fonctionnelle pour un déterministe tokenizer juste à décider si une seule ou plusieurs point ('.'/'...') indique la fin de la phraseou quelque chose d'autre:

    function isEndOfSentence(leftContext, rightContext)

    1. Retourner False pour les décimales à l'intérieur de chiffres ou de monnaie par exemple 1.23 , $1.23, "ce n'est Que mon $.02" tenir également compte de la section des références comme 1.2.3 ou Européennes, les formats de date comme 09.07.2014
    2. Return False (et ne pas marquer en lettres individuelles) pour les abréviations, par exemple, "les états-UNIS les stocks sont en baisse", ce qui nécessite un dictionnaire de connu abréviations. Rien en dehors de ce dictionnaire vous permettra d'obtenir des faux.
    3. Ellipses '...' à la fin des phrases sont terminales, mais dans le milieu de phrases ne sont pas. Ce n'est pas aussi facile que vous pourriez penser: vous avez besoin de regarder à gauche contexte et dans le bon contexte, plus précisément, c'est le membre de droite capitalisés et encore considérer capitalisés des mots comme " je " et les abréviations. Voici un exemple montrant l'ambiguïté qui : Elle m'a demandé de rester... j'ai laissé une heure plus tard. (Était-ce une phrase ou deux? Impossible de déterminer)
    4. Vous pouvez également écrire quelques modèles pour détecter et rejeter divers non-phrase de fin usages de la ponctuation: les émoticônes, ASCII art, espacées d'ellipses . . . et d'autres choses esp. Twitter. (Faire qu'une adaptation est encore plus difficile). Comment pouvons-nous dire si @de minuit est un utilisateur de Twitter, le show sur Comedy Centralou simplement indésirables/ordure/faute de frappe de la ponctuation? Sérieusement non-trivial.
    5. Après vous gérer tous ces cas négatifs, vous pouvez arbitrairement dire que tout isolé période suivie par des espaces est susceptible d'être une fin de phrase. (En fin de compte, si vous voulez vraiment acheter une précision supplémentaire, vous finissez par écrire votre propre probabiliste de la phrase-générateur de jetons qui utilise des pondérations, et de la formation sur un corpus spécifique(par exemple, des textes juridiques, des médias de diffusion, StackOverflow, Twitter, forums, commentaires, etc.)) Ensuite, vous devez passer en revue manuellement exemplaires et formation des erreurs. Voir Manning et Jurafsky livre ou Coursera [a].
      En fin de compte, vous obtenez autant d'exactitude que vous êtes prêt à payer pour.
    6. Tous les ci-dessus est clairement spécifiques à la langue anglaise/les abréviations, les états-unis nombre/temps/formats de date. Si vous voulez faire de ce pays et indépendant de la langue, c'est une plus grande proposition, vous aurez besoin de corpus, de langue maternelle gens à étiqueter et d'assurance qualité, tout cela, etc.
    7. Tous les ci-dessus est encore que de l'ASCII. Permettre l'entrée à l'Unicode, et les choses deviennent encore plus difficile (et de la formation-définir, doit nécessairement être beaucoup plus ou beaucoup moins dense)

    Dans le simple (déterministe), function isEndOfSentence(leftContext, rightContext) retourne un booléen, mais dans le sens plus général, c'est probabiliste: elle retourne un float (niveau de confiance que le". " est une phrase à la fin).

    Références: [a] Coursera vidéo: "Base de Traitement de Texte 2-5 - la Segmentation de la Phrase - Stanford PNL - Professeur Dan Jurafsky & Chris Manning"

  3. 4

    Essayez de fractionner l'entrée selon les espaces plutôt que d'un point ou ?si vous aimez ce la dot ou ? ne seront pas imprimées dans le résultat final.

    >>> import re
>>> s = """Mr. Smith bought cheapsite.com for 1.5 million dollars, i.e. he paid a lot for it. Did he mind? Adam Jones Jr. thinks he didn't. In any case, this isn't true... Well, with a probability of .9 it isn't."""
>>> m = re.split(r'(?<=[^A-Z].[.?]) +(?=[A-Z])', s)
>>> for i in m:
...     print i
... 
Mr. Smith bought cheapsite.com for 1.5 million dollars, i.e. he paid a lot for it.
Did he mind?
Adam Jones Jr. thinks he didn't.
In any case, this isn't true...
Well, with a probability of .9 it isn't.
  4. 2
    sent = re.split('(?<!\w\.\w.)(?<![A-Z][a-z]\.)(?<=\.|\?)(\s|[A-Z].*)',text)
for s in sent:
    print s

    Ici l'expression régulière utilisée est : (?<!\w\.\w.)(?<![A-Z][a-z]\.)(?<=\.|\?)(\s|[A-Z].*)

    Premier bloc: (?<!\w\.\w.) : ce modèle recherches dans une boucle de rétroaction négative (?<!) pour tous les mots (\w) suivie par point (\.) , suivie par d'autres mots (\.)

    Deuxième bloc: (?<![A-Z][a-z]\.): ce modèle recherches dans une boucle de rétroaction négative pour rien, en commençant par des majuscules alphabets ([A-Z])suivie par une diminution des cas d'alphabets ([a-z]) jusqu'à un point (\.) est trouvé.

    Troisième bloc: (?<=\.|\?): ce modèle de recherches dans une boucle de rétroaction de la dot (\.) OU d'interrogation (\?)

    Quatrième bloc: (\s|[A-Z].*): ce modèle recherches après la virgule OU le point d'interrogation à partir de la troisième bloc. Il recherche l'espace vide (\s) OU toute séquence de caractères commençant par une majuscule de l'alphabet ([A-Z].*).
    Ce bloc est important de diviser si l'entrée est comme

    Bonjour tout le monde.Salut, je suis ici aujourd'hui.

    c'est à dire si il reste de la place ou pas d'espace après le point.

  5. 0

    Essayez ceci:

    (?<!\b(?:[A-Z][a-z]|\d|[i.e]))\.(?!\b(?:com|\d+)\b)
  6. 0

    Approche naïve pour l'anglais des phrases à ne pas commencer avec les alphas et ne contenant pas cité les parties du discours:

    import re
text = """\
Mr. Smith bought cheapsite.com for 1.5 million dollars, i.e. he paid a lot for it. Did he mind? Adam Jones Jr. thinks he didn't. In any case, this isn't true... Well, with a probability of .9 it isn't.
"""
EndPunctuation = re.compile(r'([\.\?\!]\s+)')
NonEndings = re.compile(r'(?:Mrs?|Jr|i\.e)\.\s*$')
parts = EndPunctuation.split(text)
sentence = []
for part in parts:
  if len(part) and len(sentence) and EndPunctuation.match(sentence[-1]) and not NonEndings.search(''.join(sentence)):
    print(''.join(sentence))
    sentence = []
  if len(part):
    sentence.append(part)
if len(sentence):
  print(''.join(sentence))

    De faux positifs fractionnement peut être réduite par l'extension de NonEndings un peu. Autres cas, il faudra un code supplémentaire. La manipulation de fautes de frappe dans une manière sensible ce sera difficile avec cette approche.

    Vous ne serez jamais atteindre la perfection avec cette approche. Mais en fonction de la tâche, il est possible que ça fonctionne "assez"...

  7. 0

    J'ai écrit cette prise en considération, smci les commentaires ci-dessus. C'est un milieu-de-la-route d'approche qui ne nécessite pas de bibliothèques externes et ne pas utiliser des regex. Il permet de fournir une liste des abréviations et des comptes pour les phrases terminées par les terminaisons dans wrappers, comme une période et devis: [.", ?', .)].

    abbreviations = {'dr.': 'doctor', 'mr.': 'mister', 'bro.': 'brother', 'bro': 'brother', 'mrs.': 'mistress', 'ms.': 'miss', 'jr.': 'junior', 'sr.': 'senior', 'i.e.': 'for example', 'e.g.': 'for example', 'vs.': 'versus'}
terminators = ['.', '!', '?']
wrappers = ['"', "'", ')', ']', '}']
def find_sentences(paragraph):
end = True
sentences = []
while end > -1:
end = find_sentence_end(paragraph)
if end > -1:
sentences.append(paragraph[end:].strip())
paragraph = paragraph[:end]
sentences.append(paragraph)
sentences.reverse()
return sentences
def find_sentence_end(paragraph):
[possible_endings, contraction_locations] = [[], []]
contractions = abbreviations.keys()
sentence_terminators = terminators + [terminator + wrapper for wrapper in wrappers for terminator in terminators]
for sentence_terminator in sentence_terminators:
t_indices = list(find_all(paragraph, sentence_terminator))
possible_endings.extend(([] if not len(t_indices) else [[i, len(sentence_terminator)] for i in t_indices]))
for contraction in contractions:
c_indices = list(find_all(paragraph, contraction))
contraction_locations.extend(([] if not len(c_indices) else [i + len(contraction) for i in c_indices]))
possible_endings = [pe for pe in possible_endings if pe[0] + pe[1] not in contraction_locations]
if len(paragraph) in [pe[0] + pe[1] for pe in possible_endings]:
max_end_start = max([pe[0] for pe in possible_endings])
possible_endings = [pe for pe in possible_endings if pe[0] != max_end_start]
possible_endings = [pe[0] + pe[1] for pe in possible_endings if sum(pe) > len(paragraph) or (sum(pe) < len(paragraph) and paragraph[sum(pe)] == ' ')]
end = (-1 if not len(possible_endings) else max(possible_endings))
return end
def find_all(a_str, sub):
start = 0
while True:
start = a_str.find(sub, start)
if start == -1:
return
yield start
start += len(sub)

    J'ai utilisé de Karl find_all fonction de cette entrée: Trouver toutes les occurrences d'une sous-chaîne de caractères en Python

  8. 0

    Je ne suis pas très à des expressions régulières, mais une version plus simple, "force brute" de fait, ci-dessus est 

    sentence = re.compile("([\'\"][A-Z]|([A-Z][a-z]*\. )|[A-Z])(([a-z]*\.[a-z]*\.)|([A-Za-z0-9]*\.[A-Za-z0-9])|([A-Z][a-z]*\. [A-Za-z]*)|[^\.?]|[A-Za-z])*[\.?]")

    qui signifie
    commencer acceptable unités sont '[A-Z] ou[A-Z]

    veuillez noter que la plupart des expressions régulières sont avides de sorte que la commande est très importante lorsque l'on ne |(ou). C'est pourquoi j'ai écrit c'est à dire expression régulière en premier, puis est venu formes comme Inc.

  9. -1

    Si vous voulez briser jusqu'à des peines de 3 périodes (pas sûr si c'est ce que vous voulez) vous pouvez utiliser cette expresion:

    import re
text = """\
Mr. Smith bought cheapsite.com for 1.5 million dollars, i.e. he paid a lot for it. Did he mind? Adam Jones Jr. thinks he didn't. In any case, this isn't true... Well, with a probability of .9 it isn't.
"""
sentences = re.split(r'\.{3}', text)
for stuff in sentences:
print(stuff)