使用函数返回包含所需字母的单词列表

Question

我正在尝试编写一个带字符串的函数，并检查该字符串中的每个字母对应每个字母，每行中的单词列表。我写的代码是：

def uses_all(required):
    fin = open('words.txt')
    for line in fin:
        for letter in line:
            if letter not in required:
                pass
    return line

当我尝试只返回包含元音的单词时，它只返回文件中的最后一行。

>>> uses_all('aeiou')
'zymurgy\n'

Answer 1

通过迭代文件产生的行在结尾处有EOL。首先剥离。

此外，该问题与代码中的逻辑不匹配。

Answer 2

好吧，你编写的函数在没有做任何事情的情况下遍历文件，然后返回最后一行，所以你看到的行为是有点期待的。

试试这个：

def uses_all(required):
    ret = []
    fin = open('words.txt')
    for line in fin:
        # Let´s try and find all our required letters in that word.
        for letter in required:
            if letter not in line:
                break # We`re missing one! Break!

        else: # else block executes if no break occured
            ret.append(line)

    return ret

这是一个糟糕的实现，但它应该工作。

Answer 3

您只返回行，它只是循环变量。您需要构建一个答案列表。我不确定你在哪里尝试使用传递这是一个无操作，但这里是你的代码的一个版本应该可以工作......

def uses_all(required):
    fin = open('words.txt')
    answer = []
    for line in fin:
       should_take = True 
       for letter in required:
            if letter not in required:
                should_take = False
        if should_take ==True:
            answer.append(line)

    return answer

Answer 4

class WordMatcher(object):
    @classmethod
    def fromFile(cls, fname):
        with open(fname) as inf:
            return cls(inf)

    def __init__(self, words):
        super(WordMatcher,self).__init__()
        self.words = set(word.strip().lower() for word in words)

    def usesAllLetters(self, letters):
        letters = set(letters)
        for word in self.words:
            if all(ch in word for ch in letters):
                yield word

wordlist = WordMatcher.fromFile('words.txt')
vowelWords = list(wordlist.usesAllLetters('aeiou'))

Answer 5

uses_any()

名称uses_all()似乎与意图相矛盾“我试图只包含包含元音的单词”。这是一个可能的更正：

def uses_any(letters):
    """Yield words that contain any of the `letters`."""
    with open('words.txt') as fin:
         for word in fin: # if there is a single word per line then just say so
             if any(letter in letters for letter in word):
                # or set(letters).issuperset(word)
                yield word.strip() # remove leading/trailing whitespace 

uses_only()

另一种解释可能是：

def uses_only(input_words, required_letters, only=True):
    """Yield words from `input_words` that contain `required_letters`.

    if `only` is true then a word is constructed entirely from`required_letters` 
    (but — may be not from *all* `required_letters`).
    """
    present = all if only else any
    for word in input_words: 
        if present(letter in required_letters for letter in word):
           yield word #note: no .strip(), .lower(), etc here

with open('/etc/dictionaries-common/words') as fin:
     words = fin.read().decode('utf-8').lower().splitlines()

print 'Words that constructed entirely from given vowels:'
print '\n'.join(uses_only(words, u'aeiou'))
print 'Words that contain any given vowels:'
print '\n'.join(uses_only(words, u'aeiou', only=False))

输出

Words that constructed entirely from given vowels:

a
au
e
eu
i
io
o
u
a
e
i
o
u

Words that contain any given vowels:
...
épées
étude
étude's
études

uses_all()

如果意图是：“我尝试只返回包含[所有]元音的单词[但也允许其他字母]”然后：

def uses_all(input_words, required_letters):
    """Yield `input_words` that contain all `required_letters`."""
    required_letters = frozenset(required_letters)
    for word in input_words:
        if required_letters.issubset(word):
           yield word

print 'Words that contain all given vowels:'
print '\n'.join(uses_all(unique_justseen(words), u'aeiou'))

前一个示例中定义了words，而unique_justseen()是：

from itertools import imap, groupby
from operator  import itemgetter

def unique_justseen(iterable, key=None):
    """List unique elements, preserving order. 

    Remember only the element just seen.
    """
    # unique_justseen('AAAABBBCCDAABBB') --> A B C D A B
    # unique_justseen('ABBCcAD', str.lower) --> A B C A D
    return imap(next, imap(itemgetter(1), groupby(iterable, key)))

输出

Words that contain all given vowels:
...
vivaciousness's
vocabularies
voluntaries
voluptuaries
warehousing