Python Relational Operators

diagram a < b < c is not two comparisons on a result mermaid

  flowchart TD
  A["1 < 2 < 3"] --> B["becomes (1 < 2) and (2 < 3)"]
  B --> C["True"]
  D["in most other languages"] --> E["(1 < 2) < 3  ->  True < 3  ->  1 < 3"]
  E --> F["a different question entirely"]
  G["f(1) < f(2) < f(0)"] --> H["f(2) is evaluated ONCE, not twice"]
  I["1 < 2 > 0"] --> J["legal, and True -- but is it a range check?"]
  J --> K["mixed directions compile fine; read them twice"]

Python chains the comparison instead of evaluating left to right the way most languages do -- so a < b < c means a < b and b < c, and the middle expression is evaluated only once. That is usually what you wanted. The trap is that mixed directions are also legal, so an expression that reads like a range check may not be one.

The middle term is evaluated once — verified

python

def f(n): calls.append(n); return n
f(1) < f(2) < f(0)      # calls == [1, 2, 0]

f(2) appears in both halves of the expansion but ran once. That matters when the middle term is expensive or has a side effect — a database call, a pop from a queue.

Two related surprises worth knowing while you are here:

python

False == 0      # True
True == 1       # True
1 in [True]     # True

bool is a subclass of int, so True really does equal 1. A membership test against a list of flags can therefore match a number, and {1: "a", True: "b"} is a one-key dictionary.

Navigating Relationships: Relational Operators in Python

Relational operators in Python play a pivotal role in evaluating and expressing relationships between values. They allow you to compare variables, check conditions, and make decisions based on the outcomes of these comparisons. In this comprehensive guide, we’ll explore the realm of relational operators, their syntax, and their applications in Python programming.

Tip

Relational operators in Python are the same as in other programming languages (like C, C++, Java, etc.). However, there are a few differences that you should be aware of. For example, the equality operator (==) in Python is different from the assignment operator (=). We’ll discuss these differences in detail later in this tutorial.

The following table lists the relational operators in Python:

Operator	Description	Example
==	If the values of two operands are equal, then the condition becomes true	x == y
!=	If values of two operands are not equal, then the condition becomes true	x != y
>	If the value of the left operand is greater than the value of the right operand, then the condition becomes true	x > y
<	If the value of the left operand is less than the value of the right operand, then the condition becomes true	x < y
>=	If the value of the left operand is greater than or equal to the value of the right operand, then the condition becomes true	x >= y
<=	If the value of the left operand is less than or equal to the value of the right operand, then the condition becomes true	x <= y

Note

Relational operators in Python are binary operators, meaning they require two operands. However, the identity operators (is and is not) are unary operators, meaning they require only one operand. Relational operators are also known as comparison operators. The Result of a relational operator is either True or False. For example, x == y returns True if x is equal to y, otherwise it returns False. We’ll discuss this in detail later in this tutorial.

Equality

== (Equality) Operator

The equality operator (==) compares the values of two operands. If the values of both operands are equal, then the condition becomes True. Otherwise, the condition becomes False. The following example demonstrates how to use the equality operator in Python:

operators.py

# Equality operator
x = 10
y = 5
z = x == y
t = x == 10
print(z)
print(t)

Output:

command

C:\Users\Your Name> python operators.py
False
True

In the above example, we have used the equality operator to compare the values of two operands x and y. Since the value of x is not equal to the value of y, the condition becomes False. The result of the equality operator is then assigned to the variable z. The value of z is then printed to the console.

Inequality

!= (Inequality) Operator

The inequality operator (!=) compares the values of two operands. If the values of both operands are not equal, then the condition becomes True. Otherwise, the condition becomes False. The following example demonstrates how to use the inequality operator in Python:

operators.py

# Inequality operator
x = 10
y = 5
z = x != y
t = x != 10
print(z)
print(t)

Output:

command

C:\Users\Your Name> python operators.py
True
False

In the above example, we have used the inequality operator to compare the values of two operands x and y. Since the value of x is not equal to the value of y, the condition becomes True. The result of the inequality operator is then assigned to the variable z. The value of z is then printed to the console.

Greater Than

> (Greater Than) Operator

The greater than operator (>) compares the values of two operands. If the value of the left operand is greater than the value of the right operand, then the condition becomes True. Otherwise, the condition becomes False. The following example demonstrates how to use the greater than operator in Python:

operators.py

# Greater than operator
x = 10
y = 5
z = x > y
t = x > 10
print(z)
print(t)

Output:

command

C:\Users\Your Name> python operators.py
True
False

In the above example, we have used the greater than operator to compare the values of two operands x and y. Since the value of x is greater than the value of y, the condition becomes True. The result of the greater than operator is then assigned to the variable z. The value of z is then printed to the console.

Less Than

< (Less Than) Operator

The less than operator (<) compares the values of two operands. If the value of the left operand is less than the value of the right operand, then the condition becomes True. Otherwise, the condition becomes False. The following example demonstrates how to use the less than operator in Python:

operators.py

# Less than operator
x = 10
y = 5
z = x < y
t = x < 10
print(z)
print(t)

Output:

command

C:\Users\Your Name> python operators.py
False
False

In the above example, we have used the less than operator to compare the values of two operands x and y. Since the value of x is not less than the value of y, the condition becomes False. The result of the less than operator is then assigned to the variable z. The value of z is then printed to the console.

