मैं पायथन का उपयोग करके मौजूदा निर्देशिका में फ़ाइलों की एक पूरी निर्देशिका की प्रतिलिपि कैसे बना सकता हूं?

Question

निम्न कोड को एक निर्देशिका से चलाएँ जिसमें एक निर्देशिका नाम bar(एक या अधिक फ़ाइलें हैं) और एक निर्देशिका नाम baz(जिसमें एक या अधिक फ़ाइलें भी हैं)। सुनिश्चित करें कि कोई निर्देशिका नाम नहीं है foo।

import shutil
shutil.copytree('bar', 'foo')
shutil.copytree('baz', 'foo')

इसके साथ असफल होगा:

$ python copytree_test.py 
Traceback (most recent call last):
  File "copytree_test.py", line 5, in <module>
    shutil.copytree('baz', 'foo')
  File "/System/Library/Frameworks/Python.framework/Versions/2.5/lib/python2.5/shutil.py", line 110, in copytree
  File "/System/Library/Frameworks/Python.framework/Versions/2.5/lib/python2.5/os.py", line 172, in makedirs
OSError: [Errno 17] File exists: 'foo'

मैं चाहता हूं कि यह उसी तरह काम करे जैसे मैंने टाइप किया था:

$ mkdir foo
$ cp bar/* foo/
$ cp baz/* foo/

मैं का उपयोग करने की आवश्यकता है shutil.copy()में प्रत्येक फ़ाइल की प्रतिलिपि करने bazमें foo? (के बाद मैं पहले से ही 'बार' की सामग्री को 'फू' के साथ कॉपी कर लेता हूं shutil.copytree()?) या वहाँ एक आसान / बेहतर तरीका है?

Comments

FYI करें: यहाँ मूल कॉपीराईट फ़ंक्शन है, बस इसे कॉपी करें और पैच करें :)

— schlamar

मौजूदा निर्देशिका में लिखने की अनुमति देने के लिए व्यवहार बदलने के बारेshutil.copytree() में एक पायथन मुद्दा है , लेकिन कुछ व्यवहार विवरण हैं जिन पर सहमति बनाने की आवश्यकता है।

— निक चामास

केवल यह देखते हुए कि ऊपर उल्लिखित संवर्द्धन अनुरोध पायथन 3.8 के लिए लागू किया गया है: docs.python.org/3.8/whatsnew/3.8.html#shutil

— ncoghlan

Answer 1

मानक की यह सीमा shutil.copytreeमनमानी और कष्टप्रद लगती है। युक्ति:

import os, shutil
def copytree(src, dst, symlinks=False, ignore=None):
    for item in os.listdir(src):
        s = os.path.join(src, item)
        d = os.path.join(dst, item)
        if os.path.isdir(s):
            shutil.copytree(s, d, symlinks, ignore)
        else:
            shutil.copy2(s, d)

ध्यान दें कि यह पूरी तरह से मानक के अनुरूप नहीं है copytree:

• यह मान symlinksऔर ignoreरूट निर्देशिका के लिए मानदंड नहीं हैsrc पेड़ ;
• यह shutil.Errorमूल स्तर पर त्रुटियों के लिए नहीं उठाता हैsrc ;
• उपप्रकार की प्रतिलिपि बनाने के दौरान त्रुटियों के मामले में, यह shutil.Errorउस उपश्रेणी के बजाय अन्य उपप्रकारों की प्रतिलिपि बनाने और एकल संयुक्त उठाने की कोशिश करेगा shutil.Error।

Comments

धन्यवाद! सहमत हूँ कि यह पूरी तरह से मनमाना लगता है! शुरू में shutil.copytreeकरता है os.makedirs(dst)। कोड के किसी भी हिस्से को वास्तव में पहले से मौजूद डायर की समस्या नहीं होगी। इसे बदलने की जरूरत है। कम से कम exist_ok=Falseकॉल को एक पैरामीटर प्रदान करें

— cfi

यह एक अच्छा जवाब है - हालांकि नीचे मिताल वोरा का जवाब भी देखने लायक है। उन्होंने shutil.copytree () को कॉल करने के बजाए पुनरावर्ती रूप से कॉपीरटरी कहा है क्योंकि वही समस्या अन्यथा उत्पन्न होगी। संभवतः जवाब देने या मितल वोरा को अपडेट करने पर विचार करें।

— PJeffes

यह विफल हो जाता है अगर कोई ऐसा रास्ता दिया जाए जिसमें एक निर्देशिका शामिल हो जो गंतव्य में खाली न हो। हो सकता है कि कोई इसे पूंछ पुनरावृत्ति के साथ हल कर सकता है, लेकिन यहां आपके कोड के लिए एक संशोधन है जो काम करता हैdef copyTree( src, dst, symlinks=False, ignore=None): for item in os.listdir(src): s = os.path.join(src, item) d = os.path.join(dst, item) if os.path.isdir(s): if os.path.isdir(d): self.recursiveCopyTree(s, d, symlinks, ignore) else: shutil.copytree(s, d, symlinks, ignore) else: shutil.copy2(s, d)

— सोजर्न

मेह, अति-कष्टप्रद। यह 4 साल बाद है, और shutil.copytree में अभी भी यह मूर्खतापूर्ण प्रतिबंध है। :-(

— एंटी

@antred ... लेकिन distutils.dir_util.copy_tree(), जो stdlib में भी रहता है, उसके पास ऐसा कोई प्रतिबंध नहीं है और वास्तव में अपेक्षा के अनुरूप व्यवहार करता है। यह देखते हुए, अपने स्वयं के ( ... आमतौर पर टूटे हुए ) कार्यान्वयन को अनियंत्रित करने का प्रयास करने के लिए कोई बाध्यकारी कारण नहीं है । ब्रेंडन एबेल का जवाब अब बिल्कुल स्वीकृत समाधान होना चाहिए।

— सेसिल करी

Answer 2

यहाँ एक समाधान है जो मानक पुस्तकालय का हिस्सा है:

from distutils.dir_util import copy_tree
copy_tree("/a/b/c", "/x/y/z")

इसी तरह का प्रश्न देखें।

अजगर के साथ एक निर्देशिका में निर्देशिका सामग्री की प्रतिलिपि बनाएँ

• संदर्भ - https://docs.python.org/3/distutils/apiref.html#distutils.dir_util.copy_tree

Comments

यह एक अच्छा है क्योंकि यह मानक पुस्तकालय का उपयोग करता है। साइमलिंक, मोड और समय को भी संरक्षित किया जा सकता है।

— इसका जूल

एक छोटा सा नुकसान देखा। distutils.errors.DistutilsInternalError: mkpath: 'name' must be a string, अर्थात यह स्वीकार नहीं करता है PosixPath। की जरूरत है str(PosixPath)। सुधार के लिए इच्छा सूची। इस मामले के अलावा, मैं इस जवाब को पसंद करता हूं।

— सूर्य भालू

@SunBear, हाँ, मुझे लगता है कि अधिकांश अन्य पुस्तकालयों के साथ ऐसा ही होने जा रहा है जो पथ के रूप में पथ लेते हैं। नकारात्मक पक्ष वस्तु पथ के पूर्व कार्यान्वयन के अधिकांश की तरह, मुझे लगता है कि Pathवस्तु से विरासत में नहीं चुनने के लिए नकारात्मक पक्ष का हिस्सा str..

— ब्रेंडन एबेल

Btw, मैं इस समारोह की एक कमी दस्तावेज में आया था। यह यहाँ प्रलेखित है । इस फ़ंक्शन के उपयोगकर्ताओं को इसके बारे में जागरूक होने की सलाह दी गई थी।

— सूर्य भालू

जबकि "तकनीकी रूप से सार्वजनिक", कृपया ध्यान दें कि डिस्टल्यूट के डेवलपर्स ने इसे स्पष्ट कर दिया था (@ SunBear, thx! के रूप में एक ही लिंक) जिसे डिस्टुटिल का distutils.dir_util.copy_tree()कार्यान्वयन विवरण माना जाता है और सार्वजनिक उपयोग के लिए अनुशंसित नहीं है। वास्तविक समाधान को shutil.copytree()बेहतर बनाने के लिए / बढ़ाया जाना चाहिए जैसे कि अधिक व्यवहार करने के लिए distutils.dir_util.copy_tree(), लेकिन इसकी कमियों के बिना। इस बीच, मैं अन्य जवाबों में प्रदान किए गए कुछ के समान कस्टम सहायक कार्यों का उपयोग करता रहूंगा।

— बोरिस डालस्टेन

Answer 3

फ़ंक्शन के लिए एज़्ज़ के उत्तर पर मामूली सुधार में, जहां उपरोक्त फ़ंक्शन हमेशा स्रोत से गंतव्य तक फ़ाइलों को कॉपी करने की कोशिश करता है।

def copytree(src, dst, symlinks=False, ignore=None):
    if not os.path.exists(dst):
        os.makedirs(dst)
    for item in os.listdir(src):
        s = os.path.join(src, item)
        d = os.path.join(dst, item)
        if os.path.isdir(s):
            copytree(s, d, symlinks, ignore)
        else:
            if not os.path.exists(d) or os.stat(s).st_mtime - os.stat(d).st_mtime > 1:
                shutil.copy2(s, d)

मेरे उपरोक्त कार्यान्वयन में

• यदि पहले से मौजूद नहीं है, तो आउटपुट डायरेक्टरी बनाना
• प्रतिलिपि निर्देशिका को पुन: अपने तरीके से कॉल करके करना।
• जब हम वास्तव में फाइल को कॉपी करने के लिए आते हैं, तो मैं जांचता हूं कि क्या फाइल को संशोधित किया गया है, तभी हमें कॉपी करना चाहिए।

मैं उपर्युक्त फ़ंक्शन का उपयोग कर रहा हूं और साथ ही साथ scons build। इसने मुझे हर बार बहुत मदद की जब मैं संकलित करता हूं मुझे फ़ाइलों के पूरे सेट को कॉपी करने की आवश्यकता नहीं हो सकती है .. लेकिन केवल उन फाइलों को संशोधित किया जाता है।

Comments

अच्छा है, सिवाय इसके कि आपके पास सहानुभूति है और तर्क के रूप में उपेक्षा करते हैं, लेकिन उन्हें अनदेखा किया जाता है।

— मैथ्यू अल्परट

यह ध्यान देने योग्य है कि st_mtime ग्रैन्युलैरिटी FAT filesystems docs.python.org/2/library/os.html पर 2 सेकंड के रूप में मोटे हो सकते हैं । इस कोड का उपयोग एक संदर्भ में किया जाता है जहां तेजी से उत्तराधिकार में अपडेट होता है, आप पा सकते हैं कि ओवरराइड नहीं होते हैं।

— dgh

दूसरी-से-अंतिम पंक्ति में एक बग है, होना चाहिए: if not os.path.exists(d) or os.stat(s).st_mtime - os.stat(d).st_mtime > 1:

— एमपीडरबेक

Answer 4

एटज और मिताल वोरा से प्रेरित एक मर्ज:

#!/usr/bin/python
import os
import shutil
import stat
def copytree(src, dst, symlinks = False, ignore = None):
  if not os.path.exists(dst):
    os.makedirs(dst)
    shutil.copystat(src, dst)
  lst = os.listdir(src)
  if ignore:
    excl = ignore(src, lst)
    lst = [x for x in lst if x not in excl]
  for item in lst:
    s = os.path.join(src, item)
    d = os.path.join(dst, item)
    if symlinks and os.path.islink(s):
      if os.path.lexists(d):
        os.remove(d)
      os.symlink(os.readlink(s), d)
      try:
        st = os.lstat(s)
        mode = stat.S_IMODE(st.st_mode)
        os.lchmod(d, mode)
      except:
        pass # lchmod not available
    elif os.path.isdir(s):
      copytree(s, d, symlinks, ignore)
    else:
      shutil.copy2(s, d)

• के रूप में ही व्यवहार shutil.copytree , साथ सिमलिंक और उपेक्षा मानकों
• यदि गैर अस्तित्व में निर्देशिका गंतव्य संरचना बनाएँ
• यदि dst पहले से मौजूद है तो विफल नहीं होगा

Comments

यह मूल समाधान की तुलना में बहुत तेज़ है जब निर्देशिका नेस्टिंग गहरी है। धन्यवाद

— काशिफ

क्या आपने एक फ़ंक्शन को कोड में कहीं और भी अनदेखा किया है?

— KenV99

आप किसी भी फ़ंक्शन को किसी भी नाम से परिभाषित कर सकते हैं जिसे आप कॉपीर्री फ़ंक्शन को कॉल करने से पहले पसंद करते हैं। यह फ़ंक्शन (जो एक लंबोदर अभिव्यक्ति भी हो सकता है) दो तर्क लेता है: एक निर्देशिका नाम और इसमें मौजूद फाइलें, इसे अनदेखा फ़ाइलों की पुनरावृत्ति चाहिए।

— साइरिल पोंटेव्यूएक्स

[x for x in lst if x not in excl]यह कोपिट्री के समान नहीं करता है, जो ग्लोब पैटर्न मिलान का उपयोग करता है। en.wikipedia.org/wiki/Glob_(programming)

— कॉन्स्टेंटिन शुबर्ट

यह भी खूब रही। उपरोक्त उत्तर में उपेक्षा का सही उपयोग नहीं किया जा रहा था।

— कीथ हॉलिडे

Answer 5

अजगर 3.8 शुरू की dirs_exist_okतर्क करने के लिए shutil.copytree:

रिकर्सिवली में निहित एक पूरी निर्देशिका वृक्ष कॉपी src एक नामी निर्देशिका के लिए डीएसटी और गंतव्य निर्देशिका लौट आते हैं। dirs_exist_ok तय है कि क्या इस मामले में एक अपवाद को बढ़ाने के लिए डीएसटी या किसी भी लापता मूल निर्देशिका पहले से मौजूद है।

इसलिए, पायथन 3.8+ के साथ यह काम करना चाहिए:

import shutil

shutil.copytree('bar', 'foo')
shutil.copytree('baz', 'foo', dirs_exist_ok=True)

Comments

dirs_exist_ok=Falseडिफ़ॉल्ट रूप से कोपायट्री में, पहली प्रति का प्रयास विफल नहीं होगा?

— जे

@ जय, केवल अगर निर्देशिका पहले से मौजूद है। मैंने dirs_exist_okअंतर बताने के लिए पहली कॉल छोड़ दी (और क्योंकि निर्देशिका अभी तक ओपी के उदाहरण में मौजूद नहीं है), लेकिन निश्चित रूप से आप चाहें तो इसका उपयोग कर सकते हैं।

— क्रिस

धन्यवाद, यदि आप पहली प्रति के पास एक टिप्पणी जोड़ते हैं, तो मुझे लगता है कि इससे यह स्पष्ट हो जाएगा :)

— जय

Answer 6

डॉक्स स्पष्ट रूप से बताता है कि गंतव्य निर्देशिका मौजूद नहीं होनी चाहिए :

गंतव्य निर्देशिका, जिसका नाम है dst, पहले से मौजूद नहीं होना चाहिए; यह मूल माता-पिता के लापता होने के साथ-साथ बनाया जाएगा।

मुझे लगता है कि आपकी सबसे अच्छी शर्त os.walkदूसरी और सभी परिणामी निर्देशिकाओं, copy2निर्देशिका और फाइलों के लिए है और copystatनिर्देशिकाओं के लिए अतिरिक्त है। आखिरकार copytreeडॉक्स में जैसा बताया गया है वैसा ही है। या आप कर सकते हैं copyऔर copystatप्रत्येक निर्देशिका / फ़ाइल और के os.listdirबजाय os.walk।

Answer 7

यह atzz द्वारा प्रदान किए गए मूल सर्वश्रेष्ठ उत्तर से प्रेरित है, मैंने अभी प्रतिस्थापित फ़ाइल / फ़ोल्डर तर्क जोड़ा है। तो यह वास्तव में विलय नहीं करता है, लेकिन मौजूदा फ़ाइल / फ़ोल्डर को हटा देता है और नए को कॉपी करता है:

import shutil
import os
def copytree(src, dst, symlinks=False, ignore=None):
    for item in os.listdir(src):
        s = os.path.join(src, item)
        d = os.path.join(dst, item)
        if os.path.exists(d):
            try:
                shutil.rmtree(d)
            except Exception as e:
                print e
                os.unlink(d)
        if os.path.isdir(s):
            shutil.copytree(s, d, symlinks, ignore)
        else:
            shutil.copy2(s, d)
    #shutil.rmtree(src)

इसे एक चल समारोह बनाने के लिए rmtree को अनलॉक करें।

Answer 8

यहाँ एक ही कार्य का मेरा संस्करण है ::

import os, glob, shutil

def make_dir(path):
    if not os.path.isdir(path):
        os.mkdir(path)


def copy_dir(source_item, destination_item):
    if os.path.isdir(source_item):
        make_dir(destination_item)
        sub_items = glob.glob(source_item + '/*')
        for sub_item in sub_items:
            copy_dir(sub_item, destination_item + '/' + sub_item.split('/')[-1])
    else:
        shutil.copy(source_item, destination_item)

Answer 9

यहां इस धागे से प्रेरित एक संस्करण है जो अधिक बारीकी से नकल करता है distutils.file_util.copy_file।

updateonlyएक बूल है अगर सही है, केवल dstतब तक संशोधित फ़ाइलों के साथ नई फ़ाइलों forceupdateको कॉपी करेगा जब तक कि सूचीबद्ध फ़ाइलों की परवाह किए बिना कॉपी की जाएगी।

ignoreऔर यूनिक्स शैली वाइल्डकार्ड के समान या उसके सापेक्षforceupdate फाइलनाम या फ़ोल्डर / फ़ाइल नाम की सूची की अपेक्षा करें । srcglobfnmatch

फ़ंक्शन कॉपी की गई फ़ाइलों की सूची देता है (या dryrunयदि सच है तो कॉपी किया जाएगा )।

import os
import shutil
import fnmatch
import stat
import itertools

def copyToDir(src, dst, updateonly=True, symlinks=True, ignore=None, forceupdate=None, dryrun=False):

    def copySymLink(srclink, destlink):
        if os.path.lexists(destlink):
            os.remove(destlink)
        os.symlink(os.readlink(srclink), destlink)
        try:
            st = os.lstat(srclink)
            mode = stat.S_IMODE(st.st_mode)
            os.lchmod(destlink, mode)
        except OSError:
            pass  # lchmod not available
    fc = []
    if not os.path.exists(dst) and not dryrun:
        os.makedirs(dst)
        shutil.copystat(src, dst)
    if ignore is not None:
        ignorepatterns = [os.path.join(src, *x.split('/')) for x in ignore]
    else:
        ignorepatterns = []
    if forceupdate is not None:
        forceupdatepatterns = [os.path.join(src, *x.split('/')) for x in forceupdate]
    else:
        forceupdatepatterns = []
    srclen = len(src)
    for root, dirs, files in os.walk(src):
        fullsrcfiles = [os.path.join(root, x) for x in files]
        t = root[srclen+1:]
        dstroot = os.path.join(dst, t)
        fulldstfiles = [os.path.join(dstroot, x) for x in files]
        excludefiles = list(itertools.chain.from_iterable([fnmatch.filter(fullsrcfiles, pattern) for pattern in ignorepatterns]))
        forceupdatefiles = list(itertools.chain.from_iterable([fnmatch.filter(fullsrcfiles, pattern) for pattern in forceupdatepatterns]))
        for directory in dirs:
            fullsrcdir = os.path.join(src, directory)
            fulldstdir = os.path.join(dstroot, directory)
            if os.path.islink(fullsrcdir):
                if symlinks and dryrun is False:
                    copySymLink(fullsrcdir, fulldstdir)
            else:
                if not os.path.exists(directory) and dryrun is False:
                    os.makedirs(os.path.join(dst, dir))
                    shutil.copystat(src, dst)
        for s,d in zip(fullsrcfiles, fulldstfiles):
            if s not in excludefiles:
                if updateonly:
                    go = False
                    if os.path.isfile(d):
                        srcdate = os.stat(s).st_mtime
                        dstdate = os.stat(d).st_mtime
                        if srcdate > dstdate:
                            go = True
                    else:
                        go = True
                    if s in forceupdatefiles:
                        go = True
                    if go is True:
                        fc.append(d)
                        if not dryrun:
                            if os.path.islink(s) and symlinks is True:
                                copySymLink(s, d)
                            else:
                                shutil.copy2(s, d)
                else:
                    fc.append(d)
                    if not dryrun:
                        if os.path.islink(s) and symlinks is True:
                            copySymLink(s, d)
                        else:
                            shutil.copy2(s, d)
    return fc

Answer 10

पिछले समाधान में कुछ समस्या है जो srcअधिलेखित हो सकती हैdst बिना किसी अधिसूचना या अपवाद के है।

मैं predict_errorकॉपी करने से पहले त्रुटियों की भविष्यवाणी करने के लिए एक विधि जोड़ता हूं । copytreeमुख्य रूप से सिरिल पोंटवीक्स के संस्करण पर आधारित है।

predict_errorपहली बार में सभी त्रुटियों का अनुमान लगाने का उपयोग करना सबसे अच्छा है, जब तक कि आप copytreeसभी त्रुटि को ठीक करने तक एक दूसरे द्वारा उठाए गए अपवाद को देखना पसंद न करें।

def predict_error(src, dst):  
    if os.path.exists(dst):
        src_isdir = os.path.isdir(src)
        dst_isdir = os.path.isdir(dst)
        if src_isdir and dst_isdir:
            pass
        elif src_isdir and not dst_isdir:
            yield {dst:'src is dir but dst is file.'}
        elif not src_isdir and dst_isdir:
            yield {dst:'src is file but dst is dir.'}
        else:
            yield {dst:'already exists a file with same name in dst'}

    if os.path.isdir(src):
        for item in os.listdir(src):
            s = os.path.join(src, item)
            d = os.path.join(dst, item)
            for e in predict_error(s, d):
                yield e


def copytree(src, dst, symlinks=False, ignore=None, overwrite=False):
    '''
    would overwrite if src and dst are both file
    but would not use folder overwrite file, or viceverse
    '''
    if not overwrite:
        errors = list(predict_error(src, dst))
        if errors:
            raise Exception('copy would overwrite some file, error detail:%s' % errors)

    if not os.path.exists(dst):
        os.makedirs(dst)
        shutil.copystat(src, dst)
    lst = os.listdir(src)
    if ignore:
        excl = ignore(src, lst)
        lst = [x for x in lst if x not in excl]
    for item in lst:
        s = os.path.join(src, item)
        d = os.path.join(dst, item)
        if symlinks and os.path.islink(s):
            if os.path.lexists(d):
                os.remove(d)
            os.symlink(os.readlink(s), d)
            try:
                st = os.lstat(s)
                mode = stat.S_IMODE(st.st_mode)
                os.lchmod(d, mode)
            except:
                pass  # lchmod not available
        elif os.path.isdir(s):
            copytree(s, d, symlinks, ignore)
        else:
            if not overwrite:
                if os.path.exists(d):
                    continue
            shutil.copy2(s, d)

Answer 11

यहाँ समस्या पर मेरा पास है। मैंने मूल कार्यक्षमता बनाए रखने के लिए कोपिट्री के लिए स्रोत कोड को संशोधित किया, लेकिन अब कोई त्रुटि तब नहीं होती है जब निर्देशिका पहले से मौजूद है। मैंने इसे भी बदल दिया है इसलिए यह मौजूदा फ़ाइलों को अधिलेखित नहीं करता है, बल्कि दोनों प्रतियों को रखता है, एक संशोधित नाम के साथ, क्योंकि यह मेरे आवेदन के लिए महत्वपूर्ण था।

import shutil
import os


def _copytree(src, dst, symlinks=False, ignore=None):
    """
    This is an improved version of shutil.copytree which allows writing to
    existing folders and does not overwrite existing files but instead appends
    a ~1 to the file name and adds it to the destination path.
    """

    names = os.listdir(src)
    if ignore is not None:
        ignored_names = ignore(src, names)
    else:
        ignored_names = set()

    if not os.path.exists(dst):
        os.makedirs(dst)
        shutil.copystat(src, dst)
    errors = []
    for name in names:
        if name in ignored_names:
            continue
        srcname = os.path.join(src, name)
        dstname = os.path.join(dst, name)
        i = 1
        while os.path.exists(dstname) and not os.path.isdir(dstname):
            parts = name.split('.')
            file_name = ''
            file_extension = parts[-1]
            # make a new file name inserting ~1 between name and extension
            for j in range(len(parts)-1):
                file_name += parts[j]
                if j < len(parts)-2:
                    file_name += '.'
            suffix = file_name + '~' + str(i) + '.' + file_extension
            dstname = os.path.join(dst, suffix)
            i+=1
        try:
            if symlinks and os.path.islink(srcname):
                linkto = os.readlink(srcname)
                os.symlink(linkto, dstname)
            elif os.path.isdir(srcname):
                _copytree(srcname, dstname, symlinks, ignore)
            else:
                shutil.copy2(srcname, dstname)
        except (IOError, os.error) as why:
            errors.append((srcname, dstname, str(why)))
        # catch the Error from the recursive copytree so that we can
        # continue with other files
        except BaseException as err:
            errors.extend(err.args[0])
    try:
        shutil.copystat(src, dst)
    except WindowsError:
        # can't copy file access times on Windows
        pass
    except OSError as why:
        errors.extend((src, dst, str(why)))
    if errors:
        raise BaseException(errors)

Answer 12

इसे इस्तेमाल करे:

import os,shutil

def copydir(src, dst):
  h = os.getcwd()
  src = r"{}".format(src)
  if not os.path.isdir(dst):
     print("\n[!] No Such directory: ["+dst+"] !!!")
     exit(1)

  if not os.path.isdir(src):
     print("\n[!] No Such directory: ["+src+"] !!!")
     exit(1)
  if "\\" in src:
     c = "\\"
     tsrc = src.split("\\")[-1:][0]
  else:
    c = "/"
    tsrc = src.split("/")[-1:][0]

  os.chdir(dst)
  if os.path.isdir(tsrc):
    print("\n[!] The Directory Is already exists !!!")
    exit(1)
  try:
    os.mkdir(tsrc)
  except WindowsError:
    print("\n[!] Error: In[ {} ]\nPlease Check Your Dirctory Path !!!".format(src))
    exit(1)
  os.chdir(h)
  files = []
  for i in os.listdir(src):
    files.append(src+c+i)
  if len(files) > 0:
    for i in files:
        if not os.path.isdir(i):
            shutil.copy2(i, dst+c+tsrc)

  print("\n[*] Done ! :)")

copydir("c:\folder1", "c:\folder2")

Answer 13

यहां एक संस्करण है जो एक pathlib.Pathइनपुट के रूप में अपेक्षा करता है।

# Recusively copies the content of the directory src to the directory dst.
# If dst doesn't exist, it is created, together with all missing parent directories.
# If a file from src already exists in dst, the file in dst is overwritten.
# Files already existing in dst which don't exist in src are preserved.
# Symlinks inside src are copied as symlinks, they are not resolved before copying.
#
def copy_dir(src, dst):
    dst.mkdir(parents=True, exist_ok=True)
    for item in os.listdir(src):
        s = src / item
        d = dst / item
        if s.is_dir():
            copy_dir(s, d)
        else:
            shutil.copy2(str(s), str(d))

ध्यान दें कि इस फ़ंक्शन के लिए Python 3.6 की आवश्यकता होती है, जो कि Python का पहला संस्करण है जहां os.listdir()इनपुट के रूप में पथ जैसी वस्तुओं का समर्थन करता है। आप अजगर के पुराने संस्करणों का समर्थन करने की जरूरत है, तो आप की जगह ले सकता listdir(src)से listdir(str(src))।

Answer 14

मैं सबसे तेज़ और सरल तरीका मानूंगा कि अजगर को सिस्टम कमांड कहा जाएगा ...

उदाहरण..

import os
cmd = '<command line call>'
os.system(cmd)

टार और निर्देशिका को gzip करें .... वांछित स्थान पर निर्देशिका को अनज़िप और अनटार्ट करें।

हाँ?

Comments

अगर आप विंडोज़ में चल रहे हैं ... 7zip डाउनलोड करें .. और उसके लिए कमांड लाइन का उपयोग करें। ... फिर से सिर्फ सुझाव।

— किर्बी

सिस्टम कमांड हमेशा एक अंतिम उपाय होना चाहिए। जब भी संभव हो मानक पुस्तकालय का उपयोग करना हमेशा बेहतर होता है ताकि आपका कोड पोर्टेबल हो।

— १