रिकर्सिव पथ बनाने का कुशल तरीका पायथन

Question

मुझे पाइथन में पथ बनाने के लिए एक साधारण फ़ंक्शन की आवश्यकता है जहां माता-पिता मौजूद हो या न हो।

पायथन दस्तावेज से os.makedirs विफल हो जाएंगे यदि माता-पिता में से कोई एक मौजूद है।

मैंने नीचे दी गई विधि लिखी है जैसा कि आवश्यकतानुसार कई उप निर्देशिका बनाता है।

क्या यह कुशल दिखता है?

def create_path(path): 
    import os.path as os_path 
    paths_to_create = [] 
    while not os_path.lexists(path): 
     paths_to_create.insert(0, path) 
     head,tail = os_path.split(path) 
     if len(tail.strip())==0: # Just incase path ends with a/or \ 
      path = head 
      head,tail = os_path.split(path) 
     path = head 

    for path in paths_to_create: 
     os.mkdir(path) 

Answer 1

"अजगर प्रलेखन os.makedirs से असफल हो जायेगी अगर माता-पिता में से एक से मौजूद है।"

नहीं, os.makedirs विफल हो जाएगा यदि निर्देशिका पहले से मौजूद है। अगर कोई भी मूल निर्देशिका पहले से मौजूद है तो यह असफल नहीं होगा।

Answer 2

रफ ड्राफ्ट:

import os 


class Path(str): 
    """ 
    A helper class that allows easy contactenation 
    of path components, creation of directory trees, 
    amongst other things. 
    """ 
    @property 
    def isdir(self): 
     return os.path.isdir(self) 

    @property 
    def isfile(self): 
     return os.path.isfile(self) 

    def exists(self): 
     exists = False 
     if self.isfile: 
      try: 
       f = open(self) 
       f.close() 
       exists = True 
      except IOError: 
       exists = False 
     else: 
      return self.isdir 
     return exists 

    def mktree(self, dirname): 
     """Create a directory tree in this directory.""" 
     newdir = self + dirname 
     if newdir.exists(): 
      return newdir 
     path = dirname.split('/') or [dirname] 
     current_path = self + path.pop(0) 
     while True: 
      try: 
       os.mkdir(current_path) 
      except OSError as e: 
       if not e.args[0] == 17: 
        raise e 
       current_path = current_path + path.pop(0) 
       continue 
      if len(path) == 0: 
       break 
     return current_path 

    def up(self): 
     """ 
     Return a new Path object set a the parent 
     directory of the current instance. 
     """ 
     return Path('/'.join(self.split('/')[:-1])) 

    def __repr__(self): 
     return "<Path: {0}>".format(self) 

    def __add__(x, y): 
     return Path(x.rstrip('/') + '/' + y.lstrip('/')) 

Answer 3

इस कोड का प्रयास करें, यह जाँच करता है, तो पथ n उप निर्देशिका स्तर तक मौजूद है, और नहीं मौजूद है, तो निर्देशिका बनाने।

def pathtodir(path): 
if not os.path.exists(path): 
    l=[] 
    p = "/" 
    l = path.split("/") 
    i = 1 
    while i < len(l): 
     p = p + l[i] + "/" 
     i = i + 1 
     if not os.path.exists(p): 
      os.mkdir(p, 0755) 

Answer 4

यहाँ मेरी ले, जो की सुविधा देता है प्रणाली पुस्तकालयों सभी पथ-खींचतान करते हैं। पहले से मौजूद निर्देशिका के अलावा किसी भी त्रुटि का प्रचार किया जाता है।

import os, errno 

def ensure_dir(dirname): 
    """ 
    Ensure that a named directory exists; if it does not, attempt to create it. 
    """ 
    try: 
     os.makedirs(dirname) 
    except OSError, e: 
     if e.errno != errno.EEXIST: 
      raise 

Answer 5

मुझे एक परियोजना निर्देशिका के अंदर सरल निर्देशिका पेड़ बनाने के लिए एक तरीका शोध करते समय यह प्रश्न मिला।

मैं पाइथन के लिए कुछ नया हूं, और जब मैं डेटा संरचनाएं बहुत जटिल हो जाता हूं, तो मैं संघर्ष करता हूं, यानी घोंसला। मेरे मस्तिष्क के मानसिक मैपिंग पर पुनरावृत्तियों की छोटी सूचियों का ट्रैक रखने के लिए यह बहुत आसान है, इसलिए मैं निर्देशिका पेड़ निर्माण के साथ मेरी सहायता करने के लिए दो बहुत ही बुनियादी defs के साथ आया था।

1. एक रूट निर्देशिका पथ = PROJECT_HOME
2. एक घर पथ = घर (बनाया अगर यह मौजूद नहीं है, ओवरराइट नहीं)
3. एक:

   उदाहरण एक पेड़ बनाने के लिए चार वस्तुओं लेता है निर्देशिका नामों के पुन: प्रयोज्य जो घर के अंदर बनाए गए हैं (घर के अंदर बनाए गए हैं, ओवरराइट नहीं किए गए हैं)

