¿Cómo puedo crear de forma segura un directorio anidado?

¿Cuál es la forma más elegante de verificar si el directorio en el que se va a escribir un archivo existe y, si no es así, crear el directorio usando Python? Esto es lo que probé:

import os

file_path = "/my/directory/filename.txt"
directory = os.path.dirname(file_path)

try:
    os.stat(directory)
except:
    os.mkdir(directory)       

f = file(filename)

De alguna manera, me perdí os.path.exists (gracias Kanja, Blair y Douglas). Esto es lo que tengo ahora:

def ensure_dir(file_path):
    directory = os.path.dirname(file_path)
    if not os.path.exists(directory):
        os.makedirs(directory)

¿Hay una bandera de "abierto" que haga que esto suceda automáticamente?

preguntado el 07 de noviembre de 08 a las 16:11

En general, es posible que deba tener en cuenta el caso en el que no hay un directorio en el nombre del archivo. En mi máquina dirname ('foo.txt') da '', que no existe y hace que makedirs () falle. -

En Python 2.7 os.path.mkdir no existe. Es os.mkdir. -

si la ruta existe, no solo hay que verificar si es un directorio y no un archivo regular u otro objeto (muchas respuestas verifican esto), también es necesario verificar si se puede escribir (no encontré una respuesta que marcara esto) -

En caso de que haya venido aquí para crear directorios principales de la cadena de ruta del archivo p, aquí está mi fragmento de código: os.makedirs(p[:p.rindex(os.path.sep)], exist_ok=True) -

27 Respuestas

En Python ≥ 3.5, use pathlib.Path.mkdir:

from pathlib import Path
Path("/my/directory").mkdir(parents=True, exist_ok=True)

Para versiones anteriores de Python, veo dos respuestas con buenas cualidades, cada una con un pequeño defecto, así que daré mi opinión:

Trata os.path.exists, y considerar os.makedirs para la creación.

import os
if not os.path.exists(directory):
    os.makedirs(directory)

Como se señaló en los comentarios y en otros lugares, hay una condición de carrera: si el directorio se crea entre los os.path.exists y os.makedirs llamadas, el os.makedirs fallará con un OSError. Desafortunadamente, atrapa la manta OSError y continuar no es infalible, ya que ignorará una falla en la creación del directorio debido a otros factores, como permisos insuficientes, disco lleno, etc.

Una opción sería atrapar el OSError y examine el código de error incrustado (consulte ¿Existe una forma multiplataforma de obtener información del OSError de Python?):

import os, errno

try:
    os.makedirs(directory)
except OSError as e:
    if e.errno != errno.EEXIST:
        raise

Alternativamente, podría haber un segundo os.path.exists, pero supongamos que otro creó el directorio después de la primera verificación y luego lo eliminó antes de la segunda; aún así, podríamos engañarnos.

Según la aplicación, el peligro de las operaciones simultáneas puede ser mayor o menor que el peligro que plantean otros factores, como los permisos de archivos. El desarrollador tendría que saber más sobre la aplicación particular que se está desarrollando y su entorno esperado antes de elegir una implementación.

Las versiones modernas de Python mejoran un poco este código, tanto al exponer FileExistsError (en 3.3 +) ...

try:
    os.makedirs("path/to/directory")
except FileExistsError:
    # directory already exists
    pass

... y permitiendo un argumento de palabra clave para os.makedirs , que son exist_ok (en 3.2+).

os.makedirs("path/to/directory", exist_ok=True)  # succeeds even if directory exists.

Respondido el 30 de diciembre de 19 a las 09:12

La condición de carrera es un buen punto, pero el enfoque en stackoverflow.com/questions/273192/#273208, ocultará un error al crear el directorio. No se sienta mal por votar en contra, no le gusta la respuesta. Para eso están los votos. - Blair Conrado

