Python

username = "alice"
age = 30
is_active = True

price: float = 19.99
items: list[str] = ["apple", "bread"]
user_map: dict[str, int] = {"alice": 1}

x, y, z = 10, 20, 30
first, *rest = [1, 2, 3, 4, 5]
print(first, rest)

score = 95.5
print(type(score))
print(isinstance(score, (int, float)))

result = None
if result is None:
    print("No result yet")

# Common pattern: optional return
def find_user(user_id: int) -> str | None:
    return None

MAX_RETRIES = 3
BASE_URL = "https://api.example.com"
PI = 3.14159

data = 42
print(type(data))
data = "now a string"
print(type(data))

type UserId = int
type Coordinate = tuple[float, float]
type UserMap = dict[UserId, str]

position: Coordinate = (40.71, -74.01)

name = "Alice"
balance = 1234.5
print(f"User: {name}")
print(f"Balance: ${balance:,.2f}")
print(f"{'centered':^20}")

email = "  [email protected]  "
print(email.strip().lower())
print("hello world".title())
print("python".startswith("py"))
print("2026-04-04".replace("-", "/"))

word = "pythonic"
print(word[0:4])
print(word[-4:])
print(word[::2])
print(word[::-1])

query = """
    SELECT name, email
    FROM users
    WHERE active = true
""".strip()
print(query)

path = r"C:\Users\alice\docs"
pattern = r"\d{3}-\d{4}"
print(path)
print(pattern)

text = "caf\u00e9"
encoded = text.encode("utf-8")
print(encoded)
print(encoded.decode("utf-8"))

words = ["Python", "is", "great"]
sentence = " ".join(words)
print(sentence)

csv_row = "alice,30,engineer"
fields = csv_row.split(",")
print(fields)

pin = "4821"
print(pin.isdigit())
print("hello123".isalnum())
print("  ".isspace())
print("api" in "api_key_value")

count = 1_000_000
ratio = 0.618
print(type(count), type(ratio))
print(count + ratio)

