Comment supprimer le contenu d'un dossier en Python?

Question

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

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

Answer 1

Mise à jour pour ne supprimer que les fichiers et pour utiliser la méthode os.path.join () proposée dans les commentaires. Si vous souhaitez également supprimer des sous-répertoires, supprimez la mise en commentaire de l'instruction 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 2

Essayez le module shutil

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

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

Docstring: Supprimez récursivement a arborescence de répertoires.

Si ignore_errors est défini, les erreurs sont ignoré; sinon, si onerror est défini, il est appelé à gérer l'erreur avec arguments (func, path, exc_info) où func est os.listdir, os.remove ou os.rmdir; chemin est l'argument à cela fonction qui a causé son échec; et exc_info est un tuple renvoyé par sys.exc_info(). Si ignore_errors est false et onerror est None, un l'exception est levée.

Answer 3

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.

Answer 4

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

Utiliser rmtree et recréer le dossier pourrait fonctionner, mais des erreurs se sont produites lors de la suppression et de la recréation immédiate de dossiers sur des lecteurs réseau.

La solution proposée à l'aide de walk ne fonctionne pas car elle utilise rmtree pour supprimer des dossiers, puis peut tenter d'utiliser os.unlink sur les fichiers qui se trouvaient précédemment dans ces dossiers. Cela provoque une erreur.

La solution glob publiée tentera également de supprimer des dossiers non vides, en 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):
        os.unlink(file_object_path)
    else:
        shutil.rmtree(file_object_path)

Answer 6

En tant que doublure:

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

(2.7) serait une solution plus robuste pour la comptabilisation des fichiers et des répertoires:

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 7

Notes: au cas où quelqu'un voterait 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 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 savoir que le répertoire lui-même sera également supprimé par shutil.rmtree(). Bien que cela puisse être acceptable pour certains, ce n'est pas une réponse valable 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 customisé propriétaire et les bits de mode, 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 default (hérité) propriétaire et 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 les bits de propriétaire et de mode d'origine sur le répertoire (par exemple, vous n'êtes pas un superutilisateur).
4. Enfin, soyez patient et lisez le code . C'est long et moche (en vue), mais il s'est avéré fiable et efficace (en cours d'utilisation).

---

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

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

• Il gère correctement les liens symboliques, y compris le fait de ne pas appeler shutil.rmtree() sur un lien symbolique (qui passera le test os.path.isdir() s'il est lié à un répertoire; même le résultat de os.walk() contient également des répertoires liés symboliquement).
• 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")

Answer 8

C’est la seule réponse à ce jour, qui:

• supprime tous les liens symboliques
  • liens morts
  • liens vers des annuaires
  • 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, ceci n'essaye pas d'ajuster les permissions pour permettre la suppression de fichiers/répertoires.

Answer 9

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 mentionnait également l'utilisation de 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)

Answer 10

Vous feriez mieux d'utiliser os.walk() pour cela.

os.listdir() ne distingue pas les fichiers des répertoires et vous aurez rapidement des difficultés à les dissocier. Il existe un bon exemple d'utilisation de os.walk() pour supprimer de manière récursive un répertoire ici , ainsi que des conseils sur la manière de l'adapter à votre situation.

Answer 11

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 pour supprimer tout le contenu d'un répertoire. Parce que j’ai des problèmes d’autorisation lors de l’utilisation de shutil.rmtree () et que 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))

Answer 12

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

import shutil
import os

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

Answer 13

Encore une autre solution:

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

Answer 14

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

Answer 15

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)

Answer 16

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

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

time.sleep(.5)

os.makedirs(folder_location, 0o777)

Answer 17

Faites ceci simplement. Cela supprimera tous les fichiers du répertoire ainsi que ceux des sous-répertoires. Sans nuire à aucun dossier/répertoire. Fonctionne bien sur Ubuntu sans aucune erreur.

import os, re, os.path
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))

Answer 18

Répondez pour une situation spécifique limitée: Si vous souhaitez supprimer les fichiers tout en maintenant 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):
        map(recursively_remove_files, [os.path.join(f,fi) for fi in os.listdir(f)])

recursively_remove_files(my_directory)

Peut-être un peu hors sujet, mais je pense que beaucoup le trouveraient utile

Answer 19

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

Answer 20

En supposant que temp_dir soit supprimé, une commande à une seule ligne utilisant os serait:

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

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

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

Answer 21

Je suis surpris que personne n'ait mentionné la pathlib impressionnante pour faire ce travail.

Si vous souhaitez uniquement supprimer des fichiers dans un répertoire, vous pouvez utiliser un programme en ligne.

from pathlib import Path

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

Pour supprimer récursivement les 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)

Answer 22

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)