Python how to create folder

Create a directory in Python

The OS module in Python provides functions for interacting with the operating system. OS comes under Python’s standard utility modules. This module provides a portable way of using operating system dependent functionality. The os and os.path modules include many functions to interact with the file system. All functions in os module raise OSError in the case of invalid or inaccessible file names and paths, or other arguments that have the correct type but are not accepted by the operating system.

There are different methods available in the OS module for creating a director. These are –

Using os.mkdir()

os.mkdir() method in Python is used to create a directory named path with the specified numeric mode. This method raise FileExistsError if the directory to be created already exists.

Syntax: os.mkdir(path, mode = 0o777, *, dir_fd = None)

Parameter:
path: A path-like object representing a file system path. A path-like object is either a string or bytes object representing a path.
mode (optional): A Integer value representing mode of the directory to be created. If this parameter is omitted then default value Oo777 is used.
dir_fd (optional): A file descriptor referring to a directory. The default value of this parameter is None.
If the specified path is absolute then dir_fd is ignored.

Note: The ‘*’ in parameter list indicates that all following parameters (Here in our case ‘dir_fd’) are keyword-only parameters and they can be provided using their name, not as positional parameter.

Return Type: This method does not return any value.

How to Create a Directory in Python

Hello, folks! In this article, we will be unveiling different ways to Create a Directory in Python

Steps to Create a Directory in Python

Python os module contains various in-built functions to deal with and interact with the underlying operating systems and the files.

The os module contains various in-built functions create directories in the system.

In the upcoming sections, we will have look at the various ways through which you can create a directory using the os module.

Technique 1: Using os.mkdir() method to Create a Directory in Python

The os module has in-built os.mkdir() method to create a directory in the system.

Syntax:

Example 1: Create a Directory using Python in the specified location.

Output:

Example 2: Providing permissions to deal with read and write operations within the directory.

Setting mode = 0o666, allows read and write file operations within the created directory.

Output:

Exceptions with os.mkdir() function

The os.mkdir() method raises a FileExistsError Exception if the directory in the location specified already exists.

Example:

Output:

Technique 2: Using os.makedirs() method to create directory in the system

The os module has in-built os.makedirs() method to create nested or recursive directories within the system.

That is, the os.makedirs() function creates the parent directory, the intermediate directories as well as the leaf directory if any of them is not present in the system files.

Syntax:

Example:

In the above example, the makedirs() function creates the intermediate directories – ‘Python_files’ as well as the leaf directory – ‘OS_module’ in one shot through the function.

Output:

Conclusion

Thus, in this article, we have understood the ways to create directories within the system using the os module.

Creating and Deleting Directories with Python

This article continues with our series on interacting with the file system in Python. The previous articles dealt with reading and writing files. Interestingly, the file system is much more than a way to store/retrieve data to disk. There are also various other types of entries such as files, directories, sockets (for inter-process communication), named pipes, both soft and hard links, as well as special files (block devices). Reading and writing from and to them is done in a similar way as we saw in the previous articles.

This article focuses on the handling of directories. Other operating systems, like UNIX/Linux, instead use a different terminology, where an «entry» is named a «folder». Next, we will show you how to identify the current working directory, how to create both a persistent and a temporary, single directory as well as nested directory structures with subfolders, and how to remove a directory if no longer needed. Therefore, the two Python modules os and tempfile come into play.

Required Python Modules

Reading and writing files does not require loading an additional module, but accessing the file system functions (like handling directories) requires that we use a separate module. First, the os module has to be loaded. os is a Python module which belongs to the core part of the Python ecosystem. It is done using an import statement as follows:

The os module contains most of the methods we’ll need throughout this article. However, as you’ll see later on, if you want to something more advanced, like create a temporary file for storing data, then we’ll also be needing the tempfile module.

Detecting the Current Working Directory

The output should look something like this:

Furthermore, the os module contains the additional getcwdb() method. This one is similar to the getcwd() method but returns the path as a binary string, instead.

There are quite a few other directory operations not covered in this article, like checking if a file or directory exists. But for now we’ll move on to the main purpose of this article.

Creating a Directory

Creating a single directory is done using the mkdir() method. As a parameter, mkdir() first requires the path name for the directory in order for it to be created. For an example, see the code below:

Keep in mind that the mkdir() method cannot create sub-directories on a deeper level than one in a single call. To create an entire path you have to call mkdir() once per directory level. Alternatively, if you want to create multiple directories at once, make use of the makedirs() method instead (which you can see in Listing 4 below).

As an optional parameter you can specify the access rights to the directory within your mkdir() call. The default setting is 777, which means it is readable and writable by the owner, group members, and all other users as well. In case you require a more restrictive setting, like 755, (readable and accessible by all users, and write access by only the owner) you may call it as follows:

However, as the Python documentation states, some systems ignore the mode parameter and you should use os.chmod instead.

Creating a Directory with Subdirectories

As already mentioned above, the mkdir() method allows us to create a single directory, only. To create multi-level subdirectories the makedirs() method comes into play. Actually, makedirs() is implemented in such a way that it calls mkdir() to create one directory after the next.

Creating a Temporary Directory

So far, we’ve created permanent entries in the file system. For various reasons like parking data temporarily it can be necessary to just have a temporary directory. The tempfile module contains methods that handle such cases in a safe and consistent way.

Listing 5 shows an example that uses the TemporaryDirectory() method in combination with the with statement. After the with statement the temporary directory does not exist anymore because both the directory, and its contents have been entirely removed.

Listing 6 shows the output of the Python script from Listing 5. In order to create temporary files, on UNIX/Linux systems the three directories /tmp, /var/tmp, and /usr/tmp are tried, and the first match of them is taken. In this current case it is the /tmp directory that is used.

Free eBook: Git Essentials

Check out our hands-on, practical guide to learning Git, with best-practices, industry-accepted standards, and included cheat sheet. Stop Googling Git commands and actually learn it!

Deleting a Directory

Deleting a directory is the opposite case of creating one. You can do that using the rmdir() method of the os module. rmdir() requires a path string that contains the directory name, and only deletes the deepest entry in the path string. Note that this only works when the directory is entirely empty. If it is not empty then an OSError is raised. Listing 7 shows the according Python code.

In case you would like to remove an entire directory tree the rmtree() method from the shutil module will help you with that task.

Conclusion

As you may have noted, handling directories is very simple in Python. It takes you only a few lines of code to create and to remove this kind of file entry.

Links and References

Acknowledgements

The author would like to thank Zoleka Hatitongwe for her support while preparing the article.

How To Create Directory In Python With Example

Python os.mkdir() is an inbuilt function that creates a directory. The OS module in Python gives methods for interacting with the operating system. The OS module comes under Python’s standard utility modules. The OS module provides the portable way of using operating system dependent functionality.

Python create directory

Reading and writing files do not require loading the additional module, but accessing a file system functions requires that we use the separate module.

First, the os module has to be imported. The os is a Python module that belongs to a core part of the Python ecosystem. It is done using the import statement as follows.

There are two main methods available in the OS module for creating a directory. These are the following.

Python os.mkdir()

Python’s OS module provides the function to create the directory. The os.mkdir() method in Python is used to create a directory named path with the specified numeric mode. This method raises FileExistsError if the directory to be created already exists.

Syntax

Parameters

path: It takes a path as a required parameter, which is the path to which we want to create a directory. A path-like object is representing the file system path. A path-like object is either the string or bytes object representing a path.

mode (optional): It is an Integer value representing a mode of a directory to be created. If the mode parameter is omitted, then default value 777 is used.

file_descriptor(optional): A file descriptor referring to a directory. The default value of this parameter is None. If the specified path is absolute, then file_descriptor is ignored.

Example

See the following code.

Output

When you run the first time, it will give us the above output. Now, you can see that the app directory is created in your current project folder.

Now, run the above file second time and see the output.

That means it gives us FileExistsError, which means that the folder already exists.

Python not operator

To check an existing folder in a particular directory, we can use Python, not operator with Python os.path.exists() function. See the following code.

Output

Now, again if you run the file, then it compiler finds that the folder already exists so it will execute the else condition.

The os.mkdir(path) will create the given directory only, but it will not create the intermediate directory in the given path.

So let’s say if we want to create a directory inside the directory, and both directories do not exist, then it won’t create any directory.

For example, if we want to create a >> b >> c in which we are at the a folder, and now we want to create b and c folder, then it is not possible. At max, it will create a b folder and not b after c.

See the following code.

Output

Here compiler does not create any directory and returns an error because it tries to find ‘a/b/c’ directory and not a >> b >> c directory. It takes a path as a whole string, and that is why it won’t create.

The os.mkdir(path) can not create intermediate directories in the given path if they are not present. It will throw the error in such cases. For that, we need another function.

Python os.makedirs()

Python os.makedirs() is an inbuilt method that is used to create a directory recursively. That means while making leaf directory if any intermediate-level directory is missing, os. makedirs() method will create them all.

Syntax

The os.makedirs(name) will create the directory on a given path, and also, if any intermediate-level directory doesn’t exist, then it will create that too.

Let’s create a directory with intermediate directories with the following code.

Output

Now, if there are no directories like a >> b >> c, then the above code will create one for you.

Python Create Directory: A How-To Guide

