flux de code Python ne fonctionne pas comme prévu?

Question

Je suis en train de traiter divers textes de regex et de python NLTK -qui est à http: // www .nltk.org / livre- . Je suis en train de créer un générateur de texte aléatoire et j'ai un léger problème. Tout d'abord, voici mon flux de code:

1. Entrez une phrase comme entrée -Ce est appelée chaîne de déclenchement, est affectée à une variable -

2. Get mot le plus long dans la chaîne de déclenchement

3. Rechercher tous base de données du projet Gutenberg pour les phrases qui contiennent ce mot en minuscule majuscule -quel que soit -

4. Retour la plus longue phrase qui a le mot que je parlais à l'étape 3

5. Append la phrase à l'étape 1 et Step4 ensemble

6. Attribuer la phrase à l'étape 4, la nouvelle phrase « déclencheur » et répétez le processus. Notez que je dois obtenir le mot le plus long dans la deuxième phrase et continuer comme ça et ainsi de suite -

Jusqu'à présent, j'ai pu le faire une seule fois. Lorsque je tente de garder cela continue, le programme ne garde que l'impression de la première phrase mes rendements de recherche. Il devrait regarder en fait le plus long mot dans cette nouvelle phrase et continuer à appliquer mon flux de code décrit ci-dessus.

Voici mon code ainsi que d'une entrée échantillon / sortie:

entrée d'échantillon

  

"Thane de code"

Exemple de sortie

  

"Thane code Norvège mesme, avec des chiffres terribles, ASSISTE par que la plupart disloyall Traytor, le duc de Cawdor, a commencé un conflit dismall, Jusqu'à ce Bridegroome de Bellona, ??LAPT à proofe, le Confronté à Selfe - comparaisons, point contre le point, rebelle Armé 'gainst Armé, Freiner son esprit lauish: et de conclure, le Victorie est tombé sur vs "

Maintenant, cela devrait effectivement prendre la phrase qui commence par la Norvège .... mesme 'et recherchez le plus long mot et faire les étapes ci-dessus et ainsi de suite, mais il ne fonctionne pas. Aucune suggestion? Merci.

import nltk

from nltk.corpus import gutenberg

triggerSentence = raw_input("Please enter the trigger sentence: ")#get input str

split_str = triggerSentence.split()#split the sentence into words

longestLength = 0

longestString = ""

montyPython = 1

while montyPython:

    #code to find the longest word in the trigger sentence input
    for piece in split_str:
        if len(piece) > longestLength:
            longestString = piece
            longestLength = len(piece)


    listOfSents = gutenberg.sents() #all sentences of gutenberg are assigned -list of list format-

    listOfWords = gutenberg.words()# all words in gutenberg books -list format-
    # I tip my hat to Mr.Alex Martelli for this part, which helps me find the longest sentence
    lt = longestString.lower() #this line tells you whether word list has the longest word in a case-insensitive way. 

    longestSentence = max((listOfWords for listOfWords in listOfSents if any(lt == word.lower() for word in listOfWords)), key = len)
    #get longest sentence -list format with every word of sentence being an actual element-

    longestSent=[longestSentence]

    for word in longestSent:#convert the list longestSentence to an actual string
        sstr = " ".join(word)
    print triggerSentence + " "+ sstr
    triggerSentence = sstr

Answer 1

Monsieur. La réponse de Hankin est plus élégante, mais ce qui suit est plus conforme à l'approche que vous avez commencé avec:

import sys
import string
import nltk
from nltk.corpus import gutenberg

def longest_element(p):
    """return the first element of p which has the greatest len()"""
    max_len = 0
    elem = None
    for e in p:
        if len(e) > max_len:
            elem = e
            max_len = len(e)
    return elem

def downcase(p):
    """returns a list of words in p shifted to lower case"""
    return map(string.lower, p)


def unique_words():
    """it turns out unique_words was never referenced so this is here
       for pedagogy"""
    # there are 2.6 million words in the gutenburg corpus but only ~42k unique
    # ignoring case, let's pare that down a bit
    for word in gutenberg.words():
        words.add(word.lower())
    print 'gutenberg.words() has', len(words), 'unique caseless words'
    return words

print 'loading gutenburg corpus...'
sentences = []
for sentence in gutenberg.sents():
    sentences.append(downcase(sentence))

trigger = sys.argv[1:]
target = longest_element(trigger).lower()
last_target = None

while target != last_target:
    matched_sentences = []
    for sentence in sentences:
        if target in sentence:
            matched_sentences.append(sentence)

    print '===', target, 'matched', len(matched_sentences), 'sentences'
    longestSentence = longest_element(matched_sentences)
    print ' '.join(longestSentence)

    trigger = longestSentence
    last_target = target
    target = longest_element(trigger).lower()

