Python 3.7

pathlib - ऑब्जेक्ट-ओरिएंटेड फ़ाइल सिस्टम पथ




python

pathlib - ऑब्जेक्ट-ओरिएंटेड फ़ाइल सिस्टम पथ

संस्करण 3.4 में नया।

स्रोत कोड: Lib/pathlib.py

यह मॉड्यूल विभिन्न ऑपरेटिंग सिस्टम के लिए उपयुक्त शब्दार्थ के साथ फाइलसिस्टम रास्तों का प्रतिनिधित्व करने वाली कक्षाएं प्रदान करता है। पथ वर्गों को शुद्ध पथों के बीच विभाजित किया जाता है, जो I / O के बिना विशुद्ध रूप से कम्प्यूटेशनल संचालन प्रदान करते हैं, और कंक्रीट पथ , जो शुद्ध पथों से विरासत में मिलते हैं, लेकिन I / O संचालन भी प्रदान करते हैं।

../_images/pathlib-inheritance.png

यदि आपने पहले कभी भी इस मॉड्यूल का उपयोग नहीं किया है या यह सुनिश्चित नहीं किया है कि कौन सा वर्ग आपके कार्य के लिए सही है, तो Path की सबसे अधिक संभावना है कि आपको क्या चाहिए। यह जिस प्लेटफ़ॉर्म पर चल रहा है, उसके लिए यह एक ठोस रास्ता है।

कुछ विशेष मामलों में शुद्ध मार्ग उपयोगी होते हैं; उदाहरण के लिए:

  1. यदि आप एक यूनिक्स मशीन (या इसके विपरीत) पर विंडोज पथ में हेरफेर करना चाहते हैं। जब आप यूनिक्स पर चल रहे हों, तो आप WindowsPath PureWindowsPath नहीं कर सकते हैं, लेकिन आप PureWindowsPath कर सकते हैं।
  2. आप यह सुनिश्चित करना चाहते हैं कि आपका कोड केवल ओएस को एक्सेस किए बिना ही रास्तों में फेरबदल करे। इस मामले में, शुद्ध वर्गों में से एक को तत्काल उपयोगी हो सकता है क्योंकि उन पर बस कोई ओएस-एक्सेसिंग ऑपरेशन नहीं होता है।

यह भी देखें

PEP 428 : पाथलिब मॉड्यूल - ऑब्जेक्ट-ओरिएंटेड फाइलसिस्टम पथ।

यह भी देखें

स्ट्रिंग्स पर निम्न-स्तरीय पथ हेरफेर के लिए, आप os.path मॉड्यूल का उपयोग भी कर सकते हैं।

मूल उपयोग

मुख्य वर्ग का आयात:

>>> from pathlib import Path

लिस्टिंग उपनिर्देशिका:

>>> p = Path('.')
>>> [x for x in p.iterdir() if x.is_dir()]
[PosixPath('.hg'), PosixPath('docs'), PosixPath('dist'),
 PosixPath('__pycache__'), PosixPath('build')]

इस निर्देशिका ट्री में पायथन सोर्स फाइल्स को सूचीबद्ध करना:

>>> list(p.glob('**/*.py'))
[PosixPath('test_pathlib.py'), PosixPath('setup.py'),
 PosixPath('pathlib.py'), PosixPath('docs/conf.py'),
 PosixPath('build/lib/pathlib.py')]

एक निर्देशिका ट्री के अंदर नेविगेट करना:

>>> p = Path('/etc')
>>> q = p / 'init.d' / 'reboot'
>>> q
PosixPath('/etc/init.d/reboot')
>>> q.resolve()
PosixPath('/etc/rc.d/init.d/halt')

पथ गुणों को छोड़ना:

>>> q.exists()
True
>>> q.is_dir()
False

एक फ़ाइल खोलना:

>>> with q.open() as f: f.readline()
...
'#!/bin/bash\n'

शुद्ध मार्ग

शुद्ध पथ ऑब्जेक्ट पथ हैंडलिंग संचालन प्रदान करते हैं जो वास्तव में एक फाइल सिस्टम तक नहीं पहुंचते हैं। इन वर्गों तक पहुँचने के तीन तरीके हैं, जिन्हें हम फ्लेवर भी कहते हैं :

class pathlib.PurePath(*pathsegments)

एक सामान्य वर्ग जो सिस्टम के पथ स्वाद का प्रतिनिधित्व करता है (इसे तत्काल या तो PurePosixPath या PurePosixPath बनाता है):

>>> PurePath('setup.py')      # Running on a Unix machine
PurePosixPath('setup.py')

रास्तों के प्रत्येक तत्व या तो एक स्ट्रिंग हो सकते हैं जो पथ खंड का प्रतिनिधित्व करते हैं, एक ऑब्जेक्ट जो os.PathLike इंटरफ़ेस को लागू करता है जो एक स्ट्रिंग, या एक अन्य पथ वस्तु लौटाता है:

>>> PurePath('foo', 'some/path', 'bar')
PurePosixPath('foo/some/path/bar')
>>> PurePath(Path('foo'), Path('bar'))
PurePosixPath('foo/bar')

जब पथरीकरण खाली होता है, तो वर्तमान निर्देशिका मान ली जाती है:

>>> PurePath()
PurePosixPath('.')