The Python os.mkdir() method creates a blank directory on your file system. You cannot use this method to create a folder in a folder that does not exist. The os.mkdirs() method recursively creates a blank directory.

Files let you store data outside a program that can be referenced by a program in the future. When you’re working with files, you may decide to create a new directory in which a file should be stored.

That’s where the Python os module comes in. The os module includes two methods called os.mkdir() and os.mkdirs() which can be used to create directories in Python.

This tutorial will explore how to create a directory in Python using the os.mkdir() and os.mkdirs() methods. We will also use a few examples to show how these methods work.

Python os Refresher

Before you can work with files in Python, you need to import the os module. The os module is built-in to Python. It contains a number of methods that can be used to interface with a computer’s underlying operating system.

In this case, we are interested in the os module’s file system methods, which can be used to work with files. We can use a Python import statement to import os into our program:

Python Create Directory

The os.mkdir() method can be used to create a single directory. For example, if we were creating a program that needs a new folder to store its outputs, we would use os.mkdir().

The syntax for the os.mkdir() method is as follows:

81% of participants stated they felt more confident about their tech job prospects after attending a bootcamp. Get matched to a bootcamp today.

Find Your Bootcamp Match

The average bootcamp grad spent less than six months in career transition, from starting a bootcamp to finding their first job.

Start your career switch today

The os.mkdir() function takes in two parameters:

Python os.mkdir() Example

Let’s explore an example to showcase how to use the os.mkdir() method.

Say we are creating a program that analyzes a list of math student test scores. This program stores whether each student has passed the latest test.

To start, we want to create a directory where our data will be stored. This will ensure that our data will be separate from the rest of our program.

Here’s the code we could use to create a directory for our data:

Our code creates a new directory called final in the /home/school/math/grades folder in our operating system. Then, it returns the message:

The mkdir() method can only be used to create one directory at a time. We could not create a folder called final and then create a folder within final called jan2020.

Find Your Bootcamp Match

Select your interest
First name

Last name

Email

Phone number

By continuing you agree to our Terms of Service and Privacy Policy, and you consent to receive offers and opportunities from Career Karma by telephone, text message, and email.

os.mkdir() Permissions Example

We can use the optional access parameter to specify the permissions we want our directory to have. By default, the access permissions for the directory mkdir() creates is 777. This means the directory is readable and writable by the owner and all other users.

But what if we want to set our own permissions?

Say that our operating system is accessible to multiple teachers, and we only want to grant write access to the owner. We need to use the 755 permission. This permission states a file is readable and accessible by all users. But, only the owner can write to the file.

Here’s the code we could use to create a working directory with custom permissions:

We have created a target directory called /home/school/math/grades/final. This directory has the access permission 755. This means that our file can be read by all users, but only the owner can write to the file. Then, our program prints the message:

It’s important to note that our access variable is equal to 0o755 in our code. We have done this because access rights use the octal prefix, and so we need to specify 0o before our access parameter.

To learn how to check if a file or directory exists, check out our tutorial on checking if files exist in Python.

Python Create Multiple Directories

The Python os.makedirs() method recursively creates folders. You can use this method to create a folder inside a folder that does not exist. os.mkdirs() accepts one argument: the path of the folder you want to create.

Let’s take a look at the syntax for os.mkdirs():

This method accepts the same arguments as os.mkdir().

Python os.mkdirs() Example

There are often cases where we need to create directories that exist within other new directories.

«Career Karma entered my life when I needed it most and quickly helped me match with a bootcamp. Two months after graduating, I found my dream job that aligned with my values and goals in life!»

Venus, Software Engineer at Rockbot

Find Your Bootcamp Match

For instance, say we are creating a program that stores our math student test score data. Instead of storing all of our data in one folder, we could store data in multiple folders.

Each folder would correspond with the year and month of the test. Storing data in this way would make our files easier to find if and when we want to refer back to them.

Let’s use our school math test example to illustrate how the os.makedirs() method works.

The specifications of our program have changed. Now we want to store data in folders depending on the year and month of the test. We could accomplish this task using the following code:

Let’s say that we do not yet have a 2020 folder or an 02 folder. This code would first create the 2020 folder, then it would create the folder called 02 within 2020. We assign this folder the access permissions 755.

After our program creates our folder, it prints out the message:

Conclusion

Creating a directory is a common operation in Python when you’re working with files. The os.mkdir() method can be used to create a single directory, and the os.makedirs() method can be used to create multi-level directories.

This tutorial discussed how to use both os.mkdir() and os.makedirs() to create folders in Python. We also explored an example of each of these methods in action.

Are you interested in learning more about Python? Check out our complete How to Learn Python guide for expert tips and advice on how to learn this programming language.