Comment supprimer / supprimer un dossier qui n'est pas vide?

J'obtiens une erreur «accès refusé» lorsque j'essaie de supprimer un dossier qui n'est pas vide. J'ai utilisé la commande suivante dans ma tentative: os.remove("/folder_name").

Quelle est la manière la plus efficace de supprimer / supprimer un dossier / répertoire qui n'est pas vide?

import shutil

shutil.rmtree('/folder_name')

Référence de bibliothèque standard: shutil.rmtree .

De par sa conception, rmtreeéchoue sur les arborescences de dossiers contenant des fichiers en lecture seule. Si vous souhaitez que le dossier soit supprimé, qu'il contienne ou non des fichiers en lecture seule, utilisez

shutil.rmtree('/folder_name', ignore_errors=True)

De la documentation python sur os.walk():

# Delete everything reachable from the directory named in 'top',
# assuming there are no symbolic links.
# CAUTION:  This is dangerous!  For example, if top == '/', it
# could delete all your disk files.
import os
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))

import shutil
shutil.rmtree(dest, ignore_errors=True)

à partir de python 3.4, vous pouvez utiliser:

import pathlib

def delete_folder(pth) :
    for sub in pth.iterdir() :
        if sub.is_dir() :
            delete_folder(sub)
        else :
            sub.unlink()
    pth.rmdir() # if you just want to delete dir content, remove this line

où pthest une pathlib.Pathinstance. Bien, mais peut-être pas le plus rapide.

De docs.python.org :

Cet exemple montre comment supprimer une arborescence de répertoires sous Windows où certains fichiers ont leur bit de lecture seule défini. Il utilise le rappel onerror pour effacer le bit en lecture seule et réessayer la suppression. Tout échec ultérieur se propagera.

import os, stat
import shutil

def remove_readonly(func, path, _):
    "Clear the readonly bit and reattempt the removal"
    os.chmod(path, stat.S_IWRITE)
    func(path)

shutil.rmtree(directory, onerror=remove_readonly)

import os
import stat
import shutil

def errorRemoveReadonly(func, path, exc):
    excvalue = exc[1]
    if func in (os.rmdir, os.remove) and excvalue.errno == errno.EACCES:
        # change the file to be readable,writable,executable: 0777
        os.chmod(path, stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)  
        # retry
        func(path)
    else:
        # raiseenter code here

shutil.rmtree(path, ignore_errors=False, onerror=errorRemoveReadonly) 

Si ignore_errors est défini, les erreurs sont ignorées; sinon, si onerror est défini, il est appelé pour gérer l'erreur avec des arguments (func, path, exc_info) où func est os.listdir, os.remove ou os.rmdir; chemin est l'argument de cette fonction qui a provoqué son échec; et exc_info est un tuple renvoyé par sys.exc_info (). Si ignore_errors est false et onerror est None, une exception est déclenchée. Entrez le code ici

Basé sur la réponse de kkubasik, vérifiez si le dossier existe avant de le supprimer, plus robuste

import shutil
def remove_folder(path):
    # check if folder exists
    if os.path.exists(path):
         # remove if exists
         shutil.rmtree(path)
    else:
         # throw your exception to handle this special scenario
         raise XXError("your exception") 
remove_folder("/folder_name")

si vous êtes sûr que vous voulez supprimer tout l'arborescence de dir et que vous n'êtes plus intéressé par le contenu de dir, alors l'exploration de l'arborescence de dir entière est stupide ... il suffit d'appeler la commande native OS de python pour le faire. Il sera plus rapide, efficace et consommera moins de mémoire.

RMDIR c:\blah /s /q 

ou * nix

rm -rf /home/whatever 

En python, le code ressemblera à ..

import sys
import os

mswindows = (sys.platform == "win32")

def getstatusoutput(cmd):
    """Return (status, output) of executing cmd in a shell."""
    if not mswindows:
        return commands.getstatusoutput(cmd)
    pipe = os.popen(cmd + ' 2>&1', 'r')
    text = pipe.read()
    sts = pipe.close()
    if sts is None: sts = 0
    if text[-1:] == '\n': text = text[:-1]
    return sts, text