Compte tenu de votre phrase de l'échantillon cependant, il atteint la fixation en deux cycles:

  

$ python nltkgut.py Thane code
  chargement Gutenburg corpus ...
  === Thane cible correspond 24 phrases
  norvège mesme, avec une terrible   numéros, assistés par la plupart   disloyall traytor, le Thane   Cawdor, a commencé un conflit dismall,   jusqu'à la bridegroome de ce Bellona ',   LAPT à proofe, face à lui   selfe - comparaisons, le point contre   point rebelle arme 'gainst arme   , Freinant son esprit lauish: et   conclure, le Victorie est tombé sur vs
  === bridegroome cible trouvée 1 phrases
  norvège mesme, avec   chiffres terribles, aidés par cette   plus traytor disloyall, le Thane   Cawdor, a commencé un conflit dismall,   jusqu'à la bridegroome de ce Bellona ',   LAPT à proofe, face à lui   selfe - comparaisons, le point contre   point rebelle arme 'gainst arme   , Freinant son esprit lauish: et   conclure, le Victorie est tombé sur vs

Une partie du problème avec la réponse au dernier problème est qu'il a fait ce que vous avez demandé, mais vous a posé une question plus spécifique que vous vouliez une réponse. Ainsi, la réponse obtenue enlisée dans certaines expressions de la liste assez compliquée que je ne sais pas bien compris. Je vous suggère d'utiliser plus libérale des déclarations d'impression et ne pas le code d'importation si vous ne savez pas ce qu'il fait. Alors que les déballant expressions de la liste I trouvé (comme indiqué) que vous jamais utilisé le corpus wordlist. Les fonctions sont une aide aussi.

Answer 2

Comment cela?

1. Vous trouvez mot le plus long déclenchement
2. Vous trouvez le plus long mot dans la phrase la plus longue mot contenant trouvé dans 1.
3. Le mot de 1. est le plus long mot de la phrase 2.

Qu'est-ce qui se passe? Astuce: réponse commence par « infini ». Pour corriger le problème que vous pourriez trouver un ensemble de mots en minuscules pour être utile.

BTW quand vous pensez devient faux et Monty Python la finition du programme?

Answer 3

Au lieu de rechercher l'ensemble du corpus à chaque fois, il peut être plus rapide de construire une seule carte de mot à la plus longue phrase contenant ce mot. Voici mon (non testé) pour tenter de le faire.

import collections
from nltk.corpus import gutenberg

def words_in(sentence):
    """Generate all words in the sentence (lower-cased)"""
    for word in sentence.split():
        word = word.strip('.,"\'-:;')
        if word:
            yield word.lower()

def make_sentence_map(books):
    """Construct a map from words to the longest sentence containing the word."""
    result = collections.defaultdict(str)
    for book in books:
        for sentence in book:
            for word in words_in(sentence):
                if len(sentence) > len(result[word]):
                    result[word] = sent
    return result

def generate_random_text(sentence, sentence_map):
    while True:
        yield sentence
        longest_word = max(words_in(sentence), key=len)
        sentence = sentence_map[longest_word]

sentence_map = make_sentence_map(gutenberg.sents())
for sentence in generate_random_text('Thane of code.', sentence_map): 
    print sentence

Answer 4

Vous assignez « split_str » en dehors de la boucle, il obtient la valeur d'origine, puis le maintient. Vous devez assigner au début de la boucle While, il change à chaque fois.

import nltk

from nltk.corpus import gutenberg

triggerSentence = raw_input("Please enter the trigger sentence: ")#get input str

longestLength = 0

longestString = ""

montyPython = 1

while montyPython:
    #so this is run every time through the loop
    split_str = triggerSentence.split()#split the sentence into words

    #code to find the longest word in the trigger sentence input
    for piece in split_str:
        if len(piece) > longestLength:
            longestString = piece
            longestLength = len(piece)


    listOfSents = gutenberg.sents() #all sentences of gutenberg are assigned -list of list format-

    listOfWords = gutenberg.words()# all words in gutenberg books -list format-
    # I tip my hat to Mr.Alex Martelli for this part, which helps me find the longest sentence
    lt = longestString.lower() #this line tells you whether word list has the longest word in a case-insensitive way. 

    longestSentence = max((listOfWords for listOfWords in listOfSents if any(lt == word.lower() for word in listOfWords)), key = len)
    #get longest sentence -list format with every word of sentence being an actual element-

    longestSent=[longestSentence]

    for word in longestSent:#convert the list longestSentence to an actual string
        sstr = " ".join(word)
    print triggerSentence + " "+ sstr
    triggerSentence = sstr