print(17 / 5)
print(17 // 5)
print(17 % 5)
print(2 ** 10)

print(abs(-42.5))
print(round(3.14159, 2))
print(round(2.5))
print(round(3.5))

import math
print(math.ceil(4.2))
print(math.floor(4.8))
print(math.sqrt(144))
print(math.log(100, 10))
print(math.pi)

z = 3 + 4j
print(z.real, z.imag)
print(abs(z))

print(int("42"))
print(int(9.99))
print(float("3.14"))
print(int("0xff", 16))

from decimal import Decimal

# Floating point issue
print(0.1 + 0.2)

# Decimal precision
result = Decimal("0.1") + Decimal("0.2")
print(result)

price = 1234567.891
print(f"{price:,.2f}")
print(f"{0.856:.1%}")
print(f"{42:08b}")
print(f"{255:#06x}")

colors = ["red", "green", "blue"]
numbers = list(range(1, 6))
mixed = [1, "two", 3.0, True]
empty = []
print(numbers)

fruits = ["apple", "banana", "cherry", "date"]
print(fruits[0])
print(fruits[-1])
print(fruits[-2])

nums = [10, 20, 30, 40, 50, 60]
print(nums[1:4])
print(nums[::2])
print(nums[::-1])
nums[1:3] = [200, 300]
print(nums)

tasks = ["email"]
tasks.append("report")
tasks.insert(0, "standup")
tasks.extend(["review", "deploy"])
print(tasks)

items = ["a", "b", "c", "d", "e"]
items.remove("c")
print(items)
last = items.pop()
print(last, items)
del items[0]
print(items)

prices = [29.99, 5.50, 12.00, 89.99]
prices.sort()
print(prices)

names = ["Charlie", "alice", "Bob"]
ordered = sorted(names, key=str.lower)
print(ordered)

prices = [10, 25, 50, 75, 100]
affordable = [p for p in prices if p <= 50]
print(affordable)

squares = [n ** 2 for n in range(1, 6)]
print(squares)

coords = [10, 20, 30, 40, 50]
x, y, *remaining = coords
print(x, y, remaining)

first, *_, last = coords
print(first, last)

items = ["pen", "notebook", "eraser"]
print(len(items))
print("pen" in items)

for idx, item in enumerate(items, start=1):
    print(f"{idx}. {item}")

user = {"name": "Alice", "age": 30, "active": True}
from_pairs = dict(host="localhost", port=8080)
print(user)
print(from_pairs)

config = {"debug": False, "port": 3000}
print(config["port"])
config["debug"] = True
config["host"] = "0.0.0.0"
print(config)

settings = {"theme": "dark"}
theme = settings.get("theme", "light")
lang = settings.get("language", "en")
print(theme, lang)

scores = {"alice": 95, "bob": 82, "carol": 91}
print(list(scores.keys()))
print(list(scores.values()))

for name, score in scores.items():
    print(f"{name}: {score}")

words = ["hello", "world", "python"]
lengths = {w: len(w) for w in words}
print(lengths)

original = {"a": 1, "b": 2, "c": 3}
filtered = {k: v for k, v in original.items() if v >= 2}
print(filtered)

defaults = {"color": "blue", "size": "medium"}
overrides = {"size": "large", "bold": True}
final = defaults | overrides
print(final)

from collections import defaultdict

word_count = defaultdict(int)
for word in "the cat sat on the mat".split():
    word_count[word] += 1
print(dict(word_count))

from collections import Counter

letters = Counter("mississippi")
print(letters.most_common(3))

inventory = Counter(apples=5, oranges=3)
inventory.update(apples=2)
print(inventory["apples"])

point = (10, 20)
singleton = (42,)
x, y = point
print(f"x={x}, y={y}")
print(len(singleton))

from collections import namedtuple

Color = namedtuple("Color", ["red", "green", "blue"])
sky = Color(135, 206, 235)
print(sky.red, sky.blue)
print(sky._asdict())

from typing import NamedTuple

class Endpoint(NamedTuple):
    host: str
    port: int = 443

api = Endpoint("api.example.com")
print(api.host, api.port)

tags = {"python", "tutorial", "beginner"}
from_list = set([1, 2, 2, 3, 3, 3])
print(from_list)

empty_set = set()
print(type(empty_set))

frontend = {"alice", "bob", "carol"}
backend = {"bob", "carol", "dave"}

print(frontend | backend)
print(frontend & backend)
print(frontend - backend)
print(frontend ^ backend)

permissions = frozenset(["read", "write"])
print("read" in permissions)

# Can be used as a dictionary key
cache = {permissions: "admin"}
print(cache[frozenset(["read", "write"])])

emails = ["[email protected]", "[email protected]", "[email protected]", "[email protected]"]
unique_lower = {e.lower() for e in emails}
print(unique_lower)

active = {"alice", "bob"}
active.add("carol")
active.discard("bob")
active.discard("nonexistent")
print(active)

score = 85
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
else:
    grade = "F"
print(grade)

age = 20
status = "adult" if age >= 18 else "minor"
print(status)

# Nested (use sparingly)
label = "high" if age > 60 else "mid" if age > 30 else "young"
print(label)

command = {"action": "move", "x": 10, "y": 20}

match command:
    case {"action": "move", "x": x, "y": y}:
        print(f"Moving to ({x}, {y})")
    case {"action": "stop"}:
        print("Stopping")
    case _:
        print("Unknown command")

total = 0
prices = [12.50, 8.99, 24.00]
for price in prices:
    total += price
print(f"Total: ${total:.2f}")

for i in range(3):
    print(f"Attempt {i + 1}")

attempts = 0
max_attempts = 3

while attempts < max_attempts:
    attempts += 1
    print(f"Try {attempts}")

print("Done")

for n in range(1, 20):
    if n % 7 == 0:
        print(f"Found first multiple of 7: {n}")
        break
    if n % 2 == 0:
        continue
    print(f"Odd: {n}")

targets = [2, 4, 6, 8]
for num in targets:
    if num % 5 == 0:
        print(f"Found multiple of 5: {num}")
        break
else:
    print("No multiple of 5 found")

data = [5, 12, 3, 18, 7, 22]
high = [x for x in data if (doubled := x * 2) > 20]
print(high)

import re
text = "Order #12345 confirmed"
if (match := re.search(r"#(\d+)", text)):
    print(f"Order ID: {match.group(1)}")

def greet(name: str, greeting: str = "Hello") -> str:
    """Build a personalized greeting."""
    return f"{greeting}, {name}!"

print(greet("Alice"))
print(greet("Bob", greeting="Hey"))

def log_event(event: str, *tags: str, **metadata: str):
    print(f"Event: {event}")
    print(f"Tags: {tags}")
    print(f"Meta: {metadata}")

log_event("login", "auth", "user", ip="10.0.0.1")

def fetch(url: str, /, *, timeout: int = 30, retries: int = 3):
    print(f"GET {url} (timeout={timeout}, retries={retries})")

fetch("https://api.example.com", timeout=10)
# fetch(url="...")  # TypeError: positional-only

square = lambda n: n ** 2
print(square(5))

users = [{"name": "Carol", "age": 28}, {"name": "Alice", "age": 35}]
users.sort(key=lambda u: u["age"])
print([u["name"] for u in users])

import functools
import time

def timer(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{func.__name__} took {elapsed:.4f}s")
        return result
    return wrapper

@timer
def compute(n):
    return sum(range(n))

compute(1_000_000)

def make_multiplier(factor: int):
    def multiply(n: int) -> int:
        return n * factor
    return multiply

double = make_multiplier(2)
triple = make_multiplier(3)
print(double(10), triple(10))

def countdown(n: int):
    while n > 0:
        yield n
        n -= 1

for tick in countdown(3):
    print(tick)

# Generators are lazy — values produced one at a time
nums = countdown(1_000_000)
print(next(nums))

from collections.abc import Callable

def apply(
    values: list[int],
    transform: Callable[[int], int]
) -> list[int]:
    return [transform(v) for v in values]

result = apply([1, 2, 3], lambda x: x * 10)
print(result)

def factorial(n: int) -> int:
    if n <= 1:
        return 1
    return n * factorial(n - 1)

print(factorial(6))

import sys
print(f"Recursion limit: {sys.getrecursionlimit()}")

class BankAccount:
    def __init__(self, owner: str, balance: float = 0):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount: float) -> None:
        self.balance += amount

acct = BankAccount("Alice", 100)
acct.deposit(50)
print(f"{acct.owner}: ${acct.balance}")

class Vehicle:
    def __init__(self, make: str, year: int):
        self.make = make
        self.year = year

class ElectricCar(Vehicle):
    def __init__(self, make: str, year: int, range_km: int):
        super().__init__(make, year)
        self.range_km = range_km

    def __repr__(self) -> str:
        return f"{self.year} {self.make} ({self.range_km}km range)"

car = ElectricCar("Tesla", 2026, 600)
print(car)

class Temperature:
    def __init__(self, celsius: float):
        self._celsius = celsius

    @property
    def fahrenheit(self) -> float:
        return self._celsius * 9 / 5 + 32

    @property
    def celsius(self) -> float:
        return self._celsius

    @celsius.setter
    def celsius(self, value: float) -> None:
        if value < -273.15:
            raise ValueError("Below absolute zero")
        self._celsius = value

t = Temperature(100)
print(t.fahrenheit)
t.celsius = 0
print(t.fahrenheit)

class DateRecord:
    def __init__(self, year: int, month: int, day: int):
        self.year = year
        self.month = month
        self.day = day

    @classmethod
    def from_string(cls, date_str: str) -> "DateRecord":
        y, m, d = map(int, date_str.split("-"))
        return cls(y, m, d)

    @staticmethod
    def is_valid_year(year: int) -> bool:
        return 1 <= year <= 9999

record = DateRecord.from_string("2026-04-04")
print(record.year, DateRecord.is_valid_year(2026))

from dataclasses import dataclass, field

@dataclass
class Product:
    name: str
    price: float
    tags: list[str] = field(default_factory=list)

    @property
    def display_price(self) -> str:
        return f"${self.price:.2f}"

p = Product("Widget", 9.99, ["sale"])
print(p)
print(p.display_price)

@dataclass(slots=True)
class Point:
    x: float
    y: float

p = Point(1.0, 2.0)
print(p)
# p.z = 3.0  # AttributeError: no __dict__

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self) -> float: ...