def deleteDir(path):
    """deletes the path entirely"""
    if mswindows: 
        cmd = "RMDIR "+ path +" /s /q"
    else:
        cmd = "rm -rf "+path
    result = getstatusoutput(cmd)
    if(result[0]!=0):
        raise RuntimeError(result[1])

Juste quelques options de python 3.5 pour compléter les réponses ci-dessus. (J'aurais adoré les trouver ici).

import os
import shutil
from send2trash import send2trash # (shutil delete permanently)

Supprimer le dossier s'il est vide

root = r"C:\Users\Me\Desktop\test"   
for dir, subdirs, files in os.walk(root):   
    if subdirs == [] and files == []:
           send2trash(dir)
           print(dir, ": folder removed")

Supprimer également le dossier s'il contient ce fichier

    elif subdirs == [] and len(files) == 1: # if contains no sub folder and only 1 file 
        if files[0]== "desktop.ini" or:  
            send2trash(dir)
            print(dir, ": folder removed")
        else:
            print(dir)

supprimer le dossier s'il ne contient que des fichiers .srt ou .txt

    elif subdirs == []: #if dir doesn’t contains subdirectory
        ext = (".srt", ".txt")
        contains_other_ext=0
        for file in files:
            if not file.endswith(ext):  
                contains_other_ext=True
        if contains_other_ext== 0:
                send2trash(dir)
                print(dir, ": dir deleted")

Supprimer le dossier si sa taille est inférieure à 400 Ko:

def get_tree_size(path):
    """Return total size of files in given path and subdirs."""
    total = 0
    for entry in os.scandir(path):
        if entry.is_dir(follow_symlinks=False):
            total += get_tree_size(entry.path)
        else:
            total += entry.stat(follow_symlinks=False).st_size
    return total


for dir, subdirs, files in os.walk(root):   
    If get_tree_size(dir) < 400000:  # ≈ 400kb
        send2trash(dir)
    print(dir, "dir deleted")

Je voudrais ajouter une approche "pure pathlib":

from pathlib import Path
from typing import Union

def del_dir(target: Union[Path, str], only_if_empty: bool = False):
    target = Path(target).expanduser()
    assert target.is_dir()
    for p in sorted(target.glob('**/*'), reverse=True):
        if not p.exists():
            continue
        p.chmod(0o666)
        if p.is_dir():
            p.rmdir()
        else:
            if only_if_empty:
                raise RuntimeError(f'{p.parent} is not empty!')
            p.unlink()
    target.rmdir()

Cela repose sur le fait qu'il Pathest ordonnable, et les chemins plus longs seront toujours triés après les chemins plus courts, tout comme str. Par conséquent, les répertoires viendront avant les fichiers. Si nous inversons le tri, les fichiers arriveront avant leurs conteneurs respectifs, nous pouvons donc simplement les dissocier / rmdir un par un en un seul passage.

Avantages:

• Il ne s'appuie PAS sur des binaires externes: tout utilise les modules inclus dans les batteries de Python (Python> = 3.6)
• C'est rapide et efficace en mémoire: pas de pile de récursivité, pas besoin de démarrer un sous-processus
• C'est multiplateforme (du moins, c'est ce qui pathlibpromet dans Python 3.6; aucune opération ci-dessus n'a déclaré ne pas fonctionner sur Windows)
• Si nécessaire, on peut effectuer une journalisation très granulaire, par exemple, enregistrer chaque suppression au fur et à mesure.

def deleteDir(dirPath):
    deleteFiles = []
    deleteDirs = []
    for root, dirs, files in os.walk(dirPath):
        for f in files:
            deleteFiles.append(os.path.join(root, f))
        for d in dirs:
            deleteDirs.append(os.path.join(root, d))
    for f in deleteFiles:
        os.remove(f)
    for d in deleteDirs:
        os.rmdir(d)
    os.rmdir(dirPath)

Si vous ne souhaitez pas utiliser le shutilmodule, vous pouvez simplement utiliser le osmodule.

from os import listdir, rmdir, remove
for i in listdir(directoryToRemove):
    os.remove(os.path.join(directoryToRemove, i))
rmdir(directoryToRemove) # Now the directory is empty of files

Dix ans plus tard et en utilisant Python 3.7 et Linux, il existe encore différentes façons de procéder:

import subprocess
from pathlib import Path

#using pathlib.Path
path = Path('/path/to/your/dir')
subprocess.run(["rm", "-rf", str(path)])

#using strings
path = "/path/to/your/dir"
subprocess.run(["rm", "-rf", path])

Il s'agit essentiellement d'utiliser le module de sous-processus de Python pour exécuter le script bash $ rm -rf '/path/to/your/dircomme si vous utilisiez le terminal pour accomplir la même tâche. Ce n'est pas entièrement en Python, mais cela se fait.

La raison pour laquelle j'ai inclus l' pathlib.Pathexemple est que, selon mon expérience, il est très utile lorsqu'il s'agit de nombreux chemins qui changent. Les étapes supplémentaires d'importation du pathlib.Pathmodule et de conversion des résultats finaux en chaînes sont souvent moins coûteuses pour moi en termes de temps de développement. Il serait pratique de disposer Path.rmdir()d'une option arg pour gérer explicitement les répertoires non vides.

Pour supprimer un dossier même s'il n'existe peut-être pas (en évitant la condition de concurrence critique dans la réponse de Charles Chow ) mais qu'il y a toujours des erreurs lorsque d'autres choses vont mal (par exemple, des problèmes d'autorisation, une erreur de lecture sur le disque, le fichier n'est pas un répertoire)

Pour Python 3.x:

import shutil

def ignore_absent_file(func, path, exc_inf):
    except_instance = exc_inf[1]
    if isinstance(except_instance, FileNotFoundError):
        return
    raise except_instance

shutil.rmtree(dir_to_delete, onerror=ignore_absent_file)

Le code Python 2.7 est presque le même:

import shutil
import errno

def ignore_absent_file(func, path, exc_inf):
    except_instance = exc_inf[1]
    if isinstance(except_instance, OSError) and \
        except_instance.errno == errno.ENOENT:
        return
    raise except_instance

shutil.rmtree(dir_to_delete, onerror=ignore_absent_file)

Avec os.walk, je proposerais la solution qui consiste en 3 appels Python à une ligne:

python -c "import sys; import os; [os.chmod(os.path.join(rs,d), 0o777) for rs,ds,fs in os.walk(_path_) for d in ds]"
python -c "import sys; import os; [os.chmod(os.path.join(rs,f), 0o777) for rs,ds,fs in os.walk(_path_) for f in fs]"
python -c "import os; import shutil; shutil.rmtree(_path_, ignore_errors=False)"

Tous les sous-répertoires du premier script chmod, tous les fichiers du second script chmod. Ensuite, le troisième script supprime tout sans aucun obstacle.

J'ai testé cela à partir du "Shell Script" dans un travail Jenkins (je ne voulais pas stocker un nouveau script Python dans SCM, c'est pourquoi j'ai cherché une solution sur une ligne) et cela a fonctionné pour Linux et Windows.

Vous pouvez utiliser la commande os.system pour plus de simplicité:

import os
os.system("rm -rf dirname")

Comme il est évident, il appelle en fait le terminal système pour accomplir cette tâche.

J'ai trouvé un moyen très simple de supprimer n'importe quel dossier (même NON vide) ou fichier sur WINDOWS OS .

os.system('powershell.exe  rmdir -r D:\workspace\Branches\*%s* -Force' %CANDIDATE_BRANCH)

Pour Windows, si le répertoire n'est pas vide et que vous avez des fichiers en lecture seule ou des erreurs comme

• Access is denied
• The process cannot access the file because it is being used by another process

Essaye ça, os.system('rmdir /S /Q "{}"'.format(directory))

C'est équivalent rm -rfsous Linux / Mac.