Wie entferne / lösche ich einen Ordner, der nicht leer ist?

Beim Versuch, einen nicht leeren Ordner zu löschen, wird der Fehler "Zugriff verweigert" angezeigt. Ich habe bei meinem Versuch den folgenden Befehl verwendet : os.remove("/folder_name").

Was ist der effektivste Weg, um einen Ordner / ein Verzeichnis zu entfernen / löschen, der nicht leer ist?

import shutil

shutil.rmtree('/folder_name')

Standardbibliotheksreferenz: shutil.rmtree .

Schlägt rmtreestandardmäßig in Ordnerbäumen fehl, die schreibgeschützte Dateien enthalten. Wenn Sie möchten, dass der Ordner gelöscht wird, unabhängig davon, ob er schreibgeschützte Dateien enthält, verwenden Sie

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

Von dem Python - docs auf 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)

Ab Python 3.4 können Sie Folgendes verwenden:

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

Wo pthist eine pathlib.PathInstanz? Schön, aber vielleicht nicht der schnellste.

Von docs.python.org :

Dieses Beispiel zeigt, wie Sie einen Verzeichnisbaum unter Windows entfernen, für den für einige Dateien das schreibgeschützte Bit gesetzt ist. Es verwendet den onerror-Rückruf, um das schreibgeschützte Bit zu löschen und das Entfernen erneut zu versuchen. Jeder nachfolgende Fehler wird sich ausbreiten.

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) 

Wenn ignore_errors gesetzt ist, werden Fehler ignoriert. Wenn onerror gesetzt ist, wird es aufgerufen, um den Fehler mit Argumenten (func, path, exc_info) zu behandeln, wobei func os.listdir, os.remove oder os.rmdir ist. Pfad ist das Argument für diese Funktion, die zum Fehlschlagen geführt hat. und exc_info ist ein Tupel, das von sys.exc_info () zurückgegeben wird. Wenn ignore_errors false und onerror None ist, wird hier eine Ausnahme ausgelöst. Geben Sie Code ein

Überprüfen Sie anhand der Antwort von kkubasik, ob der Ordner vorhanden ist, bevor Sie ihn entfernen

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

Wenn Sie sicher sind, dass Sie den gesamten Verzeichnisbaum löschen möchten und sich nicht mehr für den Inhalt von dir interessieren, ist es dumm, nach dem gesamten Verzeichnisbaum zu kriechen. Rufen Sie dazu einfach den nativen Betriebssystembefehl von Python auf. Es wird schneller, effizienter und weniger speicherintensiv sein.

RMDIR c:\blah /s /q 

oder * nix

rm -rf /home/whatever 

In Python sieht der Code wie folgt aus:

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

Nur einige Python 3.5-Optionen, um die obigen Antworten zu vervollständigen. (Ich hätte sie gerne hier gefunden).

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

Ordner löschen, wenn leer

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

Löschen Sie auch den Ordner, wenn er diese Datei enthält

    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)

Ordner löschen, wenn er nur .srt- oder .txt-Dateien enthält

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

Ordner löschen, wenn seine Größe weniger als 400 KB beträgt:

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

Ich möchte einen "reinen Pathlib" -Ansatz hinzufügen:

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

Dies beruht auf der Tatsache, dass Pathes ordentlich ist und längere Pfade immer nach kürzeren Pfaden sortieren, genau wie str. Daher werden Verzeichnisse vor Dateien stehen. Wenn wir umkehren die Sortierung , werden die Dateien vor ihren jeweiligen Containern angezeigt, sodass wir sie einfach einzeln mit einem Durchgang trennen / rmdiren können.

Leistungen:

• Es ist NICHT auf externe Binärdateien angewiesen: Alles verwendet Pythons Module, die in Batterien enthalten sind (Python> = 3.6).
• Es ist schnell und speichereffizient: Kein Rekursionsstapel, kein Unterprozess muss gestartet werden
• Es ist plattformübergreifend (zumindest ist es das, was pathlib verspricht dies in Python 3.6; kein oben angegebener Vorgang soll nicht unter Windows ausgeführt werden)
• Bei Bedarf kann eine sehr detaillierte Protokollierung durchgeführt werden, z. B. jede Löschung wird protokolliert, sobald dies geschieht.

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)

Wenn Sie das shutilModul nicht verwenden möchten, können Sie es einfach verwenden os.

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

Zehn Jahre später und unter Verwendung von Python 3.7 und Linux gibt es noch verschiedene Möglichkeiten, dies zu tun:

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

Im Wesentlichen wird das Unterprozessmodul von Python verwendet, um das Bash-Skript $ rm -rf '/path/to/your/dirso auszuführen, als würden Sie das Terminal verwenden, um dieselbe Aufgabe auszuführen . Es ist nicht vollständig Python, aber es schafft es.

Der Grund, warum ich das pathlib.PathBeispiel aufgenommen habe, ist, dass es meiner Erfahrung nach sehr nützlich ist, wenn es um viele Pfade geht, die sich ändern. Die zusätzlichen Schritte zum Importieren des pathlib.PathModuls und zum Konvertieren der Endergebnisse in Zeichenfolgen sind für mich oft weniger Kosten für die Entwicklungszeit. Es wäre praktisch, wenn Sie Path.rmdir()eine arg-Option hätten, um nicht leere Verzeichnisse explizit zu behandeln.

So löschen Sie einen Ordner, auch wenn er möglicherweise nicht vorhanden ist (Vermeidung der Race-Bedingung in Charles Chows Antwort ), aber dennoch Fehler, wenn andere Fehler auftreten (z. B. Berechtigungsprobleme, Fehler beim Lesen der Festplatte, die Datei ist kein Verzeichnis)

Für 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)

Der Python 2.7-Code ist fast der gleiche:

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)

Mit os.walk würde ich die Lösung vorschlagen, die aus 3 einzeiligen Python-Aufrufen besteht:

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

Das erste Skript chmod enthält alle Unterverzeichnisse, das zweite Skript chmod enthält alle Dateien. Dann entfernt das dritte Skript alles ohne Hindernisse.

Ich habe dies anhand des "Shell-Skripts" in einem Jenkins-Job getestet (ich wollte kein neues Python-Skript in SCM speichern, deshalb wurde nach einer einzeiligen Lösung gesucht) und es funktionierte für Linux und Windows.

Der Einfachheit halber können Sie den Befehl os.system verwenden:

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

Es ist offensichtlich, dass das Systemterminal aufgerufen wird, um diese Aufgabe auszuführen.

Ich habe eine sehr einfache Möglichkeit gefunden, einen Ordner (auch NICHT leer) oder eine Datei unter WINDOWS OS zu löschen .

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

Für Windows, wenn das Verzeichnis nicht leer ist und Sie schreibgeschützte Dateien haben oder Fehler wie erhalten

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

Versuche dies, os.system('rmdir /S /Q "{}"'.format(directory))

Es ist gleichbedeutend rm -rfmit Linux / Mac.