pathlib - מקוון בענן

תָכְנִית:

שֵׁם

pathlib - pathlib תיעוד

מניפולציה של נתיבים של מערכת קבצים כאובייקטי מחרוזת יכולה להפוך במהירות למסורבלת: מרובה
קורא ל os.path.join () or os.path.dirname()וכו'. מודול זה מציע קבוצה של שיעורים
כולל את כל הפעולות הנפוצות בנתיבים בצורה קלה ומונחה עצמים.

מומלץ להשתמש במודול זה עם Python 3.2 ואילך, אך הוא גם תואם לפיתון
2.7.

הערה:
מודול זה היה כלול בספרייה הסטנדרטית של Python 3.4 לאחר זריזות 428
קַבָּלָה. אתה רק צריך להתקין אותו עבור Python 3.3 ומעלה.

לִרְאוֹת גַם:
זריזות 428: נימוק לעיצוב ה-pathlib הסופי ול-API.

DOWNLOAD

מהדורות עצמאיות זמינות ב- PyPI: http://pypi.python.org/pypi/pathlib/

הפיתוח העיקרי מתרחש כעת בספריית התקן Python: ראה את פיתון
מפתחים מדריך.

ניתן למצוא את מאגר התחזוקה עבור מודול יציאות אחורי עצמאי זה ב-BitBucket,
אך הפעילות צפויה להיות נמוכה למדי: https://bitbucket.org/pitrou/pathlib/

רמה גבוהה נוף

מודול זה מציע מחלקות המייצגות נתיבים של מערכת קבצים עם סמנטיקה המתאימה
מערכות הפעלה שונות. כיתות נתיב מחולקות בין טהור שבילים, המספקים
פעולות חישוביות בלבד ללא קלט/פלט, ו בטון שבילים, היורשים מטהור
נתיבים אלא גם מספקים פעולות קלט/פלט. [תמונה]

אם מעולם לא השתמשת במודול זה בעבר או פשוט אינך בטוח איזו מחלקה מתאימה לך
מְשִׁימָה, נתיב סביר להניח שזה מה שאתה צריך. זה מייצר א בטון נתיב עבור הפלטפורמה
הקוד פועל.

נתיבים טהורים שימושיים במקרים מיוחדים מסוימים; לדוגמה:

1. אם ברצונך לבצע מניפולציות בנתיבי Windows במחשב יוניקס (או להיפך). אתה לא יכול
להזדהות א WindowsPath כאשר פועל על יוניקס, אבל אתה יכול ליצור מופע
PureWindowsPath.

2. אתה רוצה לוודא שהקוד שלך מפעיל רק נתיבים מבלי לגשת בפועל
מערכת ההפעלה. במקרה זה, מופע אחד מהשיעורים הטהורים עשוי להיות שימושי מאז אלה
פשוט אין לך פעולות הנגישות למערכת ההפעלה.

בסיסי להשתמש

ייבוא ​​מחלקות המודול:

>>> מיבוא pathlib *

ספריות משנה של רישום:

>>> p = Path('.')
>>> [x עבור x ב-p.iterdir() אם x.is_dir()]
[PosixPath('.hg'), PosixPath('docs'), PosixPath('dist'),
PosixPath('__pycache__'), PosixPath('build')]

רישום קובצי מקור של Python בעץ ספריות זה:

>>> 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('/וכו')
>>> q = p / 'init.d' / 'אתחול מחדש'
>>> ש
PosixPath('/etc/init.d/reboot')
>>> q.resolve()
PosixPath('/etc/rc.d/init.d/halt')

שאילתת מאפייני נתיב:

>>> q.exists()
נָכוֹן
>>> q.is_dir()
לא נכון

פתיחת קובץ:

>>> עם q.open() בתור f: f.readline()
...
'#!/ bin / bash\n'

טָהוֹר שבילים

אובייקטי נתיב טהורים מספקים פעולות טיפול בנתיב שאינן ניגשות למעשה ל- a
מערכת קבצים. ישנן שלוש דרכים לגשת לשיעורים הללו, שאנו קוראים להם גם טעמים:

בכיתה pathlib.PurePath(*pathsegments)
מחלקה גנרית המייצגת את הטעם של הנתיב של המערכת (אם היא יוצרת
או א PurePosixPath או PureWindowsPath):