Recuerde que os.path.exists () no es gratuito. Si el caso normal es que el directorio estará allí, entonces el caso en el que no lo esté debe manejarse como una excepción. En otras palabras, intente abrir y escribir en su archivo, detectar la excepción OSError y, basándose en errno, haga su makedir () y vuelva a intentarlo o vuelva a subir. Esto crea una duplicación de código a menos que envuelva la escritura en un método local. - Andrés

os.path.exists también regresa True para un archivo. He publicado una respuesta para abordar esto. - agudeza

Como han señalado los comentaristas de otras respuestas aquí, el exists_ok parámetro para os.makedirs() se puede usar para cubrir cómo se maneja la existencia previa de la ruta, desde Python 3.2. - Borla

os.mkdirs() puede crear carpetas no deseadas si un separador de ruta se omite accidentalmente, la carpeta actual no es la esperada, un elemento de ruta contiene el separador de ruta. Si utiliza os.mkdir() estos errores generarán una excepción y lo alertarán de su existencia. - drevicko

Python 3.5 +:

import pathlib
pathlib.Path('/my/directory').mkdir(parents=True, exist_ok=True) 

pathlib.Path.mkdir como se usó arriba crea recursivamente el directorio y no genera una excepción si el directorio ya existe. Si no necesita o no desea que se creen los padres, omita el parents argumento.

Python 3.2 +:

Usar pathlib:

Si puede, instale el actual pathlib backport nombrado pathlib2. No instale el puerto posterior no mantenido más antiguo llamado pathlib. A continuación, consulte la sección Python 3.5+ anterior y utilícela de la misma manera.

Si usa Python 3.4, aunque viene con pathlib, falta lo útil exist_ok opción. El backport está destinado a ofrecer una implementación más nueva y superior de mkdir que incluye esta opción que falta.

Usar os:

import os
os.makedirs(path, exist_ok=True)

os.makedirs como se usó arriba crea recursivamente el directorio y no genera una excepción si el directorio ya existe. Tiene el opcional exist_ok argumento solo si se usa Python 3.2+, con un valor predeterminado de False. Este argumento no existe en Python 2.x hasta 2.7. Como tal, no es necesario el manejo manual de excepciones como con Python 2.7.

Python 2.7 +:

Usar pathlib:

Si puede, instale el actual pathlib backport nombrado pathlib2. No instale el puerto posterior no mantenido más antiguo llamado pathlib. A continuación, consulte la sección Python 3.5+ anterior y utilícela de la misma manera.

Usar os:

import os
try: 
    os.makedirs(path)
except OSError:
    if not os.path.isdir(path):
        raise

Si bien una solución ingenua puede usarse primero os.path.isdir seguido por os.makedirs, la solución anterior invierte el orden de las dos operaciones. Al hacerlo, evita una condición de carrera común que tiene que ver con un intento duplicado de crear el directorio y también elimina la ambigüedad de los archivos de los directorios.

Tenga en cuenta que capturar la excepción y usar errno es de utilidad limitada porque OSError: [Errno 17] File exists, Es decir, errno.EEXIST, se genera tanto para archivos como para directorios. Es más confiable simplemente verificar si el directorio existe.

alternativa:

mkpath crea el directorio anidado y no hace nada si el directorio ya existe. Esto funciona tanto en Python 2 como en 3.

import distutils.dir_util
distutils.dir_util.mkpath(path)

Con Error 10948, una limitación severa de esta alternativa es que funciona solo una vez por proceso de Python para una ruta determinada. En otras palabras, si lo usa para crear un directorio, elimine el directorio desde dentro o fuera de Python, luego use mkpath de nuevo para volver a crear el mismo directorio, mkpath simplemente usará silenciosamente su información almacenada en caché no válida de haber creado previamente el directorio, y en realidad no volverá a crear el directorio. A diferencia de, os.makedirs no depende de tal caché. Esta limitación puede estar bien para algunas aplicaciones.


Con respecto a la guía modo, consulte la documentación si le interesa.

contestado el 17 de mayo de 18 a las 18:05

