it-swarm-tr.com

Bir dosyanın istisnalar olmadan var olup olmadığını nasıl kontrol ederim?

try deyimini kullanmadan bir dosyanın olup olmadığını nasıl anlarım?

4981
spence91

Kontrol etme sebebiniz if file_exists: open_it() gibi bir şey yapabiliyorsanız, onu açma girişiminde try kullanmak daha güvenlidir. Kontrol etmek ve daha sonra açmak, dosyayı kontrol ettiğinizde ve açmaya çalıştığınız zaman arasında silinmiş veya taşınmış gibi bir risk taşır.

Dosyayı hemen açmayı planlamıyorsanız, os.path.isfile

Yol mevcut bir normal dosya ise True değerini döndür. Bu sembolik bağları izler, böylece hem islink () ve isfile () aynı yol için doğru olabilir.

import os.path
os.path.isfile(fname) 

bir dosya olduğundan emin olmanız gerekiyorsa.

Python 3.4 ile başlayarak, pathlib module , nesne yönelimli bir yaklaşım sunar (Python 2.7'de pathlib2 için desteklenir):

from pathlib import Path

my_file = Path("/path/to/file")
if my_file.is_file():
    # file exists

Bir dizini kontrol etmek için şunları yapın:

if my_file.is_dir():
    # directory exists

Bir Path nesnesinin dosya veya dizin olup olmadığından bağımsız olarak olup olmadığını kontrol etmek için exists() işlevini kullanın:

if my_file.exists():
    # path exists

resolve(strict=True) işlevini try bloğunda da kullanabilirsiniz:

try:
    my_abs_path = my_file.resolve(strict=True)
except FileNotFoundError:
    # doesn't exist
else:
    # exists
4560
rslite

os.path.exists fonksiyonuna sahipsiniz:

import os.path
os.path.exists(file_path)

Bu, hem dosyalar hem de dizinler için True değerini döndürür, ancak bunun yerine kullanabilirsiniz

os.path.isfile(file_path)

Özellikle bir dosya olup olmadığını sınamak için. İzleri takip ediyor.

1913
PierreBdR

isfile() , exists() 'den farklı olarak, dizinler için True değerini döndürür.
Dolayısıyla, yalnızca düz dosyalar veya dizinler istiyorsanız, isfile() veya exists() işlevlerini kullanın. İşte basit bir REPL çıkışı.

>>> print os.path.isfile("/etc/password.txt")
True
>>> print os.path.isfile("/etc")
False
>>> print os.path.isfile("/does/not/exist")
False
>>> print os.path.exists("/etc/password.txt")
True
>>> print os.path.exists("/etc")
True
>>> print os.path.exists("/does/not/exist")
False
885
bortzmeyer
import os.path

if os.path.isfile(filepath):
543
Paul

os.path.isfile() ile/ os.access() ile kullanın:

import os
import os.path

PATH='./file.txt'

if os.path.isfile(PATH) and os.access(PATH, os.R_OK):
    print "File exists and is readable"
else:
    print "Either the file is missing or not readable"
268
Yugal Jindle
import os
os.path.exists(path) # Returns whether the path (directory or file) exists or not
os.path.isfile(path) # Returns whether the file exists or not
248
benefactual

Bir dosyanın olup olmadığını kontrol etmenin en basit yoludur. Sadece çünkü kontrol ettiğinizde mevcut dosya garanti etmiyor açmanız gerektiğinde orada olacak.

import os
fname = "foo.txt"
if os.path.isfile(fname):
    print("file does exist at this time")
else:
    print("no such file exists at this time")
145
un33k

Python 3.4+ nesneye yönelik bir yol modülüne sahiptir: pathlib . Bu yeni modülü kullanarak, bir dosyanın böyle olup olmadığını kontrol edebilirsiniz:

import pathlib
p = pathlib.Path('path/to/file')
if p.is_file():  # or p.is_dir() to see if it is a directory
    # do stuff

Dosyaları açarken (ve genellikle gerekir) hala bir try/except bloğu kullanabilirsiniz:

try:
    with p.open() as f:
        # do awesome stuff
except OSError:
    print('Well darn.')

Pathlib modülünün içinde pek çok harika şey var: uygun iş çıkarma, dosya sahibini kontrol etme, daha kolay yol katılımı, vb. Daha eski bir Python'daysanız (sürüm 2.6 veya üstü), pathlib'i hala pip ile yükleyebilirsiniz:

# installs pathlib2 on older Python versions
# the original third-party module, pathlib, is no longer maintained.
pip install pathlib2

Sonra aşağıdaki gibi alın:

# Older Python versions
import pathlib2 as pathlib
132
Cody Piersall

Try ifadesini tercih edin. Daha iyi bir tarz olarak kabul edilir ve yarış koşullarından kaçınır.

Bunun için benim sözümü alma. Bu teori için bolca destek var. İşte bir çift:

116
pkoch

Python kullanarak bir try ifadesi kullanmadan bir dosyanın olup olmadığını nasıl kontrol ederim?

Şimdi Python 3.4'ten beri mevcut, bir Path nesnesini dosya adıyla içe aktarın ve başlatın ve is_file yöntemini kontrol edin (bunun, normal dosyalara işaret eden sembolik bağlantılar için True döndürdüğünü unutmayın):

>>> from pathlib import Path
>>> Path('/').is_file()
False
>>> Path('/initrd.img').is_file()
True
>>> Path('/doesnotexist').is_file()
False

Python 2'deyseniz, pathlib modülünü pypi, pathlib2 'dan geri alabilirsiniz veya aksi takdirde os.path modülünden isfile adresini kontrol edebilirsiniz:

>>> import os
>>> os.path.isfile('/')
False
>>> os.path.isfile('/initrd.img')
True
>>> os.path.isfile('/doesnotexist')
False

Şimdi yukarıdakiler muhtemelen buradaki en iyi pragmatik doğrudan cevaptır, ancak bir yarış koşulunun (neyi başarmaya çalıştığınıza bağlı olarak) olasılığı vardır ve altta yatan uygulamanın bir try kullanması, ancak Python her yerde try kullanmaktadır. uygulanması.

Python her yerde try öğesini kullandığından, onu kullanan bir uygulamadan kaçınmak için hiçbir neden yoktur.

Ancak bu cevabın geri kalanı bu uyarıları dikkate almaya çalışır.

Daha uzun, çok daha bilgili cevap

Python 3.4'den beri mevcut, yeni Path nesnesini pathlib içinde kullanın. Dizinlerin dosya olmadığından .exists öğesinin doğru olmadığını unutmayın (unix anlamında, her şey bir dosyadır).

>>> from pathlib import Path
>>> root = Path('/')
>>> root.exists()
True

Bu yüzden is_file kullanmamız gerekiyor:

>>> root.is_file()
False

İşte is_file yardımı:

is_file(self)
    Whether this path is a regular file (also True for symlinks pointing
    to regular files).

Öyleyse bildiğimiz bir dosya alalım:

>>> import tempfile
>>> file = tempfile.NamedTemporaryFile()
>>> filepathobj = Path(file.name)
>>> filepathobj.is_file()
True
>>> filepathobj.exists()
True

Varsayılan olarak, NamedTemporaryFile dosyayı kapatıldığında siler (ve daha fazla başvuru olmadığında otomatik olarak kapanır).

>>> del file
>>> filepathobj.exists()
False
>>> filepathobj.is_file()
False

Eğer uygulamalara - girerseniz , yine de is_filetry kullanır:

def is_file(self):
    """
    Whether this path is a regular file (also True for symlinks pointing
    to regular files).
    """
    try:
        return S_ISREG(self.stat().st_mode)
    except OSError as e:
        if e.errno not in (ENOENT, ENOTDIR):
            raise
        # Path doesn't exist or is a broken symlink
        # (see https://bitbucket.org/pitrou/pathlib/issue/12/)
        return False

Yarış Koşulları: Neden denemekten hoşlanıyoruz

try öğesini seviyoruz, çünkü yarış koşullarından kaçınıyor. try ile dosyanızı basitçe orada bulmayı beklemeye çalışırsınız, eğer değilse, istisnayı yakalar ve geri dönüş davranışlarının ne anlama geldiğini gerçekleştirirsiniz.

Bir dosyayı okumaya çalışmadan önce bir dosyanın var olup olmadığını kontrol etmek istiyorsanız ve onu siliyor olabilirsiniz ve daha sonra birden fazla iş parçacığı veya işlemi kullanıyor olabilirsiniz veya başka bir program bu dosyayı biliyor ve siliyor olabilir; a yarış koşulu var olup olmadığını kontrol ederseniz, çünkü yarış, koşulu (varlığı) değişmeden önce onu açarsınız.

Yarış koşullarının hata ayıklaması çok zor çünkü programınızın başarısız olmasına neden olabilecek küçük bir pencere var.

Ancak bu sizin motivasyonunuzsa, try bağlam yöneticisini kullanarak can, suppress ifadesinin değerini alırsınız.

Bir deneme ifadesi olmadan yarış koşullarından kaçınmak: suppress

Python 3.4 bize suppress bağlam yöneticisini (daha önce ignore bağlam yöneticisini) verir, daha az satırda anlamıyla tam olarak aynı şeyi yapar, aynı zamanda (en azından yüzeysel olarak) orijinal bir toplantıyı try Beyan:

from contextlib import suppress
from pathlib import Path

Kullanımı:

>>> with suppress(OSError), Path('doesnotexist').open() as f:
...     for line in f:
...         print(line)
... 
>>>
>>> with suppress(OSError):
...     Path('doesnotexist').unlink()
... 
>>> 

Daha önceki Pythons için kendi suppress'nizi yuvarlayabilirsiniz, ancak try'siz olmadan olduğundan daha ayrıntılı olacaktır. Ben aslında inanıyorum ki, Python 'da herhangi bir düzeyde try işlevini kullanmayan tek cevap, Python 3.4'den önce uygulanabilecek tek cevap, çünkü bunun yerine bir bağlam yöneticisi kullanıyor:

class suppress(object):
    def __init__(self, *exceptions):
        self.exceptions = exceptions
    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_value, traceback):
        if exc_type is not None:
            return issubclass(exc_type, self.exceptions)

