How to Minify Python Code (Tested Size Reductions)

Python ignores comments, docstrings, and blank lines at runtime, and it doesn't care whether your variables are named total_area or A. Minifiers exploit exactly that. Here's a small, readable script we'll shrink:

import math


def circle_area(radius):
    """Return the area of a circle with the given radius."""
    # multiply pi by r squared
    result = math.pi * radius ** 2
    return result


data = [("small", 1.0), ("medium", 2.5), ("large", 4.0)]
for name, r in data:
    print(f"{name}: {circle_area(r):.2f}")

The quickest path: paste your script into the free Python Minifier. It runs in your browser (nothing uploaded), strips the non-essentials, and hands back a compact, still-runnable script you can copy. Good when you just need a smaller file once and don't want to install anything.

For scripting or a build step, the python-minifier package does the same job with fine-grained control:

import python_minifier

src = open('circles.py').read()

# Safe: strip comments, docstrings, blank lines — keep names
small = python_minifier.minify(src, rename_locals=False, rename_globals=False)

# Max: also rename identifiers to single letters
tiny = python_minifier.minify(src, rename_locals=True, rename_globals=True)

open('circles.min.py', 'w').write(tiny)

Here are the actual sizes I measured on the script above:

And the fully-minified output — same program, renamed and crushed onto few lines:

import math
def A(radius):'Return the area of a circle with the given radius.';return math.pi*radius**2
for(B,C)in[("small",1.),("medium",2.5),("large",4.)]:print(f"{B}: {A(C):.2f}")

This is the trap. Minified code *looks* scrambled, so people assume it's protected. It isn't — every string literal is still sitting there in plain text, and a formatter re-expands the structure in one click. Watch a "secret" survive full minification:

python_minifier.minify('API_KEY = "sk-live-9f83"\nprint(API_KEY)', rename_globals=True)
# ->  A='sk-live-9f83'\nprint(A)
#     'sk-live-9f83' still present:  True

The honest use cases and the honest limits:

• Do minify to reduce file size — embedding a script in another file, fitting a size-limited field, or shipping fewer bytes over the wire.
• Don't expect a speed-up. Python compiles to bytecode before running, and whitespace and variable names don't survive into that bytecode — so a minified script runs at the *same* speed. Minification saves bytes on disk, not CPU cycles.
• Don't treat it as protection — it's fully reversible and leaks every string.
• Keep your real source in version control and minify as a build step; never hand-edit minified code.

If it's raw size you care about and the file is only *transported*, gzipping it usually beats minifying (and stacks with it). Minify when the Python itself must stay small in its final form.