Reference library

Python Code Samples

Easy snippets you can copy, study, and run in the browser editor.

32 matches
System design patterns easy

How to Mock Hexagonal Architecture Ports and Adapters in Python

Mock an email adapter in a hexagonal architecture with unittest.mock to test business logic in isolation.

hexagonal-architecture unittest-mock dependency-injection
Python
from unittest.mock import Mock

class EmailService:
    def send(self, recipient, message):
        raise NotImplementedError

class OrderProcessor:
    def __init__(self, email_service):
        self.email_service = email_service
    
    def process_order(self, order_id, customer_email):
        # Business logic
   …
15 0 Open
Caching & Redis easy

How to Implement Namespaced Cache Keys for Tenant Isolation in Python

Build a tenant-aware cache wrapper that prefixes keys with tenant and namespace, and test it with mocks.

cache tenant namespace
Python
from keyvaluestore import SimpleCache
from unittest.mock import patch

class TenantCache(SimpleCache):
    def __init__(self, tenant_id, namespace="default"):
        super().__init__()
        self.tenant_id = tenant_id
        self.namespace = namespace

    def _key(self, key):
        return f"tenant:{self.tenant_…
17 0 Open
ML engineering pipelines easy

Compare Model A vs Model B Metrics in Python

A script that simulates and compares metrics between two ML models, showing a formatted diff table for quick insight.

model comparison mock metrics
Python
import random


def compare_a_b(samples=5):
    """Mock comparison of model A vs model B predictions."""
    metrics = ["accuracy", "precision", "recall", "f1"]
    print(f"{'Metric':<12}{'Model A':>10}{'Model B':>10}{'Diff':>10}")
    print("-" * 42)

    random.seed(42)
    for metric in metrics:
        a = round(r…
14 0 Open
A/B testing & experimentation easy

Bonferroni Correction in Python

Applies the Bonferroni correction to a list of p-values to control the family-wise error rate when performing multiple comparisons.

statistics p-values multiple-comparisons
Python
import numpy as np

def bonferroni_correction(p_values, alpha=0.05):
    """Apply Bonferroni correction to a list of p-values."""
    n = len(p_values)
    corrected_alpha = alpha / n
    significant = [p < corrected_alpha for p in p_values]
    return corrected_alpha, significant

if __name__ == "__main__":
    # Moc…
16 0 Open
Database scaling & optimization easy

How to Count Star vs Estimate Matches in Python

Count how many times 'star' and 'estimate' annotations match their actual labels in a list of mock comparison results.

counting dictionary matching
Python
def count_star_vs_estimate(mock_scores):
    """
    Count the number of times 'star' wins and 'estimate' wins
    from a list of mock comparison results.

    Args:
        mock_scores: list of tuples, each (annotation, actual)
                     where annotation is 'star' or 'estimate'

    Returns:
        dict w…
12 0 Open
Database scaling & optimization easy

How to Mock Date Sharding by Range in Python

Split a date interval into fixed-size contiguous shards, returning each window as an ISO date string pair.

date datetime sharding
Python
from datetime import date, timedelta

def shard_ranges(start_date, end_date, shard_days=7):
    if start_date > end_date:
        raise ValueError("start_date cannot be after end_date")

    shards = []
    current = start_date
    while current <= end_date:
        shard_end = min(current + timedelta(days=shard_days …
13 0 Open
Auth & security at scale easy

How to Hash and Verify Passwords in Python

Hash passwords securely with PBKDF2-SHA256 and verify them using a constant-time comparison.

password-hashing security pbkdf2
Python
import hashlib
import hmac
import secrets
from typing import Tuple


def hash_password(password: str, salt: str = None) -> Tuple[str, str]:
    """Hash a password with a random salt using PBKDF2-SHA256."""
    salt = salt or secrets.token_hex(16)
    hashed = hashlib.pbkdf2_hmac(
        "sha256", password.encode("utf…
14 0 Open
Auth & security at scale easy

How to Salt Passwords per User in Python

Hash each user's password with a unique random salt using hashlib, and verify logins with timing-safe comparison.

password-hashing security authentication
Python
import hashlib
import secrets

def hash_password(password: str, salt: str | None = None) -> tuple[str, str]:
    """Hash a password with a random salt (or provided salt).

    Returns:
        (salt_hex, password_hash_hex)
    """
    if salt is None:
        salt = secrets.token_hex(16)
    salted = (salt + password)…
14 0 Open

Browse by section

Each section groups closely related Python snippets.

Guide: free Python code samples library

Copy-ready Python snippets for learners and developers

PythonSkillset code samples are short, focused examples organised by topic and difficulty. Every snippet is server-rendered HTML — readable by search engines and easy to copy. Open any sample, read the notes, copy the code, then press Try in editor to run it in the browser with Pyodide.

How to use this library

  1. Pick a topic section — strings, lists, files, functions, and more
  2. Open a sample, read How it works, and copy the code block
  3. Run it in the IDE, tweak values, then take a related quiz or tutorial lesson

Samples vs tutorials and challenges

Samples are quick reference — one concept per page. For step-by-step teaching, use our Python tutorials. To test yourself, try quizzes or coding challenges. Clean up style with the Python formatter.