pathlib - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

pathlib - pathlib ഡോക്യുമെന്റേഷൻ

സ്ട്രിംഗ് ഒബ്‌ജക്റ്റുകളായി ഫയൽസിസ്റ്റം പാത്തുകൾ കൈകാര്യം ചെയ്യുന്നത് പെട്ടെന്ന് ബുദ്ധിമുട്ടുള്ളതായിരിക്കും: ഒന്നിലധികം
എന്നതിലേക്ക് വിളിക്കുന്നു os.path.join() or os.path.dirname(), മുതലായവ. ഈ മൊഡ്യൂൾ ഒരു കൂട്ടം ക്ലാസുകൾ വാഗ്ദാനം ചെയ്യുന്നു
എളുപ്പവും ഒബ്ജക്റ്റ്-ഓറിയന്റഡ് രീതിയിൽ പാതകളിലെ എല്ലാ പൊതുവായ പ്രവർത്തനങ്ങളും ഫീച്ചർ ചെയ്യുന്നു.

ഈ മൊഡ്യൂൾ പൈത്തൺ 3.2 അല്ലെങ്കിൽ അതിനു ശേഷമുള്ളവയ്‌ക്കൊപ്പമാണ് ഉപയോഗിക്കുന്നത്, പക്ഷേ ഇത് പൈത്തണുമായി പൊരുത്തപ്പെടുന്നു
2.7.

ശ്രദ്ധിക്കുക:
ഈ മൊഡ്യൂൾ ഉണ്ടായിട്ടുണ്ട് ഉൾപ്പെടുത്തിയത് ശേഷം പൈത്തൺ 3.4 സ്റ്റാൻഡേർഡ് ലൈബ്രറിയിൽ പെയിന്റ് 428
സ്വീകാര്യത. നിങ്ങൾ ഇത് പൈത്തൺ 3.3 അല്ലെങ്കിൽ പഴയതിനായി മാത്രം ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട്.

കാണുക കൂടാതെ:
പെയിന്റ് 428: അന്തിമ പാത്ത്‌ലിബ് രൂപകല്പനയുടെയും API-യുടെയും യുക്തി.

ഡൌൺലോഡ്

സ്വതന്ത്രമായ റിലീസുകൾ PyPI-യിൽ ലഭ്യമാണ്: http://pypi.python.org/pypi/pathlib/

പ്രധാന വികസനം ഇപ്പോൾ പൈത്തൺ സ്റ്റാൻഡേർഡ് ലൈബ്രറിയിൽ നടക്കുന്നു: കാണുക പൈത്തൺ
ഡെവലപ്പറുടെ വഴികാട്ടി.

ഈ ഒറ്റപ്പെട്ട ബാക്ക്‌പോർട്ട് മൊഡ്യൂളിന്റെ മെയിന്റനൻസ് റിപ്പോസിറ്ററി ബിറ്റ്ബക്കറ്റിൽ കാണാം,
എന്നാൽ പ്രവർത്തനം വളരെ കുറവായിരിക്കുമെന്ന് പ്രതീക്ഷിക്കുന്നു: https://bitbucket.org/pitrou/pathlib/

ഹൈ ലെവൽ കാണുക

ഈ മൊഡ്യൂൾ സെമാന്റിക്സ് ഉപയോഗിച്ച് ഫയൽസിസ്റ്റം പാതകളെ പ്രതിനിധീകരിക്കുന്ന ക്ലാസുകൾ വാഗ്ദാനം ചെയ്യുന്നു
വ്യത്യസ്ത ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ. പാത ക്ലാസുകൾ തമ്മിൽ തിരിച്ചിരിക്കുന്നു ശുദ്ധമായ പാതകൾ, ഏത് നൽകുന്നു
I/O ഇല്ലാതെ പൂർണ്ണമായും കമ്പ്യൂട്ടേഷണൽ പ്രവർത്തനങ്ങൾ, കൂടാതെ കോൺക്രീറ്റ് പാതകൾ, അത് ശുദ്ധമായതിൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്നു
പാതകൾ മാത്രമല്ല I/O ഓപ്പറേഷനുകളും നൽകുന്നു. [ചിത്രം]

നിങ്ങൾ മുമ്പ് ഈ മൊഡ്യൂൾ ഉപയോഗിച്ചിട്ടില്ലെങ്കിലോ ഏത് ക്ലാസ് നിങ്ങൾക്ക് അനുയോജ്യമാണെന്ന് ഉറപ്പില്ലെങ്കിലോ
ചുമതല, പാത മിക്കവാറും നിങ്ങൾക്ക് ആവശ്യമുള്ളത് ഇതാണ്. ഇത് തൽക്ഷണം എ കോൺക്രീറ്റ് പാത പ്ലാറ്റ്ഫോമിനായി
കോഡ് പ്രവർത്തിക്കുന്നു.

ചില പ്രത്യേക സന്ദർഭങ്ങളിൽ ശുദ്ധമായ പാതകൾ ഉപയോഗപ്രദമാണ്; ഉദാഹരണത്തിന്:

1. നിങ്ങൾക്ക് ഒരു Unix മെഷീനിൽ വിൻഡോസ് പാഥുകൾ കൈകാര്യം ചെയ്യണമെങ്കിൽ (അല്ലെങ്കിൽ തിരിച്ചും). നിങ്ങൾക്ക് കഴിയില്ല
തൽക്ഷണം എ വിൻഡോസ്പാത്ത് Unix-ൽ പ്രവർത്തിക്കുമ്പോൾ, എന്നാൽ നിങ്ങൾക്ക് തൽക്ഷണം ചെയ്യാൻ കഴിയും
PureWindowsPath.

2. യഥാർത്ഥത്തിൽ ആക്‌സസ് ചെയ്യാതെ തന്നെ നിങ്ങളുടെ കോഡ് പാത്തുകൾ കൈകാര്യം ചെയ്യുന്നുവെന്ന് ഉറപ്പാക്കേണ്ടതുണ്ട്
OS. ഈ സാഹചര്യത്തിൽ, ശുദ്ധമായ ക്ലാസുകളിലൊന്ന് ഉടനടി നൽകുന്നത് ഉപയോഗപ്രദമാകും
കേവലം OS-ആക്സസിംഗ് പ്രവർത്തനങ്ങളൊന്നും ഇല്ല.

ബേസിക് ഉപയോഗിക്കുക

മൊഡ്യൂൾ ക്ലാസുകൾ ഇറക്കുമതി ചെയ്യുന്നു:

