Reference library

Python Code Samples

Copy-ready Python snippets by topic and difficulty — short, focused, and runnable in the browser editor.

9 matches
Functions & basics easy

Call a Function Dynamically by Name in Python

Use globals() to look up and call a function by its name as a string, with optional arguments.

globals dynamic-dispatch reflection
Python
def greet():
    return "Hello from greet!"

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

def multiply(a, b):
    return a * b

if __name__ == "__main__":
    func_name = "add"
    args = (3, 5)
    
    # Call function dynamically by name from globals
    result = globals()[func_name](*args)
    print(f"{func_name}({', '.join(ma…
13 0 Open
Functions & basics medium

How to Create a Counter Closure in Python

Build a closure in Python that remembers and increments a counter across calls without using global variables.

closures nonlocal state
Python
def create_counter(start=0):
    count = start
    def increment():
        nonlocal count
        count += 1
        return count
    return increment

if __name__ == "__main__":
    counter = create_counter(10)
    print(counter())
    print(counter())
    print(counter())
12 0 Open
Files & data easy

How to Compare Directory Trees in Python

This code recursively scans two directory trees and reports files that exist in only one directory, as well as files present in both but with different content.

filesystem comparison pathlib
Python
from pathlib import Path

def compare_directories(path1, path2):
    dir1 = Path(path1)
    dir2 = Path(path2)

    if not dir1.is_dir() or not dir2.is_dir():
        raise ValueError("Both paths must be directories.")

    files1 = {p.relative_to(dir1) for p in dir1.rglob("*") if p.is_file()}
    files2 = {p.relative…
11 0 Open
Files & data easy

How to List Files Matching a Glob Pattern in Python

Uses pathlib.Path.glob to find and sort all files matching a glob pattern like *.py in a directory.

glob pathlib filesystem
Python
from pathlib import Path

def list_files_matching(pattern: str, directory: str = ".") -> list[str]:
    """Return sorted list of file paths matching the glob pattern in a directory."""
    return sorted(Path(directory).glob(pattern))

if __name__ == "__main__":
    # Example: list all .py files in current directory
  …
12 0 Open
Automation & scripting medium

Create a Local Search Engine to Instantly Find Files on Your Computer in Python

Build a local file search engine in Python that indexes files by name, extension, and glob pattern for instant retrieval.

file search indexing os.walk
Python
import os
import sys
import time
from pathlib import Path
import fnmatch

class LocalSearchEngine:
    def __init__(self, root_directory="."):
        self.root_directory = Path(root_directory)
        self.file_index = {}
        
    def build_index(self):
        """Build a complete index of files in the root direc…
44 0 Open
Reliability & rate limiting medium

How to implement a rate-limited shared counter in Python

Implements a thread-safe global counter that allows a maximum number of increments per second using a lock and time-based refill.

rate-limiting threading global-counter
Python
import threading
import time
import random

counter = 0
lock = threading.Lock()
MAX_CALLS_PER_SECOND = 3
last_refill = time.time()

def rate_limited_increment():
    global counter, last_refill
    with lock:
        now = time.time()
        if now - last_refill >= 1.0:
            last_refill = now
            count…
12 0 Open
Big data & Spark medium

Accumulators Global Counter Mock in Python

Shows an accumulator-style global counter with a mock patch to control its value in tests.

accumulator global state mock
Python
import unittest
from unittest.mock import patch

# Module-level global counter accumulator
counter = 0

def increment(by=1):
    """Increment the global counter in place (accumulator pattern)."""
    global counter
    counter += by
    return counter

def reset():
    """Reset the counter to zero."""
    global count…
14 0 Open
A/B testing & experimentation easy

How to create a global control holdout group in Python

This code implements a deterministic global control holdout group, randomly selecting a fraction of users to be excluded from feature rollouts for experiment validation.

ab-testing holdout global-control
Python
import random

class GlobalControl:
    def __init__(self, population_size, holdout_fraction=0.2, seed=42):
        random.seed(seed)
        self.population_size = population_size
        self.holdout_fraction = holdout_fraction
        self.holdout_size = int(population_size * holdout_fraction)
        self.holdout_…
11 0 Open
Database scaling & optimization easy

How to Replicate Data Across All Shards in Python

Mocks a global table that replicates a key-value pair to every shard, ensuring reads return the same value from any shard.

sharding replication distributed systems
Python
from dataclasses import dataclass
from typing import Dict, List


@dataclass
class Shard:
    id: str
    data: Dict[str, int]


class GlobalTable:
    def __init__(self, shards: List[Shard]):
        self._shards = {s.id: s for s in shards}

    def set_value(self, key: str, value: int) -> None:
        """Replicate …
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.