Bitwise Operators

Intermediate ~20 min read

Bitwise operators work directly on the binary representation of numbers, manipulating individual bits. While they might seem low-level, they're essential for permission systems, flags, cryptography, and performance optimizations!

Understanding Binary Numbers

Before diving into bitwise operators, let's understand how numbers are represented in binary. Each digit (bit) can be 0 or 1, and each position represents a power of 2.

Output

Click Run to execute your code

Key Point: Python prefixes binary numbers with 0b. Use bin() to convert decimal to binary, and int('1010', 2) to convert binary strings to decimal.

The Six Bitwise Operators

Python has six bitwise operators that work on the binary representation of integers.

Operator	Name	Description	Example
`&`	AND	1 if BOTH bits are 1	`5 & 3 = 1`
`\|`	OR	1 if AT LEAST ONE bit is 1	`5 \| 3 = 7`
`^`	XOR	1 if bits are DIFFERENT	`5 ^ 3 = 6`
`~`	NOT	Inverts all bits	`~5 = -6`
`<<`	Left Shift	Shifts bits left (multiply by 2^n)	`5 << 1 = 10`
`>>`	Right Shift	Shifts bits right (divide by 2^n)	`5 >> 1 = 2`

# Basic Bitwise Operators

a = 12  # Binary: 1100
b = 10  # Binary: 1010

# Show binary representations
print("=== Binary Representations ===")
print(f"a = {a:2d}  →  binary: {bin(a):>6s}  →  {a:04b}")
print(f"b = {b:2d}  →  binary: {bin(b):>6s}  →  {b:04b}")
print()

# Bitwise AND (&) - 1 only if BOTH bits are 1
print("=== Bitwise AND (&) ===")
print(f"    {a:04b}  (a = {a})")
print(f"  & {b:04b}  (b = {b})")
print(f"  ------")
print(f"    {a & b:04b}  (result = {a & b})")
print()

# Bitwise OR (|) - 1 if AT LEAST ONE bit is 1
print("=== Bitwise OR (|) ===")
print(f"    {a:04b}  (a = {a})")
print(f"  | {b:04b}  (b = {b})")
print(f"  ------")
print(f"    {a | b:04b}  (result = {a | b})")
print()

# Bitwise XOR (^) - 1 if bits are DIFFERENT
print("=== Bitwise XOR (^) ===")
print(f"    {a:04b}  (a = {a})")
print(f"  ^ {b:04b}  (b = {b})")
print(f"  ------")
print(f"    {a ^ b:04b}  (result = {a ^ b})")
print()

# Bitwise NOT (~) - Inverts ALL bits
print("=== Bitwise NOT (~) ===")
print(f"~{a} = {~a}")
print("(Note: Python uses two's complement for negative numbers)")

Output

Click Run to execute your code

Visual Tip: Line up the binary digits vertically when working with bitwise operations. Compare each column independently: AND needs both 1s, OR needs at least one 1, XOR needs exactly one 1.

Bit Shifting

Shift operators move all bits left or right by a specified number of positions. This is equivalent to multiplying or dividing by powers of 2!

# Bit Shifting Operators

# Left shift (<<) - multiply by 2^n
print("=== Left Shift (<<) ===")
x = 5  # Binary: 00000101
print(f"x = {x} ({x:08b})")
print()
print(f"x << 1 = {x << 1:3d} ({x << 1:08b})  # x * 2")
print(f"x << 2 = {x << 2:3d} ({x << 2:08b})  # x * 4")
print(f"x << 3 = {x << 3:3d} ({x << 3:08b})  # x * 8")
print(f"x << 4 = {x << 4:3d} ({x << 4:08b})  # x * 16")

print()

