Python Code
Samples
Copy-ready Python snippets by topic and difficulty — short, focused, and runnable in the browser editor.
Rebalance Shard Ranges Across Nodes in Python
A mock rebalancing function that shuffles shard ranges and distributes them evenly across nodes using round-robin assignment.
import random
from dataclasses import dataclass
@dataclass
class Shard:
id: int
start: int
end: int
def rebalance_shards(shards: list[Shard], node_count: int) -> dict[int, list[Shard]]:
"""Mock rebalancing of shard ranges across nodes."""
all_ranges = [(s.start, s.end) for s in shards]
random…Simulate PostgreSQL Vacuum to Reclaim Space in Python
A Python class that safely rewrites a data file to remove deleted rows and reclaim physical space, mimicking PostgreSQL's VACUUM operation.
import shutil
import os
class VacuumCleaner:
"""Simulates PostgreSQL-style vacuum reclaiming dead space in a file."""
def __init__(self, filepath, fill_ratio=0.7, dead_marker="[DELETED]"):
self.filepath = filepath
self.fill_ratio = fill_ratio
self.dead_marker = dead_marker
…How to Hash Passwords and Authenticate Users in Python
A beginner-friendly dataclass-based design that hashes passwords with PBKDF2 and verifies them securely using constant-time comparisons.
import hashlib
import hmac
import secrets
from dataclasses import dataclass
from typing import Optional
@dataclass
class User:
id: int
username: str
password_hash: str
salt: str
def hash_password(password: str) -> tuple[str, str]:
salt = secrets.token_hex(16)
password_hash = hashlib.pbkdf2_…How to Implement a CSRF Token Double Submit Mock in Python
A mock CSRF protection class that generates and validates double-submit tokens using HMAC-SHA256 with a secret key.
import hmac
import hashlib
import secrets
class CSRFProtection:
def __init__(self, secret_key: str):
self.secret_key = secret_key.encode("utf-8")
def generate_token(self) -> str:
random_value = secrets.token_hex(16)
signature = hmac.new(
self.secret_key, random_value.enco…How to Implement a Vault Dynamic Database Credentials Mock in Python
A Python dataclass-based mock of HashiCorp Vault that issues short-lived database credentials, tracks leases, and revokes them, demonstrating dynamic secrets rotation.
import time
import json
from dataclasses import dataclass, field
from typing import Dict
@dataclass
class DynamicCredential:
username: str
password: str
lease_duration: int
created_at: float = field(default_factory=time.time)
def is_valid(self) -> bool:
return time.time() - self.created_…How to Mock a Permissions Policy in Python
A lightweight Python class that simulates a browser Permissions-Policy header by tracking allowed/ denied feature permissions with get, set, reset, and bulk operations.
class PermissionsPolicy:
def __init__(self):
self._features = {
"geolocation": "self",
"camera": "self",
"microphone": "self",
"payment": "self",
"usb": "self",
}
def get_feature_policy(self, feature):
return self._features.ge…How to Mock a Redis Session Store in Python
An in-memory RedisSessionStore class with TTL-based expiry, get/set/delete/exists methods, and JSON field support—perfect for testing and prototyping without a live Redis.
import time
import json
from collections import defaultdict
class RedisSessionStore:
"""In-memory mock of a Redis-backed session store."""
def __init__(self, ttl=3600):
self._data = defaultdict(dict)
self._expires = {}
self._ttl = ttl
def set(self, session_id, field, value):
…How to Mock a TLS Certificate Rotation Schedule in Python
Simulate a TLS certificate rotation schedule with a Python class that tracks last and next rotation dates and decides when to rotate.
import datetime
import random
import time
class CertRotator:
def __init__(self, cert_name, rotation_days=30):
self.cert_name = cert_name
self.rotation_days = rotation_days
self.last_rotated = datetime.date.today() - datetime.timedelta(days=random.randint(10, 25))
self.next_rotatio…How to Revoke Tokens with a Blacklist Set in Python
A minimal TokenBlacklist class using a Python set to revoke, batch-revoke, check, and remove expired tokens for simple token invalidation.
import time
class TokenBlacklist:
def __init__(self):
self.blacklisted_tokens = set()
def revoke(self, token):
self.blacklisted_tokens.add(token)
print(f"Token {token} revoked. Blacklist size: {len(self.blacklisted_tokens)}")
def revoke_batch(self, tokens):
before = len(s…How to Set a SameSite Cookie in Python
Set a SameSite cookie attribute in Python using the standard library's SimpleCookie class.
from http.cookies import SimpleCookie
def set_same_site_cookie(name, value, same_site="Lax"):
cookie = SimpleCookie()
cookie[name] = value
cookie[name]["path"] = "/"
cookie[name]["samesite"] = same_site
return cookie[name].OutputString()
if __name__ == "__main__":
print(set_same_site_cookie("…How to redact secrets from log messages in Python
This code defines a logging.Filter subclass that automatically redacts sensitive keys like password, token, and API key from any dict logged.
import logging
from dataclasses import dataclass
@dataclass
class ApiResponse:
status: int
body: dict
class SecretRedactor(logging.Filter):
SENSITIVE_KEYS = {"password", "token", "secret", "api_key"}
def filter(self, record: logging.LogRecord) -> bool:
if isinstance(record.msg, dict):
…Design a Data Helper for Beginners in Python
Build a beginner-friendly DataHelper class that loads, saves, appends, and summarizes JSON data with atomic file writes.
import json
from datetime import datetime
from pathlib import Path
class DataHelper:
"""A beginner-friendly helper for common data operations."""
def __init__(self, data=None, filepath=None):
self.data = data if data is not None else []
self.filepath = Path(filepath) if filepath else None
…How to Build a Data Helper for Production Deployment in Python
Build a reusable DataHelper class that loads configs, validates required keys, normalizes string values, and logs schema details — a production-ready data processing pattern.
import json
from pathlib import Path
from typing import Any, Dict
class DataHelper:
"""Common data processing patterns for production deployment."""
def __init__(self, config_path: str | Path):
self.config_path = Path(config_path)
self.config = self._load_config()
def _load_confi…How to Build a GitOps Argo CD Sync Mock in Python
Simulate Argo CD-style GitOps deployment sync with Python dataclasses, random success rates, and force-sync retry logic.
import random
import time
from dataclasses import dataclass, field
from typing import List, Dict
@dataclass
class Application:
name: str
source_repo: str
target_revision: str
synced: bool = False
health_status: str = "Healthy"
history: List[Dict] = field(default_factory=list)
def sync(se…How to Build a Simple Data Helper Class in Python
A beginner-friendly DataHelper class that safely saves and loads JSON files with automatic directory creation, perfect for production-style file handling.
from pathlib import Path
import json
class DataHelper:
"""Simple production-style helper for loading and saving JSON data."""
def __init__(self, data_dir="data"):
self.data_dir = Path(data_dir)
self.data_dir.mkdir(exist_ok=True)
def save(self, filename, data):
filepath = self.da…How to Build a Simple Data Helper Class in Python
A beginner-friendly DataHelper class that stores Python dataclass objects as JSON records to disk, with load, add, and save methods.
import json
from dataclasses import dataclass, asdict
from pathlib import Path
@dataclass
class User:
name: str
age: int
email: str
class DataHelper:
def __init__(self, filepath: str = "data.json"):
self.filepath = Path(filepath)
self._data = self._load()
def _load(self) -> l…How to Build a Synthetic Monitor Mock in Python
Simulates a synthetic monitoring system in Python that collects latency samples, averages them, and reports service status as UP or DEGRADED.
import random
import time
from dataclasses import dataclass, field
from statistics import mean
@dataclass
class SyntheticMonitor:
service: str
endpoint: str
latency_ms: list[float] = field(default_factory=list)
def check(self) -> float:
latency = random.uniform(50.0, 250.0)
self.late…How to Implement a Data Helper Class in Python for Production Deployments
Build an environment-aware data helper in Python that loads config, extracts, transforms, and reports on JSON data using small, testable functions.
"""Production-style data helper for beginners.
Demonstrates:
- environment-aware config
- central data extraction
- small, testable functions
"""
import os
import json
from pathlib import Path
from typing import List, Dict, Any
def load_config(env: str = os.getenv("APP_ENV", "development")) -> Dict[str, Any]:
…How to Mock Docker Image Non-Root User in Python
This Python class simulates Docker image layers and inspects whether the final user is a non-root user, returning UID, GID, and security status.
from pathlib import Path
class DockerImageMock:
def __init__(self, name, tag):
self.name = name
self.tag = tag
self.layers = []
self.user = "root"
def add_file(self, path, content):
self.layers.append({"file": path, "content": content})
def set_user(self, usernam…How to Mock Kubernetes Services with a ClusterIP Registry in Python
Simulate Kubernetes service discovery by assigning ClusterIP addresses to dataclass-defined services, with JSON export for inspection or testing.
import json
from dataclasses import dataclass, asdict
from typing import Dict, Optional
@dataclass
class Service:
name: str
namespace: str
cluster_ip: str
selector: Dict[str, str]
port: int
target_port: Optional[int] = None
class ClusterIPServiceRegistry:
_ip_counter = 0
def __init…How to Mock Multi-Stage Docker Builds in Python
Simulate a multi-stage Docker build in pure Python using classes and temp directories to understand how build stages copy artifacts into a final image.
# Simulate multi-stage Docker build with pure Python
from pathlib import Path
import tempfile
import shutil
class BuildContext:
"""Mimics a Docker build context with stages."""
def __init__(self, name):
self.name = name
self.files = {}
def add_file(self, dest, content):
s…How to Mock a CI Pipeline with Build, Test, and Deploy Stages in Python
Simulate a three-stage CI pipeline (build, test, deploy) in Python with random pass/fail logic, early exit on failure, and measured stage durations.
import time
import random
from dataclasses import dataclass
@dataclass
class StageResult:
name: str
status: str
duration: float
def run_stage(name: str, success_chance: float = 0.9) -> StageResult:
"""Simulate a pipeline stage with random success/failure."""
start = time.time()
time.sleep(r…How to Mock a Dockerfile Multi-Stage Build in Python
Simulate a Dockerfile multi-stage build process in Python using dataclasses to validate stage ordering and file availability before you write the real Dockerfile.
from dataclasses import dataclass
from pathlib import Path
@dataclass
class BuildStage:
name: str
base_image: str
files: list[str]
commands: list[str]
def run_build(stage: BuildStage, context_dir: Path):
print(f"=== Stage: {stage.name} (base: {stage.base_image}) ===")
for file in stage.file…How to Mock a Feature Flag Rollout Percentage in Python
Simulate a percentage-based feature flag rollout by hashing a user ID to deterministically enable features for a subset of users.
import random
from dataclasses import dataclass
@dataclass
class FeatureFlag:
name: str
rollout_percentage: int
def is_feature_enabled(feature_flag: FeatureFlag, user_id: str) -> bool:
hashed_id = hash(user_id) % 100
return hashed_id < feature_flag.rollout_percentage
if __name__ == "__main__":
…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
- Pick a topic section — strings, lists, files, functions, and more
- Open a sample, read How it works, and copy the code block
- 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.