Python Operators Tutorial With Examples

Every program you write does the same few things with data. It adds numbers, compares two values, checks whether an item is in a list, or decides whether two conditions are both true. Each of these small actions is done by an operator, a symbol such as the plus sign, the equals sign or a word such as and.

An operator tells Python what to do with the values next to it. Those values are called operands. In the expression 20 + 3, the plus sign is the operator, and 20 and 3 are the operands. The whole thing is called an expression, and Python works out its value. You will use operators in the first program you write and in the ten thousandth, so it pays to learn them properly once.

In this tutorial, we go through all seven groups of Python operators: arithmetic, assignment, comparison, logical, identity, membership and bitwise. Every example uses the same two variables, x as 20 and y as 3, and shows the real output from Python 3.13. We then cover operator precedence, which decides what runs first, and the mistakes beginners make most often, such as comparing floats with the equals operator and confusing is with ==. We finish with a quick reference and the complete script.

Types of Operators in Python

Python groups its operators by the job they do. Here are the seven groups, with what each one answers.

For every example below, we start with these two variables:

x = 20
y = 3

Arithmetic Operators in Python

Arithmetic operators do the maths you learned at school. Python has seven of them.

x = 20
y = 3
print(x + y, x - y, x * y)
print(x / y)
print(round(x / y, 2))
print(x % y, x ** y, x // y)

23 17 60
6.666666666666667
6.67
2 8000 6

Two points trip up beginners. First, the division operator always returns a float, even when the numbers divide evenly, so 8 divided by 2 gives 4.0 and not 4. Second, Python does not round on its own, so the division above prints 6.666666666666667. Use the round function when you want fewer decimals.

Floor Division and Modulus With Negative Numbers

Floor division rounds down toward minus infinity, not toward zero. That surprises people when a number is negative.

print(-20 // 3, -20 % 3)

-7 1

The result of minus 20 floor divided by 3 is minus 7, not minus 6, and the remainder is 1. Python keeps the rule that (a // b) * b + (a % b) always gives back a.

Assignment Operators in Python

The plain equals sign stores a value in a variable. The other assignment operators are shortcuts. They do an operation and store the result back in the same variable, so x += 5 means the same as x = x + 5. In the table, every row starts again with x as 20.

x = 20
x += 5
print(x)
x /= 5
print(x)

25
5.0

The bitwise rows give whole numbers, because those operators work on integers. The last six rows make sense after you read the bitwise section further down.

Comparison Operators in Python

Comparison operators compare two values and return True or False. You will use them in every if statement and every loop condition.

x = 20
y = 3
print(x == y, x != y, x > y, x < y, x >= y, x <= y)

False True True False True False

One equals sign stores a value, and two equals signs compare. Mixing them up is a very common first error.

Logical Operators in Python

Logical operators combine conditions. The word and gives True only when both sides are true. The word or gives True when at least one side is true. The word not flips the answer.

x = 20
y = 3
print(x > 10 and y < 5, x > 10 or y > 5, not x > 10)

True True False

and and or Return an Operand, Not Just True or False

With conditions, and and or give True or False. With plain values, they return one of the two values themselves. Python treats 0, empty text, an empty list and None as false, and everything else as true.

x = 20
print(x and 0, x or 0, 0 or "default", 0 and 5)

0 20 default 0

Here, x and 0 gives 0 because x is true, so Python moves to the second value and returns it. And x or 0 gives 20, because x is already true and Python stops there. Python also stops early when the answer is known. That is called short circuit evaluation, and it lets you write safe checks such as len(items) > 0 and items[0] == 5, where the second part never runs if the list is empty.

Identity Operators in Python

Identity operators check whether two names point to the same object in memory. That is different from asking whether two values look equal.

p = [1, 2, 3]
q = p
r = [1, 2, 3]
print(p is q, p is r, p == r, p is not r)

True False True True

The names p and q point to the same list, so p is q is True. The name r is a separate list that holds the same values, so p == r is True, but p is r is False. In short, == asks whether the values are equal, and is asks whether it is the very same object.

The most useful everyday use of is is the check against None:

v = None
print(v is None)

True

Avoid using is to compare numbers or text. Python sometimes reuses small objects, so the answer can change from one case to another. Use == for values.

Membership Operators in Python

Membership operators check whether a value is present inside a collection such as a string, list, tuple, set or dictionary.

print("a" in "apple", "z" not in "apple")
print(3 in [1, 2, 3], 5 in (1, 2), "k" in {"k": 1}, 1 in {"k": 1})

True True
True False True False

For a dictionary, in checks the keys and not the values, which is why 1 in the dictionary gives False. Using in with a plain number on the right raises an error, because a number is not a collection:

try:
    print(3 in 20)
except TypeError as error:
    print("TypeError:", error)

TypeError: argument of type 'int' is not iterable

Bitwise Operators in Python

Bitwise operators work on the individual bits, the ones and zeros, of whole numbers. You will not need them every day, but they appear in permissions, flags, networking, hardware code and interview questions. Here is a worked example using 12 and 10.

a = 12
b = 10
print(format(a, "04b"), format(b, "04b"))

1100 1010

a = 12
b = 10
print(a & b, a | b, a ^ b)
print(~a)
print(a << 2, a >> 2)

8 14 6
-13
48 3

The tilde operator is bitwise NOT, not NOR. For whole numbers, ~a equals minus a minus 1, which is why ~12 gives minus 13. A left shift by 2 multiplies by 4, and a right shift by 2 divides by 4 and drops the remainder.

Operator Precedence in Python

When an expression has more than one operator, Python does not just read left to right. It follows precedence rules, the same idea as BODMAS in maths. Here they are, from highest to lowest.

print(2 + 3 * 4, (2 + 3) * 4)
print(2 ** 3 ** 2, -3 ** 2, (-3) ** 2)
print(10 - 2 - 3, 100 / 10 / 5)
print(True or False and False)

14 20
512 -9 9
5 2.0
True

Look at the second line. The exponent runs right to left, so 2 ** 3 ** 2 is 2 ** 9, which is 512. And -3 ** 2 gives minus 9, because the exponent runs before the minus sign. When in doubt, use brackets. They cost nothing and make the code easy to read.

Chained Comparisons

Python lets you chain comparisons the way you write them in maths. This is cleaner than joining two checks with and.

print(1 < 2 < 3, 1 < 3 < 2)

True False

The first chain asks whether 2 is greater than 1 and also less than 3. Use it for range checks, such as 0 <= marks <= 100.

Common Mistakes With Python Operators

Comparing Floats With ==

Decimal numbers are stored in binary, so some cannot be held exactly. This gives a result that surprises everyone once.

print(0.1 + 0.2 == 0.3, round(0.1 + 0.2, 2) == 0.3)

False True

Round the numbers first, or use the isclose function from the math module.

Mixing Up Division and Floor Division

print(7 / 2, 7 // 2, type(7 / 2).__name__, type(8 / 2).__name__)

3.5 3 float float

Use the division operator for an exact answer, and floor division when you need a whole number, such as the number of full pages or full boxes.

Using is Instead of ==

Use == to compare values. Keep is for None and for cases where you truly want to know whether two names share one object.

Using = Instead of ==

A single equals sign stores a value. Writing if x = 20 gives a SyntaxError. Write if x == 20.

Quick Reference

Complete Script to Run Yourself

Here is the script that produces every output on this page. Copy it into a file, run it with Python 3, and compare the results line by line.

x = 20
y = 3

# Arithmetic
print(x + y, x - y, x * y)
print(x / y)
print(round(x / y, 2))
print(x % y, x ** y, x // y)
print(-20 // 3, -20 % 3)

# Comparison
print(x == y, x != y, x > y, x < y, x >= y, x <= y)

# Logical
print(x > 10 and y < 5, x > 10 or y > 5, not x > 10)
print(x and 0, x or 0, 0 or "default", 0 and 5)

# Assignment
n = 20
n += 5
print(n)
n -= 3
print(n)
n *= 2
print(n)
n /= 4
print(n)
n = 20
n %= 3
print(n)
n = 20
n //= 3
print(n)
n = 20
n **= 2
print(n)
n = 20
n &= 3
print(n)
n = 20
n |= 3
print(n)
n = 20
n ^= 3
print(n)
n = 20
n >>= 2
print(n)
n = 20
n <<= 3
print(n)

# Bitwise
a = 12
b = 10
print(format(a, "04b"), format(b, "04b"))
print(a & b, format(a & b, "04b"))
print(a | b, format(a | b, "04b"))
print(a ^ b, format(a ^ b, "04b"))
print(~a)
print(a << 2, a >> 2)

# Identity
p = [1, 2, 3]
q = p
r = [1, 2, 3]
print(p is q, p is r, p == r, p is not r)
print(id(p) == id(q))
print(None is None)
v = None
print(v is None)

# Membership
print("a" in "apple", "z" not in "apple")
print(3 in [1, 2, 3], 5 in (1, 2), "k" in {"k": 1}, 1 in {"k": 1})
try:
    print(3 in 20)
except TypeError as e:
    print("TypeError:", e)

# Precedence
print(2 + 3 * 4, (2 + 3) * 4, 2 ** 3 ** 2, -3 ** 2, (-3) ** 2)
print(10 - 2 - 3, 100 / 10 / 5)
print(1 < 2 < 3, 1 < 3 < 2)
print(True or False and False)
print(not True == False)

# Pitfalls
print(0.1 + 0.2 == 0.3, round(0.1 + 0.2, 2) == 0.3)
print(7 / 2, 7 // 2, type(7 / 2).__name__, type(8 / 2).__name__)

Operators are small, but they sit inside almost every line you will write. Learn the seven groups, remember that and and or return operands, that the division operator gives a float, and that is is not the same as ==, and you will avoid most beginner bugs. Run the script above, change the numbers, and watch what happens. Then move on to Python conditions and loops, where these operators do the real work.