Belki bir denemeyle daha kolay:

from contextlib import contextmanager

@contextmanager
def suppress(*exceptions):
    try:
        yield
    except exceptions:
        pass

"Denemeden" isteğini karşılamayan diğer seçenekler:

isfile

import os
os.path.isfile(path)

dokümanlardan :

os.path.isfile(path)

Yol mevcut bir normal dosyaysa True döndür. Bu sembolik bağları izler, böylece hem islink() hem de isfile() aynı yol için doğru olabilir.

Ancak, bu fonksiyonun kaynağını kısmını incelerseniz, gerçekten bir try ifadesi kullandığını görürsünüz:

# This follows symbolic links, so both islink() and isdir() can be true
# for the same path on systems that support symlinks
def isfile(path):
    """Test whether a path is a regular file"""
    try:
        st = os.stat(path)
    except os.error:
        return False
    return stat.S_ISREG(st.st_mode)
>>> OSError is os.error
True

Yaptığı tek şey, üzerinde istatistik olup olmadığını görmek için verilen yolu kullanmak, OSError dosyasını yakalamak ve sonra da istisnayı arttırmadıysa bir dosya olup olmadığını kontrol etmek.

Dosyayla bir şeyler yapmayı düşünüyorsanız, bir yarış koşulundan kaçınmak dışında doğrudan bir denemeyle denemeyi öneririm:

try:
    with open(path) as f:
        f.read()
except OSError:
    pass

os.access

Unix ve Windows için kullanılabilir os.access, ancak kullanmak için bayraklar geçmelisiniz ve dosyalar ve dizinler arasında ayrım yapmaz. Bu, daha fazla gerçek istekte bulunan kullanıcının yüksek bir ayrıcalık ortamında erişim sağlayıp sağlamadığını test etmek için kullanılır:

import os
os.access(path, os.F_OK)

Ayrıca isfile ile aynı yarış durumu sorunlarından muzdarip. dokümanlardan :

Not: Bir kullanıcının örneğin; gerçekte yapmadan önce bir dosyayı açmak, open () kullanmak bir güvenlik açığı oluşturur, çünkü kullanıcı dosyayı kontrol etmek ve açmak için kısa bir süre aralığından yararlanabilir. EAFP tekniklerini kullanmak tercih edilir. Örneğin:

if os.access("myfile", os.R_OK):
    with open("myfile") as fp:
        return fp.read()
return "some default data"

daha iyi olarak yazılmış:

try:
    fp = open("myfile")
except IOError as e:
    if e.errno == errno.EACCES:
        return "some default data"
    # Not a permission error.
    raise
else:
    with fp:
        return fp.read()

os.access kullanmaktan kaçının. Yukarıda açıklanan daha üst seviye objelerden ve fonksiyonlardan daha fazla kullanıcı hatası için fırsat sunan düşük seviyeli bir fonksiyondur.