class Circle(Shape):
    def __init__(self, radius: float):
        self.radius = radius

    def area(self) -> float:
        return 3.14159 * self.radius ** 2

# shape = Shape()  # TypeError: can't instantiate abstract class
circle = Circle(5)
print(f"Area: {circle.area():.2f}")

from typing import Protocol

class Saveable(Protocol):
    def save(self, path: str) -> None: ...

class Document:
    def save(self, path: str) -> None:
        print(f"Saved to {path}")

def backup(item: Saveable, dest: str) -> None:
    item.save(dest)

backup(Document(), "/tmp/doc.txt")

class Money:
    def __init__(self, amount: float, currency: str = "USD"):
        self.amount = amount
        self.currency = currency

    def __repr__(self) -> str:
        return f"Money({self.amount}, '{self.currency}')"

    def __str__(self) -> str:
        return f"{self.currency} {self.amount:.2f}"

    def __eq__(self, other: object) -> bool:
        if not isinstance(other, Money):
            return NotImplemented
        return self.amount == other.amount and self.currency == other.currency

print(Money(42.50))
print(repr(Money(42.50)))

with open("config.txt", "r", encoding="utf-8") as f:
    content = f.read()
    print(content[:50])

# Read line by line (memory efficient)
with open("data.log") as f:
    for line in f:
        print(line.strip())

