Como faço para remover / excluir uma pasta que não está vazia?

Estou recebendo um erro 'acesso negado' quando tento excluir uma pasta que não está vazia. Eu usei o seguinte comando na minha tentativa: os.remove("/folder_name").

Qual é a maneira mais eficaz de remover / excluir uma pasta / diretório que não está vazio?

import shutil

shutil.rmtree('/folder_name')

Referência da biblioteca padrão: shutil.rmtree .

Por design, rmtreefalha nas árvores de pastas que contêm arquivos somente leitura. Se você deseja que a pasta seja excluída, independentemente de conter arquivos somente leitura, use

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

A partir dos documentos python em 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)

do python 3.4 você pode usar:

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

onde pthé uma pathlib.Pathinstância Bom, mas pode não ser o mais rápido.

Do docs.python.org :

Este exemplo mostra como remover uma árvore de diretórios no Windows em que alguns dos arquivos têm o bit somente leitura definido. Ele usa o retorno de chamada onerror para limpar o bit somente leitura e tentar remover novamente. Qualquer falha subsequente será propagada.

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) 

Se ignore_errors estiver definido, os erros serão ignorados; caso contrário, se onerror for definido, ele será chamado para manipular o erro com argumentos (func, path, exc_info) em que func é os.listdir, os.remove ou os.rmdir; path é o argumento para essa função que causou a falha; e exc_info é uma tupla retornada por sys.exc_info (). Se ignore_errors for false e onerror for None, uma exceção será gerada.

Com base na resposta do kkubasik, verifique se a pasta existe antes de remover, mais robusta

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

se você tiver certeza de que deseja excluir toda a árvore de diretórios e não estiver mais interessado no conteúdo dele, rastrear toda a árvore de diretórios é estúpido ... basta chamar o comando nativo do SO do python para fazer isso. Será mais rápido, eficiente e consumirá menos memória.

RMDIR c:\blah /s /q 

ou * nix

rm -rf /home/whatever 

Em python, o código terá a aparência ..

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

Apenas algumas opções do python 3.5 para concluir as respostas acima. (Eu adoraria encontrá-los aqui).

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

Excluir pasta se estiver vazio

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

Exclua também a pasta se ela contiver este arquivo

    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)

exclua a pasta se ela contiver apenas arquivos .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")

Exclua a pasta se o tamanho for menor que 400kb:

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

Eu gostaria de adicionar uma abordagem de "pathlib puro":

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

Isso depende do fato de Pathser ordenável, e caminhos mais longos sempre serão classificados após caminhos mais curtos, assim como str. Portanto, os diretórios virão antes dos arquivos. Se invertermos a classificação, os arquivos virão antes de seus respectivos contêineres, para que possamos simplesmente desvincular / rmdir deles um a um com uma passagem.

Benefícios:

• NÃO depende de binários externos: tudo usa os módulos incluídos nas baterias do Python (Python> = 3.6)
• É rápido e economiza memória: sem pilha de recursão, sem necessidade de iniciar um subprocesso
• É multiplataforma (pelo menos, é o que pathlibpromete no Python 3.6; nenhuma operação acima mencionada não deve ser executada no Windows)
• Se necessário, é possível fazer um registro muito granular, por exemplo, registrar cada exclusão à medida que ela acontece.

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)

Se você não quiser usar o shutilmódulo, basta usá-lo 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

Dez anos depois, e usando Python 3.7 e Linux, ainda existem maneiras diferentes de fazer isso:

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

Essencialmente, ele está usando o módulo de subprocesso do Python para executar o script bash $ rm -rf '/path/to/your/dircomo se você estivesse usando o terminal para realizar a mesma tarefa. Não é totalmente Python, mas é feito.

A razão pela qual incluí o pathlib.Pathexemplo é porque, em minha experiência, é muito útil ao lidar com muitos caminhos que mudam. As etapas extras de importação do pathlib.Pathmódulo e conversão dos resultados finais em seqüências de caracteres costumam ser um custo menor para o tempo de desenvolvimento. Seria conveniente se Path.rmdir()viesse com uma opção arg para lidar explicitamente com diretórios não vazios.

Para excluir uma pasta mesmo que ela não exista (evitando a condição de corrida na resposta de Charles Chow ), mas ainda tenha erros quando outras coisas derem errado (por exemplo, problemas de permissão, erro de leitura de disco, o arquivo não é um diretório)

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

O código Python 2.7 é quase o mesmo:

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)

Com o os.walk, eu proporia a solução que consiste em 3 chamadas Python de uma linha:

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

O primeiro script chmod é todos os subdiretórios, o segundo script chmod é todos os arquivos. Em seguida, o terceiro script remove tudo sem impedimentos.

Eu testei isso no "Shell Script" em um trabalho de Jenkins (não queria armazenar um novo script Python no SCM, por isso procurei uma solução de uma linha) e funcionou para Linux e Windows.

Você pode usar o comando os.system para simplificar:

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

Como óbvio, ele realmente chama o terminal do sistema para realizar esta tarefa.

Eu encontrei uma maneira muito fácil de excluir qualquer pasta (mesmo que não esteja vazia) ou arquivo no sistema operacional WINDOWS .

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

Para Windows, se o diretório não estiver vazio e você tiver arquivos somente leitura ou tiver erros como

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

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

É equivalente rm -rfno Linux / Mac.