autopep8 vs Black: I Formatted the Same Messy File With Both

autopep8 is a linter's fixer; Black is a rewriter. autopep8 runs the same checks as pycodestyle (the PEP 8 checker) and edits only what's needed to make those warnings go away — so a file can pass and still keep most of your personal style. Black ignores your style entirely and re-emits the file in *its* single, non-configurable format. That's the whole story; everything below is a consequence of it.

This is the input I gave both tools — deliberately sloppy: mixed quotes, no operator spacing, a cramped signature, a multi-import line:

import os, sys
x = {'name':'alice','role':'admin','tags':['a','b','c']}
def greet( name,greeting = 'hello' ):
    msg=greeting+', '+name+'!'
    return msg

Here's what autopep8 did (default, no flags):

import os
import sys
x = {'name': 'alice', 'role': 'admin', 'tags': ['a', 'b', 'c']}


def greet(name, greeting='hello'):
    msg = greeting+', '+name+'!'
    return msg

And here's Black on the same input:

import os, sys

x = {"name": "alice", "role": "admin", "tags": ["a", "b", "c"]}


def greet(name, greeting="hello"):
    msg = greeting + ", " + name + "!"
    return msg

Look closely — they disagree on almost every line, and each disagreement is a real rule.

The operator one surprised people I showed this to. autopep8 spaced the = but left greeting+', '+name alone — because missing whitespace around an *arithmetic* operator is check E226, which autopep8 ignores by default. It only fixes it if you opt in:

orig:              z=a+b*c
autopep8 default:  z = a+b*c
autopep8 -aa:      z = a + b * c
black:             z = a + b * c

And the line-length default is easy to trip over. I fed both an 81-character line. autopep8 (max 79) wrapped it; Black (max 88) left it alone — same code, different result, purely because the defaults differ.

Formatting should never change what your program *does*. I ran the original file and both formatted versions and compared the results — all three produced identical output:

orig:      hello, world!  admin
autopep8:  hello, world!  admin
black:     hello, world!  admin

Both preserved behavior here — but there's an important asymmetry. Black guarantees it: after formatting, it re-parses the output and checks the AST is equivalent to the input, and bails if it isn't. autopep8 in its default mode is safe too, but its --aggressive fixes (the ones that finally space your arithmetic operators, rewrite comparisons, etc.) are *not* guaranteed semantics-preserving and can, in edge cases, change meaning.

There's no universally "better" one — they're built for different goals:

• Use Black for new projects and teams. It's deterministic and non-configurable, so it ends every style argument and produces byte-identical output for everyone. It's the de-facto standard for new Python code, and editors/CI integrate it everywhere.
• Use autopep8 when you're improving an existing codebase and want *small, reviewable diffs*. It won't touch your quotes or re-explode your data structures — it just clears the PEP 8 warnings. Great for a gradual cleanup where a full Black reformat would bury real changes under thousands of style edits.
• Worth knowing: ruff format is a newer, Rust-based formatter that's essentially Black-compatible but dramatically faster, and it also lints. If you're starting fresh, it's worth a look alongside Black.

You don't have to install anything to try either one. Our free Python Formatter runs Black, autopep8, and YAPF in your browser — paste the same messy snippet, switch the engine, and watch the exact differences above happen live. If you'd rather lint *and* format with the fast modern option, the Ruff linter & formatter is there too.