>>> PurePath('setup.py') # פועל על מחשב יוניקס
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')

עם זאת, בנתיב של 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'), וזה לא בסדר אם Foo מהווה קישור סמלי לאחר
מַדרִיך)

בכיתה pathlib.PurePosixPath(*pathsegments)
תת -סוג של PurePath, טעם נתיב זה מייצג נתיבים שאינם של מערכת הקבצים של Windows:

>>> PurePosixPath('/וכו')
PurePosixPath('/וכו')

מקטעי נתיב מצוין בדומה ל PurePath.

בכיתה pathlib.PureWindowsPath(*pathsegments)
תת -סוג של PurePath, טעם נתיב זה מייצג נתיבים של מערכת הקבצים של Windows:

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

מקטעי נתיב מצוין בדומה ל PurePath.

ללא קשר למערכת שבה אתה פועל, אתה יכול ליצור מופע של כל השיעורים האלה,
מכיוון שהם לא מספקים שום פעולה שמבצעת שיחות מערכת.

כללי נכסים
הנתיבים אינם ניתנים לשינוי וניתנים לגיבוש. נתיבים של אותו טעם ניתנים להשוואה וניתנים להזמנה.
מאפיינים אלה מכבדים את הסמנטיקה של קיפול המארז של הטעם:

>>> PurePosixPath('foo') == PurePosixPath('FOO')
לא נכון
>>> PureWindowsPath('foo') == PureWindowsPath('FOO')
נָכוֹן
>>> PureWindowsPath('FOO') ב- { PureWindowsPath('foo') }
נָכוֹן
>>> PureWindowsPath('C:') < PureWindowsPath('d:')
נָכוֹן

נתיבים של טעם שונה משתווים לא שווים ולא ניתן להזמין:

>>> PureWindowsPath('foo') == PurePosixPath('foo')
לא נכון
>>> PureWindowsPath('foo') < PurePosixPath('foo')
Traceback (השיחה האחרונה אחרונה):
קובץ " ", שורה 1, ב
TypeError: סוגים לא ניתנים לסדר: PureWindowsPath() < PurePosixPath()

מפעילים
אופרטור הלוכסן עוזר ליצור נתיבים צאצאים, בדומה ל os.path.join:

>>> p = PurePath('/וכו')
>>> עמ'
PurePosixPath('/וכו')
>>> p / 'init.d' / 'apache2'
PurePosixPath('/etc/init.d/apache2')
>>> q = PurePath('bin')
>>> '/ usr' / ש
PurePosixPath('/ usr / bin')

ייצוג המחרוזת של נתיב הוא נתיב מערכת הקבצים הגולמי עצמו (בצורה מקורית,
למשל עם קווים אחוריים תחת Windows), אותם אתה יכול להעביר לכל פונקציה שלוקחת קובץ
נתיב כמחרוזת:

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

באופן דומה, מתקשר בתים on a path נותן את הנתיב של מערכת הקבצים הגולמית כאובייקט בתים, as
מקודד על ידי 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:\\', 'Program Files', 'PSF')

(שים לב כיצד הכונן והשורש המקומי מקובצים מחדש בחלק אחד)

שיטות ו נכסים
נתיבים טהורים מספקים את השיטות והמאפיינים הבאים:

PurePath.drive
מחרוזת המייצגת את אות הכונן או את השם, אם יש:

>>> PureWindowsPath('c:/Program Files/').כונן
'c:'
>>> PureWindowsPath('/Program Files/').כונן
''
>>> 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
'c:'
>>> 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.הורה
PurePosixPath('/a/b/c')

אתה לא יכול לעבור על פני עוגן או נתיב ריק:

>>> p = PurePosixPath('/')
>>> p.הורה
PurePosixPath('/')
>>> p = PurePosixPath('.')
>>> p.הורה
PurePosixPath('.')

הערה:
זוהי פעולה מילונית בלבד, ומכאן ההתנהגות הבאה:

>>> p = PurePosixPath('foo/..')
>>> p.הורה
PurePosixPath('foo')

אם אתה רוצה ללכת בנתיב שרירותי של מערכת קבצים כלפי מעלה, מומלץ לעשות זאת
שיחה ראשונה Path.resolve() כדי לפתור סימלינקים ולחסל ".."
רכיבים.