Greater Than or Equal To

>= (Greater Than or Equal To) Operator

The greater than or equal to operator (>=) compares the values of two operands. If the value of the left operand is greater than or equal to the value of the right operand, then the condition becomes True. Otherwise, the condition becomes False. The following example demonstrates how to use the greater than or equal to operator in Python:

operators.py

# Greater than or equal to operator
x = 10
y = 5
z = x >= y
t = x >= 10
print(z)
print(t)

Output:

command

C:\Users\Your Name> python operators.py
True
True

In the above example, we have used the greater than or equal to operator to compare the values of two operands x and y. Since the value of x is greater than the value of y, the condition becomes True. The result of the greater than or equal to operator is then assigned to the variable z. The value of z is then printed to the console.

Less Than or Equal To

<= (Less Than or Equal To) Operator

The less than or equal to operator (<=) compares the values of two operands. If the value of the left operand is less than or equal to the value of the right operand, then the condition becomes True. Otherwise, the condition becomes False. The following example demonstrates how to use the less than or equal to operator in Python:

operators.py

# Less than or equal to operator
x = 10
y = 5
z = x <= y
t = x <= 10
print(z)
print(t)

Output:

command

C:\Users\Your Name> python operators.py
False
True

In the above example, we have used the less than or equal to operator to compare the values of two operands x and y. Since the value of x is not less than the value of y, the condition becomes False. The result of the less than or equal to operator is then assigned to the variable z. The value of z is then printed to the console.

Combining Relational Operators

You can combine relational operators in Python to create complex conditions. For example, you can combine the equality operator (==) and the greater than operator (>) to create a condition that checks if the value of x is greater than y and equal to z. The following example demonstrates how to combine relational operators in Python:

operators.py

# Combining relational operators
x = 10
y = 5
z = 10
t = x > y and x == z
print(t)

Output:

command

C:\Users\Your Name> python operators.py
True

In the above example, we have combined the equality operator (==) and the greater than operator (>) to create a condition that checks if the value of x is greater than y and equal to z. Since the value of x is greater than y and equal to z, the condition becomes True. The result of the condition is then assigned to the variable t. The value of t is then printed to the console.

Relational Operators with Strings

You can also use relational operators with strings in Python. For example, you can use the equality operator (==) to check if two strings are equal. The following example demonstrates how to use relational operators with strings in Python:

operators.py

# Relational operators with strings
x = "Hello"
y = "World"
z = x == y
t = x == "Hello"
print(z)
print(t)

Output:

command

C:\Users\Your Name> python operators.py
False
True

In the above example, we have used the equality operator to check if the value of x is equal to the value of y. Since the value of x is not equal to the value of y, the condition becomes False. The result of the condition is then assigned to the variable z. The value of z is then printed to the console.

Conclusion

Relational operators are fundamental tools for expressing conditions and making decisions in Python. Whether you’re comparing numerical values, checking string order, or combining conditions with logical operators, relational operators provide the means to navigate relationships between variables.

As you continue your Python journey, experiment with different relational operators, explore their applications in real-world scenarios, and use them to create dynamic and responsive code. For more insights and practical examples, check out our tutorials on Python Central Hub!

---

sketch a < b < c is one expression, not two comparisons p5.js Pause Restart

Python expands a chain into an AND of neighbouring pairs, and the middle term is evaluated only once. Most other languages compare left to right, which turns the first result into a boolean and then compares THAT with the third value -- a different question with a plausible-looking answer.

Check yourself

pch.quizTag pch.quizDefaultTitle

1. In Python, what does `1 < 2 < 3` mean?

   A `(1 < 2) < 3` B `(1 < 2) and (2 < 3)` C `1 < (2 < 3)` D A syntax error
   pch.quizShowAnswer

   B — `(1 < 2) and (2 < 3)` — Python chains the comparison into an AND of neighbouring pairs. Most other languages evaluate left to right, which compares a boolean with the third value instead.

2. `f(1) < f(2) < f(0)`. How many times is `f(2)` called?

   A Twice — it appears in both halves B Once C Zero times if the first comparison is False D It depends on the return values
   pch.quizShowAnswer

   B — Once — Verified: the call log was `[1, 2, 0]`. The middle term appears twice in the expansion but is evaluated once, which matters when it is expensive or has a side effect.

3. What is `False == 0` in Python?

   A `False` B `True` C It raises TypeError D `None`
   pch.quizShowAnswer

   B — `True` — `bool` is a subclass of `int`, so `True == 1` and `False == 0`. That is also why `1 in [True]` is True and `{1: 'a', True: 'b'}` is a one-key dictionary.

4. Is `1 < 2 > 0` valid Python?

   A No, directions cannot be mixed B Yes, and it means `(1 < 2) and (2 > 0)` C Yes, but it always returns False D Only inside an `if`
   pch.quizShowAnswer

   B — Yes, and it means `(1 < 2) and (2 > 0)` — It is legal and evaluates to True. It reads like a range check and is not one, which is exactly why mixed-direction chains deserve a second look.

Try it: Relational Operators Exercises

Exercise 1 – Basic Comparisons

pch.exerciseTag pch.exerciseTitle

Exercise 2 – String Comparison

pch.exerciseTag pch.exerciseTitle

Exercise 3 – Chained Comparisons

pch.exerciseTag pch.exerciseTitle