python -m venv .venv            # 1. create (one-time per project)
source .venv/bin/activate       # 2. activate (Linux/macOS)
.venv\Scripts\activate          #    (Windows CMD/PowerShell)
python -m pip install -U pip    # 3. fresh envs ship an old pip — upgrade
pip install requests            # 4. install into the env only
deactivate                      # 5. leave the env

# 1 — print & arithmetic
print("Hello, Python!", 2 + 2, 10 / 4, 10 // 4, 10 % 4, 2 ** 10)

# 2 — variables need no declarations
name, age = "Matin", 30
print(f"{name} will be {age + 1} next year")     # f-string

# 3 — a list, a loop
for i in [3, 1, 4, 1, 5]:
    print(i * "*")

# 4 — conditions
temperature = 31
print("hot" if temperature > 28 else "fine")

# 5 — function
def greet(who="world"):
    return f"Hello, {who}!"
print(greet(), greet("Python"))

# 6 — dictionary
book = {"title": "Dune", "year": 1965}
book["author"] = "Frank Herbert"
print(book["title"].upper())

# 7 — input (note: always a string!)
age = int(input("Your age? "))
print("Days alive ≈", age * 365.25)

# 8 — file write & read
with open("notes.txt", "w", encoding="utf-8") as f:
    f.write("line 1\nline 2\n")
print(open("notes.txt").read().splitlines())

# 9 — comprehension
squares = [n * n for n in range(1, 11) if n % 2 == 1]
print(squares)

# 10 — import & use the battery included
from datetime import date
from pathlib import Path
print(date.today(), "· cwd:", Path.cwd().name)

[build-system]
requires = ["setuptools>=69"]
build-backend = "setuptools.build_meta"

[project]
name = "coolpkg"                     # PyPI name
version = "1.0.0"                    # or dynamic from git tags
description = "Does cool things"
readme = "README.md"
requires-python = ">=3.10"
license = {text = "MIT"}
authors = [{name = "Matin", email = "you@example.com"}]
keywords = ["cli", "tools"]
classifiers = ["Programming Language :: Python :: 3", "License :: OSI Approved :: MIT License"]
dependencies = ["requests>=2.31", "rich>=13"]

[project.optional-dependencies]
dev = ["pytest", "ruff", "mypy"]

[project.scripts]
cool = "coolpkg.cli:main"            # creates the `cool` command on install

[project.urls]
Homepage = "https://github.com/xvviix/coolpkg"

[tool.setuptools.packages.find]
include = ["coolpkg*"]

python -m cProfile -s cumulative script.py          # sorted by total time
python -m cProfile -o out.prof script.py            # save
python -m pstats out.prof                           # browse: sort cumulative / stats 10 / strip

python -m timeit "'-'.join(map(str, range(50)))"
python -m timeit -s "x=list(range(1000))" "x.sort()"

s = "Pythonista"
s[0] s[-1]        # 'P', 'a'
s[2:5] s[:4] s[6:]     # 'tho', 'Pyth', 'ista'
s[::2] s[::-1]         # 'PtoiA' step-2; reversed copy
s[1:-1:3]              # start 1, stop before -1, step 3

f"{3.14159:.2f}"          # '3.14'
f"{1234567:,}"            # '1,234,567'
f"{0.85:.1%}"             # '85.0%'
f"{255:#x} {255:b}"       # '0xff' '11111111'
f"{'hi':^10}"             # '    hi    '
f"{name=} / {x=}"         # 'name=...' debug prints the expression!
f"{dt:%Y-%m-%d}"          # datetime inline
f"{obj!r}"                # repr() instead of str()

if x > 100:        ...
elif x > 10:       ...
else:              ...

# ternary
label = "big" if x > 100 else "small"

# match (3.10+) — structural pattern matching
match command.split():
    case ["go", direction]:            print("moving", direction)
    case ["go", *rest]:                print("go many:", rest)
    case ["drop", item] if item != "": print("dropping", item)
    case ["quit" | "exit"]:            break
    case {"op": "add", "n": n}:        total += n        # mapping patterns
    case Point(x=0, y=y):              ...               # class patterns
    case _:                            print("unknown")

for item in iterable: ...          # the one loop
for i, item in enumerate(items, 1): ...
for a, b in zip(xs, ys): ...
while condition: ...
break                               # exit loop
continue                            # next iteration
else:                              # runs only if loop finished WITHOUT break — unique to Python
    print("no break happened")
for n in range(10, 0, -1): ...     # countdown

[n*n for n in range(10) if n % 2 == 0]           # list
{n: n*n for n in range(5)}                       # dict
{ch for ch in "abracadabra" if ch in "abc"}      # set
(lazy := (line.strip() for line in f))           # generator expression — memory-free
[[r*c for c in range(4)] for r in range(3)]      # nested
[x if x > 0 else 0 for x in data]                # conditional expression inside
flat = [x for row in matrix for x in row]        # flatten (order: outer loop first)

def countdown(n):
    while n > 0:
        yield n          # pause here, hand value out
        n -= 1

gen = (x*x for x in range(1_000_000))   # lazy, O(1) memory
next(gen)                               # pull one value
def fib():                              # infinite stream
    a, b = 0, 1
    while True:
        yield a; a, b = b, a + b

# yield from delegates to a sub-generator
def chain_all(*iterables):
    for it in iterables:
        yield from it

# send / close — coroutine-style generators
g = echo(); g.send(None); g.send("hi")

def f(pos_only, /, normal, *args, kw_only=1, **kwargs):
    """Docstring. pos_only is positional-only (the /)."""
    ...

f(1, 2, 3, 4, kw_only=9, anything="goes")
# pos_only=1, normal=2, args=(3,4), kwargs={'anything':'goes'}

def g(a, b=(), /, *, key=None): ...       # / left = positional-only, * right = keyword-only
lambda x, y: x + y                         # expression function
func(*args_list, **kwargs_dict)            # unpacking at call site

def make_multiplier(n):
    def multiply(x): return x * n          # closes over n
    return multiply

import functools
@functools.cache                            # memoize (3.9+); @lru_cache(maxsize=None) same
def fib(n): return n if n < 2 else fib(n-1) + fib(n-2)

@functools.wraps(f)                         # preserve metadata in custom decorators
def wrapper(*a, **k): ...

def process(items: list[int], name: str = "x", *,
            limit: int | None = None) -> dict[str, float]: ...

from typing import Optional, Union, Literal, TypedDict, Protocol, Callable, TypeVar, Generic, Any
Vector = list[float]                        # type alias (or `type Vector = list[float]` 3.12+)
T = TypeVar("T")

class Repo(Generic[T]):
    def get(self, id: int) -> T | None: ...

def scale(v: list[float], k: float = 1.0) -> list[float]: return [x * k for x in v]

# gradual typing: hints are NOT enforced at runtime — check with mypy / pyright

class Animal:
    kingdom = "Animalia"                        # class attribute (shared)
    def __init__(self, name: str, legs: int = 4):
        self.name = name                        # instance attributes
        self.legs = legs
    def speak(self) -> str:
        return "..."
    def __repr__(self):
        return f"Animal({self.name!r})"         # unambiguous (debug) repr
    def __str__(self):
        return f"{self.name} ({self.legs} legs)" # friendly str

class Dog(Animal):                              # inheritance
    def __init__(self, name):
        super().__init__(name, 4)               # call parent init
    def speak(self):                            # override
        return "Woof"

d = Dog("Rex")
isinstance(d, Animal)  → True;  issubclass(Dog, Animal) → True

from dataclasses import dataclass, field

@dataclass
class Point:
    x: float
    y: float = 0.0
    tags: list[str] = field(default_factory=list)   # mutable-safe default

    def dist(self): return (self.x**2 + self.y**2) ** 0.5

p = Point(3, 4)         # __init__ generated
p == Point(3, 4)        # True — __eq__ generated
print(p)                # Point(x=3, y=4) — __repr__ generated

BaseException
├── SystemExit              # sys.exit()
├── KeyboardInterrupt       # Ctrl+C
├── GeneratorExit
└── Exception
    ├── ArithmeticError
    │   ├── ZeroDivisionError
    │   ├── OverflowError
    │   └── FloatingPointError
    ├── AssertionError
    ├── AttributeError
    ├── BufferError
    ├── EOFError
    ├── ImportError
    │   └── ModuleNotFoundError
    ├── LookupError
    │   ├── IndexError
    │   └── KeyError
    ├── MemoryError
    ├── NameError
    │   └── UnboundLocalError
    ├── OSError
    │   ├── FileNotFoundError
    │   ├── FileExistsError
    │   ├── PermissionError
    │   ├── IsADirectoryError / NotADirectoryError
    │   ├── BlockingIOError / InterruptedError
    │   ├── TimeoutError
    │   ├── ConnectionError (Reset/Aborted/Refused)
    │   └── ProcessLookupError / ChildProcessError
    ├── ReferenceError
    ├── RuntimeError
    │   ├── NotImplementedError
    │   └── RecursionError
    ├── StopIteration / StopAsyncIteration
    ├── SyntaxError
    │   └── IndentationError
    │       └── TabError
    ├── SystemError
    ├── TypeError
    ├── ValueError
    │   └── UnicodeError (Decode/Encode/Translate)
    └── Warning (Deprecation, Future, User, RuntimeWarning, …)

try:
    risky()
except (ValueError, KeyError) as e:      # multiple types, bound as e
    log.warning("bad input: %s", e)
except OSError as e:
    if e.errno == 2: ...                  # inspect errno
    raise                                 # re-raise same exception
else:
    print("no exception happened")        # only on success
finally:
    cleanup()                             # always

raise ValueError(f"bad mode: {mode!r}") from cause          # exception chaining
raise TimeoutError("server didn't answer") from None        # hide the chain

class InventoryError(Exception):
    """Custom domain error."""

with contextlib.suppress(FileNotFoundError):
    os.remove("tmp.txt")                  # try/except-pass, but readable

import math                                # whole module
import numpy as np                         # aliased
from datetime import date, timedelta       # names directly
from pathlib import Path as P              # aliased name
from mypkg import submodule                # a submodule
from .sibling import helper                # relative (inside a package)

with open("data.txt", "r", encoding="utf-8", newline="\n") as f:   # ALWAYS with
    text = f.read()                    # whole file
    first = f.readline()
    lines = f.readlines()              # list of lines
for line in f:                         # lazy — best for big files
    process(line.rstrip("\n"))

with open("out.txt", "w", encoding="utf-8") as f:
    f.write("text\n"); f.writelines(lines)

from pathlib import Path
p = Path("docs") / "report" / "final.txt"     # / joins!

import json
json.dumps(obj)  / json.dump(obj, f, indent=2, ensure_ascii=False)   # → str / file
json.loads(s)    / json.load(f)                                      # ← str / file
# tuples→lists, keys must be str, use default= for dates/custom

import csv
with open("t.csv", newline="", encoding="utf-8") as f:
    rows = list(csv.DictReader(f))                 # dicts keyed by header
with open("out.csv", "w", newline="", encoding="utf-8") as f:
    w = csv.DictWriter(f, fieldnames=["a","b"]); w.writeheader(); w.writerows(rows)

import pickle                                  # ⚠ only unpickle data you trust
pickle.dump(obj, open("o.pkl","wb")); obj = pickle.load(open("o.pkl","rb"))

import sqlite3
con = sqlite3.connect("app.db")                # or :memory:
con.execute("CREATE TABLE IF NOT EXISTS t (id INTEGER PRIMARY KEY, name TEXT)")
con.execute("INSERT INTO t(name) VALUES (?)", ("alice",))   # ALWAYS ? params
con.commit(); [r for r in con.execute("SELECT * FROM t WHERE name=?", ("alice",))]
con.row_factory = sqlite3.Row; con.close()

import tempfile, io
tmp = tempfile.NamedTemporaryFile(delete=False); tmp.name
buf = io.StringIO("initial"); buf.seek(0)      # in-memory text file

from threading import Thread, Lock, Event, Semaphore, Condition, local
lock = Lock()
def worker(n):
    with lock:                    # GIL still applies to Python bytecode
        shared.append(n)
threads = [Thread(target=worker, args=(i,)) for i in range(8)]
[t.start() for t in threads]; [t.join() for t in threads]

from multiprocessing import Process, Pool, Queue, Pipe
def cube(n): return n * n * n
if __name__ == "__main__":                     # REQUIRED on Windows/macOS spawn
    with Pool() as pool:
        results = pool.map(cube, range(10))    # parallel map
        r = pool.apply_async(cube, (7,)); r.get(timeout=5)
    p = Process(target=worker, args=(1,)); p.start(); p.join()

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor, as_completed
with ThreadPoolExecutor(max_workers=20) as ex:
    futures = {ex.submit(fetch, url): url for url in urls}
    for fut in as_completed(futures):
        try: print(fut.result())
        except Exception as e: print("failed:", futures[fut], e)
pages = list(ex.map(fetch, urls))               # simple parallel map

import asyncio

async def fetch(name, delay):
    await asyncio.sleep(delay)                  # non-blocking wait
    return f"{name} done"

async def main():
    # sequential
    a = await fetch("a", 1)
    # concurrent — gather (results in order)
    results = await asyncio.gather(fetch("b", 2), fetch("c", 1), return_exceptions=True)
    # structured concurrency (3.11+)
    async with asyncio.TaskGroup() as tg:
        t1 = tg.create_task(fetch("d", 1))
        t2 = tg.create_task(fetch("e", 2))       # one fails → all cancelled
    # timeout
    try:
        await asyncio.wait_for(fetch("f", 10), timeout=2)
    except TimeoutError: pass

asyncio.run(main())                              # THE entry point

from datetime import datetime, date, time, timedelta, timezone
now = datetime.now()                      # local, naive
utc  = datetime.now(timezone.utc)         # TIMEZONE-AWARE — prefer for real code
datetime.fromisoformat("2026-08-30T14:30:00+02:00")   # parse ISO (3.11+: most formats)
dt = datetime.strptime("30/08/2026", "%d/%m/%Y")      # parse any format
dt.strftime("%Y-%m-%d %H:%M")                         # format out
dt + timedelta(days=7, hours=3)                       # arithmetic
(dt2 - dt1).days / .total_seconds()                   # differences
dt.timestamp() ; datetime.fromtimestamp(1760000000)   # epoch shuttle
date.today() ; dt.date() ; dt.year .month .day .hour .weekday()  # Monday=0 / isoweekday()

import subprocess
r = subprocess.run(["ping", "-n", "1", "example.com"], capture_output=True,
                   text=True, timeout=10, check=False)
r.returncode, r.stdout, r.stderr
subprocess.run("echo hi > f.txt", shell=True)             # ⚠ shell=True = injection risk
subprocess.run(["python", "script.py"], input="y\n", text=True, check=True)

import argparse

p = argparse.ArgumentParser(
    prog="tool", description="Do the thing",
    epilog="Enjoy.")
p.add_argument("src", help="source file")                       # positional
p.add_argument("dst", nargs="?", default="out.txt")             # optional positional
p.add_argument("-n", "--dry-run", action="store_true")          # flag
p.add_argument("-v", "--verbose", action="count", default=0)    # -vvv → 3
p.add_argument("--limit", type=int, default=10)                 # typed option
p.add_argument("--mode", choices=["fast","safe"], default="safe")
p.add_argument("--tags", action="append")                       # repeatable → list
p.add_argument("--log", type=argparse.FileType("w"))            # opens the file!
p.add_argument("--retries", metavar="N", type=int, default=3)
sub = p.add_subparsers(dest="cmd", required=True)
p_init = sub.add_parser("init", help="create config")
p_init.add_argument("--force", action="store_true")
p_push = sub.add_parser("push", help="upload")
p_push.add_argument("target")

args = p.parse_args()          # --help auto-generated from all of the above

import logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s %(levelname)-8s %(name)s: %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S",
    filename="app.log",          # omit → stderr
)
log = logging.getLogger("payroll")           # per-module loggers: logging.getLogger(__name__)
log.debug("detail %s", item)                 # lazy % formatting — never f-strings in hot paths
log.info("processed %d rows", n)
log.warning("deprecated call")
log.error("failed: %s", err)
log.exception("boom")                        # ERROR + traceback (in except block)