4. कुंजीपटल तीरंदाजी का एक शब्दकोश जो शाखाओं = पत्तियों पर नक्शा करता है (प्रत्येक मैप किए गए शाखा के अंदर बनाए गए प्रत्येक मान को ओवरराइट नहीं किया जाता है)

5. यदि कोई निर्देशिका मौजूद है, तो यह अधिलेखित नहीं है और त्रुटि चुपचाप गुजरती है।

   import os 
   from os.path import join as path_join 
   import errno 
   
   def make_node(node): 
       try: 
        os.makedirs(node) 
       except OSError, e: 
        if e.errno != errno.EEXIST: 
         raise 
   
   
   def create_tree(home, branches, leaves): 
       for branch in branches: 
        parent = path_join(home, branch) 
        make_node(parent) 
        children = leaves.get(branch, []) 
        for child in children: 
         child = os.path.join(parent, child) 
         make_node(child) 
   
   if __name__ == "__main__": 
       try: # create inside of PROJECT_HOME if it exists 
        PROJECT_HOME = os.environ['PROJECT_HOME'] 
       except KeyError: # otherwise in user's home directory 
        PROJECT_HOME = os.expanduser('~') 
   
       home = os.path.join(PROJECT_HOME, 'test_directory_tree') 
       create_tree(home, branches=[], leaves={}) 
   
       branches = (
        'docs', 
        'scripts', 
       ) 
       leaves = (
        ('rst', 'html',), 
        ('python', 'bash',) 
       ) 
       leaves = dict(list(zip(branches, leaves))) 
       create_tree(home, branches, leaves) 
   
       python_home = os.path.join(home, 'scripts', 'python') 
       branches = (
        'os', 
        'sys', 
        'text_processing', 
       ) 
       leaves = {} 
       leaves = dict(list(zip(branches, leaves))) 
       create_tree(python_home, branches, leaves) 
   
       after_thought_home = os.path.join(home, 'docs', 'after_thought') 
       branches = (
        'child_0', 
        'child_1', 
       ) 
       leaves = (
        ('sub_0', 'sub_1'), 
        (), 
       ) 
       leaves = dict(list(zip(branches, leaves))) 
       create_tree(after_thought_home, branches, leaves) 
   

निर्देशिका वृक्ष कि इस उदाहरण इस तरह दिखता है बनाता है:

dev/test_directory_tree/ 
    ├── docs 
    │   ├── after_thought 
    │   │   ├── child_0 
    │   │   │   ├── sub_0 
    │   │   │   └── sub_1 
    │   │   └── child_1 
    │   ├── html 
    │   └── rst 
    └── scripts 
     ├── bash 
     └── python 
      ├── os 
      ├── sys 
      └── text_processing 

Answer 6

अजगर के साथ

(> = 3.4.1) वहाँ os.makedirs के लिए exist_ok पैरामीटर है।

यदि मौजूद है_क गलत है (डिफ़ॉल्ट), तो लक्ष्य निर्देशिका पहले से मौजूद है तो एक ओएसईआरआरआर उठाया जाता है।

तो अगर आप exist_ok तरह का उपयोग = सच वहाँ नहीं रिकर्सिव निर्देशिका निर्माण के लिए किसी भी समस्या के लिए किया जाएगा।

नोट: exist_ok दूसरी ओर अजगर 3.2 के साथ आता है वहाँ एक बग अपवाद भले ही आप सही पर सेट बढ़ाने के बारे में था। तो अजगर का उपयोग करके देखें> = 3.4.1 (कि संस्करण में ठीक)

Answer 7

This code, यह देखते हुए गहराई और चौड़ाई के साथ निर्देशिका वृक्ष उत्पन्न पुनरावर्ती क्रिया कॉल का उपयोग कर देगा:

#!/usr/bin/python2.6 

import sys 
import os 

def build_dir_tree(base, depth, width): 
    print("Call #%d" % depth) 
    if depth >= 0: 
     curr_depth = depth 
     depth -= 1 
     for i in xrange(width): 
       # first creating all folder at current depth 
       os.makedirs('%s/Dir_#%d_level_%d' % (base, i, curr_depth)) 
     dirs = os.walk(base).next()[1] 
     for dir in dirs: 
       newbase = os.path.join(base,dir) 
       build_dir_tree(newbase, depth, width) 
    else: 
     return 

if not sys.argv[1:]: 
     print('No base path given') 
     sys.exit(1) 

print('path: %s, depth: %d, width: %d' % (sys.argv[1], int(sys.argv[2]), int(sys.argv[3]))) 
build_dir_tree(sys.argv[1], int(sys.argv[2]), int(sys.argv[3])) 

Answer 8

यह एक पुरानी धागा है , लेकिन मैं प्रदान किए गए समाधान से संतुष्ट नहीं था क्योंकि वे एक साधारण कार्य के लिए अधिक जटिल थे।

पुस्तकालय में उपलब्ध कार्यों से मेरा मानना ​​है कि साफ हम क्या कर सकते हैं:

os.path.isdir("mydir") or os.makedirs("mydir")