Stop Using String Concatenation for Paths: A Guide to Python's pathlib

For a long time, the standard way to work with filesystem paths in Python was to use the os.path module. This involved a lot of string manipulation, which was often clumsy and error-prone, especially when dealing with cross-platform differences between Windows (\) and macOS/Linux (/).

Since Python 3.4, there has been a better way: the pathlib module. It provides a beautiful, object-oriented interface for filesystem paths that is both powerful and intuitive.

If you're still concatenating strings to build paths, it's time to make the switch.

Why pathlib is Better

• Object-Oriented: Paths are objects, not strings. This means they have methods and properties that make working with them much cleaner.
• Cross-Platform by Default: pathlib automatically handles the differences between path separators on different operating systems.
• More Readable: The code you write with pathlib is often more expressive and easier to understand.
• Less Importing: Many common file operations that would have required importing os, shutil, and glob can now be done directly from a Path object.

The Old Way vs. The pathlib Way

Let's look at a simple example. Imagine you have a path to a directory and you want to construct a path to a file inside it.

The Old Way (with os.path):

import os

data_dir = 'data/raw'
file_name = '2023-01-20.csv'

# This is okay, but a bit verbose
file_path = os.path.join(data_dir, file_name)

print(file_path) # Output: data/raw/2023-01-20.csv

The pathlib Way:

from pathlib import Path

data_dir = Path('data/raw')
file_name = '2023-01-20.csv'

# Use the / operator for joining paths
file_path = data_dir / file_name

print(file_path) # Output: data/raw/2023-01-20.csv

The use of the / operator is not just syntactic sugar; it's a powerful and intuitive way to build paths. The resulting file_path is not a string, but a PosixPath or WindowsPath object.

Common pathlib Operations

Here are some of the most useful properties and methods of a Path object.

from pathlib import Path

file_path = Path('data/processed/report.txt')

# --- Accessing parts of the path ---
print(f"Parent directory: {file_path.parent}") # data/processed
print(f"File name: {file_path.name}")         # report.txt
print(f"File stem (name without extension): {file_path.stem}") # report
print(f"File extension: {file_path.suffix}")     # .txt

# --- Checking path properties ---
print(f"Does it exist? {file_path.exists()}")
print(f"Is it a file? {file_path.is_file()}")
print(f"Is it a directory? {file_path.is_dir()}")

# --- Modifying paths ---
# Change the file extension
new_path = file_path.with_suffix('.md')
print(f"New path: {new_path}") # data/processed/report.md

# Get the absolute path
print(f"Absolute path: {file_path.resolve()}")

Reading and Writing Files

pathlib makes simple file I/O incredibly easy. You no longer need to use with open(...) for basic cases.

from pathlib import Path

my_file = Path('greeting.txt')

# Write text to a file (overwrites if it exists)
my_file.write_text('Hello, pathlib!')

# Read text from a file
content = my_file.read_text()
print(content)

# You can also do the same with bytes
my_file.write_bytes(b'Hello, bytes!')
bytes_content = my_file.read_bytes()

Creating and Deleting Files and Directories

from pathlib import Path

# Create a new directory
data_dir = Path('my_new_data')
data_dir.mkdir(exist_ok=True) # exist_ok=True prevents an error if it already exists

# Create a file inside it
new_file = data_dir / 'test.txt'
new_file.touch() # Creates an empty file

# Delete the file
new_file.unlink()

# Delete the (now empty) directory
data_dir.rmdir()

Iterating Over Directories

pathlib provides a clean way to list the contents of a directory, replacing the need for os.listdir and glob.

from pathlib import Path

project_dir = Path('.')

# Iterate over all items in the directory
for item in project_dir.iterdir():
    print(item)

# Use glob to find all Python files recursively
for py_file in project_dir.glob('**/*.py'):
    print(py_file)

Conclusion

The pathlib module is a significant improvement over the older, string-based methods for handling filesystem paths. It's more readable, more robust, and more Pythonic. By embracing its object-oriented approach, you can write cleaner and more maintainable code. For any new Python project, pathlib should be your default choice for all filesystem path operations.