Comparing words in python

For instance, let’s compare the names “Alice” and “Bob”. This comparison corresponds to checking if Alice is before Bob in alphabetical order.

Now you have the tools for comparing strings in Python. Next, let’s understand how the string comparison works behind the scenes.

String Unicodes in Python

In reality, comparing Python strings means comparing integers under the hood.

To understand how it works, you first need to understand the concept of Unicode.

Python string uses the Unicode Standard for representing characters. This means each character has a unique integer code assigned to it. It is this Unicode integer value that is compared when comparing strings in Python

Here is the Unicode table for English characters (also known as the ASCII values).

When a Python program compares strings, it compares the Unicode values of the characters.

By the way, to check the Unicode of a character, you do not have to look it up from this table. Instead, you can use the built-in ord() function.

>>> ord('a') 97 >>> ord('b') 98 >>> ord('c') 99 >>> ord('d') 100

Now, let’s check the Unicode values for the capitalized versions of the above four characters:

>>> ord('A') 65 >>> ord('B') 66 >>> ord('C') 67 >>> ord('D') 68

As you can see, the Unicode values for capitals characters differ from their lowercase counterparts. This highlights an important point—Python is case-sensitive with characters and strings.

For example, the result of this comparison:

Yields True.

How Python String Comparison Works Under the Hood

When you compare strings in Python the strings are compared character by character using the Unicode values.

When you compare two characters, the process is rather simple. But what happens when you compare strings, that is, sequences of characters?

Let’s demonstrate the process with examples.

Example 1—Which String Comes First in Alphabetic Order

Let’s compare the two names “Alice” and “Bob” to see if “Alice” is less than “Bob”:

This states that “Alice” is less than “Bob”. In real life, this means that Alice comes before Bob in alphabetical order, which totally makes sense.

But how does Python know it?

Python starts by comparing the first characters of the strings. In the case of “Alice” and “Bob” it starts by checking if ‘A’ is less than ‘B’ in Unicode:

As ord(‘A’) returns the Unicode value of 65 and ord(‘B’) 66, the comparison evaluates to True.

This means Python does not need to continue any further. Based on the first letters it is already able to determine that “Alice” is less than “Bob” because ‘A’ is less than ‘B’ in Unicode.

This is the simplest way to understand how Python compares strings.

Let’s see another a bit trickier example where the compared strings have same first letters.

Example 2—How to Compare Strings with Equal First Letters

What if the first letters are equal when comparing two strings? No problem, Python then compares the second letters.

For instance, let’s check if “Axel” comes before “Alex” in alphabetical order.

This suggests that Alex comes before Axel, which is indeed the case.

Let’s see how Python was able to determine this:

1. The first letters are compared. Both are ‘A’, so there is a “tie”. The comparison continues to the next characters.
2. The second characters are are ‘x’ and ‘l’. The unicode value for ‘x’ is 120 and 108 for ‘l’. And 120 < 108returns False. Thus the whole string comparison returns False.

Example 3—How to Compare Strings with Identical Beginning

What if the strings are otherwise equal, but there are additional characters at the end of the other one?

For instance, can you determine if “Alex” comes before “Alexis” in alphabetical order?

Let’s check this using Python:

In this case, the Python interpreter simply treats the longer string as the greater one. In other words, “Alex” is before “Alexis” in alphabetical order.

Now you understand how the string comparison works under the hood in Python.

Finally, let’s take a look at an interesting application of string comparison by comparing timestamps.

Compare Timestamps in Python with String Comparison

In this guide, you have learned that each character in Python has a Unicode value which is an integer. This is no exception to numeric strings.

For example, a string “1” has a Unicode value of 49 and “2” has a Unicode value of 50 and so on:

The Unicode value of a numeric character grows as the number grows.

This means comparing the order of numeric strings gives you a correct result:

But why would you ever compare numbers as strings?

Comparing numeric strings is useful when talking about ISO 8601 timestamps of format 2021-12-14T09:30:16+00:00.

For example, let’s check if “2021-12-14T09:30:16+00:00” comes before “2022-01-01T00:00:00+00:00“:

But wait a minute! Does the comparison operator have any idea about dates and their precedence?