जब कई निरपेक्ष मार्ग दिए जाते हैं, तो अंतिम को एक लंगर (नकल os.path.join() व्यवहार) के रूप में लिया जाता है:

>>> PurePath('/etc', '/usr', 'lib64')
PurePosixPath('/usr/lib64')
>>> PureWindowsPath('c:/Windows', 'd:bar')
PureWindowsPath('d:bar')

हालाँकि, Windows पथ में, स्थानीय रूट को बदलना पिछली ड्राइव सेटिंग को नहीं छोड़ता है:

>>> PureWindowsPath('c:/Windows', '/Program Files')
PureWindowsPath('c:/Program Files')

स्परियस स्लैश और सिंगल डॉट्स ढह गए हैं, लेकिन डबल डॉट्स ( '..' ) नहीं हैं, क्योंकि यह प्रतीकात्मक लिंक के चेहरे में एक पथ का अर्थ बदल देगा:

>>> PurePath('foo//bar')
PurePosixPath('foo/bar')
>>> PurePath('foo/./bar')
PurePosixPath('foo/bar')
>>> PurePath('foo/../bar')
PurePosixPath('foo/../bar')

(एक भोली दृष्टिकोण PurePosixPath('foo/../bar') को PurePosixPath('bar') बराबर बना PurePosixPath('bar') , जो कि गलत है अगर foo किसी अन्य निर्देशिका का प्रतीकात्मक लिंक है)

शुद्ध पथ ऑब्जेक्ट os.PathLike इंटरफ़ेस को लागू करते हैं, जिससे उन्हें इंटरफ़ेस स्वीकार किए जाने के लिए कहीं भी उपयोग करने की अनुमति मिलती है।

संस्करण 3.6 में परिवर्तित: os.PathLike इंटरफ़ेस के लिए जोड़ा गया समर्थन।

class pathlib.PurePosixPath(*pathsegments)

PurePath का एक उपवर्ग, यह पथ स्वाद गैर-Windows फ़ाइल सिस्टम पथ का प्रतिनिधित्व करता है:

>>> PurePosixPath('/etc')
PurePosixPath('/etc')

पाथसेप शुद्धिपथ के समान है।

class pathlib.PureWindowsPath(*pathsegments)

PurePath उपवर्ग, यह पथ स्वाद Windows फ़ाइल सिस्टम पथ का प्रतिनिधित्व करता है:

>>> PureWindowsPath('c:/Program Files/')
PureWindowsPath('c:/Program Files')

पाथसेप शुद्धिपथ के समान है।

आप जिस भी सिस्टम पर चल रहे हैं, उसके बावजूद, आप इन सभी वर्गों को तुरंत कर सकते हैं, क्योंकि वे कोई भी ऑपरेशन प्रदान नहीं करते हैं जो सिस्टम कॉल करता है।

सामान्य विशेषता

रास्ते अपरिवर्तनीय और धोने योग्य हैं। एक ही स्वाद के पथ तुलनात्मक और क्रमबद्ध हैं। ये गुण फ्लेवर के केस-फोल्डिंग शब्दार्थ का सम्मान करते हैं:

>>> PurePosixPath('foo') == PurePosixPath('FOO')
False
>>> PureWindowsPath('foo') == PureWindowsPath('FOO')
True
>>> PureWindowsPath('FOO') in { PureWindowsPath('foo') }
True
>>> PureWindowsPath('C:') < PureWindowsPath('d:')
True

एक अलग स्वाद के पथ असमान की तुलना करते हैं और आदेश नहीं दिए जा सकते हैं:

>>> PureWindowsPath('foo') == PurePosixPath('foo')
False
>>> PureWindowsPath('foo') < PurePosixPath('foo')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'PureWindowsPath' and 'PurePosixPath'

ऑपरेटर्स

स्लैश ऑपरेटर बाल पथ बनाने में मदद करता है, इसी तरह os.path.join() :

>>> p = PurePath('/etc')
>>> p
PurePosixPath('/etc')
>>> p / 'init.d' / 'apache2'
PurePosixPath('/etc/init.d/apache2')
>>> q = PurePath('bin')
>>> '/usr' / q
PurePosixPath('/usr/bin')

एक पथ ऑब्जेक्ट का उपयोग कहीं भी किया जा सकता है, जो os.PathLike को लागू करने के लिए स्वीकृत है

>>> import os
>>> p = PurePath('/etc')
>>> os.fspath(p)
'/etc'

एक पथ का स्ट्रिंग निरूपण कच्चे फाइल सिस्टम पथ (मूल रूप में, उदाहरण के लिए विंडोज के तहत बैकस्लैश के साथ) है, जिसे आप स्ट्रिंग के रूप में एक फ़ाइल पथ लेने वाले किसी भी फ़ंक्शन को पास कर सकते हैं:

>>> p = PurePath('/etc')
>>> str(p)
'/etc'
>>> p = PureWindowsPath('c:/Program Files')
>>> str(p)
'c:\\Program Files'

इसी तरह, एक पथ पर bytes कॉल करने से कच्ची फाइलसिस्टम पथ को बाइट्स ऑब्जेक्ट के रूप में os.fsencode() , जैसा कि os.fsencode() द्वारा एन्कोड किया गया है:

>>> bytes(p)
b'/etc'

ध्यान दें

