{"title":"Variables","description":"","content":"A variable in Python is a name that refers to a value. The mental model most beginners pick up first, that a variable is a labeled box holding a value, will lead you wrong in Python. Names point to objects, and assignment rebinds the name. This lesson walks through what `=` actually does, how multiple names can share a single object, and the small set of syntactic patterns you'll use every day.\n\n---\n\n# Names, Not Boxes\n\nWhen you write `price = 19.99`, three things happen, in order:\n\n1. Python evaluates the right-hand side and creates a `float` object with the value `19.99`.\n2. Python looks up the name `price` in the current scope.\n3. Python binds the name `price` to that object.\n\nThe variable isn't a container that stores `19.99`. It's a label attached to the object. If you reassign `price`, the label moves to a different object. The old object stays put until nothing else refers to it, at which point Python's garbage collector reclaims its memory.\n\n\n```python\nprice = 19.99\nprint(price)\n\nprice = 24.99\nprint(price)\n```\n\n\nThe second assignment didn't change the original `19.99` object. It created a new `float` for `24.99` and pointed `price` at it. The old `19.99` is now unreachable and eligible for cleanup.\n\nYou can see this with the built-in `id()` function, which returns a unique integer identifier for an object (in CPython, this is the object's memory address).\n\n\n```python\nprice = 19.99\nprint(id(price))\n\nprice = 24.99\nprint(id(price))\n```\n\n\nDifferent ids confirm these are two distinct objects. The name `price` was rebound, the float wasn't mutated.\n\nHere's the picture in your head:\n\n\n```mermaid\nflowchart LR\n N1[price]:::cyan -.before.-> O1[19.99]:::orange\n N2[price]:::cyan -.after.-> O2[24.99]:::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```\n\n\nThe name moved. The old object didn't change, it just lost its only reference.\n\n---\n\n# Two Names, One Object\n\nA name binding is a one-way arrow from name to object. Nothing stops you from pointing two names at the same object.\n\n\n```python\ncart = [\"apple\", \"bread\", \"milk\"]\nitems = cart\n\nprint(id(cart))\nprint(id(items))\nprint(cart is items)\n```\n\n\nThe ids match. The `is` operator checks whether two names refer to the same object, and it returns `True` here. Now look at what that means in practice.\n\n\n```python\ncart = [\"apple\", \"bread\", \"milk\"]\nitems = cart\nitems.append(\"eggs\")\n\nprint(cart)\nprint(items)\n```\n\n\nYou appended through `items`, but the change shows up under `cart` too. There's only one list. Two names point to it. Mutating it through either name affects both views.\n\nThis trips up everyone at first. For now, hold onto the rule: assignment doesn't copy. It shares.\n\n\n> **INFO**\n>\n> **Cost:** Sharing is free, but it's also a source of subtle bugs when you mutate an object that other code holds a reference to. If you want an independent copy, use `cart.copy()` or `list(cart)`.\n\n\n\n```mermaid\nflowchart LR\n A[cart]:::cyan --> O[List object
apple, bread, milk]:::orange\n B[items]:::cyan --> O\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n```\n\n\nTwo arrows, one object. That's the model.\n\n---\n\n# Rebinding vs Mutating\n\nThese two operations look similar but behave very differently:\n\n\n```python\ncart = [\"apple\", \"bread\"]\nitems = cart\n\ncart = [\"new\", \"list\"]\n\nprint(cart)\nprint(items)\n```\n\n\nReassigning `cart` rebound the name to a brand-new list object. The name `items` still points to the original list, which wasn't touched. Contrast this with the previous example, where calling `items.append(...)` mutated the shared object so both names saw the change.\n\nThe rule of thumb: assignment to a bare name (`cart = ...`) rebinds that name only. Method calls or item assignment that change the object's contents (`cart.append(...)`, `cart[0] = ...`) mutate the object, and every name pointing at it sees the change.\n\n\n| Operation | Effect | Visible through other names? |\n|-----------|--------|------------------------------|\n| `x = something_new` | Rebinds `x` | No, other names still point to the old object |\n| `x.append(item)` | Mutates the object | Yes, all names share the change |\n| `x[0] = item` | Mutates the object | Yes, all names share the change |\n| `x = x + [item]` | Rebinds `x` to a new list | No, this builds a new list and rebinds |\n\n\nThe last row is worth noting. `x = x + [item]` looks like a mutation but isn't. It builds a fresh list by concatenating, then rebinds `x`. Other names keep their old reference.\n\n---\n\n# Multiple Assignment\n\nPython lets you assign to several names at once. The right-hand side is evaluated first, then the values are unpacked into the names on the left.\n\n\n```python\nname, email, age = \"Aisha\", \"aisha@example.com\", 28\nprint(name)\nprint(email)\nprint(age)\n```\n\n\nThis is called **tuple unpacking**, because the right-hand side is a tuple `(\"Aisha\", \"aisha@example.com\", 28)`. The number of names on the left must match the number of values on the right, or Python raises `ValueError`.\n\n\n```python\nname, email = \"Aisha\", \"aisha@example.com\", 28\n```\n\n\nYou can also chain assignments to give several names the same value:\n\n\n```python\nquantity_in_cart = quantity_reserved = stock_taken = 0\nprint(quantity_in_cart, quantity_reserved, stock_taken)\n```\n\n\nAll three names now point to the same `0` object. Since `0` is an immutable integer, this is safe. With a mutable object, chained assignment shares the same object across all names, which is usually not what you want.\n\n\n```python\ncart_a = cart_b = []\ncart_a.append(\"apple\")\nprint(cart_b)\n```\n\n\nBoth names refer to the same list, so appending through `cart_a` shows up in `cart_b`. If you wanted two independent empty carts, write `cart_a, cart_b = [], []` instead.\n\n---\n\n# Swapping Values\n\nThe unpacking pattern gives you a clean way to swap two variables without a temporary. In many languages this requires a third variable; in Python it's one line.\n\n\n```python\nfirst_item = \"Wireless Mouse\"\nsecond_item = \"USB Cable\"\n\nfirst_item, second_item = second_item, first_item\nprint(first_item)\nprint(second_item)\n```\n\n\nThe right-hand side `second_item, first_item` is evaluated to a tuple first, then unpacked into the two names on the left. The swap happens through the tuple, not through some special swap operator.\n\nThis works for any number of variables and for elements of a list. A common use is reordering the top of a wishlist:\n\n\n```python\nwishlist = [\"Bluetooth Speaker\", \"Smart Watch\", \"Headphones\"]\nwishlist[0], wishlist[1] = wishlist[1], wishlist[0]\nprint(wishlist)\n```\n\n\n---\n\n# Augmented Assignment\n\nAugmented assignment combines an operation with a rebind. The form `x += y` is shorthand for \"compute `x + y` and bind the result to `x`.\"\n\n\n```python\ntotal = 0\ntotal += 19.99\ntotal += 24.99\ntotal += 9.99\nprint(round(total, 2))\n```\n\n\nEvery numeric and bitwise operator has an augmented form:\n\n\n| Operator | Equivalent to | Use case |\n|----------|---------------|----------|\n| `+=` | `x = x + y` | Add to running total |\n| `-=` | `x = x - y` | Deduct stock, decrement quantity |\n| `*=` | `x = x * y` | Apply a multiplier |\n| `/=` | `x = x / y` | Divide and rebind |\n| `//=` | `x = x // y` | Integer division |\n| `%=` | `x = x % y` | Modulo |\n| `**=` | `x = x ** y` | Power |\n\n\nFor numbers and strings (which are immutable), augmented assignment always rebinds the name to a new object. For mutable objects like lists, the picture is slightly different.\n\n\n```python\ncart = [\"apple\"]\nitems = cart\ncart += [\"bread\"]\nprint(cart)\nprint(items)\n```\n\n\n`list += other_list` is equivalent to `list.extend(other_list)`. It mutates the existing list in place rather than creating a new one. Both names still point at the same list, and both see the new element. Compare that with regular `+`.\n\n\n```python\ncart = [\"apple\"]\nitems = cart\ncart = cart + [\"bread\"]\nprint(cart)\nprint(items)\n```\n\n\nThe `+` operator builds a new list, and the assignment rebinds only `cart`. The original list, which `items` still points to, is unchanged. So `+=` and `= ... +` are not always interchangeable for mutable types.\n\n---\n\n# Dynamic Typing\n\nPython is **dynamically typed**, which means the type of a value is associated with the value itself, not with the name. You don't declare `int price` or `string name` ahead of time. The same name can hold values of different types at different times.\n\n\n```python\norder_id = 12345\nprint(type(order_id))\n\norder_id = \"ORD-12345\"\nprint(type(order_id))\n\norder_id = None\nprint(type(order_id))\n```\n\n\nThe variable `order_id` was rebound three times, each time to a value of a different type. Python is fine with this. The downside is that you find out about type mismatches at runtime, not while writing the code.\n\n\n```python\nquantity = \"5\"\ntotal = quantity * 2.99\n```\n\n\n`quantity` is a string, not a number, so multiplying by `2.99` fails. Python doesn't auto-convert strings to floats.\n\nThe freedom is nice, the responsibility is yours. Bigger codebases often use optional type hints (`quantity: int = 5`) to document intent and let tools catch type errors before runtime. For now, just know that Python won't complain if you rebind a name to a different type, but the operations you later try on it might.\n\n---\n\n# Identifier Rules\n\nA variable name in Python (also called an **identifier**) follows a few rules:\n\n- Starts with a letter (a-z, A-Z) or underscore (`_`). It cannot start with a digit.\n- The rest can be letters, digits, or underscores. No spaces, no hyphens, no punctuation.\n- Names are case-sensitive: `total`, `Total`, and `TOTAL` are three different names.\n- You can't use a reserved keyword as a name. The full list lives in the `keyword` module.\n\n\n```python\nimport keyword\nprint(keyword.kwlist)\n```\n\n\nTrying to use any of these as a name raises `SyntaxError`:\n\n\n```python\nclass = \"Electronics\"\n```\n\n\nThe fix is to pick a different name, like `category` or `class_name`. By convention, when you need a name that collides with a keyword or built-in (such as `class` or `type`), Python developers add a trailing underscore: `class_`, `type_`. This is documented in the PEP 8 style guide.\n\nA few names that are technically valid but a bad idea:\n\n\n```python\ntype = \"premium\"\nlist = [1, 2, 3]\nprint = \"Order placed\"\n```\n\n\nThese overwrite built-in functions or types inside the current scope. After running them, `list(...)` and `print(...)` no longer behave as expected. Avoid using names that shadow built-ins.\n\n---\n\n# Deleting a Name with `del`\n\nThe `del` statement removes a name binding. After `del`, the name no longer exists in the current scope, and trying to use it raises `NameError`.\n\n\n```python\nprice = 19.99\nprint(price)\n\ndel price\nprint(price)\n```\n\n\n`del` doesn't directly destroy the object, it just removes one reference to it. If other names still point to the same object, it stays alive.\n\n\n```python\ncart = [\"apple\", \"bread\"]\nitems = cart\n\ndel cart\nprint(items)\n```\n\n\nThe list still exists because `items` references it. Only the `cart` name was removed. When the last reference goes away, Python's garbage collector reclaims the memory.\n\n`del` also works on items inside a collection, like `del cart[0]` to remove the first element of a list, or `del scores[\"alice\"]` to remove a key from a dictionary.\n\nIn day-to-day code, you rarely need `del` for plain variables. Names go out of scope on their own when a function returns. The most common use is removing items from a collection or freeing a large object earlier than the function's end.\n\n---\n\n# Common Mistakes\n\nA short tour of the patterns that trip up new Python developers.\n\n**What's wrong with this code?**\n\n\n```python\ntotal = quantity * price\nquantity = 3\nprice = 19.99\n```\n\n\nThe first line runs before `quantity` and `price` are defined. Python evaluates `quantity * price` immediately and raises `NameError` because neither name exists yet. The fix is to assign the inputs first, then compute the result:\n\n\n```python\nquantity = 3\nprice = 19.99\ntotal = quantity * price\n```\n\n\n**What's wrong with this code?**\n\n\n```python\ncustomer_name = \"Aisha\"\nprint(Customer_Name)\n```\n\n\n`Customer_Name` (with capitals) is a different name from `customer_name`. Python raises `NameError: name 'Customer_Name' is not defined`. Names are case-sensitive. Stick to one convention (lowercase with underscores, per PEP 8) and use it everywhere.\n\n**What's wrong with this code?**\n\n\n```python\ncart = [\"apple\", \"bread\"]\nbackup = cart\ncart.clear()\nprint(backup)\n```\n\n\n`backup = cart` did not copy the list. Both names point to the same list object, and `cart.clear()` mutates it in place. The \"backup\" is empty because there's only one list. If you wanted an independent copy: `backup = cart.copy()` or `backup = cart[:]`.\n\n---\n\n# Quiz","pageType":"python"}

Get Premium