lines = ["alice,95", "bob,82", "carol,91"]

with open("scores.csv", "w", encoding="utf-8") as f:
    f.write("name,score\n")
    for line in lines:
        f.write(line + "\n")

# Append mode
with open("scores.csv", "a") as f:
    f.write("dave,88\n")

from pathlib import Path

data_dir = Path("project") / "data"
data_dir.mkdir(parents=True, exist_ok=True)

config = data_dir / "settings.json"
config.write_text('{"debug": true}', encoding="utf-8")
print(config.read_text())
print(config.suffix, config.stem)

import csv

# Writing
with open("users.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["name", "age"])
    writer.writeheader()
    writer.writerow({"name": "Alice", "age": 30})
    writer.writerow({"name": "Bob", "age": 25})

# Reading
with open("users.csv", newline="", encoding="utf-8") as f:
    for row in csv.DictReader(f):
        print(row["name"], row["age"])

import json
from pathlib import Path

config = {"host": "localhost", "port": 8080, "debug": True}

# Write
Path("config.json").write_text(
    json.dumps(config, indent=2), encoding="utf-8"
)

# Read
loaded = json.loads(Path("config.json").read_text())
print(loaded["port"])

# Copy a binary file
with open("image.png", "rb") as src:
    data = src.read()

with open("copy.png", "wb") as dst:
    dst.write(data)

print(f"Copied {len(data)} bytes")

from contextlib import contextmanager

@contextmanager
def temp_directory():
    import tempfile, shutil
    path = tempfile.mkdtemp()
    try:
        yield path
    finally:
        shutil.rmtree(path)

with temp_directory() as tmp:
    print(f"Working in {tmp}")

from pathlib import Path

# All Python files in current directory
for py_file in Path(".").glob("*.py"):
    print(py_file.name)

# Recursive search
all_json = list(Path(".").rglob("*.json"))
print(f"Found {len(all_json)} JSON files")

try:
    value = int("not_a_number")
except ValueError as e:
    print(f"Conversion failed: {e}")

# Multiple exception types
try:
    result = {"a": 1}["b"]
except (KeyError, IndexError) as e:
    print(f"Lookup error: {e}")

def safe_divide(a: float, b: float) -> float | None:
    try:
        result = a / b
    except ZeroDivisionError:
        print("Cannot divide by zero")
        return None
    else:
        print(f"Result: {result}")
        return result
    finally:
        print("Division attempted")

safe_divide(10, 3)
safe_divide(10, 0)

def withdraw(balance: float, amount: float) -> float:
    if amount <= 0:
        raise ValueError(f"Amount must be positive, got {amount}")
    if amount > balance:
        raise RuntimeError("Insufficient funds")
    return balance - amount

try:
    withdraw(100, 200)
except RuntimeError as e:
    print(e)

class PaymentError(Exception):
    def __init__(self, amount: float, reason: str):
        self.amount = amount
        self.reason = reason
        super().__init__(f"Payment of ${amount:.2f} failed: {reason}")

try:
    raise PaymentError(49.99, "card declined")
except PaymentError as e:
    print(e)
    print(f"Amount: ${e.amount}")

def validate(data: dict) -> None:
    errors = []
    if not data.get("name"):
        errors.append(ValueError("name is required"))
    if not data.get("email"):
        errors.append(ValueError("email is required"))
    if errors:
        raise ExceptionGroup("Validation failed", errors)

try:
    validate({})
except* ValueError as eg:
    for err in eg.exceptions:
        print(f"  - {err}")

class DatabaseError(Exception):
    pass

try:
    int("bad")
except ValueError as e:
    raise DatabaseError("Failed to parse DB record") from e

# ValueError - wrong value for the type
# TypeError - wrong type entirely
# KeyError - missing dictionary key
# IndexError - list index out of range
# AttributeError - missing attribute
# FileNotFoundError - file doesn't exist
# PermissionError - insufficient permissions
# StopIteration - iterator exhausted

try:
    open("nonexistent.txt")
except FileNotFoundError:
    print("File not found")

from contextlib import suppress
import os

# Instead of try/except/pass
with suppress(FileNotFoundError):
    os.remove("temp_cache.dat")

print("Cleanup done")

import json
from pathlib import Path
from collections import defaultdict, Counter
import numpy as np  # common alias convention

data = json.dumps({"key": "value"})
print(data)

# my_module.py
def compute_tax(price: float, rate: float = 0.08) -> float:
    return price * rate

if __name__ == "__main__":
    # Only runs when executed directly, not when imported
    result = compute_tax(100)
    print(f"Tax: ${result:.2f}")

# utils.py
__all__ = ["format_price", "validate_email"]

def format_price(amount: float) -> str:
    return f"${amount:,.2f}"

def validate_email(email: str) -> bool:
    return "@" in email

def _internal_helper():  # not exported
    pass

# project/
# ├── __init__.py
# ├── models.py
# └── services/
#     ├── __init__.py
#     └── auth.py

# Inside services/auth.py:
# from ..models import User
# from . import helpers

# Create a virtual environment
# python -m venv .venv

# Activate (macOS/Linux)
# source .venv/bin/activate

# Activate (Windows)
# .venv\Scripts\activate

# Install packages
# pip install requests

# Save dependencies
# pip freeze > requirements.txt

# Deactivate
# deactivate

# myapp/
# ├── __init__.py          # makes it a package
# ├── config.py
# ├── models/
# │   ├── __init__.py
# │   └── user.py
# └── utils/
#     ├── __init__.py
#     └── formatting.py

# In __init__.py, expose public API:
# from .config import Settings
# from .models.user import User

import importlib

# Import module by string name
json_mod = importlib.import_module("json")
result = json_mod.dumps({"dynamic": True})
print(result)

# Reload a module during development
# importlib.reload(my_module)

# Install a package
# pip install requests

# Install specific version
# pip install requests==2.31.0

# Install from requirements file
# pip install -r requirements.txt

# Show installed packages
# pip list

# Show details about a package
# pip show requests

# Transform + filter
temps_f = [32, 68, 95, 104, 50]
warm_c = [(f - 32) * 5 / 9 for f in temps_f if f > 60]
print([round(c, 1) for c in warm_c])

# Nested comprehension (flatten)
matrix = [[1, 2], [3, 4], [5, 6]]
flat = [n for row in matrix for n in row]
print(flat)

# Invert a dictionary
http_codes = {200: "OK", 404: "Not Found", 500: "Server Error"}
code_lookup = {msg: code for code, msg in http_codes.items()}
print(code_lookup["Not Found"])

# From two parallel lists
keys = ["host", "port", "debug"]
vals = ["localhost", 8080, True]
config = {k: v for k, v in zip(keys, vals)}
print(config)

sentence = "the quick brown fox jumps over the lazy dog"
word_lengths = {len(word) for word in sentence.split()}
print(sorted(word_lengths))

# Sum of squares without building a list
total = sum(n ** 2 for n in range(1, 101))
print(total)

# Lazy evaluation
import sys
list_size = sys.getsizeof([x for x in range(10000)])
gen_size = sys.getsizeof(x for x in range(10000))
print(f"List: {list_size} bytes, Generator: {gen_size} bytes")

def flatten(nested):
    for item in nested:
        if isinstance(item, list):
            yield from flatten(item)
        else:
            yield item

data = [1, [2, [3, 4]], [5, 6]]
print(list(flatten(data)))

from itertools import chain, islice, groupby, product

# Chain multiple iterables
all_items = list(chain([1, 2], [3, 4], [5]))
print(all_items)

# Take first N from any iterable
first_three = list(islice(range(1000000), 3))
print(first_three)

# Cartesian product
sizes = ["S", "M"]
colors = ["red", "blue"]
combos = list(product(sizes, colors))
print(combos)

from itertools import groupby

transactions = [
    {"type": "credit", "amount": 100},
    {"type": "credit", "amount": 200},
    {"type": "debit", "amount": 50},
    {"type": "debit", "amount": 75},
]

# Must be sorted by the grouping key first!
for ttype, group in groupby(transactions, key=lambda t: t["type"]):
    amounts = [t["amount"] for t in group]
    print(f"{ttype}: {amounts}")

import math

values = [1, 10, 100, 1000, 10000]
# Compute once, use in both filter and output
result = [
    (v, log_v)
    for v in values
    if (log_v := math.log10(v)) >= 2
]
print(result)

from datetime import datetime, timedelta

now = datetime.now()
print(now.strftime("%Y-%m-%d %H:%M"))

deadline = now + timedelta(days=7, hours=3)
print(f"Due: {deadline:%B %d, %Y}")

parsed = datetime.strptime("2026-04-04", "%Y-%m-%d")
print(parsed.date())

from collections import deque, ChainMap

# deque: efficient append/pop from both ends
buffer = deque(maxlen=3)
for n in range(5):
    buffer.append(n)
print(list(buffer))

# ChainMap: layered dict lookup
defaults = {"color": "blue", "size": 10}
overrides = {"color": "red"}
config = ChainMap(overrides, defaults)
print(config["color"], config["size"])

from functools import lru_cache, partial

@lru_cache(maxsize=128)
def fibonacci(n: int) -> int:
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(30))
print(fibonacci.cache_info())

