Jak usunąć zawartość folderu w Pythonie?

Wypróbuj moduł shutil

import shutil
shutil.rmtree('/path/to/folder')

Opis: shutil.rmtree(path, ignore_errors=False, onerror=None)

Docstring: Recursively delete a drzewo katalogów.

Jeśli ignore_errors jest ustawione, błędy są ignorowane; w przeciwnym razie, Jeśli onerror jest ustawione, jest wywoływany do obsługi błędu z argumenty (func, path, exc_info) gdzie func jest os.listdir, os.remove, lub os.rmdir; path jest argumentem do tego funkcja, która spowodowała jego awarię; oraz exc_info jest krotką zwracaną przez sys.exc_info(). If ignore_errors is false and onerror is None, an wyjątkiem jest podniesiony.

Możesz po prostu to zrobić:

import os
import glob

files = glob.glob('/YOUR/PATH/*')
for f in files:
    os.remove(f)

Możesz oczywiście użyć innego filtra w swojej ścieżce, na przykład : /YOU / PATH/*.txt do usuwania wszystkich plików tekstowych w katalogu.

Rozszerzenie odpowiedzi mhawke to jest to, co zaimplementowałem. Usuwa całą zawartość folderu, ale nie sam folder. Przetestowany na Linuksie z plikami, folderami i dowiązaniami symbolicznymi, powinien działać również na Windows.

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

Użycie rmtree i odtworzenie folderu może zadziałać, ale napotkałem błędy podczas usuwania i natychmiastowego odtwarzania folderów na dyskach sieciowych.

Proponowane rozwiązanie przy użyciu walk nie działa, ponieważ używa {[1] } do usuwania folderów, a następnie może próbować użyć os.unlink na plikach, które były wcześniej w tych folderach. Powoduje to błąd.

Opublikowane rozwiązanie glob będzie również próbowało usunąć niepuste foldery, powodując błędy.

Proponuję użyć:

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)

Jako Jedynka:

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

Bardziej solidnym rozwiązaniem uwzględniającym również pliki i katalogi byłoby (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)) )

uwagi: w przypadku, gdy ktoś głosował na moją odpowiedź, mam coś do wyjaśnienia tutaj.

1. każdy lubi krótkie i proste odpowiedzi. Jednak czasami rzeczywistość nie jest taka prosta.
2. Wracając do mojej odpowiedzi. Wiem, że shutil.rmtree() może być użyty do usunięcia drzewa katalogów. Używałem go wielokrotnie w moich własnych projektach. Ale musisz zdawać sobie sprawę, że sam katalog również zostanie usunięty przez shutil.rmtree(). Chociaż może to być akceptowalne dla niektórych, nie jest to prawidłowa odpowiedź na usunięcie zawartości folderu (bez skutków ubocznych).
3. pokażę Ci przykład skutków ubocznych. Załóżmy, że masz katalog z dostosowany właściciel i mode bitów, gdzie jest dużo zawartości. Następnie usuwa się go za pomocą shutil.rmtree() i przebudowuje za pomocą os.mkdir(). Zamiast tego otrzymasz pusty katalog z domyślnym (dziedziczonym) właścicielem i bitami trybu. Chociaż możesz mieć uprawnienia do usuwania zawartości, a nawet katalogu, możesz nie być w stanie ustawić z powrotem oryginalne bity właściciela i trybu w katalogu (np. nie jesteś superużytkownikiem).
4. wreszcie, bądź cierpliwy i przeczytaj kod. Jest długi i brzydki( w zasięgu wzroku), ale okazał się niezawodny i skuteczny (w użyciu).

Rozwiązuje kilka problemów, które nie są rozwiązywane przez innych odpowiedziających:

• poprawnie obsługuje dowiązania symboliczne, w tym nie wywołuje shutil.rmtree() na dowiązaniu symbolicznym (które przejdzie test os.path.isdir(), jeśli łączy się z katalogiem; nawet wynik os.walk() zawiera również dowiązania symboliczne).
• ładnie obsługuje pliki tylko do odczytu.

Oto kod (jedyną użyteczną funkcją jest clear_dir()):

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

Jest to jak dotąd jedyna odpowiedź, która:

• usuwa wszystkie dowiązania symboliczne
  • martwe linki
  • Linki do katalogów
  • Linki do plików
• usuwa podkatalogi
• nie usuwa katalogu nadrzędnego

Kod:

for filename in os.listdir(dirpath):
    filepath = os.path.join(dirpath, filename)
    try:
        shutil.rmtree(filepath)
    except OSError:
        os.remove(filepath)

Jak wiele innych odpowiedzi, to nie próbuje dostosować uprawnienia, aby umożliwić usuwanie plików / katalogów.

Może lepiej użyć os.walk() do tego.

os.listdir() nie odróżnia plików od katalogów i szybko wpadniesz w kłopoty próbując je odłączyć. Istnieje dobry przykład użycia os.walk() do rekurencyjnego usuwania katalogu tutaj i podpowiedzi, jak dostosować go do swoich okoliczności.

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]

Wcześniejszy komentarz wspomina również o używaniu systemu operacyjnego.scandir w Pythonie 3.5+. Na przykład:

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)

Kiedyś rozwiązywałem problem w ten sposób:

import shutil
import os

shutil.rmtree(dirpath)
os.mkdir(dirpath)

Konw to stary wątek, ale znalazłem coś ciekawego z oficjalnej strony Pythona. Tylko za podzielenie się innym pomysłem na usunięcie całej zawartości w katalogu. Ponieważ mam pewne problemy z autoryzacją podczas korzystania z shutil.rmtree () i nie chcę usuwać katalogu i go odtwarzać. Oryginalny adres to http://docs.python.org/2/library/os.html#os.walk mam nadzieję, że to komuś pomoże.

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

Yet Another Solution:

import sh
sh.rm(sh.glob('/path/to/folder/*'))

Rozwiązałem problem błędu z rmtree makedirs, dodając czas.sleep ()

if os.path.isdir(folder_location):
    shutil.rmtree(folder_location)

time.sleep(.5)

os.makedirs(folder_location, 0o777)

Jeśli używasz systemu *nix, dlaczego nie użyć polecenia systemowego?

import os
path = 'folder/to/clean'
os.system('rm -rf %s/*' % path)

ODPOWIEDŹ na ograniczoną, konkretną sytuację: zakładając, że chcesz usunąć Pliki podczas utrzymywania drzewa podfolderów, możesz użyć algorytmu rekurencyjnego:

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)

Może trochę off-topic, ale myślę, że wielu uznałoby to za przydatne

Zakładając, że temp_dir zostanie usunięte, jednolinijkowe polecenie używając os będzie brzmiało:

_ = [os.remove(os.path.join(save_dir,i)) for i in os.listdir(temp_dir)]

Uwaga: Jest to tylko 1-liner do usuwania plików ' nie usuwa katalogów.

To powinno zrobić sztuczkę tylko za pomocą modułu systemu operacyjnego, aby wyświetlić listę, a następnie usunąć!

import os
DIR = os.list('Folder')
for i in range(len(DIR)):
    os.remove('Folder'+chr(92)+i)

Pracował dla mnie, wszelkie problemy daj mi znać!