{"title":"Operators","description":"","content":"Operators are the small symbols that make Python actually compute things: adding cart totals, comparing prices, checking whether a product is in stock, combining boolean conditions. This lesson covers every operator you'll use day-to-day, the rules Python follows when several appear in the same expression, and a few sharp edges that trip up beginners.\n\n---\n\n# Arithmetic Operators\n\nThese do the same thing they did in school, with two extras worth knowing about: floor division and exponentiation.\n\n\n| Operator | Name | Example | Result |\n| --- | --- | --- | --- |\n| `+` | Addition | `19.99 + 4.99` | `24.98` |\n| `-` | Subtraction | `100 - 19.99` | `80.01` |\n| `*` | Multiplication | `19.99 * 3` | `59.97` |\n| `/` | True division | `10 / 3` | `3.3333333333333335` |\n| `//` | Floor division | `10 // 3` | `3` |\n| `%` | Modulo (remainder) | `10 % 3` | `1` |\n| `**` | Exponentiation | `2 ** 10` | `1024` |\n\n\nHere they are working on a small cart:\n\n\n```python\nprice = 19.99\nquantity = 3\nshipping = 4.99\n\nsubtotal = price * quantity\ntotal = subtotal + shipping\n\nprint(\"Subtotal:\", subtotal)\nprint(\"Total:\", total)\n```\n\n\nTwo things deserve a closer look: `/` versus `//`, and what `%` actually does.\n\n`/` always returns a `float`, even when the numbers divide evenly. `10 / 2` is `5.0`, not `5`. If you want an integer result, use `//`, which discards the fractional part and rounds toward negative infinity:\n\n\n```python\nprint(10 / 3)\nprint(10 // 3)\nprint(-10 // 3)\n```\n\n\nThat last result surprises people. `-10 // 3` is `-4`, not `-3`, because floor division rounds *down* (toward negative infinity), not toward zero. If you want truncation toward zero, use `int(-10 / 3)` instead, which gives `-3`.\n\n`%` returns the remainder after division. It's useful for splitting items into groups or detecting \"every Nth\" events:\n\n\n```python\norder_count = 17\nitems_per_box = 5\n\nfull_boxes = order_count // items_per_box\nleftover = order_count % items_per_box\n\nprint(\"Full boxes:\", full_boxes)\nprint(\"Items left over:\", leftover)\n```\n\n\n`**` is exponentiation. `2 ** 10` is `1024`, `9 ** 0.5` is `3.0`. It also works with negative exponents to give fractions: `2 ** -1` is `0.5`.\n\n\n> **INFO**\n>\n> **Cost:** `**` with huge integer exponents can produce arbitrarily large results (Python ints have no fixed size). `2 ** 1000` is fine, but `10 ** 1_000_000` will allocate megabytes of memory and take a noticeable moment. Use it deliberately.\n\n\n---\n\n# Comparison Operators\n\nComparison operators return `True` or `False`. You use them everywhere: filtering products by price, checking stock, deciding which orders qualify for free shipping.\n\n\n| Operator | Meaning | Example | Result |\n| --- | --- | --- | --- |\n| `==` | Equal to | `19.99 == 19.99` | `True` |\n| `!=` | Not equal to | `19.99 != 24.99` | `True` |\n| `<` | Less than | `5 < 10` | `True` |\n| `<=` | Less than or equal | `5 <= 5` | `True` |\n| `>` | Greater than | `10 > 5` | `True` |\n| `>=` | Greater than or equal | `10 >= 10` | `True` |\n\n\n\n```python\ncart_total = 75.50\nfree_shipping_threshold = 50\n\nqualifies_for_free_shipping = cart_total >= free_shipping_threshold\nprint(\"Free shipping?\", qualifies_for_free_shipping)\n```\n\n\nA common beginner mistake is using `=` (assignment) when you meant `==` (comparison). Python will refuse to run code like `if cart_total = 50:` and raise a `SyntaxError`, which is helpful. The two symbols do completely different things: `=` puts a value into a name, `==` asks whether two values are equal.\n\nComparisons also work on strings (lexicographic order) and other types, but mixing types you can't compare raises an error:\n\n\n```python\nprint(\"apple\" < \"banana\")\nprint(5 < \"5\")\n```\n\n\nString comparison goes character by character using Unicode code points, so `\"apple\"` comes before `\"banana\"`. Comparing a number to a string makes no sense to Python and raises `TypeError`.\n\n---\n\n# Chained Comparisons\n\nPython has a feature most other languages don't: you can chain comparison operators in a single expression and Python evaluates them mathematically.\n\n\n```python\nprice = 35\n\nis_mid_range = 20 < price < 100\nprint(is_mid_range)\n```\n\n\n`20 < price < 100` reads exactly like math notation and means `20 < price and price < 100`. Python evaluates `price` once and combines both comparisons.\n\nHere's the flow Python actually follows when it sees a chained comparison:\n\n\n```mermaid\nflowchart LR\n A[20 < price < 100]:::cyan --> B[Evaluate price
once]:::orange\n B --> C{20 < price?}:::teal\n C -->|False| D[Return False
skip rest]:::red\n C -->|True| E{price < 100?}:::teal\n E -->|True| F[Return True]:::green\n E -->|False| G[Return False]:::red\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\nThe key insight is that `price` is computed exactly once and then reused for both comparisons. If the first check fails, Python doesn't even bother evaluating the second one, which is the same short-circuit behavior `and` uses everywhere else.\n\nYou can chain as many as you want, and they can mix operators:\n\n\n```python\nrating = 4.5\nprint(0 <= rating <= 5)\nprint(1 < rating < 5 != 0)\n```\n\n\nThe second one means \"1 < rating AND rating < 5 AND 5 != 0\", which is `True` because all three are true.\n\nWithout chaining, you'd write the awkward version:\n\n\n```python\nprice = 35\nis_mid_range = price > 20 and price < 100\n```\n\n\nThat works fine, but the chained form is more readable and slightly faster because `price` is evaluated only once.\n\n\n> **INFO**\n>\n> **Cost:** In `a < f() < b`, Python calls `f()` exactly once. With `a < f() and f() < b`, it calls `f()` twice. If `f()` is expensive, chaining matters.\n\n\n---\n\n# Logical Operators\n\nLogical operators combine boolean values. Python uses words (`and`, `or`, `not`) instead of symbols like `&&` and `||`.\n\n\n| Operator | Meaning | Example | Result |\n| --- | --- | --- | --- |\n| `and` | True if both are true | `True and False` | `False` |\n| `or` | True if either is true | `True or False` | `True` |\n| `not` | Inverts the value | `not True` | `False` |\n\n\nHere's a cart check that combines two conditions:\n\n\n```python\ncart_total = 75\nitems_in_cart = 4\n\nready_to_checkout = cart_total > 0 and items_in_cart > 0\nprint(\"Ready to checkout?\", ready_to_checkout)\n```\n\n\nTwo behaviors are worth pinning down: short-circuit evaluation and the actual value these operators return.\n\n### Short-Circuit Evaluation\n\n`and` and `or` stop evaluating as soon as the answer is known.\n\n- `False and X` is always `False`, so Python never evaluates `X`.\n- `True or X` is always `True`, so Python never evaluates `X`.\n\nThis lets you guard against errors:\n\n\n```python\ndiscount_code = \"\"\n\nis_valid = discount_code != \"\" and discount_code.startswith(\"SAVE\")\nprint(is_valid)\n```\n\n\nIf `discount_code` is empty, the first half is `False` and Python skips the second half entirely. Without short-circuiting, calling `.startswith(\"SAVE\")` on a value you haven't validated could be a bug source.\n\nThis diagram shows how `or` decides whether to evaluate its right operand, and what it actually returns (which is one of the operands, not a plain `True` or `False`):\n\n\n```mermaid\nflowchart LR\n A[Evaluate left operand]:::cyan --> B{Truthy?}:::orange\n B -->|Yes| C[Return left value
skip right]:::green\n B -->|No| D[Evaluate right operand]:::teal\n D --> E[Return right value]:::green\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n```\n\n\n`and` mirrors this exactly, just with the test flipped: it stops on the first falsy operand and returns it, otherwise it returns the right operand. That's why `\"\" or \"Guest\"` returns `\"Guest\"` (left is falsy, so it falls through) and `\"Alex\" and \"alex@example.com\"` returns the email (left is truthy, so `and` keeps going).\n\n### What `and` and `or` Actually Return\n\nHere's a subtle point: `and` and `or` don't return `True` or `False` directly. They return one of the *operands*.\n\n- `a and b` returns `a` if `a` is falsy, otherwise `b`.\n- `a or b` returns `a` if `a` is truthy, otherwise `b`.\n\n\n```python\nprint(0 or 19.99)\nprint(\"\" or \"Guest\")\nprint(\"Alex\" and \"alex@example.com\")\nprint(None and \"anything\")\n```\n\n\n`0 or 19.99` returns `19.99` because `0` is falsy. `\"\" or \"Guest\"` falls back to `\"Guest\"` for the same reason, which is a common idiom for default values. `\"Alex\" and \"alex@example.com\"` returns the second value because the first is truthy and `and` keeps going.\n\nThat's why you often see code like `name = user_name or \"Guest\"` in Python: it uses the actual value when it exists and falls back when it doesn't.\n\n`not` is simpler. It always returns a real `True` or `False`:\n\n\n```python\nprint(not True)\nprint(not \"\")\nprint(not 19.99)\n```\n\n\n`not \"\"` is `True` because the empty string is falsy. `not 19.99` is `False` because any non-zero number is truthy.\n\n---\n\n# Identity vs Equality: `is` vs `==`\n\n`==` asks \"are these values equal?\". `is` asks \"are these the same object in memory?\". They look similar but mean different things.\n\n\n```python\ncart_a = [\"Wireless Mouse\", \"USB Cable\"]\ncart_b = [\"Wireless Mouse\", \"USB Cable\"]\ncart_c = cart_a\n\nprint(cart_a == cart_b)\nprint(cart_a is cart_b)\nprint(cart_a is cart_c)\n```\n\n\n`cart_a` and `cart_b` have equal contents, so `==` is `True`. They're two separate lists in memory though, so `is` is `False`. `cart_c` was assigned from `cart_a`, so both names point to the exact same list, and `is` is `True`.\n\nThe rule of thumb: use `==` for value comparison, and reserve `is` for comparing with `None`, `True`, or `False`:\n\n\n```python\nselected_coupon = None\n\nif selected_coupon is None:\n print(\"No coupon applied\")\n```\n\n\nThe official Python style guide (PEP 8) says to compare with `None` using `is` and `is not`, not `==`. There's only ever one `None` object in a running Python program, so identity is the right test.\n\n`is not` is the negated form. `selected_coupon is not None` means \"the coupon exists\".\n\nA trap that catches everyone eventually: small integers and short strings are often *interned* (reused) by the interpreter, which makes `is` accidentally work for them in some cases and not others:\n\n\n```python\na = 256\nb = 256\nprint(a is b)\n\na = 1000\nb = 1000\nprint(a is b)\n```\n\n\nThis is an implementation detail of CPython. Don't rely on it. Use `==` for values and `is` only for singletons.\n\n---\n\n# Membership Operators: `in` and `not in`\n\n`in` checks whether a value appears in a collection. It works for strings, lists, tuples, sets, dictionaries, and other iterables.\n\n\n```python\ncart = [\"Wireless Mouse\", \"USB Cable\", \"HDMI Cable\"]\n\nprint(\"USB Cable\" in cart)\nprint(\"Webcam\" in cart)\nprint(\"Webcam\" not in cart)\n```\n\n\nFor strings, `in` checks substring containment:\n\n\n```python\nemail = \"alex@example.com\"\nprint(\"@\" in email)\nprint(\".com\" in email)\nprint(\"alex\" in email)\n```\n\n\nFor dictionaries, `in` checks the keys, not the values:\n\n\n```python\nstock = {\"Wireless Mouse\": 12, \"USB Cable\": 30, \"HDMI Cable\": 0}\n\nprint(\"Wireless Mouse\" in stock)\nprint(12 in stock)\n```\n\n\n`12` is a value in the dictionary, but `in` only looks at keys, so it returns `False`. If you actually want to search values, use `12 in stock.values()`.\n\n\n> **INFO**\n>\n> **Cost:** `x in list` is O(n) because Python scans every element. `x in set` and `x in dict` are O(1) on average because both use hash tables. If you're checking membership repeatedly against a large collection, convert it to a `set` first.\n\n\n---\n\n# Bitwise Operators\n\nBitwise operators work on the binary representation of integers. You won't reach for them often in everyday application code, but they show up in low-level work: feature flags, permission bits, color manipulation, hash tricks.\n\n\n| Operator | Name | Example | Result |\n| --- | --- | --- | --- |\n| `&` | AND | `0b1100 & 0b1010` | `0b1000` (`8`) |\n| `\\|` | OR | `0b1100 \\| 0b1010` | `0b1110` (`14`) |\n| `^` | XOR | `0b1100 ^ 0b1010` | `0b0110` (`6`) |\n| `~` | NOT | `~0b1100` | `-13` |\n| `<<` | Left shift | `1 << 4` | `16` |\n| `>>` | Right shift | `16 >> 2` | `4` |\n\n\nA practical case: storing customer notification preferences as flags. Each preference is one bit.\n\n\n```python\nEMAIL = 0b001 # 1\nSMS = 0b010 # 2\nPUSH = 0b100 # 4\n\n# Customer opts in to email and push, not SMS.\npreferences = EMAIL | PUSH\n\nprint(\"Wants email?\", bool(preferences & EMAIL))\nprint(\"Wants SMS?\", bool(preferences & SMS))\nprint(\"Wants push?\", bool(preferences & PUSH))\n```\n\n\n`|` combines flags. `&` checks whether a flag is set. The result of `preferences & EMAIL` is either `0` (false) or the flag's value (truthy), which is why `bool(...)` produces the right answer.\n\n`<<` and `>>` shift bits left and right. Left-shifting by `n` is equivalent to multiplying by `2 ** n`, right-shifting divides by `2 ** n` (floor):\n\n\n```python\nprint(1 << 4)\nprint(16 >> 2)\nprint(7 >> 1)\n```\n\n\n`~` flips every bit. For a Python integer, the result is `-(x + 1)` because of how negative numbers are represented in two's complement. `~5` is `-6`, `~0` is `-1`.\n\nThese operators only work on integers. Using them on floats raises `TypeError`. If you don't need bit-level work, you can comfortably skip them for now.\n\n---\n\n# Assignment and Augmented Assignment\n\nYou already know `=`: it binds a value to a name. The augmented assignment operators combine an arithmetic or bitwise operator with assignment.\n\n\n| Operator | Equivalent to | Example |\n| --- | --- | --- |\n| `+=` | `x = x + y` | `total += price` |\n| `-=` | `x = x - y` | `stock -= 1` |\n| `*=` | `x = x * y` | `price *= 1.1` |\n| `/=` | `x = x / y` | `share /= 4` |\n| `//=` | `x = x // y` | `groups //= 5` |\n| `%=` | `x = x % y` | `index %= 10` |\n| `**=` | `x = x ** y` | `value **= 2` |\n| `&=`, `\\|=`, `^=`, `<<=`, `>>=` | Bitwise variants | `flags \\|= ADMIN` |\n\n\nBuilding a cart total step by step:\n\n\n```python\ncart_total = 0\n\ncart_total += 19.99\ncart_total += 4.99\ncart_total += 14.99\n\nprint(\"Cart total:\", cart_total)\n```\n\n\nFor numbers and strings (which are immutable), `x += y` and `x = x + y` produce the same result. For mutable types like lists, there's a subtle difference: `+=` modifies the existing list in place, while `x = x + y` creates a new list.\n\n\n```python\ncart_a = [\"Wireless Mouse\"]\ncart_b = cart_a\n\ncart_a += [\"USB Cable\"]\nprint(\"cart_a:\", cart_a)\nprint(\"cart_b:\", cart_b)\n```\n\n\nBoth names see the new item because `+=` on a list mutates the original list, and `cart_b` points to the same one. Compare with this version:\n\n\n```python\ncart_a = [\"Wireless Mouse\"]\ncart_b = cart_a\n\ncart_a = cart_a + [\"USB Cable\"]\nprint(\"cart_a:\", cart_a)\nprint(\"cart_b:\", cart_b)\n```\n\n\n`cart_a + [\"USB Cable\"]` builds a new list and rebinds `cart_a` to it. `cart_b` still points to the original, so it doesn't change. This difference matters a lot once you start passing lists into functions.\n\n\n> **INFO**\n>\n> **Cost:** Building a string with `+=` in a loop is O(n^2) because strings are immutable, so each `+=` creates a brand new string and copies the old contents over. Use `\"\".join(parts)` or an f-string for that pattern.\n\n\n---\n\n# Operator Precedence\n\nWhen an expression mixes operators, Python evaluates them in a specific order. Higher precedence binds tighter, meaning that operator runs first.\n\n\n| Precedence | Operators | Notes |\n| --- | --- | --- |\n| Highest | `**` | Right-to-left associative |\n| | `+x`, `-x`, `~x` | Unary plus, minus, bitwise NOT |\n| | `*`, `/`, `//`, `%` | Multiplicative |\n| | `+`, `-` | Additive |\n| | `<<`, `>>` | Bitwise shifts |\n| | `&` | Bitwise AND |\n| | `^` | Bitwise XOR |\n| | `\\|` | Bitwise OR |\n| | `==`, `!=`, `<`, `<=`, `>`, `>=`, `is`, `is not`, `in`, `not in` | All comparison and membership operators |\n| | `not` | Logical NOT |\n| | `and` | Logical AND |\n| Lowest | `or` | Logical OR |\n\n\nThe full table in the official docs has a few more rows for things you'll meet later (lambda, conditional expressions), but the above covers everything in this lesson.\n\nTwo quick examples:\n\n\n```python\nprint(2 + 3 * 4)\nprint((2 + 3) * 4)\n```\n\n\nIn `2 + 3 * 4`, the multiplication runs first (higher precedence), so it's `2 + 12`. Parentheses force the addition first.\n\nMixing arithmetic, comparison, and logical operators in one line:\n\n\n```python\nprice = 30\nstock = 5\n\neligible = price > 20 and stock > 0\nprint(eligible)\n```\n\n\nComparison operators bind tighter than `and`, so Python evaluates `price > 20` (True) and `stock > 0` (True) first, then combines them with `and`. You don't need parentheses, but adding them never hurts readability:\n\n\n```python\neligible = (price > 20) and (stock > 0)\n```\n\n\nOne detail that confuses people: `**` is right-associative.\n\n\n```python\nprint(2 ** 3 ** 2)\nprint((2 ** 3) ** 2)\nprint(2 ** (3 ** 2))\n```\n\n\n`2 ** 3 ** 2` means `2 ** (3 ** 2)`, which is `2 ** 9 = 512`, not `(2 ** 3) ** 2 = 64`. If you're nesting exponentiation, use parentheses to be explicit.\n\nWhen you're unsure, parentheses are free. They cost nothing at runtime and make intent obvious.\n\n---\n\n# Summary\n\n- Arithmetic operators: `+ - *` work as expected. `/` always returns a float, `//` floors toward negative infinity, `%` gives the remainder, and `**` is exponentiation (right-associative).\n- Comparison operators (`< <= > >= == !=`) return booleans and can be chained: `0 < x < 100` is equivalent to `0 < x and x < 100`, with `x` evaluated only once.\n- `and` and `or` short-circuit and return one of their operands, not always a boolean. `name or \"Guest\"` is a common default-value idiom.\n- Use `==` for value equality and reserve `is` for `None`, `True`, and `False`.\n- `in` checks membership: O(n) on lists and tuples, O(1) on sets and dicts. For dictionaries, it checks keys.\n- Bitwise operators (`& | ^ ~ << >>`) work only on integers. They show up in flags, permissions, and low-level work.\n- Augmented assignments (`+= -= *= //= **=`) mutate mutable types in place but rebind for immutable types. The difference matters when other names share the same object.\n- When in doubt about precedence, add parentheses. They cost nothing and make intent clear.\n\nNow that you can compute, compare, and combine values, the next lesson, _Input & Output_, covers how to read data from the user with `input()` and how to control what `print()` produces.","pageType":"python"}

Operators

Get Premium