Directory is not empty please choose a different location anaconda ошибка

The Python error “OSError: [Errno 39] Directory not empty” occurs when you try to remove a directory that has other files or directories in it. Functions like os.rmdir() or .rmdir() on a pathlib Path object can only remove directories that are already empty. To fix this, you can either delete all the files in the directory first with a for loop, or use a function like shutil.rmtree(<your dirname>) to remove the directory and all its contents.

Python makes it super easy to deal with files and do simple file operations. Unfortunately, some of the things you want to do with files aren’t as straightforward as they might seem on the surface. For example, if you want to delete a directory, you need to make sure its empty first. That is, unless you use shutil.rmtree(); os.rmdir() won’t work.

Fortunately, we’re here to help. There’s lots of options for you when it comes to deleting a directory that’s not empty. Ignoring the most obvious first choice which is simply “don’t do that”, of course.

Let’s start with the problem!

❌ Problem: you are using os.rmdir() or pathlib‘s .rmdir() to remove a directory that isn’t empty

Again, deleting a directory that’s not empty in Python isn’t impossible, but you have to do it the right way. Let’s look at an example directory below:

.
├── main.py
├── testdir
    ├── testdir2
    │   ├── test2.txt
    │   ├── testdir3
    │   │   └── another_test.txt
    │   └── test.txt
    └── test.txt

As you can see, we got lots of stuff in here. Aside from our main.py above, which is our Python script, we have testdir as well as a bunch of nested files and directories inside.

You might try to just go ahead and do something like this, but you’d be wrong:

import os

os.rmdir('testdir')

Here, we’re using the good old os.rmdir(<your dirname>) to try to delete testdir. That’s not gonna work. If you try to do this, you’ll get the following error message:

Traceback (most recent call last):
  File "/home/user/main.py", line 3, in <module>
    os.rmdir('testdir')
OSError: [Errno 39] Directory not empty: 'testdir'

Oops! But you already knew that was going to happen. That’s why you’re here, after all. Luckily this Python error has a pretty straightforward message for us: the directory isn’t empty. Like using rm on Linux or Mac that isn’t empty, we can’t do this!

✅ Fix 1: use shutil.rmtree() to delete the directory and all its contents

This is the simplest way to delete a directory that isn’t empty in Python. But be warned, this will delete everything in that directory, including the directory itself. If you’re absolutely sure this is what you want to be doing, here’s how you’d do it:

import shutil

shutil.rmtree('testdir')

Can’t get much easier than that. But what if you wanted more control over the deleting of stuff within testdir?

✅ Fix 2: delete all files in the directory first

If you don’t want to just blow away an entire directory and all its contents, you might want to recursively delete everything in the directory, including all of its subdirectories. This is useful if you want to do something like logging the filenames you’re deleting, or optionally moving certain files during the process that match specific criteria.

To recursively delete a directory and all its contents in Python, you can use this function I wrote:

import pathlib

def recursive_delete(dir_obj: pathlib.Path):
    assert dir_obj.is_dir()

    for file_obj in dir_obj.iterdir():
        if not file_obj.is_dir():
            file_obj.unlink()
        else:
            recursive_delete(file_obj)

    dir_obj.rmdir()

recursive_delete(pathlib.Path('testdir'))

Here, we wrote a function called recursive_delete() that takes a pathlib Path object. First, we check to make sure it’s actually a directory. That’s important. If it’s not, nothing else in the function will work properly. Then, we loop through each file in that directory. If that directory is a file, we just remove it. Otherwise, we recurse back into our recursive_delete function to start the process over again. Finally, we remove the directory that recursive_delete was called on once its empty.

Feel free to copy / paste this function and add more to it – this is just a bare-bones example that doesn’t do much that shutil.rmtree() doesn’t already do (in much fewer lines of code). If all you’re wanting to do is delete a directory and all its contents, use shutil.rmtree() instead.

✅ Fix 3: use an if / else statement to check if the directory is empty first

If you don’t want to remove directories that have stuff in them, but receiving the name of a directory that has stuff in it isn’t an error state for your application, you should check if the directory is empty first before trying to remove it.

Here’s how you’d do that:

import os

dir_to_delete = 'testdir'

if len(os.listdir(dir_to_delete)) == 0:
    os.rmdir(dir_to_delete)
else:
    print(f"{dir_to_delete} is not empty!")
    # do something useful...

# -> testdir is not empty!

Here, we first call os.listdir() on the directory name first, which will give us a list of all filenames it contains. We do that in an if statement where we use len() on the returned list of filenames to make sure it equals 0, which means it’s empty. If it’s not empty, we just print out a complaint to the user.

Now, you’ll want to do something more than that here, otherwise you might as well not check at all and let the program crash with a stack trace instead.

✅ Fix 4: use a try / except block to catch the exception

If you aren’t expecting to receive the name of a directory that’s got stuff in it and that is an error state for your program but you don’t want the program to just crash, you should use a try / except block instead like so:

import os

dir_to_delete = 'testdir'

try:
    os.rmdir(dir_to_delete)
except OSError as ose:
    print(ose)
    # do something useful...

# -> [Errno 39] Directory not empty: 'testdir'

Here, we simply try to delete the directory, and if it’s full, we catch the OSError and print it out. You should also do something in the except block that is more useful than that, otherwise there’s not much point in catching the error to begin with.

As always, you want to be as specific as possible when catching exceptions. This makes sure that you’re not catching everything and possibly masking a deeper problem with your application logic. Here, by specifically catching OSError, we avoid this.

Conclusion

In this article we covered what causes “OSError: [Errno 39] Directory not empty” and how to avoid it. In general, it’s always caused by trying to remove a directory that isn’t empty yet. The simplest way to handle it is to use shutil.rmtree(<your dirname>) to delete the directory and all its contents. If you need more control, use the recursive function I provided above. And if you don’t actually want to remove a directory with everything in it, use an if / else statement or a try / except block instead.

That’s all for now, hope it helps!