Python Operators

All 7 operator categories — arithmetic, comparison, logical, bitwise, assignment, identity, and membership — with every example run in the notebook.

Overview

Operators are used to perform operations on variables and values. Python has 7 categories of operators:

1. Arithmetic operators
2. Comparison operators
3. Logical operators
4. Bitwise operators
5. Assignment operators
6. Identity operators
7. Membership operators

This note walks through each category with the exact examples run in the notebook.

Key Concepts

• / always returns a float (true division); // returns floor division (integer part only).
• ** is the exponentiation operator.
• and, or, not work on truthy/falsy values, not just True/False.
• Bitwise operators (&, |, ~, >>, <<) work at the binary bit level.
• Python has no ++/-- — always use += 1 / -= 1.
• is/is not → identity (same object in memory); ==/!= → value equality.
• in/not in → membership check inside sequences.

1. Arithmetic Operators

Setup: x = 5, y = 2

x = 5
y = 2

print(x + y)    # 7
print(x - y)    # 3
print(x * y)    # 10
print(x / y)    # 2.5
print(x % y)    # 1
print(x ** y)   # 25
print(x // 2)   # 2

💡 Tip: / vs // — / gives a precise float result, // gives only the whole number part (rounded down, not truncated — matters for negative numbers).

2. Comparison (Relational) Operators

Setup: x = 5, y = 2 (continued from above)

print(x > y)    # True
print(x < y)    # False
print(x >= y)   # True
print(x <= y)   # False
print(x == y)   # False
print(x != y)   # True

⚠️ Don't confuse == with =. = is assignment; == is comparison.

3. Logical Operators

Setup: x = True, y = False

x = True
y = False

print(x or y)   # True
print(x and y)  # False
print(not y)    # True

Important Points:

• or → short-circuits and returns True as soon as one operand is True.
• and → short-circuits and returns False as soon as one operand is False.
• not → simply flips True ↔ False.

4. Bitwise Operators

Setup: x = 2, y = 3 (binary: x = 010, y = 011)

x = 2   # binary: 010
y = 3   # binary: 011

print(x & y)   # 2   → 010 & 011 = 010
print(x | y)   # 3   → 010 | 011 = 011
print(x >> 2)  # 0   → shifts bits right, drops off the end
print(y << 3)  # 24  → 011 << 3 = 011000 (binary) = 24
print(~x)      # -3  → bitwise complement: ~x = -(x+1)

How each works (bit-level):

• & (AND): Compares each bit position; result bit is 1 only if both bits are 1.

    010
  & 011
  -----
    010   → 2

• | (OR): Result bit is 1 if either bit is 1.

    010
  | 011
  -----
    011   → 3

• >> (Right shift): Shifts all bits to the right, dropping bits off the end (equivalent to floor-dividing by 2^n).
• << (Left shift): Shifts all bits to the left, filling with zeros (equivalent to multiplying by 2^n).
• ~ (NOT): Flips every bit; mathematically ~x = -(x + 1).

💡 Tip: Left shift by n ≈ multiply by 2ⁿ; right shift by n ≈ floor-divide by 2ⁿ.

5. Assignment Operators

Basic Assignment

a = 3
print(a)
# Output: 3

Compound Assignment Operators

a += 3        # same as: a = a + 3
print(a)
# Output: 6   (started from a = 3)

a -= 3
a *= 3
a &= 3

💡 Tip: Compound assignment operators make code shorter and slightly more efficient than writing the full expression.

⚠️ No Increment/Decrement Operators in Python

a++
++a

SyntaxError: invalid syntax

• Python does not support a++ or ++a (unlike C/C++/Java).
• ++a doesn't error by itself in isolation (+ treated as unary plus applied twice), but a++ is invalid syntax.
• To increment a value, always use: a += 1

6. Identity Operators (is, is not)

Purpose: Check whether two variables point to the same object in memory — not whether their values are equal.

a = 3
b = 3
print(a is b)
# Output: True

a = "Hello"
b = "Hello"
print(a is b)
# Output: True

a = [1, 2, 3]
b = [1, 2, 3]
print(a is b)
# Output: False

a = "Hello-world"
b = "Hello-world"
print(a is b)
# Output: False

print(a is not b)
# Output: True

7. Membership Operators (in, not in)

Purpose: Check whether a value exists within a sequence (string, list, tuple, etc.)

x = "Delhi"
print("D" in x)
# Output: True

x = "Delhi"
print("D" not in x)
# Output: False

x = [1, 2, 3]
print(5 in x)
# Output: False

Full Operator Summary Table

Important Points

• / → float division; // → floor division. Don't mix them up.
• and/or/not short-circuit — evaluation stops as soon as the result is determined.
• Bitwise operators work on the binary representation of integers.
• +=, -=, *=, &= etc. are shorthand for reassignment — there is no ++/-- in Python.
• is compares identity (memory address); == compares value.
• Small integers & simple strings may be interned by Python → is can misleadingly return True.
• Mutable objects like lists are never the same object even with identical values (unless explicitly assigned, e.g. b = a).
• in/not in work on any iterable: strings, lists, tuples, sets, dicts (checks keys).

Quick Revision

• 7 operator categories: Arithmetic, Comparison, Logical, Bitwise, Assignment, Identity, Membership.
• Arithmetic: + - * / % ** // → / gives float, // gives floor int.
• Comparison: > < >= <= == != → returns True/False.
• Logical: and (both true), or (at least one true), not (inverts).
• Bitwise: & AND, | OR, ~ NOT (-(x+1)), >> right shift (÷2ⁿ), << left shift (×2ⁿ).
• Assignment: +=, -=, *=, &= = shorthand; no ++/-- in Python — use a += 1.
• Identity (is/is not): Same object in memory, not same value. Small ints/simple strings → often interned (True); lists/complex strings → usually False.
• Membership (in/not in): Checks if a value exists inside a string/list/etc.
• Golden rule: Use == for value comparison, is only for identity checks (like is None).