Skip to main content

Python Logical and Bitwise Operators: Complete Guide

Logical operators in Python (and, or, not) combine boolean expressions to control program flow, while bitwise operators (&, |, ^, ~, <<, >>) manipulate individual bits in integers for low-level operations. Understanding both categories and their differences is essential for writing efficient Python code that properly handles conditional logic and binary data.

Key Takeaways​

  • Logical operators (and, or, not) work on boolean values and control program flow
  • Short-circuit evaluation stops evaluating as soon as the result is determined, improving efficiency
  • Bitwise operators work directly on binary representations of integers for low-level manipulation
  • Never confuse logical operators (and, or) with bitwise operators (&, |)
  • Use logical operators for conditionals; use bitwise operators for binary/bit manipulation tasks

How Do Logical Operators Work in Python?​

Logical operators are used to combine and modify boolean expressions. Python provides three primary logical operators: and, or, and not. The and operator returns True only if both operands are True; or returns True if at least one operand is True; and not reverses a boolean value. These operators are fundamental to building complex conditional statements.

Using the and Operator​

The and operator returns True if both operands are true:

print(True and True)   # Output: True
print(True and False)  # Output: False
print(False and False) # Output: False

# Practical example: checking multiple conditions
age = 25
has_license = True
can_drive = age >= 18 and has_license
print(can_drive)  # Output: True

Using the or Operator​

The or operator returns True if at least one operand is true:

print(True or False)  # Output: True
print(False or False) # Output: False
print(True or True)   # Output: True

# Practical example: checking alternative conditions
is_weekend = True
is_holiday = False
can_relax = is_weekend or is_holiday
print(can_relax)  # Output: True

Using the not Operator​

The not operator reverses the boolean value:

print(not True)   # Output: False
print(not False)  # Output: True

# Practical example: negating a condition
is_raining = False
should_go_outside = not is_raining
print(should_go_outside)  # Output: True

What Is Short-Circuit Evaluation?​

Short-circuit evaluation is Python's optimization strategy where the second operand of a logical operator is only evaluated if the first operand is not sufficient to determine the result. This improves performance by avoiding unnecessary computations and is a key feature of Python's logical operators.

Short-Circuit with and​

When using and, if the first operand is False, the entire expression must be False, so Python skips evaluating the second operand:

def check_positive(x):
    print(f"Checking if {x} is positive")
    return x > 0

# The second function call is NOT executed because the first is False
result = (5 > 10) and check_positive(5)
print(result)  # Output: False (check_positive is never called)

# The second function IS executed because the first is True
result = (5 < 10) and check_positive(5)
print(result)  # Output: True (check_positive is called and prints)

Short-Circuit with or​

When using or, if the first operand is True, the entire expression must be True, so Python skips the second operand:

def check_negative(x):
    print(f"Checking if {x} is negative")
    return x < 0

# The second function call is NOT executed because the first is True
result = (5 > 0) or check_negative(5)
print(result)  # Output: True (check_negative is never called)

# The second function IS executed because the first is False
result = (5 < 0) or check_negative(5)
print(result)  # Output: False (check_negative is called and prints)

What Are Bitwise Operators and How Do They Work?​

Bitwise operators work directly on the binary representations of integers, treating numbers as sequences of bits. These operators are used for low-level programming tasks such as setting flags, toggling bits, and performing efficient mathematical operations. Python supports six primary bitwise operators: & (AND), | (OR), ^ (XOR), ~ (NOT), << (left shift), and >> (right shift).