यूनिक्स के तहत केवल bytes की सिफारिश की जाती है। विंडोज के तहत, यूनिकोड फॉर्म फाइलसिस्टम रास्तों का कैनोनिकल प्रतिनिधित्व है।

व्यक्तिगत भागों तक पहुँचना

किसी पथ के व्यक्तिगत "भागों" (घटकों) का उपयोग करने के लिए, निम्नलिखित संपत्ति का उपयोग करें:

PurePath.parts

पथ के विभिन्न घटकों तक पहुंच प्रदान करने वाला एक टपल:

>>> p = PurePath('/usr/bin/python3')
>>> p.parts
('/', 'usr', 'bin', 'python3')

>>> p = PureWindowsPath('c:/Program Files/PSF')
>>> p.parts
('c:\\', 'Program Files', 'PSF')

(ध्यान दें कि ड्राइव और लोकल रूट को कैसे एक हिस्से में फिर से जोड़ा जाता है)

तरीके और गुण

शुद्ध मार्ग निम्नलिखित तरीके और गुण प्रदान करते हैं:

PurePath.drive

ड्राइव पत्र या नाम का एक स्ट्रिंग, यदि कोई हो:

>>> PureWindowsPath('c:/Program Files/').drive
'c:'
>>> PureWindowsPath('/Program Files/').drive
''
>>> PurePosixPath('/etc').drive
''

UNC शेयरों को ड्राइव भी माना जाता है:

>>> PureWindowsPath('//host/share/foo.txt').drive
'\\\\host\\share'
PurePath.root

एक स्ट्रिंग (स्थानीय या वैश्विक) रूट का प्रतिनिधित्व करता है, यदि कोई हो:

>>> PureWindowsPath('c:/Program Files/').root
'\\'
>>> PureWindowsPath('c:Program Files/').root
''
>>> PurePosixPath('/etc').root
'/'

UNC शेयरों में हमेशा एक जड़ होती है:

>>> PureWindowsPath('//host/share').root
'\\'
PurePath.anchor

ड्राइव और रूट का संयोजन:

>>> PureWindowsPath('c:/Program Files/').anchor
'c:\\'
>>> PureWindowsPath('c:Program Files/').anchor
'c:'
>>> PurePosixPath('/etc').anchor
'/'
>>> PureWindowsPath('//host/share').anchor
'\\\\host\\share\\'
PurePath.parents

पथ के तार्किक पूर्वजों तक पहुंच प्रदान करने वाला एक अपरिवर्तनीय क्रम:

>>> p = PureWindowsPath('c:/foo/bar/setup.py')
>>> p.parents[0]
PureWindowsPath('c:/foo/bar')
>>> p.parents[1]
PureWindowsPath('c:/foo')
>>> p.parents[2]
PureWindowsPath('c:/')
PurePath.parent

मार्ग के तार्किक जनक:

>>> p = PurePosixPath('/a/b/c/d')
>>> p.parent
PurePosixPath('/a/b/c')

आप लंगर, या खाली रास्ते पर नहीं जा सकते:

>>> p = PurePosixPath('/')
>>> p.parent
PurePosixPath('/')
>>> p = PurePosixPath('.')
>>> p.parent
PurePosixPath('.')

ध्यान दें

यह एक विशुद्ध रूप से शाब्दिक संचालन है, इसलिए निम्नलिखित व्यवहार:

>>> p = PurePosixPath('foo/..')
>>> p.parent
PurePosixPath('foo')

यदि आप एक मनमाने ढंग से फाइलसिस्टम पथ को ऊपर की ओर चलना चाहते हैं, तो पहले Path.resolve() कॉल करने के लिए अनुशंसा की जाती है ताकि Path.resolve() को हल किया जा सके और “..” घटकों को समाप्त किया जा सके।

PurePath.name

अंतिम पथ घटक का प्रतिनिधित्व करने वाला एक स्ट्रिंग, ड्राइव और रूट को छोड़कर, यदि कोई हो:

>>> PurePosixPath('my/library/setup.py').name
'setup.py'

UNC ड्राइव नामों पर विचार नहीं किया जाता है:

>>> PureWindowsPath('//some/share/setup.py').name
'setup.py'
>>> PureWindowsPath('//some/share').name
''
PurePath.suffix

अंतिम घटक का फ़ाइल एक्सटेंशन, यदि कोई हो:

>>> PurePosixPath('my/library/setup.py').suffix
'.py'
>>> PurePosixPath('my/library.tar.gz').suffix
'.gz'
>>> PurePosixPath('my/library').suffix
''
PurePath.suffixes

पथ की फ़ाइल एक्सटेंशन की सूची:

>>> PurePosixPath('my/library.tar.gar').suffixes
['.tar', '.gar']
>>> PurePosixPath('my/library.tar.gz').suffixes
['.tar', '.gz']
>>> PurePosixPath('my/library').suffixes
[]
PurePath.stem

अंतिम प्रत्यय घटक, इसके प्रत्यय के बिना:

>>> PurePosixPath('my/library.tar.gz').stem
'library.tar'
>>> PurePosixPath('my/library.tar').stem
'library'
>>> PurePosixPath('my/library').stem
'library'
PurePath.as_posix()

आगे स्लैश ( / ) के साथ पथ का एक स्ट्रिंग प्रतिनिधित्व लौटें:

