Jaki jest najbardziej elegancki sposób sprawdzenia, czy katalog plik zostanie zapisany, a jeśli nie, utwórz katalog za pomocą Pythona? Oto, czego próbowałem:

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)

W jakiś sposób tęskniłem za os.path.exists (dzięki Kanja, Blair i Douglas). To jest teraz, co mam:

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

Czy jest flaga dla "otwartych", to sprawia, że to się dzieje automatycznie?

4534
Parand 7 listopad 2008, 21:56

25 odpowiedzi

Najlepsza odpowiedź

Na Pythonie ≥ 3.5, użyj {x0}}:

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

Dla starszych wersji Pythona widzę dwie odpowiedzi z dobrymi cechami, każda z małą wadą, więc oddam moje podejście:

Spróbuj os.path.exists i rozważ os.makedirs dla tworzenia.

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

Jak wspomniano w komentarzach i gdzie indziej, istnieje stan wyścigu - jeśli katalog jest tworzony między os.path.exists a os.makedirs wywołania {x1}} nie powiedzie się z OSError. Niestety, łapanie kocowe OSError i kontynuacja nie jest niezawodna, ponieważ zignoruje błąd w celu utworzenia katalogu z powodu innych czynników, takich jak niewystarczające uprawnienia, pełny dysk itp.

Jedną z opcji byłoby uwięzić OSError i zbadać wbudowany kod błędu (patrz Czy istnieje międzyoponowany sposób uzyskania informacji z Pythona Oserror):

import os, errno

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

Alternatywnie, może być drugi os.path.exists, ale przypuśćmy, że inny utworzył katalog po pierwszym czeku, a następnie usunięto go przed drugim - wciąż mogliśmy zostać oszukani.

W zależności od zastosowania niebezpieczeństwo współbieżnych działalności może być mniej więcej niż niebezpieczeństwo stwarzające inne czynniki, takie jak uprawnienia do plików. Deweloper musiałby dowiedzieć się więcej o konkretnym opracowywaniu aplikacji i jego oczekiwanym środowisku przed wyborem wdrażania.

Nowoczesne wersje Pythona ulepszają ten kod sporo, zarówno przez odsłonięcie

... i dzięki czemu Argument słów kluczowych do os.makedirs Nazywany { {X1}} (w 3,2+).

os.makedirs("path/to/directory", exist_ok=True)  # succeeds even if directory exists.
5628
Boris 30 grudzień 2019, 09:23

Python 3.5+:

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

pathlib.Path.mkdir, jak używany powyżej rekurencyjnie tworzy katalog i nie podnosi wyjątku, jeśli katalog już istnieje. Jeśli nie potrzebujesz ani nie chcesz, aby rodzice zostali stworzyć, pomiń argument parents.

Python 3.2+:

przy użyciu pathlib:

Jeśli możesz, zainstalować bieżący pathlib backport o nazwie pathlib2. Nie instaluj starszego nieodmiotowego baciska o nazwie pathlib. Następnie można znaleźć w powyższej sekcji Python 3.5+ i użyj go tak samo.

Jeśli używasz Python 3.4, nawet jeśli chodzi o pathlib, brakuje przydatnych exist_ok opcji. Bezpieczniki ma zaoferować nowsze i lepsze wdrożenie mkdir, która obejmuje tę brakującą opcję.

przy użyciu os:

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

os.makedirs, jak użyte powyżej rekurencyjnie tworzy katalog i nie Podnieś wyjątek, jeśli katalog już istnieje. Ma opcjonalny argument exist_ok tylko wtedy, gdy używasz Python 3.2+, z domyślną wartością False. Ten argument nie istnieje w Pythonie 2.x do 2,7. W związku z tym nie ma potrzeby obsługi ręcznej obsługi wyjątku jak w przypadku Pythona 2.7.

Python 2.7+:

przy użyciu pathlib:

Jeśli możesz, zainstalować bieżący pathlib backport o nazwie pathlib2. Nie instaluj starszego nieodmiotowego baciska o nazwie pathlib. Następnie można znaleźć w powyższej sekcji Python 3.5+ i użyj go tak samo.

przy użyciu os:

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

Podczas gdy naiwny roztwór może najpierw użyć {x0}}, a następnie {x1}} rozwiązanie powyżej odwraca kolejność dwóch operacji. W ten sposób zapobiega wspólnym stanie wyścigu, który ma związek z powieloną próbą utworzenia katalogu, a także ujednoznażnie pliki z katalogów.

Należy pamiętać, że przechwytywanie wyjątku i przy użyciu errno ma ograniczoną przydatność, ponieważ OSError: [Errno 17] File exists, I.e. errno.EEXIST, jest podniesiony zarówno dla plików, jak i katalogów. Jest bardziej niezawodny, aby sprawdzić, czy istnieje katalog.