# partial: pre-fill arguments
def power(base, exp):
    return base ** exp

square = partial(power, exp=2)
print(square(7))

import re

text = "Contact: [email protected] or [email protected]"
emails = re.findall(r"[\w.]+@[\w.]+\.\w+", text)
print(emails)

# Named groups
log = "2026-04-04 ERROR: Connection timeout"
match = re.match(r"(?P<date>[\d-]+) (?P<level>\w+): (?P<msg>.+)", log)
if match:
    print(match.group("level"), match.group("msg"))

from typing import TypeVar, Generic

T = TypeVar("T")

class Stack(Generic[T]):
    def __init__(self) -> None:
        self._items: list[T] = []

    def push(self, item: T) -> None:
        self._items.append(item)

    def pop(self) -> T:
        return self._items.pop()

stack = Stack[int]()
stack.push(42)
print(stack.pop())

import os

# Environment variables
db_host = os.environ.get("DB_HOST", "localhost")
print(f"DB: {db_host}")

# Path operations (prefer pathlib for new code)
print(os.path.expanduser("~"))
print(os.path.splitext("report.pdf"))
print(os.getcwd())

import json
from datetime import datetime

# Custom serializer for non-JSON types
def custom_encoder(obj):
    if isinstance(obj, datetime):
        return obj.isoformat()
    raise TypeError(f"Not serializable: {type(obj)}")