# Right shift (>>) - divide by 2^n (floor)
print("=== Right Shift (>>) ===")
y = 100  # Binary: 01100100
print(f"y = {y} ({y:08b})")
print()
print(f"y >> 1 = {y >> 1:3d} ({y >> 1:08b})  # y // 2")
print(f"y >> 2 = {y >> 2:3d} ({y >> 2:08b})  # y // 4")
print(f"y >> 3 = {y >> 3:3d} ({y >> 3:08b})  # y // 8")
print(f"y >> 4 = {y >> 4:3d} ({y >> 4:08b})  # y // 16")

print()

# Fast multiplication and division
print("=== Fast Math with Shifts ===")
n = 7
print(f"n = {n}")
print(f"n * 2  = {n * 2}   using shift: n << 1 = {n << 1}")
print(f"n * 4  = {n * 4}   using shift: n << 2 = {n << 2}")
print(f"n * 8  = {n * 8}   using shift: n << 3 = {n << 3}")

m = 64
print(f"\nm = {m}")
print(f"m // 2  = {m // 2}   using shift: m >> 1 = {m >> 1}")
print(f"m // 4  = {m // 4}   using shift: m >> 2 = {m >> 2}")
print(f"m // 8  = {m // 8}   using shift: m >> 3 = {m >> 3}")

Output

Click Run to execute your code

Caution: Right shifting a negative number in Python preserves the sign (arithmetic shift). Also, shifting by negative amounts or extremely large values can cause unexpected results. Always validate your shift amounts!

Practical Applications

Bitwise operators are commonly used for permission systems, flags, efficient math, and clever algorithms.

# Practical Bitwise Applications

# 1. Permission Flags (like Unix file permissions)
print("=== Permission Flags ===")
READ = 0b100     # 4
WRITE = 0b010    # 2
EXECUTE = 0b001  # 1

# Grant permissions with OR
permissions = READ | WRITE  # rwx = 110 = 6
print(f"READ | WRITE = {permissions} ({permissions:03b})")

# Check permission with AND
has_read = permissions & READ
has_execute = permissions & EXECUTE
print(f"Has READ? {bool(has_read)}")
print(f"Has EXECUTE? {bool(has_execute)}")

# Revoke permission with AND + NOT
permissions = permissions & ~WRITE  # Remove WRITE
print(f"After revoking WRITE: {permissions} ({permissions:03b})")

# Toggle permission with XOR
permissions = permissions ^ EXECUTE  # Toggle EXECUTE
print(f"After toggling EXECUTE: {permissions} ({permissions:03b})")

print()

# 2. Checking if a number is even or odd
print("=== Even/Odd Check ===")
for n in [4, 7, 12, 15]:
    is_odd = n & 1  # Last bit is 1 for odd numbers
    print(f"{n} is {'odd' if is_odd else 'even'} (binary: {n:04b})")

print()

# 3. Swapping values without temp variable
print("=== XOR Swap ===")
a, b = 10, 25
print(f"Before: a = {a}, b = {b}")
a = a ^ b
b = a ^ b
a = a ^ b
print(f"After:  a = {a}, b = {b}")

print()

# 4. Finding unique element (XOR trick)
print("=== Find Unique Element ===")
numbers = [2, 3, 5, 3, 2]  # 5 appears once
result = 0
for num in numbers:
    result ^= num
print(f"List: {numbers}")
print(f"Unique element: {result}")

Output

Click Run to execute your code

Common Uses:

n & 1 - Check if odd (faster than n % 2)
n << 1 - Multiply by 2 (faster than n * 2)
flags | FLAG - Set a flag
flags & ~FLAG - Clear a flag
flags ^ FLAG - Toggle a flag

Common Mistakes

1. Confusing & with and, | with or

# Wrong - these are different!
if a & b:  # Bitwise AND (compares bits)
if a and b:  # Logical AND (checks truthiness)

# Examples:
a, b = 2, 4
print(a & b)   # 0 (no common bits)
print(a and b) # 4 (both truthy, returns last)

2. Forgetting operator precedence

# Wrong - comparison has higher precedence!
if x & 1 == 1:  # Parsed as: x & (1 == 1) → x & True → x & 1
    pass