PurePath.name
מחרוזת המייצגת את רכיב הנתיב הסופי, למעט הכונן והשורש, if
כל:

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

שמות כונני UNC אינם נחשבים:

>>> PureWindowsPath('//some/share/setup.py').name
'setup.py'
>>> PureWindowsPath('//some/share').שם
''

PurePath.suffix
סיומת הקובץ של הרכיב הסופי, אם בכלל:

>>> PurePosixPath('my/library/setup.py'). סיומת
'.py'
>>> PurePosixPath('my/library.tar.gz'). סיומת
'.gz'
>>> PurePosixPath('my/library').suffix
''

PurePath.suffixes
רשימה של סיומות הקבצים של הנתיב:

>>> PurePosixPath('my/library.tar.gar').סיומות
['.tar', '.gar']
>>> PurePosixPath('my/library.tar.gz').סיומות
['.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)
'c:\\windows'
>>> p.as_posix()
'c:/windows'

PurePath.as_uri()
ייצג את הנתיב בתור א פילה סוּג. ValueError מועלה אם הנתיב אינו מוחלט.

>>> p = PurePosixPath('/ etc / passwd')
>>> p.as_uri()
'קוֹבֶץ:/// 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, לחזור נָכוֹן אם הנתיב נחשב שמור תחת Windows,
לא נכון אחרת. עם PurePosixPath, לא נכון מוחזר תמיד.

>>> PureWindowsPath('nul').is_reserved()
נָכוֹן
>>> PurePosixPath('nul').is_reserved()
לא נכון

קריאות למערכת הקבצים בנתיבים שמורים עלולות להיכשל באופן מסתורי או לא מכוונות
אפקטים.

PurePath.joinpath(*other)
קריאה לשיטה זו שווה ערך לשילוב הנתיב עם כל אחד מה- אַחֵר
טיעונים בתורם:

>>> 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(pattern)
התאימו את הנתיב הזה לתבנית שסופקה בסגנון גלוב. לַחֲזוֹר נָכוֹן אם תואמים
מצליח, לא נכון אחרת.

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')
Traceback (השיחה האחרונה אחרונה):
קובץ " ", שורה 1, ב
קובץ "pathlib.py", שורה 694, ב-relative_to
.format(str(self), str(formatted)))
ValueError: '/ etc / passwd' לא מתחיל ב'/ usr'

PurePath.with_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 (השיחה האחרונה אחרונה):
קובץ " ", שורה 1, ב
קובץ "/home/antoine/cpython/default/Lib/pathlib.py", שורה 751, ב-with_name
raise ValueError("ל%r יש שם ריק" % (עצמי,))
ValueError: ל-PureWindowsPath('c:/') יש שם ריק

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

קונקרטית שבילים

שבילי בטון הם תת-מחלקות של מחלקות הנתיבים הטהורים. בנוסף לפעולות
המסופקים על ידי האחרונים, הם גם מספקים שיטות לבצע קריאות מערכת על אובייקטי נתיב.
ישנן שלוש דרכים ליצור נתיבים בטון:

בכיתה pathlib.Path(*pathsegments)
תת -סוג של PurePath, מחלקה זו מייצגת נתיבים קונקרטיים של נתיב המערכת
טעם (הדגמה שלו יוצרת או א PosixPath או WindowsPath):

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

מקטעי נתיב מצוין בדומה ל PurePath.

בכיתה pathlib.PosixPath(*pathsegments)
תת -סוג של נתיב ו PurePosixPath, מחלקה זו מייצגת בטון שאינה Windows
נתיבים של מערכת הקבצים:

>>> PosixPath('/וכו')
PosixPath('/וכו')

מקטעי נתיב מצוין בדומה ל PurePath.

בכיתה pathlib.WindowsPath(*pathsegments)
תת -סוג של נתיב ו PureWindowsPath, מחלקה זו מייצגת חלונות בטון
נתיבים של מערכת הקבצים:

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

מקטעי נתיב מצוין בדומה ל PurePath.

אתה יכול רק ליצור מופע של טעם הכיתה המתאים למערכת שלך (מה שמאפשר
קריאות מערכת בטעמים לא תואמים של נתיב עלולות להוביל לבאגים או לכשלים שלך
יישום):

