Introduction

PEP 8 recommends spaces over tabs because indentation in Python is part of the language syntax, not just visual formatting. Spaces make indentation width explicit and consistent across editors, while tabs can render differently depending on local settings, which creates unnecessary ambiguity in code that depends on exact indentation.

Indentation Is Semantics in Python

In many languages, indentation is mostly cosmetic. In Python, indentation defines blocks. That means disagreement about indentation is not only a style problem; it can change or break the program.

A simple example is:

if True:
    print("inside")
print("outside")

The spaces are part of the program structure. If indentation becomes inconsistent, Python may raise an error or readers may misinterpret the intended block structure.

That is why PEP 8 cares strongly about predictability here.

Tabs Depend on Editor Settings

The core technical problem with tabs is that a tab character does not have one universal display width. One editor may show it as four columns, another as eight, and another may align it to tab stops in a way that changes how the code looks.

Spaces do not have that ambiguity. Four spaces is always four spaces.

That difference matters for collaboration. If one developer sees a file with tabs at width four and another sees it at width eight, the visual nesting can look different even though the bytes are the same.

Mixing Tabs and Spaces Is Especially Dangerous

The worst case is mixing tabs and spaces in the same file or block. Python 3 is intentionally strict here and can raise indentation errors when the structure is inconsistent.

if True:
    print("line one")
	print("line two")

Depending on the exact context, this can produce an indentation error or at least confuse anyone reading the file. PEP 8's preference for spaces helps eliminate that class of problem by standardizing on one indentation method.

Why Four Spaces Became the Norm

PEP 8 does not just say "use spaces." It specifically recommends four spaces per indentation level. That gives Python code a consistent look across the ecosystem and lines up with formatter and linter behavior.

Most modern Python tools assume this convention:

• 'black outputs spaces'
• many editors insert spaces when you press Tab in Python mode
• linters and code review tools expect space-based indentation

Once the ecosystem converges, choosing spaces is not only technically safer but also socially cheaper because it matches nearly every shared codebase.

It Is Mostly a Portability and Clarity Rule

The recommendation is not based on spaces being morally superior. It is based on reducing surprises.

With spaces, the indentation seen in the editor is the indentation encoded in the file. That property is especially valuable in Python because indentation changes meaning.

So the real argument is:

• spaces are explicit
• spaces display consistently
• spaces reduce editor-dependent rendering differences
• spaces make collaboration and tooling simpler

That is why PEP 8 uses strong language here.

Common Pitfalls

A common mistake is thinking tabs are harmless because the local editor shows them nicely. The problem appears when the file moves to another editor, machine, or code review tool.

Another mistake is mixing tabs and spaces accidentally because the editor inserts one style sometimes and another style elsewhere. Configure the editor explicitly for Python.

People also sometimes argue that tabs save bytes or keystrokes. That misses the real issue in Python, which is semantic clarity and consistency, not file-size micro-optimizations.

Finally, do not rely on visual alignment tricks that depend on tab width. Python code is easier to maintain when indentation means only block structure.

Summary

• PEP 8 prefers spaces because indentation is part of Python syntax.
• Tabs can display differently across editors and create ambiguity.
• Mixing tabs and spaces is especially error-prone in Python.
• Four spaces has become the stable ecosystem convention.
• The recommendation is mainly about portability, readability, and avoiding indentation bugs.