Python Variables
Naming, Assignment, and Scope

🎯 The Conceptual Model

In Python, a variable is a name bound to an object. When you write x = 42, Python:

1. Creates an integer object with value 42 somewhere in memory.
2. Binds the name x to that object.
3. Stores the binding in the current scope (usually the local namespace of your script or function).

x = 42
print(x)
print(id(x))
print(type(x))

The id() function returns the object's memory address — a unique integer that identifies which object x refers to. Two names referring to the same object will have the same id().

🔁 Reassignment Rebinds, Not Mutates

When you reassign a variable, Python doesn't modify the original object — it binds the name to a new object. The old object may still exist if other names refer to it.

a = 10
b = a
print("a:", a, "b:", b)

a = 20
print("a:", a, "b:", b)
print("Same object?", a is b)

Output:

a: 10 b: 10
a: 20 b: 10
Same object? False

When a = 20 runs, Python creates a new integer object with value 20 and binds a to it. The name b still refers to the original 10 object. Both objects coexist in memory — 10 because b still references it, 20 because a now does.

📋 Variables in Python vs Other Languages

🎯 Basic Assignment

An assignment statement uses the = operator. The left side is the name; the right side is an expression that evaluates to a value.

x = 42
name = "Alice"
is_active = True
pi = 3.14159
empty = None

result = 10 + 20 * 3

user = {"name": "Bob", "age": 25}

print(x, name, is_active, pi, empty)
print(result)

The right side is evaluated first — fully, to a single value — and then the assignment happens. So x = x + 1 works because x + 1 is computed using the old value of x, and only after that does x get rebound to the result.

➕ Augmented Assignment

Python provides shorthand operators that combine arithmetic with assignment: +=, -=, *=, /=, //=, %=, **=. These are equivalent to the long form but more concise.

counter = 0
counter += 1
counter += 1
counter += 1
print(counter)

total = 100
total -= 25
total *= 2
total //= 5
print(total)

message = "Hello"
message += ", World!"
print(message)

🚫 Assignment Is Not Equality

A common beginner mistake is confusing = (assignment) with == (equality comparison). They are completely different operators.

if x = 5:
    print("x is five")

if x == 5:
    print("x is five")

🔗 Chained Assignment

You can assign the same value to multiple names in a single statement:

a = b = c = 0
print(a, b, c)

x = y = [1, 2, 3]
x.append(4)
print(y)

Chained assignment with mutable objects is dangerous — all three names point to the same object. Modifying through one name affects the others. This is often a subtle bug.

🔀 Tuple Unpacking

Python evaluates the right side as a tuple, then matches each element to a name on the left:

x, y, z = 1, 2, 3
print(x, y, z)

name, age, city = "Alice", 30, "Manila"
print(name, age, city)

If the number of names doesn't match the number of values, Python raises a ValueError:

# ValueError: too many values to unpack
# a, b = 1, 2, 3

# ValueError: not enough values to unpack
# a, b, c = 1, 2

⭐ Starred Assignment

A single name can be prefixed with * to absorb all "extra" values into a list. This is called extended unpacking and is useful when you know the first item or two but not the rest.

first, *middle, last = [1, 2, 3, 4, 5]
print("First:", first)
print("Middle:", middle)
print("Last:", last)

head, *tail = ["a", "b", "c", "d"]
print(head, tail)

🔄 Swapping Variables Without a Temp

Because Python evaluates the right side first, you can swap two variables without a temporary:

a = 10
b = 20
a, b = b, a
print(a, b)

Compare to the C-style approach, which needs a temp variable:

temp = a
a = b
b = temp

Python's version is shorter, safer, and more readable — no risk of accidentally overwriting a value before it's been used.

🎯 Unpacking Function Return Values

When a function returns a tuple, you can unpack it directly into names:

def min_max(numbers):
    return min(numbers), max(numbers)

low, high = min_max([3, 1, 4, 1, 5, 9, 2, 6])
print(f"Low: {low}, High: {high}")

values = min_max([1, 2, 3])
print(values)

✅ Rules the Interpreter Enforces

These are hard requirements — violating any of them raises a SyntaxError or NameError at runtime:

• ✓Must begin with a letter (a–z, A–Z) or underscore (_)
• ✓Can contain letters, digits, and underscores after the first character
• ✓Cannot be a reserved keyword (class, def, if, for, etc.)
• ✓Case-sensitive — name, Name, and NAME are three different variables
• ✓Cannot contain spaces, hyphens, or most punctuation

# Valid names:
name = "Alice"
_user_id = 42
MAX_SIZE = 100
count2 = 5
myLongVariableName = True

# Invalid — will raise SyntaxError:
# 2fast = 10
# first-name = "Bob"
# class = "Physics"
# my var = 5

💡 Conventions Python Expects (PEP 8)

These aren't enforced by the interpreter, but they're followed universally in professional Python code. Following them makes your code instantly readable to any other Python developer.

🎯 What Makes a Good Variable Name

Beyond the rules, good names have a few qualities:

• ✓Descriptive, not abbreviated. user_account_balance is clearer than uab or bal.
• ✓Pronounceable. If you can't say it out loud, you'll struggle to talk about the code with others.
• ✓Not too long. the_total_quantity_of_items_in_the_shopping_cart is excessive — cart_total is better.
• ✓No type suffixes. user_list or name_str are un-Pythonic — let the value speak for itself.
• ✓Not shadowing built-ins. Never name a variable list, dict, type, id, or input — it breaks the built-in function.

