How To Navigate the Filesystem with Python’s Pathlib

Picture by Creator

In Python, utilizing common strings for filesystem paths is usually a ache, particularly if you must carry out operations on the trail strings. Switching to a special working system causes breaking modifications to your code, too. Sure, you need to use os.path from the os module to make issues simpler. However the pathlib module makes all of this way more intuitive.

The pathlib module launched in Python 3.4 (yeah, it’s been round for some time) permits for an OOP method that allows you to create and work with path objects, and comes with batteries included for widespread operations resembling becoming a member of and manipulating paths, resolving paths, and extra.

This tutorial will introduce you to working with the file system utilizing the pathlib module. Let’s get began.

Working with Path Objects

To start out utilizing pathlib, you first must import the Path class:

Which lets you instantiate path objects for creating and manipulating file system paths.

Creating Path Objects

You’ll be able to create a Path object by passing in a string representing the trail like so:

path = Path('your/path/right here')

You’ll be able to create new path objects from current paths as properly. For example, you possibly can create path objects from your house listing or the present working listing:

home_dir = Path.dwelling()
print(home_dir)

cwd = Path.cwd()
print(cwd)

This could provide you with an identical output:

Output >>>
/dwelling/balapriya
/dwelling/balapriya/project1

Suppose you’ve got a base listing and also you need to create a path to a file inside a subdirectory. Right here’s how you are able to do it:

from pathlib import Path

# import Path from pathlib
from pathlib import Path

# create a base path
base_path = Path("/dwelling/balapriya/Paperwork")

# create new paths from the bottom path
subdirectory_path = base_path / "initiatives"https://www.kdnuggets.com/"project1"
file_path = subdirectory_path / "report.txt"

# Print out the paths
print("Base path:", base_path)
print("Subdirectory path:", subdirectory_path)
print("File path:", file_path)

This primary creates a path object for the bottom listing: /dwelling/balapriya/Paperwork. Bear in mind to switch this base path with a legitimate filesystem path in your working setting.

It then creates subdirectory_path by becoming a member of base_path with the subdirectories initiatives and project1. Lastly, the file_path is created by becoming a member of subdirectory_path with the filename report.txt.

As seen, you need to use the / operator to append a listing or file identify to the present path, creating a brand new path object. Discover how the overloading of the / operator gives a readable and intuitive technique to be a part of paths.

While you run the above code, it’s going to output the next paths:

Output >>>
Base path: /dwelling/balapriya/paperwork
Subdirectory path: /dwelling/balapriya/paperwork/initiatives/project1
File path: /dwelling/balapriya/paperwork/initiatives/project1/report.txt

Checking Standing and Path Varieties

Upon getting a legitimate path object, you possibly can name easy strategies on it to verify the standing and sort of the trail.

To verify if a path exists, name the exists() technique:

path = Path("/dwelling/balapriya/Paperwork")
print(path.exists())

If the trail exists, it outputs True; else, it returns False.

You may as well verify if a path is a file or listing:

print(path.is_file())
print(path.is_dir())

Be aware: An object of the Path class creates a concrete path on your working system. However it’s also possible to use PurePath when you must deal with paths with out accessing the filesystem, like working with Home windows path on a Unix machine.

Navigating the Filesystem

Navigating the filesystem is fairly easy with pathlib. You’ll be able to iterate over the contents of directories, rename and resolve paths, and extra.

You’ll be able to name the iterdir() technique on the trail object like so to iterate over all of the contents of a listing:

path = Path("/dwelling/balapriya/project1")

# iterating over listing contents

for merchandise in path.iterdir():
    print(merchandise)

Right here’s the pattern output:

Output >>>
/dwelling/balapriya/project1/take a look at.py
/dwelling/balapriya/project1/fundamental.py

Renaming Information

You’ll be able to rename recordsdata by calling the rename() technique on the trail object:

path = Path('old_path')
path.rename('new_path')

Right here, we rename take a look at.py within the project1 listing to assessments.py:

path = Path('/dwelling/balapriya/project1/take a look at.py')
path.rename('/dwelling/balapriya/project1/assessments.py')

Now you can cd into the project1 listing to verify if the file has been renamed.
 

Deleting Information and Directories

You may as well delete a file and take away empty directories with the unlink() to and rmdir() strategies, respectively.

# For recordsdata
path.unlink()   

# For empty directories
path.rmdir()  

Be aware: Properly, in case deleting empty directories acquired you interested in creating them. Sure, it’s also possible to create directories with mkdir() like so: path.mkdir(mother and father=True, exist_ok=True). The mkdir() technique creates a brand new listing. Setting mother and father=True permits the creation of father or mother directories as wanted, and exist_ok=True prevents errors if the listing already exists.

Resolving Absolute Paths

Typically, it’s simpler to work with relative paths and broaden to absolutely the path when wanted. You are able to do it with the resolve() technique, and the syntax is tremendous easy:

absolute_path = relative_path.resolve()

Right here’s an instance:

relative_path = Path('new_project/README.md')
absolute_path = relative_path.resolve()
print(absolute_path)

And the output:

Output >>> /dwelling/balapriya/new_project/README.md

File Globbing

Globbing is tremendous useful for locating recordsdata matching particular patterns. Let’s take a pattern listing:

projectA/
├── projectA1/
│   └── information.csv
└── projectA2/
	├── script1.py
	├── script2.py
	├── file1.txt
	└── file2.txt

Right here’s the trail:

path = Path('/dwelling/balapriya/projectA')

Let’s attempt to discover all of the textual content recordsdata utilizing glob():

text_files = listing(path.glob('*.txt'))
print(text_files)

Surprisingly, we don’t get the textual content recordsdata. The listing is empty:

It’s as a result of these textual content recordsdata are within the subdirectory and glob doesn’t search by way of subdirectories. Enter recursive globbing with rglob().

text_files = listing(path.rglob('*.txt'))
print(text_files)

The rglob() technique performs a recursive seek for all textual content recordsdata within the listing and all its subdirectories. So we should always get the anticipated output:

Output >>>
[PosixPath('/home/balapriya/projectA/projectA2/file2.txt'), 
PosixPath('/home/balapriya/projectA/projectA2/file1.txt')]

And that is a wrap!

Wrapping Up

On this tutorial, we have explored the pathlib module and the way it makes file system navigation and manipulation in Python accessible. We’ve lined sufficient floor that will help you create and work with filesystem paths in Python scripts.

You’ll find the code used on this tutorial on GitHub. Within the subsequent tutorial, we’ll have a look at attention-grabbing sensible functions. Till then, preserve coding!

Bala Priya C is a developer and technical author from India. She likes working on the intersection of math, programming, information science, and content material creation. Her areas of curiosity and experience embrace DevOps, information science, and pure language processing. She enjoys studying, writing, coding, and low! At the moment, she’s engaged on studying and sharing her data with the developer group by authoring tutorials, how-to guides, opinion items, and extra. Bala additionally creates participating useful resource overviews and coding tutorials.