Comparison Operators in Python
Learn about the various types of comparison operators in Python, ASCII values, syntax, and their usage in comparing values.
Table of Contents
- Introduction to Comparison Operators
- Greater than Operator (>)
- Less than operator (<)
- Equality operator (==)
- Not equal to (!=)
- Greater than equal to (>=)
- Less than equal to (<=)
Introduction to comparison operators
Assume you are adding 2 numbers. The numbers are the operands and the
+ symbol is the operator.
Comparison operators in Python are used to compare the values of its operands and return a boolean result. Apart from numbers, Python also allows comparing strings. Confused? The secret lies in ASCII values.
ASCII is a character encoding standard and stands for American Standard Code for Information Interchange. It is used to encode the characters that we as humans are used to, into a binary format. You can find a list of all ASCII codes here.
Here are the various types of comparison operators in python.
Let’s check out the usage of all these operators through some examples.
Greater than operator (>)
This operator is used to check if the value on the left is greater than the value on the right.
print(3 > 2) print(-5 > 4) print(-290023 > 1)
In all the above examples, it is going to check if the comparison holds. The above snippet will return the following result.
True False False
Makes sense, right?
Like mentioned earlier, we can also compare strings.
print('Savan' > 'savan')
The above snippet will return False. Its because the ASCII value of
s is 115 and the ASCII value of
S is 83. When you compare strings, the ASCII values of the first characters are first compared. If the ASCII values are different, a boolean result is returned based on the comparison. If the ASCII values are the same, the next characters are compared, and so on.
So what happens when you run the following code?
print('savan' > 'savaN')
The starting 4 characters of both the strings are same. Only the last character is different. In this case, python will compare the ASCII values of all the characters until the last. Since the ASCII value of
n(110) is greater than the ASCII value of
N(78), Python will return us True. The image below shows the pictorial representation of the process.
Less than operator (<)
This operator is used to check if the value on the left is less than the value on the right.
print(3 < 2) # Returns False print(-5 < 4) # Returns True print(-290023 < 1) # Returns True
It works similarly with strings.
print('Savan' < 'savan')
The above snippet will return us True. Its because the ASCII value of
S is 83 and the ASCII value of
s is 115. So the rest of the letters are not compared anymore and Python returns True.
Equality operator (==)
Equality operator is used to checking the equality of the values of its operands. Not to be confused with the equal to (
= operator is used to assigning a value to a variable. When you say
x = 5, you are assigning the value 5 to variable x. The
== operator just checks if the values of both left and right operands are equal or not and returns a boolean.
Consider the following statements.
x = 5 print(x == 5) # Returns True print(x == 4) # Returns False # Equality with strings print('Savan' == 'Savan') # Returns True print('Savan' == 'savan') # Returns False
For numerical comparison, it is pretty straightforward. For strings, it is the ASCII value again that determines the result of the comparison.
Not equal to (!=)
This is the opposite of the equality operator. It checks if the values of its operands are unequal. Let's consider the above example.
x = 5 print(x != 5) # Returns False print(x != 4) # Returns True # Equality with strings print('Savan' != 'Savan') # Returns False print('Savan' != 'savan') # Returns True
So if the values of both its operands are equal, the
!= operator will return False.
Greater than equal to (>=)
This operator combines the greater than operator
(>) with the equality operator
(==). It checks if the left side operand is greater than or equal to the right side operand.
x = 5 print(x >= 5) # Returns True print(x >= 6) # Returns False # Comparison of strings print('Savan' >= 'Savan') # Returns True print('Savan' >= 'savan') # Returns False
Since the ASCII value of
S (83) is less than the ASCII value of
s (115), the comparison will return us False.
Less than equal to (<=)
This operator is the opposite of >= operator. This operator combines the less than operator
(<) with the equality operator (==). It checks if the left side operand is less than or equal to the right side operand.
x = 5 print(x <= 5) # Returns True print(x <= 4) # Returns False # Comparison of strings print('Savan' <= 'Savan') # Returns True print('Savan' <= 'savan') # Returns True
Since the ASCII value of
S (83) is less than the ASCII value of
s (115), the comparison will return us True.
Hold on !!
What are we talking about here? Isn’t it true that Python 3 doesn’t have ASCII anymore? Isn’t everything Unicode in Python 3 (at least the text type)? Then why do the explanations for the comparison of strings using ASCII values make sense?
Short explanation - Unicode is backward compatible.
Confused? Let’s understand it better.
Now Python doesn’t actually use ASCII (at least since Python 3 came out - Python 2 did use ASCII), but rather another encoding called UTF-8 where UTF stands for UCS Transformation Format and UCS stands for Universal Coded Character Set.
UTF-8 is what is called a variable-width encoding and the de facto standard when it comes to Unicode. The beauty of UTF-8 is that it supports loads of special characters - but not at the price of making the regularly used characters (for the western world at least) need more memory. This is the variable width part mentioned earlier.
The gritty details
If we take a look at the most common characters used, their memory representation looks like this:
'R' => 0b0101_0010 <U+0052> 's' => 0b0111_0011 <U+0073>
The part in angled brackets is called a Unicode code point. It’s usually written in hex - as it is here. If you compare these values to their ASCII pendant, you’ll see that they’re actually the same.
# ASCII counterparts for the above letters # hex codes 'R' => 0x52 's' => 0x73
This is another great property of UTF-8 - it’s backward compatible with ASCII and also the reason, why the above explanation still holds true for the most part.
If you prefer to watch videos, check out this Youtube video on Comparison and Assignment Operators.