>>> pathlib ഇറക്കുമതിയിൽ നിന്ന് *

ലിസ്‌റ്റിംഗ് ഉപഡയറക്‌ടറികൾ:

>>> p = പാത('.')
>>> [x ന്റെ p.iterdir() ൽ x.is_dir()]
[PosixPath('.hg'), PosixPath('docs'), PosixPath('dist'),
PosixPath('__pycache__'), PosixPath('build')]

ഈ ഡയറക്‌ടറി ട്രീയിൽ പൈത്തൺ സോഴ്‌സ് ഫയലുകൾ ലിസ്റ്റുചെയ്യുന്നു:

>>> ലിസ്റ്റ്(p.glob('**/*.py'))
[PosixPath('test_pathlib.py'), PosixPath('setup.py'),
PosixPath('pathlib.py'), PosixPath('docs/conf.py'),
PosixPath('build/lib/patlib.py')]

ഒരു ഡയറക്ടറി ട്രീക്കുള്ളിൽ നാവിഗേറ്റ് ചെയ്യുന്നു:

>>> p = പാത('/തുടങ്ങിയവ')
>>> q = p / 'init.d' / 'reboot'
>>> ക്യു
PosixPath('/etc/init.d/reboot')
>>> q.resolve()
PosixPath('/etc/rc.d/init.d/halt')

ക്വയറിങ് പാത്ത് പ്രോപ്പർട്ടികൾ:

>>> q. നിലവിലുണ്ട്()
ട്രൂ
>>> q.is_dir()
തെറ്റായ

ഒരു ഫയൽ തുറക്കുന്നു:

>>> കൂടെ q.open() f ആയി: f.readline()
...
'#!/ ബിൻ / ബാഷ്\n'

PURE പാതകൾ

പ്യൂർ പാത്ത് ഒബ്‌ജക്റ്റുകൾ യഥാർത്ഥത്തിൽ ആക്‌സസ് ചെയ്യാത്ത പാത്ത്-ഹാൻഡ്‌ലിംഗ് പ്രവർത്തനങ്ങൾ നൽകുന്നു
ഫയൽസിസ്റ്റം. ഈ ക്ലാസുകൾ ആക്സസ് ചെയ്യാൻ മൂന്ന് വഴികളുണ്ട്, അതിനെ ഞങ്ങൾ വിളിക്കുന്നു സുഗന്ധങ്ങൾ:

ക്ലാസ് pathlib.PurePath(*pathsegments)
സിസ്റ്റത്തിന്റെ പാത്ത് ഫ്ലേവറിനെ പ്രതിനിധീകരിക്കുന്ന ഒരു ജനറിക് ക്ലാസ് (തൽക്ഷണം അത് സൃഷ്ടിക്കുന്നു
ഒന്നുകിൽ എ PurePosixPath അല്ലെങ്കിൽ PureWindowsPath):

>>> PurePath('setup.py') # ഒരു Unix മെഷീനിൽ പ്രവർത്തിക്കുന്നു
PurePosixPath('setup.py')

ഓരോ ഘടകങ്ങളും പാതകൾ a പ്രതിനിധീകരിക്കുന്ന ഒരു സ്ട്രിംഗ് അല്ലെങ്കിൽ ബൈറ്റുകൾ ഒബ്ജക്റ്റ് ആകാം
പാത സെഗ്മെന്റ്; ഇത് മറ്റൊരു പാത്ത് ഒബ്ജക്റ്റ് ആകാം:

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

എപ്പോൾ പാതകൾ ശൂന്യമാണ്, നിലവിലെ ഡയറക്‌ടറി അനുമാനിക്കുന്നു:

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

നിരവധി സമ്പൂർണ്ണ പാതകൾ നൽകുമ്പോൾ, അവസാനത്തേത് ഒരു ആങ്കറായി എടുക്കും (അനുകരണം
os.path.join()ന്റെ പെരുമാറ്റം):

>>> PurePath('/തുടങ്ങിയവ','/ usr', 'lib64')
PurePosixPath('/usr/lib64')
>>> PureWindowsPath('c:/Windows', 'd:bar')
PureWindowsPath('d:bar')

എന്നിരുന്നാലും, ഒരു വിൻഡോസ് പാതയിൽ, ലോക്കൽ റൂട്ട് മാറ്റുന്നത് മുമ്പത്തേത് നിരസിക്കുന്നില്ല
ഡ്രൈവ് ക്രമീകരണം:

>>> 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('ബാർ'), എങ്കിൽ തെറ്റാണ് ഫൂ മറ്റൊന്നിലേക്കുള്ള പ്രതീകാത്മക കണ്ണിയാണ്
ഡയറക്ടറി)

ക്ലാസ് pathlib.PurePosixPath(*pathsegments)
ഒരു ഉപവിഭാഗം ശുദ്ധപാത, ഈ പാത്ത് ഫ്ലേവർ വിൻഡോസ് ഇതര ഫയൽസിസ്റ്റം പാത്തുകളെ പ്രതിനിധീകരിക്കുന്നു:

>>> PurePosixPath('/തുടങ്ങിയവ')
PurePosixPath('/തുടങ്ങിയവ')

പാതകൾ എന്നതിന് സമാനമായി വ്യക്തമാക്കിയിരിക്കുന്നു ശുദ്ധപാത.

ക്ലാസ് pathlib.PureWindowsPath(*pathsegments)
ഒരു ഉപവിഭാഗം ശുദ്ധപാത, ഈ പാത്ത് ഫ്ലേവർ വിൻഡോസ് ഫയൽസിസ്റ്റം പാത്തുകളെ പ്രതിനിധീകരിക്കുന്നു:

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

പാതകൾ എന്നതിന് സമാനമായി വ്യക്തമാക്കിയിരിക്കുന്നു ശുദ്ധപാത.

നിങ്ങൾ പ്രവർത്തിപ്പിക്കുന്ന സിസ്റ്റം പരിഗണിക്കാതെ തന്നെ, നിങ്ങൾക്ക് ഈ ക്ലാസുകളെല്ലാം തൽക്ഷണം ചെയ്യാൻ കഴിയും,
സിസ്റ്റം കോളുകൾ ചെയ്യുന്ന ഒരു പ്രവർത്തനവും അവർ നൽകാത്തതിനാൽ.

