Reference library

Python Code Samples

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

1466 matches
Testing & modern typing easy

How to Use the pytest tmp_path Fixture for Temporary Directories

Use pytest's built-in tmp_path fixture to create a unique temporary directory per test for clean file I/O testing.

pytest tmp_path fixtures
Python
import pytest


def test_write_and_read_file(tmp_path):
    # tmp_path is a pytest fixture that provides a temporary directory
    # unique to each test invocation
    data_file = tmp_path / "data.txt"
    data_file.write_text("hello world")
    assert data_file.read_text() == "hello world"


def test_multiple_tmp_pat…
19 0 Open
Testing & modern typing easy

How to Validate Dataclass Fields with Python Type Hints

A beginner-friendly helper that checks if instance attributes match their declared type hints using dataclasses and get_type_hints.

dataclasses type-hints validation
Python
from typing import Any, TypeVar, get_type_hints
from dataclasses import dataclass

T = TypeVar("T")

@dataclass
class User:
    name: str
    age: int
    email: str

def validate_fields(obj: Any) -> dict[str, bool]:
    """Check if object attributes match declared type hints."""
    hints = get_type_hints(obj.__class…
14 0 Open
Testing & modern typing easy

How to Verify Formatted Output with an Approval Test in Python

Write a small Python approval test that verifies a function's exact formatted output using unittest.

approval-testing unittest formatting
Python
import sys
from io import StringIO
import unittest

def generate_output(name, score):
    return f"Player: {name} | Score: {score:03d}"

class TestFormattedOutput(unittest.TestCase):
    def test_output_format(self):
        expected = "Player: Alice | Score: 042"
        result = generate_output("Alice", 42)
        …
15 0 Open
Testing & modern typing easy

How to Write a Contract Test with Mock in Python

Use unittest.mock to verify a consumer's expectations match the provider's response shape in a Python contract test.

contract-testing unittest mock
Python
from unittest.mock import Mock

# Contract test: verify consumer expects data shape that provider delivers.
# We mock the provider and assert the consumer's calls match the agreed contract.

def fetch_user(provider_client, user_id):
    """Consumer code: expects provider to return {'id', 'name', 'email'}."""
    respo…
16 0 Open
Testing & modern typing easy

How to Write a Fast Smoke Test for a Critical Path in Python

A quick smoke test that validates the /health critical path executes fast enough, raising errors on wrong paths or slow responses.

smoke-test performance health-check
Python
import time

def smoke_test(path):
    if path != "/health":
        raise ValueError("Critical path expected /health")
    start = time.perf_counter()
    # Simulate the critical health check work
    time.sleep(0.01)
    elapsed = time.perf_counter() - start
    if elapsed > 0.05:
        raise RuntimeError("Health …
15 0 Open
Testing & modern typing easy

How to Write a pytest Test Function with assert Equal in Python

Define simple pytest test functions that use assert to verify result equality and run them with pytest.main.

pytest unit testing assert
Python
import pytest

def add(a, b):
    return a + b

def test_add_positive_numbers():
    result = add(2, 3)
    assert result == 5

def test_add_negative_numbers():
    result = add(-2, -3)
    assert result == -5

def test_add_mixed_numbers():
    result = add(2, -3)
    assert result == -1

if __name__ == "__main__":
  …
13 0 Open
Testing & modern typing easy

How to Write pytest Test Function Assert Equal in Python

Write three pytest test functions that assert the result of an add() function equals an expected numeric value.

pytest assert testing
Python
import pytest

def add(a, b):
    return a + b

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

def test_add_negative_numbers():
    assert add(-1, -2) == -3

def test_add_mixed_numbers():
    assert add(5, -3) == 2

if __name__ == "__main__":
    pytest.main([__file__, "-v"])
15 0 Open
Testing & modern typing easy

How to freeze time in Python tests with freezegun

Use the freezegun decorator to freeze datetime.now() at a fixed timestamp so tests that depend on current time run deterministically.

freezegun datetime testing
Python
from datetime import datetime
from freezegun import freeze_time


@freeze_time("2024-01-15 12:30:00")
def test_frozen_time():
    now = datetime.now()
    return now


if __name__ == "__main__":
    result = test_frozen_time()
    print(result)
17 0 Open
Testing & modern typing easy

How to mark known bugs with pytest xfail in Python

Use @pytest.mark.xfail to mark tests that are expected to fail due to known bugs, with optional strict mode to control pass/fail behavior.

pytest testing xfail
Python
import pytest


def divide(a: int, b: int) -> float:
    if b == 0:
        raise ZeroDivisionError("Cannot divide by zero")
    return a / b


@pytest.mark.xfail(reason="Known bug: division returns int instead of float", strict=False)
def test_divide_integer_division():
    result = divide(10, 4)
    assert isinstanc…
20 0 Open
Testing & modern typing easy

How to use Optional type hint in Python

Use the Optional type hint to indicate a parameter can be a string or None, with an example function that handles both cases.

typing optional type-hints
Python
from typing import Optional

def greet(name: Optional[str]) -> str:
    if name is None:
        return "Hello, anonymous!"
    else:
        return f"Hello, {name}!"

if __name__ == "__main__":
    print(greet("Alice"))
    print(greet(None))
12 0 Open
Testing & modern typing easy

How to use unittest mock side_effect with a sequence in Python

Demonstrates using Mock.side_effect with a list to return different values per call and raise an exception at a specific call in unittest.

unittest mock side_effect
Python
import unittest
from unittest.mock import Mock

class TestMockSideEffectSequence(unittest.TestCase):
    def test_side_effect_sequence(self):
        mock = Mock()
        mock.side_effect = [1, 2, 3, Exception("boom")]
        
        self.assertEqual(mock(), 1)
        self.assertEqual(mock(), 2)
        self.asser…
15 0 Open
Testing & modern typing easy

Interface Segregation with Fake Test Implementations in Python

Defines segregated abstract interfaces (Printer, Scanner) and uses a FakePrinter to record calls for unit testing without real resources.

abc interface-segregation testing
Python
from abc import ABC, abstractmethod


class Printer(ABC):
    @abstractmethod
    def print_document(self, doc: str) -> str:
        pass


class Scanner(ABC):
    @abstractmethod
    def scan_document(self) -> str:
        pass


class MultiFunctionPrinter(Printer, Scanner):
    def print_document(self, doc: str) -> …
15 0 Open
Testing & modern typing easy

Mock datetime with time-machine in Python

Use the time-machine library to travel to a fixed datetime when running tests or scripts, mocking datetime.utcnow().

testing datetime mock
Python
from time_machine import travel
from datetime import datetime


@travel("2020-01-01 10:30:00")
def check_date():
    return datetime.utcnow()


if __name__ == "__main__":
    print(check_date())
17 0 Open
Testing & modern typing easy

Mock datetime.now to freeze time in Python

Use unittest.mock.patch to replace datetime.now with a fixed value so your code always sees the same time during tests.

datetime mock unittest
Python
from datetime import datetime
from unittest.mock import patch

def current_message():
    now = datetime.now()
    return f"Current time: {now:%Y-%m-%d %H:%M:%S}"

if __name__ == "__main__":
    with patch("__main__.datetime") as mock_dt:
        mock_dt.now.return_value = datetime(2024, 3, 15, 10, 30, 0)
        prin…
15 0 Open
Testing & modern typing easy

NamedTuple typed record in Python

Define a lightweight immutable record with type hints using typing.NamedTuple; access fields by name and unpack like a tuple.

namedtuple typing records
Python
from typing import NamedTuple


class Point(NamedTuple):
    x: float
    y: float
    label: str = "origin"


if __name__ == "__main__":
    p = Point(3.5, -2.0, "A")
    print(p)
    print(f"x={p.x}, y={p.y}, label={p.label}")
    print("is tuple:", isinstance(p, tuple))

    q = Point(1.0, 1.0)
    print(q)

    # …
16 0 Open
Testing & modern typing easy

Table-Driven Tests in Python (unittest)

Run a single unittest test against many input cases using a list of tuples and subTest.

unittest table-driven testing
Python
import unittest

def add(a, b):
    return a + b

class TestAddFunction(unittest.TestCase):

    def test_add_with_table(self):
        cases = [
            (1, 2, 3),
            (-1, 1, 0),
            (0, 0, 0),
            (2, -3, -1),
        ]
        for x, y, expected in cases:
            with self.subTest(x…
16 0 Open
System design patterns easy

Builder pattern for mocking complex objects in Python

Use a fluent Builder to construct realistic mock objects with defaults, enabling readable test data setup.

builder-pattern mock-data testing
Python
class User:
    def __init__(self):
        self.name = "default"
        self.age = 0
        self.email = "unknown@example.com"
        self.address = "unknown"

    def __repr__(self):
        return f"User(name={self.name!r}, age={self.age}, email={self.email!r}, address={self.address!r})"


class UserBuilder:
   …
22 0 Open
System design patterns easy

Create a Data Helper Class in Python

A reusable DataHelper class that saves and loads JSON and CSV files from a configurable base directory, with automatic header detection for CSV.

data-helper json csv
Python
import json
import csv
from pathlib import Path

class DataHelper:
    def __init__(self, base_path="."):
        self.base_path = Path(base_path)
        self.base_path.mkdir(exist_ok=True)

    def save_json(self, data, filename):
        path = self.base_path / filename
        with open(path, "w") as f:
          …
20 0 Open
System design patterns easy

How to Aggregate Mock API Routes by Method in Python

Groups mock API routes by path and method, collecting response bodies and counts into a nested dictionary structure.

defaultdict api-gateway aggregation
Python
from collections import defaultdict


def aggregate_mock_routes(routes):
    """Aggregate mock API routes by method and aggregate their response bodies."""
    aggregated = defaultdict(lambda: defaultdict(list))

    for route in routes:
        method = route["method"]
        path = route["path"]
        response = …
16 0 Open
System design patterns easy

How to Build a Health Check System with Instance Up and Down Status in Python

Track instance health by marking them up or down and simulating health checks with a mock class in Python.

health-check monitoring system-design
Python
from datetime import datetime
import random

class HealthChecker:
    def __init__(self):
        self.status = {}
    
    def mark_up(self, instance_id):
        self.status[instance_id] = {
            "state": "up",
            "last_check": datetime.now().isoformat(),
            "healthy": True
        }
    
  …
15 0 Open
System design patterns easy

How to Build a Simple Service Discovery Registry in Python

A lightweight in-memory service registry class using a dict — register, deregister, and discover services with host, port, and version.

service-discovery registry dict
Python
class ServiceRegistry:
    def __init__(self):
        self._services = {}

    def register(self, name, host, port, version="1.0"):
        self._services[name] = {
            "host": host,
            "port": port,
            "version": version
        }

    def deregister(self, name):
        return self._servic…
16 0 Open
System design patterns easy

How to Build a Weighted Random Load Balancer in Python

A Python load balancer mock that distributes requests across servers based on configurable weights using a cumulative weighted random selection algorithm.

python how build
Python
import random
from collections import Counter

SERVERS = {
    "server-a": 50,
    "server-b": 30,
    "server-c": 20,
}


def weighted_random_server(servers: dict[str, int]) -> str:
    """Select a server based on its weight (higher weight = more likely)."""
    total_weight = sum(servers.values())
    rand = random.…
16 0 Open
System design patterns easy

How to Build an Append-Only Event Store in Python

Implement a simple append-only event store class that stores events in a list and supports retrieval by index range.

event-sourcing append-only event-store
Python
class EventStore:
    def __init__(self):
        self._events = []

    def append(self, event):
        """Append an event to the store."""
        self._events.append(event)

    def get_events(self, start=0, end=None):
        """Return events from start index to end (exclusive)."""
        return self._events[sta…
14 0 Open
System design patterns easy

How to Build an MVP Presenter View Mock in Python

A minimal MVP (Model-View-Presenter) mock showing a Presenter controlling a SlideDeck model with slide navigation and typed state via dataclasses.

dataclasses mvp design-patterns
Python
from dataclasses import dataclass, field
from typing import List


@dataclass
class SlideDeck:
    title: str
    slides: List[str] = field(default_factory=list)
    current_index: int = 0

    def next_slide(self) -> str:
        if self.current_index < len(self.slides) - 1:
            self.current_index += 1
      …
15 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.