# Step 1 — the calculator soul of Python (REPL: >>> means type it live)
2 + 2, 7 / 2, 7 // 2, 7 % 2, 2 ** 10          # (4, 3.5, 3, 1, 1024)

# Step 2 — variables & types (dynamic: names are labels, not boxes)
width, height = 3, 4
area = width * height
type(area)                                     # <class 'int'>

# Step 3 — strings & f-strings
name = "Ada"
print(f"{name} computed area={area}")

# Step 4 — lists and loops
temps = [21, 25, 19, 30, 27]
for t in temps:
    print("hot" if t >= 25 else "mild", t)
print("avg:", sum(temps) / len(temps))

# Step 5 — functions
def to_f(c): return c * 9 / 5 + 32
print([to_f(t) for t in temps])

# Step 6 — dict as a tiny database
people = {"ada": 36, "alan": 41}
people["grace"] = 45
for who, age in sorted(people.items()):
    print(f"{who:>6}: {age}")

# Step 7 — program 1: number guessing game
import random
secret = random.randint(1, 100)
while (guess := int(input("Guess: "))) != secret:
    print("higher" if guess < secret else "lower")
print("Correct!")

# Step 8 — program 2: word counter
text = input("Sentence: ")
counts = {}
for word in text.lower().split():
    counts[word] = counts.get(word, 0) + 1