പൊതുവായ പ്രോപ്പർട്ടികൾ
പാതകൾ മാറ്റമില്ലാത്തതും ഹാഷ് ചെയ്യാവുന്നതുമാണ്. ഒരേ രുചിയുടെ പാതകൾ താരതമ്യപ്പെടുത്താവുന്നതും ക്രമപ്പെടുത്താവുന്നതുമാണ്.
ഈ ഗുണങ്ങൾ ഫ്ലേവറിന്റെ കെയ്‌സ്-ഫോൾഡിംഗ് സെമാന്റിക്‌സിനെ മാനിക്കുന്നു:

>>> PurePosixPath('foo') == PurePosixPath('FOO')
തെറ്റായ
>>> PureWindowsPath('foo') == PureWindowsPath('FOO')
ട്രൂ
>>> {PureWindowsPath('foo')}-ൽ PureWindowsPath('FOO')
ട്രൂ
>>> PureWindowsPath('C:') < PureWindowsPath('d:')
ട്രൂ

വ്യത്യസ്ത സ്വാദുള്ള പാതകൾ അസമമായി താരതമ്യം ചെയ്യുന്നു, അവ ഓർഡർ ചെയ്യാൻ കഴിയില്ല:

>>> PureWindowsPath('foo') == PurePosixPath('foo')
തെറ്റായ
>>> PureWindowsPath('foo') < PurePosixPath('foo')
ട്രേസ്ബാക്ക് (ഏറ്റവും പുതിയ കോൾ അവസാനമായി):
ഫയൽ " ", വരി 1, ഇൻ
ടൈപ്പ് പിശക്: ക്രമപ്പെടുത്താനാവാത്ത തരങ്ങൾ: പ്യുവർ വിൻഡോസ്പാത്ത്() < പ്യൂർപോസിക്സ്പാത്ത്()

ഓപ്പറേറററുകളും
സ്ലാഷ് ഓപ്പറേറ്റർ ചൈൽഡ് പാത്തുകൾ സൃഷ്ടിക്കാൻ സഹായിക്കുന്നു os.path.join:

>>> p = PurePath('/തുടങ്ങിയവ')
>>> പി
PurePosixPath('/തുടങ്ങിയവ')
>>> p / 'init.d' / 'apache2'
PurePosixPath('/etc/init.d/apache2')
>>> q = PurePath('bin')
>>> '/ usr' / ക്യു
PurePosixPath('/ usr / bin')