>>> p = PureWindowsPath('c:\\windows')
>>> str(p)
'c:\\windows'
>>> p.as_posix()
'c:/windows'
PurePath.as_uri()

एक file URI के रूप में पथ का प्रतिनिधित्व करें। यदि पथ निरपेक्ष नहीं है, तो ValueError को उठाया जाता है।

>>> p = PurePosixPath('/etc/passwd')
>>> p.as_uri()
'file:///etc/passwd'
>>> p = PureWindowsPath('c:/Windows')
>>> p.as_uri()
'file:///c:/Windows'
PurePath.is_absolute()

वापसी करें कि रास्ता निरपेक्ष है या नहीं। एक पथ को निरपेक्ष माना जाता है यदि उसमें जड़ हो और (यदि स्वाद अनुमति देता है) एक ड्राइव:

>>> PurePosixPath('/a/b').is_absolute()
True
>>> PurePosixPath('a/b').is_absolute()
False

>>> PureWindowsPath('c:/a/b').is_absolute()
True
>>> PureWindowsPath('/a/b').is_absolute()
False
>>> PureWindowsPath('c:').is_absolute()
False
>>> PureWindowsPath('//some/share').is_absolute()
True
PurePath.is_reserved()

PureWindowsPath साथ, यदि Windows, False अन्यथा के तहत पथ को आरक्षित माना जाता है, तो True लौटें। PurePosixPath साथ, False हमेशा वापस आ जाती है।

>>> PureWindowsPath('nul').is_reserved()
True
>>> PurePosixPath('nul').is_reserved()
False

आरक्षित पथों पर फ़ाइल सिस्टम कॉल रहस्यमय रूप से विफल हो सकते हैं या अनपेक्षित प्रभाव पड़ सकते हैं।

PurePath.joinpath(*other)

इस विधि को कॉल करना, बारी-बारी से अन्य तर्कों के साथ पथ के संयोजन के बराबर है:

>>> PurePosixPath('/etc').joinpath('passwd')
PurePosixPath('/etc/passwd')
>>> PurePosixPath('/etc').joinpath(PurePosixPath('passwd'))
PurePosixPath('/etc/passwd')
>>> PurePosixPath('/etc').joinpath('init.d', 'apache2')
PurePosixPath('/etc/init.d/apache2')
>>> PureWindowsPath('c:').joinpath('/Program Files')
PureWindowsPath('c:/Program Files')
PurePath.match(pattern)

प्रदान किए गए ग्लोब-शैली पैटर्न के खिलाफ इस पथ का मिलान करें। यदि मिलान सफल हो, तो True लौटें, अन्यथा False

यदि पैटर्न सापेक्ष है, तो मार्ग सापेक्ष या निरपेक्ष हो सकता है, और मिलान दाईं ओर से किया जाता है:

>>> PurePath('a/b.py').match('*.py')
True
>>> PurePath('/a/b/c.py').match('b/*.py')
True
>>> PurePath('/a/b/c.py').match('a/*.py')
False

यदि पैटर्न निरपेक्ष है, तो पथ पूर्ण होना चाहिए, और संपूर्ण पथ का मिलान होना चाहिए:

>>> PurePath('/a.py').match('/*.py')
True
>>> PurePath('a/b.py').match('/*.py')
False

अन्य तरीकों की तरह, केस-सेंसिटिविटी देखी जाती है:

>>> PureWindowsPath('b.py').match('*.PY')
True
PurePath.relative_to(*other)

इस पथ के एक संस्करण की तुलना दूसरे के प्रतिनिधित्व वाले मार्ग के सापेक्ष करें। यदि यह असंभव है, तो ValueError उठाया जाता है:

>>> p = PurePosixPath('/etc/passwd')
>>> p.relative_to('/')
PurePosixPath('etc/passwd')
>>> p.relative_to('/etc')
PurePosixPath('passwd')
>>> p.relative_to('/usr')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "pathlib.py", line 694, in relative_to
    .format(str(self), str(formatted)))
ValueError: '/etc/passwd' does not start with '/usr'
PurePath.with_name(name)

बदले हुए name साथ एक नया रास्ता लौटाएँ। यदि मूल पथ में नाम नहीं है, तो ValueError को उठाया जाता है:

>>> p = PureWindowsPath('c:/Downloads/pathlib.tar.gz')
>>> p.with_name('setup.py')
PureWindowsPath('c:/Downloads/setup.py')
>>> p = PureWindowsPath('c:/')
>>> p.with_name('setup.py')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/home/antoine/cpython/default/Lib/pathlib.py", line 751, in with_name
    raise ValueError("%r has an empty name" % (self,))
ValueError: PureWindowsPath('c:/') has an empty name
PurePath.with_suffix(suffix)

suffix साथ एक नया रास्ता बदला। यदि मूल पथ में प्रत्यय नहीं है, तो इसके स्थान पर नया प्रत्यय जोड़ा जाता है। यदि प्रत्यय एक रिक्त स्ट्रिंग है, तो मूल प्रत्यय हटा दिया जाता है:

>>> p = PureWindowsPath('c:/Downloads/pathlib.tar.gz')
>>> p.with_suffix('.bz2')
PureWindowsPath('c:/Downloads/pathlib.tar.bz2')
>>> p = PureWindowsPath('README')
>>> p.with_suffix('.txt')
PureWindowsPath('README.txt')
>>> p = PureWindowsPath('README.txt')
>>> p.with_suffix('')
PureWindowsPath('README')

