Python Create Directory Recursively

If you need a folder tree such as data/reports/2026 before writing logs or exports, Python’s standard library gives you two solid tools: pathlib.Path.mkdir (usually preferred) and os.makedirs. This page puts pathlib first, matches the official Path.mkdir signature (parents, exist_ok), then covers os.makedirs, comparisons, creating parents before saving a file, errors, and why distutils is obsolete.

Examples use relative paths like data/reports/2026 and, where a full path helps, Path.home() / "reports" so the ideas work on Windows and Linux. Each fenced example is a complete script (imports included) that creates directories under tempfile.TemporaryDirectory() so it does not touch your project tree. Those operations are file system I/O: the opening fences use {run=false} so the in-page Run control is not offered on Cloudflare Pages (Judge0 may block or vary temp filesystem behavior). Copy the snippet into a local python3 shell or script for the same output.

Tested on: Python 3.13.3; kernel 6.14.0-37-generic.

Best way to create directories recursively in Python

Use pathlib.Path with parents=True (create missing parents) and exist_ok=True (do not fail if the leaf directory already exists):

import tempfile
from pathlib import Path

with tempfile.TemporaryDirectory() as tmp:
    path = Path(tmp) / "logs" / "2026" / "06"
    path.mkdir(parents=True, exist_ok=True)
    print(path.is_dir())

You should see True: the whole chain logs/2026/06 exists under the temp root. That pattern maps directly to project code such as Path("data/reports/2026") when tmp is your working tree.

Create nested directories using pathlib Path.mkdir()

Path.mkdir follows mkdir(mode=0o777, parents=False, exist_ok=False) in the docs. For nested trees you almost always want parents=True. Use mode= only when you care about permission bits on POSIX; on Windows it may be partially ignored.

import tempfile
from pathlib import Path

with tempfile.TemporaryDirectory() as tmp:
    nested = Path(tmp) / "data" / "reports" / "2026"
    nested.mkdir(parents=True, exist_ok=False)
    print(nested)

Running it prints an absolute path ending in .../data/reports/2026. A second run with the same path and exist_ok=False would raise FileExistsError unless you set exist_ok=True.

Create directory if it does not exist using pathlib

Set exist_ok=True when rerunning scripts or tests should not crash if the directory is already there. The docs note that exist_ok=True does not help if a file already sits where you want a directory—you still get FileExistsError. See check if a path exists before creating when you expect collisions.

import tempfile
from pathlib import Path

with tempfile.TemporaryDirectory() as tmp:
    path = Path(tmp) / "cache" / "session"
    path.mkdir(parents=True, exist_ok=True)
    path.mkdir(parents=True, exist_ok=True)
    print("ok", path.is_dir())

You should see ok True twice in spirit—the second mkdir is a no-op for an existing directory.

Create nested directories using os.makedirs()

os.makedirs creates the leaf directory and any intermediate ones. With exist_ok=False (the default), an existing target directory raises FileExistsError.

import os
import tempfile

with tempfile.TemporaryDirectory() as tmp:
    target = os.path.join(tmp, "logs", "2026", "06")
    os.makedirs(target, exist_ok=True)
    print(os.path.isdir(target))

You should see True. Prefer os.path.join (or pathlib) over hardcoding \ or / so the same code runs cross-platform.

Create directory if it does not exist using os.makedirs

Pass exist_ok=True for idempotent setup, the same idea as Path.mkdir(..., exist_ok=True).

import os
import tempfile

with tempfile.TemporaryDirectory() as tmp:
    target = os.path.join(tmp, "out", "render")
    os.makedirs(target, exist_ok=True)
    os.makedirs(target, exist_ok=True)
    print("ready")

This prints ready without error. If a file named render already exists, both APIs fail with FileExistsError when you try to create a directory at that path.

pathlib mkdir vs os.makedirs

Pick one style per module for consistency; mixing is fine at boundaries if you convert with Path(p) or os.fspath(p).

Create parent folders before writing a file

Real code often needs the parent of a file path, not the file itself:

import tempfile
from pathlib import Path

with tempfile.TemporaryDirectory() as tmp:
    file_path = Path(tmp) / "reports" / "2026" / "june" / "output.txt"
    file_path.parent.mkdir(parents=True, exist_ok=True)
    file_path.write_text("Report generated")
    print(file_path.read_text())

You should see Report generated. On user-owned trees you can build under the home directory without hardcoding separators, for example Path.home() / "reports" / "2026" (same mkdir on .parent before writing). The same mkdir(parents=True, exist_ok=True) on target.parent is required before a rename or move in Python when the destination folder does not exist yet.

Handle errors while creating directories

Catch PermissionError when the process lacks rights, and OSError for other platform issues (disk full, read-only filesystem, invalid name).

import tempfile
from pathlib import Path

with tempfile.TemporaryDirectory() as tmp:
    path = Path(tmp) / "logs" / "2026" / "06"
    try:
        path.mkdir(parents=True, exist_ok=True)
        print("created", path.is_dir())
    except PermissionError:
        print("Permission denied")
    except OSError as error:
        print(f"Could not create directory: {error}")

In normal temp setups this prints created True. For more on failures when opening paths, see FileNotFoundError in Python.

Why distutils.dir_util.mkpath should be avoided

Older tutorials used distutils.dir_util.mkpath(). distutils was removed from the standard library in Python 3.12 (deprecated earlier in 3.10). Do not teach it as a current option; use pathlib.Path.mkdir or os.makedirs instead and migrate any legacy mkpath call sites.

Common mistakes when creating directories

• Omitting parents=True and then wondering why a nested path raises FileNotFoundError because an intermediate folder is missing.
• Omitting exist_ok=True in idempotent jobs so reruns raise FileExistsError even though the tree is already correct.
• Importing or copying distutils examples into a Python 3.12+ environment where the module is gone.
• Calling mkdir on a path where a file already exists with the same name—both pathlib and os refuse to replace a file with a directory via these calls.
• Hardcoding C:\... or mixing / and \ by hand; prefer Path(...) or os.path.join.
• Opening Path("reports/june.txt") for write without creating Path("reports") first—create .parent (or use open helpers that document who creates parents).
• Swallowing all errors: at minimum distinguish PermissionError from other OSError types so operators can react.

Python create directory quick reference table

Summary

For recursive directory creation in current Python, start with pathlib.Path.mkdir(parents=True, exist_ok=True); use os.makedirs(..., exist_ok=True) when string paths and the os module fit your codebase. Create parent directories before writing files with file_path.parent.mkdir(...). Handle PermissionError and OSError, and do not rely on distutils—it is gone from the stdlib in 3.12+. For writing after the tree exists, follow up with write to file patterns in your app.

References

• pathlib.Path.mkdir (Python 3)
• os.makedirs (Python 3)
• PEP 632 — Removal of distutils