Python playground
Pick a snippet, tweak the code, and run it in the browser. Great for refreshing core syntax and algorithm muscle memory.
Fundamentals, playground drills, and walkthroughs in one flow.
Concise language tools that show up often in backend codebases.
Python offers concise syntax for building sequences.
{k: v for ...}) and set
comprehensions ({x for ...}).
even_squares = [x ** 2 for x in range(10) if x % 2 == 0]
print(even_squares) # [0, 4, 16, 36, 64]Decorators wrap functions or methods to add behavior without changing call sites.
@staticmethod, @classmethod,
@property.
def log_calls(func):
def wrapper(*args, **kwargs):
print(f"Starting {func.__name__}")
result = func(*args, **kwargs)
print(f"Finished {func.__name__}")
return result
return wrapper
@log_calls
def greet(name):
print(f"Hello, {name}!")
greet("Alice")Use with to guarantee cleanup of resources, even on exceptions.
__enter__ and __exit__.with open("data.txt", "r") as f:
lines = f.readlines()
# closed automaticallyAnonymous, one-line functions for key functions or small transforms.
items = [("a", 3), ("b", 1), ("c", 2)]
sorted_items = sorted(items, key=lambda x: x[1])
print(sorted_items) # [("b", 1), ("c", 2), ("a", 3)]Improve readability and tooling support.
from typing import Any, Dict
def greeting(name: str) -> str:
return "Hello, " + name
payload: Dict[str, Any] = {"id": 1, "ok": True}Catch expected errors and avoid overly broad exceptions.
try:
value = int(user_input)
except ValueError as e:
print("Invalid input:", e)
finally:
print("Execution complete")Reach for map, filter, zip, and enumerate when transforms get repetitive.
nums = [1, 2, 3]
doubled = list(map(lambda x: x * 2, nums))
odds = list(filter(lambda x: x % 2, nums))
paired = list(zip(nums, ["a", "b", "c"]))
print(doubled) # [2, 4, 6]
print(odds) # [1, 3]
print(paired) # [(1, "a"), (2, "b"), (3, "c")]
for idx, val in enumerate(nums, start=1):
print(idx, val)Core containers, performance expectations, and small sketches.
Mutable ordered sequence.
stack = []
stack.append(1)
stack.append(2)
print(stack.pop()) # 2Hash map for fast key lookup.
user_ages = {"Alice": 30, "Bob": 25}
print(user_ages.get("Alice")) # 30Unordered unique elements with fast membership tests.
s = {1, 2, 3, 2}
print(2 in s) # True
print(s | {3, 4}) # {1, 2, 3, 4}Immutable ordered sequence for fixed records and dict keys.
coords = (10.0, 20.0)
print(coords[0]) # 10.0FIFO structure with efficient pops from the left.
from collections import deque
queue = deque([1, 2, 3])
queue.append(4)
print(queue.popleft()) # 1Min-heap priority queue implementation.
import heapq
heap = []
heapq.heappush(heap, 5)
heapq.heappush(heap, 3)
heapq.heappush(heap, 10)
print(heapq.heappop(heap)) # 3No built-in type, so implement nodes with pointers.
class Node:
def __init__(self, data):
self.data = data
self.next = None
n1 = Node(1)
n2 = Node(2)
n3 = Node(3)
n1.next = n2
n2.next = n3Use when you need frequent insert/delete with pointers, or for pointer practice.
Hierarchical structure. Binary trees have up to two children.
class TreeNode:
def __init__(self, key):
self.key = key
self.left = None
self.right = None
root = TreeNode(10)
root.left = TreeNode(5)
root.right = TreeNode(15)Common traversals: preorder, inorder, postorder, and BFS level order.
Nodes and edges to model networks and dependencies.
graph = {
"A": ["B", "C"],
"B": ["A", "D"],
"C": ["A", "D"],
"D": ["B", "C"],
}Traversal: BFS or DFS with an adjacency list.
Practice patterns you will use for services, queues, caches, and data transforms.
Given orders with user and price, compute total spend per user.
orders = [
{"user": "Alice", "price": 50},
{"user": "Bob", "price": 75},
{"user": "Alice", "price": 100},
{"user": "Bob", "price": 25},
]
totals = {}
for order in orders:
user = order["user"]
totals[user] = totals.get(user, 0) + order["price"]
print(totals) # {"Alice": 150, "Bob": 100}Use OrderedDict to track recency and evict oldest entries.
from collections import OrderedDict
class LRUCache:
def __init__(self, capacity=3):
self.cache = OrderedDict()
self.capacity = capacity
def get(self, key):
if key not in self.cache:
return -1
self.cache.move_to_end(key)
return self.cache[key]
def put(self, key, value):
if key in self.cache:
self.cache.move_to_end(key)
self.cache[key] = value
if len(self.cache) > self.capacity:
self.cache.popitem(last=False)
cache = LRUCache(capacity=2)
cache.put("a", 1)
cache.put("b", 2)
print(cache.get("a")) # 1
cache.put("c", 3) # evicts "b"
print(list(cache.cache.keys())) # ["a", "c"]Use deque for efficient queue behavior.
from collections import deque
tasks = deque(["task1", "task2"])
tasks.append("task3")
while tasks:
current = tasks.popleft()
print("Processing:", current)Common for nested JSON arrays.
def flatten(nested):
flat = []
for item in nested:
if isinstance(item, list):
flat.extend(flatten(item))
else:
flat.append(item)
return flat
nested = [1, [2, 3], [4, [5, 6]]]
print(flatten(nested)) # [1, 2, 3, 4, 5, 6]Memoize expensive calls such as DB or remote fetches.
from functools import lru_cache
@lru_cache(maxsize=100)
def fetch_user_data(user_id):
print(f"Fetching data for {user_id}")
return {"id": user_id, "data": "..."}
fetch_user_data(42) # hits expensive path
fetch_user_data(42) # served from cacheUse this as a final sweep before you practice in the playground.
Run small exercises for syntax, data structures, and algorithms.
Active snippet
Use the editor to experiment with the code.
stdout and errors appear here.
Run code to see output.
Open any card, review the guidance, then load the code into the editor to practice.
Core storage models, operations, and pitfalls.
Step-by-step procedures with complexity and Python sketches.
Reusable problem-solving strategies, signals, and pitfalls.