හිස් නොවන ෆෝල්ඩරයක් ඉවත් කරන්නේ / මකා දැමෙන්නේ කෙසේද?

හිස් නොවන ෆෝල්ඩරයක් මකා දැමීමට උත්සාහ කරන විට මට 'ප්‍රවේශය ප්‍රතික්ෂේප වේ' දෝෂයක් ලැබේ. මගේ උත්සාහයේදී මම පහත විධානය භාවිතා කළෙමි : os.remove("/folder_name").

හිස් නොවන ෆෝල්ඩරයක් / නාමාවලියක් ඉවත් කිරීමට / මකා දැමීමට වඩාත්ම way ලදායී ක්‍රමය කුමක්ද?

import shutil

shutil.rmtree('/folder_name')

සම්මත පුස්තකාල යොමුව: shutil.rmtree .

සැලසුම අනුව, rmtreeකියවීමට පමණි ලිපිගොනු අඩංගු ෆෝල්ඩර ගස් මත අසමත් වේ. කියවීමට පමණක් ඇති ලිපිගොනු තිබේද යන්න නොසලකා ෆෝල්ඩරය මකා දැමීමට ඔබට අවශ්‍ය නම්, භාවිතා කරන්න

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

සිට මෙම පිඹුරා ලේඛන මත 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)

පයිතන් 3.4 සිට ඔබට භාවිතා කළ හැකිය:

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 the dir content but not the dir itself, remove this line

එහිදී pthයනු pathlib.Pathඋදාහරණයක්. හොඳයි, නමුත් වේගවත්ම නොවේ.

Docs.python.org වෙතින් :

මෙම උදාහරණයෙන් දැක්වෙන්නේ වින්ඩෝස් හි ඇති ඩිරෙක්ටරි ගසක් ඉවත් කරන්නේ කෙසේද යන්නයි. එය කියවිය හැකි බිට් ඉවත් කිරීමට සහ ඉවත් කිරීම නැවත උත්සාහ කිරීමට onerror callback භාවිතා කරයි. ඕනෑම පසුකාලීන අසමත් වීමක් ප්රචාරය කරනු ඇත.

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) 

Ignore_errors සකසා ඇත්නම්, දෝෂ නොසලකා හරිනු ලැබේ; වෙනත් ආකාරයකින්, onerror සකසා ඇත්නම්, එය දෝෂය තර්ක සමඟ හැසිරවීමට කැඳවනු ලැබේ (func, path, exc_info) එහිදී func යනු os.listdir, os.remove, හෝ os.rmdir; මාර්ගය යනු එම ශ්‍රිතය අසාර්ථක වීමට හේතු වූ තර්කයයි; සහ exc_info යනු sys.exc_info () විසින් ආපසු ලබා දෙන ලද ටුපල් ය. Ignore_errors අසත්‍ය නම් සහ onerror කිසිවක් නොවේ නම්, ව්‍යතිරේකයක් මතු වේ. මෙහි කේතය

Kkubasik ගේ පිළිතුර මත පදනම්ව, ඉවත් කිරීමට පෙර ෆෝල්ඩරය තිබේදැයි පරීක්ෂා කරන්න, වඩා ශක්තිමත්

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

ඔබට විශ්වාස නම්, ඔබට සම්පූර්ණ ඩර් ගස මකා දැමීමට අවශ්‍ය බවත්, ඩර් හි අන්තර්ගතය ගැන වැඩි උනන්දුවක් නොදක්වන බවත්, එවිට මුළු ඩර් ගස සඳහා බඩගා යාම මෝඩකමක් බවත් ... එය කිරීමට පයිතන් සිට ස්වදේශීය මෙහෙයුම් විධානය අමතන්න. එය වේගවත්, කාර්යක්ෂම හා අඩු මතක පරිභෝජනයක් වනු ඇත.

RMDIR c:\blah /s /q 

හෝ * නික්ස්

rm -rf /home/whatever 

පයිතන් වලදී, කේතය පෙනෙනු ඇත ..

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