Esta respuesta cubre casi todos los casos especiales hasta donde yo sé. Planeo envolver esto en un "si no os.path.isdir ()", ya que espero que el directorio exista casi siempre y puedo evitar la excepción de esa manera. - Charles L.

@CharlesL. Una excepción es probablemente más barata que la E / S de disco de la verificación, si el motivo es el rendimiento. - jpmc26

@ jpmc26 pero makedirs hace estadísticas adicionales, umask, lstat cuando solo se verifica para lanzar OSError. - kwarunek

Esta es la respuesta incorrecta, ya que introduce una condición potencial de carrera de FS. Vea la respuesta de Aaron Hall. - somnoliento

como ha dicho @sleepycal, esto sufre de una condición de carrera similar a la respuesta aceptada. Si entre la aparición del error y la comprobación os.path.isdir Si alguien más elimina la carpeta, generará el error incorrecto, desactualizado y confuso de que la carpeta existe. - farmear

El uso de try except y el código de error correcto del módulo errno elimina la condición de carrera y es multiplataforma:

import os
import errno

def make_sure_path_exists(path):
    try:
        os.makedirs(path)
    except OSError as exception:
        if exception.errno != errno.EEXIST:
            raise

En otras palabras, intentamos crear los directorios, pero si ya existen ignoramos el error. Por otro lado, se informa cualquier otro error. Por ejemplo, si crea el directorio 'a' de antemano y le quita todos los permisos, obtendrá un OSError criado con errno.EACCES (Permiso denegado, error 13).

Respondido 24 Abr '17, 02:04

La respuesta aceptada es realmente peligrosa porque tiene una condición de carrera. Sin embargo, es más simple, por lo que si no está al tanto de la condición de carrera, o cree que no se aplicará a usted, esa sería su primera elección obvia. - Heikki Toivonen

Planteando la excepción solo cuando exception.errno != errno.EEXIST ignorará involuntariamente el caso cuando la ruta existe pero es un objeto que no es de directorio, como un archivo. Lo ideal es que la excepción se genere si la ruta es un objeto que no es de directorio. - agudeza

Tenga en cuenta que el código anterior es equivalente a os.makedirs(path,exist_ok=True) - Navin

@Navin El exist_ok El parámetro se introdujo en Python 3.2. No está presente en Python 2.x. Lo incorporaré a mi respuesta. - agudeza

@HeikkiToivonen Técnicamente hablando, si otro programa está modificando los directorios y archivos al mismo tiempo que su programa, todo su programa es una condición de carrera gigante. ¿Qué impide que otro programa simplemente elimine este directorio después de que el código lo crea y antes de que usted realmente coloque archivos en él? - jpmc26

Yo personalmente recomendaría que uses os.path.isdir() para probar en lugar de os.path.exists().

>>> os.path.exists('/tmp/dirname')
True
>>> os.path.exists('/tmp/dirname/filename.etc')
True
>>> os.path.isdir('/tmp/dirname/filename.etc')
False
>>> os.path.isdir('/tmp/fakedirname')
False

Si tiene:

>>> dir = raw_input(":: ")

Y una tonta entrada de usuario:

:: /tmp/dirname/filename.etc

... Vas a terminar con un directorio llamado filename.etc cuando pasas ese argumento a os.makedirs() si pruebas con os.path.exists().

contestado el 31 de mayo de 14 a las 15:05

Si usa solo 'isdir', ¿no seguirá teniendo problemas cuando intente crear el directorio y ya exista un archivo con el mismo nombre? - Sr. Maravilloso

@MrWonderful La excepción resultante al crear un directorio sobre un archivo existente reflejaría correctamente el problema al llamador. - Damián Yerrick

Consulta os.makedirs: (Se asegura de que exista la ruta completa).
Para manejar el hecho de que el directorio podría existir, captura OSError. (Si exist_ok is False (el predeterminado), un OSError se genera si el directorio de destino ya existe).

