How Do You Count Characters and Words?

Each count needs a different tool, and choosing the right one is the skill being tested.

import re

text = "Python is easy-to-learn, and it's fast."

print(len(text))                             # 39 characters
print(len(text.split()))                     # 6 whitespace-separated words
print(len(re.findall(r"[A-Za-z']+", text)))  # 8 word-like tokens
print(len(re.findall(r"[.!?]", text)))        # 1 sentence
print(sum(1 for c in text.lower() if c in "aeiou"))   # 10 vowels

The character count is simply the length of the string, which counts code points rather than bytes, so an accented letter counts as one.

The two word counts differ, and the difference is the interesting part. split() splits on whitespace and keeps the punctuation attached to each word, so easy-to-learn, comes out as one piece. The regular expression finds runs of letters and apostrophes, so easy-to-learn becomes three tokens and the trailing comma disappears. Neither is wrong — you have to decide what a word means for your data.

Counting sentences with a regex over the punctuation marks is a quick approximation, but it is fooled by an abbreviation or a decimal point. A real sentence splitter needs a library, which is worth saying out loud rather than pretending the regex is exact.

The vowel count uses a generator expression inside sum, which is the idiomatic way to count items that satisfy a condition. The alternative, text.lower().count("a") summed over each vowel, is more readable for a beginner and roughly the same speed.

A plain dict plus get is all you need, and it is worth being able to write it without reaching for Counter.

text = "the cat sat on the mat the end of the day"

counts = {}
for word in text.split():
    counts[word] = counts.get(word, 0) + 1

# Most common word
best = max(counts, key=counts.get)
print(best, counts[best])              # the 3

# Full ranking, most frequent first
ranked = sorted(counts.items(), key=lambda pair: pair[1], reverse=True)
print(ranked[:3])                      # [('the', 3), ('cat', 1), ('sat', 1)]

The counting loop is the whole trick. counts.get(word, 0) returns zero for a word that has not been seen, so the increment always works and no separate membership check is needed.

The max call passes counts.get as the key function, so max compares the counts rather than the words. Because max returns the first item that reaches the maximum, ties are broken by insertion order, which is the order the words first appeared.

Three things a careful answer should add. Lowercase the words if you want case-insensitive counting, and strip punctuation, because the and the. are different keys otherwise. And when you want the top n rather than just the winner, use sorted with a key function and reverse=True, as in the second block — but be aware that sorting is O(n log n) while a single max pass is O(n), so for a very large text and a small top n, heapq.nlargest is the better tool.

In production you would reach for collections.Counter, which does all of this in one line and has a most_common method with the same early-exit optimisation built in.

For characters, use len(text). For words, use len(text.split()), which splits on arbitrary whitespace, collapses runs of spaces and discards empty pieces. For sentences, you need either a regex over terminal punctuation or a dedicated library if accuracy matters.

The things to watch out for are almost all about what a word means. split() keeps punctuation attached, so the end. is a different key from the end. If you are counting word frequencies, you normally want to lowercase and strip the punctuation off each token first, which is easy with a comprehension but easy to forget.

Second, len() counts Unicode code points, not grapheme clusters and not bytes. A flag emoji is several code points but one visible character, so len on emoji text is larger than what a reader sees. There is no built-in solution for that in Python; if it matters, a third-party library handles it. And if you need the byte size instead, use len(text.encode("utf-8")).

Third, be careful about what you are counting when the string is large. Building text.split() allocates a list of every word, which is fine for a paragraph and wasteful for a large corpus. And when you need the most common word, max over a counts dict is a single pass, while sorting the whole dict is O(n log n) — a difference that matters when the vocabulary is large.

Finally, remember that the standard library has no word-frequency counter, but collections.Counter is exactly that in one line, and it is the right answer in production even if it is worth knowing how to write the loop yourself.