print(sorted(counts.items(), key=lambda kv: -kv[1]))

# parse access logs like: 2026-08-30 12:01:02 ERROR payment failed id=771
import re, csv
from collections import Counter
from pathlib import Path

log_re = re.compile(r"(?P<date>\d{4}-\d{2}-\d{2}) (?P<time>\d{2}:\d{2}:\d{2}) "
                    r"(?P<level>INFO|WARNING|ERROR) (?P<msg>.*)")

rows, level_counts = [], Counter()
for line in Path("app.log").read_text(encoding="utf-8").splitlines():
    if m := log_re.match(line):
        rows.append(m.groupdict())
        level_counts[m["level"]] += 1

with open("report.csv", "w", newline="", encoding="utf-8") as f:
    w = csv.DictWriter(f, fieldnames=["date", "time", "level", "msg"])
    w.writeheader(); w.writerows(rows)

print("levels:", dict(level_counts))
print("errors on:", {r["date"] for r in rows if r["level"] == "ERROR"})

import requests

def get_json(url, **params):
    r = requests.get(url, params=params, timeout=10)
    r.raise_for_status()
    return r.json()

data = get_json("https://api.github.com/repos/python/cpython/events", per_page=5)
for ev in data:
    print(f"{ev['type']:<22} {ev['actor']['login']:<20} {ev['repo']['name']}")

