How can I delete the contents of a local folder in Python?
The current project is for Windows, but I would like to see *nix also.
Updated to only delete files and to used the os.path.join() method suggested in the comments. If you also want to remove subdirectories, uncomment the elif statement.
import os, shutil folder = '/path/to/folder' for the_file in os.listdir(folder): file_path = os.path.join(folder, the_file) try: if os.path.isfile(file_path): os.unlink(file_path) #elif os.path.isdir(file_path): shutil.rmtree(file_path) except Exception as e: print(e)
Try the shutil module
import shutil shutil.rmtree('/path/to/folder')
shutil.rmtree(path, ignore_errors=False, onerror=None)
Docstring: Recursively delete a
ignore_errorsis set, errors are
ignored; otherwise, if
it is called to handle the error with
(func, path, exc_info)where
os.rmdir; path is the argument to that
function that caused it to fail; and
exc_infois a tuple returned by
exception is raised.
You can simply do this :
import os import glob files = glob.glob('/YOUR/PATH/*') for f in files: os.remove(f)
You can of corse use an other filter in you path, for exemple : /YOU/PATH/*.txt for removing all text files in a directory.
Expanding on mhawke’s answer this is what I’ve implemented. It removes all the content of a folder but not the folder itself. Tested on Linux with files, folders and symbolic links, should work on Windows as well.
import os import shutil for root, dirs, files in os.walk('/path/to/folder'): for f in files: os.unlink(os.path.join(root, f)) for d in dirs: shutil.rmtree(os.path.join(root, d))
rmtree and recreating the folder could work, but I have run into errors when deleting and immediately recreating folders on network drives.
The proposed solution using walk does not work as it uses
rmtree to remove folders and then may attempt to use
os.unlink on the files that were previously in those folders. This causes an error.
glob solution will also attempt to delete non-empty folders, causing errors.
I suggest you use:
folder_path = '/path/to/folder' for file_object in os.listdir(folder_path): file_object_path = os.path.join(folder_path, file_object) if os.path.isfile(file_object_path): os.unlink(file_object_path) else: shutil.rmtree(file_object_path)
As a oneliner:
import os # Python 2.7 map( os.unlink, (os.path.join( mydir,f) for f in os.listdir(mydir)) ) # Python 3+ list( map( os.unlink, (os.path.join( mydir,f) for f in os.listdir(mydir)) ) )
A more robust solution accounting for files and directories as well would be (2.7):
def rm(f): if os.path.isdir(f): return os.rmdir(f) if os.path.isfile(f): return os.unlink(f) raise TypeError, 'must be either file or directory' map( rm, (os.path.join( mydir,f) for f in os.listdir(mydir)) )
You might be better off using
os.walk() for this.
os.listdir() doesn’t distinguish files from directories and you will quickly get into trouble trying to unlink these. There is a good example of using
os.walk() to recursively remove a directory here, and hints on how to adapt it to your circumstances.
Notes: in case someone down voted my answer, I have something to explain here.
- Everyone likes short ‘n’ simple answers. However, sometimes the reality is not so simple.
- Back to my answer. I know
shutil.rmtree()could be used to delete a directory tree. I’ve used it many times in my own projects. But you must realize that the directory itself will also be deleted by
shutil.rmtree(). While this might be acceptable for some, it’s not a valid answer for deleting the contents of a folder (without side effects).
- I’ll show you an example of the side effects. Suppose that you have a directory with customized owner and mode bits, where there are a lot of contents. Then you delete it with
shutil.rmtree()and rebuild it with
os.mkdir(). And you’ll get an empty directory with default (inherited) owner and mode bits instead. While you might have the privilege to delete the contents and even the directory, you might not be able to set back the original owner and mode bits on the directory (e.g. you’re not a superuser).
- Finally, be patient and read the code. It’s long and ugly (in sight), but proven to be reliable and efficient (in use).
Here’s a long and ugly, but reliable and efficient solution.
It resolves a few problems which are not addressed by the other answerers:
- It correctly handles symbolic links, including not calling
shutil.rmtree()on a symbolic link (which will pass the
os.path.isdir()test if it links to a directory; even the result of
os.walk()contains symbolic linked directories as well).
- It handles read-only files nicely.
Here’s the code (the only useful function is
import os import stat import shutil # http://stackoverflow.com/questions/1889597/deleting-directory-in-python def _remove_readonly(fn, path_, excinfo): # Handle read-only files and directories if fn is os.rmdir: os.chmod(path_, stat.S_IWRITE) os.rmdir(path_) elif fn is os.remove: os.lchmod(path_, stat.S_IWRITE) os.remove(path_) def force_remove_file_or_symlink(path_): try: os.remove(path_) except OSError: os.lchmod(path_, stat.S_IWRITE) os.remove(path_) # Code from shutil.rmtree() def is_regular_dir(path_): try: mode = os.lstat(path_).st_mode except os.error: mode = 0 return stat.S_ISDIR(mode) def clear_dir(path_): if is_regular_dir(path_): # Given path is a directory, clear its content for name in os.listdir(path_): fullpath = os.path.join(path_, name) if is_regular_dir(fullpath): shutil.rmtree(fullpath, onerror=_remove_readonly) else: force_remove_file_or_symlink(fullpath) else: # Given path is a file or a symlink. # Raise an exception here to avoid accidentally clearing the content # of a symbolic linked directory. raise OSError("Cannot call clear_dir() on a symbolic link")
I konw it’s an old thread but I have found something interesting from the official site of python. Just for sharing another idea for removing of all contents in a directory. Because I have some problems of authorization when using shutil.rmtree() and I don’t want to remove the directory and recreate it. The address original is http://docs.python.org/2/library/os.html#os.walk. Hope that could help someone.
def emptydir(top): if(top == '/' or top == "\\"): return else: for root, dirs, files in os.walk(top, topdown=False): for name in files: os.remove(os.path.join(root, name)) for name in dirs: os.rmdir(os.path.join(root, name))
This is the only answer so far, which:
- removes all symbolic links
- dead links
- links to directories
- links to files
- removes subdirectories
- does not remove the parent directory
for filename in os.listdir(dirpath): filepath = os.path.join(dirpath, filename) try: shutil.rmtree(filepath) except OSError: os.remove(filepath)
As many other answers, this does not try to adjust permissions to enable removal of files/directories.
I used to solve the problem this way:
import shutil import os shutil.rmtree(dirpath) os.mkdir(dirpath)
Yet Another Solution:
import sh sh.rm(sh.glob('/path/to/folder/*'))
import os import shutil # Gather directory contents contents = [os.path.join(target_dir, i) for i in os.listdir(target_dir)] # Iterate and remove each item in the appropriate manner [os.remove(i) if os.path.isfile(i) or os.path.islink(i) else shutil.rmtree(i) for i in contents]
An earlier comment also mentions using os.scandir in Python 3.5+. For example:
import os import shutil with os.scandir(target_dir) as entries: for entry in entries: if entry.is_file() or entry.is_symlink(): os.remove(entry.path) elif entry.is_dir(): shutil.rmtree(entry.path)
I resolved the error issue with rmtree makedirs by adding time.sleep() between.
if os.path.isdir(folder_location): shutil.rmtree(folder_location) time.sleep(.5) os.makedirs(folder_location, 0o777)
Answer for a limited, specific situation:
assuming you want to delete the files while maintainig the subfolders tree, you could use a recursive algorithm:
import os def recursively_remove_files(f): if os.path.isfile(f): os.unlink(f) elif os.path.isdir(f): map(recursively_remove_files, [os.path.join(f,fi) for fi in os.listdir(f)]) recursively_remove_files(my_directory)
Maybe slightly off-topic, but I think many would find it useful
This should do the trick just using the OS module to list and then remove!
import os DIR = os.list('Folder') for i in range(len(DIR)): os.remove('Folder'+chr(92)+i)
Worked for me, any problems let me know!