Get free ebooK with 50 must do coding Question for Product Based Companies solved
Fill the details & get ebook over email
Thank You!
We have sent the Ebook on 50 Must Do Coding Questions for Product Based Companies Solved over your email. All the best!

# Python Logical Operators

Last Updated on March 10, 2023 by Abhishek Sharma

In Python, operators are symbols that represent actions to be performed on data. These actions can be mathematical, logical, or bit-wise operations. Operators are used to manipulating values and variables in a program, and they are essential for writing efficient and concise code. There are several types of operators in Python, including arithmetic operators, comparison operators, assignment operators, and logical operators. In this article, we will explore Python logical operators along with their usage and examples.

## What are Python Logical Operators?

Python logical operators are used to combine and manipulate Boolean values. They allow you to create more complex expressions that evaluate to be either True or False. Logical operators are essential for writing conditional statements and controlling the flow of your program.

## Types of Python Logical Operators

There are three types of Python logical operators available:

### AND Operator

The logical And operator in Python is represented by the symbol "and". It is used to combine two or more Boolean values and returns True if all operands are True. Otherwise, it returns False.

Here are some examples of using the "and" operator in Python:

Example 1 of AND operator in Python-

``````a = True
b = False

print(a and b) # Prints False``````

Explanation: In the example above, the variable "a" is assigned the Boolean value True, and the variable "b" is assigned the Boolean value False. The above example returns False because "b" is False, even though "a" is True.

Example 2 of using AND operator with non-Boolean values-
You can also use the "and" operator with non-Boolean values, in which case Python will evaluate the operands as Boolean values based on their truthiness.

``````a = 10
b = 5
c = 0

print(a and b) # Prints True because both a and b are truthy

print(a and c) # Prints 0 because c is falsy``````

Explanation: In this example, the variable "a" is assigned the integer value 10, the variable "b" is assigned the integer value 5, and the variable "c" is assigned the integer value 0. The first example prints True because both "a" and "b" are truthy. The second example prints 0 because "c" is falsy, even though "a" is truthy.

Example 3 of using AND operator using short-circuit evaluation –
The "and" operator uses short-circuit evaluation. This means that if the first operand is False, Python does not evaluate the second operand because the overall expression will always be False.

``````a = False
b = True

print(b and a) # Does not evaluate b because a is False``````

Explanation: In this example, the variable "a" is assigned the Boolean value False, and the variable "b" is assigned the Boolean value True. The above example does not evaluate "b" because "a" is False, and the overall expression will always be False.

### OR Operator

The logical "or" operator in Python is represented by the symbol "or". It is used to combine two or more Boolean values and returns True if at least one operand is True. Otherwise, it returns False.

Here are some examples of using the "or" operator in Python:

Example – 1 of OR operator in python

``````a = True
b = False
c = False

# Prints True because a is True, even though c is False
print(a or b or c) ``````

Explanation: In the example above, the variable "a" is assigned the Boolean value True, the variable "b" is assigned the Boolean value False, and the variable "c" is assigned the Boolean value False. The above example prints True because "a" is True, even though "b" and "c" are both False.

Example – 2 of using OR operator using short-circuit evaluation
The "or" operator uses short-circuit evaluation. This means that if the first operand is True, Python does not evaluate the second operand because the overall expression will always be True.

``````a = True
b = False

# Prints True because a is True
print(b or a)

# Does not evaluate b because a is True
print(a or b)``````

Explanation: In this example, the variable "a" is assigned the Boolean value True and the variable "b" is assigned the Boolean value False. The first example prints True because "a" is True, even though "b" is False. The second example does not evaluate "b" because "a" is True, and the overall expression will always be True.

### NOT Operator

The logical "not" operator in Python is represented by the keyword "not". It is used to reverse the Boolean value of an operand. If the operand is True, "not" returns False. If the operand is False, "not" returns True.

Here are some examples of using the "not" operator in Python:

Example – 1 of NOT Operator

``````a = True
b = False

# Prints False because a is True
print(not a)

# Prints True because b is False
print(not b)``````

Explanation: In the example above, the variable "a" is assigned the Boolean value True and the variable "b" is assigned the Boolean value False. The first example returns False because "a" is True, but "not" reverses it to False. The second example returns True because "b" is False, and "not" reverses it to True.