ඉහත පිළිතුරු සම්පූර්ණ කිරීම සඳහා පයිතන් 3.5 විකල්ප කිහිපයක් පමණි. (මම ඔවුන් මෙහි සොයා ගැනීමට කැමතියි).

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

ෆෝල්ඩරය හිස් නම් මකන්න

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

මෙම ගොනුව එහි තිබේ නම් ෆෝල්ඩරයද මකන්න

    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)

.srt හෝ .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")

ෆෝල්ඩරයේ ප්‍රමාණය 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")

මම "පිරිසිදු පාත්ලිබ්" ප්‍රවේශයක් එක් කිරීමට කැමතියි:

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

මෙය රඳා Pathපවතින්නේ පිළිවෙලට ඇති කාරණය මත වන අතර දිගු මාර්ග සෑම විටම කෙටි මාර්ග වලින් පසුව වර්ග කරනු ඇත str. එබැවින්, නාමාවලි ලිපිගොනු වලට පෙර පැමිණෙනු ඇත. අපි ආපසු හැරෙව්වොත් වර්ග කිරීම හැරවූයේ නම්, ලිපිගොනු ඒවායේ බහාලුම් ඉදිරිපිටට එනු ඇත, එබැවින් අපට ඒවා එකින් එක පාස් එකකින් ඉවත් කරන්න / rmdir කළ හැකිය.

ප්‍රතිලාභ:

• එය බාහිර ද්විමය මත රඳා නොපවතී: සෑම දෙයක්ම පයිතන්ගේ බැටරි ඇතුළත් මොඩියුල භාවිතා කරයි (පයිතන්> = 3.6)
• එය වේගවත් හා මතක-කාර්යක්ෂම වේ: පුනරාවර්තන තොගයක් නැත, උප ක්‍රියාවලියක් ආරම්භ කිරීම අවශ්‍ය නොවේ
• එය හරස් වේදිකාවකි (අවම වශයෙන්, එයයි pathlib පයිතන් 3.6 හි පොරොන්දු වන්නේ ; වින්ඩෝස් මත ධාවනය නොවන බවට ඉහත කිසිදු මෙහෙයුමක් සඳහන් කර නැත)
• අවශ්‍ය නම්, කෙනෙකුට ඉතා කැටිති ලොග් කිරීමක් කළ හැකිය, උදා: සෑම මකාදැමීමක්ම සිදු වන විට ලොග් කරන්න.

අවුරුදු දහයකට පසුව සහ පයිතන් 3.7 සහ ලිනක්ස් භාවිතා කිරීම සඳහා මෙය කිරීමට තවමත් විවිධ ක්‍රම තිබේ:

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

අත්යවශ්යයෙන්ම එය bash ස්ක්‍රිප්ට් ධාවනය කිරීම සඳහා පයිතන්ගේ උප-ප්‍රොසෙස් මොඩියුලය භාවිතා කරයි $ rm -rf '/path/to/your/dir එකම කාර්යය ඉටු කිරීම සඳහා ඔබ ටර්මිනලය භාවිතා කරනවා සේ භාවිතා කරයි. එය සම්පුර්ණයෙන්ම පයිතන් නොවේ, නමුත් එය සිදු කරයි.

මා pathlib.Pathඋදාහරණය ඇතුළත් කිරීමට හේතුව මගේ අත්දැකීම් අනුව වෙනස් වන බොහෝ මාර්ග සමඟ කටයුතු කිරීමේදී එය ඉතා ප්‍රයෝජනවත් වේ. pathlib.Pathමොඩියුලය ආනයනය කිරීමේ සහ අවසාන ප්‍රති results ල නූල් බවට පරිවර්තනය කිරීමේ අමතර පියවර බොහෝ විට සංවර්ධන කාලය සඳහා මට අඩු පිරිවැයක් දරයි. Path.rmdir()හිස් නොවන ඩර්ස් පැහැදිලිව හැසිරවීමට ආග් විකල්පයක් තිබේ නම් එය පහසු වනු ඇත .

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)

ඔබට shutilමොඩියුලය භාවිතා කිරීමට අවශ්‍ය නැතිනම් ඔබට මොඩියුලය භාවිතා කළ හැකිය 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

