Check english word in python

In this article, you will learn how to write python code for spell checking. I have discussed various methods you can use to implement your spell checker program.

But, before that, let’s learn some core topics, i.e., what spell checking is and its benefits. And after that, we will learn different approaches to writing Python programs for spell checking.

What is spell checking?

Spell checking is the process of checking a document or sentence for spelling errors. It is done in two ways either manually by proofreading the documents or by using a spell checker software program like Grammarly, Pro Writing Aid, Ginger Software, etc.

Spell checking is an integral part of editing and proofreading as it ensures the document is error-free.

Here are some of the benefits of proofreading and spell-checking the documents:

How to check spelling in python

There are several ways to approach spell checking in python. One common approach is to use a dictionary to store a list of words. The program then checks each word in the document against the dictionary to see if spells are correct.

Another approach is to use a spell checker library. These libraries typically use a more sophisticated approach to spell checking than a simple dictionary lookup. They may also consider the context of a word; to identify errors better.

In this article, We will start by looking at how to use a dictionary for spell-checking. After that, we will explore how to use spell checker libraries for writing spell-checking programs that will check and suggest English words.

One of the simplest ways to approach spell checking is to use a dictionary. A dictionary is a data structure that stores a collection of values. Each value in a dictionary is associated with a key. 

In the context of spell checking, the keys are words, and the values are Boolean values that indicate whether the spelling of a word is correct.

Let’s start by creating an empty dictionary. We will call our dictionary spell_dict.

spell_dict = {}

Next, we must populate our dictionary with words and their associated Boolean values. There are a few ways to do this; One option is to manually add words to the dictionary. This is fine for a few words, but it quickly becomes tedious for large dictionaries.

A more efficient approach is to read the words from a file. We can then loop over the words in the file and add them to the dictionary.

The following code shows how to read the words from a file and add them to a dictionary. 

with open ('words.txt', 'r') as f:
   for line in f :
       word = line.strip()
       spell_dict[word] = True

We can now use our dictionary for spell checking using python. The following code shows how to check a word against the dictionary.

def check_spelling(word):
   if word in spell_dict:
       return True
   else:
       return False

The check_spelling() function takes a word as an argument and returns a Boolean value. If the word is in the dictionary, the function returns True. Otherwise, it returns False.

We can use the check_spelling() function to spell check a document. The following code shows how to do this.

with open('document.txt', 'r') as f:
   for line in f:
       for word in line.split():
           if not check_spelling(word):
               print('Incorrect spelling: ' + word)

In the code above, we have opened the document.txt file in read-only mode. After that, we used a for loop to iterate over the lines in the file. For each line, we have used the split() method to split the line into words. We then used another for loop to iterate over the words. For each word, we have used the check_spelling() function to check if the word is correct. If the word is not in the dictionary, the check_spelling() function will return False.

And here is the complete code in action:

spell_dict = {}

with open ('words.txt', 'r') as f:
   for line in f :
       word = line.strip()
       spell_dict[word] = True

def check_spelling(word):
   if word in spell_dict:
       return True
   else:
       return False

with open('document.txt', 'r') as f:
   for line in f:
       for word in line.split():
           if not check_spelling(word):
               print('Incorrect spelling: ' + word)
              
'''
#--------words.txt-----
hello
how
are
you
doing?

#--------document.txt-----
Hell how r you doing?

#Output
Incorrect spelling: Hell
Incorrect spelling: r
'''

The spell-checking approach used in the code above is very basic. It will only identify words that are not in the dictionary.

If you need a more sophisticated spell checker program, you should consider using a different spell checker library.

There are several spell checker libraries available for python. In this section, we will look at how to use the pyenchant library.

The pyenchant library is a Python wrapper for the Enchant spell checker library. Enchant is a cross-platform library that supports a variety of languages.

The pyenchant library is available from PyPI, so install it using pip.

pip install pyenchant

And if you are facing any problems, you can visit the pyenchant installation guide.

After successful installation, we can use enchant to check the spelling of words. The following code shows how to do this.

import enchant
d = enchant.Dict("en_US")
word = "hellow"
if d.check(word):
   print ("Spelling is correct")
else:
   print ("Spelling is incorrect")

In the code above, we have imported the enchant module. We then used the Dict class to create a dictionary object for the en_US language.

We then checked the spelling of the word “hellow”. The check() method returns a Boolean value. If the spelling of a word is correct, it returns True. Otherwise, it returns False.

If there is a misspelling, the pyenchant library can suggest possible corrections. The following code shows how to do this.