import os
try:
    os.makedirs('./path/to/somewhere')
except OSError:
    pass

contestado el 16 de mayo de 19 a las 13:05

con try / except, enmascarará errores en la creación del directorio, en el caso de que el directorio no existiera pero por alguna razón no pueda hacerlo - Blair Conrado

OSError aparecerá aquí si la ruta es un archivo o directorio existente. He publicado una respuesta para abordar esto. - agudeza

Esto está a mitad de camino. Necesita verificar la condición de sub-error de OSError antes de decidir ignorarlo. Ver stackoverflow.com/a/5032238/763269. - Chris Johnson

A partir de Python 3.5, pathlib.Path.mkdir tiene un exist_ok bandera:

from pathlib import Path
path = Path('/my/directory/filename.txt')
path.parent.mkdir(parents=True, exist_ok=True) 
# path.parent ~ os.path.dirname(path)

Esto crea el directorio de forma recursiva y no genera una excepción si el directorio ya existe.

(Tal como os.makedirs obtuve un exist_ok bandera a partir de Python 3.2, por ejemplo os.makedirs(path, exist_ok=True))


Nota: cuando publiqué esta respuesta, ninguna de las otras respuestas se mencionó exist_ok...

Respondido 28 Oct 20, 06:10

Perspectivas sobre los detalles de esta situación

Le da un archivo en particular en una ruta determinada y extrae el directorio de la ruta del archivo. Luego, después de asegurarse de tener el directorio, intenta abrir un archivo para leerlo. Para comentar este código:

filename = "/my/directory/filename.txt"
dir = os.path.dirname(filename)

Queremos evitar sobrescribir la función incorporada, dir. Además, filepath o quizás fullfilepath es probablemente un mejor nombre semántico que filename así que esto estaría mejor escrito:

import os
filepath = '/my/directory/filename.txt'
directory = os.path.dirname(filepath)

Su objetivo final es abrir este archivo, inicialmente declara, para escribir, pero esencialmente se está acercando a este objetivo (según su código) de esta manera, que abre el archivo para lectura:

if not os.path.exists(directory):
    os.makedirs(directory)
f = file(filename)

Asumiendo apertura para lectura

¿Por qué crearía un directorio para un archivo que espera que esté allí y pueda leer?

Intente abrir el archivo.

with open(filepath) as my_file:
    do_stuff(my_file)

Si el directorio o archivo no está allí, obtendrá un IOError con un número de error asociado: errno.ENOENT apuntará al número de error correcto independientemente de su plataforma. Puedes atraparlo si quieres, por ejemplo:

import errno
try:
    with open(filepath) as my_file:
        do_stuff(my_file)
except IOError as error:
    if error.errno == errno.ENOENT:
        print 'ignoring error because directory or file is not there'
    else:
        raise

Asumiendo que estamos abriendo para escribir

Es probablemente lo que estás queriendo.

En este caso, probablemente no estemos enfrentando condiciones de carrera. Así que haz lo que estabas haciendo, pero ten en cuenta que, para escribir, debes abrir con el w modo (o a para anexar). También es una buena práctica de Python utilizar el administrador de contexto para abrir archivos.

import os
if not os.path.exists(directory):
    os.makedirs(directory)
with open(filepath, 'w') as my_file:
    do_stuff(my_file)

Sin embargo, digamos que tenemos varios procesos de Python que intentan poner todos sus datos en el mismo directorio. Entonces podemos tener una disputa sobre la creación del directorio. En ese caso, es mejor envolver el makedirs llamar en un bloque try-except.

import os
import errno
if not os.path.exists(directory):
    try:
        os.makedirs(directory)
    except OSError as error:
        if error.errno != errno.EEXIST:
            raise
with open(filepath, 'w') as my_file:
    do_stuff(my_file)

Respondido 01 Abr '16, 22:04

Prueba el os.path.exists función

if not os.path.exists(dir):
    os.mkdir(dir)

Respondido 15 Oct 15, 17:10

