Variables and Data Types — Middle Level¶

import sys

x = 42
print(id(x))          # Identity — memory address
print(type(x))        # Type — <class 'int'>
print(x)              # Value — 42
print(sys.getrefcount(x))  # Reference count (usually > 1 due to interning)

# Aliasing with mutable types
a = [1, 2, 3]
b = a              # b is an alias for the same list
b.append(4)
print(a)           # [1, 2, 3, 4] — a is also affected!

# Creating independent copies
import copy
c = a.copy()       # shallow copy
d = copy.deepcopy(a)  # deep copy — nested objects are also copied

c.append(5)
print(a)           # [1, 2, 3, 4] — unaffected

x = "global"           # Global scope

def outer():
    x = "enclosing"    # Enclosing scope

    def inner():
        x = "local"    # Local scope
        print(x)       # "local"

    inner()
    print(x)           # "enclosing"

outer()
print(x)               # "global"

# Using global and nonlocal keywords
counter = 0

def increment():
    global counter
    counter += 1

def make_counter():
    count = 0
    def inc():
        nonlocal count
        count += 1
        return count
    return inc

c = make_counter()
print(c())  # 1
print(c())  # 2

from typing import Optional, Union, Final
from collections.abc import Sequence

# Optional — can be None
def find_user(user_id: int) -> Optional[dict]:
    users = {1: {"name": "Alice"}}
    return users.get(user_id)

# Union — multiple possible types (Python 3.10+ use |)
def process(value: int | str) -> str:
    return str(value)

# Final — constant that should not be reassigned
MAX_CONNECTIONS: Final[int] = 100

# Sequence — accepts list, tuple, or any sequence
def first_element(items: Sequence[int]) -> int:
    return items[0]

# Integer interning: -5 to 256 are cached
a = 256
b = 256
print(a is b)   # True — same cached object

a = 257
b = 257
print(a is b)   # False in interactive mode (may be True in scripts due to peephole optimizer)

# String interning: simple identifier-like strings are interned
s1 = "hello"
s2 = "hello"
print(s1 is s2)  # True — interned

s1 = "hello world"
s2 = "hello world"
print(s1 is s2)  # May be False — not interned (contains space)

# Manual interning
import sys
s1 = sys.intern("hello world")
s2 = sys.intern("hello world")
print(s1 is s2)  # True — forced interning

import sys

class PointRegular:
    def __init__(self, x: float, y: float):
        self.x = x
        self.y = y

class PointSlots:
    __slots__ = ("x", "y")
    def __init__(self, x: float, y: float):
        self.x = x
        self.y = y

r = PointRegular(1.0, 2.0)
s = PointSlots(1.0, 2.0)

print(sys.getsizeof(r.__dict__))  # ~104 bytes for the dict
# PointSlots has no __dict__ — much smaller per instance

from dataclasses import dataclass
from typing import NamedTuple

@dataclass
class User:
    name: str
    age: int
    is_active: bool = True

class Point(NamedTuple):
    x: float
    y: float

u = User("Alice", 30)
p = Point(1.0, 2.0)
print(u)        # User(name='Alice', age=30, is_active=True)
print(p.x)      # 1.0

from dataclasses import dataclass, field
from typing import Final
import os


# Constants
DEFAULT_PORT: Final[int] = 8080
DEFAULT_HOST: Final[str] = "0.0.0.0"


@dataclass(frozen=True)  # frozen=True makes it immutable
class AppConfig:
    """Application configuration with validated types."""
    host: str = DEFAULT_HOST
    port: int = DEFAULT_PORT
    debug: bool = False
    allowed_origins: tuple[str, ...] = ("http://localhost",)

    def __post_init__(self) -> None:
        if not 1 <= self.port <= 65535:
            raise ValueError(f"Port must be 1-65535, got {self.port}")
        if not self.host:
            raise ValueError("Host cannot be empty")

    @classmethod
    def from_env(cls) -> "AppConfig":
        """Create config from environment variables."""
        return cls(
            host=os.getenv("APP_HOST", DEFAULT_HOST),
            port=int(os.getenv("APP_PORT", str(DEFAULT_PORT))),
            debug=os.getenv("APP_DEBUG", "false").lower() == "true",
        )


if __name__ == "__main__":
    config = AppConfig.from_env()
    print(config)
    # AppConfig is immutable — config.port = 9999 raises FrozenInstanceError

import copy


