Comment supprimer le contenu d'un dossier?

Comment puis-je supprimer le contenu d'un dossier local en Python?

Le projet actuel est pour Windows, mais j'aimerais aussi voir * nix.

import os, shutil
folder = '/path/to/folder'
for filename in os.listdir(folder):
    file_path = os.path.join(folder, filename)
    try:
        if os.path.isfile(file_path) or os.path.islink(file_path):
            os.unlink(file_path)
        elif os.path.isdir(file_path):
            shutil.rmtree(file_path)
    except Exception as e:
        print('Failed to delete %s. Reason: %s' % (file_path, e))

Vous pouvez simplement faire ceci:

import os
import glob

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

Vous pouvez bien sûr utiliser un autre filtre dans votre chemin, par exemple: /YOU/PATH/*.txt pour supprimer tous les fichiers texte d'un répertoire.

Vous pouvez supprimer le dossier lui-même, ainsi que tout son contenu, en utilisant shutil.rmtree:

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

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

Supprimer une arborescence de répertoires entière; chemin doit pointer vers un répertoire (mais pas un lien symbolique vers un répertoire). Si ignore_errors est vrai, les erreurs résultant d'échecs de suppression seront ignorées; si elles sont fausses ou omises, ces erreurs sont gérées en appelant un gestionnaire spécifié par onerror ou, si cela est omis, elles déclenchent une exception.

En développant la réponse de mhawke, c'est ce que j'ai mis en œuvre. Il supprime tout le contenu d'un dossier mais pas le dossier lui-même. Testé sur Linux avec des fichiers, des dossiers et des liens symboliques, devrait également fonctionner sur 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))

En utilisant rmtree et la recréation du dossier pourraient fonctionner, mais j'ai rencontré des erreurs lors de la suppression et de la recréation immédiate des dossiers sur les lecteurs réseau.

La solution proposée à l'aide de walk ne fonctionne pas car elle permet rmtreede supprimer des dossiers et peut ensuite tenter d'utiliser os.unlinksur les fichiers qui se trouvaient précédemment dans ces dossiers. Cela provoque une erreur.

Le posté glob solution tentera également de supprimer les dossiers non vides, provoquant des erreurs.

Je vous suggère d'utiliser:

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) or os.path.islink(file_object_path):
        os.unlink(file_object_path)
    else:
        shutil.rmtree(file_object_path)

Cette:

• supprime tous les liens symboliques
  • liens morts
  • liens vers des répertoires
  • liens vers des fichiers
• supprime les sous-répertoires
• ne supprime pas le répertoire parent

Code:

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

Comme beaucoup d'autres réponses, cela n'essaie pas d'ajuster les autorisations pour permettre la suppression des fichiers / répertoires.

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

Une solution plus robuste tenant également compte des fichiers et des répertoires serait (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)) )

Remarques: si quelqu'un a voté contre ma réponse, j'ai quelque chose à expliquer ici.

1. Tout le monde aime les réponses courtes et simples. Cependant, parfois la réalité n'est pas si simple.
2. Revenons à ma réponse. Je sais que cela shutil.rmtree()pourrait être utilisé pour supprimer une arborescence de répertoires. Je l'ai utilisé plusieurs fois dans mes propres projets. Mais vous devez comprendre que le répertoire lui-même sera également supprimé parshutil.rmtree() . Bien que cela puisse être acceptable pour certains, ce n'est pas une réponse valide pour supprimer le contenu d'un dossier (sans effets secondaires) .
3. Je vais vous montrer un exemple des effets secondaires. Supposons que vous ayez un répertoire avec des bits de propriétaire et de mode personnalisés , où il y a beaucoup de contenu. Ensuite, vous le supprimez avec shutil.rmtree()et le reconstruisez avec os.mkdir(). Et vous obtiendrez un répertoire vide avec le propriétaire par défaut (hérité) et les bits de mode à la place. Bien que vous ayez le privilège de supprimer le contenu et même le répertoire, vous ne pourrez peut-être pas redéfinir le propriétaire d'origine et les bits de mode sur le répertoire (par exemple, vous n'êtes pas un superutilisateur).
4. Enfin, soyez patient et lisez le code . Il est long et moche (en vue), mais s'est avéré fiable et efficace (en cours d'utilisation).

Voici une solution longue et moche, mais fiable et efficace.

Il résout quelques problèmes qui ne sont pas traités par les autres répondeurs:

• Il gère correctement les liens symboliques, y compris ne pas faire appel shutil.rmtree()à un lien symbolique (qui réussira le os.path.isdir()test s'il établit un lien vers un répertoire; même le résultat de os.walk()contient également des répertoires liés symboliques).
• Il gère bien les fichiers en lecture seule.

Voici le code (la seule fonction utile est 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")

Je suis surpris que personne n'ait mentionné le formidable pathlibde faire ce travail.

Si vous souhaitez uniquement supprimer des fichiers dans un répertoire, il peut s'agir d'un oneliner

from pathlib import Path

[f.unlink() for f in Path("/path/to/folder").glob("*") if f.is_file()] 

Pour supprimer également récursivement des répertoires, vous pouvez écrire quelque chose comme ceci:

from pathlib import Path
from shutil import rmtree

for path in Path("/path/to/folder").glob("**/*"):
    if path.is_file():
        path.unlink()
    elif path.is_dir():
        rmtree(path)

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 commentaire précédent mentionne également l'utilisation d'os.scandir dans Python 3.5+. Par exemple:

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)