event = {"name": "Launch", "when": datetime(2026, 4, 4, 12, 0)}
print(json.dumps(event, default=custom_encoder, indent=2))

import subprocess

result = subprocess.run(
    ["echo", "Hello from subprocess"],
    capture_output=True, text=True
)
print(result.stdout.strip())
print(f"Return code: {result.returncode}")

def describe(value):
    match value:
        case int(n) if n > 0:
            return f"positive int: {n}"
        case str(s) if len(s) > 5:
            return f"long string: {s!r}"
        case [first, *rest]:
            return f"list starting with {first}, {len(rest)} more"
        case {"type": "error", "code": code}:
            return f"error code {code}"
        case _:
            return "something else"

print(describe(42))
print(describe([1, 2, 3]))
print(describe({"type": "error", "code": 500}))

# Nested quotes and backslashes now allowed (3.12+)
users = [{"name": "Alice"}, {"name": "Bob"}]
print(f"First user: {users[0]['name']}")

# Multi-line f-string expressions
result = f"Total: {
    sum(
        item['price']
        for item in [{'price': 10}, {'price': 20}]
    )
}"
print(result)

# New syntax (3.12+) - no more TypeVar boilerplate
def first_element[T](items: list[T]) -> T:
    return items[0]

print(first_element([10, 20, 30]))
print(first_element(["a", "b"]))

