Problem Statement: What is the most convenient approach to verify if a directory to which a file is going to be written already exists or not, and if not, how to create the nested directory using Python?
Introducing the Problem
Sometimes you need to store/organize the data/information outside the current working script/program in files that can later be referred to by another application. You can either choose to build up another directory within the root directory itself in which you can save the files, or you can opt to create a subfolder/nested directory within the same working directory of your project and separately store the external files in that directory. Here’s a visual example in Pycharm-
In the above example, how would you check if directory “dir_a.1” exists or not? If not, how will you create it before storing the files in it?
Now that you have a clear picture of the problem at hand, let’s look at the different methods to safely create a nested directory.
Instruction: Consider that we have two directories:- “dir_A” and “dir_a.1” where “dir_A” is the parent directory and “dir_2” is the nested directory.
Method 1- Using pathlib.Path.mkdir
We can safely create a nested directory in Python 3.5 and above using
mkdir() method of the pathlib module we first have to import
Path from the
from pathlib import Path
Further, we need to create a Path object that includes the directory paths to be created and then link the object to the
.mkdir() method to create the directory. Then we will simply call
mkdir() method and set two parameters within it, i.e.,
When the directory Already exists then by default
exist_OK is False and it raises
FileExistsError if the given directory already exists. To avoid this error, you can set
exist_OK to True.
from pathlib import Path p = Path('/root/dir_A/dir_a.1') p.mkdir(parents = True, exist_ok = True)
Path.mkdir returns the FileNotFoundError if the parent directory (in this case
dir_A) is missing, i.e if the
parent = False.
To avoid this error ensure that the parent folder (
dir_A) is either present or set
Caution: In the Python 3.4 version the pathlib module is missing the
Method 2- Using os.makedirs
Another approach using which we create a nested directory in Python 3.2 versions and newer is by using the
makedirs method. You have to import the os module in your code to access system-specific functions.
The os.makedirs() method constructs a directory recursively. It takes the path as an input and creates the missing intermediate directories. We can even use the
os.makedirs method to create a folder inside an empty folder. In this case, the path to the folder you want to create will be the only single argument to
Scenario I: When the parent directory and child directory does not exist.
import os os.makedirs('./dir_A/dir_a.1')
Caution: You must always ensure that the path provided to the os.makedirs is the full path, i.e. the absolute path of the directory. It must not be the relative path or the program won’t run successfully.
Scenario 2: In case a directory already exists, the code given above will raise an exception as shown below.
To avoid this error we can use exception handling to along with the
os.makedirs method. For this, we will use the try and except statements such that when the folder does not exist then the except block gets executed and the error is bypassed. The advantage of using try-except is that even when the directory does not exist, Python will create it.
import os try: os.makedirs('./dir_A/dir_a.1') except: print("Directory Already Exists!")
We will receive the following output if the directory already exists:
Directory Already Exists!
Bonus Read: One more condition that can occur is that if the directory gets created between the
os.path.exists and the
os.makedirs calls, the
os.makedirs call fails and throws an OSError. However, even if you catch the OSError and proceed- it will overlook the failure to create the directory because of the other factors, such as insufficient permissions, full disk, etc. One solution to solve this is to use exception handling:
# Importing the os module import os, errno # Exception handling try: os.makedirs('/dir_A/dir_a.1') except OSError as e: if e.errno != errno.EEXIST: print(' The given directory already exists')
Note: Capturing the exception and using Errno is not that useful because the OSError: File exists, i.e. errno.EEXIST, is raised for both files and directories. Hence, it is advisable to simply check if the directory exists.
Method 3- Using distutils.dir_util
The distutils.dir_util module is used to operate on directories and trees of directories and, hence we can use this module to safely create a nested directory. We have to import the distutils.dir_util module before using it in our program.
In the following program, we use the mkpath() method to check whether the directory exists or not. We will do nothing if the directory already exists. We can also raise the distutilsFileError if the program is unable to create the directory, i.e. subpath exists but is a file rather than a directory.
# Import the distutils.dir_util module import distutils.dir_util distutils.dir_util.mkpath("./dir_A/dir_a.1")
Method 4 – The Conventional Way
Another approach to this problem is to take the conventional path. We will once again use the almighty os module.
- In case the directories are not present, simply go ahead and check whether the directory is present or not using the os.path.isdir method.
- If the directories are not present, go ahead and create them using os.mkdirs method.
- If the directories are already present, do nothing.
import os # When directories are already present if os.path.isdir("./dir_A/dir_a.1"): print("Directories Already Present!") # When directories are not present else: os.makedirs('./dir_A/dir_a.1')
We looked at different methods to safely create a nested directory in Python. I hope it has helped to answer your queries. Please subscribe and stay tuned for more interesting articles in the future.
Recommended Read: How Do I List All Files of a Directory in Python?
Finxter Computer Science Academy
- One of the most sought-after skills on Fiverr and Upwork is web scraping. Make no mistake: extracting data programmatically from websites is a critical life skill in today’s world that’s shaped by the web and remote work.
- So, do you want to master the art of web scraping using Python’s BeautifulSoup?
- If the answer is yes – this course will take you from beginner to expert in Web Scraping.