Başka bir cevabın eleştirisi:

Başka bir cevap, os.access hakkında şunu söylüyor:

Şahsen, bunu tercih ediyorum çünkü başlık altında, yerel API'leri ("$ {PYTHON_SRC_DIR} /Modules/posixmodule.c" üzerinden) çağırıyor, ancak olası kullanıcı hataları için bir kapı açıyor ve diğer değişkenler kadar Pythonic değil :

Bu cevap, Pythonic olmayan, hataya açık bir yöntemi tercih ettiğini, gerekçe göstermediğini söylüyor. Kullanıcıları anlamadan düşük seviye API kullanmaya teşvik ediyor gibi görünüyor.

Ayrıca, koşulsuz olarak True değerini döndürerek tüm İstisnaların (KeyboardInterrupt ve SystemExit!! Dahil) geri dönmesine izin veren ve hataları gizlemenin iyi bir yolu olan bir bağlam yöneticisi oluşturur.

Bu, kullanıcıları kötü uygulamaları benimsemeye teşvik ediyor gibi görünüyor.

110
Aaron Hall
import os
#Your path here e.g. "C:\Program Files\text.txt"
#For access purposes: "C:\\Program Files\\text.txt"
if os.path.exists("C:\..."):   
    print "File found!"
else:
    print "File not found!"

os dosyasını içe aktarma, işletim sisteminizde gezinme ve standart eylemleri gerçekleştirmeyi kolaylaştırır.

Başvuru için ayrıca bkz. Python kullanılarak bir dosyanın var olup olmadığı nasıl kontrol edilir?

Üst düzey işlemlere ihtiyacınız varsa shutil kullanın.

82
bishop

os.path.isfile(), os.path.isdir() ve os.path.exists() olan dosya ve klasörleri test etme

"Yol" un geçerli bir yol olduğunu varsayarak, bu tablo dosya ve klasörler için her bir işlev tarafından döndürülenleri gösterir:

 enter image description here

Bir dosyanın uzantıyı almak için os.path.splitext() işlevini kullanarak belirli bir dosya türü olup olmadığını da sınayabilirsiniz (zaten bilmiyorsanız).

>>> import os
>>> path = "path to a Word document"
>>> os.path.isfile(path)
True
>>> os.path.splitext(path)[1] == ".docx" # test if the extension is .docx
True
75
Tom Fuller