Alternatywny:

mkpath tworzy zagnieżdżony katalog i nic Jeśli katalog już istnieje. Działa to zarówno w Pythonie 2, jak i 3.

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

Na Bug 10948, poważne ograniczenie tej alternatywy jest to, że działa tylko raz na proces Python dla danej ścieżki . Innymi słowy, jeśli używasz go do utworzenia katalogu, a następnie usuń katalog od wewnątrz lub poza Python, a następnie ponownie użyj mkpath ponownie, aby odtworzyć ten sam katalog, mkpath po prostu wilnie użyj jego nieprawidłowych buforowanych informacji po wcześniej utworzeniu katalogu i nie zrobi ponownie katalogu ponownie. W przeciwieństwie os.makedirs nie polega na żadnej takiej pamięci podręcznej. To ograniczenie może być w porządku dla niektórych zastosowań.


W odniesieniu do trybu katalogów można znaleźć w dokumentacji, jeśli zależy Ci na nim.

1307
Acumenus 17 maj 2018, 17:16

Używanie próby, z wyjątkiem, a właściwy kod błędu z modułu Errno pozbywa się stanu wyścigowego i jest między platformą:

import os
import errno

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

Innymi słowy, staramy się stworzyć katalogi, ale jeśli już istnieją, zignorujemy błąd. Z drugiej strony, każdy inny błąd zostanie zgłoszony. Na przykład, jeśli wcześniej utworzysz reżysko "A" i usuniesz wszystkie uprawnienia, otrzymasz podniesiony OSError z errno.EACCES (Odmowa pozwolenia, błąd 13).

614
vallentin 24 kwiecień 2017, 01:55

Sprawdź {x0}}: (Upewnia się, że kompletny ścieżka istnieje.)
Aby poradzić sobie z faktem, że katalog może istnieć, złap OSError. (Jeśli exist_ok jest False (domyślnie), podnosi się OSError, jeśli katalog docelowy już istnieje.)

import os
try:
    os.makedirs('./path/to/somewhere')
except OSError:
    pass
85
Georgy 16 maj 2019, 12:15

Począwszy od Python 3.5, pathlib.Path.mkdir ma Flaga 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)

To rekurencyjnie tworzy katalog i nie podnosi wyjątku, jeśli katalog już istnieje.

(Tak jak os.makedirs Flaga exist_ok począwszy od Pythona 3.2, np. os.makedirs(path, exist_ok=True))

83
hiro protagonist 28 październik 2020, 06:13

Spostrzeżenia na temat specyfiki tej sytuacji

Podasz konkretny plik na określonej ścieżce i pociągniesz katalog z ścieżki plików. Następnie po upewnieniu się, że masz katalog, próbujesz otworzyć plik do odczytu. Aby skomentować ten kod:

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

Chcemy unikać nadpisywania wbudowanej funkcji, dir. Również filepath lub być może fullfilepath jest prawdopodobnie lepszą nazwą semantyczną niż filename, więc byłoby to lepiej napisane:

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

Celem końcowym jest otwarcie tego pliku, początkowo stwierdzasz, do pisania, ale zasadniczo zbliżasz się do tego celu (na podstawie twojego kodu), który otwiera plik dla odczytu :

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

Zakładając otwarcie do czytania

Dlaczego mógłbyś zrobić katalog dla pliku, którego spodziewasz się tam i będzie mógł czytać?

Po prostu spróbuj otworzyć plik.

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

Jeśli tam katalog lub plik nie ma, otrzymasz IOError za pomocą powiązanego numeru błędu: errno.ENOENT Wskazuje na prawidłowy numer błędu niezależnie od platformy. Możesz go złapać, jeśli chcesz, na przykład:

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

Zakładając, że otwieramy do pisania

To jest prawdopodobnie , co chcesz.

W tym przypadku prawdopodobnie nie stoimy przed żadnym warunkiem rasy. Więc po prostu robiłeś, ale zauważ, że do pisania należy otworzyć z trybem w (lub {x1}}, aby dołączyć). To także najlepsza praktyka Pythona do korzystania z menedżera kontekstu do otwierania plików.

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

Jednak powiedzmy, że mamy kilka procesów Pythona, które próbują umieścić wszystkie dane do tego samego katalogu. Wtedy możemy mieć trwałość nad stworzeniem katalogu. W takim przypadku najlepiej jest owinąć połączenie makedirs w bloku Wypróbuj.

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)
48
Aaron Hall 1 kwiecień 2016, 21:54

Wypróbuj {{ X0}} Funkcja

if not os.path.exists(dir):
    os.mkdir(dir)
37
jesterjunk 15 październik 2015, 16:05

Umieściłem następujący. Nie jest jednak całkowicie niezawoodporny.

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

