5 Best Ways to Count the Number of Words in a String in Python

Counting the number of words in a string is a common task in text processing and analysis. This article outlines five methods ranging from simple to more advanced techniques for determining the word count in a given string. Picture a scenario where we receive a string like “Hello world, Python is amazing!” and we seek to find out that there are 5 words in this string.

Method 1: Using str.split()

This method involves utilizing Python’s built-in string method split(), which divides a string into a list of words, using whitespace as the default separator. The number of words in the string is then the length of this list.

Here’s an example:

text = "Count the words in this sentence, please."
words = text.split()
word_count = len(words)
print(word_count)

Output:

This code snippet splits the input string into a list of individual words based on whitespace. Afterwards, it determines the total number of words by finding the length of the list using the built-in function len().

Method 2: Using Regular Expressions (re.findall())

Regular expressions can be used for more complex word counting, including handling strings with punctuation. The findall() method from Python’s re module is employed to locate all substrings that match a regular expression.

Here’s an example:

import re
text = "Hello world! Python's regex can match words."
words = re.findall(r'\b\w+\b', text)
word_count = len(words)
print(word_count)

Output:

This code utilizes a regular expression pattern \b\w+\b that matches whole words, including those with apostrophes. It produces a list of all matched words, and similarly to Method 1, the word count is the length of this list.

Method 3: Using str.count() with a Twist

Instead of directly splitting the string, this method counts the number of spaces and adds one, assuming that words are separated by single spaces. It’s less accurate but faster for large texts without punctuation.

Here’s an example:

text = "Fast, but less accurate word count."
word_count = text.count(' ') + 1
print(word_count)

Output:

This method simply counts how many times a space appears in the string with the count() function and assumes there is one more word than there are spaces. This approach is simplistic and can lead to incorrect results if the input string has multiple consecutive spaces or punctuation.

Method 4: Using a Custom Function

Writing a custom function allows for more control and potentially more accurate word counting by manually iterating over the string and considering different delimiters or rules for what constitutes a word.

Here’s an example:

def count_words(text):
    state = False
    word_count = 0
    for char in text:
        if char.isalpha():
            state = True
        elif state:
            word_count += 1
            state = False
    return word_count + (1 if state else 0)

text = "Custom function: counts accurately (mostly)!"
print(count_words(text))

Output:

This custom function iterates through each character in the string, flipping a state variable when transitioning from a non-letter to a letter, which signifies the start of a new word. The function then increments the word count as each word is identified.

Bonus One-Liner Method 5: Using len() with List Comprehension

A compact and Pythonic approach involves using a list comprehension to filter out spaces and punctuation and then getting the count of words with len().

Here’s an example:

text = "One-liners: powerful, succinct; Pythonic!"
word_count = len([word for word in text.split() if word.strip(".,;:")])
print(word_count)

Output:

The one-liner uses a list comprehension to filter out empty strings that result from splitting at punctuation, thereby counting only actual words. However, this method might fail with complex punctuation or special cases.

Summary/Discussion

• Method 1: Using str.split(). Simple and straightforward. It works well for average cases but does not handle punctuation well.
• Method 2: Using Regular Expressions. More precise as it can handle punctuation and special word characters. However, it might require additional considerations for edge cases and is slower for large texts.
• Method 3: Using str.count() with a Twist. It’s a quick method but not accurate for strings with multiple spaces or punctuation.
• Method 4: Using a Custom Function. Offers flexibility and can be tailored for specific needs or rules on what constitutes a word. It could be overkill for simple strings though.
• Bonus Method 5: Using len() with List Comprehension. A concise Pythonic way for counting words, best for simpler cases where some assumptions about formatting can be made.