>>> ייבוא ​​מערכת הפעלה
>>> os.name
'פוזיקס'
>>> Path('setup.py')
PosixPath('setup.py')
>>> PosixPath('setup.py')
PosixPath('setup.py')
>>> WindowsPath('setup.py')
Traceback (השיחה האחרונה אחרונה):
קובץ " ", שורה 1, ב
קובץ "pathlib.py", שורה 798, ב-__new__
% (cls.__name__,))
NotImplementedError: אין אפשרות ליצור 'WindowsPath' במערכת שלך

שיטות
שבילי בטון מספקים את השיטות הבאות בנוסף לשיטות שבילים טהורים. הרבה מ
שיטות אלה יכולות להעלות א OSError אם קריאת מערכת נכשלת (לדוגמה בגלל הנתיב
לא קיים):

שיטת כיתה Path.cwd()
החזר אובייקט נתיב חדש המייצג את הספרייה הנוכחית (כפי שהוחזר על ידי
os.getcwd ()):

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

Path.stat()
החזר מידע על נתיב זה (בדומה ל os.stat ()). התוצאה נראית
בכל קריאה לשיטה זו.

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

Path.chmod(מצב)
שנה את מצב הקובץ וההרשאות, כמו os.chmod():

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

Path.exists()
האם הנתיב מצביע לקובץ או ספרייה קיימים:

>>> מיבוא pathlib *
>>> Path('.').exists()
נָכוֹן
>>> Path('setup.py').exists()
נָכוֹן
>>> נתיב('/וכו').קיים()
נָכוֹן
>>> Path('nonexistentfile').exists()
לא נכון

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()
החזר את שם הקבוצה שבבעלותה הקובץ. שגיאת מפתח מועלה אם הקובץ הוא gid
לא נמצא במסד הנתונים של המערכת.

Path.is_dir()
לחזור נָכוֹן אם הנתיב מצביע על ספרייה (או קישור סמלי המצביע על א
מַדרִיך), לא נכון אם זה מצביע על סוג אחר של קובץ.

לא נכון מוחזר גם אם הנתיב לא קיים או שהוא קישור סימלי שבור; אַחֵר
שגיאות (כגון שגיאות הרשאה) מופצות.

Path.is_file()
לחזור נָכוֹן אם הנתיב מצביע על קובץ רגיל (או קישור סמלי המצביע על א
קובץ רגיל), לא נכון אם זה מצביע על סוג אחר של קובץ.

לא נכון מוחזר גם אם הנתיב לא קיים או שהוא קישור סימלי שבור; אַחֵר
שגיאות (כגון שגיאות הרשאה) מופצות.

Path.is_symlink()
לחזור נָכוֹן אם הנתיב מצביע על קישור סמלי, לא נכון אחרת.

לא נכון מוחזר גם אם הנתיב לא קיים; שגיאות אחרות (כגון הרשאה
שגיאות) מופצות.

Path.is_socket()
לחזור נָכוֹן אם הנתיב מצביע על שקע יוניקס (או קישור סמלי המצביע על a
שקע יוניקס), לא נכון אם זה מצביע על סוג אחר של קובץ.

לא נכון מוחזר גם אם הנתיב לא קיים או שהוא קישור סימלי שבור; אַחֵר
שגיאות (כגון שגיאות הרשאה) מופצות.

Path.is_fifo()
לחזור נָכוֹן אם הנתיב מצביע על FIFO (או קישור סמלי המצביע על FIFO),
לא נכון אם זה מצביע על סוג אחר של קובץ.

לא נכון מוחזר גם אם הנתיב לא קיים או שהוא קישור סימלי שבור; אַחֵר
שגיאות (כגון שגיאות הרשאה) מופצות.

Path.is_block_device()
לחזור נָכוֹן אם הנתיב מצביע על התקן בלוק (או קישור סמלי המצביע על א
חסימת מכשיר), לא נכון אם זה מצביע על סוג אחר של קובץ.

לא נכון מוחזר גם אם הנתיב לא קיים או שהוא קישור סימלי שבור; אַחֵר
שגיאות (כגון שגיאות הרשאה) מופצות.

Path.is_char_device()
לחזור נָכוֹן אם הנתיב מצביע על התקן תו (או קישור סמלי המצביע
למכשיר תו), לא נכון אם זה מצביע על סוג אחר של קובץ.