Iba a comentar la pregunta, pero ¿nos referimos a os.mkdir? Mi python (2.5.2) no tiene os.path.mkdir .... - Blair Conrado

No hay os.path.mkdir() método. os.ruta módulo implementa algunos útiles funciones en nombres de ruta. - sergio s

He escrito lo siguiente. Sin embargo, no es totalmente infalible.

import os

dirname = 'create/me'

try:
    os.makedirs(dirname)
except OSError:
    if os.path.exists(dirname):
        # We are nearly safe
        pass
    else:
        # There was an error on creation, so make sure we know about it
        raise

Ahora, como digo, esto no es realmente infalible, porque tenemos la posibilidad de fallar al crear el directorio, y otro proceso lo crea durante ese período.

contestado el 31 de mayo de 14 a las 15:05

Dos problemas: (1) debe verificar la condición de sub-error de OSError antes de decidir verificar os.path.exists - ver stackoverflow.com/a/5032238/763269, y (2) éxito en os.path.exists no significa que el directorio exista, solo que la ruta existe; podría ser un archivo, un enlace simbólico u otro objeto del sistema de archivos. - Chris Johnson

Compruebe si existe un directorio y créelo si es necesario.

La respuesta directa a esto es, asumiendo una situación simple en la que no espera que otros usuarios o procesos estén jugando con su directorio:

if not os.path.exists(d):
    os.makedirs(d)

or si la creación del directorio está sujeta a condiciones de carrera (es decir, si después de verificar la ruta existe, es posible que alguna otra cosa ya lo haya hecho) haga esto:

import errno
try:
    os.makedirs(d)
except OSError as exception:
    if exception.errno != errno.EEXIST:
        raise

Pero quizás un enfoque aún mejor es eludir el problema de la contención de recursos mediante el uso de directorios temporales a través de tempfile:

import tempfile

d = tempfile.mkdtemp()

Estos son los aspectos esenciales del documento en línea:

mkdtemp(suffix='', prefix='tmp', dir=None)
    User-callable function to create and return a unique temporary
    directory.  The return value is the pathname of the directory.

    The directory is readable, writable, and searchable only by the
    creating user.

    Caller is responsible for deleting the directory when done with it.

Nuevo en Python 3.5: pathlib.Path con exist_ok

Hay una nueva Path objeto (a partir de 3.4) con muchos métodos que uno querría usar con rutas, uno de los cuales es mkdir.

(Para el contexto, estoy rastreando mi representante semanal con un script. Aquí están las partes relevantes del código del script que me permiten evitar presionar Stack Overflow más de una vez al día para los mismos datos).

Primero las importaciones relevantes:

from pathlib import Path
import tempfile

No tenemos que lidiar con os.path.join ahora, simplemente une las partes de la ruta con un /:

directory = Path(tempfile.gettempdir()) / 'sodata'

Luego me aseguro idempotentemente de que el directorio existe: el exist_ok El argumento aparece en Python 3.5:

directory.mkdir(exist_ok=True)

Aquí está la parte relevante del documentación:

If exist_ok es verdad, FileExistsError las excepciones serán ignoradas (el mismo comportamiento que el POSIX mkdir -p comando), pero solo si el último componente de ruta no es un archivo existente que no sea de directorio.

Aquí hay un poco más del script: en mi caso, no estoy sujeto a una condición de carrera, solo tengo un proceso que espera que el directorio (o los archivos contenidos) estén allí y no tengo nada que intentar eliminar. El directorio.

todays_file = directory / str(datetime.datetime.utcnow().date())
if todays_file.exists():
    logger.info("todays_file exists: " + str(todays_file))
    df = pd.read_json(str(todays_file))

Path los objetos tienen que ser coaccionados para str antes que otras API que esperan str los caminos pueden usarlos.

Quizás Pandas debería actualizarse para aceptar instancias de la clase base abstracta, os.PathLike.

Respondido 07 Jul 17, 04:07

