Python中创建递归路径的高效方法

Question

我需要一个简单的Python函数，用于创建路径，其中父路径可能存在也可能不存在。

根据Python文档，如果其中一个父路径存在，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)

- Mark Ellul

Answer 1

"根据Python文档，如果其中一个父目录存在，则os.makedirs将失败。"

不是的，只有当目录本身已经存在时，os.makedirs才会失败。如果只是任何父目录已经存在，它不会失败。

- sth

---

这两个句子是否相互矛盾？ - AlanS

@AlanSha：是的，它们互相矛盾。这句话引用了问题并包含了一个误解。我的评论旨在纠正这个误解，并解释实际发生的情况。 - sth

Answer 2

这是我的意见，它让系统库来处理所有路径问题。 除了目录已经存在的错误会被传播。

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

- Graham Klyne

---

请注意，在Python 3中，ok.makedirs还接受exists_ok参数，您可以将其设置为True以避免实现此包装器。同时参见https://dev59.com/U3NA5IYBdhLWcg3wfN2O#29508062 - ales_t

Answer 3

Rough draft:

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

- Izz ad-Din Ruhulessin

Answer 4

使用Python ( >=3.4.1 )， os.makedirs 提供了 exist_ok 参数。

如果 exist_ok 为 False (默认值)，则当目标目录已经存在时，会引发 OSError 异常。

因此，如果将其设置为 exist_ok=True，递归创建目录就不会出现问题。

注意：exist_ok 在 Python 3.2 版本及以后提供。然而，在该版本中，即使设置为 True，也存在引发异常的 bug。所以建议使用 Python >= 3.4.1（该版本已修复）。

- Ömer Fadıl Usta

Answer 5

尝试使用此代码，它检查路径是否存在到 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)

- jp922898

Answer 6

这是一个旧帖子，但我对提供的解决方案不满意，因为它们大多数对于简单的任务来说过于复杂。从库中可用的函数中，我认为我们可以做到最干净的方式是：

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

- F Pereira

Answer 7

这段代码将使用递归函数调用生成给定深度和宽度的目录树：

#!/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]))

- Samuel

Answer 8

我在研究如何在项目目录中创建简单的目录树时发现了这个问题。

我对Python还比较新，当数据结构变得太复杂（即嵌套）时，我会遇到困难。为了更容易地跟踪可迭代的小列表，我想出了两个非常基本的def来帮助我创建目录树。

示例需要四个对象来创建目录树：

1. 根目录路径=PROJECT_HOME
2. 主目录路径=home（如果不存在则创建，不覆盖）
3. 目录名称的可迭代对象将位于home内=branches（在home内创建，不覆盖）
4. 将映射到分支的键控迭代器的字典=leaves（在每个映射分支内创建值，不覆盖）

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:  # 如果PROJECT_HOME存在，则在其中创建
           PROJECT_HOME = os.environ['PROJECT_HOME']
       except KeyError:  # 否则在用户主目录中
           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

- dmmfll