ഒരു പാതയുടെ സ്ട്രിംഗ് പ്രാതിനിധ്യം റോ ഫയൽസിസ്റ്റം പാത്ത് തന്നെയാണ് (നേറ്റീവ് രൂപത്തിൽ,
ഉദാ: വിൻഡോസിനു കീഴിലുള്ള ബാക്ക്‌സ്ലാഷുകൾ ഉപയോഗിച്ച്, ഒരു ഫയൽ എടുക്കുന്ന ഏത് ഫംഗ്‌ഷനിലേക്കും നിങ്ങൾക്ക് കൈമാറാനാകും
ഒരു സ്ട്രിംഗായി പാത:

>>> p = PurePath('/തുടങ്ങിയവ')
>>> str(p)
'/തുടങ്ങിയവ'
>>> p = PureWindowsPath('c:/Program Files')
>>> str(p)
'സി:\\പ്രോഗ്രാം ഫയലുകൾ'

അതുപോലെ, വിളിക്കുന്നു ബൈറ്റുകൾ ഒരു പാതയിൽ, റോ ഫയൽസിസ്റ്റം പാത്ത് ഒരു ബൈറ്റ്സ് ഒബ്ജക്റ്റായി നൽകുന്നു
എൻകോഡ് ചെയ്തത് os.fsencode:

>>> ബൈറ്റുകൾ(p)
b'/തുടങ്ങിയവ'

ആക്‌സസ്സുചെയ്യുന്നു വ്യക്തിഗത ഭാഗങ്ങൾ
ഒരു പാതയുടെ വ്യക്തിഗത "ഭാഗങ്ങൾ" (ഘടകങ്ങൾ) ആക്സസ് ചെയ്യുന്നതിന്, ഇനിപ്പറയുന്ന പ്രോപ്പർട്ടി ഉപയോഗിക്കുക:

PurePath.parts
പാതയുടെ വിവിധ ഘടകങ്ങളിലേക്ക് പ്രവേശനം നൽകുന്ന ഒരു ട്യൂപ്പിൾ:

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

>>> p = PureWindowsPath('c:/Program Files/PSF')
>>> p.parts
('c:\\', 'പ്രോഗ്രാം ഫയലുകൾ', 'PSF')

(ഡ്രൈവും ലോക്കൽ റൂട്ടും എങ്ങനെയാണ് ഒരു ഭാഗത്ത് പുനഃസംഘടിപ്പിച്ചതെന്ന് ശ്രദ്ധിക്കുക)

രീതികൾ ഒപ്പം പ്രോപ്പർട്ടികൾ
ശുദ്ധമായ പാതകൾ ഇനിപ്പറയുന്ന രീതികളും സവിശേഷതകളും നൽകുന്നു:

PurePath.drive
ഡ്രൈവ് അക്ഷരത്തെയോ പേരിനെയോ പ്രതിനിധീകരിക്കുന്ന ഒരു സ്ട്രിംഗ്, എന്തെങ്കിലും ഉണ്ടെങ്കിൽ:

>>> PureWindowsPath('c:/Program Files/').drive
'സി:'
>>> PureWindowsPath('/Program Files/').drive
''
>>> PurePosixPath('/തുടങ്ങിയവ').ഡ്രൈവ്
''

UNC ഷെയറുകളും ഡ്രൈവുകളായി കണക്കാക്കുന്നു:

>>> PureWindowsPath('//host/share/foo.txt').drive
'\\\\ഹോസ്റ്റ്\\പങ്ക്'

PurePath.root
(ലോക്കൽ അല്ലെങ്കിൽ ഗ്ലോബൽ) റൂട്ടിനെ പ്രതിനിധീകരിക്കുന്ന ഒരു സ്ട്രിംഗ്, എന്തെങ്കിലും ഉണ്ടെങ്കിൽ:

>>> PureWindowsPath('c:/Program Files/').root
'\\'
>>> PureWindowsPath('c:Program Files/').root
''
>>> PurePosixPath('/തുടങ്ങിയവ').റൂട്ട്
'/'

UNC ഓഹരികൾക്ക് എപ്പോഴും ഒരു റൂട്ട് ഉണ്ട്:

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

PurePath.anchor
ഡ്രൈവിന്റെയും റൂട്ടിന്റെയും സംയോജനം:

>>> PureWindowsPath('c:/Program Files/').anchor
'c:\\'
>>> PureWindowsPath('c:Program Files/').anchor
'സി:'
>>> PurePosixPath('/തുടങ്ങിയവ').ആങ്കർ
'/'
>>> PureWindowsPath('//host/share').anchor
'\\\\ഹോസ്റ്റ്\\ ഷെയർ\\'

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() സിംലിങ്കുകൾ പരിഹരിക്കുന്നതിനും ഇല്ലാതാക്കുന്നതിനും ".."
ഘടകങ്ങൾ.

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').സഫിക്സുകൾ
['.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
'പുസ്തകശാല'
>>> PurePosixPath('my/library').stem
'പുസ്തകശാല'

PurePath.as_posix()
ഫോർവേഡ് സ്ലാഷുകളുള്ള പാതയുടെ ഒരു സ്ട്രിംഗ് പ്രാതിനിധ്യം തിരികെ നൽകുക (/):

>>> p = PureWindowsPath('c:\\windows')
>>> str(p)
'സി:\\വിൻഡോസ്'
>>> p.as_posix()
'c:/windows'

PurePath.as_uri()
പാതയെ a ആയി പ്രതിനിധീകരിക്കുക ഫയല് URI മൂല്യ പിശക് പാത സമ്പൂർണ്ണമല്ലെങ്കിൽ ഉയർത്തുന്നു.

>>> 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()
ട്രൂ
>>> PurePosixPath('a/b').is_absolute()
തെറ്റായ

>>> PureWindowsPath('c:/a/b').is_absolute()
ട്രൂ
>>> PureWindowsPath('/a/b').is_absolute()
തെറ്റായ
>>> PureWindowsPath('c:').is_absolute()
തെറ്റായ
>>> PureWindowsPath('//some/share').is_absolute()
ട്രൂ

PurePath.is_reserved()
കൂടെ PureWindowsPath, മടങ്ങുക ട്രൂ പാത വിൻഡോസിന് കീഴിൽ റിസർവ് ചെയ്തതായി കണക്കാക്കുന്നുവെങ്കിൽ,
തെറ്റായ അല്ലാത്തപക്ഷം. കൂടെ PurePosixPath, തെറ്റായ എല്ലായ്പ്പോഴും തിരികെ നൽകുന്നു.

>>> PureWindowsPath('nul').is_reserved()
ട്രൂ
>>> PurePosixPath('nul').is_reserved()
തെറ്റായ

റിസർവ് ചെയ്ത പാതകളിലെ ഫയൽ സിസ്റ്റം കോളുകൾ നിഗൂഢമായി പരാജയപ്പെടാം അല്ലെങ്കിൽ ഉദ്ദേശിക്കാത്തവയാകാം
ഇഫക്റ്റുകൾ.

PurePath.joinpath(*മറ്റ്)
ഈ രീതിയെ വിളിക്കുന്നത് ഓരോന്നിന്റെയും പാതയെ സംയോജിപ്പിക്കുന്നതിന് തുല്യമാണ് മറ്റ്
ക്രമത്തിൽ വാദങ്ങൾ:

>>> PurePosixPath('/തുടങ്ങിയവ').joinpath('passwd')
PurePosixPath('/ etc / passwd')
>>> PurePosixPath('/തുടങ്ങിയവ').joinpath(PurePosixPath('passwd'))
PurePosixPath('/ etc / passwd')
>>> PurePosixPath('/തുടങ്ങിയവ').joinpath('init.d', 'apache2')
PurePosixPath('/etc/init.d/apache2')
>>> PureWindowsPath('c:').joinpath('/Program Files')
PureWindowsPath('c:/Program Files')

PurePath.match(പാറ്റേൺ)
നൽകിയിരിക്കുന്ന ഗ്ലോബ്-സ്റ്റൈൽ പാറ്റേണുമായി ഈ പാത പൊരുത്തപ്പെടുത്തുക. മടങ്ങുക ട്രൂ പൊരുത്തപ്പെടുന്നെങ്കിൽ
വിജയകരമാണ്, തെറ്റായ അല്ലെങ്കിൽ.

If പാറ്റേൺ ആപേക്ഷികമാണ്, പാത ആപേക്ഷികമോ കേവലമോ ആകാം, പൊരുത്തപ്പെടുന്നു
വലതുഭാഗത്ത് നിന്ന് ചെയ്യുന്നത്:

>>> PurePath('a/b.py').match('*.py')
ട്രൂ
>>> PurePath('/a/b/c.py').match('b/*.py')
ട്രൂ
>>> PurePath('/a/b/c.py').match('a/*.py')
തെറ്റായ

If പാറ്റേൺ സമ്പൂർണ്ണമാണ്, പാത കേവലമായിരിക്കണം, മുഴുവൻ പാതയും പൊരുത്തപ്പെടണം:

>>> PurePath('/a.py').match('/*.py')
ട്രൂ
>>> PurePath('a/b.py').match('/*.py')
തെറ്റായ

മറ്റ് രീതികൾ പോലെ, കേസ്-സെൻസിറ്റിവിറ്റി നിരീക്ഷിക്കപ്പെടുന്നു:

>>> PureWindowsPath('b.py').match('*.PY')
ട്രൂ

PurePath.relative_to(*other)
പ്രതിനിധീകരിക്കുന്ന പാതയുമായി ബന്ധപ്പെട്ട ഈ പാതയുടെ ഒരു പതിപ്പ് കണക്കാക്കുക മറ്റ്. എങ്കിൽ
അസാധ്യമാണ്, ValueError ഉയർത്തിയിരിക്കുന്നു:

>>> p = PurePosixPath('/ etc / passwd')
>>> p.relative_to('/')
PurePosixPath('etc/passwd')
>>> p.relative_to('/തുടങ്ങിയവ')
PurePosixPath('passwd')
>>> p.relative_to('/ usr')
ട്രേസ്ബാക്ക് (ഏറ്റവും പുതിയ കോൾ അവസാനമായി):
ഫയൽ " ", വരി 1, ഇൻ
ഫയൽ "pathlib.py", ലൈൻ 694, Related_to
.ഫോർമാറ്റ്(str(self), str(ഫോർമാറ്റ് ചെയ്തത്)))
മൂല്യ പിശക്: '/ etc / passwd' എന്നതിൽ തുടങ്ങുന്നില്ല/ usr'

PurePath.with_name(name)
ഉപയോഗിച്ച് ഒരു പുതിയ പാത തിരികെ നൽകുക പേര് മാറി. യഥാർത്ഥ പാതയ്ക്ക് പേരില്ലെങ്കിൽ,
മൂല്യ പിശക് ഉയർത്തി:

>>> 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')
ട്രേസ്ബാക്ക് (ഏറ്റവും പുതിയ കോൾ അവസാനമായി):
ഫയൽ " ", വരി 1, ഇൻ
ഫയൽ "/home/antoine/cpython/default/Lib/pathlib.py", ലൈൻ 751, with_name-ൽ
മൂല്യം ഉയർത്തുക("%rന് ഒരു ശൂന്യമായ പേരുണ്ട്" % (സ്വയം,))
മൂല്യ പിശക്: PureWindowsPath('c:/') ശൂന്യമായ ഒരു പേരുണ്ട്

PurePath.with_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')

കോൺക്രീറ്റ് പാതകൾ

കോൺക്രീറ്റ് പാതകൾ ശുദ്ധമായ പാത ക്ലാസുകളുടെ ഉപവിഭാഗങ്ങളാണ്. പ്രവർത്തനങ്ങൾക്ക് പുറമേ
രണ്ടാമത്തേത് നൽകിയത്, പാത്ത് ഒബ്ജക്റ്റുകളിൽ സിസ്റ്റം കോളുകൾ ചെയ്യുന്നതിനുള്ള രീതികളും അവ നൽകുന്നു.
കോൺക്രീറ്റ് പാതകൾ തൽക്ഷണം ചെയ്യാൻ മൂന്ന് വഴികളുണ്ട്:

ക്ലാസ് pathlib.Path(*pathsegments)
ഒരു ഉപവിഭാഗം ശുദ്ധപാത, ഈ ക്ലാസ് സിസ്റ്റത്തിന്റെ പാതയുടെ കോൺക്രീറ്റ് പാതകളെ പ്രതിനിധീകരിക്കുന്നു
രസം (ഇത് തൽക്ഷണം സൃഷ്ടിക്കുന്നത് ഒന്നുകിൽ a PosixPath അല്ലെങ്കിൽ വിൻഡോസ്പാത്ത്):

>>> പാത('setup.py')
PosixPath('setup.py')

പാതകൾ എന്നതിന് സമാനമായി വ്യക്തമാക്കിയിരിക്കുന്നു ശുദ്ധപാത.

ക്ലാസ് pathlib.PosixPath(*pathsegments)
ഒരു ഉപവിഭാഗം പാത ഒപ്പം PurePosixPath, ഈ ക്ലാസ് കോൺക്രീറ്റ് നോൺ-വിൻഡോകളെ പ്രതിനിധീകരിക്കുന്നു
ഫയൽസിസ്റ്റം പാതകൾ:

>>> PosixPath('/തുടങ്ങിയവ')
PosixPath('/തുടങ്ങിയവ')

പാതകൾ എന്നതിന് സമാനമായി വ്യക്തമാക്കിയിരിക്കുന്നു ശുദ്ധപാത.

ക്ലാസ് pathlib.WindowsPath(*pathsegments)
ഒരു ഉപവിഭാഗം പാത ഒപ്പം PureWindowsPath, ഈ ക്ലാസ് കോൺക്രീറ്റ് വിൻഡോകളെ പ്രതിനിധീകരിക്കുന്നു
ഫയൽസിസ്റ്റം പാതകൾ:

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

പാതകൾ എന്നതിന് സമാനമായി വ്യക്തമാക്കിയിരിക്കുന്നു ശുദ്ധപാത.

നിങ്ങളുടെ സിസ്റ്റവുമായി പൊരുത്തപ്പെടുന്ന ക്ലാസ് ഫ്ലേവർ മാത്രമേ നിങ്ങൾക്ക് തൽക്ഷണം ചെയ്യാൻ കഴിയൂ (അനുവദിക്കുന്നു
അനുയോജ്യമല്ലാത്ത പാത്ത് ഫ്ലേവറുകളിലെ സിസ്റ്റം കോളുകൾ നിങ്ങളുടെ ബഗുകളിലേക്കോ പരാജയങ്ങളിലേക്കോ നയിച്ചേക്കാം
അപേക്ഷ):

>>> OS ഇറക്കുമതി ചെയ്യുക
>>> os.name
'posix'
>>> പാത('setup.py')
PosixPath('setup.py')
>>> PosixPath('setup.py')
PosixPath('setup.py')
>>> WindowsPath('setup.py')
ട്രേസ്ബാക്ക് (ഏറ്റവും പുതിയ കോൾ അവസാനമായി):
ഫയൽ " ", വരി 1, ഇൻ
ഫയൽ "pathlib.py", ലൈൻ 798, __new__ ൽ
% (cls.__name__,))
NotEmplementedError: നിങ്ങളുടെ സിസ്റ്റത്തിൽ 'WindowsPath' ഇൻസ്റ്റൻഷ്യേറ്റ് ചെയ്യാൻ കഴിയില്ല