Example – 2 of NOT Operator

``````a = 10
b = 0

# Returns False because a is truthy
print(not a)

# Returns True because b is falsy
print(not b)``````

Explanation: In this example, the variable "a" is assigned the integer value 10 and the variable "b" is assigned the integer value 0. The first example returns False because "a" is truthy, but "not" reverses it to False. The second example returns True because "b" is falsy, and "not" reverses it to True.

## Order of Evaluation of Logical Operators

In Python, the order of precedence for logical operators is –

``NOT > AND > OR``

The following is the order in which Python logical operators are evaluated:

• NOT operator has the highest precedence.
• AND operator has medium precedence.
• OR operator has the least precedence.

Sample Expression – not x and y or z
The expression will be transformed to (((not x) and y) or z) due to the fact that NOT has the greatest precedence and will be assessed first, followed by the AND operator, and finally the OR operator because it has the lowest precedence.

Summary
Here’s a summary of the key points about Python logical operators:

• Logical operators are symbols used to combine and manipulate Boolean values in Python.
• The three logical operators in Python are "and", "or", and "not".
• The "and" operator returns True if both operands are True, otherwise, it returns False.
• The "or" operator returns True if at least one operand is True, otherwise, it returns False.
• The "not" operator reverses the logical state of its operand.
• Logical operators can be used with non-Boolean values, which are evaluated as Boolean values based on their truthiness.
• Short-circuit evaluation is a behavior in Python where the second operand of "and" or "or" is not evaluated if the first operand determines the outcome.
• Parentheses can be used to group expressions together and control the order of evaluation for logical operators.
• The order of precedence for logical operators in Python is: NOT > AND > OR, but can be changed using parentheses.
• Logical operators are not case-sensitive in Python.
• Logical operators are commonly used in conditional statements and looping structures in Python to control program flow based on Boolean conditions.

## FAQs Related to Logical Operators

Here are some frequently asked questions on Python logical operators.

Q1 – What are Boolean expressions in Python?
Ans – Boolean expressions are expressions that evaluate to either True or False in Python. They are used in conditional statements, loops, and other control structures to determine the flow of the program.

Q2 – What is the difference between "and" and "or" operators in Python?
Ans – The "and" operator returns True if both expressions given to it are True, while the "or" operator returns True if at least one of the expressions given to it is True.

Q3 – Can logical operators be used with non-Boolean values in Python?
Ans – No, logical operators can only be used with Boolean values in Python. However, non-Boolean values can be evaluated as Boolean values using certain rules. For example, any non-zero numerical value or non-empty sequence is considered True, while zero or an empty sequence is considered False.

Q4 – What is the order of evaluation for logical operators in Python?
Ans – Logical operators are evaluated after comparison operators in Python. However, you can use parentheses to change the order of evaluation and group expressions together.

Q5 – What is the purpose of the "not" operator in Python?
Ans – The "not" operator is used to reverse the Boolean value of an expression in Python. If the expression is True, "not" will make it False, and vice versa.

Q6 – What is short-circuit evaluation in Python?
Ans – Short-circuit evaluation is a behavior in Python where the second operand of the "and" or "or" operator is not evaluated if the first operand determines the outcome. For example, if the first operand of "and" is False, Python does not evaluate the second operand because the overall expression will always be False.

Q7 – Can parentheses be used to change the order of evaluation for logical operators in Python?
Ans – Yes, parentheses can be used to change the order of evaluation for logical operators in Python. Using parentheses allows you to group expressions together and control the order in which they are evaluated.

Q8 – What is the order of evaluation for logical operators in Python?
Ans – The order of evaluation for logical operators in Python is "not" > "and" > "or". However, you can change the order of evaluation using parentheses.

Q9 – How do I combine multiple conditions in Python?
Ans – You can combine multiple conditions in Python using logical operators. For example, you can use the "and" operator to combine two or more conditions that must all be True for the overall expression to be True.

Q10 – Are logical operators case-sensitive in Python?
Ans – No, logical operators are not case-sensitive in Python. You can use "and", "or", and "not" in uppercase or lowercase letters.