En Python 3.4 también puede usar el Para estrenar pathlib módulo:

from pathlib import Path
path = Path("/my/directory/filename.txt")
try:
    if not path.parent.exists():
        path.parent.mkdir(parents=True)
except OSError:
    # handle error; you can also catch specific errors like
    # FileExistsError and so on.

respondido 11 mar '15, 20:03

@JanuszSkonieczny pypi.python.org/pypi/pathlib2 es el backport más nuevo. El más viejo está sin mantenimiento. - agudeza

Como se indica en la primera línea del archivo Léame; P. Pero el antiguo backport sigue siendo válido para la respuesta aquí. Y no hay dolor de cabeza por nombrar. No es necesario explicar por qué y cuándo usar pathlib y donde pathlib2 para los nuevos usuarios, y creo que los profesionales se darán cuenta de la desaprobación;) - Janusz Skonieczny

In Python3, os.makedirs apoya la configuración exist_ok. La configuración predeterminada es False, lo que significa un OSError se generará si el directorio de destino ya existe. Configurando exist_ok a True, OSError (el directorio existe) se ignorará y no se creará el directorio.

os.makedirs(path,exist_ok=True)

In Python2, os.makedirs no es compatible con la configuración exist_ok. Puede utilizar el enfoque en la respuesta de heikki-toivonen:

import os
import errno

def make_sure_path_exists(path):
    try:
        os.makedirs(path)
    except OSError as exception:
        if exception.errno != errno.EEXIST:
            raise

contestado el 23 de mayo de 17 a las 13:05

El sistema documentación de Python relevante sugiere el uso de la Estilo de codificación EAFP (más fácil de pedir perdón que permiso). Esto significa que el código

try:
    os.makedirs(path)
except OSError as exception:
    if exception.errno != errno.EEXIST:
        raise
    else:
        print "\nBE CAREFUL! Directory %s already exists." % path

es mejor que la alternativa

if not os.path.exists(path):
    os.makedirs(path)
else:
    print "\nBE CAREFUL! Directory %s already exists." % path

La documentación sugiere esto exactamente debido a la condición de carrera discutida en esta pregunta. Además, como otros mencionan aquí, existe una ventaja de rendimiento al consultar una vez en lugar de dos veces el sistema operativo. Finalmente, el argumento presentado, potencialmente, a favor del segundo código en algunos casos, cuando el desarrollador conoce el entorno en el que se está ejecutando la aplicación, solo se puede defender en el caso especial de que el programa haya configurado un entorno privado para sí mismo (y otras instancias del mismo programa).

Incluso en ese caso, esta es una mala práctica y puede llevar a una depuración inútil durante mucho tiempo. Por ejemplo, el hecho de que establezcamos los permisos para un directorio no debería dejarnos con los permisos de impresión que se establecieron de manera apropiada para nuestros propósitos. Se puede montar un directorio principal con otros permisos. En general, un programa siempre debería funcionar correctamente y el programador no debería esperar un entorno específico.

Respondido el 31 de diciembre de 17 a las 03:12

Para una solución de una sola línea, puede utilizar IPython.utils.path.ensure_dir_exists():

from IPython.utils.path import ensure_dir_exists
ensure_dir_exists(dir)

Desde el documentación: Asegúrese de que exista un directorio. Si no existe, intente crearlo y protéjase contra una condición de carrera si otro proceso está haciendo lo mismo.

contestado el 16 de mayo de 19 a las 13:05

Nueva documentación de IPython disponible aquí. - jkdev

El sistema IPython no se garantiza en absoluto que el módulo esté presente. Está presente de forma nativa en mi Mac, pero no en ninguna de mis instalaciones de Python en Linux. Básicamente, no es uno de los módulos enumerados en el Índice del módulo de Python. - agudeza

Seguro. Para instalar el paquete, simplemente ejecute el habitual pip install ipython o incluir la dependencia en su requerimientos.txt or pom.xml. Documentación: ipython.org/install.html - tashuka

