Working With Files In Python by@marvin

Working With Files In Python

Marvin HackerNoon profile picture


Software engineer. I write code and stay weird.

Most of us have had that one experience where we had a ton of dis-organized files in our machines. It happens. One minute, you're opening a large zip file, the next thing you know, the files are everywhere in the directory, mixing with all your important files and randomly placed leaving you with the task of manually sorting what needs to go where. It's a real pain. To ease this process, we're going to delve into file management with python the smart way.

Work smart, not hard.

Let's begin. We'll be using python 3.4 or greater.

Assuming you've got python up and running already, we're going to take a walk with the

module and a few others we will introduce along the way. Most of these come with python, so there's no need to install anything else to follow along.

Creating random files

Create a directory to work with. Call it

. Inside this folder create another folder
. Your directory structure should now look like this:


We're going to create random files to play with in the


Create a file
directory. You now have this:


Done? Now get in the following code, we'll get into its details in a moment.

import os
from pathlib import Path
import random

list_of_extensions = ['.rst','.txt','.md','.docx','.odt','.html','.ppt','.doc']

# get into the RandomFiles directory

for item in list_of_extensions:
    # create 20 random files for each file extension
    for num in range(20):
        # let the file begin with a random number between 1 to 50
        file_name = random.randint(1,50)
        file_to_create = str(file_name) + item

As of python 3.4, we 've got

, our little magic box. We also import python's
function for creating random numbers; Hold on to that thought, we're going to cover it when as we get to the line that uses it.

First off, we create a list of file extensions from where we will get our random files. Feel free to add to it.

Next up, we change to the

directory, then comes our loop, so here goes.

We are simply saying, take each item in this

and do the following to it. Let's take the
for instance. We get into another loop, where to this
, we do something to it 20 times.

Remember our import of

? We use it to select a random number between 1 and 50 for our file. In short, what this little loop does is save us, the less creative lot(don't worry, I'm part of this crew), the time of naming random files. We will simply create a file say
, provided it falls within our range of 50, twenty times. This is just so as to create a mess large enough to give pain when moving manually. The same process will be done with the other extensions. Next? Run this in your terminal.


Congratulations! We now have a mess of a directory. Now to clean it up.

In the same location where our
is, create a file
and get the below in.

Method 1:

import os
import shutil
import glob

# get into the RandomFiles directory

# get the list of files in the directory RandomFiles
files_to_group = []
for random_file in os.listdir('.'):

# get all the file extensions present
file_extensions = []
for our_file in files_to_group:


file_types = set(file_extensions)

for type in file_types:
    new_directory = type.replace(".", " ")
    os.mkdir(new_directory)  # create directory with given name

    for fname in glob.glob(f'*.{type[1:]}'):
        shutil.move(fname, new_directory)

For this, we import two new libraries;

. The
will help us move our files while the
will help find the files to classify. Just like before, this will all become clear as we get to the line.

First off, we get a list of all the files in the directory.

Here, we assume that we do not have a clue of what files are in the directory. This means unlike where you can get all the extensions present manually and use `if statements` or `switch`, we want the program to look through the directory and do this for us. What if the file had dozens of extensions or log files? Would you do this manually?

Once we get a list of all the files in the folder, we get into another loop, to get the file extensions of these files.

Notice how we use:


Currently, the our_file variable looks something like this

(for instance). When we split it, we get this:

`('5', '.docx')`

we then get the index [1] from it which in turn takes

is index [0].

So we now have the list of all file extensions present in the folder, whether repeated or not.

To make it non-repetitive, we make a set. This takes all the items from the list and gets only the unique items. In our case, if we had a list where we had an extension say

repeating itself over and over in the set would ensure we had only one of it.

# create a set and assign it to a variable 
file_types = set(file_extensions)

Remember our list of file types still has the

for every file extension. This would mean if we were to create a folder named exactly the same way, we would end up creating hidden folders and that is something we do not want.

So, as we loop over this set, we create a directory with the same extension name, only this time, we replace the

in the name with an empty string.

new_directory = type.replace(".", " ")
# our directory would now be called  'docx'

We still need the

extension to move the files.

for fname in glob.glob(f'*.{type[1:]}')

This simply implies take any file that ends with the

file extension (Notice the spacing used in
) . There is no space.

The wild card

means a file can be named anything, provided it ends in
. Since we have already placed the period
we take the string we have and have everything else afterwards and that's why we use [1:] which just means take from after the first character, hence take

What next? Move any file with this extension into the directory named as so.

shutil.move(fname, new_directory)

In this way, once a directory for the first file found in the loop has been created, no other duplicates can be made. In short, we will not have a folder to store

and many others to store
and so on. Once we have a directory made, all other folders looking like so will move there. That's it!

Method 2

You can alternatively, use generators. This is a fancy way of creating a list with a one liner.

import os
import shutil
import glob

# get into the RandomFiles directory

#take every file from the directory and add to a list for all files
all_files = [x for x in os.listdir('.') ]

# make a set for the extensions present in the directory
file_types = set((os.path.splitext(f)[1] for f in all_files))

for ftype in file_types:
    new_directory = ftype.replace(".", '')

    for fname in glob.glob(f'*.{ftype[1:]}'):
        shutil.move(fname, new_directory)

Both of these will work. You've now got all your files sorted according to extension.


Woosh! That was a lot. We did save some time though. Any questions? Feel free to reach out. That's it for now, Stick around as we take it up a notch next week. For the code on this, check TheGreenCodes.

As always: @codes_green

Previously published at


Signup or Login to Join the Discussion


Related Stories