ෆෝල්ඩරයක් නොපවතින නමුත් මකා දැමීම ( චාල්ස් චව්ගේ පිළිතුරෙහි ධාවන තත්වය මඟ හැරීම ) නමුත් වෙනත් දේ වැරදී ඇති විට දෝෂ ඇත (උදා: අවසර ගැටළු, තැටි කියවීමේ දෝෂය, ගොනුව නාමාවලියක් නොවේ)

පයිතන් 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)

පයිතන් 2.7 කේතය බොහෝ දුරට සමාන ය:

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)

Os.walk සමඟ එක්-ලයිනර් පයිතන් ඇමතුම් 3 කින් සමන්විත විසඳුම මම යෝජනා කරමි:

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

පළමු ස්ක්‍රිප්ට් chmod හි සියලුම උප ඩිරෙක්ටරි, දෙවන ස්ක්‍රිප්ට් chmod හි සියලුම ගොනු. එවිට තුන්වන පිටපත කිසිදු බාධාවකින් තොරව සියල්ල ඉවත් කරයි.

මම මෙය ජෙන්කින්ස් රැකියාවක "ෂෙල් ස්ක්‍රිප්ට්" වෙතින් පරීක්ෂා කර ඇත්තෙමි (මට නව පයිතන් ස්ක්‍රිප්ට් එකක් SCM තුළට ගබඩා කිරීමට අවශ්‍ය නොවීය, ඒ නිසා එක්-පේළියේ විසඳුමක් සෙව්වේය) එය ලිනක්ස් සහ වින්ඩෝස් සඳහා වැඩ කළේය.

සරල බව සඳහා ඔබට os.system විධානය භාවිතා කළ හැකිය:

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

පැහැදිලිව පෙනෙන පරිදි, මෙම කාර්යය ඉටු කිරීම සඳහා එය ඇත්ත වශයෙන්ම පද්ධති පර්යන්තයට ආයාචනා කරයි.

WINDOWS මෙහෙයුම් පද්ධතියේ ඕනෑම ෆෝල්ඩරයක් (හිස් නොවේ) හෝ ගොනුවක් මකා දැමීමට මම ඉතා පහසු ක්‍රමයක් සොයාගෙන ඇත .

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

වින්ඩෝස් සඳහා, ඩිරෙක්ටරිය හිස් නොවේ නම් සහ ඔබට කියවීමට පමණක් ලිපිගොනු තිබේ නම් හෝ ඔබට දෝෂ ඇතිවේ

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

මේක උත්සාහ කරන්න, os.system('rmdir /S /Q "{}"'.format(directory))

එය rm -rfලිනක්ස් / මැක් සඳහා සමාන වේ .

මගේ නඩුවේදී මකා දැමිය හැකි එකම ක්‍රමය වූයේ සියලු හැකියාවන් භාවිතා කිරීමයි. මන්ද මගේ කේතය cmd.exe හෝ powerhell.exe මඟින් ක්‍රියාත්මක විය යුතු බැවිනි. එය ඔබගේ නඩුව නම්, මෙම කේතය සමඟ ශ්‍රිතයක් සාදන්න, එවිට ඔබ හොඳින් වනු ඇත:

        #!/usr/bin/env python3

        import shutil
        from os import path, system
        import sys

        # Try to delete the folder ---------------------------------------------
        if (path.isdir(folder)):
            shutil.rmtree(folder, ignore_errors=True)

        if (path.isdir(folder)):
            try:
                system("rd -r {0}".format(folder))
            except Exception as e:
                print("WARN: Failed to delete => {0}".format(e),file=sys.stderr)

        if (path.isdir(self.backup_folder_wrk)):
            try:
                system("rd /s /q {0}".format(folder))
            except Exception as e:
                print("WARN: Failed to delete => {0}".format(e),file=sys.stderr)

        if (path.isdir(folder)):
            print("WARN: Failed to delete {0}".format(folder),file=sys.stderr)
        # -------------------------------------------------------------------------------------