Puede usar el mkpath

# Create a directory and any missing ancestor directories. 
# If the directory already exists, do nothing.

from distutils.dir_util import mkpath
mkpath("test")    

Tenga en cuenta que también creará los directorios de antepasados.

Funciona para Python 2 y 3.

Respondido el 13 de Septiembre de 16 a las 22:09

distutils.dir_util no es parte de la API pública distutil y tiene problemas en entornos de subprocesos múltiples: bugs.python.org/issue10948 - Vaina

Si. Como se señaló en el primer mensaje del error, el problema con distutils.dir_util.mkpath es que si crea un directorio, luego elimínelo desde dentro o fuera de Python, luego use mkpath de nuevo, mkpath simplemente usará su información almacenada en caché no válida de haber creado previamente el directorio, y en realidad no volverá a crear el directorio. A diferencia de, os.makedirs no depende de tal caché. - agudeza

yo suelo os.path.exists(), aquí es un script de Python 3 que se puede usar para verificar si existe un directorio, crear uno si no existe y eliminarlo si existe (si se desea).

Solicita a los usuarios que ingresen el directorio y se puede modificar fácilmente.

Respondido el 31 de diciembre de 17 a las 03:12

Encontré esta Q / A e inicialmente estaba desconcertado por algunas de las fallas y errores que estaba obteniendo. Estoy trabajando en Python 3 (v.3.5 en un entorno virtual Anaconda en un sistema Arch Linux x86_64).

Considere esta estructura de directorio:

└── output/         ## dir
   ├── corpus       ## file
   ├── corpus2/     ## dir
   └── subdir/      ## dir

Aquí están mis experimentos / notas, que aclaran las cosas:

# ----------------------------------------------------------------------------
# [1] https://stackoverflow.com/questions/273192/how-can-i-create-a-directory-if-it-does-not-exist

import pathlib

""" Notes:
        1.  Include a trailing slash at the end of the directory path
            ("Method 1," below).
        2.  If a subdirectory in your intended path matches an existing file
            with same name, you will get the following error:
            "NotADirectoryError: [Errno 20] Not a directory:" ...
"""
# Uncomment and try each of these "out_dir" paths, singly:

# ----------------------------------------------------------------------------
# METHOD 1:
# Re-running does not overwrite existing directories and files; no errors.

# out_dir = 'output/corpus3'                ## no error but no dir created (missing tailing /)
# out_dir = 'output/corpus3/'               ## works
# out_dir = 'output/corpus3/doc1'           ## no error but no dir created (missing tailing /)
# out_dir = 'output/corpus3/doc1/'          ## works
# out_dir = 'output/corpus3/doc1/doc.txt'   ## no error but no file created (os.makedirs creates dir, not files!  ;-)
# out_dir = 'output/corpus2/tfidf/'         ## fails with "Errno 20" (existing file named "corpus2")
# out_dir = 'output/corpus3/tfidf/'         ## works
# out_dir = 'output/corpus3/a/b/c/d/'       ## works

# [2] https://docs.python.org/3/library/os.html#os.makedirs

# Uncomment these to run "Method 1":

#directory = os.path.dirname(out_dir)
#os.makedirs(directory, mode=0o777, exist_ok=True)

# ----------------------------------------------------------------------------
# METHOD 2:
# Re-running does not overwrite existing directories and files; no errors.

# out_dir = 'output/corpus3'                ## works
# out_dir = 'output/corpus3/'               ## works
# out_dir = 'output/corpus3/doc1'           ## works
# out_dir = 'output/corpus3/doc1/'          ## works
# out_dir = 'output/corpus3/doc1/doc.txt'   ## no error but creates a .../doc.txt./ dir
# out_dir = 'output/corpus2/tfidf/'         ## fails with "Errno 20" (existing file named "corpus2")
# out_dir = 'output/corpus3/tfidf/'         ## works
# out_dir = 'output/corpus3/a/b/c/d/'       ## works

