Jak usunąć / usunąć folder, który nie jest pusty?

Podczas próby usunięcia folderu, który nie jest pusty, pojawia się błąd „odmowa dostępu”. Użyłem następującego polecenia w moim próba: os.remove("/folder_name").

Jaki jest najskuteczniejszy sposób usuwania / usuwania folderu / katalogu, który nie jest pusty?

import shutil

shutil.rmtree('/folder_name')

Odwołanie do biblioteki standardowej: shutil.rmtree .

Z założenia rmtreezawodzi w drzewach folderów zawierających pliki tylko do odczytu. Jeśli chcesz usunąć folder bez względu na to, czy zawiera on pliki tylko do odczytu, użyj

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

Od docs Pythona na 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)

z Pythona 3.4 możesz użyć:

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

gdzie pthjest pathlib.Pathinstancja. Fajnie, ale może nie być najszybszy.

Z docs.python.org :

W tym przykładzie pokazano, jak usunąć drzewo katalogów w systemie Windows, w którym niektóre pliki mają ustawiony bit tylko do odczytu. Używa wywołania zwrotnego onerror, aby wyczyścić bit tylko do odczytu i ponowić próbę usunięcia. Wszelkie kolejne niepowodzenia będą się rozprzestrzeniać.

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) 

Jeśli ustawione jest ignore_errors, błędy są ignorowane; w przeciwnym razie, jeśli ustawiony jest onerror, wywoływany jest do obsługi błędu z argumentami (func, path, exc_info), gdzie func to os.listdir, os.remove lub os.rmdir; ścieżka jest argumentem tej funkcji, która spowodowała jej awarię; a exc_info to krotka zwrócona przez sys.exc_info (). Jeśli ignore_errors ma wartość false, a onerror ma wartość None, zgłaszany jest wyjątek. Wprowadź kod tutaj

Oprzyj się na odpowiedzi kkubasika, sprawdź, czy folder istnieje przed usunięciem, bardziej solidny

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")

jeśli jesteś pewien, że chcesz usunąć całe drzewo katalogów i nie jesteś już zainteresowany zawartością katalogu, to przeszukiwanie całego drzewa katalogów jest głupotą ... po prostu wywołaj natywną komendę systemu operacyjnego z python, aby to zrobić. Będzie szybszy, wydajniejszy i zużywa mniej pamięci.

RMDIR c:\blah /s /q 

lub * nix

rm -rf /home/whatever 

W pythonie kod będzie wyglądał jak ...

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])

Tylko niektóre opcje Pythona do uzupełnienia powyższych odpowiedzi. (Chciałbym je tutaj znaleźć).

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

Usuń folder, jeśli jest pusty

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")

Usuń także folder, jeśli zawiera ten plik

    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)

usuń folder, jeśli zawiera tylko pliki .srt lub .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")

Usuń folder, jeśli jego rozmiar jest mniejszy niż 400 KB:

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")

Chciałbym dodać podejście „czystej ścieżki”:

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()

Zależy to od tego, że Pathjest uporządkowane, a dłuższe ścieżki zawsze będą sortować po krótszych ścieżkach, tak jak str. Dlatego katalogi pojawią się przed plikami. Jeśli się odwrócimy sortowanie, pliki pojawią się przed ich odpowiednimi kontenerami, więc możemy je po prostu odłączyć / rmdir jeden po drugim za jednym przejściem.

Korzyści:

• NIE jest oparty na zewnętrznych plikach binarnych: wszystko korzysta z modułów zawartych w bateriach Pythona (Python> = 3.6)
• Jest szybki i energooszczędny: bez stosu rekurencyjnego, bez potrzeby uruchamiania podprocesu
• Jest wieloplatformowy (przynajmniej tyle pathlib obiecuje w Pythonie 3.6; żadna z powyższych operacji nie działa w systemie Windows)
• W razie potrzeby można wykonać bardzo szczegółowe rejestrowanie, np. Rejestrować każde usunięcie w miarę upływu czasu.

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)

Jeśli nie chcesz korzystać z shutilmodułu, możesz po prostu użyć osmodułu.

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

Dziesięć lat później i przy użyciu Pythona 3.7 i Linuksa istnieją jeszcze różne sposoby:

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])

Zasadniczo używa modułu podprocesu Pythona do uruchamiania skryptu bash, $ rm -rf '/path/to/your/dirtak jakbyś używał terminala do wykonania tego samego zadania. To nie jest w pełni Python, ale robi to.

Podałem pathlib.Pathprzykład, ponieważ z mojego doświadczenia wynika, że ​​jest bardzo przydatny, gdy mamy do czynienia z wieloma zmieniającymi się ścieżkami. Dodatkowe etapy importowania pathlib.Pathmodułu i konwertowania wyników końcowych na ciągi są często dla mnie niższym kosztem czasu programowania. Byłoby wygodne, gdyby Path.rmdir()był wyposażony w opcję arg do jawnej obsługi niepustych katalogów.

Aby usunąć folder, nawet jeśli nie istnieje (unikając warunków wyścigu w odpowiedzi Charlesa Chowa ), ale nadal występują błędy, gdy inne rzeczy idą źle (np. Problemy z uprawnieniami, błąd odczytu dysku, plik nie jest katalogiem)

W przypadku 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)

Kod Python 2.7 jest prawie taki sam:

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)

W przypadku os.walk zaproponowałbym rozwiązanie składające się z 3 jedno-liniowych wywołań Pythona:

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)"

Pierwszy skrypt chmod ma wszystkie podkatalogi, drugi skrypt chmod ma wszystkie pliki. Następnie trzeci skrypt usuwa wszystko bez przeszkód.

Przetestowałem to z poziomu „Skryptu powłoki” w zadaniu Jenkinsa (nie chciałem przechowywać nowego skryptu Python w SCM, dlatego szukałem rozwiązania jednowierszowego) i działało to w systemach Linux i Windows.

Dla uproszczenia możesz użyć polecenia os.system:

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

Jak oczywiste, faktycznie wykonuje terminal systemowy, aby wykonać to zadanie.

Znalazłem bardzo łatwy sposób na usunięcie dowolnego folderu (nawet NIE pustego) lub pliku w systemie operacyjnym WINDOWS .

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

W systemie Windows, jeśli katalog nie jest pusty i masz pliki tylko do odczytu lub występują błędy takie jak

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

Spróbuj tego, os.system('rmdir /S /Q "{}"'.format(directory))

Jest to odpowiednik rm -rfw systemach Linux / Mac.