രീതികൾ
കോൺക്രീറ്റ് പാതകൾ ശുദ്ധമായ പാതകളുടെ രീതികൾക്ക് പുറമേ ഇനിപ്പറയുന്ന രീതികൾ നൽകുന്നു. പലതും
ഈ രീതികൾ ഒരു ഉയർത്താൻ കഴിയും OSError ഒരു സിസ്റ്റം കോൾ പരാജയപ്പെടുകയാണെങ്കിൽ (ഉദാഹരണത്തിന്, കാരണം പാത
നിലവിലില്ല):

ക്ലാസ് രീതി Path.cwd()
നിലവിലെ ഡയറക്‌ടറിയെ പ്രതിനിധീകരിക്കുന്ന ഒരു പുതിയ പാത്ത് ഒബ്‌ജക്റ്റ് തിരികെ നൽകുക (റിട്ടേൺ ചെയ്തത് പോലെ
os.getcwd()):

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

Path.stat()
ഈ പാതയെക്കുറിച്ചുള്ള വിവരങ്ങൾ തിരികെ നൽകുക (അതുപോലെ os.stat()). ഫലം നോക്കി
ഈ രീതിയിലേക്കുള്ള ഓരോ കോളിലും.

>>> p = പാത('setup.py')
>>> p.stat().st_size
956
>>> p.stat().st_mtime
1327883547.852554

