Как мне удалить / удалить папку, которая не пуста?

import shutil

shutil.rmtree('/folder_name')

Ссылка на стандартную библиотеку: shutil.rmtree.

По своей конструкции rmtree не работает в деревьях папок, содержащих файлы, доступные только для чтения. Если вы хотите, чтобы папка была удалена независимо от того, содержит ли она файлы только для чтения, используйте

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

Из документы python на 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))

если вы уверены, что хотите удалить все дерево каталогов и больше не интересуетесь содержимым каталога, то сканирование всего дерева каталогов - глупость ... просто вызовите собственную команду ОС из python, чтобы сделать это. Это будет быстрее, эффективнее и потребляет меньше памяти.

RMDIR c:\blah /s /q 

или * nix

rm -rf /home/whatever 

В python код будет выглядеть так ..

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

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

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) 

Если установлено ignore_errors, ошибки игнорируются; в противном случае, если установлена ​​ошибка onerror, она вызывается для обработки ошибки с аргументами (func, path, exc_info), где func - это os.listdir, os.remove или os.rmdir; path - это аргумент той функции, которая вызвала сбой; а exc_info - это кортеж, возвращаемый sys.exc_info (). Если ignore_errors имеет значение false, а onerror равно None, возникает исключение. Введите здесь код.

из python 3.4 вы можете использовать:

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 the dir content but not the dir itself, remove this line

где pth - это экземпляр pathlib.Path. Красиво, но может быть не самым быстрым.

Основываясь на ответе kkubasik, проверьте, существует ли папка перед удалением, более надежный

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

Вы можете использовать команду os.system для простоты:

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

Очевидно, что он фактически вызывает системный терминал для выполнения этой задачи.

Если вы не хотите использовать модуль shutil, вы можете просто использовать модуль 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

Просто несколько вариантов Python 3.5, чтобы завершить ответы выше. (Мне бы очень хотелось найти их здесь).

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

Удалить папку, если пуста

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

Удалите также папку, если она содержит этот файл

    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)

удалить папку, если она содержит только файлы .srt или .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")

Удалите папку, если ее размер меньше 400 Кб:

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

От docs.python.org:

This example shows how to remove a directory tree on Windows where some of the files have their read-only bit set. It uses the onerror callback to clear the readonly bit and reattempt the remove. Any subsequent failure will propagate.

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)

Чтобы удалить папку, даже если она может не существовать (избегая состояния гонки в Ответ Чарльза Чоу), но все еще иметь ошибки, когда другие вещи идут не так (например, проблемы с разрешениями, ошибка чтения с диска, файл не является каталогом)

Для 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)

Код Python 2.7 почти такой же:

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)

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)

Я нашел очень простой способ удалить любой папка (даже НЕ пустая) или файл на ОС Windows.

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

С os.walk я бы предложил решение, которое состоит из трех однострочных вызовов Python:

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

Первый сценарий chmod - все подкаталоги, второй сценарий - все файлы chmod. Затем третий скрипт удаляет все без препятствий.

Я тестировал это из «Shell Script» в задании Jenkins (я не хотел хранить новый скрипт Python в SCM, поэтому искал однострочное решение), и это сработало для Linux и Windows.

Десять лет спустя, используя Python 3.7 и Linux, все еще есть разные способы сделать это:

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

По сути, он использует модуль подпроцесса Python для запуска сценария bash $ rm -rf '/path/to/your/dir, как если бы вы использовали терминал для выполнения той же задачи. Это не полностью Python, но он справляется.

Я включил пример pathlib.Path потому, что, по моему опыту, он очень полезен при работе со многими изменяющимися путями. Дополнительные шаги по импорту модуля pathlib.Path и преобразованию конечных результатов в строки часто обходятся мне дешевле времени разработки. Было бы удобно, если бы Path.rmdir() поставлялся с опцией arg для явной обработки непустых каталогов.

Для Windows, если каталог не пуст, и у вас есть файлы, доступные только для чтения, или вы получаете такие ошибки, как

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

Попробуй, os.system('rmdir /S /Q "{}"'.format(directory))

Это эквивалент rm -rf в Linux / Mac.

Я хотел бы добавить подход "чистого pathlib":

from pathlib import Path
from typing import Union

def del_dir(target: Union[Path, str], only_if_empty: bool = False):
    """
    Delete a given directory and its subdirectories.

    :param target: The directory to delete
    :param only_if_empty: Raise RuntimeError if any file is found in the tree
    """
    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()

Это основано на том факте, что Path можно заказать, и более длинные пути всегда будут отсортированы после более коротких, как и str. Следовательно, каталоги будут предшествовать файлам. Если мы обратный сортировки, файлы будут располагаться перед соответствующими контейнерами, поэтому мы можем просто отсоединить / rmdir их один за другим за один проход.

Выгоды:

• Он НЕ полагается на внешние двоичные файлы: все использует модули Python с батарейками (Python> = 3.6)
  • Это означает, что не нужно повторно запускать новый подпроцесс для отключения.
• Это довольно быстро и просто; вам не нужно реализовывать свою собственную рекурсию
• Это кроссплатформенный (по крайней мере, это то, что pathlib обещает в Python 3.6; ни одна из указанных выше операций не работает в Windows)
• При необходимости можно вести подробный журнал, например, записывать каждое удаление по мере его возникновения.

В моем случае единственным способом удаления было использование всех возможностей, потому что мой код должен был запускаться либо с помощью cmd.exe, либо с помощью powershell.exe. Если это ваш случай, просто создайте функцию с этим кодом, и все будет в порядке:

        #!/usr/bin/env python3

        import shutil
        from os import path, system
        import sys

        # Try to delete the folder ---------------------------------------------
        if (path.isdir(folder)):
            shutil.rmtree(folder, ignore_errors=True)

        if (path.isdir(folder)):
            try:
                system("rd -r {0}".format(folder))
            except Exception as e:
                print("WARN: Failed to delete => {0}".format(e),file=sys.stderr)

        if (path.isdir(self.backup_folder_wrk)):
            try:
                system("rd /s /q {0}".format(folder))
            except Exception as e:
                print("WARN: Failed to delete => {0}".format(e),file=sys.stderr)

        if (path.isdir(folder)):
            print("WARN: Failed to delete {0}".format(folder),file=sys.stderr)
        # -------------------------------------------------------------------------------------

Основанное на рекурсии, чистое решение pathlib:

from pathlib import Path

def remove_path(path: Path):
    if path.is_file() or path.is_symlink():
        path.unlink()
        return
    for p in path.iterdir():
        remove_path(p)
    path.rmdir()

Поддерживает Windows и символические ссылки