कंक्रीट के रास्ते

कंक्रीट पथ शुद्ध पथ वर्गों के उपवर्ग हैं। उत्तरार्द्ध द्वारा प्रदान किए गए संचालन के अलावा, वे पथ ऑब्जेक्ट पर सिस्टम कॉल करने के तरीके भी प्रदान करते हैं। कंक्रीट पथों को त्वरित करने के तीन तरीके हैं:

class pathlib.Path(*pathsegments)

PurePath का एक उपवर्ग, यह वर्ग सिस्टम के पथ स्वाद के ठोस पथों का प्रतिनिधित्व करता है (इसे तत्काल एक PosixPath या PosixPath बनाता है):

>>> Path('setup.py')
PosixPath('setup.py')

पाथसेप शुद्धिपथ के समान है।

class pathlib.PosixPath(*pathsegments)

Path और PurePosixPath का एक उपवर्ग, यह वर्ग ठोस गैर-विंडोज फाइल सिस्टम पथ का प्रतिनिधित्व करता है:

>>> PosixPath('/etc')
PosixPath('/etc')

पाथसेप शुद्धिपथ के समान है।

class pathlib.WindowsPath(*pathsegments)

Path और PureWindowsPath का एक उपवर्ग, यह वर्ग ठोस Windows फ़ाइल सिस्टम पथ का प्रतिनिधित्व करता है:

>>> WindowsPath('c:/Program Files/')
WindowsPath('c:/Program Files')

पाथसेप शुद्धिपथ के समान है।

आप केवल अपने सिस्टम से मेल खाने वाले वर्ग के स्वाद का तुरंत उपयोग कर सकते हैं (गैर-संगत पथ जायके पर सिस्टम कॉल की अनुमति देने से आपके आवेदन में बग या विफलता हो सकती है):

>>> import os
>>> os.name
'posix'
>>> Path('setup.py')
PosixPath('setup.py')
>>> PosixPath('setup.py')
PosixPath('setup.py')
>>> WindowsPath('setup.py')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "pathlib.py", line 798, in __new__
    % (cls.__name__,))
NotImplementedError: cannot instantiate 'WindowsPath' on your system

तरीके

कंक्रीट पथ शुद्ध पथ विधियों के अलावा निम्नलिखित तरीके प्रदान करते हैं। अगर सिस्टम कॉल विफल हो जाता है (उदाहरण के लिए पथ मौजूद नहीं है) तो इनमें से कई तरीके OSError बढ़ा सकते हैं:

classmethod Path.cwd()

वर्तमान निर्देशिका का प्रतिनिधित्व करते हुए एक नया पथ ऑब्जेक्ट लौटें (जैसा कि os.getcwd() द्वारा लौटाया गया है):

>>> Path.cwd()
PosixPath('/home/antoine/pathlib')
classmethod Path.home()

उपयोगकर्ता के होम डायरेक्टरी का प्रतिनिधित्व करते हुए एक नया पथ ऑब्जेक्ट लौटाएं (जैसा कि ~ निर्माण के साथ os.path.expanduser() द्वारा लौटाया गया है):

>>> Path.home()
PosixPath('/home/antoine')

संस्करण 3.5 में नया।

Path.stat()

इस पथ के बारे में जानकारी (इसी तरह os.stat() ) पर os.stat() । इस पद्धति के लिए प्रत्येक कॉल पर परिणाम देखा जाता है।

>>> p = Path('setup.py')
>>> p.stat().st_size
956
>>> p.stat().st_mtime
1327883547.852554
Path.chmod(mode)

os.chmod() तरह फ़ाइल मोड और अनुमतियाँ बदलें:

>>> p = Path('setup.py')
>>> p.stat().st_mode
33277
>>> p.chmod(0o444)
>>> p.stat().st_mode
33060
Path.exists()

क्या पथ किसी मौजूदा फ़ाइल या निर्देशिका की ओर इशारा करता है:

>>> Path('.').exists()
True
>>> Path('setup.py').exists()
True
>>> Path('/etc').exists()
True
>>> Path('nonexistentfile').exists()
False

ध्यान दें

यदि पथ किसी सिमिलिंक की ओर इंगित करता है, तो exists() वापस आता है, चाहे सिमिलिंक किसी मौजूदा फ़ाइल या निर्देशिका को इंगित करता है

Path.expanduser()

जैसा कि os.path.expanduser() द्वारा लौटाया गया है, विस्तारित और ~user निर्माणों के साथ एक नया रास्ता os.path.expanduser() :

>>> p = PosixPath('~/films/Monty Python')
>>> p.expanduser()
PosixPath('/home/eric/films/Monty Python')

संस्करण 3.5 में नया।

Path.glob(pattern)

इस पथ द्वारा प्रस्तुत निर्देशिका में दिए गए पैटर्न को ग्लोब करें, सभी मिलान फ़ाइलों (किसी भी प्रकार की) की उपज:

>>> sorted(Path('.').glob('*.py'))
[PosixPath('pathlib.py'), PosixPath('setup.py'), PosixPath('test_pathlib.py')]
>>> sorted(Path('.').glob('*/*.py'))
[PosixPath('docs/conf.py')]

