Python Developer Roadmap

def clamp(value, low, high):
    if value < low:
        return low
    if value > high:
        return high
    return value

score = 88

if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
else:
    grade = "C"

names = ["ada", "lin", "sam"]
for name in names:
    print(name.upper())

for i, ch in enumerate("py"):
    print(i, ch)

n = 3
while n > 0:
    print(n)
    n -= 1

def greet(name: str, excited: bool = False) -> str:
    msg = f"Hello, {name}"
    return msg + "!" if excited else msg

print(greet("Softaims", excited=True))

def move(x, y, *, speed=1):
    return (x * speed, y * speed)

point = {"x": 2, "y": 3}
print(move(**point, speed=2))

count = 0

def outer():
    count = 10
    def inner():
        nonlocal count
        count += 1
        return count
    return inner

fn = outer()
print(fn(), fn())

pairs = [("ada", 10), ("lin", 7), ("sam", 12)]
pairs.sort(key=lambda item: item[1])
print(pairs)

from collections import Counter

words = ["python", "data", "python", "flow"]
print(Counter(words))

nums = [3, 1, 4, 1, 5]
nums.append(9)
nums.sort()
squares = [n * n for n in nums if n % 2 == 1]
print(squares)

point = (10, 20)
x, y = point
records = {(42, "draft"): "pending"}
print(records[(42, "draft")])

user = {"name": "Ada", "role": "engineer"}
user["email"] = "[email protected]"
for key, value in user.items():
    print(f"{key}: {value}")

a = {1, 2, 3, 3}
b = {3, 4, 5}
print(a | b, a & b, a - b)

title = "  python roadmap  "
slug = "-".join(title.split()).lower()
detail = f"Topic: {slug!r}"
print(detail)

from pathlib import Path

path = Path("notes.txt")
text = path.read_text(encoding="utf-8")
print(text[:80])

with open("log.txt", "w", encoding="utf-8") as fh:
    fh.write("startup\n")

with open("log.txt", "r", encoding="utf-8") as fh:
    for line in fh:
        print(line.strip())

from contextlib import contextmanager

@contextmanager
def tag(name):
    print(f"<{name}>")
    try:
        yield
    finally:
        print(f"</{name}>")

with tag("section"):
    print("content")

try:
    value = int("42a")
except ValueError as exc:
    print("bad int:", exc)

def read_number(path):
    fh = open(path, "r", encoding="utf-8")
    try:
        return int(fh.read().strip())
    finally:
        fh.close()

def divide(a, b):
    if b == 0:
        raise ValueError("b must be non-zero")
    return a / b

try:
    divide(1, 0)
except ValueError as exc:
    raise RuntimeError("division setup failed") from exc

data = {"mode": "read"}

try:
    print(data["write"])
except KeyError:
    print("missing key: write")

def average(nums):
    assert len(nums) > 0, "nums must not be empty"
    return sum(nums) / len(nums)

print(average([10, 20, 30]))

class Greeter:
    def __init__(self, name: str) -> None:
        self.name = name

    def hello(self) -> str:
        return f'Hello, {self.name}'

print(Greeter('Softaims').hello())

class Counter:
    kind = 'tally'

    def __init__(self) -> None:
        self.value = 0

    def inc(self) -> None:
        self.value += 1

c = Counter()
c.inc()
print(c.value, Counter.kind)

class User:
    def __init__(self, email: str, active: bool = True) -> None:
        if '@' not in email:
            raise ValueError('email looks invalid')
        self.email = email
        self.active = active

class Animal:
    def speak(self) -> str:
        return '...'

class Dog(Animal):
    def speak(self) -> str:
        return 'woof'

print(Dog().speak())

# project/pkg/mathx.py
def double(x: int) -> int:
    return x * 2

import json
from pathlib import Path

data = json.loads(Path('config.json').read_text(encoding='utf-8'))

"""Small stats helpers for demos."""

def mean(nums: list[float]) -> float:
    return sum(nums) / len(nums)

python -m pip install --upgrade pip
python -m pip install requests

python3 -m venv .venv
source .venv/bin/activate
python -m pip install -r requirements.txt

from flask import Flask

app = Flask(__name__)

@app.get('/')
def home():
    return {'service': 'ok'}

# Flask: minimal core
# Django: django-admin startproject mysite

from flask import Flask, jsonify

app = Flask(__name__)

@app.get('/health')
def health():
    return jsonify(status='ok')

@app.post('/items')
def create_item():
    return {'id': 1}, 201

from flask import Flask, render_template

app = Flask(__name__)

@app.get('/hello/<name>')
def hello(name: str):
    return render_template('hello.html', name=name)

from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column

class Base(DeclarativeBase):
    pass

