Python Code
Samples
Copy-ready Python snippets by topic and difficulty — short, focused, and runnable in the browser editor.
How to Remove Banned Words from a Set in Python
Filter a vocabulary set by removing banned words using the .difference() method.
vocabulary = {"apple", "banana", "cherry", "date", "elderberry"}
banned_words = {"banana", "date", "fig"}
# Remove banned words using set difference
allowed_words = vocabulary.difference(banned_words)
print("Original vocabulary:", sorted(vocabulary))
print("Banned words:", sorted(banned_words))
print("Allowed words …How to Use Counter for Most Common Elements in Python
This code demonstrates how to find the most frequent elements in a list using Python's Counter class from the collections module.
from collections import Counter
def most_common_elements(items, n=1):
"""Return the n most common elements and their counts."""
counter = Counter(items)
return counter.most_common(n)
if __name__ == "__main__":
data = ["apple", "banana", "apple", "orange", "banana", "apple", "grape"]
print(most_co…How to Use MappingProxyType to Create Immutable Dict Views in Python
Create a read-only, immutable view of a dictionary using MappingProxyType from the types module, while the original dict stays mutable.
from types import MappingProxyType
config = {"debug": True, "port": 8080}
# Create an immutable read-only view of the dict
read_only_config = MappingProxyType(config)
print(f"Read-only value: {read_only_config['debug']}")
print(f"Dict is mapping: {isinstance(read_only_config, dict)}")
# Original dict can still be …Traverse Nested Dict Paths Depth-First in Python
Recursively walk a nested dictionary depth-first and yield each full path from root to leaf as lists.
def depth_first_paths(node, path=None):
if path is None:
path = []
if not isinstance(node, dict):
yield path + [node]
return
for key, value in node.items():
new_path = path + [key]
if isinstance(value, dict):
yield from depth_first_paths(value, …Bridge Pattern in Python: Separate Abstraction from Implementation
Implement the Bridge design pattern in Python so that an abstraction (remote control) can operate on different device implementations independently.
class RemoteControl:
"""Abstraction: controls a device without knowing implementation details."""
def __init__(self, device):
self.device = device
def toggle_power(self):
if self.device.is_enabled():
self.device.disable()
return "Power off"
else:
…How to Build a Class Method Alternative Constructor from Dict in Python
Use a classmethod alternative constructor to build a Book instance from a dictionary with sensible defaults.
class Book:
def __init__(self, title, author, pages):
self.title = title
self.author = author
self.pages = pages
@classmethod
def from_dict(cls, data):
"""Alternative constructor that builds a Book from a dictionary."""
return cls(
title=data["title"],
…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.
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 …Container With Most Water: Two-Pointer Solution in Python
Find the maximum water a container can hold from a list of heights using an efficient two-pointer technique in O(n) time.
from typing import List
def max_water_container(heights: List[int]) -> int:
left, right = 0, len(heights) - 1
max_area = 0
while left < right:
width = right - left
height = min(heights[left], heights[right])
area = width * height
max_area = max(max_area, area)
…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.
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…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.
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…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.
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…Find Elements in One Python List but Not Another
Return a new list containing only the elements from list A that are not present in list B, preserving duplicates and order.
def difference_elements(a, b):
"""Return elements present in list a but not in list b."""
set_b = set(b)
return [item for item in a if item not in set_b]
if __name__ == "__main__":
a = [1, 2, 3, 4, 5, 3, 2]
b = [2, 4, 6]
result = difference_elements(a, b)
print(f"A: {a}")
print(f"B: {b…Find Missing Number in Python Sequence 1 to N
Find the missing number from a list containing numbers 1 to N using the arithmetic sum formula.
def find_missing_number(nums, n):
expected_sum = n * (n + 1) // 2
actual_sum = sum(nums)
return expected_sum - actual_sum
if __name__ == "__main__":
n = 10
numbers = [1, 2, 3, 4, 5, 6, 7, 9, 10]
missing = find_missing_number(numbers, n)
print(f"The missing number is: {missing}")Find k Closest Points to Origin in Python
Sorts a list of (x, y) point tuples by their Euclidean distance from the origin and returns the k nearest points.
import math
def k_closest(points, k):
points.sort(key=lambda p: math.sqrt(p[0]**2 + p[1]**2))
return points[:k]
if __name__ == "__main__":
points = [(1, 2), (3, 4), (-1, 0), (5, 5), (0, 1)]
k = 3
result = k_closest(points, k)
print(f"Original points: {points}")
print(f"K closest points (k…Find the Last Index Where a Condition Is True in Python
This code scans a sequence from the end and returns the index of the last element that satisfies a given condition, or -1 if none do.
def last_index_where(sequence, condition):
"""Return the index of the last element in sequence that satisfies condition."""
for i in range(len(sequence) - 1, -1, -1):
if condition(sequence[i]):
return i
return -1
if __name__ == "__main__":
numbers = [1, 4, 7, 2, 9, 5, 8, 3]
is_…Find the Second Largest Unique Number in a Python List
This Python function finds the second largest unique number from a list by converting it to a set, removing the maximum, and returning the new maximum.
def second_largest_unique(numbers):
unique_numbers = set(numbers)
if len(unique_numbers) < 2:
return None
unique_numbers.remove(max(unique_numbers))
return max(unique_numbers)
if __name__ == "__main__":
test_list = [4, 2, 9, 5, 2, 9, 1, 5]
result = second_largest_unique(test_list)
…Game of Life Next State Grid in Python
Compute the next generation of Conway's Game of Life from a 2D grid using the standard three rules with neighbor counting.
def next_state(grid):
m, n = len(grid), len(grid[0])
new = [[0] * n for _ in range(m)]
for r in range(m):
for c in range(n):
total = 0
for dr in (-1, 0, 1):
for dc in (-1, 0, 1):
if dr == 0 and dc == 0:
continue
…How to Compute the Cartesian Product of Two Lists in Python
Generates all ordered pairs from two lists using itertools.product and prints each combination.
from itertools import product
# Two small input lists
list_a = [1, 2, 3]
list_b = ["x", "y"]
# Compute the Cartesian product
result = list(product(list_a, list_b))
# Display the result
print("Cartesian product of", list_a, "and", list_b, "is:")
for pair in result:
print(pair)How to Count Occurrences of Each Value in Python
Count how many times each value appears in a list using Python's Counter from the collections module.
from collections import Counter
def count_occurrences(values):
"""Return a dictionary mapping each value to its count."""
return dict(Counter(values))
if __name__ == "__main__":
sample_data = ["apple", "banana", "apple", "cherry", "banana", "apple"]
result = count_occurrences(sample_data)
print(r…How to Find the n Smallest Items in a Large List with heapq in Python
This code demonstrates how to efficiently extract the n smallest items from a large list using Python's heapq module and a manual max-heap approach.
import heapq
def n_smallest_iterable(data, n):
"""Return the n smallest items without loading the whole list."""
if n <= 0:
return []
return heapq.nsmallest(n, data)
def n_smallest_manual(data, n):
"""Return the n smallest using a heap, O(n log k) time."""
if n <= 0:
return []
…How to Get All Combinations of a List in Python
Generate and display all combinations of a given length from a list using Python's itertools.combinations.
from itertools import combinations
def list_combinations(items, r):
"""Return all combinations of length r from a list."""
return list(combinations(items, r))
if __name__ == "__main__":
fruits = ["apple", "banana", "cherry", "date"]
pick = 2
result = list_combinations(fruits, pick)
print…How to Implement a Moving Average from a Data Stream in Python
Implement a MovingAverage class using a deque and running sum to compute the average of the last k values from a continuous data stream.
from collections import deque
class MovingAverage:
def __init__(self, size):
self.size = size
self.queue = deque()
self.window_sum = 0
def next(self, val):
self.queue.append(val)
self.window_sum += val
if len(self.queue) > self.size:
self.window_su…How to Remove Banned Values from a List in Python
Filters a list by removing elements present in a banned set, preserving the original order.
def remove_banned(values, banned):
banned_set = set(banned)
return [item for item in values if item not in banned_set]
if __name__ == "__main__":
values = [1, 2, 3, 4, 5, 2, 6, 3, 7]
banned = [2, 3]
result = remove_banned(values, banned)
print(result)How to Remove Duplicates in Python Preserving Order
Removes duplicate items from a list while keeping the first occurrence order intact using a set for fast membership checks.
def remove_duplicates_preserving_order(items):
seen = set()
result = []
for item in items:
if item not in seen:
seen.add(item)
result.append(item)
return result
if __name__ == "__main__":
sample = [3, 1, 2, 1, 3, 4, 2, 5]
unique_items = remove_duplicates_preserv…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.