# POST with auth:
# requests.post(url, json={"key": "value"}, headers={"Authorization": f"Bearer {token}"})

"""todo.py — a tiny task manager."""
import argparse, json
from pathlib import Path

DB = Path.home() / ".todo.json"

def load():
    return json.loads(DB.read_text()) if DB.exists() else []
def save(tasks): DB.write_text(json.dumps(tasks, indent=2))

def main():
    p = argparse.ArgumentParser(description="Tiny todo")
    sub = p.add_subparsers(dest="cmd", required=True)
    a = sub.add_parser("add");    a.add_argument("task", help="task text")
    d = sub.add_parser("done");   d.add_argument("n", type=int, help="task number")
    sub.add_parser("list", help="show tasks")
    args = p.parse_args()

    tasks = load()
    match args.cmd:
        case "add":  tasks.append({"task": args.task, "done": False}); save(tasks)
        case "done": tasks[args.n - 1]["done"] = True; save(tasks)
        case "list":
            for i, t in enumerate(tasks, 1):
                print(f"{'✓' if t['done'] else '·'} {i}. {t['task']}")

if __name__ == "__main__":
    main()

from dataclasses import dataclass, field
from enum import Enum

class Condition(Enum):
    NEW = "new"; USED = "used"; BROKEN = "broken"

@dataclass(order=True)
class Item:
    sort_index: float = field(init=False, repr=False)
    sku: str = ""
    name: str = ""
    price: float = 0.0
    condition: Condition = Condition.NEW
    tags: list[str] = field(default_factory=list)

    def __post_init__(self):
        self.sort_index = -self.price          # highest price first

class Inventory:
    def __init__(self): self._items: dict[str, Item] = {}
    def add(self, item: Item): self._items[item.sku] = item
    def total_value(self) -> float:
        return sum(i.price for i in self._items.values() if i.condition != Condition.BROKEN)
    def find(self, query: str) -> list[Item]:
        q = query.lower()
        return [i for i in self._items.values() if q in i.name.lower() or q in " ".join(i.tags)]

inv = Inventory()
inv.add(Item(sku="A1", name="Keyboard", price=79.9, tags=["input"]))
inv.add(Item(sku="A2", name="Monitor", price=349, condition=Condition.USED))
print(inv.total_value(), inv.find("monitor"))

# 1. Layout
mylib/
├── pyproject.toml      # from §6 — name, version, deps, [project.scripts]
├── README.md
├── src/mylib/__init__.py
└── tests/test_mylib.py

# 2. Local sanity
python -m venv .venv && source .venv/bin/activate
pip install -e . && mylib-cli --help          # entry point works?