לא נכון מוחזר גם אם הנתיב לא קיים או שהוא קישור סימלי שבור; אַחֵר
שגיאות (כגון שגיאות הרשאה) מופצות.

Path.iterdir()
כאשר הנתיב מצביע על ספרייה, הפק אובייקטי נתיב של תוכן הספרייה:

>>> p = Path('docs')
>>> עבור ילד ב-p.iterdir(): ילד
...
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(מצב)
כמו Path.chmod() אבל, אם הנתיב מצביע על קישור סמלי, הקישור הסימבולי
המצב משתנה ולא של היעד שלו.

Path.lstat()
כמו Path.stat() אבל, אם הנתיב מצביע על קישור סמלי, החזר את הסמל
המידע של הקישור ולא של היעד שלו.

Path.mkdir(mode=0o777, הורים=שקר)
צור ספרייה חדשה בנתיב נתון זה. אם מצב ניתן, הוא משולב עם
התהליך' אומסק ערך כדי לקבוע את מצב הקובץ ודגלי הגישה. אם השביל
כבר קיים, OSError מורם.

If הורים נכון, כל הורים חסרים של הנתיב הזה נוצרים לפי הצורך; הֵם
נוצרים עם הרשאות ברירת המחדל מבלי לקחת מצב בחשבון
(מחקה את ה-POSIX mkdir -p פקודה).

If הורים הוא שקר (ברירת המחדל), הורה חסר מעלה OSError.

Path.open(mode='r', חציצה=-1, קידוד=אין, errors=אין, newline=אין)
פתח את הקובץ שעליו מצביע הנתיב, כמו המובנה לִפְתוֹחַ() הפונקציה עושה:

>>> p = Path('setup.py')
>>> עם p.open() בתור f:
... f.readline()
...
'#!/usr/bin/env python3\n'

Path.owner()
החזר את שם המשתמש בעל הקובץ. שגיאת מפתח מועלה אם הקובץ uid
לא נמצא במסד הנתונים של המערכת.

Path.rename(target)
שנה את שם הקובץ או הספרייה לנתונים יעד. יעד יכול להיות מחרוזת
או אובייקט נתיב אחר:

>>> p = Path('foo')
>>> p.open('w').write('some text')
9
>>> target = Path('bar')
>>> p.rename(target)
>>> target.open().read()
'קצת טקסט'

Path.replace(target)
שנה את שם הקובץ או הספרייה לנתונים יעד. אם יעד מצביע על קיים
קובץ או ספרייה, הם יוחלפו ללא תנאי.

שיטה זו זמינה רק עם Python 3.3; זה יעלה NotImplementedError on
גרסאות פייתון קודמות.

Path.resolve()
הפוך את הנתיב למוחלט, פתרון כל סימלינקים. מוחזר אובייקט נתיב חדש:

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

".." רכיבים גם בוטלו (זו השיטה היחידה לעשות זאת):

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

אם הנתיב לא קיים, א OSError מורם. אם לולאה אינסופית היא
נתקלו בנתיב הפתרון, RuntimeError מורם.

Path.rglob(pattern)
זה כמו להתקשר גלוב () עם "**" הוסיף לפני הנתון דפוס:

>>> 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.symlink_to(target, target_is_directory=False)
הפוך את הנתיב הזה לקישור סמלי אליו יעד. תחת Windows, target_is_directory צריך
להיות אמיתי (ברירת מחדל לא נכון) אם היעד של הקישור הוא ספרייה. תחת 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=0o777, exist_ok=true)
צור קובץ בנתיב הנתון הזה. אם מצב ניתן, הוא משולב עם
תהליך' אומסק ערך כדי לקבוע את מצב הקובץ ודגלי הגישה. אם הקובץ
כבר קיימת, הפונקציה מצליחה אם קיים_בסדר נכון (והשינוי שלו
השעה מתעדכנת לשעה הנוכחית), אחרת OSError מורם.

Path.unlink()
הסר את הקובץ או הקישור הסמלי הזה. אם הנתיב מצביע על ספרייה, השתמש
Path.rmdir() במקום.

השתמש ב-pathlib באינטרנט באמצעות שירותי onworks.net