Path.chmod(മോഡ്)
ഫയൽ മോഡും അനുമതികളും മാറ്റുക os.chmod():

>>> p = പാത('setup.py')
>>> p.stat().st_mode
33277
>>> p.chmod(0o444)
>>> p.stat().st_mode
33060

Path.exist()
പാത്ത് നിലവിലുള്ള ഫയലിലേക്കോ ഡയറക്‌ടറിയിലേക്കോ പോയിന്റ് ചെയ്‌താലും:

>>> pathlib ഇറക്കുമതിയിൽ നിന്ന് *
>>> പാത('.') നിലവിലുണ്ട്()
ട്രൂ
>>> Path('setup.py') നിലവിലുണ്ട്()
ട്രൂ
>>> പാത('/തുടങ്ങിയവ').നിലവിലുണ്ട്()
ട്രൂ
>>> Path('nonexistentfile').exist()
തെറ്റായ

Path.glob(പാറ്റേൺ)
നൽകിയിരിക്കുന്നത് ഗ്ലോബ് ചെയ്യുക പാറ്റേൺ ഈ പാത പ്രതിനിധീകരിക്കുന്ന ഡയറക്ടറിയിൽ, എല്ലാം നൽകുന്നു
പൊരുത്തപ്പെടുന്ന ഫയലുകൾ (ഏത് തരത്തിലും):

>>> അടുക്കി(പാത്ത്('.').glob('*.py'))
[PosixPath('pathlib.py'), PosixPath('setup.py'), PosixPath('test_patlib.py')]
>>> അടുക്കി(പാത്ത്('.').glob('*/*.py'))
[PosixPath('docs/conf.py')]

"**പാറ്റേൺ എന്നാൽ "ഈ ഡയറക്ടറിയും എല്ലാ ഉപഡയറക്‌ടറികളും, ആവർത്തനപരമായി" എന്നാണ് അർത്ഥമാക്കുന്നത്
മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ഇത് ആവർത്തന ഗ്ലോബിംഗ് പ്രവർത്തനക്ഷമമാക്കുന്നു:

>>> അടുക്കി(പാത്ത്('.').glob('**/*.py'))
[PosixPath('build/lib/patlib.py'),
PosixPath('docs/conf.py'),
PosixPath('patlib.py'),
PosixPath('setup.py'),
PosixPath('test_patlib.py')]

ശ്രദ്ധിക്കുക:
ഉപയോഗിച്ച് "**"വലിയ ഡയറക്ടറി ട്രീകളിലെ പാറ്റേൺ അമിതമായ തുക ഉപയോഗിച്ചേക്കാം
സമയം.

Path.group()
ഫയൽ കൈവശമുള്ള ഗ്രൂപ്പിന്റെ പേര് തിരികെ നൽകുക. കീ പിശക് ഫയലിന്റെ gid ആണെങ്കിൽ ഉയർത്തുന്നു
സിസ്റ്റം ഡാറ്റാബേസിൽ കാണുന്നില്ല.

Path.is_dir()
മടങ്ങുക ട്രൂ പാത ഒരു ഡയറക്‌ടറിയിലേക്ക് ചൂണ്ടിക്കാണിക്കുന്നുവെങ്കിൽ (അല്ലെങ്കിൽ ഒരു പ്രതീകാത്മക ലിങ്ക് a
ഡയറക്ടറി), തെറ്റായ അത് മറ്റൊരു തരത്തിലുള്ള ഫയലിലേക്ക് വിരൽ ചൂണ്ടുകയാണെങ്കിൽ.

തെറ്റായ പാത നിലവിലില്ലെങ്കിലോ തകർന്ന സിംലിങ്ക് ആണെങ്കിലോ തിരികെ നൽകും; മറ്റുള്ളവ
പിശകുകൾ (അനുമതി പിശകുകൾ പോലുള്ളവ) പ്രചരിപ്പിക്കപ്പെടുന്നു.

Path.is_file()
മടങ്ങുക ട്രൂ പാത്ത് ഒരു സാധാരണ ഫയലിലേക്കാണ് വിരൽ ചൂണ്ടുന്നതെങ്കിൽ (അല്ലെങ്കിൽ ഒരു പ്രതീകാത്മക ലിങ്ക് എ
സാധാരണ ഫയൽ), തെറ്റായ അത് മറ്റൊരു തരത്തിലുള്ള ഫയലിലേക്ക് വിരൽ ചൂണ്ടുകയാണെങ്കിൽ.

തെറ്റായ പാത നിലവിലില്ലെങ്കിലോ തകർന്ന സിംലിങ്ക് ആണെങ്കിലോ തിരികെ നൽകും; മറ്റുള്ളവ
പിശകുകൾ (അനുമതി പിശകുകൾ പോലുള്ളവ) പ്രചരിപ്പിക്കപ്പെടുന്നു.

Path.is_symlink()
മടങ്ങുക ട്രൂ പാത ഒരു പ്രതീകാത്മക ലിങ്കിലേക്കാണ് വിരൽ ചൂണ്ടുന്നതെങ്കിൽ, തെറ്റായ അല്ലെങ്കിൽ.

തെറ്റായ പാത നിലവിലില്ലെങ്കിൽ തിരികെ നൽകും; മറ്റ് പിശകുകൾ (അനുമതി പോലെ
പിശകുകൾ) പ്രചരിപ്പിക്കപ്പെടുന്നു.

Path.is_socket()
മടങ്ങുക ട്രൂ പാത ഒരു Unix സോക്കറ്റിലേക്ക് പോയിന്റ് ചെയ്യുന്നുവെങ്കിൽ (അല്ലെങ്കിൽ a യിലേക്ക് ചൂണ്ടിക്കാണിക്കുന്ന ഒരു പ്രതീകാത്മക ലിങ്ക്
യുണിക്സ് സോക്കറ്റ്), തെറ്റായ അത് മറ്റൊരു തരത്തിലുള്ള ഫയലിലേക്ക് വിരൽ ചൂണ്ടുകയാണെങ്കിൽ.

തെറ്റായ പാത നിലവിലില്ലെങ്കിലോ തകർന്ന സിംലിങ്ക് ആണെങ്കിലോ തിരികെ നൽകും; മറ്റുള്ളവ
പിശകുകൾ (അനുമതി പിശകുകൾ പോലുള്ളവ) പ്രചരിപ്പിക്കപ്പെടുന്നു.

