如何获取字符串并返回字典中与该单词相差一个字母的所有单词的列表？

Question

So right now I'm working with a very long dictionary of words from AZ. With this dictionary I'm trying to create a function that takes a string as a parameter and returns all words within that dictionary that are one letter different at any point. Eg.

>>> oneLetterDiff('find')
    ['bind', 'kind', 'lind', 'mind', 'rind', 'wind', 'fend', 'fond', 'fund', 'fine', 'fink', 'finn', 'fins']
    >>> words=oneLetterDiff('hand')
    >>> print words
    ['band', 'land', 'rand', 'sand', 'wand', 'hard', 'hang', 'hank', 'hans']
    >>> oneLetterDiff('horse')
    ['morse', 'norse', 'worse', 'house', 'horde', 'horst']
    >>> oneLetterDiff('monkey')
    ['donkey']
    >>> oneLetterDiff('action')
    []

I've imported a separate function which is working perfectly at the moment I've called WordLookup. It looks like this:

def createDictionary():
    """
    Creates a global dict of all the words in the word file.
    Every word from the word list file because a key in the dict.
    Each word maps to the value None.  This is because all we care about
    is whether a given word is in the dict.

    """
    global wordList # Specifies that wordList will not go away at the end
                    # of this function call and that other functions may
                    # use it
    wordList = dict()
    wordFile = open('WordList.txt')
    for word in wordFile:
        word = word.strip() # remove leading or trailing spaces
        # map the word to an arbitrary value that doesn't take much
        # space; we'll just be asking "in" questions of the dict
        wordList[word] = None 
    wordFile.close()


def lookup(word):
    global wordList # states that the function is using this global variable
    return word in wordList

Following this code I have the actual oneLetterDiff function:

def oneLetterDiff(myString):
        theAlphabet = string.ascii_lowercase
        for i in myString:
            for j in theAlphabet:
                #Maybe try to see if the letters can be changed in this fashion?

Is anyone able to help me understand this a bit better? I've really been struggling to figure out a proper solution and any help is appreciated!

Answer 1

I guess you shouldn't reinvent the wheel. There is a good python library that implements the Levenstein distance metric. I think you'll find it useful.

Answer 2

Let's define a utility function called close_enough . It takes two words and returns True if the words have the same length and differ by one and only one letter:

def close_enough(word1, word2):
    return len(word1) == len(word2) and 1 == sum(x!=y for x,y in zip(word1, word2))

Next, we need a function to search through the word list, called wordlist , and select the words that are close_enough (differ by one letter). Here is a function to do that. It takes two arguments: the word to compare against, called myword and the wordlist :

def one_letter_diff(myword, wordlist)
    return [word for word in wordlist if close_enough(word, myword)]

If you prefer, we could make wordlist a global:

def one_letter_diff2(myword):
    # Uses global wordlist
    return [word for word in wordlist if close_enough(word, myword)]

Generally, though, program logic is easier to understand if globals are avoided.

Examples

Here is close_enough in action finding which words differ by one letter and which don't:

In [22]: close_enough('hand', 'land')
Out[22]: True

In [23]: close_enough('hand', 'lend')
Out[23]: False

Here is one_letter_diff in action looking for words in wordlist that differ by one letter from hand :

In [26]: one_letter_diff('hand', ['land', 'melt', 'cat', 'hane'])
Out[26]: ['land', 'hane']

How it works

Let's look first at close_enough . It returns True if two conditions are satisfied. The first is that the words have the same length:

len(word1) == len(word2) 

The second is that they differ by only one letter:

1 == sum(x!=y for x,y in zip(word1, word2))

Let's break that down into parts. This returns True for every letter that differs:

[x!=y for x,y in zip(word1, word2)]

For example:

In [37]: [x!=y for x,y in zip('hand', 'land')]
Out[37]: [True, False, False, False]

sum is used to count the number of letters that differ.

In [38]: sum(x!=y for x,y in zip('hand', 'land'))
Out[38]: 1

If that sum is one, then the condition is satisfied.

The command in one_letter_diff is a _list comprehension`:

[word for word in wordlist if close_enough(word, myword)]

It goes through each word in wordlist and includes it in the final list only if close_enough returns True.