2016'da en iyi yol hala os.path.isfile kullanıyor:

>>> os.path.isfile('/path/to/some/file.txt')

Veya Python 3'te pathlib kullanabilirsiniz:

import pathlib
path = pathlib.Path('/path/to/some/file.txt')
if path.is_file():
    ...
67
KaiBuxe

Deneme/haricinde ve isfile() arasında anlamlı bir işlevsel fark var gibi görünmüyor, bu nedenle hangisini mantıklı kullanmalısınız.

Bir dosyayı okumak istiyorsanız, varsa

try:
    f = open(filepath)
except IOError:
    print 'Oh dear.'

Ancak bir dosyayı varsa yeniden adlandırmak istiyorsanız ve bu nedenle açmanız gerekmiyorsa,

if os.path.isfile(filepath):
    os.rename(filepath, filepath + '.old')

Bir dosyaya yazmak istiyorsanız, yoksa

# python 2
if not os.path.isfile(filepath):
    f = open(filepath, 'w')

# python 3, x opens for exclusive creation, failing if the file already exists
try:
    f = open(filepath, 'wx')
except IOError:
    print 'file already exists'

Dosya kilitlemeye ihtiyacınız varsa, bu farklı bir konu.

62
chad

Bunu deneyebilirsin (daha güvenli):

try:
    # http://effbot.org/zone/python-with-statement.htm
    # 'with' is safer to open a file
    with open('whatever.txt') as fh:
        # Do something with 'fh'
except IOError as e:
    print("({})".format(e))

Çıkış:

([Errno 2] Böyle bir dosya veya dizin yok: 'whatever.txt')

Ardından, sonuca bağlı olarak, programınız oradan çalışmaya devam edebilir veya isterseniz durdurmak için kod yazabilirsiniz.

53
philberndt

Her zaman try ve except deyimlerini kullanmanızı tavsiye etmeme rağmen, işte size bir kaç olasılık (kişisel favorim os.access kullanıyor):

  1. Dosyayı açmayı deneyin:

    Dosyanın açılması her zaman dosyanın varlığını doğrular. Bunun gibi bir işlev yapabilirsiniz:

    def File_Existence(filepath):
        f = open(filepath)
        return True
    

    False ise, Python'un sonraki sürümlerinde değiştirilmemiş bir IOError veya OSError ile yürütmeyi durduracaktır. İstisnayı yakalamak için, fıkra hariç bir deneme kullanmanız gerekir. Elbette, böyle bir ifade dışında daima bir try kullanabilirsiniz. ( hsandt / beni düşündürdüğü için):

    def File_Existence(filepath):
        try:
            f = open(filepath)
        except IOError, OSError: # Note OSError is for later versions of Python
            return False
    
        return True
    
  2. os.path.exists(path) kullanın:

    Bu, belirttiğinizin varlığını kontrol edecektir. Ancak, ve dizinindeki dosyaları kontrol eder, bu yüzden onu nasıl kullandığınıza dikkat edin.

    import os.path
    >>> os.path.exists("this/is/a/directory")
    True
    >>> os.path.exists("this/is/a/file.txt")
    True
    >>> os.path.exists("not/a/directory")
    False
    
  3. os.access(path, mode) kullanın:

    Bu, dosyaya erişiminizin olup olmadığını kontrol edecektir. İzinleri kontrol edecek. Os.py belgelerine dayanarak, os.F_OK yazarak yolun varlığını kontrol eder. Ancak, birileri izinleri kontrol etmek ve dosyayı açmak arasında geçen süreyi kullanarak dosyaya saldırabileceğinden, bu bir güvenlik açığı oluşturacaktır. Bunun yerine, izinlerini kontrol etmek yerine doğrudan dosyayı açmaya gitmelisiniz. ( EAFP vs LBYP ). Daha sonra dosyayı açmayacaksanız ve yalnızca varlığını kontrol ediyorsanız, bunu kullanabilirsiniz.

    Neyse, burada:

    >>> import os
    >>> os.access("/is/a/file.txt", os.F_OK)
    True
    