Path.is_fifo()
മടങ്ങുക ട്രൂ പാത ഒരു FIFO ലേക്ക് ചൂണ്ടിക്കാണിക്കുന്നുവെങ്കിൽ (അല്ലെങ്കിൽ FIFO ലേക്ക് ചൂണ്ടിക്കാണിക്കുന്ന ഒരു പ്രതീകാത്മക ലിങ്ക്),
തെറ്റായ അത് മറ്റൊരു തരത്തിലുള്ള ഫയലിലേക്ക് വിരൽ ചൂണ്ടുകയാണെങ്കിൽ.

തെറ്റായ പാത നിലവിലില്ലെങ്കിലോ തകർന്ന സിംലിങ്ക് ആണെങ്കിലോ തിരികെ നൽകും; മറ്റുള്ളവ
പിശകുകൾ (അനുമതി പിശകുകൾ പോലുള്ളവ) പ്രചരിപ്പിക്കപ്പെടുന്നു.

Path.is_block_device()
മടങ്ങുക ട്രൂ പാത ഒരു ബ്ലോക്ക് ഉപകരണത്തിലേക്ക് ചൂണ്ടിക്കാണിക്കുന്നുവെങ്കിൽ (അല്ലെങ്കിൽ ഒരു പ്രതീകാത്മക ലിങ്ക് എ
ബ്ലോക്ക് ഉപകരണം), തെറ്റായ അത് മറ്റൊരു തരത്തിലുള്ള ഫയലിലേക്ക് വിരൽ ചൂണ്ടുകയാണെങ്കിൽ.

തെറ്റായ പാത നിലവിലില്ലെങ്കിലോ തകർന്ന സിംലിങ്ക് ആണെങ്കിലോ തിരികെ നൽകും; മറ്റുള്ളവ
പിശകുകൾ (അനുമതി പിശകുകൾ പോലുള്ളവ) പ്രചരിപ്പിക്കപ്പെടുന്നു.

Path.is_char_device()
മടങ്ങുക ട്രൂ പാത്ത് ഒരു പ്രതീക ഉപകരണത്തിലേക്ക് പോയിന്റുചെയ്യുകയാണെങ്കിൽ (അല്ലെങ്കിൽ ഒരു പ്രതീകാത്മക ലിങ്ക് പോയിന്റിംഗ്
ഒരു പ്രതീക ഉപകരണത്തിലേക്ക്), തെറ്റായ അത് മറ്റൊരു തരത്തിലുള്ള ഫയലിലേക്ക് വിരൽ ചൂണ്ടുകയാണെങ്കിൽ.

തെറ്റായ പാത നിലവിലില്ലെങ്കിലോ തകർന്ന സിംലിങ്ക് ആണെങ്കിലോ തിരികെ നൽകും; മറ്റുള്ളവ
പിശകുകൾ (അനുമതി പിശകുകൾ പോലുള്ളവ) പ്രചരിപ്പിക്കപ്പെടുന്നു.

Path.iterdir()
ഒരു ഡയറക്‌ടറിയിലേക്ക് പാത്ത് പോയിന്റ് ചെയ്യുമ്പോൾ, ഡയറക്‌ടറി ഉള്ളടക്കത്തിന്റെ പാത്ത് ഒബ്‌ജക്‌റ്റുകൾ നൽകുക:

>>> p = പാത('ഡോക്സ്')
>>> p.iterdir(): കുട്ടിക്ക്
...
PosixPath('docs/conf.py')
PosixPath('docs/_templates')
PosixPath('docs/make.bat')
PosixPath('docs/index.rst')
PosixPath('docs/_build')
PosixPath('ഡോക്സ്/_സ്റ്റാറ്റിക്')
PosixPath('ഡോക്സ്/മേക്ക്ഫയൽ')

Path.lchmod(മോഡ്)
പോലെ Path.chmod() പക്ഷേ, പാത ഒരു പ്രതീകാത്മക ലിങ്കിലേക്കാണ് വിരൽ ചൂണ്ടുന്നതെങ്കിൽ, പ്രതീകാത്മക ലിങ്കിന്റെ
അതിന്റെ ലക്ഷ്യത്തേക്കാൾ മോഡ് മാറിയിരിക്കുന്നു.

Path.lstat()
പോലെ Path.stat() പക്ഷേ, പാത ഒരു പ്രതീകാത്മക ലിങ്കിലേക്ക് വിരൽ ചൂണ്ടുകയാണെങ്കിൽ, പ്രതീകാത്മകമായത് തിരികെ നൽകുക
ലക്ഷ്യത്തേക്കാൾ ലിങ്കിന്റെ വിവരങ്ങൾ.

Path.mkdir(മോഡ്=0o777, മാതാപിതാക്കൾ = തെറ്റ്)
ഈ നൽകിയിരിക്കുന്ന പാതയിൽ ഒരു പുതിയ ഡയറക്ടറി സൃഷ്ടിക്കുക. എങ്കിൽ മോഡ് നൽകിയിരിക്കുന്നു, അതുമായി സംയോജിപ്പിച്ചിരിക്കുന്നു
പ്രക്രിയ' ഉമാസ്ക് ഫയൽ മോഡ് നിർണ്ണയിക്കുന്നതിനും ഫ്ലാഗുകൾ ആക്സസ് ചെയ്യുന്നതിനുമുള്ള മൂല്യം. പാത എങ്കിൽ
ഇതിനകം നിലവിലുണ്ട്, OSError ഉയർത്തിയിരിക്കുന്നു.

If മാതാപിതാക്കൾ ശരിയാണ്, ഈ പാതയിൽ കാണാതായ മാതാപിതാക്കളെ ആവശ്യാനുസരണം സൃഷ്ടിക്കപ്പെടുന്നു; അവർ
എടുക്കാതെ തന്നെ ഡിഫോൾട്ട് അനുമതികളോടെ സൃഷ്‌ടിക്കപ്പെട്ടവയാണ് മോഡ് അക്കൗണ്ടിലേക്ക്
(POSIX-നെ അനുകരിക്കുന്നു mkdir -p കമാൻഡ്).

If മാതാപിതാക്കൾ തെറ്റാണ് (സ്ഥിരസ്ഥിതി), കാണാതായ രക്ഷിതാവ് ഉയർത്തുന്നു OSError.