# 3. Build & validate
pip install build twine
python -m build
twine check dist/*

# 4. Rehearse on TestPyPI, then the real thing
twine upload --repository testpypi dist/*
pip install -i https://test.pypi.org/simple/ mylib && python -c "import mylib"
twine upload dist/*                            # needs a PyPI API token

# tests/test_math.py
import pytest
from mylib import add, divide, load_config

def test_add_ints():
    assert add(2, 3) == 5

@pytest.mark.parametrize("a,b,out", [(0,0,0), (-1,1,0), (100,1,101)])
def test_add_many(a, b, out):
    assert add(a, b) == out

def test_divide_by_zero():
    with pytest.raises(ZeroDivisionError):
        divide(1, 0)

@pytest.fixture
def config(tmp_path):
    cfg = tmp_path / "c.ini"; cfg.write_text("[main]\nkey=1\n")
    return load_config(cfg)

def test_config(config):
    assert config["main"]["key"] == "1"

def test_output(capsys):
    print("hi"); assert capsys.readouterr().out == "hi\n"

pytest -v --durations=3
pytest --lf
pytest --cov=mylib --cov-report=term-missing

# A — rename & sort a folder of photos by EXIF-less mtime
from pathlib import Path
from datetime import datetime
for p in Path("dump").iterdir():
    if p.is_file():
        stamp = datetime.fromtimestamp(p.stat().st_mtime).strftime("%Y-%m/%Y%m%d_%H%M%S")
        target = Path("sorted") / f"{stamp}{p.suffix}"
        target.parent.mkdir(parents=True, exist_ok=True)
        p.rename(target)

# B — Excel → cleaned Excel (pip install openpyxl pandas)
import pandas as pd
df = pd.read_excel("sales.xlsx", sheet_name="Q3")
clean = (df.dropna(subset=["amount"])
           .assign(total=lambda d: d.amount * d.qty)
           .groupby("region", as_index=False)["total"].sum())
clean.to_excel("sales_summary.xlsx", index=False)

# C — send an email report (stdlib)
import smtplib
from email.message import EmailMessage
msg = EmailMessage()
msg["From"], msg["To"], msg["Subject"] = "me@x.com", "boss@x.com", "Weekly report"
msg.set_content(open("report.txt").read())
with smtplib.SMTP("smtp.example.com", 587) as s:
    s.starttls(); s.login("me@x.com", "app-password"); s.send_message(msg)

# D — watch a folder for new files
import time
seen = set()
while True:
    for p in Path("inbox").glob("*.csv"):
        if p not in seen:
            seen.add(p); print("new:", p); # process(p)
    time.sleep(2)

import asyncio, aiohttp, time

URLS = [f"https://httpbin.org/delay/{d}" for d in (1, 1, 1, 1, 1)]

async def fetch(session, url):
    async with session.get(url, timeout=aiohttp.ClientTimeout(total=15)) as r:
        return url, r.status

async def main():
    async with aiohttp.ClientSession() as session:
        async with asyncio.TaskGroup() as tg:                    # 3.11+
            tasks = [tg.create_task(fetch(session, u)) for u in URLS]
    for t in tasks:
        print(t.result())

start = time.perf_counter()
asyncio.run(main())
print(f"5 requests in {time.perf_counter() - start:.1f}s (sequential would be ~5s)")

# 1 — reproduce under pdb
python -m pdb app.py input.csv
(Pdb) b app.py:42            # break where it goes wrong
(Pdb) c                      # run to it
(Pdb) p rows[:3]             # inspect
(Pdb) pp {r["id"]: r for r in rows}
(Pdb) w                      # how did we get here?
(Pdb) interact               # full REPL with all locals

# 2 — or post-mortem the last crash
python -i app.py
>>> import pdb; pdb.pm()

# 3 — find the hotspot
python -m cProfile -s cumtime app.py | head -25
# or: python -X importtime -c "import app" 2>&1 | sort -t'|' -k2 -n | tail

import requests

# 1 — the basic GET (ALWAYS pass a timeout)
r = requests.get("https://api.github.com/users/torvalds", timeout=10)
r.raise_for_status()                 # 4xx/5xx → exception instead of silent garbage
print(r.status_code, r.headers["content-type"])
bio = r.json()                       # parse the body as JSON → dict

# 2 — query params, headers, auth
r = requests.get("https://api.github.com/search/repositories",
                 params={"q": "python cli", "sort": "stars", "per_page": 3},
                 headers={"Accept": "application/vnd.github+json"},
                 timeout=10)
for item in r.json()["items"]:
    print(f"{item['full_name']:40} ★{item['stargazers_count']}")

# 3 — POST with a JSON body (what 95 % of APIs want)
created = requests.post("https://httpbin.org/post",
                        json={"title": "hello", "done": False}, timeout=10)

# 4 — Session: connection reuse + persistent cookies + one place for defaults
with requests.Session() as s:
    s.headers.update({"Authorization": "Bearer YOUR_TOKEN", "User-Agent": "learn/1.0"})
    s.get("https://api.github.com/user", timeout=10)          # authenticated!
    for page in range(1, 3):                                   # pagination
        resp = s.get("https://api.github.com/users/torvalds/repos",
                     params={"page": page}, timeout=10)
        repos = resp.json()
        if not repos: break
        print([repo["name"] for repo in repos])

try:
    r = requests.get(url, timeout=10)
    r.raise_for_status()
except requests.Timeout:
    print("server too slow")
except requests.HTTPError as e:
    print(f"HTTP {e.response.status_code} — check the URL/token")
except requests.ConnectionError:
    print("no network / DNS fail")
else:
    data = r.json()

import httpx
r = httpx.get("https://example.org", timeout=10)        # drop-in for requests

import asyncio
async def fetch_all(urls):
    async with httpx.AsyncClient(timeout=10) as client:   # concurrent fetches
        replies = await asyncio.gather(*(client.get(u) for u in urls))
        return [r.status_code for r in replies]
print(asyncio.run(fetch_all(["https://example.org"] * 5)))

from pydantic import BaseModel, Field, field_validator, model_validator
from datetime import date
from typing import Literal

class Address(BaseModel):                       # nested model
    city: str
    zip_code: str = Field(pattern=r"^\d{4,10}$")   # regex-constrained

class User(BaseModel):
    id: int
    name: str = Field(min_length=1, max_length=60)
    email: str                                   # basic type checks
    role: Literal["admin", "user"] = "user"      # only these values allowed
    birthday: date | None = None
    address: Address

    @field_validator("email")                    # custom rule
    @classmethod
    def email_lowercase(cls, v): return v.lower()

    @model_validator(mode="after")               # cross-field rule
    def check(self):
        if self.role == "admin" and self.name.lower() == "guest":
            raise ValueError("admin cannot be named guest")
        return self

u = User.model_validate({                        # messy input → validated object
    "id": "7",                                   # str → coerced to int!
    "name": "Matin",
    "email": "MATIN@Example.COM",
    "address": {"city": "Vienna", "zip_code": "1010"},
})
print(u.id, u.email, u.address.city)             # 7 matin@example.com Vienna
print(u.model_dump())                            # back to a plain dict
print(User.model_json_schema())                  # a JSON Schema, for free

from pydantic import ValidationError
try:
    User(id=1, name="x", email="nope", address={"city": "c", "zip_code": "ABC"})
except ValidationError as e:
    print(e.error_count(), "errors")             # precise, structured error report

# .env file:   API_TOKEN=abc123   DEBUG=true
from pydantic_settings import BaseSettings
from pydantic import Field

class Settings(BaseSettings):
    api_token: str = Field(repr=False)           # repr=False hides it from logs
    debug: bool = False
    model_config = {"env_file": ".env"}          # reads .env automatically

settings = Settings()
print(settings.debug)                            # True — typed, validated config

import numpy as np

# 1 — creation
a = np.array([1, 2, 3, 4])                       # from a list
z = np.zeros(5); ones = np.ones((2, 3))          # shapes: (rows, cols)
rng = np.random.default_rng(seed=42)
noise = rng.normal(0, 1, size=1_000_000)         # a million samples, instantly
grid = np.arange(12).reshape(3, 4)               # 0..11 in a 3×4 matrix

# 2 — elementwise math WITHOUT loops (this is the whole point)
temps_c = np.array([12.5, 18.0, 24.3, 31.2, 27.8])
temps_f = temps_c * 9 / 5 + 32                   # one line, C speed
print(temps_f.round(1))

# 3 — slicing returns VIEWS (no copy!) — 2D: [rows, cols]
grid[0, 1]          # row 0, col 1
grid[:, 0]          # entire first column
grid[1:, ::2]       # rows 1+, every 2nd column
grid[grid > 5]      # boolean mask → 1D of matches
np.where(temps_c > 25, "hot", "mild")            # vectorized conditional

# 4 — aggregations and the axis argument
grid.sum(), grid.mean(), grid.std()
grid.sum(axis=0)     # down the columns → per-column totals
grid.sum(axis=1)     # across the rows   → per-row totals
np.argmax(temps_c)   # index of the max

# 5 — broadcasting: combine different shapes sensibly
prices = np.array([10.0, 20.0, 30.0])            # shape (3,)
quantities = np.array([[1, 2, 3], [4, 5, 6]])    # shape (2, 3)
totals = prices * quantities                      # (3,) stretches to (2, 3) — row-wise
print(totals.sum(axis=1))                         # per-order totals

# before                       # after
out = []                       import numpy as np
for x in data:                 out = np.sqrt(np.abs(data))
    out.append(abs(x)**0.5)

import pandas as pd

# 1 — load (csv / excel / json / sql all work)
df = pd.read_csv("sales.csv", parse_dates=["date"])

# 2 — inspect before touching anything
df.head()            # first rows
df.shape             # (rows, cols)
df.info()            # dtypes + missing-value counts
df.describe()        # numeric summary

# 3 — select: columns, rows, filters
df[["region", "amount"]]                    # column subset
df.loc[df["amount"] > 500, ["region", "amount"]]   # boolean rows + column subset
df.iloc[0:10]                               # positional slice
df.query("region == 'East' and amount > 200")      # SQL-ish syntax

# 4 — clean: missing values and broken types
df["amount"] = pd.to_numeric(df["amount"], errors="coerce")  # bad values → NaN
df = df.dropna(subset=["amount"])            # drop rows without an amount
df["region"] = df["region"].str.strip().str.title()          # normalize text

# 5 — derive columns
df["month"] = df["date"].dt.to_period("M")
df["amount_with_tax"] = df["amount"] * 1.2
df["size"] = pd.cut(df["amount"], bins=[0, 100, 500, np.inf],
                    labels=["small", "medium", "large"])

# 6 — the groupby reflex: split → apply → combine
df.groupby("region")["amount"].agg(["count", "sum", "mean"])
df.groupby(["region", "month"])["amount"].sum().unstack()    # pivot wide
df.pivot_table(index="region", columns="size", values="amount",
               aggfunc="sum", fill_value=0)

# 7 — combine frames
pd.merge(orders, customers, on="customer_id", how="left")    # SQL join
pd.concat([q1, q2, q3])                                      # stack frames

# 8 — export
df.to_csv("clean.csv", index=False)
df.to_excel("report.xlsx", sheet_name="sales")
df.to_sql("sales", engine, if_exists="replace")              # into a database

top = (df.groupby("region")["amount"]
         .sum()
         .sort_values(ascending=False))
print(top.head(10))
growth = df.set_index("date").resample("ME")["amount"].sum()  # monthly trend
print(growth.pct_change().round(3).tail())                     # % change

import matplotlib.pyplot as plt
import numpy as np

# 0 — the anatomy: figure = the canvas, axes = one chart
fig, ax = plt.subplots(figsize=(8, 4))          # one axes

x = np.linspace(0, 10, 100)

# 1 — line (trends over ordered x)
ax.plot(x, np.sin(x), label="sin", linewidth=2)
ax.plot(x, np.cos(x), label="cos", linestyle="--")

ax.set_title("Trig functions")                  # ALWAYS title + label axes
ax.set_xlabel("x"); ax.set_ylabel("y")
ax.legend(); ax.grid(alpha=0.3)
fig.savefig("trig.png", dpi=150, bbox_inches="tight")   # save BEFORE show
plt.show()

fig, axes = plt.subplots(2, 2, figsize=(10, 8))   # 2×2 grid of axes
ax = axes[0, 0]
ax.bar(["A", "B", "C"], [3, 7, 5])                 # compare categories
ax.set_title("bar — comparison")

axes[0, 1].scatter(rng.normal(size=50), rng.normal(size=50),
                   alpha=0.7)                      # relationship between 2 vars
axes[0, 1].set_title("scatter — relationship")

axes[1, 0].hist(rng.normal(0, 1, 1000), bins=30)   # distribution of one var
axes[1, 1].set_title("hist — distribution")

data = [rng.normal(0, 1, 100), rng.normal(2, 1, 100)]
axes[1, 1].boxplot(data)                           # spread + outliers
axes[1, 1].set_title("box — spread")
fig.tight_layout()
fig.savefig("dashboard.png", dpi=150)

plt.style.use("seaborn-v0_8-darkgrid")     # instant decent look (plt.style.available)
df.plot(kind="line", x="date", y="amount", title="Sales")   # pandas one-liner!
df.groupby("region")["amount"].sum().plot(kind="barh")      # groupby → chart
fig, ax = plt.subplots()
im = ax.imshow(np.random.random((5, 5)), cmap="viridis")    # heatmap
fig.colorbar(im)

"""notes.py — typer + rich demo CLI"""
from pathlib import Path
import json, typer
from rich.console import Console
from rich.table import Table
from rich.panel import Panel

app = typer.Typer(help="Tiny note manager")
DB = Path.home() / ".notes.json"
console = Console()

def load() -> list[dict]:
    return json.loads(DB.read_text()) if DB.exists() else []

@app.command()
def add(text: str, tag: str = typer.Option("general", help="category tag")):
    """Add a note."""
    notes = load()
    notes.append({"text": text, "tag": tag})
    DB.write_text(json.dumps(notes, indent=2))
    console.print(Panel(f"[green]Saved[/] '{text}' [dim]({tag})[/]"))

@app.command()
def list(tag: str = typer.Option(None, help="filter by tag"),
         limit: int = typer.Option(10, min=1, max=100)):
    """List notes as a rich table."""
    notes = [n for n in load() if tag is None or n["tag"] == tag][:limit]
    table = Table(title="Notes")
    table.add_column("#", justify="right", style="cyan")
    table.add_column("Tag", style="magenta")
    table.add_column("Text")
    for i, n in enumerate(notes, 1):
        table.add_row(str(i), n["tag"], n["text"])
    console.print(table)

@app.command()
def stats():
    """Counts per tag, with a progress bar for show."""
    from collections import Counter
    with console.status("counting..."):
        counts = Counter(n["tag"] for n in load())
    for tag, count in counts.most_common():
        console.print(f"[bold]{tag}[/]: {count}")

if __name__ == "__main__":
    app()

python notes.py add "ship the report" --tag work
python notes.py add "buy milk"
python notes.py list --tag work
python notes.py --help            # typer wrote all this help for you

from sqlalchemy import create_engine, select, ForeignKey
from sqlalchemy.orm import (DeclarativeBase, Mapped, mapped_column,
                            Session, relationship)

class Base(DeclarativeBase): pass

class Bookmark(Base):
    __tablename__ = "bookmarks"
    id: Mapped[int] = mapped_column(primary_key=True)
    url: Mapped[str]
    title: Mapped[str]
    tags: Mapped[list["Tag"]] = relationship(back_populates="bookmark")

class Tag(Base):
    __tablename__ = "tags"
    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str]
    bookmark_id: Mapped[int] = mapped_column(ForeignKey("bookmarks.id"))
    bookmark: Mapped[Bookmark] = relationship(back_populates="tags")

engine = create_engine("sqlite:///bookmarks.db")   # just a file; use
Base.metadata.create_all(engine)                   #   postgresql://… for real DBs

with Session(engine) as session:                   # CREATE
    session.add_all([
        Bookmark(url="https://docs.python.org", title="Python docs",
                 tags=[Tag(name="docs"), Tag(name="daily")]),
        Bookmark(url="https://pypi.org", title="PyPI", tags=[Tag(name="docs")]),
    ])
    session.commit()

with Session(engine) as session:                   # READ
    for bm in session.scalars(select(Bookmark).where(Bookmark.url.like("%py%"))):
        print(bm.title, [t.name for t in bm.tags])

    stmt = (select(Bookmark)                                # UPDATE + DELETE
            .where(Bookmark.title == "PyPI"))
    session.scalars(stmt).one().title = "Python Package Index"
    session.commit()

import time
import requests
from bs4 import BeautifulSoup

def get_soup(url):
    r = requests.get(url, timeout=10,
                     headers={"User-Agent": "learning-bot/1.0"})   # identify yourself
    r.raise_for_status()
    return BeautifulSoup(r.text, "lxml")            # lxml parser = fast

soup = get_soup("https://quotes.toscrape.com/")     # a site built for practice

# 1 — find vs select: pick your weapon
first_quote = soup.find("div", class_="quote")      # first match by tag+class
all_quotes  = soup.find_all("div", class_="quote")  # all matches
top_tags    = soup.select(".tag-item .tag")         # CSS selectors (most flexible)

# 2 — dig into one element
for q in all_quotes:
    text = q.select_one(".text").get_text(strip=True)
    author = q.select_one(".author").get_text()
    tags = [t.get_text() for t in q.select(".tag")]
    print(f"{author}: {text[:50]}…  {tags}")

# 3 — attributes, links, tables
link = soup.select_one("a")["href"]                  # attribute access
table_rows = soup.select("table tr")                 # any table → rows
import pandas as pd
# df = pd.read_html(r.text)[0]                       # tables in ONE line

# 4 — follow pagination like a courteous visitor
page = 1
while True:
    soup = get_soup(f"https://quotes.toscrape.com/page/{page}/")
    quotes = soup.select("div.quote")
    if not quotes: break
    print(f"page {page}: {len(quotes)} quotes")
    page += 1
    time.sleep(1)                                    # rate-limit yourself — always

from pathlib import Path
from PIL import Image

# 1 — open · inspect · save (format conversion is just save-as)
img = Image.open("photo.jpg")
print(img.size, img.mode)             # (width, height) e.g. (4032, 3024) RGB
img.save("photo.png")

# 2 — the everyday transforms
img.resize((800, 600))                # exact size (distorts)
img.crop((100, 100, 500, 500))        # (left, top, right, bottom)
img.rotate(90, expand=True)
img.convert("L")                      # grayscale
img.filter(Image.Filter.BLUR)

# 3 — thumbnail: fits the box, KEEPS the aspect ratio — use this for web images
img.thumbnail((300, 300))

# 4 — batch a whole folder
src, out = Path("photos"), Path("photos/thumbs")
out.mkdir(exist_ok=True)
records = []
for file in sorted(src.glob("*.jpg")):
    with Image.open(file) as im:
        im.thumbnail((300, 300))
        thumb = out / f"{file.stem}_thumb.jpg"
        im.convert("RGB").save(thumb, "JPEG", quality=85)
        records.append((file.name, *im.size, thumb.name))

from openpyxl import Workbook
from openpyxl.styles import Font, PatternFill
from openpyxl.utils import get_column_letter

wb = Workbook()
ws = wb.active
ws.title = "Thumbnails"

header_font = Font(bold=True, color="FFFFFF")
header_fill = PatternFill("solid", fgColor="2F7DAE")
for col, title in enumerate(["Original", "Width", "Height", "Thumbnail"], 1):
    c = ws.cell(row=1, column=col, value=title)
    c.font, c.fill = header_font, header_fill

for row, rec in enumerate(records, 2):
    for col, value in enumerate(rec, 1):
        ws.cell(row=row, column=col, value=value)

for col, width in enumerate([28, 10, 10, 28], 1):   # readable columns
    ws.column_dimensions[get_column_letter(col)].width = width
ws.freeze_panes = "A2"                              # keep the header visible
ws.cell(row=len(records) + 3, column=1,
        value=f"=COUNTA(A2:A{len(records) + 1})").comment = None   # real formula
wb.save("thumbs_report.xlsx")

"""github_report.py — the utilities tutorial, assembled."""
from dotenv import load_dotenv                     # 1. config from .env
import os, requests, typer
from tenacity import retry, stop_after_attempt, wait_exponential
from tqdm import tqdm
from rich.console import Console
from rich.table import Table
from pydantic import BaseModel, Field

load_dotenv()                                      # reads .env into os.environ
TOKEN = os.getenv("GITHUB_TOKEN", "")

class Repo(BaseModel):                             # 2. validated data
    name: str
    stars: int = Field(alias="stargazers_count")
    language: str | None = None
    model_config = {"populate_by_name": True}

@retry(stop=stop_after_attempt(4),                 # 3. retries with backoff
       wait=wait_exponential(multiplier=1, min=2, max=30),
       reraise=True)
def fetch_repos(user: str, page: int) -> list[dict]:
    r = requests.get(f"https://api.github.com/users/{user}/repos",
                     params={"page": page, "per_page": 30},
                     headers={"Authorization": f"Bearer {TOKEN}"},
                     timeout=10)
    r.raise_for_status()
    return r.json()

def main(user: str):
    console = Console()
    rows, page = [], 1
    with tqdm(desc="fetching", unit="page") as bar:     # 4. honest progress
        while batch := fetch_repos(user, page):
            rows.extend(Repo.model_validate(x) for x in batch)
            page += 1; bar.update()
    if not rows:
        console.print("[yellow]no repos found[/]"); return

    table = Table(title=f"{user} — {len(rows)} repositories")   # 5. rich output
    for col in ["Repo", "Language", "★ Stars"]:
        table.add_column(col)
    for repo in sorted(rows, key=lambda r: -r.stars)[:15]:
        table.add_row(repo.name, repo.language or "—", f"{repo.stars:,}")
    console.print(table)

if __name__ == "__main__":
    typer.run(main)

# .env:   GITHUB_TOKEN=ghp_...
python github_report.py torvalds

# Files & data
python -c "import json;print(json.dumps(json.load(open('x.json')),indent=2))"   # pretty JSON
sorted(paths, key=lambda p: p.stat().st_size)[-1]      # biggest file
Path("f.txt").read_text().count("ERROR")               # occurrences
[*{line.split(',')[0] for line in open('t.csv')}]      # unique first column

# Collections
sorted(d.items(), key=lambda kv: -kv[1])               # dict by value desc
[x for x in xs if x not in seen]                       # dedupe, keep order
list(zip(*matrix))                                     # transpose
max(words, key=len)                                    # longest word
collections.Counter(nums).most_common(1)[0]            # mode

# Strings
", ".join(sorted(set(names)))                          # unique, sorted, comma'd
s.title() ; s.capitalize() ; " ".join(w.capitalize() for w in s.split())
any(p in text.lower() for p in ["err","fail"])         # keyword alarm
str(int("ff",16)) ; f"{255:08b}"                       # base conversions

# Clever stdlib
python -m http.server 8000                             # share this folder
python -m json.tool messy.json                         # validate JSON
python -m zipfile -e app.zip out/                      # unzip anything
sum(a[1]*b[1] for a,b in zip(prices,qtys))             # dot product
__import__("sys").exit(1)                              # last-resort inline exit

Traceback (most recent call last):        ← read DOWN to find your code…
  File "app.py", line 10, in <module>     ← your entry: process(invoice)
  File "lib.py", line 4, in process
    total = sum(row["qty"] for row in rows)
  File "lib.py", line 4, in <genexpr>
KeyError: 'qty'                           ← …the LAST line names the disease