¿Cómo puedo eliminar / eliminar una carpeta que no está vacía con Python?

De los documentos de python en 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)

Desde python 3.4 puedes 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

Donde pth es una instancia pathlib.Path. Bonito, pero puede que no sea el más rápido.

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) 

Si ignore_errors está establecido, los errores son ignorados; de lo contrario, si onerror está establecido, se llama para manejar el error con argumentos (func, path, exc_info) donde func es os.listdir, os.quitar, o os.rmdir; path es el argumento de la función que causó que fallara; y exc_info es una tupla devuelta por sys.exc_info (). Si ignore_errors es false y onerror es None, se genera una excepción.introduzca el código aquí

Si está seguro de que desea eliminar todo el árbol de dir, y ya no está interesado en el contenido del dir, entonces rastrear todo el árbol de dir es estupidez... simplemente llame al comando nativo del sistema operativo desde python para hacer eso. Será más rápido, eficiente y consumirá menos memoria.

RMDIR c:\blah /s /q 

O * nix

rm -rf /home/whatever 

En python, el código se verá como..

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

Basado en la respuesta de kkubasik, compruebe si existe la carpeta antes de eliminar, más robusto

import shutil
def remove_folder(path):
    # check if folder exists
    if os.path.exists(path):
         # remove if exists
         shutil.rmtree(path)
remove_folder("/folder_name")

De docs.python.org:

Este ejemplo muestra cómo eliminar un árbol de directorios en Windows donde algunos de los archivos tienen su bit de solo lectura establecido. Utiliza el onerror devolución de llamada para borrar el bit de solo lectura y volver a intentar eliminar. Cualquier el fallo posterior se propagará.

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)

Si no quieres usar el módulo shutil puedes usar el módulo 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

Solo algunas opciones de python 3.5 para completar las respuestas anteriores. (Me hubiera encantado encontrarlos aquí).

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

Eliminar carpeta si está vacía

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

Eliminar también carpeta si contiene este archivo

    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)

Eliminar carpeta si solo contiene .srt or .archivo (s) 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")

Eliminar carpeta si su tamaño es inferior a 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")

Puede usar el sistema operativo.comando del sistema para simplificar:

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

Como es obvio, en realidad invoca a system terminal para realizar esta tarea.

Para eliminar una carpeta incluso si no existe (evitando la condición de carrera en La respuesta de Charles Chow ) pero aún tiene errores cuando otras cosas salen mal (por ejemplo, problemas de permisos, error de lectura del disco, el archivo no es un directorio)

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)

El código de Python 2.7 es casi el mismo:

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)

He encontrado una manera muy fácil de Eliminar cualquier carpeta (Incluso NO Vacía) o archivo en WINDOWS OS.

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

Con os.caminando me gustaría proponer la solución que consta de 3 one-liner Python llamadas:

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

El primer script chmod es all sub-directories, el segundo script chmod es all files. Entonces el tercer guión elimina todo sin impedimentos.

He probado esto desde el "Shell Script" en un trabajo de Jenkins (no quería almacenar un nuevo script de Python en SCM, por eso busqué una solución de una línea) y funcionó para Linux y Windows.