Reference library

Python Code Samples

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

1466 matches
OOP & classes easy

How to Implement a Stack Class in Python

A complete Stack class implemented with a Python list, featuring push, pop, peek, is_empty, size, and a readable string representation.

oop stack data-structures
Python
class Stack:
    def __init__(self):
        self._items = []

    def push(self, item):
        """Add an item to the top of the stack."""
        self._items.append(item)

    def pop(self):
        """Remove and return the top item. Raises IndexError if empty."""
        if self.is_empty():
            raise IndexE…
14 0 Open
OOP & classes easy

How to Implement the Decorator Pattern in Python to Add Behavior

This Python code demonstrates the decorator pattern by wrapping a function to add logging behavior without modifying the original function.

decorator pattern logging
Python
import functools

def logger(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__} with {args} {kwargs}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} returned {result}")
        return result
    return wrapper

@logger
def add(a, b):
   …
13 0 Open
OOP & classes easy

How to Make a Python Class Hashable with __eq__ and __hash__

Define __eq__ and __hash__ together on a Python class so equal instances share the same hash and work correctly in sets and dictionary keys.

oop hashable eq
Python
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __eq__(self, other):
        if not isinstance(other, Point):
            return NotImplemented
        return self.x == other.x and self.y == other.y

    def __hash__(self):
        return hash((self.x, self.y))

    def __repr…
14 0 Open
OOP & classes easy

How to Sort Data in Python with a Class Helper

This beginner-friendly class wraps the built-in sorted() function to sort numbers, strings ignoring case, and dictionaries by a specified key.