Ayrıca bir dosyanın varlığını doğrulayamayacağınız iki yol olduğunu da belirtmeliyim. Ya sorun permission denied ya da no such file or directory olacaktır. Bir IOError yakalarsanız, IOError as e (ilk seçeneğim gibi) ayarlayın ve ardından sorununuzu umarım belirleyebilmeniz için print(e.args) yazın. Umut ediyorum bu yardım eder! :)

48
Zizouz212

Tarih: 2017/12/04

Her olası çözüm diğer cevaplarda listelenmiştir.

Bir dosyanın olup olmadığını kontrol etmenin sezgisel ve tartışmalı bir yolu şudur:

import os
os.path.isfile('~/file.md')  # Returns True if exists, else False
# additionaly check a dir
os.path.isdir('~/folder')  # Returns True if the folder exists, else False
# check either a dir or a file
os.path.exists('~/file')

Referansınız için ayrıntılı bir sayfa hazırladım:

#os.path methods in exhaustive cheatsheet
{'definition': ['dirname',
               'basename',
               'abspath',
               'relpath',
               'commonpath',
               'normpath',
               'realpath'],
'operation': ['split', 'splitdrive', 'splitext',
               'join', 'normcase'],
'compare': ['samefile', 'sameopenfile', 'samestat'],
'condition': ['isdir',
              'isfile',
              'exists',
              'lexists'
              'islink',
              'isabs',
              'ismount',],
 'expand': ['expanduser',
            'expandvars'],
 'stat': ['getatime', 'getctime', 'getmtime',
          'getsize']}
42
JawSaw

Ek olarak, os.access():

if os.access("myfile", os.R_OK):
    with open("myfile") as fp:
        return fp.read()

R_OK, W_OK ve X_OK olmak izinleri test etmek için bayrakları ( doc ).

32
zgoda

Dosyanın açılması için aşağıdaki tekniklerden birini kullanabilirsiniz:

>>> with open('somefile', 'xt') as f: #Using the x-flag, Python3.3 and above
...     f.write('Hello\n')

>>> if not os.path.exists('somefile'): 
...     with open('somefile', 'wt') as f:
...         f.write("Hello\n")
... else:
...     print('File already exists!')

GÜNCELLEME

Karışıklığı önlemek ve aldığım cevaplara dayanarak, mevcut cevap verilen adla bir dosya veya bir dizin bulur.

30
bergercookie
if os.path.isfile(path_to_file):
    try: 
        open(path_to_file)
            pass
    except IOError as e:
        print "Unable to open file"

İstisnaları yükseltmek, programınızdaki akış kontrolü için kabul edilebilir ve Pythonic bir yaklaşım olarak kabul edilir. Eksik dosyaları IOErrors ile kullanmayı düşünün. Bu durumda, dosya varsa ancak kullanıcı okuma iznine sahip değilse, bir IOError istisnası ortaya çıkar.

SRC: http://www.pfinn.net/python-check-if-file-exists.html

20
Pedro Lobito

Brian'ın önerisini try: olmadan yazabilirsiniz.

from contextlib import suppress

with suppress(IOError), open('filename'):
    process()

suppress Python 3.4'ün bir parçasıdır. Eski sürümlerde hızlı bir şekilde kendi baskınızı yazabilirsiniz:

from contextlib import contextmanager

@contextmanager
def suppress(*exceptions):
    try:
        yield
    except exceptions:
        pass
17
Chris

NumPy'yi zaten başka amaçlar için içe aktardıysanız, pathlib, os, paths, vb. Gibi diğer kütüphaneleri içe aktarmaya gerek yoktur.

import numpy as np
np.DataSource().exists("path/to/your/file")