OperatorNameDescriptionExample
&Bitwise ANDSets each bit to 1 if both bits are 15 & 3 = 1 (binary: 101 & 011 = 001)
|Bitwise ORSets each bit to 1 if one of two bits is 15 | 3 = 7 (binary: 101 | 011 = 111)
^Bitwise XORSets each bit to 1 if only one of two bits is 15 ^ 3 = 6 (binary: 101 ^ 011 = 110)
~Bitwise NOTInverts all the bits~5 = -6 (two's complement)
<<Left ShiftShifts bits left by pushing zeros in from the right5 << 1 = 10 (binary: 101 << 1 = 1010)
>>Right ShiftShifts bits right by pushing copies of the sign bit in from the left5 >> 1 = 2 (binary: 101 >> 1 = 10)

Practical Bitwise Examples​

# Bitwise AND: common use for checking flags
a = 5      # binary: 0101
b = 3      # binary: 0011
print(a & b)  # Output: 1 (binary: 0001)

# Bitwise OR: combining flags
a = 5      # binary: 0101
b = 3      # binary: 0011
print(a | b)  # Output: 7 (binary: 0111)

# Bitwise XOR: finding differences
a = 5      # binary: 0101
b = 3      # binary: 0011
print(a ^ b)  # Output: 6 (binary: 0110)

# Left shift: multiply by 2
a = 5
print(a << 1)  # Output: 10 (5 * 2)

# Right shift: divide by 2
a = 5
print(a >> 1)  # Output: 2 (5 // 2)

How Do Logical Operators Differ from Bitwise Operators?​

Logical and bitwise operators serve different purposes and operate on different data types. Logical operators work on boolean values and are used for conditional logic and control flow, while bitwise operators work on integer representations and are used for binary manipulation. Confusing the two is a common source of bugs in Python programs.

Logical Operators vs. Bitwise Operators​

AspectLogicalBitwise
Data typeWorks on booleans (True, False)Works on integers (binary digits)
PurposeControls program flow (conditionals)Manipulates individual bits
Operatorsand, or, not&, |, ^, ~, <<, >>
Typical useif statements, combining conditionsFlag checking, bit manipulation, optimization
Exampleage > 18 and has_licenseflags & 0x01 (check if bit 0 is set)

Common Mistake: Using Bitwise When You Mean Logical​

# WRONG: using bitwise & instead of logical and
if x > 5 & y < 10:  # This will produce incorrect results
    pass

# CORRECT: using logical and
if x > 5 and y < 10:
    pass

# Another mistake
value = (10 and 20)  # Returns 20 (last truthy value), not 1
result = (10 & 20)   # Returns 0 (bitwise operation)

Frequently Asked Questions​

What is the difference between and and & in Python?​

The and operator is a logical operator that returns the last evaluated value (not necessarily a boolean), works on boolean context, and supports short-circuit evaluation. The & operator is a bitwise operator that performs binary AND on integer bits and always evaluates both operands. Use and for conditionals; use & for bit manipulation.

Why should I care about short-circuit evaluation?​

Short-circuit evaluation improves performance by avoiding unnecessary computations and can prevent errors. For example, if user is not None and user.name == "Alice" safely checks the user exists before accessing its name attribute. Without short-circuit evaluation, the second condition would cause an error if user were None.

When should I use bitwise operators instead of arithmetic?​

Bitwise operations are faster than arithmetic for certain tasks. Left shift (<<) is 2-3 times faster than multiplication; right shift (>>) is faster than division. Use bitwise for performance-critical code, flag checking in systems programming, or network packet manipulation. For most application code, readable arithmetic is preferable.

Can I use bitwise operators on floats or strings?​

No. Bitwise operators only work on integers in Python. Attempting to use them on floats or strings raises a TypeError. If you need bit manipulation on other data types, convert to integers first using int().

What is the ~ operator and why does ~5 equal -6?​

The ~ operator inverts all bits using two's complement representation. In Python, integers use two's complement, so ~5 (binary 0101) becomes -6 because two's complement inverts all bits and adds 1 to represent negative numbers. The formula is ~x = -(x + 1).

Challenge Exercise​

Write a Python script that takes a number as input and checks if it is both positive and even. Use logical operators to combine the conditions:

number = int(input("Enter a number: "))
is_positive = number > 0
is_even = number % 2 == 0

if is_positive and is_even:
    print(f"{number} is positive and even.")
elif is_positive:
    print(f"{number} is positive but odd.")
else:
    print(f"{number} is not positive.")

Further Reading​