Introduction
In Python, we regularly must work together with the file system, whether or not it is studying information, writing to them, or creating directories. This Byte will give attention to the way to create directories in Python, and extra particularly, the way to create a listing and any lacking father or mother directories. We’ll be exploring the os.mkdir and os.makedirs features for this objective.
Why do we have to create the father or mother directories?
When working with file methods, which is widespread for system utilities or instruments, you may possible must create a listing at a sure path. If the father or mother directories of that path do not exist, you may encounter an error.
To keep away from this, you may must create all vital father or mother directories for the reason that OS/filesystem does not deal with this for you. By making certain all the required father or mother directories exist earlier than creating the goal listing, you possibly can keep away from these errors and have a extra dependable codebase.
Making a Listing Utilizing os.mkdir
The os.mkdir operate in Python is used to create a listing. This operate takes the trail of the brand new listing as an argument. This is a easy instance:
import os
os.mkdir('my_dir')
It will create a brand new listing named my_dir within the present working listing. Nonetheless, os.mkdir has a limitation – it may well solely create the ultimate listing within the specified path, and assumes that the father or mother directories exist already. If they do not, you may get a FileNotFoundError.
import os
os.mkdir('parent_dir/my_dir')
If parent_dir does not exist, this code will increase a FileNotFoundError.
Word: The os.mkdir operate will even increase a FileExistsError if the listing you are attempting to create already exists. It is at all times an excellent apply to examine if a listing exists earlier than attempting to create it. To do that, you possibly can cross the exist_ok=True argument, like this: os.makedirs(path, exist_ok=True). It will make the operate do nothing if the listing already exists.
One strategy to work across the limitation of os.mkdir is to manually examine and create every father or mother listing main as much as the goal listing. The simplest strategy to method this drawback is to separate our path by the slashes and examine each. This is an instance of how you are able to do that:
import os
path = 'parent_dir/sub_dir/my_dir'
# Break up the trail into components
components = path.cut up('/')
# Begin with an empty listing path
dir_path = ''
# Iterate by way of the components, creating every listing if it does not exist
for half in components:
dir_path = os.path.be a part of(dir_path, half)
if not os.path.exists(dir_path):
os.mkdir(dir_path)
This code will create parent_dir, sub_dir, and my_dir if they do not exist already, making certain that the father or mother directories are created earlier than the goal listing.
Nonetheless, there is a extra concise strategy to obtain the identical objective by utilizing the os.makedirs operate, which we’ll see within the subsequent part.
Creating Mother or father Directories Utilizing os.makedirs
To beat the limitation of os.mkdir, Python gives one other operate – os.makedirs. This operate creates all of the intermediate stage directories wanted to create the ultimate listing. This is how you need to use it:
import os
os.makedirs('parent_dir/my_dir')
On this case, even when parent_dir does not exist, os.makedirs will create it together with my_dir. If parent_dir already exists, os.makedirs will merely create my_dir inside it.
Word: Like os.mkdir, os.makedirs will even increase a FileExistsError if the ultimate listing you are attempting to create already exists. Nonetheless, it will not increase an error if the intermediate directories exist already.
Utilizing pathlib to Create Directories
The pathlib module in Python 3.4 and above gives an object-oriented method to deal with filesystem paths. It is extra intuitive and simpler to learn than utilizing os.mkdir or os.makedirs. To create a brand new listing with pathlib, you need to use the Path.mkdir() methodology.
Right here is an instance:
from pathlib import Path
# Outline the trail
path = Path('/path/to/listing')
# Create the listing
path.mkdir(mother and father=True, exist_ok=True)
On this code, the mother and father=True argument tells Python to create any vital father or mother directories, and exist_ok=True permits the operation to proceed with out elevating an exception if the listing already exists.
Dealing with Exceptions when Creating Directories
When working with filesystems, it is at all times a good suggestion to deal with exceptions. This might be attributable to permissions, the listing already current, or quite a lot of different unexpected points. This is one strategy to deal with exceptions when creating your directories:
from pathlib import Path
# Outline the trail
path = Path('/path/to/listing')
strive:
# Create the listing
path.mkdir(mother and father=True, exist_ok=False)
besides FileExistsError:
print("Listing already exists.")
besides PermissionError:
print("You do not have permissions to create this listing.")
besides Exception as e:
print(f"An error occurred: {e}")
On this code, we have set exist_ok=False to boost a FileExistsError if the listing already exists. We then catch this exception, together with PermissionError and another exceptions, and print a related message. This offers us extra fine-grained management over what we do when sure conditions come up, though it is much less concise and hurts readability.
When to make use of os or pathlib for Creating Directories
Selecting between os and pathlib for creating directories largely is determined by your particular use case and private choice.
The os module has been round for some time and is extensively used for interacting with the working system. It is a good selection in case you’re working with older variations of Python or if it’s good to use different os features in your code.
However, pathlib is a more moderen module that gives a extra intuitive, object-oriented method to dealing with filesystem paths. It is a good selection in case you’re utilizing Python 3.4 or above and like a extra fashionable, readable syntax.
Fortunately, each os and pathlib are a part of the usual Python library, so you will not want to put in any further packages to make use of them.
Conclusion
On this Byte, we have explored the way to create directories and deal with exceptions utilizing the os and pathlib modules in Python. Keep in mind that selecting between these two choices is determined by your particular wants and private preferences. All the time make sure you deal with exceptions when working with filesystems to make your code extra sturdy and dependable. That is vital as it is simple to make errors when working with filesystems and find yourself with an error.