active_users = get_active_users()
max_retry_count = 3
is_authenticated = check_auth()

au = get_active_users()
mrc = 3
flag = check_auth()

⚠️ Never Shadow Built-ins

Python has 35+ built-in functions and constants available by default. Naming a variable after one of them "shadows" the built-in, making it unavailable in the current scope — and leading to confusing bugs.

list = [1, 2, 3]
print(list(x))  # TypeError: 'list' object is not callable

my_list = [1, 2, 3]
print(list(my_list))

🧭 The Four Scopes

When Python encounters a name, it searches these scopes in order: L → E → G → B. The first match wins.

x = "global"

def outer():
    x = "enclosing"

    def inner():
        x = "local"
        print(x)

    inner()
    print(x)

outer()
print(x)

Output:

local
enclosing
global

Each function defines a new local scope. The inner function's x shadows the enclosing function's, which shadows the global. Reading the name at different points in the program gives different results.

🌐 Global Statement

By default, assignment inside a function creates a local variable — it doesn't touch the global. To reassign a global variable from inside a function, use the global keyword.

counter = 0

def increment_bad():
    counter = counter + 1  # UnboundLocalError

def increment_good():
    global counter
    counter += 1

increment_good()
print(counter)

🏠 nonlocal Statement

For nested functions, nonlocal rebinds a name in the nearest enclosing scope — useful for closures and counters.

def make_counter():
    count = 0

    def increment():
        nonlocal count
        count += 1
        return count

    return increment

counter = make_counter()
print(counter())
print(counter())
print(counter())

Each call to increment() modifies the count in the enclosing make_counter scope. The nonlocal keyword tells Python "this name is not local to increment; look in the enclosing scope."

🔍 Inspecting Scope — locals() and globals()

You can inspect the current scope's namespaces at any time:

x = "global_x"
y = 42

def demo():
    local_var = "local"
    print("Locals:", locals())
    print("Globals count:", len(globals()))

demo()

🎯 Every Value Is an Object

In Python, everything is an object: integers, strings, functions, classes, modules, and even None. Every object has:

• ✓An identity — a unique integer, retrievable with id(obj), never changes during the object's lifetime
• ✓A type — retrievable with type(obj), never changes
• ✓A value — mutable objects can change; immutable objects cannot

x = 42
print(id(x))
print(type(x))
print(x)

name = "Alice"
print(id(name))
print(type(name))
print(name)

🆔 Understanding id() and Identity

id() returns the memory address of an object (in CPython). Two variables referring to the same object will have the same id():

a = [1, 2, 3]
b = a
c = [1, 2, 3]

print(a is b)
print(a is c)
print(a == c)

print(id(a) == id(b))
print(id(a) == id(c))

a and b refer to the same object — same id, is returns True. c is a distinct object with the same value — different id, is returns False, but == returns True.

⚖️ is vs == — The Critical Distinction

if value is None:
    pass

if a == b:
    pass

if value == None:
    pass

if a is b:
    pass  # rarely what you want

🔒 Mutable vs Immutable Objects

Python objects fall into two camps:

• ✓Immutable: int, float, str, bool, tuple, frozenset, bytes, None — cannot be changed after creation
• ✓Mutable: list, dict, set, bytearray, custom classes — can be modified in place

# Immutable — reassignment creates a new object
s = "hello"
s2 = s
s += " world"
print(s, s2)  # s2 is unchanged

# Mutable — in-place mutation affects all references
nums = [1, 2, 3]
nums2 = nums
nums.append(4)
print(nums, nums2)  # both are [1, 2, 3, 4]

📋 Copying — copy() vs deepcopy()

For nested mutable structures, a shallow copy doesn't protect you:

import copy

original = [[1, 2], [3, 4]]
shallow = copy.copy(original)
deep = copy.deepcopy(original)

original[0][0] = 99
print("Shallow:", shallow)
print("Deep:", deep)

Both shallow and original share the same inner lists, so changing one changes both. deepcopy recursively copies every nested object — the truly independent copy.

📌 UPPER_CASE by Convention

Python doesn't have a const keyword. Instead, the community follows a naming convention: a variable whose name is entirely uppercase (UPPER_SNAKE_CASE) is treated as a constant — meaning "don't reassign this."

MAX_RETRIES = 3
DEFAULT_TIMEOUT = 30
API_BASE_URL = "https://api.example.com"
PI = 3.141592653589793

print(MAX_RETRIES)
print(API_BASE_URL)

🔐 Enforcing Constants with Enums or Frozen Dataclasses

If you truly need immutability, Python has options:

from enum import Enum

class Status(Enum):
    PENDING = "pending"
    ACTIVE = "active"
    COMPLETE = "complete"

print(Status.PENDING.value)
# Status.PENDING = "other"  # AttributeError: cannot reassign

from dataclasses import dataclass

@dataclass(frozen=True)
class Config:
    host: str = "localhost"
    port: int = 8080

config = Config()
# config.port = 9000  # FrozenInstanceError

📍 Where to Put Constants

Two common patterns:

1. At the top of a module — best when the constants belong to a single file.
2. In a dedicated constants.py — best when shared across many modules in a project.

# constants.py
DATABASE_URL = "postgresql://localhost/mydb"
MAX_LOGIN_ATTEMPTS = 5
SESSION_TIMEOUT_SECONDS = 3600

# other_module.py
from constants import MAX_LOGIN_ATTEMPTS

if attempts >= MAX_LOGIN_ATTEMPTS:
    lock_account()