class User(Base):
    __tablename__ = 'users'
    id: Mapped[int] = mapped_column(primary_key=True)
    email: Mapped[str] = mapped_column(unique=True)

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.get('/users/<int:user_id>')
def get_user(user_id: int):
    return jsonify(id=user_id, name='Ada')

# WSGI: gunicorn myapp:app
# ASGI: uvicorn myapp:app --host 0.0.0.0 --port 8000

import numpy as np
import pandas as pd

df = pd.DataFrame({'x': np.arange(5), 'y': np.linspace(0, 1, 5)})
print(df.head())

import numpy as np

a = np.array([1, 2, 3])
print(a * 2, a.mean())

import pandas as pd

df = pd.read_csv('sales.csv')
print(df.groupby('region')['amount'].sum())

import matplotlib.pyplot as plt

fig, ax = plt.subplots()
ax.plot([0, 1, 2], [0, 1, 0])
ax.set_title('Demo')
fig.savefig('demo.png')

import numpy as np
from sklearn.linear_model import LogisticRegression

X = np.array([[0], [1], [2], [3]])
y = np.array([0, 0, 1, 1])
model = LogisticRegression(max_iter=200).fit(X, y)
print(model.predict([[1.5]]))

import asyncio

async def main() -> None:
    await asyncio.sleep(0)
    print('done')

asyncio.run(main())

import asyncio

async def tick() -> None:
    for i in range(3):
        print('tick', i)
        await asyncio.sleep(0.1)

asyncio.run(tick())

async def fetch_label() -> str:
    return 'Softaims'

async def main() -> None:
    label = await fetch_label()
    print(label)

import threading

def work(n: int) -> None:
    print('from thread', n)

t = threading.Thread(target=work, args=(1,))
t.start()
t.join()

from concurrent.futures import ProcessPoolExecutor

def square(x: int) -> int:
    return x * x

with ProcessPoolExecutor() as pool:
    print(list(pool.map(square, [1, 2, 3])))

import sqlite3

with sqlite3.connect(':memory:') as conn:
    conn.execute('CREATE TABLE t (id INTEGER PRIMARY KEY, name TEXT)')
    conn.execute('INSERT INTO t (name) VALUES (?)', ('ada',))

import sqlite3

conn = sqlite3.connect('app.db')
try:
    conn.execute('SELECT 1')
finally:
    conn.close()

from sqlalchemy import create_engine, text

engine = create_engine('sqlite:///:memory:')
with engine.connect() as conn:
    print(conn.execute(text('SELECT 1')).scalar_one())

# pip install psycopg[binary]
# conn = psycopg.connect('dbname=test user=postgres')

# pip install mysql-connector-python
# import mysql.connector

from pymongo import MongoClient

client = MongoClient('mongodb://localhost:27017')
db = client['demo']
db.users.insert_one({'name': 'Ada', 'role': 'engineer'})

# SQLAlchemy engine manages pooling by default
# engine = create_engine(url, pool_size=10, max_overflow=5)

# ORM-style (SQLAlchemy 2.0 sketch)
# stmt = select(User).where(User.active.is_(True))

# Raw with bound params
# cursor.execute('SELECT * FROM users WHERE email = %s', (email,))

def add(a: int, b: int) -> int:
    return a + b

assert add(2, 3) == 5

import unittest

class TestMath(unittest.TestCase):
    def test_add(self) -> None:
        self.assertEqual(1 + 1, 2)

if __name__ == '__main__':
    unittest.main()

import unittest

class Demo(unittest.TestCase):
    def test_truth(self) -> None:
        self.assertTrue(True)

def test_upper():
    assert 'softaims'.upper() == 'SOFTAIMS'

from unittest.mock import Mock

api = Mock()
api.fetch.return_value = {'ok': True}
assert api.fetch('/health')['ok']

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["gunicorn", "myapp:app", "-b", "0.0.0.0:8000"]

python -m venv /opt/venv
/opt/venv/bin/pip install -r requirements.txt

gunicorn mypackage.wsgi:application --bind 0.0.0.0:8000 --workers 4