Teraz, jak mówię, nie jest to naprawdę niezawodne, ponieważ mamy możliwość powstania katalogu, a inny proces tworzy go w tym okresie.

33
Peter Mortensen 31 maj 2014, 14:05

Sprawdź, czy istnieje katalog i utworzyć go w razie potrzeby?

Bezpośrednia odpowiedź na to jest, zakładając prostą sytuację, w której nie oczekujesz innych użytkowników lub procesów, aby bawić się z katalogiem:

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

lub , jeśli wykonanie katalogu jest podlegać warunkach wyścigu (tj. Jeśli po sprawdzeniu ścieżki istnieje, coś innego mogło go już udało) zrobić:

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

Ale być może jeszcze lepszym podejściem jest Sidestep z powodu problemów z zasobami, przy użyciu katalogów tymczasowych przez tempfile:

import tempfile

d = tempfile.mkdtemp()

Oto niezbędne z dokumentu online:

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.

Nowy w Pythonie 3.5: pathlib.Path za pomocą exist_ok

Jest nowy obiekt Path (od 3,4) z dużą ilością metod chciałby użyć ze ścieżkami - jedną z nich jest mkdir.

(W przypadku kontekstu, śledzę moją cotygodniową republik ze skryptem. Oto odpowiednie części kodu z skryptu, które pozwalają mi uniknąć utwardzania przepełnienia stosu więcej niż raz dziennie dla tych samych danych.)

Najpierw odpowiedni przywóz:

from pathlib import Path
import tempfile

Nie musimy teraz radzić sobie z os.path.join teraz - po prostu dołącz części ścieżki za pomocą /:

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

Następnie Idempotently upewnij się, że katalog istnieje - argument exist_ok pojawia się w Pythonie 3.5:

directory.mkdir(exist_ok=True)

Oto odpowiednia część Dokumentacja:

Jeśli exist_ok jest prawdziwe, wyjątki FileExistsError zostaną zignorowane (takie same zachowanie jak polecenie POSIX mkdir -p), ale tylko wtedy, gdy komponent ostatniej ścieżki nie jest istniejącym plikiem nie-katalogu.

Oto trochę więcej skryptu - w moim przypadku nie podlega kondycji wyścigu, mam tylko jeden proces, który oczekuje, że katalog (lub zawierały pliki), a nie mam nic próbującego usunięcia katalog.

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 Obiekty muszą być przymusowe do str przed innymi interfejsami API, które oczekują str ścieżki.

Być może Pandas należy zaktualizować, aby zaakceptować instancje abstrakcyjnej klasy podstawy, os.PathLike.

25
Aaron Hall 7 lipiec 2017, 03:19

W Pythonie 3.4 można również użyć Brand New pathlib Moduł:

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.
20
Antti Haapala 11 marzec 2015, 20:50

W Python3 , os.makedirs obsługuje ustawienie exist_ok. Ustawienie domyślne to False, co oznacza, że OSError zostanie podniesiony, jeśli katalog docelowy już istnieje. Ustawiając exist_ok do True, OSError, OSError (istnieje katalog) zostanie zignorowany, a katalog nie zostanie utworzony.

os.makedirs(path,exist_ok=True)

W Python2 os.makedirs nie obsługuje ustawienia exist_ok. Możesz użyć podejścia w Odpowiedź Heikki-TOAIDE:

import os
import errno

def make_sure_path_exists(path):
    try:
        os.makedirs(path)
    except OSError as exception:
        if exception.errno != errno.EEXIST:
            raise
15
Community 23 maj 2017, 12:26

Dokumentacja Pythona sugeruje użycie Styl kodowania EAFP (łatwiej poprosić o przebaczenie niż pozwolenie). Oznacza to, że kod

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

Jest lepszy niż alternatywa

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

Dokumentacja sugeruje to dokładnie ze względu na stan wyścigu omówiony w tym pytaniu. Ponadto, jak tu inni wspominają, istnieje przewagę wydajności w zapytaniu raz zamiast dwa razy w systemie operacyjnym. Wreszcie, argument złożony do przodu, potencjalnie, na korzyść drugiego Kodeksu w niektórych przypadkach - kiedy deweloper wie, że środowisko jest uruchomiony - może być opowiadany tylko w szczególnym przypadku, że program utworzył prywatne środowisko sam (i inne instancje tego samego programu).

Nawet w takim przypadku jest to zła praktyka i może prowadzić do długiego debugowania. Na przykład, fakt, że ustawiamy uprawnienia do katalogu, nie powinny opuszczać nas z uprawnieniami wrażenia, są odpowiednio ustawione dla naszych celów. Katalog macierzysty może być zamontowany z innymi uprawnieniami. Ogólnie rzecz biorąc, program powinien zawsze pracować poprawnie, a programista nie powinien oczekiwać jednego konkretnego środowiska.

