Home

Learning Hub

Articles

Relational Operators in Python : Different Types & Examples

Relational operators are used to form a relation between two or more operands using the comparison method like greater than, less than, equal to and not equal. After the comparison of the two operands the result is a boolean value. They make it possible to compare values which makes it easier to perform vital functions like conditional execution, data filtering, validation, and effective algorithm implementation. Relational operators are essential to programming because they make software more functional and interactive by enabling the creation of complicated logical conditions.

List of Relational Operators in Python

Practical Examples

Comparing Numbers

Relational operators are normally used to compare integers and floating-point numbers.

Example:

x = 10

y = 20

• Equal to (==):

print(x == y)

• Output:

False

• Greater than (>):

print(x > y)

• Output:

False

• Less than or equal to(<=):

print(x <= y)

• Output:

True

Comparing Strings

In Python, strings can be compared using relational operators. In this, we compare them on the basis of lexicographical (dictionary) order which means Python compares characters using their Unicode values.

Example:

a1 = “apple”

a2 = “banana”

• Equal to(==):

print(a1 == a2)

• Output:

False

• Not equal to(!=):

print(a1 != a2)

• Output:

True

• Less than(<):

print(a1 < a2)

• Output:

True (because ‘a’ comes before ‘b’)

• Greater than(>):

print(a2 > a1)

• Output:

True (because ‘banana’ comes after ‘apple’)

Comparing Lists and Other Data Structures

In Python, we can also compare other data structures like lists, tuples, and sets. As seen above, lists are also compared in the same way as strings that are element by element.

List

l1 = [1, 2, 3]

l2 = [1, 2, 4]

• Equal to(==):

print(l1 == l2)

Output: False

• Not equal to(!=):

print(l1 != l2)

Output: True

• Less than(<):

print(l1 < l2)

Output: True (because 3 < 4 at the third position)

• Greater than(>):

print(l2 > l1)

Output: True

Tuples

t1 = (1, 2, 3)

t2 = (1, 2, 5)

print(t1 < t2)

Output: True                                                                      #because 3 < 5

Sets

In Python, the sets and not in order therefore the greater than and less than operators do not work directly.

s1 = {1, 2, 3}

s2 = {1, 2, 3, 4}

• Subset

print(s1 <= s2)

• Output: True

• Superset

print(s2 >= s1)

• Output: True

• Not Equal

print(s1 != s2)

• Output: True

Common Use Cases

Relational Operators are used on various platforms. Let us look at some of the common use cases:

Conditional Statements

In order to run a program efficiently sometimes the relational operators are used in if, elif, and else.

Example:

Output:

Multiple Conditions

You can combine relational operators with logical operators and, or, not for more complex conditions.

Example:

Output:

Loops

For Loop

In for loops, relational operators can be used with the range() function or other iterable data types.

Example:

Output:

While Loop

Output:

Data Validation

Relational operators are also useful for validating user input, ensuring data is within a certain range or follows specific rules.

Example:

Check if the number is within the given range:

Beyond basic comparisons, Python offers more advanced ways to use relational operators, including chaining comparisons and using them within functions. Let’s explore these topics in depth.

Chaining Relational Operators

Python allows the user to chain multiple relational operators together which helps the user to execute multiple comparisons in just one statement. This also makes the code easy to read and understand as it uses layman terms.

Example:

Output:

Benefits of Chaining:

• Chaining is concise and easy to read, especially for range checks.
• Python evaluates the chained comparisons left to right. It only checks the next condition if the current one is True, which can help optimize performance in some cases.

Also Read: While Loop in Python

Using Relational Operators with Functions

You can use relational operators within functions to make comparisons more modular and reusable. This is particularly useful when you’re comparing complex data or when the same comparison is needed in multiple parts of the code.

Example: Using Relational Operators to Validate Custom Functions

Output:

In this example, the function “inrange()” simplifies the logic of checking whether a number lies between two limits.

Also Read: Difference between For Loop and While Loop in Python

Conclusion

In Python, relational operators are a component of a fundamental programming idea. They are essential for drawing logical conclusions from value comparisons. When expressing relationships between variables, these operators offer a clear and comprehensible method, whether they are utilized for data analysis or in conditional statements.

Writing effective Python code requires an understanding of relational operators and how to combine and use them. A firm understanding of these operators will surely improve your capacity to write reliable and useful programs as you work through increasingly difficult programming assignments and a compilation of code snippets.