location / {
    proxy_pass http://127.0.0.1:8000;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}

docker build -t myapp:1.0 .
docker run --rm -p 8000:8000 myapp:1.0

# GitHub Actions example (conceptual)
# - uses: actions/setup-python@v5
#   with:
#     python-version: '3.12'
# - run: pip install -r requirements.txt && pytest

import requests

resp = requests.get('https://example.com', timeout=10)
resp.raise_for_status()
print(resp.status_code, len(resp.text))

import requests

s = requests.Session()
s.headers.update({'User-Agent': 'SoftaimsBot/1.0'})
r = s.get('https://httpbin.org/get', timeout=5)
print(r.json()['url'])

from bs4 import BeautifulSoup

html = '<p class="title">Softaims</p>'
soup = BeautifulSoup(html, 'html.parser')
print(soup.select_one('.title').get_text(strip=True))

# scrapy startproject demo
# define parse() in spiders/site.py

from selenium import webdriver
from selenium.webdriver.common.by import By

driver = webdriver.Chrome()
try:
    driver.get('https://example.com')
    print(driver.find_element(By.TAG_NAME, 'h1').text)
finally:
    driver.quit()

from urllib.parse import urljoin

base = 'https://example.com/a/'
href = '/b/c'
print(urljoin(base, href))

import requests

s = requests.Session()
payload = {'user': 'ada', 'token': 'from-env-not-hardcoded'}
s.post('https://example.com/login', data=payload, timeout=10)
r = s.get('https://example.com/dashboard', timeout=10)
print(r.ok)

import re

m = re.search(r'\b\d{3}-\d{4}\b', 'call 555-0199')
print(m.group(0) if m else 'no match')

import re

pat = re.compile(r'(?P<word>[A-Za-z]+)')
print(pat.findall('Softaims builds teams'))

import re

text = '<tag>one</tag><tag>two</tag>'
print(re.findall(r'<tag>(.*?)</tag>', text))

import re

slug = re.sub(r'\s+', '-', '  soft aims  ').lower().strip('-')
print(slug)

import re

print(re.findall(r'[\w.-]+@[\w.-]+', 'contact [email protected] today'))

def shout(fn):
    def wrapper(*args, **kwargs):
        return fn(*args, **kwargs).upper()
    return wrapper

@shout
def greet(name: str) -> str:
    return f'hello {name}'

print(greet('team'))

def tag(label):
    def deco(fn):
        def wrapper(*args, **kwargs):
            return f'[{label}] ' + fn(*args, **kwargs)
        return wrapper
    return deco

@tag('api')
def ping():
    return 'pong'

print(ping())

import functools
import time

def timed(fn):
    @functools.wraps(fn)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        try:
            return fn(*args, **kwargs)
        finally:
            print(f'{fn.__name__} took {time.perf_counter() - start:.4f}s')
    return wrapper

def add_repr(cls):
    cls.__repr__ = lambda self: f'{cls.__name__}()'
    return cls

@add_repr
class Box:
    pass

print(Box())

def count_up(n: int):
    for i in range(n):
        yield i

print(list(count_up(3)))

def reader():
    yield 'line-a'
    yield 'line-b'

for line in reader():
    print(line.upper())

import asyncio
import time

async def main():
    await asyncio.gather(
        asyncio.sleep(0.1),
        asyncio.sleep(0.1),
    )

start = time.perf_counter()
asyncio.run(main())
print('elapsed', time.perf_counter() - start)

# asyncio for many waits; ProcessPoolExecutor for CPU-bound Python

import asyncio

async def worker(n: int) -> None:
    await asyncio.sleep(0.05)
    print('done', n)

async def main() -> None:
    await asyncio.gather(*(worker(i) for i in range(3)))

asyncio.run(main())

from concurrent.futures import ThreadPoolExecutor, as_completed

def fetch(url: str) -> str:
    return url

with ThreadPoolExecutor(max_workers=4) as pool:
    futs = [pool.submit(fetch, u) for u in ['a', 'b', 'c']]
    for fut in as_completed(futs):
        print(fut.result())

from multiprocessing import Pool

def work(x: int) -> int:
    return x * x

if __name__ == '__main__':
    with Pool(2) as pool:
        print(pool.map(work, range(4)))

# Profile first: threads can still help I/O-heavy apps under the GIL

from typing import Protocol

class Notifier(Protocol):
    def send(self, msg: str) -> None: ...

def alert(n: Notifier, msg: str) -> None:
    n.send(msg)

_cache: dict[str, object] = {}

def get_client(name: str) -> object:
    if name not in _cache:
        _cache[name] = object()
    return _cache[name]

def build_parser(kind: str):
    if kind == 'json':
        import json
        return json.loads
    raise ValueError(kind)

from typing import Callable

class Subject:
    def __init__(self) -> None:
        self._listeners: list[Callable[[str], None]] = []

    def subscribe(self, fn: Callable[[str], None]) -> None:
        self._listeners.append(fn)

    def notify(self, payload: str) -> None:
        for fn in list(self._listeners):
            fn(payload)

class Greeter:
    def __init__(self, clock):
        self._clock = clock

    def hello(self, name: str) -> str:
        return f'{self._clock.now().isoformat()} hi {name}'

from typing import Protocol

class Discount(Protocol):
    def apply(self, total: float) -> float: ...

def checkout(total: float, policy: Discount) -> float:
    return policy.apply(total)