borrar - copiar archivos python

¿Cómo eliminar el contenido de una carpeta en Python?

Question

¿Cómo puedo eliminar el contenido de una carpeta local en Python?

El proyecto actual es para Windows, pero me gustaría ver * nix también.

Answer 1

¡Esto debería hacer el truco usando el módulo del sistema operativo para enumerar y luego eliminar!

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

Trabajó para mí, cualquier problema que me haga saber!

Answer 2

Actualizado para eliminar solo archivos y usar el método os.path.join () sugerido en los comentarios. Si también desea eliminar subdirectorios, elimine el comentario de la declaración elif.

import os, shutil
folder = ''/path/to/folder''
for the_file in os.listdir(folder):
    file_path = os.path.join(folder, the_file)
    try:
        if os.path.isfile(file_path):
            os.unlink(file_path)
        #elif os.path.isdir(file_path): shutil.rmtree(file_path)
    except Exception as e:
        print(e)

Answer 3

Ampliando la respuesta de mhawke, esto es lo que he implementado. Elimina todo el contenido de una carpeta pero no la carpeta en sí. Probado en Linux con archivos, carpetas y enlaces simbólicos, también debería funcionar en 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))

Answer 4

Como un oneliner:

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

Una solución más robusta que tenga en cuenta los archivos y directorios también sería (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)) )

Answer 5

El uso de rmtree y la recreación de la carpeta podrían funcionar, pero me he encontrado con errores al eliminar y rmtree carpetas en las unidades de red.

La solución propuesta que utiliza walk no funciona, ya que usa rmtree para eliminar carpetas y luego puede intentar usar os.unlink en los archivos que antes estaban en esas carpetas. Esto provoca un error.

La solución glob publicada también intentará eliminar carpetas no vacías, lo que provocará errores.

Te sugiero que uses:

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)

Answer 6

Esta es la única respuesta hasta ahora, que:

• elimina todos los enlaces simbólicos
  • enlaces muertos
  • enlaces a directorios
  • enlaces a archivos
• elimina subdirectorios
• no elimina el directorio padre

Código:

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

Como muchas otras respuestas, esto no intenta ajustar los permisos para permitir la eliminación de archivos / directorios.

Answer 7

Otra solución más:

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

Answer 8

Prueba el módulo shutil

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

Descripción: shutil.rmtree(path, ignore_errors=False, onerror=None)

Docstring: eliminar recursivamente un árbol de directorios.

Si se establece ignore_errors , los errores se ignoran; de lo contrario, si se establece onerror , se llama para manejar el error con argumentos (func, path, exc_info) donde func es os.listdir , os.remove o os.rmdir ; ruta es el argumento de esa función que hizo que fallara; y exc_info es una tupla devuelta por sys.exc_info() . Si ignore_errors es falso y onerror es None , se onerror una excepción.

Answer 9

Puede que sea mejor usar os.walk() para esto.

os.listdir() no distingue los archivos de los directorios y rápidamente tendrá problemas al intentar desvincularlos. Hay un buen ejemplo del uso de os.walk() para eliminar recursivamente un directorio here , y consejos sobre cómo adaptarlo a sus circunstancias.

Answer 10

Resolví el problema de error con rmtree makedirs agregando time.sleep () entre.

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

time.sleep(.5)

os.makedirs(folder_location, 0o777)

Answer 11

Responda a una situación específica y limitada: asumiendo que desea eliminar los archivos mientras mantiene el árbol de subcarpetas, podría usar un algoritmo recursivo:

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)

Tal vez un poco fuera de tema, pero creo que a muchos les resultaría útil

Answer 12

Sé que es un tema antiguo, pero he encontrado algo interesante en el sitio oficial de python. Solo por compartir otra idea para eliminar todos los contenidos de un directorio. Porque tengo algunos problemas de autorización al usar shutil.rmtree () y no quiero eliminar el directorio y volver a crearlo. La dirección original es http://docs.python.org/2/library/os.html#os.walk . Espero que pueda ayudar a alguien.

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

Answer 13

Si está utilizando un sistema * nix, ¿por qué no aprovechar el comando del sistema?

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

Answer 14

Simplemente puede hacer esto:

import os
import glob

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

Por supuesto, puede usar otro filtro en su ruta, por ejemplo: /YOU/PATH/*.txt para eliminar todos los archivos de texto en un directorio.

Answer 15

Solía ​​resolver el problema de esta manera:

import shutil
import os

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

Answer 16

Suponiendo que se elimine temp_dir , un comando de una sola línea que use os sería:

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

Nota: Esto es solo 1-liner para eliminar archivos ''No elimina directorios.

Espero que esto ayude. Gracias.

Answer 17

Notas: en caso de que alguien haya rechazado mi respuesta, tengo algo que explicar aquí.

1. A todos les gustan las respuestas cortas y simples. Sin embargo, a veces la realidad no es tan simple.
2. De vuelta a mi respuesta. Sé que shutil.rmtree() podría usarse para eliminar un árbol de directorios. Lo he usado muchas veces en mis propios proyectos. Pero debes darte cuenta de que el directorio en sí también será eliminado por shutil.rmtree() . Si bien esto puede ser aceptable para algunos, no es una respuesta válida para eliminar el contenido de una carpeta (sin efectos secundarios) .
3. Te mostraré un ejemplo de los efectos secundarios. Supongamos que tiene un directorio con bits de modo y propietario personalizados , donde hay una gran cantidad de contenidos. Luego lo elimina con shutil.rmtree() y lo reconstruye con os.mkdir() . Y obtendrá un directorio vacío con bits de modo y propietario predeterminados (heredados). Si bien puede tener el privilegio de eliminar el contenido e incluso el directorio, es posible que no pueda volver a establecer los bits de propietario y modo originales en el directorio (por ejemplo, no es un superusuario).
4. Finalmente, sea ​​paciente y lea el código . Es largo y feo (a la vista), pero demostrado ser confiable y eficiente (en uso).

Aquí hay una solución larga y fea, pero confiable y eficiente.

Resuelve algunos problemas que no son abordados por los otros respondedores:

• Maneja correctamente los enlaces simbólicos, incluyendo no llamar a shutil.rmtree() en un enlace simbólico (que pasará la prueba os.path.isdir() si está vinculado a un directorio; incluso el resultado de os.walk() contiene enlaces simbólicos directorios también).
• Maneja muy bien los archivos de solo lectura.

Aquí está el código (la única función útil es clear_dir() ):

import os
import stat
import shutil


# http://.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")

Answer 18

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]

Un comentario anterior también menciona el uso de os.scandir en Python 3.5+. Por ejemplo:

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)