Path.open(മോഡ്='r', ബഫറിംഗ്=-1, എൻകോഡിംഗ്=ഒന്നുമില്ല, പിശകുകൾ=ഒന്നുമില്ല, ന്യൂലൈൻ=ഒന്നുമില്ല)
ബിൽറ്റ്-ഇൻ പോലെ പാത്ത് ചൂണ്ടിക്കാണിച്ച ഫയൽ തുറക്കുക തുറക്കുക () പ്രവർത്തനം ചെയ്യുന്നു:

>>> p = പാത('setup.py')
>>> p.open() ഉപയോഗിച്ച് f ആയി:
... f.readline()
...
'#!/usr/bin/env python3\n'

Path.owner()
ഫയൽ കൈവശമുള്ള ഉപയോക്താവിന്റെ പേര് തിരികെ നൽകുക. കീ പിശക് ഫയലിന്റെ uid ആണെങ്കിൽ ഉയർത്തുന്നു
സിസ്റ്റം ഡാറ്റാബേസിൽ കാണുന്നില്ല.

Path.rename(ലക്ഷ്യം)
ഈ ഫയലിന്റെയോ ഡയറക്ടറിയുടെയോ പേരുമാറ്റുക ലക്ഷ്യം. ലക്ഷ്യം ഒന്നുകിൽ ഒരു ചരട് ആകാം
അല്ലെങ്കിൽ മറ്റൊരു പാത്ത് ഒബ്ജക്റ്റ്:

>>> p = പാത('foo')
>>> p.open('w').write('some text')
9
>>> ലക്ഷ്യം = പാത('ബാർ')
>>> p.rename(ലക്ഷ്യം)
>>> target.open().read()
'ചില വാചകം'

Path.replace(ലക്ഷ്യം)
ഈ ഫയലിന്റെയോ ഡയറക്ടറിയുടെയോ പേരുമാറ്റുക ലക്ഷ്യം. എങ്കിൽ ലക്ഷ്യം നിലവിലുള്ളതിനെ സൂചിപ്പിക്കുന്നു
ഫയൽ അല്ലെങ്കിൽ ഡയറക്ടറി, അത് നിരുപാധികമായി മാറ്റിസ്ഥാപിക്കും.

ഈ രീതി പൈത്തൺ 3.3-ൽ മാത്രമേ ലഭ്യമാകൂ; അത് ഉയർത്തും നടപ്പിലാക്കിയ പിശക് on
മുൻ പൈത്തൺ പതിപ്പുകൾ.

Path.resolve()
ഏതെങ്കിലും സിംലിങ്കുകൾ പരിഹരിച്ച് പാത സമ്പൂർണ്ണമാക്കുക. ഒരു പുതിയ പാത്ത് ഒബ്‌ജക്റ്റ് തിരികെ നൽകി:

>>> p = പാത()
>>> പി
PosixPath('.')
>>> p.resolve()
PosixPath('/home/antoine/pathlib')

".." ഘടകങ്ങളും ഒഴിവാക്കപ്പെടുന്നു (അങ്ങനെ ചെയ്യാനുള്ള ഒരേയൊരു രീതി ഇതാണ്):

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

പാത നിലവിലില്ലെങ്കിൽ, ഒരു OSError ഉയർത്തിയിരിക്കുന്നു. ഒരു അനന്തമായ ലൂപ്പ് ആണെങ്കിൽ
റെസലൂഷൻ പാതയിൽ കണ്ടുമുട്ടി, പ്രവർത്തനസമയ പിശക് ഉയർത്തിയിരിക്കുന്നു.

Path.rglob(പാറ്റേൺ)
ഇത് വിളിക്കുന്നത് പോലെയാണ് ഗ്ലോബ്() കൂടെ "**" നൽകിയതിന് മുന്നിൽ ചേർത്തു പാറ്റേൺ:

>>> അടുക്കി(പാത്ത്().rglob("*.py"))
[PosixPath('build/lib/patlib.py'),
PosixPath('docs/conf.py'),
PosixPath('patlib.py'),
PosixPath('setup.py'),
PosixPath('test_patlib.py')]

Path.rmdir()
ഈ ഡയറക്ടറി നീക്കം ചെയ്യുക. ഡയറക്ടറി ശൂന്യമായിരിക്കണം.

Path.symlink_to(ലക്ഷ്യം, target_is_directory=False)
ഈ പാത ഒരു പ്രതീകാത്മക ലിങ്ക് ആക്കുക ലക്ഷ്യം. വിൻഡോസിന് കീഴിൽ, target_is_directory ആവശമാകുന്നു
ശരിയായിരിക്കുക (സ്ഥിരസ്ഥിതി തെറ്റായ) ലിങ്കിന്റെ ലക്ഷ്യം ഒരു ഡയറക്ടറി ആണെങ്കിൽ. POSIX-ന് കീഴിൽ,
target_is_directoryയുടെ മൂല്യം അവഗണിക്കപ്പെടുന്നു.

>>> p = പാത('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(മോഡ്=0o777, exist_ok=True)
ഈ നൽകിയിരിക്കുന്ന പാതയിൽ ഒരു ഫയൽ സൃഷ്ടിക്കുക. എങ്കിൽ മോഡ് നൽകിയിരിക്കുന്നു, അതുമായി സംയോജിപ്പിച്ചിരിക്കുന്നു
പ്രക്രിയ' ഉമാസ്ക് ഫയൽ മോഡ് നിർണ്ണയിക്കുന്നതിനും ഫ്ലാഗുകൾ ആക്സസ് ചെയ്യുന്നതിനുമുള്ള മൂല്യം. ഫയൽ ആണെങ്കിൽ
ഇതിനകം നിലവിലുണ്ട്, എങ്കിൽ ഫംഗ്ഷൻ വിജയിക്കും നിലവിലുണ്ട്_ശരി ശരിയാണ് (അതിന്റെ പരിഷ്ക്കരണവും
സമയം നിലവിലെ സമയത്തേക്ക് അപ്ഡേറ്റ് ചെയ്യുന്നു), അല്ലെങ്കിൽ OSError ഉയർത്തിയിരിക്കുന്നു.

Path.unlink()
ഈ ഫയലോ പ്രതീകാത്മക ലിങ്കോ നീക്കം ചെയ്യുക. പാത ഒരു ഡയറക്‌ടറിയിലേക്ക് ചൂണ്ടിക്കാണിക്കുന്നുവെങ്കിൽ, ഉപയോഗിക്കുക
Path.rmdir() പകരം.

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് പാത്ത്‌ലിബ് ഓൺലൈനായി ഉപയോഗിക്കുക