5 Hidden Python Features That Can Supercharge Your Code

1. contextlib.suppress – silently ignore specific exceptions

When you need to discard a very specific exception without cluttering your code with a try/except block, contextlib.suppress provides a clean, readable alternative.

try:
    os.remove('tempfile.txt')
except FileNotFoundError:
    pass

Using suppress:

from contextlib import suppress
with suppress(FileNotFoundError):
    os.remove('tempfile.txt')

You can also suppress multiple exceptions at once:

with suppress(FileNotFoundError, PermissionError):
    os.remove('config.yaml')

Typical use‑cases include cleaning up temporary files, closing sockets, or attempting to remove resources that may not exist.

2. sys.setrecursionlimit – raise the recursion ceiling safely

Python’s default recursion depth is 1000, which can cause RecursionError for deep recursive algorithms such as tree traversals or DFS. You can raise this limit with a single line of code.

import sys
sys.setrecursionlimit(10**6)

After increasing the limit, well‑written recursive functions no longer hit the stack‑overflow error. Use this only when you understand the memory impact; setting it too high can exhaust resources.

3. typing.Literal – enforce a limited set of string values at type‑checking time

Instead of runtime if checks for allowed strings, Literal moves the validation to static type checkers (mypy, pyright, etc.), making APIs self‑documenting and safer.

from typing import Literal

def connect(mode: Literal['read', 'write']):
    ...

Other examples:

def get_user(role: Literal['admin', 'moderator', 'user']):
    ...

def get_data(format: Literal['json', 'xml'] | None = None):
    ...

IDE warnings appear if an invalid literal is passed, preventing bugs before runtime. This works seamlessly with pydantic, FastAPI, and other modern Python tooling.

4. __missing__ – customize dict behavior for absent keys

By overriding the hidden __missing__ method in a dict subclass, you can define exactly what happens when a key is not found.

class AutoDict(dict):
    def __missing__(self, key):
        value = self[key] = f"[{key} not found]"
        return value

# Usage
 d = AutoDict()
 print(d['python'])   # [python not found]
 print(d['java'])     # [java not found]

Advanced use‑cases include logging missing accesses or automatically generating placeholder values:

class AccessTracker(dict):
    def __missing__(self, key):
        print(f"Key {key} accessed but not found.")
        raise KeyError(key)

This method gives precise control over dictionary semantics, a feature many developers overlook.

5. __subclasshook__ – create structural (duck‑type) abstract base classes

When you want an interface‑like check without forcing inheritance, implement __subclasshook__ in an ABC. The hook returns True if the candidate class provides the required methods.

from abc import ABC, abstractmethod

class JsonSerializable(ABC):
    @abstractmethod
    def to_json(self):
        pass

    @classmethod
    def __subclasshook__(cls, C):
        if any('to_json' in B.__dict__ for B in C.__mro__):
            return True
        return NotImplemented

class MyClass:
    def to_json(self):
        return '{"hello": "world"}'

print(issubclass(MyClass, JsonSerializable))  # True

This enables flexible plugin systems and APIs where only method presence matters, avoiding rigid inheritance hierarchies.