Vous feriez peut-être mieux de l'utiliser os.walk()pour cela.

os.listdir()ne distingue pas les fichiers des répertoires et vous aurez rapidement des problèmes pour les dissocier. Il existe un bon exemple d'utilisation os.walk()pour supprimer récursivement un répertoire ici , et des conseils sur la façon de l'adapter à votre situation.

J'avais l'habitude de résoudre le problème de cette façon:

import shutil
import os

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

Encore une autre solution:

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

Je sais que c'est un vieux fil mais j'ai trouvé quelque chose d'intéressant sur le site officiel de python. Juste pour partager une autre idée de suppression de tout le contenu d'un répertoire. Parce que j'ai des problèmes d'autorisation lors de l'utilisation de shutil.rmtree () et je ne veux pas supprimer le répertoire et le recréer. L'adresse d'origine est http://docs.python.org/2/library/os.html#os.walk . J'espère que cela pourrait aider quelqu'un.

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

Pour supprimer tous les fichiers du répertoire ainsi que ses sous-répertoires, sans supprimer les dossiers eux-mêmes, il suffit de procéder comme suit:

import os
mypath = "my_folder" #Enter your path here
for root, dirs, files in os.walk(mypath):
    for file in files:
        os.remove(os.path.join(root, file))

Si vous utilisez un système * nix, pourquoi ne pas utiliser la commande système?

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

Façon assez intuitive de le faire:

import shutil, os


def remove_folder_contents(path):
    shutil.rmtree(path)
    os.makedirs(path)


remove_folder_contents('/path/to/folder')

Eh bien, je pense que ce code fonctionne. Il ne supprimera pas le dossier et vous pouvez utiliser ce code pour supprimer les fichiers ayant l'extension particulière.

import os
import glob

files = glob.glob(r'path/*')
for items in files:
    os.remove(items)

J'ai dû supprimer des fichiers de 3 dossiers séparés dans un seul répertoire parent:

directory
   folderA
      file1
   folderB
      file2
   folderC
      file3

Ce code simple a fait l'affaire pour moi: (je suis sous Unix)

import os
import glob

folders = glob.glob('./path/to/parentdir/*')
for fo in folders:
  file = glob.glob(f'{fo}/*')
  for f in file:
    os.remove(f)

J'espère que cela t'aides.

J'ai résolu le problème avec rmtree makedirsen ajoutant time.sleep()entre:

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

time.sleep(.5)

os.makedirs(folder_location, 0o777)

Répondez à une situation limitée et spécifique: en supposant que vous souhaitez supprimer les fichiers tout en conservant l'arborescence des sous-dossiers, vous pouvez utiliser un algorithme récursif:

import os

def recursively_remove_files(f):
    if os.path.isfile(f):
        os.unlink(f)
    elif os.path.isdir(f):
        for fi in os.listdir(f):
            recursively_remove_files(os.path.join(f, fi))

recursively_remove_files(my_directory)

Peut-être légèrement hors sujet, mais je pense que beaucoup le trouveraient utile

En supposant temp_dirqu'elle soit supprimée, une commande sur une seule ligne utilisant osserait:

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

Remarque: Il s'agit uniquement d'une ligne pour la suppression de fichiers 'Ne supprime pas les répertoires.

J'espère que cela t'aides. Merci.

Utilisez la méthode ci-dessous pour supprimer le contenu d'un répertoire, pas le répertoire lui-même:

import os
import shutil

def remove_contents(path):
    for c in os.listdir(path):
        full_path = os.path.join(path, c)
        if os.path.isfile(full_path):
            os.remove(full_path)
        else:
            shutil.rmtree(full_path)

la façon la plus simple de supprimer tous les fichiers d'un dossier / supprimer tous les fichiers

import os
files = os.listdir(yourFilePath)
for f in files:
    os.remove(yourFilePath + f)

Cela devrait faire l'affaire en utilisant simplement le module OS pour lister puis supprimer!

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

A travaillé pour moi, tous les problèmes me le font savoir!