Python 3.5+:

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

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

Python 3.2+:

Usando pathlib:

Si puede, instale el backport actual pathlib llamado pathlib2. No instale el backport antiguo sin mantenimiento llamado pathlib. A continuación, consulte el Python 3.5 + sección anterior y usarlo de la misma manera.

Si se usa Python 3.4, aunque viene con pathlib, le falta la útil opción exist_ok. El backport pretende ofrecer una implementación más nueva y superior de mkdir que incluye esta opción faltante.

Usando os:

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

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

Python 2.7+:

Usando pathlib:

Si puede, instale el backport actual pathlib llamado pathlib2. No instale el backport antiguo sin mantenimiento llamado pathlib. A continuación, consulte la sección anterior de Python 3.5+ y utilícela de la misma manera.

Usando os:

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

Mientras que una solución ingenua puede utilizar primero os.path.isdir seguido de 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 desambiguaarchivos de 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 plantea para ambos archivos y Directory. Es más confiable simplemente comprobar 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 y 3.

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

Para Error 10948, una limitación severa de esta alternativa es que solo funciona una vez por proceso python para una ruta dada. 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 recrear el mismo directorio, mkpath simplemente usará silenciosamente su información en caché no válida de haber creado previamente el directorio, y en realidad no volverá a crear el directorio. En contraste, os.makedirs no depende de ninguna caché de este tipo. Esta limitación puede estar bien para algunas aplicaciones.

Con respecto al modo del directorio, consulte la documentación si le importa.

Usando try except y el código de error correcto del módulo errno se deshace de 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, tratamos de crear los directorios, pero si ya existen ignoramos el error. Por otro lado, cualquier otro error se informa. Por ejemplo, si crea el directorio ' a ' de antemano y elimina todos los permisos, obtendrá un OSError generado con errno.EACCES (Permiso denegado, error 13).

Yo personalmente recomendaría que use 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 usted tiene:

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

Y una insensata entrada del usuario:

:: /tmp/dirname/filename.etc

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

Compruebe os.makedirs : (Se asegura de que exista la ruta completa.)
Para manejar el hecho de que el directorio pueda existir, captura OSError. (Si exist_ok es False (el valor predeterminado), se genera un OSError si el directorio de destino ya existe.)

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

Ideas sobre los detalles de esta situación

Se da un archivo en particular en una ruta determinada y se extrae el directorio de la ruta del archivo. Luego, después de asegurarse de que tiene el directorio, intenta abrir un archivo para su lectura. Para comentar este código:

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

Queremos evitar sobrescribir la función builtin, dir. También, filepath o quizás {[9] } es probablemente un mejor nombre semántico que filename así que esto sería mejor escrito:

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

Su fin el objetivo es abrir este archivo, que inicialmente indica, para escribir, pero esencialmente se está acercando a este objetivo (basado en su código) de esta manera, que abre el archivo para leer :

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

Suponiendo apertura para la lectura

¿Por qué crearía un directorio para un archivo que espera estar allí y ser capaz de leer?

Simplemente 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: errno.ENOENT apuntará al número de error correcto independientemente de su plataforma. Puedes cogerlo 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

Suponiendo que estamos abriendo para escribir

Esto es probablemente lo que quieres.

En este caso, probablemente no nos enfrentemos a ninguna condición de carrera. Así que simplemente haz lo que estabas haciendo, pero ten en cuenta que para escribir, necesitas abrir con el modo w (o a para anexar). También es una práctica recomendada de Python usar 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 Python que intentan poner todos sus datos en el mismo directorio. Entonces podemos tener contención sobre la creación del directorio. En ese caso, es mejor envolver la llamada makedirs 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)

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

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 recursivamente el directorio y no genera una excepción si el directorio ya existe.

(al igual que os.makedirs tiene una bandera exists_ok a partir de python 3.2).

Pruebe el os.path.exists función

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

He anotado lo siguiente. Aunque 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 creándolo durante ese período.

Comprobar si existe un directorio y crearlo si es necesario?

La respuesta directa a esto es, asumiendo una situación simple donde no esperas que otros usuarios o procesos estén jugando con tu directorio:

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

O si hacer el directorio está sujeto a condiciones de carrera (es decir, si después de verificar la ruta existe, algo más puede haberlo hecho ya) haga esto:

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

Pero tal vez un enfoque aún mejor es esquivar el problema de contención de recursos, mediante el uso de directorios temporales a través de tempfile:

import tempfile

d = tempfile.mkdtemp()

Aquí están los elementos 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 un nuevo objeto Path (a partir de la versión 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 golpear desbordamiento de pila más de una vez al día para los mismos datos.)

Primero las importaciones pertinentes:

from pathlib import Path
import tempfile

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

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

Entonces me aseguro de que el directorio exista-el argumento exist_ok aparece en Python 3.5:

directory.mkdir(exist_ok=True)

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

Si exist_ok es true, FileExistsError se ignorarán las excepciones (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 intente 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 deben ser coaccionados a str antes de que otras API que esperan str puedan usarlos.

Quizás los Pandas deberían ser actualizado para aceptar instancias de la clase base abstracta, os.PathLike.

En Python 3.4 también puedes usar el nuevo módulo pathlib :

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.

La documentación relevante de Python sugiere el uso del 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 raza discutida en esta pregunta. Además, como otros mencionan aquí, hay una ventaja de rendimiento en 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 abogar 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 establecen apropiadamente para nuestros propósitos. Un directorio padre puede montarse con otros permisos. En general, un programa siempre debe funcionar correctamente y el programador no debe esperar un entorno específico.

Puede utilizar 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 antecesores.

Funciona para Python 2 y 3.

En Python3, os.makedirs soporta la configuración exist_ok. La configuración predeterminada es False, lo que significa que se generará un OSError si el directorio de destino ya existe. Ajustando exist_ok a True, OSError (directory exists) será ignorado y el directorio no será creado.

os.makedirs(path,exist_ok=True)

En Python2, os.makedirs no admite la configuración exist_ok. Puedes usar 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

Para una solución de una sola capa, puede usar IPython.utils.path.ensure_dir_exists():

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

De la documentación : Asegúrese de que existe un directorio. Si no existe, trate de crearlo y protegerse contra una condición de carrera si otro proceso está haciendo lo mismo.

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

Solicita a los usuarios la entrada del directorio y se puede modificar fácilmente.

Encontré este Q/A y al principio estaba desconcertado por algunos de los fracasos y errores que estaba recibiendo. Estoy trabajando en Python 3 (v. 3.5 en un entorno virtual Anaconda en un sistema Arch Linux x86_64).

Considere esta estructura de directorios:

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

Aquí están mis experimentos / notas, que aclara 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.

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

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

Vi Heikki Toivonen y a-B-B's respuestas y el 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

Puedes usar os.listdir para esto:

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

Cuando se trabaja con E / S de archivo, lo importante a considerar es

TOCTTOU (time of check to time of use)

Por lo tanto, hacer una verificación con if y luego leer o escribir más tarde puede terminar en una excepción de E/S no controlada. La mejor manera de hacerlo es:

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

Si considera lo siguiente:

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

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

Utilice este comando check y cree dir

 if not os.path.isdir(test_img_dir):
     os.mkdir(str("./"+test_img_dir))

Llame 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')

¿Por qué no usar el módulo de subproceso si se ejecuta en una máquina que admite lenguajes de shell? Funciona en python 2.7 y python 3.6

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

Debería hacer el truco en la mayoría de los sistemas.

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

Donde está su código aquí use el comando (touch)

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