def demonstrate_copy_behavior() -> None:
    """Show the difference between shallow and deep copy."""
    original = {
        "name": "Alice",
        "scores": [95, 87, 92],
        "meta": {"level": 3},
    }

    shallow = copy.copy(original)
    deep = copy.deepcopy(original)

    # Modify nested mutable object
    original["scores"].append(100)
    original["meta"]["level"] = 5

    print(f"Original scores: {original['scores']}")  # [95, 87, 92, 100]
    print(f"Shallow scores:  {shallow['scores']}")    # [95, 87, 92, 100] — shared!
    print(f"Deep scores:     {deep['scores']}")       # [95, 87, 92] — independent

    print(f"Original meta: {original['meta']}")       # {'level': 5}
    print(f"Shallow meta:  {shallow['meta']}")        # {'level': 5} — shared!
    print(f"Deep meta:     {deep['meta']}")           # {'level': 3} — independent


if __name__ == "__main__":
    demonstrate_copy_behavior()

from typing import Callable


def make_multiplier(factor: int) -> Callable[[int], int]:
    """Create a closure that multiplies by a fixed factor."""
    def multiplier(x: int) -> int:
        return x * factor  # 'factor' comes from enclosing scope
    return multiplier


def make_counter(start: int = 0) -> dict[str, Callable]:
    """Create a counter with increment and get operations."""
    count = start

    def increment() -> int:
        nonlocal count
        count += 1
        return count

    def get() -> int:
        return count

    def reset() -> None:
        nonlocal count
        count = start

    return {"increment": increment, "get": get, "reset": reset}


if __name__ == "__main__":
    double = make_multiplier(2)
    triple = make_multiplier(3)
    print(double(5))   # 10
    print(triple(5))   # 15

    counter = make_counter()
    counter["increment"]()
    counter["increment"]()
    print(counter["get"]())   # 2
    counter["reset"]()
    print(counter["get"]())   # 0

# Bad — what do these variables represent?
d: dict = {}
f: bool = True
n: int = 0

# Good — self-documenting with type hints
user_cache: dict[int, str] = {}
is_authenticated: bool = True
retry_count: int = 0

from abc import ABC, abstractmethod


class UserRepository(ABC):
    @abstractmethod
    def find_by_id(self, user_id: int) -> dict | None: ...


class PostgresUserRepository(UserRepository):
    def find_by_id(self, user_id: int) -> dict | None:
        # database query
        return {"id": user_id, "name": "Alice"}


class UserService:
    def __init__(self, repo: UserRepository) -> None:  # Depends on abstraction
        self._repo = repo

    def get_user(self, user_id: int) -> dict:
        user = self._repo.find_by_id(user_id)
        if user is None:
            raise ValueError(f"User {user_id} not found")
        return user

class DataTypeError(Exception):
    """Base exception for data type operations."""
    def __init__(self, message: str, expected_type: type, actual_type: type):
        super().__init__(message)
        self.expected_type = expected_type
        self.actual_type = actual_type


class ValidationError(DataTypeError):
    """Raised when input fails type validation."""
    pass


def validate_age(value: object) -> int:
    if not isinstance(value, int):
        raise ValidationError(
            f"Expected int, got {type(value).__name__}",
            expected_type=int,
            actual_type=type(value),
        )
    if value < 0 or value > 150:
        raise ValueError(f"Age must be 0-150, got {value}")
    return value

import json
import logging
from typing import Any

logger = logging.getLogger(__name__)


def safe_parse_config(raw: str) -> dict[str, Any]:
    """Parse JSON config with type validation."""
    try:
        data = json.loads(raw)
    except json.JSONDecodeError as e:
        logger.error("Invalid JSON: %s", e)
        raise ValueError("Config must be valid JSON") from e

    if not isinstance(data, dict):
        raise TypeError(f"Config must be a dict, got {type(data).__name__}")

    return data

import pickle

# NEVER unpickle untrusted data — arbitrary code execution!
# data = pickle.loads(untrusted_bytes)  # DANGEROUS

# Safe alternative: use JSON for data exchange
import json
data = json.loads('{"name": "Alice", "age": 30}')

# Bad — trusting that input is the right type
def process_payment(amount):
    # If amount is a string like "0" it passes truthiness check but fails math
    if amount:
        charge(amount)

# Good — validate type explicitly
def process_payment(amount: float) -> None:
    if not isinstance(amount, (int, float)):
        raise TypeError(f"amount must be numeric, got {type(amount).__name__}")
    if amount <= 0:
        raise ValueError("amount must be positive")
    charge(amount)

import sys

class UserDict:
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

class UserSlots:
    __slots__ = ("name", "age")
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

