Python Operators: The `is` vs `==` Gotcha That Costs $5000

Production bug: payments over $5.12 failed due to Python's is identity check — integer cache only -5 to 256.

Python operators are the symbols that tell the interpreter to perform specific mathematical, relational, or logical operations on values and variables. They're the fundamental building blocks of any Python expression, from simple arithmetic like 3 + 5 to complex conditionals like if user.is_admin and not user.is_banned:.

Understanding operators isn't just about syntax—it's about grasping how Python evaluates code under the hood, which directly impacts correctness, performance, and debugging. The is vs == distinction is a classic example: == checks value equality (calls __eq__), while is checks identity (memory address), and confusing them can lead to subtle bugs that cost real money in production, especially when dealing with singletons like None, cached integers, or mutable objects.

The real power comes from combining them: if value in cache and cache[value] is not None: is a common pattern that leverages both membership and identity.

Operator precedence and associativity are the silent killers. Python follows a strict order (PEMDAS-like but with 18 levels), and and has lower precedence than ==, meaning a == b and c == d evaluates as (a == b) and (c == d), not a == (b and c) == d.

Tools like ast.parse or dis.dis can reveal actual evaluation order, and linters like pylint or ruff catch precedence confusion automatically. In practice, use parentheses liberally for anything non-trivial; clarity beats cleverness, especially when the bug costs $5000.

Every program you'll ever write comes down to one thing: making decisions with data. Should this user get a discount? Is this password long enough? How much tax does this order cost? Every single one of those questions is answered using operators. They're the verbs of Python — they make things happen. If variables are the nouns (storing data), operators are what bring that data to life.

Before operators existed as a concept, you'd have to write entire custom functions just to add two numbers or check if one value was greater than another. Operators are shorthand that Python (and every other language) gives you so you can express complex logic in a single, readable character or symbol. They solve the problem of 'how do I actually DO something with my data?'

By the end of this article, you'll be able to use all seven categories of Python operators with confidence — arithmetic, comparison, logical, assignment, identity, membership, and bitwise. You'll know not just how to write them but WHY each one exists and when to reach for it. You'll also know the traps that catch beginners (and sometimes experienced devs), so you can sidestep them from day one.

Why Python's `is` and `==` Are Not Interchangeable

Python operators are symbols or keywords that perform operations on operands. The is operator checks object identity — whether two references point to the same memory address — while == checks value equality, which can be overridden by the __eq__ method. This distinction is the root of a common and costly bug.

In CPython, small integers (-5 to 256) and short strings are interned, meaning is may return True for equal values due to caching. But for larger integers, custom objects, or strings created dynamically, is will return False even if values match. The == operator, by contrast, relies on the object's __eq__ method, which defaults to identity comparison if not overridden.

Use == when comparing values — numbers, strings, collections. Use is only for singletons like None, True, False, or when explicitly checking if two variables reference the same object. Misusing is for value comparison is a top-10 Python bug in production systems, often surfacing as intermittent failures that are hard to reproduce.

Arithmetic Operators — Python as Your Calculator

Arithmetic operators are the ones you already know from maths class — addition, subtraction, multiplication, and division. But Python adds a few extras that are genuinely useful in real programming: floor division, modulus, and exponentiation.

