os.path.join() Function Explained

os.path.join() combines file and folder names into a single path string.

Beginners should use it instead of joining path parts by hand because it uses the correct path separator for the current operating system. This helps you avoid mistakes with / and \ when your code runs on different computers.

Quick example

import os

file_path = os.path.join("data", "reports", "output.txt")
print(file_path)

What this does:

Combines "data", "reports", and "output.txt" into one path
Returns the path as a string
Does not create the file or folder

On one system, the output might look like this:

data/reports/output.txt

On another system, it might use a different separator.

Use os.path.join() to combine folder and file names into one path without manually typing path separators.

What `os.path.join()` does

os.path.join() is used to build paths safely.

It:

Combines multiple path parts into one path string
Uses the correct path separator for the current operating system
Helps avoid mistakes from manually adding / or \
Is useful when building file and folder paths step by step

This is part of the os module, which contains tools for working with the operating system.

Basic syntax

A common form looks like this:

import os

path = os.path.join("folder", "file.txt")
print(path)

How it works

Each argument is one part of the path
The function returns a new string
It only builds the path
It does not create the file or folder

You can think of it as a safer replacement for writing something like:

folder + "/" + file_name

That manual approach is more error-prone.

Simple example

Here is a basic example with one folder and one file name:

import os

path = os.path.join("images", "photo.jpg")
print(path)

Possible output:

images/photo.jpg

Why this is useful

The result depends on the operating system
Your code is easier to move between computers
You do not have to remember which separator to use

This becomes especially helpful when you later open the file with the open() function.

Joining many path parts

You can pass more than two parts to os.path.join().

import os

base_folder = "projects"
subfolder = "python"
filename = "notes.txt"

path = os.path.join(base_folder, subfolder, filename)
print(path)

Why this is helpful

Useful for nested folders
Easier to read than long string concatenation
Good when path parts come from variables

Without os.path.join(), beginners often write code like this:

base_folder + "/" + subfolder + "/" + filename

That works in some cases, but it is easier to make mistakes.

Important behavior to know

There are a few details beginners should understand.

A later absolute path can override earlier parts

If one of the later arguments is an absolute path, earlier parts may be ignored.

import os

path = os.path.join("folder", "/tmp", "file.txt")
print(path)

On many systems, the result will start from "/tmp" instead of "folder".

So if your final path looks wrong, check whether one argument is an absolute path.

Empty strings can affect the result

Empty strings do not always cause an error, but they can change the final path.

import os

path = os.path.join("data", "", "file.txt")
print(path)

This may still produce a valid path, but it is a good idea to inspect your inputs if the result is unexpected.

It does not check whether the path exists

os.path.join() only builds a string.

It does not:

check whether the file exists
check whether the folder exists
create anything on disk

If you need to test whether the path exists, use os.path.exists().

Example:

import os

path = os.path.join("data", "file.txt")
print(os.path.exists(path))

When to use it

Use os.path.join() whenever you need to build a path from separate parts.

Common examples:

Opening files in subfolders
Saving output files
Looping through file names in a directory
Writing code that should work across operating systems

Example:

import os

folder = "data"
filename = "report.txt"
path = os.path.join(folder, filename)

with open(path, "r") as file:
    content = file.read()

print(content)

If you want a broader explanation of path building, see working with file paths in Python.

Common beginner mistakes

These are some common problems beginners run into.

Using `+` to join path pieces

This is a common habit:

folder = "data"
file_name = "report.txt"

path = folder + "/" + file_name
print(path)

This may work, but it is less safe and less readable than os.path.join().

Mixing manual separators with `os.path.join()`

Avoid writing code like this:

import os

path = os.path.join("data/", "report.txt")
print(path)

It is better to pass clean path parts:

import os

path = os.path.join("data", "report.txt")
print(path)

Assuming the function creates folders

os.path.join() does not create anything.

If you build a path like "logs/output.txt", the logs folder will not be created automatically.

Passing non-string values

Path parts should usually be strings.

This can cause problems:

import os

year = 2024
path = os.path.join("reports", year)
print(path)

Use str() when needed:

import os

year = 2024
path = os.path.join("reports", str(year), "summary.txt")
print(path)

Common causes of confusion

Manually writing paths like folder + '/' + file
Using Windows-style backslashes directly in strings
Expecting os.path.join() to verify or create a path
Accidentally passing an absolute path as a later argument

If you are checking whether a file is really there after building the path, see how to check if a file exists in Python.

FAQ

Does `os.path.join()` create a folder or file?

No. It only returns a path string.

Why should I use `os.path.join()` instead of writing `/` yourself?

It uses the correct separator for the current operating system and reduces path formatting mistakes.

Can `os.path.join()` join more than two parts?

Yes. You can pass as many path parts as needed.

What if one part is an absolute path?

A later absolute path can override earlier parts, so the final result may not include everything you passed in.