Python Operators: A Complete Guide

Operators are the symbols Python uses to perform actions on data — adding numbers, comparing values, combining conditions, and more. If you have written even a single line of Python, you have already used them. This guide covers every operator category in Python with practical examples, a precedence reference, and the mistakes that trip up beginners most often.

Python groups its operators into seven categories. Each category serves a distinct purpose, and understanding when to reach for each one will make your code clearer and your logic tighter. We will work through them in the order you are most likely to encounter them as a beginner.

Arithmetic Operators

Arithmetic operators perform mathematical calculations on numeric values. Python supports the standard four — addition, subtraction, multiplication, and division — plus three that newer programmers sometimes overlook: floor division, modulo, and exponentiation.

Division with / always returns a float in Python 3, even when the result divides evenly. Floor division with // truncates the decimal and returns an integer (or float if either operand is a float). The modulo operator % is one of the most useful operators for beginners — it tells you the remainder after division, and it is the standard way to check whether a number is even or odd.

copy# Division always returns a float in Python 3
print(10 / 2)     # 5.0  — note the decimal

# Floor division truncates toward negative infinity
print(10 // 3)    # 3
print(-10 // 3)   # -4  — rounds DOWN, not toward zero

# Modulo: remainder after division
print(10 % 3)     # 1
print(14 % 2)     # 0  — 14 is even

# Exponentiation
print(2 ** 8)     # 256
print(9 ** 0.5)   # 3.0  — square root via fractional exponent

Comparison Operators

Comparison operators compare two values and return a boolean — either True or False. They are the foundation of every conditional statement you will ever write.

Python also supports chained comparisons, which read naturally and are more concise than writing two separate conditions joined by and.

copyage = 25

# Chained comparison — checks both conditions at once
if 18 <= age < 65:
    print("Working age adult")

# This is equivalent to:
if age >= 18 and age < 65:
    print("Working age adult")

# Strings compare lexicographically (alphabetical order)
print("apple" < "banana")   # True
print("z" > "a")            # True

Logical Operators

Logical operators combine or modify boolean expressions. Python uses the English words and, or, and not rather than symbols, which makes conditions read more like sentences.

copylogged_in = True
has_permission = False

# and — both must be True
print(logged_in and has_permission)   # False

# or — at least one must be True
print(logged_in or has_permission)    # True

# not — inverts the boolean
print(not logged_in)                  # False
print(not has_permission)             # True

A behavior that surprises many beginners: Python's logical operators use short-circuit evaluation. With and, if the left side is False, Python skips the right side entirely — the result cannot be True regardless. With or, if the left side is True, the right side is skipped. This matters when the right side has side effects like a function call.

Python's logical operators also return actual values rather than strictly True or False. The rule: and returns the first falsy value it finds, or the last value if all are truthy. or returns the first truthy value it finds, or the last value if all are falsy. This enables a concise pattern for supplying defaults.

copy# or returning actual values — classic default pattern
username = ""
display_name = username or "Anonymous"
print(display_name)   # "Anonymous"

# and returning actual values
config = {"debug": True}
debug_mode = config and config.get("debug")
print(debug_mode)   # True

Assignment Operators

The basic assignment operator = stores a value in a variable. Augmented assignment operators combine an arithmetic or bitwise operation with assignment in a single step, making code more concise and easier to read when updating a variable in place.

Python 3.8 introduced the walrus operator :=, which assigns a value and returns it in the same expression. It is useful in while loops and list comprehensions where you want to capture an intermediate result without an extra line of code.

copy# Without walrus operator
data = input("Enter something: ")
while len(data) > 0:
    print(f"You entered: {data}")
    data = input("Enter something: ")

# With walrus operator — cleaner loop
while (data := input("Enter something: ")):
    print(f"You entered: {data}")

Bitwise Operators

Bitwise operators work directly on the binary representation of integers. They are less common in everyday scripting but appear frequently in systems programming, cryptography, networking, and any situation where you need to manipulate individual bits efficiently.

copy# 5  in binary: 0101
# 3  in binary: 0011

print(5 & 3)   # 0001 = 1  (both bits must be 1)
print(5 | 3)   # 0111 = 7  (either bit can be 1)
print(5 ^ 3)   # 0110 = 6  (bits differ)

# Left shift multiplies by powers of 2
print(5 << 1)  # 10   (5 * 2)
print(5 << 2)  # 20   (5 * 4)

# Right shift divides by powers of 2 (integer result)
print(20 >> 1) # 10   (20 / 2)
print(20 >> 2) # 5    (20 / 4)

# Practical use: check if a number is odd using bitwise AND
num = 7
print(num & 1)  # 1 = odd  (least significant bit is 1)
num = 8
print(num & 1)  # 0 = even

Identity and Membership Operators

These two categories are often grouped together because they both read like plain English and beginners sometimes confuse them with comparison operators.

Identity Operators: is and is not

Identity operators check whether two variables point to the same object in memory, not just whether their values are equal. This is a meaningful distinction in Python because two variables can hold equal values while referencing different objects.

copya = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)    # True  — same values
print(a is b)    # False — different objects in memory
print(a is c)    # True  — c points to the same object as a

# The correct way to check for None
result = None
print(result is None)      # True  — preferred style
print(result == None)      # True  — works but not recommended

print(result is not None)  # False

Membership Operators: in and not in

Membership operators check whether a value exists inside a sequence — a string, list, tuple, set, or dictionary.

copyfruits = ["apple", "banana", "cherry"]

print("banana" in fruits)      # True
print("mango" not in fruits)   # True

# Works on strings too
message = "Hello, world!"
print("world" in message)      # True

# Checking dictionary keys
user = {"name": "Kandi", "role": "admin"}
print("role" in user)          # True  — checks keys
print("admin" in user)         # False — "admin" is a value, not a key
print("admin" in user.values()) # True

Operator Precedence

When an expression contains multiple operators, Python evaluates them in a defined order — just like the mathematical order of operations you learned in school, extended to cover Python's full operator set. Higher rows in the table below are evaluated first.

copy# Without parentheses — precedence determines the result
print(2 + 3 * 4)       # 14  — multiplication before addition
print(2 ** 3 ** 2)     # 512 — exponentiation is right-associative: 3**2=9, then 2**9

# With parentheses — you control the order
print((2 + 3) * 4)     # 20
print((2 ** 3) ** 2)   # 64

# Mixing comparison and logical operators
x = 5
print(x > 3 and x < 10)      # True  — comparisons evaluate before 'and'
print(not x > 3 or x == 5)   # True  — 'not' before 'or', comparisons first

"Programs must be written for people to read, and only incidentally for machines to execute." — Harold Abelson

When precedence rules make an expression difficult to read, add parentheses anyway — even when they are not strictly required. Parentheses make your intent explicit and save the next reader (including future you) from mentally simulating the evaluation order.

Key Takeaways

1. Division always produces a float: Use // when you need an integer result. Use % to extract the remainder.
2. == checks value equality; is checks object identity: Use is only with None, True, and False. Use == for everything else.
3. Logical operators return values, not just booleans: Short-circuit evaluation and truthy/falsy values enable concise default patterns like name = user_input or "Anonymous".
4. Augmented assignment keeps code readable: x += 1 is cleaner than x = x + 1 and conveys that you are updating an existing variable rather than creating a new one.
5. When in doubt, use parentheses: Precedence rules are well-defined, but explicit grouping makes code easier to read and reduces the chance of subtle bugs when expressions grow complex.

Operators are one of the smallest building blocks in Python, but they sit inside nearly every expression you write. Getting comfortable with how each category behaves — and where the surprising edges are — gives you a solid foundation for everything that comes next.