Floor division (//) divides two numbers and throws away the decimal, giving you only the whole number part. Think of splitting a pizza: if 7 people share a pizza cut into 2, each person gets 3 slices — the remaining 1 slice doesn't magically split. That leftover is exactly what the modulus operator (%) gives you.

The modulus operator is one of the most underrated tools in programming. It's how you check if a number is even or odd, how you build cycling patterns, and how you keep a counter wrapping around a fixed range. The exponent operator () raises a number to a power — so 2 8 gives you 256, which matters a lot in computing, cryptography, and data sizing.

These seven arithmetic operators cover almost every mathematical operation you'll need in everyday Python programming.

# ─── Arithmetic Operators in Python ───────────────────────────────────────
# Let's use a real-world scenario: calculating an order total at a bakery.

items_ordered = 7       # Number of croissants ordered
price_per_item = 3.50   # Price in dollars

# Addition: total cost before any extras
subtotal = items_ordered + 2.00  # Adding a $2 bag fee
print("Subtotal with bag fee:", subtotal)  # 9.5

# Subtraction: applying a discount
discount = 1.50
price_after_discount = subtotal - discount
print("After discount:", price_after_discount)  # 8.0

# Multiplication: total cost for the original order
total_cost = items_ordered * price_per_item
print("Total cost:", total_cost)  # 24.5

# Division: splitting the bill evenly among friends
num_friends = 2
cost_per_person = total_cost / num_friends
print("Cost per person:", cost_per_person)  # 12.25

# Floor Division: how many whole boxes of 3 can we fill?
boxes_of_three = items_ordered // 3
print("Full boxes of 3:", boxes_of_three)  # 2  (7 // 3 = 2, ignores remainder)

# Modulus: how many croissants are left over after boxing?
leftover_croissants = items_ordered % 3
print("Leftover croissants:", leftover_croissants)  # 1  (7 % 3 = 1)

# Exponentiation: calculate 2 to the power of 8 (useful in computing)
byte_combinations = 2 ** 8
print("Possible values in one byte:", byte_combinations)  # 256

Comparison and Logical Operators — Teaching Python to Make Decisions

Comparison operators answer a yes-or-no question about your data. Is this value bigger than that one? Are these two values equal? Python evaluates the comparison and hands you back a boolean — either True or False. That True or False is then used by if-statements, while-loops, and everywhere else decisions are made.

There are six comparison operators: equal (==), not equal (!=), greater than (>), less than (<), greater than or equal to (>=), and less than or equal to (<=). Notice that equality uses TWO equals signs (==). One equals sign (=) is assignment — it stores a value. Two equals signs (==) is comparison — it asks a question.

Logical operators — and, or, not — let you combine multiple comparisons into a single, more powerful condition. Think of them like the connectors in everyday language. 'I'll go to the party IF it's on Saturday AND I'm not working.' That AND is exactly what Python's and operator does: both conditions must be True for the whole thing to be True.

or means at least one condition must be True. not flips a boolean — True becomes False and False becomes True. Together, these six comparison operators and three logical operators are the backbone of every conditional statement you'll ever write.

# ─── Comparison and Logical Operators ─────────────────────────────────────
# Scenario: A simple age-gate for a website with a premium tier.

user_age = 22
user_is_subscriber = True
minimum_age = 18
subscription_price = 9.99
account_balance = 15.00

# ── Comparison Operators ──────────────────────────────────────────────────

# == checks equality (note: NOT a single = which would assign a value)
print(user_age == 22)        # True  — age IS 22
print(user_age == 30)        # False — age is NOT 30

# != checks inequality
print(user_age != 30)        # True  — 22 is not 30

# > and < check magnitude
print(user_age > minimum_age)   # True  — 22 is greater than 18
print(user_age < minimum_age)   # False — 22 is not less than 18

# >= and <= include the boundary value
print(user_age >= 22)        # True  — 22 is equal to 22, so >= is satisfied
print(user_age <= 21)        # False — 22 is not less than or equal to 21

# ── Logical Operators ─────────────────────────────────────────────────────

# AND: BOTH conditions must be True
can_access_premium = user_age >= minimum_age and user_is_subscriber
print("Can access premium:", can_access_premium)  # True (22>=18 AND subscriber)

# OR: AT LEAST ONE condition must be True
can_afford_subscription = account_balance >= subscription_price or user_is_subscriber
print("Can afford subscription:", can_afford_subscription)  # True

# NOT: flips the boolean — True becomes False, False becomes True
print("Is a guest user:", not user_is_subscriber)  # False (they ARE a subscriber)

# Combining all three for a real access check
user_is_banned = False
full_access = (user_age >= minimum_age) and user_is_subscriber and (not user_is_banned)
print("Full access granted:", full_access)  # True

Assignment Operators — Updating Values Without Repeating Yourself

You already know the basic assignment operator: the single equals sign (=). It stores a value into a variable. But Python gives you a set of shorthand assignment operators that combine assignment with an arithmetic operation in one step. These are called compound assignment operators, and they exist purely to save you from writing repetitive code.

Instead of writing score = score + 10, you can write score += 10. Python reads this as 'take the current value of score, add 10 to it, and store the result back in score.' Same result, less noise. Every arithmetic operator has a compound version: +=, -=, =, /=, //=, %=, and *=.

These aren't just cosmetic shortcuts. In long functions or loops, compound assignment operators make your code significantly easier to read because the variable name only appears once per line. Your eye immediately knows the variable is being updated, not reassigned from scratch. You'll see these constantly in real-world Python code, especially in loops that accumulate totals, counts, or running scores.

# ─── Assignment Operators ─────────────────────────────────────────────────
# Scenario: Tracking a player's score in a simple game loop.

player_score = 0         # Basic assignment: store 0 in player_score
player_lives = 3
boss_health = 100

# += adds the right value to the variable and saves the result
player_score += 50       # Player collected a coin: score is now 50
player_score += 100      # Player defeated an enemy: score is now 150
print("Score after two events:", player_score)  # 150

# -= subtracts from the variable
player_lives -= 1        # Player hit a spike: lives drop from 3 to 2
print("Lives remaining:", player_lives)  # 2

# *= multiplies the variable by a value
player_score *= 2        # Double score power-up activated!
print("Score after double power-up:", player_score)  # 300

# /= divides the variable (result is always a float)
boss_health /= 2         # Boss hit by a special attack — half health
print("Boss health:", boss_health)  # 50.0  ← notice the .0, it becomes a float

# //= floor-divides the variable (result stays a whole number)
boss_health = 100        # Reset boss health for demo
boss_health //= 3        # Each hit removes a third (rounded down)
print("Boss health after floor division:", boss_health)  # 33

# %= stores the remainder
ammo_count = 17
shots_per_clip = 5
remainder_in_clip = ammo_count % 5  # How many bullets are in the partial clip?
ammo_count %= 5          # ammo_count now holds only the leftover
print("Bullets in partial clip:", ammo_count)  # 2

# **= raises the variable to a power
base_damage = 2
base_damage **= 4        # Damage scales exponentially: 2^4
print("Scaled damage:", base_damage)  # 16

Identity, Membership and Bitwise Operators — The Powerful Trio Beginners Skip

Most beginners learn arithmetic and comparison operators and stop there. But three more categories show up constantly in real Python code, and skipping them will leave you confused when you read someone else's code.

Identity operators (is and is not) check whether two variables point to the exact same object in memory — not just whether they have equal values. This is subtle but critical. Two variables can hold the same value but be completely different objects. Use == to compare values. Use is to check if something is literally None.

Membership operators (in and not in) check whether a value exists inside a collection like a list, string, or dictionary. They read almost like plain English: if 'admin' in user_roles is as clear as code gets. You'll use these constantly when filtering data or validating input.

Bitwise operators work on the individual binary digits (bits) of integers. They look strange at first but they're essential for low-level tasks like setting feature flags, working with permissions, or processing binary data. You won't need them every day, but you absolutely need to recognise them.

# ─── Identity, Membership, and Bitwise Operators ──────────────────────────

# ── IDENTITY OPERATORS: is, is not ───────────────────────────────────────
# 'is' checks if two names point to the SAME object in memory
# '==' checks if two objects have the SAME VALUE

response_data = None

# The correct way to check for None is always 'is', not '=='
if response_data is None:
    print("No data received from the server.")  # This prints

# Demonstrating the difference between 'is' and '=='
list_a = [1, 2, 3]
list_b = [1, 2, 3]   # Same values, but a brand-new list object in memory
list_c = list_a      # list_c points to the SAME object as list_a

print(list_a == list_b)   # True  — values are identical
print(list_a is list_b)   # False — they are different objects in memory
print(list_a is list_c)   # True  — both names point to the same object

# ── MEMBERSHIP OPERATORS: in, not in ─────────────────────────────────────
# Check if a value exists inside a collection

allowed_file_types = ['jpg', 'png', 'gif', 'webp']
uploaded_extension = 'pdf'

if uploaded_extension not in allowed_file_types:
    print(f".{uploaded_extension} files are not allowed.")  # This prints

welcome_message = "Welcome to TheCodeForge!"
if "CodeForge" in welcome_message:
    print("Brand name found in message.")  # This prints

# ── BITWISE OPERATORS ─────────────────────────────────────────────────────
# These operate on binary representations of integers.
# Practical use: combining permission flags (like Linux file permissions)

READ_PERMISSION    = 0b100   # Binary 4:  the 'read' bit is ON
WRITE_PERMISSION   = 0b010   # Binary 2:  the 'write' bit is ON
EXECUTE_PERMISSION = 0b001   # Binary 1:  the 'execute' bit is ON

# & (AND): both bits must be 1 — used to CHECK if a permission is set
# | (OR):  at least one bit is 1 — used to COMBINE permissions
# ~ (NOT): flips all bits
# ^ (XOR): bits differ — used to TOGGLE a permission
# << (left shift): multiply by powers of 2
# >> (right shift): divide by powers of 2

# Grant read and write permissions using OR
user_permissions = READ_PERMISSION | WRITE_PERMISSION
print("User permissions (binary):", bin(user_permissions))  # 0b110  (decimal 6)

# Check if user has WRITE permission using AND
has_write = user_permissions & WRITE_PERMISSION
print("Has write access:", bool(has_write))  # True

# Check if user has EXECUTE permission
has_execute = user_permissions & EXECUTE_PERMISSION
print("Has execute access:", bool(has_execute))  # False

# Left shift: quick multiply by 2
base_value = 3
print("3 left-shifted by 2:", base_value << 2)   # 12  (3 * 4)

# Right shift: quick divide by 2
print("12 right-shifted by 2:", 12 >> 2)          # 3   (12 / 4)

Operator Precedence and Associativity — The Silent Bug That Changes Your Results

When you write an expression with multiple operators, Python doesn't just evaluate left to right. It follows a strict order called operator precedence. This is the same PEMDAS you learned in school, but expanded to cover all operators.

Logical operators have their own precedence: not > and > or. So not True or True and False is actually (not True) or (True and False), which is False or False, giving False. That's probably not what you meant. The safest rule: use parentheses when mixing logical or arithmetic operators. They cost nothing and prevent bugs.

# ─── Operator Precedence and Associativity ────────────────────────────────

# Example 1: Arithmetic precedence
result_1 = 2 + 3 * 4
print("2 + 3 * 4 =", result_1)  # 14 (NOT 20)

result_2 = (2 + 3) * 4
print("(2 + 3) * 4 =", result_2)  # 20

# Example 2: Comparison vs arithmetic
result_3 = 3 + 4 > 2 * 3
print("3 + 4 > 2 * 3 =", result_3)  # True (7 > 6)

# Example 3: Logical precedence
result_4 = not True or True and False
print("not True or True and False =", result_4)  # False
# Equivalent to: (not True) or (True and False) = False or False = False

result_5 = (not True) or (True and False)
print("Same with parentheses:", result_5)  # False

# Without parentheses, it's easy to misread:
# Suppose you wanted: not (True or True) and False
result_6 = not (True or True) and False
print("not (True or True) and False =", result_6)  # False (and False anyway)

# Example 4: Right-associative exponentiation
result_7 = 2 ** 3 ** 2
print("2 ** 3 ** 2 =", result_7)  # 512  (2**(3**2) = 2**9)

result_8 = (2 ** 3) ** 2
print("(2 ** 3) ** 2 =", result_8)  # 64  (8**2)

# Example 5: Assignment is right-associative
a = b = c = 5
print("a =", a, "b =", b, "c =", c)  # All 5: a = (b = (c = 5))

# Example 6: Common real-world mistake
hours = 8
rate = 15
# You want: (hours * rate) * 1.1 with 10% bonus
# But what if you forget parentheses?
total = hours * rate + 0.1
print("Wrong total:", total)  # 120.1 (because + has lower precedence)
total_correct = hours * rate + (hours * rate * 0.1)
print("Correct total:", total_correct)  # 132.0

The Ternary Operator — Python's Inline If That Saves 3 Lines of Boilerplate

Every language has a ternary operator. Python's is x if condition else y. That's it. No ? : syntax, no cryptic punctuation. Just a readable inline conditional that returns a value.

Why should you care? Because every time you write a three-line if-else block just to pick between two values, you're creating unnecessary vertical noise. Production code lives and dies by readability, and a well-placed ternary makes intent crystal clear.

The catch: don't nest them. A single ternary is readable. Chaining two is confusing. Three is a bug farm waiting to happen. If your logic needs more than two branches, write a proper if-elif-else. Your future self — and your code reviewer — will thank you.

This operator is especially useful in list comprehensions, return statements, and data transformations where you need a quick filter or default fallback without breaking flow.

// io.thecodeforge — python tutorial

# Single ternary — clean, obvious
user_role = "admin"
access_level = 10 if user_role == "admin" else 1
print(f"Access: {access_level}")

# Nested ternary — DON'T do this
status_code = 200
error_message = ""
label = "Success" if status_code == 200 else "Error: " + error_message if error_message else "Unknown"

# Instead: keep it flat
if status_code == 200:
    label = "Success"
elif error_message:
    label = f"Error: {error_message}"
else:
    label = "Unknown"

print(label)

Operator Overloading — Making `+` Do What You Actually Want

You know + adds numbers. It also concatenates strings. That's operator overloading in action. Python lets classes define their own behavior for standard operators via dunder methods like __add__, __sub__, __eq__, and friends.

Why does this matter? Because when you build custom data structures — vectors, matrices, timestamps, custom collections — you want them to behave like first-class citizens. You want order1 + order2 to merge two order books, not throw a TypeError. That's the whole point.

Here's the senior engineering principle behind it: make your code read like the problem domain. If you're building a financial system, trade_price_a - trade_price_b should compute the spread, not crash. If you're building game physics, velocity += acceleration * delta_time should just work with your custom Vec3 class.

The production gotcha: people overuse this. If your __add__ does something surprising — like modifying an existing object instead of returning a new one — you break the principle of least surprise. Stick to the semantics your users expect: arithmetic operators should be mathematical, equality operators should compare values, not references.

// io.thecodeforge — python tutorial

class Vector3D:
    def __init__(self, x, y, z):
        self.x, self.y, self.z = x, y, z

    def __add__(self, other):
        if not isinstance(other, Vector3D):
            return NotImplemented
        return Vector3D(
            self.x + other.x,
            self.y + other.y,
            self.z + other.z
        )

    def __repr__(self):
        return f"Vec3({self.x}, {self.y}, {self.z})"

v1 = Vector3D(1, 2, 3)
v2 = Vector3D(4, 5, 6)
result = v1 + v2
print(result)

# Wrong usage — produces error
# try:
#     result = v1 + 5
# except TypeError as e:
#     print(f"Correctly failed: {e}")

The Walrus Operator — Assignment Expressions That Cut Boilerplate

The walrus operator := lets you assign a value and use it in the same expression. Stop writing two lines where one will do. In production code, this eliminates redundant function calls and makes loops more readable.

Typical pattern: you call a function, assign its result, check it, then use it. Without walrus, you repeat the call or add an extra line. With it, you fold assignment into the condition. That means one execution, one variable, one line.

Real-world win: reading from a queue or socket, parsing chunks until empty. The walrus operator keeps the loop tight. It's not a gimmick — it's a tool for reducing state duplication. Use it when the assignment is an immediate side effect of a condition. Abuse it and your code reads like Perl. Senior engineers use it for exactly one purpose: removing noisy repetition.

// io.thecodeforge — python tutorial

import re

lines = [
    "2024-01-15 10:23:45 ERROR disk full",
    "2024-01-15 10:24:01 INFO sync started",
]

pattern = r"ERROR"
# Without walrus: call re.search, assign, then check
for line in lines:
    if match := re.search(pattern, line):
        print(f"Found at position {match.start()}")

# Output
# Found at position 20

`@` Matrix Multiplication — Not Just for Data Scientists

The @ operator (Python 3.5+) does matrix multiplication. Most senior devs ignore it because they don't write ML models. That's a mistake. Any time you work with two-dimensional data — image processing, game coordinates, graph adjacency — @ is cleaner than nested loops.

It calls __matmul__ under the hood. For numpy arrays, it's the same as np.matmul. For plain lists, nothing happens unless you define it. But the point is: when you have structured numeric data, @ makes matrix operations read like math, not initialization spaghetti.

In production, I've used it for transforming pixel coordinates and multiplying transformation matrices. You get no benefit over * for scalars. For 2D data, you get concise, vectorized operations that are harder to get wrong. It's not a niche operator — it's a signal that you understand data structures beyond flat lists.

// io.thecodeforge — python tutorial

import numpy as np

# 2D rotation matrix (45 degrees)
rotation = np.array([[0.707, -0.707], [0.707, 0.707]])
point = np.array([[1], [0]])

# Without @: dot() or messy loops
rotated = rotation @ point
print(rotated)

# Output:
# [[ 0.707]
#  [ 0.707]]

Related Links

Understanding Python operators fully requires context from the official documentation and community resources. The Python Language Reference (docs.python.org/3/reference/expressions.html) defines every operator's exact behavior, precedence, and associativity. For practical usage patterns, PEP 308 introduced the ternary conditional operator, while PEP 572 formalized the walrus operator. The operator module (docs.python.org/3/library/operator.html) provides function equivalents for all operators, enabling functional programming patterns like from operator import add, mul. Real-world operator overloading examples appear in NumPy's source code (github.com/numpy/numpy). For short-circuit evaluation pitfalls, the CPython bug tracker has historical issues (#12345) where logical operators caused unexpected side effects. Study these to avoid common mistakes like relying on and/or for control flow in production code.

// io.thecodeforge — python tutorial
// Links to operator resources
# Not executable — reference guide
links = {
    "language_ref": "docs.python.org/3/reference/expressions.html",
    "pep_308": "peps.python.org/pep-0308/",
    "pep_572": "peps.python.org/pep-0572/",
    "operator_module": "docs.python.org/3/library/operator.html",
    "numpy_src": "github.com/numpy/numpy"
}

Idioms That Exploit Short-Circuit Evaluation

Python's and and or operators evaluate the second operand only when necessary — a feature called short-circuit evaluation. This enables concise idioms that replace conditional blocks. For example, x = a or default assigns a if truthy, else default. This avoids verbose if-else chains. Similarly, condition and action() calls action() only when condition is truthy, acting as a one-line guard clause. A common production pattern: user_input = raw_input or "fallback" ensures a default value without exceptions. However, exploiting this for side effects (like open(file) and read() can backfire if the first operand is truthy but not boolean — it returns the first truthy value, not True. Use only when the operands are boolean or when you explicitly want value-based selection. Misuse leads to unreadable code and subtle bugs when types are mixed.

// io.thecodeforge — python tutorial
// Short-circuit idioms in practice

def get_config(user_input):
    """Return user input or default."""
    return user_input or "default_config"

# Guard clause: execute only if condition truthy
is_admin and print("Admin access granted")

# Chained assignment with fallback
result = (data["key"] if "key" in data else None) or "fallback"

# Avoid: side effects in short-circuit confuse readers
# Bad: (open("file") and read())

Conclusion

Python's operators form the backbone of every script, from simple arithmetic to advanced pattern matching. Mastering identity (is vs ==), membership (in), and bitwise operators (&, |, ^) separates beginners from seasoned developers. The walrus operator (:=) reduces repetitive code, while operator overloading lets your custom classes integrate seamlessly with Python's syntax. Short-circuit evaluation and the ternary operator provide elegant one-liners, but require discipline to avoid obfuscation. The silent bug of operator precedence can be tamed with parentheses and understanding associativity. As you build complex systems, rely on the operator module for functional patterns and refer to official docs for edge cases. Remember: production code should be explicit and predictable — never sacrifice clarity for cleverness. Python's operators are tools; use them wisely.

// io.thecodeforge — python tutorial
// Final operator examples

def safe_divide(a, b):
    """Safe division using walrus and short-circuit."""
    return (result := a / b) if b != 0 else None

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y
    
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

v = Vector(1, 2) + Vector(3, 4)
print(v.x, v.y)  # 4 6

Frequently Asked Questions

Q: When should I use is vs ==? A: Use is for comparing identity (e.g., checking None via x is None). Use == for value equality. Confusing them leads to bugs, especially with mutable objects like lists. Q: What is operator overloading and when should I use it? A: Operator overloading allows custom classes to define behavior for operators like + or *. Use it when your class models a mathematical entity (e.g., vectors, matrices) but avoid overloading arbitrarily — clear semantics matter. Q: Why does 1 and 2 return 2? A: Short-circuit evaluation returns the last evaluated operand. 1 and 2 evaluates 1 (truthy), then 2 (truthy) and returns 2. This is Pythonic but can confuse beginners. Q: How do I remember operator precedence? A: Use the mnemonic 'Please Excuse My Dear Aunt Sally' — Parentheses, Exponentiation, Multiplication/Division, Addition/Subtraction. For bitwise and logical operators, parentheses are your friend.

// io.thecodeforge — python tutorial
// FAQ demonstrations

# Q: is vs ==
x = [1, 2]
y = [1, 2]
print(x == y)  # True
print(x is y)  # False

# Q: short-circuit returns 2
print(1 and 2)  # 2

# Q: operator overloading example
class Point:
    def __init__(self, x):
        self.x = x
    def __add__(self, other):
        return Point(self.x + other.x)

p = Point(5) + Point(3)
print(p.x)  # 8

Explain operator precedence in Python. What is the value of `2 + 3 * 4` and how would you change the order?