# Uncomment these to run "Method 2":

#import os, errno
#try:
#       os.makedirs(out_dir)
#except OSError as e:
#       if e.errno != errno.EEXIST:
#               raise
# ----------------------------------------------------------------------------

Conclusión: en mi opinión, el "Método 2" es más robusto.

[*] ¿Cómo puedo crear un directorio si no existe?

[*] https://docs.python.org/3/library/os.html#os.makedirs

Respondido el 16 de diciembre de 17 a las 19:12

Utilice este comando comprobar y crear dir

 if not os.path.isdir(test_img_dir):
     os.mkdir(test_img_dir)

contestado el 16 de mayo de 19 a las 20:05

¿Por qué no usar el módulo de subproceso si se ejecuta en una máquina que admite comando mkdir con -p opción ? Funciona en python 2.7 y python 3.6

from subprocess import call
call(['mkdir', '-p', 'path1/path2/path3'])

Debería funcionar en la mayoría de los sistemas.

En situaciones en las que la portabilidad no importa (por ejemplo, con la ventana acoplable), la solución son 2 líneas limpias. Tampoco tiene que agregar lógica para verificar si los directorios existen o no. Finalmente, es seguro volver a ejecutar sin efectos secundarios.

Si necesita manejo de errores:

from subprocess import check_call
try:
    check_call(['mkdir', '-p', 'path1/path2/path3'])
except:
    handle...

contestado el 16 de mayo de 19 a las 20:05

Vi Heikki Toivonen y TEJIDOrespuestas y pensamiento de esta variación.

import os
import errno

def make_sure_path_exists(path):
    try:
        os.makedirs(path)
    except OSError as exception:
        if exception.errno != errno.EEXIST or not os.path.isdir(path):
            raise

Respondido el 31 de diciembre de 17 a las 03:12

Puede usar el os.listdir para esto:

import os
if 'dirName' in os.listdir('parentFolderPath')
    print('Directory Exists')

Respondido el 30 de Septiembre de 17 a las 13:09

Esto no responde a la pregunta: Georgy

Llamar a la función create_dir() en el punto de entrada de su programa / proyecto.

import os

def create_dir(directory):
    if not os.path.exists(directory):
        print('Creating Directory '+directory)
        os.makedirs(directory)

create_dir('Project directory')

Respondido 28 Abr '18, 17:04

Debe establecer la ruta completa antes de crear el directorio:

import os,sys,inspect
import pathlib

currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
your_folder = currentdir + "/" + "your_folder"

if not os.path.exists(your_folder):
   pathlib.Path(your_folder).mkdir(parents=True, exist_ok=True)

Esto funciona para mí y, con suerte, también funcionará para ti.

contestado el 19 de mayo de 19 a las 01:05

Si considera lo siguiente:

os.path.isdir('/tmp/dirname')

significa que existe un directorio (ruta) Y es un directorio. Entonces para mí de esta manera hace lo que necesito. Entonces puedo asegurarme de que sea una carpeta (no un archivo) y que exista.

Respondido el 03 de diciembre de 16 a las 16:12

¿Cómo responde esto a una pregunta de la creación un directorio? - Georgy

import os
if os.path.isfile(filename):
    print "file exists"
else:
    "Your code here"

Donde está su código aquí, use el comando (táctil)

Esto verificará si el archivo está allí, si no lo está, lo creará.

Respondido 06 Jul 17, 00:07

En Linux puede crear un directorio en una línea:

import os
os.system("mkdir -p {0}".format('mydir'))

Respondido el 10 de Septiembre de 20 a las 04:09

Es mejor utilizar métodos independientes del sistema operativo. - unjugador de críquet

Puede crear un archivo y todos sus directorios principales en 1 comando con fastcore extensión a pathlib: path.mk_write(data)

from fastcore.utils import Path
Path('/dir/to/file.txt').mk_write('Hello World')

Respondido 22 Oct 20, 04:10

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.