# Memory comparison
u1 = UserDict("Alice", 30)
u2 = UserSlots("Alice", 30)
print(f"With __dict__: {sys.getsizeof(u1) + sys.getsizeof(u1.__dict__)} bytes")
print(f"With __slots__: {sys.getsizeof(u2)} bytes")  # Significantly smaller

import sys

# When you have millions of repeated string comparisons
keys = [sys.intern(f"field_{i % 100}") for i in range(1_000_000)]
# Interned strings use `is` comparison (pointer comparison) — O(1) vs O(n) for ==

# Slow — checking type in a loop
def process_items_slow(items: list) -> list[str]:
    result = []
    for item in items:
        if isinstance(item, int):
            result.append(str(item))
        elif isinstance(item, str):
            result.append(item)
    return result

# Fast — use a dispatch dict
def process_items_fast(items: list) -> list[str]:
    handlers = {int: str, str: lambda x: x, float: lambda x: f"{x:.2f}"}
    return [handlers.get(type(item), str)(item) for item in items]

def debug_variable(name: str, value: object) -> None:
    """Print comprehensive debug info about a variable."""
    print(f"Name:     {name}")
    print(f"Value:    {value!r}")
    print(f"Type:     {type(value).__name__}")
    print(f"Id:       {id(value)}")
    print(f"Bool:     {bool(value)}")
    print(f"Mutable:  {hasattr(value, '__setitem__') or hasattr(value, 'append')}")
    print()

# Scenario: "Why did my list change?"
import sys

a = [1, 2, 3]
b = a
print(f"a is b: {a is b}")                    # True — same object
print(f"sys.getrefcount(a): {sys.getrefcount(a)}")  # 3 (a, b, and getrefcount arg)

# Fix: use .copy() or list()
b = a.copy()
print(f"a is b: {a is b}")                    # False — different objects

# Bug: all functions reference the same variable
functions = []
for i in range(5):
    functions.append(lambda: i)

print([f() for f in functions])  # [4, 4, 4, 4, 4] — NOT [0, 1, 2, 3, 4]

# Fix: capture the value with a default argument
functions = []
for i in range(5):
    functions.append(lambda i=i: i)

print([f() for f in functions])  # [0, 1, 2, 3, 4]

# Bug: list is shared across all calls
def add_item(item: str, items: list[str] = []) -> list[str]:
    items.append(item)
    return items

print(add_item("a"))  # ['a']
print(add_item("b"))  # ['a', 'b'] — BUG!

# Fix: use None as default
def add_item(item: str, items: list[str] | None = None) -> list[str]:
    if items is None:
        items = []
    items.append(item)
    return items

# Never compare floats with ==
total = 0.0
for _ in range(10):
    total += 0.1
print(total == 1.0)  # False!

# Fix: use math.isclose or decimal
import math
print(math.isclose(total, 1.0))  # True

# Bad — using is for value comparison
a = 1000
b = 1000
if a is b:  # May be False! 'is' checks identity, not value
    print("equal")

# Good — use == for value comparison
if a == b:  # Always True for equal values
    print("equal")

# Bad — polluting global namespace
counter = 0
def increment():
    global counter
    counter += 1

# Good — use closure
def make_counter():
    count = 0
    def increment():
        nonlocal count
        count += 1
        return count
    return increment

# Bad — no idea what types are expected
def process(data, flag):
    ...

# Good — self-documenting
def process(data: list[dict[str, str]], flag: bool = False) -> int:
    ...

x = (1, 2, 3)
try:
    x += (4, 5)       # This WORKS — creates a new tuple
    print(x)           # (1, 2, 3, 4, 5)
except TypeError:
    pass

# But with a tuple containing a mutable element:
t = ([1, 2],)
try:
    t[0] += [3, 4]    # Raises TypeError AND modifies the list!
except TypeError:
    print(t)           # ([1, 2, 3, 4],) — the list WAS modified!

a = "x" * 5     # "xxxxx"
b = "xxxxx"
print(a == b)    # True
print(a is b)    # May be True (interned) or False — implementation detail

# Safe rule: ALWAYS use == for value comparison

a = [1, 2, 3]
b = a
b += [4, 5]
print(a)

a = (1, 2, 3)
b = (1, 2, 3)
print(a is b)

def f(x, items=[]):
    items.append(x)
    return items

print(f(1))
print(f(2))
print(f(3))

x = 256
y = 256
print(x is y)

x = 257
y = 257
print(x is y)

t = ([1, 2],)
try:
    t[0] += [3]
except TypeError as e:
    print(e)
print(t)