Python Code Beautifier: Prettify Code and Pretty-Print Data (Tested)

• Beautify code — reformat a .py file's layout (indentation, spacing around operators, quote style, line length, blank lines) without changing what it does. This is what a *formatter* does: Black, autopep8, YAPF, or Ruff's formatter.
• Pretty-print data — take a Python object (a nested dict, a list, a JSON response) that prints as one unreadable line and lay it out with indentation at runtime. This is what pprint and json.dumps do.

They're unrelated tools solving unrelated problems. Below, each with a real test.

Here's a deliberately ugly file — cramped spacing, mixed quotes, a joined import, a one-line function, and no blank lines:

import sys,os
def add( a,b ):return a+b
x = {'name':'mithun','tags':['a','b'],'score':42}
result=[add(i,i*2) for i in range(10) if i%2==0]
def greet(name = 'world'):
    print( 'hello',name )

Black is the popular "uncompromising" formatter — it reflows the whole file to one canonical style. Real output (black messy.py):

import sys, os


def add(a, b):
    return a + b


x = {"name": "mithun", "tags": ["a", "b"], "score": 42}
result = [add(i, i * 2) for i in range(10) if i % 2 == 0]


def greet(name="world"):
    print("hello", name)

Black added spaces around every operator, switched to double quotes, put the function body on its own line, and inserted two blank lines between definitions. autopep8 is more conservative — it fixes PEP 8 violations but changes as little as possible. Same input (autopep8 messy.py):

import sys
import os
def add(a, b): return a+b


x = {'name': 'mithun', 'tags': ['a', 'b'], 'score': 42}
result = [add(i, i*2) for i in range(10) if i % 2 == 0]


def greet(name='world'):
    print('hello', name)

Notice the difference: autopep8 split the joined import (that's a PEP 8 rule) but kept single quotes, kept `i*2` without spaces, and left the one-line function as-is — it only touches actual violations. Black rewrites to its own style regardless. That's the core trade-off: Black for zero-config consistency, autopep8 when you want to stay close to the original. Full head-to-head in autopep8 vs Black.

The other "beautify" is about *data*. A nested dict printed normally is a wall of text:

{'user': 'mithun', 'roles': ['admin', 'editor'], 'prefs': {'theme': 'dark', 'langs': ['py', 'rs', 'go']}, 'active': True, 'score': 42}

The standard library's `pprint` lays it out while keeping valid Python syntax (single quotes, True, tuples). It wraps to a width you choose and aligns nested structures:

{'user': 'mithun',
 'roles': ['admin', 'editor'],
 'prefs': {'theme': 'dark',
           'langs': ['py', 'rs', 'go']},
 'active': True,
 'score': 42}

If you want JSON style instead — double quotes, true/false, one item per line — use json.dumps with an indent:

{
  "user": "mithun",
  "roles": [
    "admin",
    "editor"
  ],
  "prefs": {
    "theme": "dark",
    "langs": [
      "py",
      "rs",
      "go"
    ]
  },
  "active": true,
  "score": 42
}

Rule of thumb: `pprint` when you're debugging Python objects and want them to still look like Python (and it handles tuples, sets, and non-JSON types); `json.dumps(..., indent=2)` when the data is JSON-compatible and you want standard JSON output to save or share. You can run either instantly in our online Python compiler — paste the object, print it, done.