" ** " पैटर्न का अर्थ है "यह निर्देशिका और सभी उपनिर्देशिकाएं, पुनरावर्ती"। दूसरे शब्दों में, यह पुनरावर्ती ग्लोबिंग को सक्षम करता है:

>>> sorted(Path('.').glob('**/*.py'))
[PosixPath('build/lib/pathlib.py'),
 PosixPath('docs/conf.py'),
 PosixPath('pathlib.py'),
 PosixPath('setup.py'),
 PosixPath('test_pathlib.py')]

ध्यान दें

बड़ी निर्देशिका पेड़ों में " ** " पैटर्न का उपयोग करने से समय की एक विषम राशि का उपभोग हो सकता है।

Path.group()

फ़ाइल के मालिक समूह का नाम लौटाएँ। KeyError को उठाया जाता है यदि फाइल का gid सिस्टम डेटाबेस में नहीं मिलता है।

Path.is_dir()

यदि कोई निर्देशिका (या किसी निर्देशिका को इंगित करने वाला एक प्रतीकात्मक लिंक) के लिए पथ इंगित करता है, तो True लौटें, यदि यह किसी अन्य प्रकार की फ़ाइल की ओर इंगित करता है।

यदि पथ मौजूद नहीं है या टूटा हुआ सिमलिंक है तो False भी लौटाया जाता है; अन्य त्रुटियां (जैसे अनुमति त्रुटियां) प्रचारित की जाती हैं।

Path.is_file()

यदि कोई नियमित फ़ाइल (या एक नियमित फ़ाइल को इंगित करने वाला एक प्रतीकात्मक लिंक) के लिए पथ इंगित करता है तो True लौटें, यदि यह किसी अन्य प्रकार की फ़ाइल की ओर इंगित करता है।

यदि पथ मौजूद नहीं है या टूटा हुआ सिमलिंक है तो False भी लौटाया जाता है; अन्य त्रुटियां (जैसे अनुमति त्रुटियां) प्रचारित की जाती हैं।

Path.is_mount()

यदि पथ माउंट बिंदु है तो True लौटें: फ़ाइल सिस्टम का एक बिंदु जहाँ एक अलग फ़ाइल सिस्टम आरोहित किया गया है। POSIX पर, फ़ंक्शन यह जाँचता है कि पथ के जनक, path/.. , पथ से भिन्न डिवाइस पर है या path/.. और पथ समान i-नोड पर समान डिवाइस पर इंगित करता है - यह आरोह बिंदुओं का पता लगाना चाहिए सभी यूनिक्स और POSIX वेरिएंट के लिए। विंडोज पर लागू नहीं किया गया।

संस्करण 3.7 में नया।

यदि पथ किसी प्रतीकात्मक लिंक की ओर इंगित करता है, तो True लौटें अन्यथा False

यदि मार्ग मौजूद नहीं है तो False भी लौटा दी जाती है; अन्य त्रुटियां (जैसे अनुमति त्रुटियां) प्रचारित की जाती हैं।

Path.is_socket()

यदि यह यूनिक्स सॉकेट (या यूनिक्स सॉकेट को इंगित करने वाला एक प्रतीकात्मक लिंक) को इंगित करता है, तो True लौटें, यदि यह किसी अन्य प्रकार की फ़ाइल को इंगित करता है।

यदि पथ मौजूद नहीं है या टूटा हुआ सिमलिंक है तो False भी लौटाया जाता है; अन्य त्रुटियां (जैसे अनुमति त्रुटियां) प्रचारित की जाती हैं।

Path.is_fifo()

यदि यह एक अन्य प्रकार की फ़ाइल की ओर इंगित करता है तो True लौटें यदि पथ एक FIFO (या एक FIFO को इंगित करने वाला एक सांकेतिक लिंक) को इंगित करता है, तो False

यदि पथ मौजूद नहीं है या टूटा हुआ सिमलिंक है तो False भी लौटाया जाता है; अन्य त्रुटियां (जैसे अनुमति त्रुटियां) प्रचारित की जाती हैं।

Path.is_block_device()

यदि कोई ब्लॉक डिवाइस (या एक ब्लॉक डिवाइस की ओर इशारा करते हुए एक प्रतीकात्मक लिंक) के लिए पथ इंगित करता है तो True लौटें, यदि यह किसी अन्य प्रकार की फ़ाइल को इंगित करता है।

यदि पथ मौजूद नहीं है या टूटा हुआ सिमलिंक है तो False भी लौटाया जाता है; अन्य त्रुटियां (जैसे अनुमति त्रुटियां) प्रचारित की जाती हैं।

Path.is_char_device()

यदि पथ किसी वर्ण डिवाइस (या किसी वर्ण डिवाइस की ओर इंगित करने वाला एक प्रतीकात्मक लिंक) को इंगित करता है, तो वापस लौटें यदि यह किसी अन्य प्रकार की फ़ाइल की ओर इंगित करता है।

यदि पथ मौजूद नहीं है या टूटा हुआ सिमलिंक है तो False भी लौटाया जाता है; अन्य त्रुटियां (जैसे अनुमति त्रुटियां) प्रचारित की जाती हैं।

Path.iterdir()

जब पथ किसी निर्देशिका की ओर इंगित करता है, तो निर्देशिका सामग्री की पथ ऑब्जेक्ट प्राप्त करें:

>>> p = Path('docs')
>>> for child in p.iterdir(): child
...
PosixPath('docs/conf.py')
PosixPath('docs/_templates')
PosixPath('docs/make.bat')
PosixPath('docs/index.rst')
PosixPath('docs/_build')
PosixPath('docs/_static')
PosixPath('docs/Makefile')
Path.lchmod(mode)

Path.chmod() तरह, लेकिन अगर पथ एक प्रतीकात्मक लिंक की ओर Path.chmod() , तो प्रतीकात्मक लिंक का मोड लक्ष्य के बजाय बदल जाता है।

Path.lstat()

Path.stat() तरह, लेकिन, यदि पथ एक प्रतीकात्मक लिंक की ओर Path.stat() , तो उसके लक्ष्य के बजाय प्रतीकात्मक लिंक की जानकारी लौटाएं।

Path.mkdir(mode=0o777, parents=False, exist_ok=False)

इस दिए गए पथ पर एक नई निर्देशिका बनाएं। यदि मोड दिया जाता है, तो यह फ़ाइल मोड और एक्सेस फ्लैग को निर्धारित करने के लिए प्रक्रिया के umask मूल्य के साथ संयुक्त है। यदि पथ पहले से मौजूद है, तो FileExistsError को उठाया जाता है।

यदि माता-पिता सच्चे हैं, तो इस मार्ग के किसी भी लापता माता-पिता को आवश्यकतानुसार बनाया जाता है; वे बिना मोड में डिफ़ॉल्ट अनुमतियों के साथ बनाए गए हैं (POSIX mkdir -p कमांड की नकल करते हुए)।

यदि माता-पिता झूठे (डिफ़ॉल्ट) हैं, तो एक लापता माता-पिता FileNotFoundError

यदि मौजूद_ गलत (डिफ़ॉल्ट) है, तो FileExistsError को उठाया जाता है यदि लक्ष्य निर्देशिका पहले से मौजूद है।

यदि अस्तित्व_ सही है, तो FileExistsError अपवादों को अनदेखा किया जाएगा (POSIX mkdir -p कमांड के रूप में एक ही व्यवहार), लेकिन केवल यदि अंतिम पथ घटक मौजूदा गैर-निर्देशिका फ़ाइल नहीं है।

संस्करण 3.5 में परिवर्तित किया गया: अस्तित्व_ोक पैरामीटर जोड़ा गया था।

Path.open(mode='r', buffering=-1, encoding=None, errors=None, newline=None)

पथ द्वारा बताई गई फ़ाइल खोलें, जैसे अंतर्निहित open() फ़ंक्शन करता है:

>>> p = Path('setup.py')
>>> with p.open() as f:
...     f.readline()
...
'#!/usr/bin/env python3\n'
Path.owner()

फ़ाइल के मालिक के नाम को लौटाएँ। यदि सिस्टम डेटाबेस में फ़ाइल का यूआईडी नहीं मिला है तो KeyError को उठाया जाता है।

Path.read_bytes()

बाइट ऑब्जेक्ट के रूप में बताई गई फ़ाइल की बाइनरी सामग्री लौटाएँ:

>>> p = Path('my_binary_file')
>>> p.write_bytes(b'Binary file contents')
20
>>> p.read_bytes()
b'Binary file contents'

संस्करण 3.5 में नया।

Path.read_text(encoding=None, errors=None)

स्ट्रिंग के रूप में बताई गई फ़ाइल की डिकोड की गई सामग्री लौटाएँ:

>>> p = Path('my_text_file')
>>> p.write_text('Text file contents')
18
>>> p.read_text()
'Text file contents'

फ़ाइल को खोला जाता है और फिर बंद कर दिया जाता है। वैकल्पिक मापदंडों का वही अर्थ है जो open()

संस्करण 3.5 में नया।

Path.rename(target)

इस फ़ाइल या निर्देशिका को दिए गए लक्ष्य का नाम दें । यूनिक्स पर, यदि लक्ष्य मौजूद है और एक फाइल है, तो उपयोगकर्ता की अनुमति होने पर इसे चुपचाप बदल दिया जाएगा। लक्ष्य या तो एक स्ट्रिंग या अन्य पथ ऑब्जेक्ट हो सकता है:

>>> p = Path('foo')
>>> p.open('w').write('some text')
9
>>> target = Path('bar')
>>> p.rename(target)
>>> target.open().read()
'some text'
Path.replace(target)

इस फ़ाइल या निर्देशिका को दिए गए लक्ष्य का नाम दें । यदि लक्ष्य किसी मौजूदा फ़ाइल या निर्देशिका को इंगित करता है, तो उसे बिना शर्त बदला जाएगा।

Path.resolve(strict=False)

किसी भी सिम्बल को हल करने के लिए पथ को पूर्ण बनाएं। एक नया पथ ऑब्जेक्ट लौटाया गया है:

>>> p = Path()
>>> p
PosixPath('.')
>>> p.resolve()
PosixPath('/home/antoine/pathlib')

" .. " घटक भी समाप्त हो गए हैं (ऐसा करने का यह एकमात्र तरीका है):

>>> p = Path('docs/../setup.py')
>>> p.resolve()
PosixPath('/home/antoine/pathlib/setup.py')

