How to Create a Directory and Missing Parent Directories in Python

By the end of this page, you will understand how to create directories in Python, including nested parent directories that do not already exist. You will learn the most common approaches, how os.makedirs() and pathlib.Path.mkdir() work, what the exist_ok option does, and how to avoid common mistakes when working with filesystem paths.

Creating a directory is a basic filesystem operation. Sometimes you only need to create one folder, but often the full path includes parent folders that may not exist yet.

For example, if you want to create:

reports/2026/april/summary

Python cannot place summary inside april if reports, 2026, or april do not already exist. That is why Python provides ways to create the whole path at once.

The two main tools are:

• os.makedirs() from the os module
• Path.mkdir() from the pathlib module

These let you create a directory and, if needed, create missing parent directories too.

This matters in real programming because many programs need to:

• create output folders before saving files
• prepare upload or cache directories
• initialize project structure
• ensure logs or temporary folders exist

Without this step, file-writing code often fails with errors like FileNotFoundError.

Think of a directory path like a set of nested boxes:

• reports is the outer box
• 2026 is a box inside it
• april is inside that
• summary is the final box you want to create

If the outer boxes do not exist, you cannot place the inner box inside them.

Using normal single-directory creation is like saying, "Create only the final box." That fails if the larger boxes are missing.

Using makedirs() or parents=True is like saying, "Build every missing box along the way."

Using os.makedirs()

import os

os.makedirs("path/to/nested/directory", exist_ok=True)

What this does

• creates directory
• creates nested if needed
• creates to if needed
• creates path if needed
• does not raise an error if the directory already exists because exist_ok=True

Using pathlib.Path.mkdir()

from pathlib import Path

path = Path("path/to/nested/directory")
path.mkdir(parents=True, exist_ok=True)

What this does

• parents=True means create missing parent directories
• exist_ok=True means do not fail if the directory already exists

Beginner-friendly example

Consider this example:

from pathlib import Path

path = Path("data/raw/2026")
path.mkdir(parents=True, exist_ok=True)
print("Done")

Step-by-step

1. from pathlib import Path

   • Imports the Path class for working with filesystem paths.

2. path = Path("data/raw/2026")

   • Creates a path object representing the directory you want.
   • No directory is created yet.

3. path.mkdir(parents=True, exist_ok=True)

   • Python checks whether data exists.
   • If not, it creates data.
   • Then it checks whether data/raw exists.
   • If not, it creates raw.
   • Then it checks whether data/raw/2026 exists.
   • If not, it creates 2026.

Common practical uses

Saving generated files

A script that creates reports, exports CSV files, or writes images often needs to create an output folder first.

from pathlib import Path

report_dir = Path("exports/daily")
report_dir.mkdir(parents=True, exist_ok=True)

Application logging

An app may write logs into a nested folder such as var/log/myapp.

Upload storage

A web application may need user-specific folders before storing uploaded files.

Cache or temp data

Programs often create cache directories to store processed results.

Project setup scripts

A setup script can initialize folders like:

• src
• tests
• docs
• build/output

Creating missing parent directories makes these scripts reliable and repeatable.

In real projects, developers usually do not create directories manually in many places. Instead, they use a small, consistent pattern.

Common pattern: ensure directory exists before writing

from pathlib import Path

file_path = Path("reports/2026/april/summary.txt")
file_path.parent.mkdir(parents=True, exist_ok=True)
file_path.write_text("Monthly summary")

This is very common because you usually care about writing a file, not just creating a folder.

Guard-style setup code

Programs often prepare required directories at startup:

from pathlib import Path

for folder in ["logs", "data/cache", "data/uploads"]:
    Path(folder).mkdir(parents=True, exist_ok=True)

Configuration-driven paths

Applications may read output paths from config files or environment variables, then create them safely before use.

Error handling

Sometimes developers still wrap directory creation in try/except to handle permission problems or invalid paths:

from pathlib  Path

:
    Path().mkdir(parents=, exist_ok=)
 OSError  e:
    ()

1. Using mkdir() without creating parents

Broken example:

from pathlib import Path

Path("a/b/c").mkdir()

If a or a/b does not exist, this fails.

Fix:

Path("a/b/c").mkdir(parents=True, exist_ok=True)

2. Forgetting exist_ok=True

Broken example:

import os

os.makedirs("data/output")

This raises FileExistsError if the directory already exists.

Fix:

os.makedirs("data/output", exist_ok=True)

3. Creating the file path instead of the parent directory

Broken example:

 pathlib  Path

file_path = Path()
file_path.mkdir(parents=, exist_ok=)

os.makedirs() vs Path.mkdir()

# Preferred modern style
from pathlib import Path
Path("a/b/c").mkdir(parents=True, exist_ok=True)

# Classic os style
import os
os.makedirs("a/b/c", exist_ok=True)

Key options

• parents=True: create missing parent directories
• exist_ok=True: do not raise an error if the directory already exists

Common patterns

Create a nested folder

Path("logs/app/2026").mkdir(parents=True, exist_ok=True)

Ensure a file's parent folder exists

file_path = Path("exports/report.txt")
file_path.parent.mkdir(parents=True, exist_ok=True)

Important notes

• Path.mkdir() without parents=True fails if parent folders are missing.
• exist_ok=True does not hide permission errors.

How do I do mkdir -p in Python?

Use either:

os.makedirs(path, exist_ok=True)

or:

Path(path).mkdir(parents=True, exist_ok=True)

What does exist_ok=True mean?

It tells Python not to raise an error if the directory already exists.

What is the difference between os.mkdir() and os.makedirs()?

os.mkdir() creates one directory. os.makedirs() can create the full nested path, including missing parent directories.

Should I use os or pathlib?

Both work. For modern Python, pathlib is often easier to read and maintain.

Can directory creation still fail with exist_ok=True?

Yes. It can still fail because of permissions, invalid paths, or if part of the path is a file instead of a directory.

How do I create the parent folder for a file path?

• pathlib.Path — Modern path handling in Python using objects instead of plain strings.
• os module — Traditional filesystem and operating system tools in Python.
• File I/O — Directory creation is often needed before reading from or writing to files.
• Exception handling — Filesystem operations can fail and should sometimes be wrapped in try/except.
• Absolute vs relative paths — Important for understanding where directories are created.
• Working directory — Relative paths depend on the current working directory of the program.