oop sorting sorted
Python
class DataSorter:
    def __init__(self, data):
        self.data = data

    def sort_numbers(self, reverse=False):
        return sorted(self.data, reverse=reverse)

    def sort_strings_ignore_case(self, reverse=False):
        return sorted(self.data, key=str.lower, reverse=reverse)

    def sort_dicts_by_key(self…
15 0 Open
OOP & classes easy

How to Use IntEnum Arithmetic for Priority Levels in Python

Demonstrates Python IntEnum arithmetic for priority levels, showing how enum members behave like integers in calculations and comparisons.

enum intenum priority
Python
from enum import IntEnum

class Priority(IntEnum):
    LOW = 1
    MEDIUM = 5
    HIGH = 10
    CRITICAL = 20

if __name__ == "__main__":
    current = Priority.MEDIUM
    boosted = current + 3
    lowered = current - 2
    doubled = current * 2

    print(f"Current: {current} ({current.value})")
    print(f"Boosted (…
14 0 Open
OOP & classes easy

How to Use NamedTuples for Lightweight Records in Python

Create lightweight, immutable data records with namedtuple that behave like tuples but have named fields for improved readability and access.

namedtuple tuples records
Python
from collections import namedtuple

Point = namedtuple("Point", ["x", "y"])

p = Point(3, 4)
print(p)
print(p.x, p.y)
print(p[0], p[1])

x, y = p
print(x, y)

print(p._asdict())

p2 = p._replace(x=10)
print(p2)

if __name__ == "__main__":
    print("NamedTuple demo complete")
17 0 Open
OOP & classes easy

How to Use StrEnum with auto() in Python

Define string-valued enum members automatically by using StrEnum with the auto() helper, making each member's value its own uppercase name.

enum strenum auto
Python
from enum import StrEnum, auto

class Color(StrEnum):
    RED = auto()
    GREEN = auto()
    BLUE = auto()

class Language(StrEnum):
    PYTHON = auto()
    JAVASCRIPT = auto()
    RUST = auto()

print(list(Color))
print(list(Language))

print(Color.RED == "RED")
print(Language.PYTHON == "PYTHON")

print(f"Color: {Co…
14 0 Open
OOP & classes easy

How to Validate Data Types in Python with a Class

A beginner-friendly Python class that checks if a value is a string, integer, float, list, or empty, using simple methods and isinstance checks.

class validation type checking
Python
class DataValidator:
    """A simple data validation helper for beginners."""
    
    def __init__(self, data):
        self.data = data
    
    def is_string(self):
        return isinstance(self.data, str)
    
    def is_integer(self):
        return isinstance(self.data, int) and not isinstance(self.data, bool)
…
15 0 Open
OOP & classes easy

How to Validate User Input with a Dataclass in Python

A dataclass stores name, age, and email, and a validator class checks each field, returning a dictionary of boolean results.

dataclass validation oop
Python
from dataclasses import dataclass


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

    def is_valid_name(self) -> bool:
        return bool(self.name.strip()) and len(self.name.strip()) >= 2

    def is_valid_age(self) -> bool:
        return isinstance(self.age, int) and 0 < self.age < 150

  …
16 0 Open
OOP & classes easy

How to define a custom exception class in Python with an error code attribute

Create a custom exception class with extra attributes like an error code, then raise and catch it in a try/except block.

exceptions classes error-handling
Python
class UserNotFoundError(Exception):
    def __init__(self, user_id, error_code=404):
        self.user_id = user_id
        self.error_code = error_code
        super().__init__(f"User with ID {user_id} was not found (error code: {error_code})")

def find_user(user_id, users_db):
    if user_id not in users_db:
      …
16 0 Open
OOP & classes easy

How to merge dictionaries by a key in Python with a class

This code defines a DataMerger class that collects dictionary records and merges them by a specified key, combining fields from multiple records with the same key.

classes dictionaries merging
Python
class DataMerger:
    def __init__(self):
        self.records = []

    def add_record(self, record):
        if isinstance(record, dict):
            self.records.append(record)
        else:
            raise TypeError("Record must be a dictionary")

    def merge_by_key(self, key):
        merged = {}
        for …
15 0 Open
OOP & classes easy

Parse CSV Data with a Python Class

Encapsulate CSV file loading and column/row access methods in a reusable DataParser class for beginners.

oop csv parsing
Python
class DataParser:
    def __init__(self, file_path):
        self.file_path = file_path
        self.data = []

    def load_data(self):
        with open(self.file_path, 'r') as file:
            for line in file:
                row = line.strip().split(',')
                self.data.append(row)
        return self.…
14 0 Open
OOP & classes easy

Python Adapter Class: Wrap Legacy Interface

Convert a legacy system's interface into a modern one using the Adapter pattern in Python, translating method calls and data formats.

adapter design-pattern oop
Python
class LegacySystem:
    """Legacy interface - old method names and parameter format."""
    def query_employee_info(self, emp_id, emp_name):
        return f"Legacy: {emp_id} - {emp_name}"

    def update_employee_department(self, emp_id, department_code):
        return f"Legacy: Updated {emp_id} to dept {department_…
13 0 Open
OOP & classes easy

Python Factory Method: Create Shapes by Type String

A factory method that maps a type string to a concrete shape class and returns an instance, with runtime error handling.

factory-pattern oop polymorphism
Python
class Shape:
    def draw(self):
        raise NotImplementedError


class Circle(Shape):
    def draw(self):
        return "Drawing a circle"


class Square(Shape):
    def draw(self):
        return "Drawing a square"


class Triangle(Shape):
    def draw(self):
        return "Drawing a triangle"


class ShapeFact…
13 0 Open
OOP & classes easy

Python object equality: id vs value comparison

Demonstrates the difference between default identity comparison and custom equality, with a value-based class implementing __eq__ and __hash__.

oop equality hash
Python
import copy


class IdOnly:
    def __init__(self, name):
        self.name = name


class ValueId:
    def __init__(self, name):
        self.name = name

    def __eq__(self, other):
        return isinstance(other, ValueId) and self.name == other.name

    def __hash__(self):
        return hash(self.name)

    def…
14 0 Open
OOP & classes easy

Slots Class: How to Reduce Memory Usage in Python

Use __slots__ to prevent dynamic attribute creation and reduce per-instance memory overhead, while keeping methods intact.

memory slots class
Python
class SlotsDemo:
    __slots__ = ("name", "age", "email")

    def __init__(self, name, age, email):
        self.name = name
        self.age = age
        self.email = email

    def describe(self):
        return f"{self.name}, {self.age}, {self.email}"

if __name__ == "__main__":
    instance = SlotsDemo("Alice", …
15 0 Open
OOP & classes easy

Validate dataclass fields with __post_init__ in Python

Add custom validation to a Python dataclass inside __post_init__, raising ValueError or TypeError for invalid field values.

dataclasses validation post-init
Python
from dataclasses import dataclass, field
from typing import Optional


@dataclass
class Product:
    name: str
    price: float
    quantity: int = 1
    category: Optional[str] = None

    def __post_init__(self):
        if not self.name or not isinstance(self.name, str):
            raise ValueError("name must be a…
12 0 Open
Algorithms & data structures easy

Bucket Numbers into Histogram Bin Counts in Python

Partition a list of numbers into equal-width histogram bins and count how many fall into each bin using only the Python standard library.

histogram bins statistics
Python
from collections import Counter

def histogram_bins(numbers, num_bins):
    """Bucket numbers into histogram bin counts."""
    if not numbers:
        return []
    
    min_val = min(numbers)
    max_val = max(numbers)
    bin_width = (max_val - min_val) / num_bins
    
    # Handle edge case where all values are id…
22 0 Open
Algorithms & data structures easy

Count Smaller Elements to the Right in Python

Return a list where each index counts how many elements to its right are smaller than that element using a clean O(n²) nested-loop approach.

brute-force nested-loops counting
Python
def count_smaller_elements(arr):
    """
    Return a list where result[i] is the number of elements 
    to the right of arr[i] that are smaller than arr[i].
    """
    result = []
    for i in range(len(arr)):
        count = 0
        for j in range(i + 1, len(arr)):
            if arr[j] < arr[i]:
               …
18 0 Open
Algorithms & data structures easy

Depth First Search Traversal Order in Python

Recursive depth-first search that returns the visit order of nodes in an adjacency list graph starting from a given node.

dfs graph traversal
Python
def dfs_order(adj, start):
    visited = set()
    order = []

    def dfs(node):
        visited.add(node)
        order.append(node)
        for neighbor in adj.get(node, []):
            if neighbor not in visited:
                dfs(neighbor)

    dfs(start)
    return order


if __name__ == "__main__":
    # Dem…
19 0 Open
Algorithms & data structures easy

Drop Elements From Start While Condition Is True in Python

This generator function drops elements from the beginning of an iterable while a predicate returns true, then yields the rest.

generator iteration filtering
Python
def drop_while(predicate, iterable):
    """Drop elements from the start while predicate is true."""
    it = iter(iterable)
    for item in it:
        if not predicate(item):
            yield item
            break
    yield from it

if __name__ == "__main__":
    numbers = [1, 2, 3, 4, 1, 2, 5]
    result = list(d…
13 0 Open
Algorithms & data structures easy

Extract n largest elements from a large list using heapq

Uses heapq.nlargest to efficiently extract the top n largest numbers from a large list, even with millions of elements.

heapq heaps large-data
Python
import heapq
import random

def n_largest(numbers, n):
    """Return the n largest numbers from a list using heapq."""
    if n <= 0:
        return []
    return heapq.nlargest(n, numbers)

if __name__ == "__main__":
    # Create a large list with 1,000,000 random numbers
    large_list = [random.randint(1, 1_000_000…
15 0 Open
Algorithms & data structures easy

Filter List to Keep Only Whitelist Values in Python

Filter a list of values to keep only those present in a predefined whitelist set using a list comprehension.

filtering sets list-comprehension
Python
def filter_whitelist(values, whitelist):
    """Return only values that are present in the whitelist set."""
    return [value for value in values if value in whitelist]

if __name__ == "__main__":
    raw_values = ["apple", "banana", "cherry", "date", "apple", "elderberry"]
    allowed = {"apple", "banana", "date"}

…
15 0 Open
Algorithms & data structures easy

Find All Indices of a Target Value in a Python List

Returns a list of all indices where a given target value appears in a Python list using a list comprehension with enumerate.

list index enumerate
Python
def find_all_indices(arr, target):
    return [i for i, value in enumerate(arr) if value == target]

if __name__ == "__main__":
    sample_list = [4, 2, 7, 2, 9, 2, 1, 2]
    target = 2
    result = find_all_indices(sample_list, target)
    print(result)
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.