# Generic class
class Pair[A, B]:
    def __init__(self, left: A, right: B):
        self.left = left
        self.right = right

p = Pair("name", 42)
print(p.left, p.right)

import asyncio

async def task_a():
    raise ValueError("bad value")

async def task_b():
    raise TypeError("wrong type")

async def main():
    try:
        async with asyncio.TaskGroup() as tg:
            tg.create_task(task_a())
            tg.create_task(task_b())
    except* ValueError as eg:
        print(f"Value errors: {eg.exceptions}")
    except* TypeError as eg:
        print(f"Type errors: {eg.exceptions}")

# asyncio.run(main())

import tomllib

toml_string = """
[project]
name = "myapp"
version = "1.0.0"
dependencies = ["requests", "click"]
"""

config = tomllib.loads(toml_string)
print(config["project"]["name"])
print(config["project"]["dependencies"])

import asyncio

async def fetch(url: str) -> str:
    await asyncio.sleep(0.1)
    return f"Data from {url}"

async def main():
    async with asyncio.TaskGroup() as tg:
        task1 = tg.create_task(fetch("/api/users"))
        task2 = tg.create_task(fetch("/api/orders"))

    print(task1.result())
    print(task2.result())

# asyncio.run(main())

# Python 3.13 introduced:
# 1. Experimental JIT compiler (--enable-experimental-jit)
# 2. Free-threaded mode (no GIL) via python3.13t
# 3. Improved error messages with color

import sys
print(f"Python {sys.version}")

# Check if GIL is disabled (3.13+)
# sys._is_gil_enabled()  # returns False in free-threaded build

import warnings

# Python 3.13+
# from warnings import deprecated
# @deprecated("Use process_v2() instead")
# def process_v1(data): ...

# For earlier versions, manual approach:
def deprecate(msg):
    def decorator(func):
        def wrapper(*args, **kwargs):
            warnings.warn(f"{func.__name__}: {msg}", DeprecationWarning, stacklevel=2)
            return func(*args, **kwargs)
        return wrapper
    return decorator

@deprecate("Use process_v2() instead")
def process_v1(data):
    return data

process_v1("test")

# WRONG: Shared mutable default
def add_tag_bad(tag, tags=[]):
    tags.append(tag)
    return tags

print(add_tag_bad("a"))
print(add_tag_bad("b"))  # Surprise!

# CORRECT: Use None sentinel
def add_tag(tag, tags=None):
    if tags is None:
        tags = []
    tags.append(tag)
    return tags

print(add_tag("a"))
print(add_tag("b"))

# WRONG: All lambdas see final value of i
funcs_bad = [lambda: i for i in range(4)]
print([f() for f in funcs_bad])

# CORRECT: Capture current value via default arg
funcs_good = [lambda i=i: i for i in range(4)]
print([f() for f in funcs_good])

# WRONG: Modifying during iteration skips elements
nums = [1, 2, 3, 4, 5, 6]
for n in nums:
    if n % 2 == 0:
        nums.remove(n)
print(f"Wrong: {nums}")  # 4 was skipped!

# CORRECT: List comprehension to filter
nums = [1, 2, 3, 4, 5, 6]
result = [n for n in nums if n % 2 != 0]
print(f"Right: {result}")

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

# CPython caches small integers
x = 256
y = 256
print(x is y)

x = 257
y = 257
print(x is y)  # May be False!

counter = 0

def increment_wrong():
    # UnboundLocalError: counter referenced before assignment
    # counter += 1  # This fails!
    pass

def increment_correct():
    global counter
    counter += 1

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

tick = make_counter()
print(tick(), tick(), tick())

import copy

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

original[0].append(99)
print(f"Original: {original}")
print(f"Shallow:  {shallow}")
print(f"Deep:     {deep}")

name = "  Alice  "

# WRONG: result is discarded
name.strip()
print(f"'{name}'")  # unchanged!

# CORRECT: reassign the result
name = name.strip()
print(f"'{name}'")

def process(data=None):
    # WRONG: if not data
    # This also catches empty list [], 0, and ""
    if not data:
        print("No data")  # Triggered by empty list too!

    # CORRECT: if data is None
    if data is None:
        print("Data is None")

process([])   # Might not intend to reject []
process(None)
process(0)