import enchant

d = enchant.Dict("en_US")
word = "hellow"
if d.check(word):
    print("Spelling is correct")
else:
    print("Spelling is incorrect")
    print("Suggested corrections: ")
    for correction in d.suggest(word):
        print(correction)

Apart from that, the pyenchant library also helps check the spelling in the document. The following code shows how to do this.

import enchant
d = enchant.Dict( "en_US" )
with open('document.txt', 'r') as f:
   for line in f:
       for word in line.split():
           if not d.check(word):
               print('Incorrect spelling: ' + word)
               print('Suggested corrections:')
               for correction in d.suggest(word):
                   print(correction)

In the code above, we have imported the enchant module. We then used the Dict class to create a dictionary object for the en_US language.

We then opened the document.txt file in read-only mode. We have then used a for loop to iterate over the lines in the file. For each line, we have used the split() method to split the line into words. We then used another for loop to iterate over the words.

For each word, we have used the check() method to check if the word is correct. If the word is not in the dictionary, the check() method will return False. In this case, we have printed a message to the console to indicate that the word is incorrect. We have then used the suggest() method to suggest possible corrections.

The spell checker approach used in the code above is more sophisticated than the one we used in the previous section. It takes into account the context of a word, which helps to identify errors.

Now, let’s discuss how to create a spell checker program in python using the pyspellchecker library. Pyspellchecker is a pure python library for checking spelling mistakes in strings. 

We will first install the pyspellchecker library using pip.

pip install pyspellchecker

After installation, we can import the library into our python program.

import spellchecker

Now, we will create a function that takes a string as an input and returns a list of misspelled words.

def spell_check(string):
   spell = spellchecker.SpellChecker()
   misspelled_words = spell.unknown(string.split())
   return misspelled_words

We can now test our function on a string with some misspelled words.

string = 'This is a sentense with some mispelled words'
misspelled_words = spell_check(string)
print(misspelled_words)

The code will print out the following result:

{'sentense', 'mispelled'}

Here is the complete code in action:

import spellchecker

def spell_check(string):
   spell = spellchecker.SpellChecker()
   misspelled_words = spell.unknown(string.split())
   return misspelled_words

string = 'This is a sentense with some mispelled words'
misspelled_words = spell_check(string)
print(misspelled_words)

'''
#Output
{'mispelled', 'sentense'}
'''

Apart from that, you can also write a code that can give a suggestion to the misspelled words. Here is how you can do it.

from spellchecker import SpellChecker

spell = SpellChecker()

# find those words that may be misspelled
misspelled = spell.unknown(['something', 'is', 'hapenning', 'here'])

for word in misspelled:
  # Get the one `most likely` answer
  print(spell.correction(word))

  # Get a list of `likely` options
  print(spell.candidates(word))

'''
#Output
happenning
{'hapening', 'happenning'}
'''

We have already seen two libraries for implementing spell-checking programs using python. The most popular one is probably the TextBlob library. The TextBlob library provides a simple interface for doing spell checking in python.

To use the TextBlob library, you first need to install it. You can do this using the pip command:

pip install textblob

After that, you need to create a TextBlob object by passing a string of text to the TextBlob constructor:

text = "Website name is problem solving code"
blob = TextBlob(text)

Once you have a TextBlob object, you can use the correct() method to correct the spelling of words in the string. The correct() method takes a word as an argument and returns the corrected spelling of the word:

print(blob.correct())

If the word is not in the TextBlob dictionary, then the correct() method will return the word unchanged.

Here is the complete code in action

from textblob import TextBlob
text = "Website name is problem solving code"
blob = TextBlob(text)

print(blob.correct())

'''
#Output
Website name is problem solving code
'''

The TextBlob library also provides many other methods and functions for spell checking. For more information, see the TextBlob documentation.

The Autocorrect module also enables us to check the spelling of a single word. And return the correct spelling of the word. To check the spelling, we are required to use the spell() function from the autocorrect library.

To use the autocorrect library, you first need to install it. You can do this using the pip command:

pip install autocorrect

Once you install it, you have to import it, and here is the complete working code.

from autocorrect import Speller

spell = Speller(lang='en')

print(spell('mussage'))
print(spell('survice'))
print(spell('hte'))

'''
#Output
message
service
the
'''

Conclusion

In this article, we have looked at how to use python for spell checking. We have looked at different approaches: one using a dictionary and the others using a spell checker library.

Which approach you use will depend on the specific requirements of your project. If you need a more sophisticated spell checker, you should consider using a spell checker library.