Façon efficace de créer des chemins récursifs Python

J'ai besoin d'une fonction simple pour créer un chemin d'accès en Python où le parent peut ou peut ne pas exister.

De la documentation python os.makedirs échouera si l'un des parents existe.

J'ai écrit ci-dessous la méthode qui fonctionne en fait comme de nombreux sous-répertoires nécessaires.

Ne ce look efficace?

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)

source d'informationauteur |

48

"À partir de la documentation python os.makedirs échouera si l'un des parents".

Non, os.makedirs échouera si le répertoire existe déjà. Il ne manquera pas, si seulement tout les répertoires parents existe déjà.

Voici mon point de vue, ce qui permet au système de bibliothèques de faire tout le chemin-des querelles. Toutes les erreurs autres que le répertoire déjà existant sont propagées.

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

Brouillon:

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

Essayer ce code, il vérifie si le chemin d'accès n'existe jusqu'à n sous-répertoire de niveau, et de créer un répertoire s'il n'existe pas encore.

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)

2

Avec python ( >=3.4.1 ) il n'y a exist_ok paramètre pour les os.makedirs.

Si exist_ok est False (par défaut), un OSError est déclenchée si la cible
répertoire existe déjà.

Donc si vous l'utilisez comme exist_ok=True il n'y aura aucun problème pour Récursive création de répertoire.

Remarque : exist_ok est livré avec python 3.2 de l'autre côté, il y a eu un bug
sur la possibilité de soulever une exception, même si vous définissez la valeur True. Donc essayez d'utiliser python >=
3.4.1 ( corrigé dans cette version )

J'ai trouvé cette question tout en recherchant un moyen de faire simple répertoire des arbres à l'intérieur d'un répertoire de projet.

Je suis un peu nouveau pour Python, et j'ai de la peine quand structures de données trop complexe, c'est à dire imbriqués. Il est beaucoup plus facile sur mon cerveau mentale de cartographie de garder une trace de petites listes de iterables, alors je suis venu avec deux defs pour m'aider avec le répertoire de création de l'arbre généalogique.

L'exemple de quatre objets pour créer un arbre:

un répertoire racine du chemin d'accès = PROJECT_HOME
un chemin d'accès = home (créée si elle n'existe pas, ils ne sont pas écrasés)
un objet iterable des noms de répertoire qui va aller à l'intérieur de la maison = branches (créé à l'intérieur de la maison, ils ne sont pas écrasés)
un dictionnaire de incrustée iterables que la carte sur les branches = feuilles (chaque valeur créée à l'intérieur de chaque mappé branche, ils ne sont pas écrasés)

Si le répertoire existe, il n'est pas remplacé et l'erreur passe en silence.

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)

L'arborescence du répertoire que cet exemple crée ressemble à ceci:

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

Ce code va générer l'arborescence de répertoire donné, avec de la profondeur et de la largeur, à l'aide de récursive appel de la fonction:

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

1

C'est un vieux thread, mais je n'étais pas satisfait avec les solutions apportées depuis qu'ils étaient pour la plupart trop compliqué pour une simple tâche.

De fonctions disponibles dans la bibliothèque, je crois que le plus propre que nous pouvons faire est:
```
os.path.isdir("mydir") or os.makedirs("mydir")
```

Vous devez vous connecter pour publier un commentaire.