10 Insanely Useful Python Tricks in 2026 You Wish You Knew Yesterday (Developers Are Obsessed With #4!)

from string.templatelib import Interpolation

def safe_html(template):
    parts = []
    for part in template:
        if isinstance(part, Interpolation):
            # Sanitize or escape here
            value = str(part.value).replace("&", "&")
            parts.append(value)
        else:
            parts.append(part)
    return "".join(parts)

user_input = "<script>alert('xss')</script>"
template = t"<div>Hello {user_input}!</div>"
print(safe_html(template))
# Output: <div>Hello &lt;script&gt;alert('xss')&lt;/script&gt;!</div>

from dataclasses import dataclass
from typing import Optional

@dataclass
class Node:                  # No NameError!
    value: int
    next: Optional["Node"] = None

# Introspect safely
from annotationlib import get_annotations
print(get_annotations(Node))

# Run your script without GIL
python3.14t -X gil=0 my_app.py

import threading

def cpu_heavy():
    return sum(i * i for i in range(10_000_000))

threads = [threading.Thread(target=cpu_heavy) for _ in range(8)]
for t in threads: t.start()
for t in threads: t.join()

from concurrent.futures import InterpreterPoolExecutor
from time import perf_counter

def heavy_computation(n):
    return n ** 2  # Replace with real CPU work

start = perf_counter()
with InterpreterPoolExecutor(max_workers=4) as pool:
    results = list(pool.map(heavy_computation, range(100_000)))
print(f"Done in {perf_counter() - start:.2f}s")

from pathlib import Path

src = Path("large_dataset/")
dst = Path("/backup/2026/")

# One-liner recursive copy
src.copy(dst / "dataset_backup")

# Atomic move
Path("temp_results.csv").move("/archive/final_results.csv")

# Process only expensive items that meet criteria
if (processed := [x**2 for x in data if (x := expensive_check(x)) > 10]):
    print(f"Found {len(processed)} winners!")

def handle_event(event):
    match event:
        case {"type": "click", "coords": (x, y)}:
            print(f"Clicked at {x},{y}")
        case {"type": "key", "key": k} if k in ("Enter", "Escape"):
            print("Special key!")
        case _:
            print("Unknown event")

from functools import cache

@cache
def fibonacci(n: int) -> int:
    return n if n < 2 else fibonacci(n-1) + fibonacci(n-2)

# Instant on repeated calls
print(fibonacci(500))  # No recursion depth issues

def interactive_filter():
    gen = (x * 2 for x in range(100))
    for val in gen:
        if (response := yield val) == "stop":
            break

pipeline = interactive_filter()
next(pipeline)  # Start
print(pipeline.send("continue"))

class Point:
    __slots__ = ["x", "y"]   # Saves ~50% memory per instance

# Python 3.14's incremental GC keeps pauses tiny even with millions of Points