Bu, varlığına bağlı olarak doğru veya yanlış olarak dönecektir.

17
durjoy

Dosya veya dizinin var olup olmadığını kontrol edin

Bu üç yolu takip edebilirsiniz:

Not1: Yalnızca dosyalar için kullanılan os.path.isfile

import os.path
os.path.isfile(filename) # True if file exists
os.path.isfile(dirname) # False if directory exists

Not2: Hem dosya hem de dizin için kullanılan os.path.exists

import os.path
os.path.exists(filename) # True if file exists
os.path.exists(dirname) #True if directory exists

pathlib.Path yöntemi (Python 3+ içinde, Python 2 için pip ile yüklenebilir)

from pathlib import Path
Path(filename).exists()
16
Ali Hallaji

Diğer cevaplara tam olarak yansımamış bir tane daha hafif varyasyon eklemek.

Bu file_pathNone veya boş dize olma halini ele alacaktır.

def file_exists(file_path):
    if not file_path:
        return False
    Elif not os.path.isfile(file_path):
        return False
    else:
        return True

Şahbaz’ın önerisine dayanarak bir değişken eklenmesi

def file_exists(file_path):
    if not file_path:
        return False
    else:
        return os.path.isfile(file_path)

Peter Wood'un önerisine dayanarak bir değişken eklemek

def file_exists(file_path):
    return file_path and os.path.isfile(file_path):
15
Marcel Wilson

Yaklaşık 10 senedir var olan bir paketin yazarıyım ve bu soruyu doğrudan ele alan bir işlevi var. Temel olarak, Windows olmayan bir sistemdeyseniz, Popen dosyasına erişmek için find öğesini kullanır. Bununla birlikte, Windows'daysanız, find öğesini verimli bir dosya sistemi yürüteçle çoğaltır.

Kodun kendisi, işletim sisteminin belirlenmesi ve bu nedenle sizi "Unix" tarzı style try ya da hand-buillt find 'e yönlendirmek dışında bir find bloğu kullanmaz. Zamanlama testleri try'nin işletim sistemini belirlemede daha hızlı olduğunu gösterdi, bu yüzden orada bir tane kullandım (ama hiçbir yerde).

>>> import pox
>>> pox.find('*python*', type='file', root=pox.homedir(), recurse=False)
['/Users/mmckerns/.python']

Ve doktor…

>>> print pox.find.__doc__
find(patterns[,root,recurse,type]); Get path to a file or directory

    patterns: name or partial name string of items to search for
    root: path string of top-level directory to search
    recurse: if True, recurse down from root directory
    type: item filter; one of {None, file, dir, link, socket, block, char}
    verbose: if True, be a little verbose about the search

    On some OS, recursion can be specified by recursion depth (an integer).
    patterns can be specified with basic pattern matching. Additionally,
    multiple patterns can be specified by splitting patterns with a ';'
    For example:
        >>> find('pox*', root='..')
        ['/Users/foo/pox/pox', '/Users/foo/pox/scripts/pox_launcher.py']

        >>> find('*shutils*;*init*')
        ['/Users/foo/pox/pox/shutils.py', '/Users/foo/pox/pox/__init__.py']

>>>

Bakmak istiyorsanız uygulama burada: https://github.com/uqfoundation/pox/blob/89f90fb308f285ca7a62eabe2c38acb87e89dad9/pox/shutils.py#L190

15
Mike McKerns

İşte Linux komut satırı ortamı için 1 satır Python komutu. Çok ateşli bir Bash adamı olmadığım için bunu ÇOK KOLAY buluyorum.

python -c "import os.path; print os.path.isfile('/path_to/file.xxx')"

Umarım bu yardımcı olur.

try deyimini kullanmadan bir dosyanın var olup olmadığını nasıl kontrol ederim?

2016'da, bu hala bir dosyanın olup olmadığını ve bir dosya olup olmadığını kontrol etmenin en kolay yolu.