यदि पथ मौजूद नहीं है और सख्त True , तो FileNotFoundError को उठाया जाता है। यदि False , तो False , जहाँ तक संभव हो मार्ग को हल किया गया है और किसी भी शेष को जाँच के बिना जोड़ा गया है कि क्या यह मौजूद है। यदि रिज़ॉल्यूशन पथ के साथ अनंत लूप का सामना करना पड़ता है, तो RuntimeError को उठाया जाता है।

संस्करण 3.6 में नया: सख्त तर्क।

Path.rglob(pattern)

यह दिए गए पैटर्न के सामने जोड़े गए " ** " के साथ Path.glob() को कॉल करने Path.glob() :

>>> sorted(Path().rglob("*.py"))
[PosixPath('build/lib/pathlib.py'),
 PosixPath('docs/conf.py'),
 PosixPath('pathlib.py'),
 PosixPath('setup.py'),
 PosixPath('test_pathlib.py')]
Path.rmdir()

इस निर्देशिका को हटा दें। निर्देशिका खाली होनी चाहिए।

Path.samefile(other_path)

वापसी करें कि क्या यह पथ अन्य_पाथ के समान फ़ाइल को इंगित करता है , जो या तो पथ ऑब्जेक्ट, या स्ट्रिंग हो सकता है। शब्दार्थ os.path.samefile() और os.path.samestat()

यदि किसी कारण से फ़ाइल तक नहीं पहुँचा जा सकता है तो OSError को उठाया जा सकता है।

>>> p = Path('spam')
>>> q = Path('eggs')
>>> p.samefile(q)
False
>>> p.samefile('spam')
True

संस्करण 3.5 में नया।

इस पथ को लक्ष्य करने के लिए एक प्रतीकात्मक लिंक बनाएं। यदि लिंक का लक्ष्य एक निर्देशिका है, तो Windows के अंतर्गत, target_is_directory सही (डिफ़ॉल्ट False ) होना चाहिए। POSIX के तहत, target_is_directory के मान को अनदेखा किया जाता है।

>>> p = Path('mylink')
>>> p.symlink_to('setup.py')
>>> p.resolve()
PosixPath('/home/antoine/pathlib/setup.py')
>>> p.stat().st_size
956
>>> p.lstat().st_size
8

ध्यान दें

तर्कों (लिंक, लक्ष्य) का क्रम os.symlink() के विपरीत है।

Path.touch(mode=0o666, exist_ok=True)

इस दिए गए पथ पर एक फ़ाइल बनाएँ। यदि मोड दिया जाता है, तो यह फ़ाइल मोड और एक्सेस फ्लैग को निर्धारित करने के लिए प्रक्रिया के umask मूल्य के साथ संयुक्त है। यदि फ़ाइल पहले से मौजूद है, तो फ़ंक्शन सफल होता है अगर अस्तित्व_ सही है (और इसका संशोधन समय वर्तमान समय में अपडेट किया गया है), अन्यथा FileExistsError उठाया जाता है।

इस फ़ाइल या प्रतीकात्मक लिंक को हटा दें। यदि पथ किसी निर्देशिका को इंगित करता है, तो इसके बजाय Path.rmdir() उपयोग करें।

Path.write_bytes(data)

बाइट्स मोड में बताई गई फ़ाइल खोलें, उस पर डेटा लिखें, और फ़ाइल को बंद करें:

>>> p = Path('my_binary_file')
>>> p.write_bytes(b'Binary file contents')
20
>>> p.read_bytes()
b'Binary file contents'

उसी नाम की एक मौजूदा फ़ाइल अधिलेखित है।

संस्करण 3.5 में नया।

Path.write_text(data, encoding=None, errors=None)

टेक्स्ट मोड में बताई गई फ़ाइल खोलें, उस पर डेटा लिखें और फ़ाइल को बंद करें:

>>> p = Path('my_text_file')
>>> p.write_text('Text file contents')
18
>>> p.read_text()
'Text file contents'

संस्करण 3.5 में नया।

ओएस मॉड्यूल में उपकरणों के लिए पत्राचार

नीचे उनके संगत PurePath / Path समतुल्य विभिन्न os फ़ंक्शन की तालिका तैयार की जा रही है।

ध्यान दें

हालाँकि, os.path.relpath() और PurePath.relative_to() कुछ अतिव्यापी उपयोग-मामले हैं, लेकिन उनके शब्दार्थ उनके बराबर न PurePath.relative_to() वारंट के लिए पर्याप्त हैं।

ओएस और ओस्प pathlib
os.path.abspath() Path.resolve()
os.chmod() Path.chmod()
os.mkdir() Path.mkdir()
os.rename() Path.rename()
os.replace() Path.replace()
os.rmdir() Path.rmdir()
os.remove() , os.unlink() Path.unlink()
os.getcwd() Path.cwd()
os.path.exists() exists()
os.path.expanduser() Path.expanduser() और Path.home()
os.path.isdir() Path.is_dir()
os.path.isfile() Path.is_file()
os.path.islink() Path.is_symlink()
os.stat() Path.stat() , Path.owner() , Path.group()
os.path.isabs() PurePath.is_absolute()
os.path.join() PurePath.joinpath()
os.path.basename() name
os.path.dirname() PurePath.parent
os.path.samefile() Path.samefile()
os.path.splitext() suffix