# Correct - use parentheses
if (x & 1) == 1:
    pass

3. Unexpected NOT (~) results

# Surprise! NOT doesn't give what you might expect
x = 5
print(~x)  # -6, not what you might expect!

# This is because Python uses two's complement
# ~x = -(x + 1) for all integers

4. Using ^ for exponentiation

# Wrong - ^ is XOR, not power!
result = 2 ^ 3  # 1 (XOR), not 8!

# Correct - use ** for exponentiation
result = 2 ** 3  # 8

Exercise: Permission System

Task: Implement a permission system using bitwise operators.

Requirements:

Grant READ and WRITE permissions using OR (|)
Check if user has WRITE permission using AND (&)
Revoke WRITE permission using AND (&) and NOT (~)
Toggle EXECUTE permission using XOR (^)

# Exercise: Bitwise Flags
# Task: Use bitwise operators to manage permission flags.

READ_PERMISSION = 4   # Binary: 100
WRITE_PERMISSION = 2  # Binary: 010
EXECUTE_PERMISSION = 1 # Binary: 001

user_permissions = 0

# 1. Grant READ and WRITE permissions using bitwise OR (|)
# user_permissions = ...
user_permissions = user_permissions | READ_PERMISSION | WRITE_PERMISSION

print(f"Permissions (Decimal): {user_permissions}")
print(f"Permissions (Binary): {bin(user_permissions)}")

# 2. Check if user has WRITE permission using bitwise AND (&)
# Result should be non-zero if permission exists
has_write = user_permissions & WRITE_PERMISSION
print(f"Has write permission: {has_write > 0}")

# 3. Revoke WRITE permission using bitwise AND (&) and NOT (~)
# Hint: user_permissions & ~WRITE_PERMISSION
user_permissions = user_permissions & ~WRITE_PERMISSION

print(f"Permissions after revoke (Binary): {bin(user_permissions)}")

# 4. Toggle EXECUTE permission using bitwise XOR (^)
user_permissions = user_permissions ^ EXECUTE_PERMISSION

print(f"Permissions after toggle (Binary): {bin(user_permissions)}")

Output

Click Run to execute your code

Show Solution

# Permission flags
READ_PERMISSION = 4     # 100
WRITE_PERMISSION = 2    # 010
EXECUTE_PERMISSION = 1  # 001

user_permissions = 0

# 1. Grant READ and WRITE permissions
user_permissions = user_permissions | READ_PERMISSION | WRITE_PERMISSION
print(f"After granting R+W: {user_permissions:03b}")  # 110

# 2. Check if user has WRITE permission
has_write = bool(user_permissions & WRITE_PERMISSION)
print(f"Has WRITE? {has_write}")  # True

# 3. Revoke WRITE permission
user_permissions = user_permissions & ~WRITE_PERMISSION
print(f"After revoking W: {user_permissions:03b}")  # 100

# 4. Toggle EXECUTE permission
user_permissions = user_permissions ^ EXECUTE_PERMISSION
print(f"After toggling X: {user_permissions:03b}")  # 101

Summary

& (AND) - 1 only if both bits are 1
| (OR) - 1 if at least one bit is 1
^ (XOR) - 1 if bits are different
~ (NOT) - Inverts all bits (gives -(n+1))
<< - Left shift multiplies by 2^n
>> - Right shift divides by 2^n
Use cases: Permission flags, efficient math, finding unique elements

What's Next?

Now that you understand bitwise operations, let's learn about membership operators (in and not in) - simple but powerful operators for checking if values exist in sequences like lists, strings, and dictionaries.

Previous Assignment Operators

Next Membership Operators

Understanding Binary Numbers

The Six Bitwise Operators

Bit Shifting

Practical Applications

Common Mistakes

1. Confusing & with and, | with or

2. Forgetting operator precedence

3. Unexpected NOT (~) results

4. Using ^ for exponentiation

Exercise: Permission System

Summary

What's Next?

Enjoying these tutorials?