Python: Comparing Strings

In Python, comparing strings is a common task that you’ll do often. Whether you’re checking if two pieces of text are the same, sorting items in a list, or searching for specific patterns, string comparison plays a key role in many programs.

String comparison allows you to:

Check for equality: Are two strings the same?
Sort data: Organize strings alphabetically.
Search for parts of a string: Find if one string is inside another.

In this article, we’ll focus on -how- to compare strings in Python using simple and clear methods.

Table of Contents

Using the `==` Operator – Checking for Equality

The == operator is the most straightforward way to check if two strings are exactly the same. When you use == between two strings, Python compares their characters one by one. If every character matches, the result is True; if any character doesn’t match, the result is False.

Example: Comparing Two Identical Strings

print("apple" == "apple") # True

Here, both strings are exactly the same, so the result is True.

Example: Comparing Different Strings

print("apple" == "orange") # False

In this case, the strings are different, so Python returns False.

This is a simple way to check if two pieces of text are the same in Python!

Using `!=` Operator – Checking for Inequality

The != operator is used to check if two strings are not equal. It works the opposite way of ==. If the strings are different, the result will be True; if they are the same, the result will be False.

Example: Strings that are Not Equal

print("apple" != "orange") # True

Here, the two strings are different, so the result is True.

Example: Strings that are the Same

print("apple" != "apple") # False

In this case, both strings are the same, so the result is False.

This is a simple way to check if two strings are not the same in Python!

Using `<`, `>`, `<=`, `>=` Operators – Lexicographical Comparison

You can compare strings alphabetically in Python using the operators <, >, <=, and >=. This type of comparison is called lexicographical comparison (which is like comparing words in a dictionary).

Python compares the strings based on their character values. These values are usually determined by their ASCII or Unicode codes. For example, ‘a’ has a lower value than ‘b’, so “apple” will come before “banana”.

Example: Comparing Alphabetically

print("apple" < "banana") # True (since 'a' comes before 'b')

In this case, “apple” is considered smaller (comes first) than “banana” because ‘a’ comes before ‘b’ in the alphabet.

Example: Comparing Two Strings Where One Comes Later

print("orange" > "banana")  # True (since 'o' comes after 'b')

Here, “orange” is considered greater than “banana” because ‘o’ comes after ‘b’.

This comparison is very useful when sorting words or arranging strings in order!

Using `in` and `not in` – Checking for Substrings

In Python, you can easily check if one string is a substring (a smaller part) of another string using the in and not in operators.

in checks if a string contains another string.
not in checks if a string does not contain another string.

These are great for searching for specific words or parts inside a larger text.

Example: Checking if a String is a Substring

print("apple" in "apple pie") # True

Here, "apple" is a substring of "apple pie", so the result is True.

Example: Checking if a String is Not a Substring

print("banana" not in "apple") # True

Since "banana" is not part of "apple", the result is True.

This method is super useful for finding words or patterns inside text!

Using `startswith()` and `endswith()` – Prefix and Suffix Comparison

Python has two useful methods for comparing the start and end of strings: startswith() and endswith(). These methods help you check if a string begins or ends with certain characters, which can be helpful in many situations.

startswith() checks if a string begins with a specific prefix.
endswith() checks if a string ends with a specific suffix.

Both methods return True if the string matches the given prefix or suffix, and False if it doesn’t.

Example: Checking the Start of a String

print("apple".startswith("ap")) # True

Here, "apple" starts with "ap", so the result is True.

Example: Checking the End of a String

print("orange".endswith("ge")) # True

In this case, "orange" ends with "ge", so the result is True.

These methods are great for matching specific parts at the beginning or end of a string!

Using `is` and `is not` – Comparing Object Identity

In Python, the is and is not operators are used to check if two variables point to the same object in memory. This is different from comparing the content of the strings.

When you use is, Python checks if both variables refer to the same object, not whether their values are identical. So, is compares the identity of the objects, not their actual content.

Example: Checking if Two Strings Are the Same Object

a = "hello"
b = "hello"

print(a is b) # True (strings with the same content may point to the same memory location)

Here, even though a and b both contain "hello", Python might store them at the same memory location for efficiency, so a is b returns True.

Example: Checking if Two Strings Are Different Objects

a = "hello"
b = "world"

print(a is not b) # True (different strings, so they point to different memory locations)

In this case, a and b point to different objects in memory, so a is not b is True.

Remember, is and is not are used to compare identity (where the object is stored in memory), not the value of the strings. For comparing string content, use == instead.

Case-Insensitive Comparison Using `.lower()` or `.upper()`

Sometimes you may want to compare strings without considering their case (whether they’re uppercase or lowercase). To do this, you can convert both strings to either lowercase or uppercase using the .lower() or .upper() methods, and then compare them.

.lower() converts all characters in the string to lowercase.
.upper() converts all characters in the string to uppercase.

By converting both strings to the same case, you can make the comparison case-insensitive.

Example: Comparing Two Strings in Lowercase

print("apple".lower() == "APPLE".lower()) # True

Here, both strings are converted to lowercase ("apple"), so they match, and the result is True.

Example: Comparing Two Strings in Uppercase

print("Hello".upper() == "HELLO".upper()) # True

Similarly, both strings are converted to uppercase ("HELLO"), so they match, and the result is True.

This method is useful when you need to compare strings without worrying about whether the letters are in uppercase or lowercase.

Using `locale` Module for Localized String Comparison (Optional)

Python’s locale module allows you to compare strings based on the local language and character ordering rules of a specific region. This is useful if you need to compare strings following a certain cultural or language-specific sorting order.

The locale.strcoll() function can be used to compare two strings according to the localization settings.

Example: Using `locale.strcoll()` for Localized Comparison

import locale
locale.setlocale(locale.LC_COLLATE, 'en_US.UTF-8')  # Set the locale to US English

print(locale.strcoll("apple", "banana"))  # Compares with locale rules

In this example, the strcoll() function compares "apple" and "banana" using the US English sorting rules, which may differ from the default Python comparison.

This method is optional and typically used for applications that need to sort or compare strings according to specific regional rules. It returns -1 if the first string comes before the second, 0 if equal, and 1 if first string comes after second string.

Conclusion

In this article, we’ve explored different ways to compare strings in Python:

Equality check (==) to see if two strings are the same.
Inequality check (!=) to check if strings are different.
Lexicographical comparison (<, >, <=, >=) to compare strings alphabetically.
Substring check (in, not in) to see if one string contains another.
Prefix and suffix check (startswith(), endswith()) to compare the beginning and end of strings.
Object identity check (is, is not) to see if two strings refer to the same object.
Case-insensitive comparison using .lower() or .upper().
Localized comparison using the locale module for language-specific string sorting (optional).

There are many ways to compare strings, and each has its own use case. Try experimenting with these methods in your code to see which works best for your needs.

Using the == Operator – Checking for Equality