import os
os.path.isfile('./file.txt')    # Returns True if exists, else False

isfile aslında sadece dahili olarak os.stat ve stat.S_ISREG(mode) işlevlerini kullanan yardımcı bir yöntemdir. Bu os.stat, dosyalar, dizinler, yuvalar, arabellekler ve daha fazlası hakkında size ayrıntılı bilgi sağlayacak alt düzey bir yöntemdir. Os.stat hakkında daha fazla burada

Not: Bununla birlikte, bu yaklaşım dosyayı hiçbir şekilde kilitlemeyecektir ve bu nedenle kodunuz "kullanım zamanına göre kontrol süresi" (TOCTTOU) 'e karşı savunmasız hale gelebilir böcek.

Bu nedenle istisnaları artırmak, programınızdaki akış kontrolü için kabul edilebilir ve Pythonic bir yaklaşım olarak kabul edilir. Ve biri eksik dosyaları IOErrors ile ele almayı düşünmeli, if deyimleri yerine (sadece bir tavsiye).

11
Inconnu

Python'un "OS" kütüphanesini kullanabilirsiniz:

>>> import os
>>> os.path.exists("C:\\Users\\####\\Desktop\\test.txt") 
True
>>> os.path.exists("C:\\Users\\####\\Desktop\\test.tx")
False
11
Pradip Das
import os.path

def isReadableFile(file_path, file_name):
    full_path = file_path + "/" + file_name
    try:
        if not os.path.exists(file_path):
            print "File path is invalid."
            return False
        Elif not os.path.isfile(full_path):
            print "File does not exist."
            return False
        Elif not os.access(full_path, os.R_OK):
            print "File cannot be read."
            return False
        else:
            print "File can be read."
            return True
    except IOError as ex:
        print "I/O error({0}): {1}".format(ex.errno, ex.strerror)
    except Error as ex:
        print "Error({0}): {1}".format(ex.errno, ex.strerror)
    return False
#------------------------------------------------------

path = "/usr/khaled/documents/puzzles"
fileName = "puzzle_1.txt"

isReadableFile(path, fileName)
9
Khaled.K

Dosyanın + okunabilir olup olmadığını kontrol etmek için aşağıdaki açık yöntemi kullanabilirsiniz:

open(inputFile, 'r')
9
user3197473
import os
path = /path/to/dir

root,dirs,files = os.walk(path).next()
if myfile in files:
   print "yes it exists"

Birkaç dosyayı kontrol ederken bu yardımcı olur. Ya da mevcut bir listeyle bir küme kesişme/çıkarma yapmak istiyorsunuz.

8
Jesvin Jose

Bir dosyanın olup olmadığını kontrol etmek için,

from sys import argv

from os.path import exists
script, filename = argv
target = open(filename)
print "file exists: %r" % exists(filename)
7
Hanson

Bir dosyanın belirli bir dizinde olup olmadığını kontrol etmek için os.listdir komutunu kullanabilirsiniz.

import os
if 'file.ext' in os.listdir('dirpath'):
    #code
5
iPhynx
import os

# for testing purpose args defaulted to current folder & file. 
# returns True if file found
def file_exists(FOLDER_PATH='../', FILE_NAME=__file__):
    return os.path.isdir(FOLDER_PATH) \
        and os.path.isfile(os.path.join(FOLDER_PATH, FILE_NAME))

Temelde bir klasör kontrolü, ardından os.path.join kullanarak uygun dizin ayırıcılı bir dosya kontrolü.

4

Bunu kesinlikle kullanmalısın.

from os.path import exists

if exists("file") == True:
    print "File exists."
Elif exists("file") == False:
    print "File doesn't exist."
3
user2154354

Muhtemelen gerekli değildir, ancak öyleyse, işte bazı kod

import os

def file_exists(path, filename):
    for file_or_folder in os.listdir(path):
        if file_or_folder == filename:
            return True
    return False