13
Peter Mortensen 31 grudzień 2017, 03:12

W przypadku rozwiązania jednowarwnego, możesz użyć IPython.utils.path.ensure_dir_exists():

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

Z Dokumentacja : Upewnij się, że istnieje katalog. Jeśli nie istnieje, spróbuj go utworzyć i chronić przed stanem rasy, jeśli inny proces robi to samo.

13
Georgy 16 maj 2019, 12:25

Możesz użyć mkpath

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

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

Zauważ, że również utworzy katalogi przodków.

Działa dla Pythona 2 i 3.

9
Dennis Golomazov 13 wrzesień 2016, 21:44

Używam os.path.exists(), Tutaj jest skryptem Python 3, który można użyć do sprawdzenia, czy istnieje katalog, Utwórz jeden, jeśli nie istnieje i usuń go, jeśli to istnieje (jeśli jest to pożądane).

Prosi użytkowników o wprowadzenie katalogu i można je łatwo modyfikować.

8
Peter Mortensen 31 grudzień 2017, 03:16

Znalazłem to Q / A i byłem początkowo zdziwiony przez niektóre z niepowodzeń i błędów, które dostałem. Pracuję w Pythonie 3 (V.3.5 w środowisku wirtualnym Anaconda na systemie łuku Linux X86_64).

Rozważmy tę strukturę katalogów:

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

Oto moje eksperymenty / notatki, które wyjaśnia rzeczy:

# ----------------------------------------------------------------------------
# [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
# ----------------------------------------------------------------------------

Wniosek: Moim zdaniem "Metoda 2" jest bardziej wytrzymała.

[1] Jak mogę utworzyć katalog, jeśli Nie istnieje?

[2] https://docs.Python.org/3/library/ os.html # os.medirs

7
Victoria Stuart 16 grudzień 2017, 19:26

Użyj tego polecenia Sprawdź i utwórz reż

 if not os.path.isdir(test_img_dir):
     os.mkdir(test_img_dir)
7
Jean-François Fabre 16 maj 2019, 19:07

Dlaczego nie używać modułu podprocess, jeśli działa na maszynie obsługującej polecenie mkdir z opcją -p? Działa na Pythonie 2.7 i Pythonie 3.6

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

Powinien zrobić sztuczkę w większości systemów.

W sytuacjach, w których przenośność nie ma znaczenia (np. Używanie Docker) rozwiązanie jest czyste 2 linie. Nie musisz także dodawać logiki, aby sprawdzić, czy katalogi istnieją, czy nie. Wreszcie, jest bezpieczny, aby ponownie uruchomić bez żadnych skutków ubocznych

Jeśli potrzebujesz obsługi błędów:

from subprocess import check_call
try:
    check_call(['mkdir', '-p', 'path1/path2/path3'])
except:
    handle...
7
Jean-François Fabre 16 maj 2019, 19:37

Widziałem Heikki TOIVONEN i ABB odpowiedzi i pomyślały o tej odmianę.

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
6
Peter Mortensen 31 grudzień 2017, 03:14

Możesz użyć os.listdir dla tego:

import os
if 'dirName' in os.listdir('parentFolderPath')
    print('Directory Exists')
5
dippas 30 wrzesień 2017, 12:31

Zadzwoń do funkcji create_dir() w punkcie wejścia programu / projektu.

import os

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

create_dir('Project directory')
5
Steffi Keran Rani J 28 kwiecień 2018, 16:00

Musisz ustawić pełną ścieżkę przed utworzeniem katalogu:

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)

Działa dla mnie i miejmy nadzieję, że również będzie dla Ciebie

4
Hussam Kurd 19 maj 2019, 00:40
import os
if os.path.isfile(filename):
    print "file exists"
else:
    "Your code here"

Gdzie kod jest tutaj korzystać z polecenia (dotykowego)

Spowoduje to sprawdzenie, czy plik jest tam, jeśli nie jest to wtedy utworzy.

0
Evil Exists 5 lipiec 2017, 23:15

Osobiście polecam użyć os.path.isdir(), aby przetestować zamiast 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

Jeśli masz:

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

I głupie wejście użytkownika:

:: /tmp/dirname/filename.etc

... Zamierzasz skończyć z katalogiem o nazwie filename.etc, gdy przekazujesz ten argument do os.makedirs(), jeśli testujesz z os.path.exists().

109
Peter Mortensen 31 maj 2014, 14:06

Jeśli uważasz:

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

Oznacza, że istnieje katalog (ścieżka) i jest katalogiem. Więc dla mnie w ten sposób, czego potrzebuję. Więc mogę się upewnić, że to folder (nie plik) i istnieje.

3
Ralph Schwerdt 3 grudzień 2016, 16:35