A · Backend Web, APIs and SaaS Flask application patterns Routing templates blueprints and application factories Request and response lifecycles Validation and error pages Testing and deployment FastAPI and asynchronous APIs Pydantic request schemas Dependency injection Async endpoints and sync boundaries OpenAPI and background tasks Django full-stack fundamentals Models views templates and forms Admin site and ORM Migrations and permissions Authentication and deployment API security and client contracts JWT versus sessions CSRF CORS and rate limits Request schema evolution Consumer-driven contract testing SaaS architecture Tenant separation basics Billing boundary design without live charging Subscription status and feature flags Audit and lifecycle management Deployment and operations Reverse proxies and application servers Managed Postgres and migrations HTTPS secrets and observability Safe rollout and backups Career-track capstone: {H(info.get("capstone", "Build and test a real application."))}
Working track demonstration Python · runnable
PYTHON CODE Copy code
def api_list_courses(courses, page=1, size=2):
start = (page - 1) * size
return {'items': courses[start:start + size], 'page': page}
print(api_list_courses(['HTML', 'Python', 'SQL'], page=2))Verified execution ▼
{'items': ['SQL'], 'page': 2} Why it works: Review the result and explain what was calculated.
B · Data Analysis, Visualization and Decision NumPy foundations Arrays shapes broadcasting and dtypes Vectorization and numerical pitfalls Indexing masking and aggregation Memory layout Pandas for tabular data Series DataFrame and indexing CSV Excel SQL and Parquet Joining grouping and reshaping Missing data handling Exploratory data analysis Distributions and outliers Data quality profiling Correlation versus causation Reproducible notebooks Statistics for Python analysts Summary statistics and sampling Confidence intervals Hypothesis tests and effect sizes Practical interpretation and uncertainty Data visualization Matplotlib plots and annotations Plotly interactive outputs Chart selection and accessible visuals Avoiding misleading axes Reporting and reproducibility Notebook to script workflows Parameterized pipelines Data dictionaries Validation and exports Career-track capstone: {H(info.get("capstone", "Build and test a real application."))}
Working track demonstration Python · runnable
PYTHON CODE Copy code
rows = [{'month': 'Jan', 'sales': 10}, {'month': 'Feb', 'sales': 15}]
print('Total:', sum(row['sales'] for row in rows))
print('Months:', [row['month'] for row in rows])Verified execution ▼
Total: 25
Months: ['Jan', 'Feb'] Why it works: Review the result and explain what was calculated.
C · Machine Learning, AI and LLM Applications Mathematics for ML Vectors matrices and gradients Probability distributions Optimization intuition Evaluation metrics Scikit-learn pipelines Train validation test splits Feature engineering and encoding Pipelines and cross-validation Hyperparameter search Deep learning with PyTorch Tensors autograd and modules Training loops and optimizers Regularization and evaluation GPU and reproducibility concerns Working with language models Tokenization embeddings and context limits Prompting and structured responses Retrieval-augmented generation Tool calls and safety boundaries AI reliability and evaluation Benchmarks and test datasets Hallucinations and groundedness Bias privacy and prompt injection Monitoring costs latency and errors Serving and MLOps Model serialization and provenance Batch versus online inference Drift monitoring and retraining Security and rollback Career-track capstone: {H(info.get("capstone", "Build and test a real application."))}
Working track demonstration Python · runnable
PYTHON CODE Copy code
observations = [(1, 2), (2, 4), (3, 6)]
predicted = [2 * x for x, _ in observations]
error = sum(abs(y - p) for (_, y), p in zip(observations, predicted))
print('Absolute error:', error)Verified execution ▼
Absolute error: 0 Why it works: Review the result and explain what was calculated.
D · Data Engineering and Streaming Pipelines ETL and ELT design Source extraction and incremental loads Schema contracts and validation Transform orchestration Data lineage Relational and analytical stores OLTP versus OLAP PostgreSQL and warehouse concepts Partitioning and indexes Query optimization Columnar formats and Arrow Parquet and Arrow concepts Partition pruning DuckDB query workflows Data interoperability Pipelines and orchestration DAGs dependencies and retries Airflow or Prefect concepts Scheduling and backfills Idempotency Streaming and messaging Kafka concepts and consumer groups Event time versus processing time Ordering deduplication and offsets Backpressure Data quality and operations Schema drift detection Freshness and completeness checks Observability and incident response Privacy and retention Career-track capstone: {H(info.get("capstone", "Build and test a real application."))}
Working track demonstration Python · runnable
PYTHON CODE Copy code
events = [{'id': 1, 'value': 8}, {'id': 2, 'value': 5}, {'id': 1, 'value': 8}]
unique = {event['id']: event for event in events}
print('Unique events:', len(unique))Verified execution ▼
Unique events: 2 Why it works: Review the result and explain what was calculated.
E · Automation, Scraping and Workflow Local file and office automation Folder watchers and scheduled jobs CSV Excel and PDF manipulation Naming and audit logs Safe batch operation Browser and web automation Selenium and Playwright concepts Selectors waits and sessions Flaky UI handling Consent and terms compliance Web scraping responsibly robots.txt and site rules Requests parsers and pagination Polite throttling and caching Extraction validation Email and service automation SMTP and IMAP concepts API-based integrations Templates and attachment checks Idempotency and dry-run support Schedulers and desktop workflows Cron and task scheduling Retry and escalation rules OS notifications Operator review steps Reliable RPA architecture Configurable tasks and logs Secrets management Failure screenshots and alerts Human-in-the-loop approvals Career-track capstone: {H(info.get("capstone", "Build and test a real application."))}
Working track demonstration Python · runnable
PYTHON CODE Copy code
files = ['invoice_1.pdf', 'photo.png', 'invoice_2.pdf']
matches = [name for name in files if name.endswith('.pdf')]
print('Documents:', matches)Verified execution ▼
Documents: ['invoice_1.pdf', 'invoice_2.pdf'] Why it works: Review the result and explain what was calculated.
F · Scientific, Numerical and Quantitative Python Numerical foundations Floating-point error and tolerances Vectorization and broadcasting Linear algebra and decomposition Stability and conditioning SciPy methods Optimization and root finding Integration and interpolation Signal processing fundamentals Statistical distributions Symbolic and precise mathematics SymPy expressions Symbolic differentiation Decimal fractions and exact values Expression simplification Simulation and stochastic models Random number generators and seeds Monte Carlo estimation Discrete event concepts Simulation validation Research software practices Reproducibility and environments Parameter sweeps and profiling Plotting and reporting Data and result provenance Quantitative applications Time series processing Scenario analysis Model assumptions and sensitivity Ethical interpretation of outputs Career-track capstone: {H(info.get("capstone", "Build and test a real application."))}
Working track demonstration Python · runnable
PYTHON CODE Copy code
velocity = 3.0
distance = 0.0
for second in range(4):
distance += velocity
print('Distance:', distance)Verified execution ▼
Distance: 12.0 Why it works: Review the result and explain what was calculated.
G · Cloud Infrastructure, DevOps and Platform Linux service operations Shell integration and processes Service logs and permissions Filesystem quotas and networking Repeatable operations Infrastructure automation SDK and CLI concepts Terraform and configuration management basics Idempotent infrastructure scripts State and secrets CI CD pipelines Lint test build and release stages Secure credentials and artifact signing Caching and matrix tests Rollbacks Container orchestration Docker image construction Compose local stacks Kubernetes resources overview Readiness probes and scaling Cloud reliability and cost Storage queues and managed databases SLOs and autoscaling Cost tagging and budgets Backups and region failure planning Platform engineering Developer self-service templates Configuration standards Secret rotation Observability automation and runbooks Career-track capstone: {H(info.get("capstone", "Build and test a real application."))}
Working track demonstration Python · runnable
PYTHON CODE Copy code
environment = {'debug': False, 'replicas': 2}
if environment['debug']:
print('Not production ready')
else:
print('Production setting confirmed')Verified execution ▼
Production setting confirmed Why it works: Review the result and explain what was calculated.
H · Defensive Cybersecurity and Secure Python Security foundations for developers Assets threats and trust boundaries Authentication and authorization Encryption concepts and secure transport Responsible scope and authorization Secure coding patterns Input handling and injection prevention Path traversal and unsafe deserialization Secret handling and logging Dependency vulnerability review Network visibility and diagnostics Socket-based connectivity checks DNS and TLS inspection Packet structure at a high level Rate and scope limitations Log analysis and anomaly detection Parsing timestamps and events Baselines and thresholds False positives and data privacy Reporting and triage Security automation and compliance Inventory and patch status File-integrity monitoring Configuration linting Evidence collection and audit trails Incident response and recovery Detection containment and documentation Forensic preservation basics Secrets rotation Post-incident lessons Career-track capstone: {H(info.get("capstone", "Build and test a real application."))}
Working track demonstration Python · runnable
PYTHON CODE Copy code
logins = [('alice', False), ('bob', True), ('alice', False)]
failures = sum(not passed for _, passed in logins)
print('Failed logins:', failures)Verified execution ▼
Failed logins: 2 Why it works: Review the result and explain what was calculated.
I · Desktop Applications, GUIs and Developer Tools CLI product design argparse Typer or Click Clear commands help and errors Configuration and profiles Cross-platform behavior Terminal user interfaces rich text and progress display Textual framework concepts Keyboard interactions Accessibility and state management Desktop GUI fundamentals Event loops callbacks and widgets Tkinter as a baseline Layout and user feedback Separating UI from business logic Advanced desktop architecture PySide or PyQt options Signals slots and threading State and persistence Packaging and OS dialogs Distribution and updates Wheels versus standalone executables PyInstaller concepts Signing and platform variation Crash logs and upgrade paths Usability testing and accessibility Keyboard-only workflows Validation and error messages Responsive resizing User testing and feedback loops Career-track capstone: {H(info.get("capstone", "Build and test a real application."))}
Working track demonstration Python · runnable
PYTHON CODE Copy code
class Preferences:
def __init__(self):
self.theme = 'light'
def toggle(self):
self.theme = 'dark' if self.theme == 'light' else 'light'
settings = Preferences()
settings.toggle()
print(settings.theme)Verified execution ▼
dark Why it works: Review the result and explain what was calculated.
J · Robotics, Electronics and IoT with Python Electricity and electronics readiness Voltage current and resistance Breadboards and components Microcontroller versus single-board computer Power and battery safety MicroPython fundamentals Supported board selection GPIO digital inputs and outputs Timing and memory limits Device flashing and serial console Sensors actuators and control Analog-to-digital conversion I2C SPI and UART PWM for motors and servos Noise calibration and feedback Raspberry Pi and edge Python Linux GPIO libraries and permissions Camera and sensor inputs Processes and startup Network-connected edge apps Robotics foundations Robot coordinate systems Kinematics and state estimation basics PID control intuition Simulation-first testing IoT connectivity and safety MQTT and message schemas Local network security Firmware updates and logging Physical emergency stop and failsafes Career-track capstone: {H(info.get("capstone", "Build and test a real application."))}
Working track demonstration Python · runnable
PYTHON CODE Copy code
distance_cm = 12
if distance_cm < 15:
motor_command = 'STOP'
else:
motor_command = 'FORWARD'
print('Motor:', motor_command)Verified execution ▼
Motor: STOP Why it works: Review the result and explain what was calculated.
K · Games, Graphics and Interactive Simulations Game loop and event processing Frames input and update cycles Delta time and fixed timesteps State machines Collision concepts Pygame fundamentals Surfaces sprites and groups Keyboard and mouse input Sound and asset management Menus and scene changes 2D mechanics and physics Position velocity and acceleration Collision resolution Particle effects Simple AI behaviors Procedural systems Random generation and reproducibility Grid and tile maps Pathfinding and enemies Difficulty tuning Educational game design Learning objectives and feedback Accessible controls Saving progress Fair difficulty and testing Testing and packaging games Deterministic logic tests Performance profiling Asset licensing and attribution Cross-platform distributions Career-track capstone: {H(info.get("capstone", "Build and test a real application."))}
Working track demonstration Python · runnable
PYTHON CODE Copy code
player = {'x': 2, 'y': 3}
move = (1, -1)
player['x'] += move[0]
player['y'] += move[1]
print('Position:', player)Verified execution ▼
Position: {'x': 3, 'y': 2} Why it works: Review the result and explain what was calculated.
L · Testing Frameworks, Python Tooling and Advanced pytest infrastructure Fixture scope and dependency graphs Plugins and hooks Parameterization patterns Parallel execution considerations Property-based and fuzz testing Hypothesis strategies Invariants and shrinking Stateful model testing Input boundary analysis Static analysis and type tooling AST inspection and transformation Ruff rule concepts Type-checker extensions overview False-positive management Build backends and packaging PEP 517 518 and 621 concepts Build tools and source distributions Editable installs and wheels Reproducible package metadata Documentation and API stewardship Semantic versioning and changelogs Deprecation guides Reference docs and examples Contributor support workflows Maintaining trusted open source License obligations Vulnerability disclosure Dependency update automation Long-term compatibility policy Each lesson should be complete enough to teach its listed objectives; do not inflate word count with For the planned website edition, target at least 1,200 meaningful words per full chapter where the topic Use exact commands for macOS, Windows, and Linux where they differ. Explain what the learner should Mark optional libraries, operating-system dependencies, paid services, hardware prerequisites, and Every code example should have a tested Python compatibility range and an expected result; avoid saying Use original prose, original illustrations and projects, and properly acknowledge any third-party assets or Build accessible, mobile-friendly diagrams for abstract concepts: references, control flow, stack traces, Foundation portfolio: a CLI study planner, file organizer, and tested expense tracker. Engineering portfolio: a typed package, SQL-backed service, authenticated API, and automated CI test Advanced portfolio: a profiled concurrent ingester, monitored production-style service, and system-design Specialization portfolio: at least one substantial elective capstone aligned to the learner's desired career. Final evaluation: code quality, reproducibility, reliability, security, documentation, testing, and clarity of Career-track capstone: {H(info.get("capstone", "Build and test a real application."))}
Working track demonstration Python · runnable
PYTHON CODE Copy code
def slug(text):
return '-'.join(text.lower().split())
assert slug('Learn Python Today') == 'learn-python-today'
print(slug('Clear Helpful Tools'))Verified execution ▼
clear-helpful-tools Why it works: Review the result and explain what was calculated.
