> **Источник:** https://python-all.ru/3.8/library/pathlib.html
>
> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.

---

# [`pathlib`](https://python-all.ru/3.8/library/pathlib.html#module-pathlib) – Объектно-ориентированные пути файловой системы

Новое в версии 3.4.

**Исходный код:** [Lib/pathlib.py](https://python-all.ru/src/3.8/Lib/pathlib.py)

---

Этот модуль предоставляет классы, представляющие пути файловой системы с семантикой, подходящей для разных операционных систем. Классы путей делятся на [чистые пути](https://python-all.ru/3.8/library/pathlib.html#pure-paths), которые выполняют только вычислительные операции без ввода-вывода, и [конкретные пути](https://python-all.ru/3.8/library/pathlib.html#concrete-paths), которые наследуют чистые пути, но также предоставляют операции ввода-вывода.

![../_images/pathlib-inheritance.png](https://python-all.ru/3.8/_images/pathlib-inheritance.png)

Если вы никогда не пользовались этим модулем раньше или просто не уверены, какой класс подходит для вашей задачи, скорее всего, вам нужен [`Path`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path). Он создаёт экземпляр [конкретного пути](https://python-all.ru/3.8/library/pathlib.html#concrete-paths) для платформы, на которой выполняется код.

Чистые пути полезны в некоторых особых случаях; например:

1. Если требуется манипулировать путями Windows на машине Unix (или наоборот). При работе на Unix нельзя создать экземпляр [`WindowsPath`](https://python-all.ru/3.8/library/pathlib.html#pathlib.WindowsPath), но можно создать [`PureWindowsPath`](https://python-all.ru/3.8/library/pathlib.html#pathlib.PureWindowsPath).
2. Если нужно, чтобы код только манипулировал путями без фактического обращения к ОС. В таком случае может быть полезно создать экземпляр одного из чистых классов, поскольку они просто не имеют операций доступа к ОС.

> **См. также**
>
> [**PEP 428**](https://python-all.ru/3.8/library/pathlib.html): модуль pathlib – объектно-ориентированные пути файловой системы.

> **См. также**
>
> Для низкоуровневых манипуляций с путями в виде строк можно также использовать модуль [`os.path`](https://python-all.ru/3.8/library/os.path.html#module-os.path).

## Основное использование

Импорт основного класса:

```python
>>> from pathlib import Path
```

Список подкаталогов:

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

Список исходных файлов Python в этом дереве каталогов:

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

Навигация по дереву каталогов:

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

Запрос свойств пути:

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

Открытие файла:

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

## Чистые пути

Объекты чистых путей предоставляют операции обработки путей, которые не обращаются к файловой системе. Существует три способа доступа к этим классам, которые также называются *разновидностями*:

#### `class pathlib.PurePath(*pathsegments)`

Общий класс, представляющий разновидность пути системы (при создании экземпляра создаётся либо [`PurePosixPath`](https://python-all.ru/3.8/library/pathlib.html#pathlib.PurePosixPath), либо [`PureWindowsPath`](https://python-all.ru/3.8/library/pathlib.html#pathlib.PureWindowsPath)):

```python
>>> PurePath('setup.py')      # Запуск на Unix-машине
PurePosixPath('setup.py')
```

Каждый элемент *pathsegments* может быть строкой, представляющей сегмент пути, объектом, реализующим интерфейс [`os.PathLike`](https://python-all.ru/3.8/library/os.html#os.PathLike), который возвращает строку, или другим объектом пути:

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

Когда *pathsegments* пуст, подразумевается текущий каталог:

```python
>>> PurePath()
PurePosixPath('.')
```

Когда передано несколько абсолютных путей, последний используется как привязка (по аналогии с поведением [`os.path.join()`](https://python-all.ru/3.8/library/os.path.html#os.path.join)):

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

Однако в пути Windows смена локального корня не отбрасывает предыдущую настройку диска:

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

Лишние косые черты и одиночные точки схлопываются, но двойные точки (`'..'`) – нет, так как это изменило бы смысл пути при наличии символических ссылок:

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

(наивный подход сделал бы `PurePosixPath('foo/../bar')` эквивалентным `PurePosixPath('bar')`, что неверно, если `foo` является символической ссылкой на другой каталог)

Объекты чистых путей реализуют интерфейс [`os.PathLike`](https://python-all.ru/3.8/library/os.html#os.PathLike), что позволяет использовать их везде, где этот интерфейс принимается.

Изменено в версии 3.6: Добавлена поддержка интерфейса [`os.PathLike`](https://python-all.ru/3.8/library/os.html#os.PathLike).

#### `class pathlib.PurePosixPath(*pathsegments)`

Подкласс [`PurePath`](https://python-all.ru/3.8/library/pathlib.html#pathlib.PurePath), эта разновидность путей представляет пути файловой системы, отличные от Windows:

```python
>>> PurePosixPath('/etc')
PurePosixPath('/etc')
```

Параметр *pathsegments* задаётся так же, как [`PurePath`](https://python-all.ru/3.8/library/pathlib.html#pathlib.PurePath).

#### `class pathlib.PureWindowsPath(*pathsegments)`

Подкласс [`PurePath`](https://python-all.ru/3.8/library/pathlib.html#pathlib.PurePath), этот вариант пути представляет пути файловой системы Windows:

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

Параметр *pathsegments* задаётся так же, как [`PurePath`](https://python-all.ru/3.8/library/pathlib.html#pathlib.PurePath).

Независимо от используемой системы можно создавать экземпляры всех этих классов, поскольку они не предоставляют никаких операций, совершающих системные вызовы.

### Общие свойства

Пути неизменяемы и хешируемы. Пути одного варианта сравнимы и упорядочиваемы. Эти свойства учитывают семантику регистрозависимости данного варианта:

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

Пути разных разновидностей неравны и не упорядочиваются:

```python
>>> 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()`](https://python-all.ru/3.8/library/os.path.html#os.path.join):

```python
>>> 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`](https://python-all.ru/3.8/library/os.html#os.PathLike):

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

Строковое представление пути – это сам сырой путь файловой системы (в нативном виде, например с обратными слешами в Windows), который можно передать любой функции, принимающей путь к файлу в виде строки:

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

Аналогично, вызов [`bytes`](https://python-all.ru/3.8/library/stdtypes.html#bytes) для пути возвращает сырой путь файловой системы в виде объекта bytes, закодированный с помощью [`os.fsencode()`](https://python-all.ru/3.8/library/os.html#os.fsencode):

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

> **Примечание**
>
> Вызов [`bytes`](https://python-all.ru/3.8/library/stdtypes.html#bytes) рекомендуется только в Unix. В Windows форма Unicode является каноническим представлением путей файловой системы.

### Доступ к отдельным частям

Для доступа к отдельным «частям» (компонентам) пути используйте следующее свойство:

#### `PurePath.parts`

Кортеж, предоставляющий доступ к различным компонентам пути:

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

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

(обратите внимание, как диск и локальный корень объединены в одну часть)

### Методы и свойства

Чистые пути предоставляют следующие методы и свойства:

#### `PurePath.drive`

Строка, представляющая букву или имя диска, если таковой имеется:

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

UNC-ресурсы также считаются дисками:

```python
>>> PureWindowsPath('//host/share/foo.txt').drive
'\\\\host\\share'
```

#### `PurePath.root`

Строка, представляющая (локальный или глобальный) корень, если таковой имеется:

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

UNC-ресурсы всегда имеют корень:

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

#### `PurePath.anchor`

Объединение диска и корневого каталога:

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

#### `PurePath.parents`

Неизменяемая последовательность, обеспечивающая доступ к логическим предкам пути:

```python
>>> 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`

Логический родитель пути:

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

Нельзя выйти за пределы anchor или пустого пути:

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

> **Примечание**
>
> Это чисто лексическая операция, поэтому поведение следующее:
>
> ```python
> >>> p = PurePosixPath('foo/..')
> >>> p.parent
> PurePosixPath('foo')
> ```
>
> Если нужно подняться вверх по произвольному пути файловой системы, рекомендуется сначала вызвать [`Path.resolve()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.resolve), чтобы разрешить символические ссылки и убрать компоненты *“..”*.

#### `PurePath.name`

Строка, представляющая последний компонент пути, исключая диск и корневой каталог (если они есть):

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

UNC-имена дисков не учитываются:

```python
>>> PureWindowsPath('//some/share/setup.py').name
'setup.py'
>>> PureWindowsPath('//some/share').name
''
```

#### `PurePath.suffix`

Расширение файла последнего компонента, если таковое имеется:

```python
>>> PurePosixPath('my/library/setup.py').suffix
'.py'
>>> PurePosixPath('my/library.tar.gz').suffix
'.gz'
>>> PurePosixPath('my/library').suffix
''
```

#### `PurePath.suffixes`

Список расширений файлов пути:

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

#### `PurePath.stem`

Последний компонент пути без суффикса:

```python
>>> PurePosixPath('my/library.tar.gz').stem
'library.tar'
>>> PurePosixPath('my/library.tar').stem
'library'
>>> PurePosixPath('my/library').stem
'library'
```

#### `PurePath.as_posix()`

Возвращает строковое представление пути с прямыми слэшами (`/`):

```python
>>> p = PureWindowsPath('c:\\windows')
>>> str(p)
'c:\\windows'
>>> p.as_posix()
'c:/windows'
```

#### `PurePath.as_uri()`

Представляет путь в виде `file` URI. [`ValueError`](https://python-all.ru/3.8/library/exceptions.html#ValueError) возбуждается, если путь не является абсолютным.

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

#### `PurePath.is_absolute()`

Возвращает, является ли путь абсолютным. Путь считается абсолютным, если у него есть и корень, и (если это допускает разновидность) диск:

```python
>>> 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`](https://python-all.ru/3.8/library/pathlib.html#pathlib.PureWindowsPath) возвращает `True`, если путь считается зарезервированным в Windows, иначе `False`. С [`PurePosixPath`](https://python-all.ru/3.8/library/pathlib.html#pathlib.PurePosixPath) всегда возвращается `False`.

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

Вызовы файловой системы для зарезервированных путей могут приводить к неожиданным ошибкам или непредвиденным последствиям.

#### `PurePath.joinpath(*other)`

Вызов этого метода эквивалентен последовательному объединению пути с каждым из аргументов *other*:

```python
>>> 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)`

Сопоставляет этот путь с предоставленным шаблоном в стиле glob. Возвращает `True` в случае успешного сопоставления, иначе `False`.

Если *pattern* является относительным, путь может быть как относительным, так и абсолютным, и сопоставление выполняется с правого конца:

```python
>>> 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
```

Если *pattern* является абсолютным, путь должен быть абсолютным, и должен совпадать весь путь:

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

Как и в других методах, чувствительность к регистру определяется по умолчанию платформой:

```python
>>> PurePosixPath('b.py').match('*.PY')
False
>>> PureWindowsPath('b.py').match('*.PY')
True
```

#### `PurePath.relative_to(*other)`

Вычисляет версию этого пути относительно пути, представленного *other*. Если это невозможно, возбуждается ValueError:

```python
>>> 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`](https://python-all.ru/3.8/library/pathlib.html#pathlib.PurePath.name). Если у исходного пути нет имени, вызывается ValueError:

```python
>>> 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`](https://python-all.ru/3.8/library/pathlib.html#pathlib.PurePath.suffix). Если у исходного пути нет суффикса, вместо него добавляется новый *suffix*. Если *suffix* – пустая строка, исходный суффикс удаляется:

```python
>>> 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`](https://python-all.ru/3.8/library/pathlib.html#pathlib.PurePath); этот класс представляет конкретные пути, соответствующие flavour данной файловой системы (при создании экземпляра создаётся либо [`PosixPath`](https://python-all.ru/3.8/library/pathlib.html#pathlib.PosixPath), либо [`WindowsPath`](https://python-all.ru/3.8/library/pathlib.html#pathlib.WindowsPath)):

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

Параметр *pathsegments* задаётся так же, как [`PurePath`](https://python-all.ru/3.8/library/pathlib.html#pathlib.PurePath).

#### `class pathlib.PosixPath(*pathsegments)`

Подкласс [`Path`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path) и [`PurePosixPath`](https://python-all.ru/3.8/library/pathlib.html#pathlib.PurePosixPath); этот класс представляет конкретные пути для файловых систем, отличных от Windows:

```python
>>> PosixPath('/etc')
PosixPath('/etc')
```

Параметр *pathsegments* задаётся так же, как [`PurePath`](https://python-all.ru/3.8/library/pathlib.html#pathlib.PurePath).

#### `class pathlib.WindowsPath(*pathsegments)`

Подкласс [`Path`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path) и [`PureWindowsPath`](https://python-all.ru/3.8/library/pathlib.html#pathlib.PureWindowsPath); этот класс представляет конкретные пути файловой системы Windows:

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

Параметр *pathsegments* задаётся так же, как [`PurePath`](https://python-all.ru/3.8/library/pathlib.html#pathlib.PurePath).

Можно создать экземпляр только того flavour класса, который соответствует системе (использование системных вызовов для несовместимых flavour путей может привести к ошибкам или сбоям в приложении):

```python
>>> 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`](https://python-all.ru/3.8/library/exceptions.html#OSError), если системный вызов завершается неудачей (например, из-за того, что путь не существует).

Изменено в версии 3.8: Методы [`exists()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.exists), [`is_dir()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.is_dir), [`is_file()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.is_file), [`is_mount()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.is_mount), [`is_symlink()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.is_symlink), [`is_block_device()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.is_block_device), [`is_char_device()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.is_char_device), [`is_fifo()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.is_fifo), [`is_socket()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.is_socket) теперь возвращают `False` вместо возбуждения исключения для путей, содержащих символы, непредставимые на уровне ОС.

#### `classmethod Path.cwd()`

Возвращает новый объект пути, представляющий текущий каталог (как возвращается [`os.getcwd()`](https://python-all.ru/3.8/library/os.html#os.getcwd)):

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

#### `classmethod Path.home()`

Возвращает новый объект пути, представляющий домашний каталог пользователя (как возвращается [`os.path.expanduser()`](https://python-all.ru/3.8/library/os.path.html#os.path.expanduser) с конструкцией `~`):

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

Новое в версии 3.5.

#### `Path.stat()`

Возвращает объект [`os.stat_result`](https://python-all.ru/3.8/library/os.html#os.stat_result), содержащий информацию об этом пути, например [`os.stat()`](https://python-all.ru/3.8/library/os.html#os.stat). Результат запрашивается при каждом вызове этого метода.

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

#### `Path.chmod(mode)`

Изменяет режим файла и права доступа, как [`os.chmod()`](https://python-all.ru/3.8/library/os.html#os.chmod):

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

#### `Path.exists()`

Указывает ли путь на существующий файл или каталог:

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

> **Примечание**
>
> Если путь указывает на символическую ссылку, [`exists()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.exists) возвращает, *указывает ли* симлинк на существующий файл или каталог.

#### `Path.expanduser()`

Возвращает новый путь с развёрнутыми конструкциями `~` и `~user`, как возвращается функцией [`os.path.expanduser()`](https://python-all.ru/3.8/library/os.path.html#os.path.expanduser):

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

Новое в версии 3.5.

#### `Path.glob(pattern)`

Выполняет поиск по заданному относительному *pattern* в каталоге, представленном этим путем, возвращая все совпадающие файлы (любого типа):

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

Шаблон «`**`» означает «этот каталог и все его подкаталоги рекурсивно». Другими словами, он включает рекурсивный поиск по шаблону:

```python
>>> 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`](https://python-all.ru/3.8/library/exceptions.html#KeyError) вызывается, если gid файла не найден в системной базе данных.

#### `Path.is_dir()`

Возвращает `True`, если путь указывает на каталог (или символическую ссылку на каталог), и `False`, если указывает на файл другого типа.

`False` также возвращается, если путь не существует или является битой символьной ссылкой; другие ошибки (например, ошибки прав доступа) передаются.

#### `Path.is_file()`

Возвращает `True`, если путь указывает на обычный файл (или символическую ссылку на обычный файл), и `False`, если указывает на файл другого типа.

`False` также возвращается, если путь не существует или является битой символьной ссылкой; другие ошибки (например, ошибки прав доступа) передаются.

#### `Path.is_mount()`

Возвращает `True`, если путь является *точкой монтирования*: точкой в файловой системе, куда смонтирована другая файловая система. На POSIX функция проверяет, находится ли родительский каталог *path*, `path/..`, на другом устройстве, чем *path*, или указывают ли `path/..` и *path* на один и тот же индексный дескриптор на одном устройстве – это должно определять точки монтирования для всех вариантов Unix и POSIX. Не реализовано в Windows.

Добавлено в версии 3.7.

#### `Path.is_symlink()`

Возвращает `True`, если путь указывает на символическую ссылку, иначе `False`.

`False` также возвращается, если путь не существует; другие ошибки (например, ошибки прав доступа) передаются дальше.

#### `Path.is_socket()`

Возвращает `True`, если путь указывает на сокет Unix (или на символическую ссылку, указывающую на сокет Unix), `False` если он указывает на файл другого типа.

`False` также возвращается, если путь не существует или является битой символьной ссылкой; другие ошибки (например, ошибки прав доступа) передаются.

#### `Path.is_fifo()`

Возвращает `True`, если путь указывает на FIFO (или на символическую ссылку, указывающую на FIFO), `False` если он указывает на файл другого типа.

`False` также возвращается, если путь не существует или является битой символьной ссылкой; другие ошибки (например, ошибки прав доступа) передаются.

#### `Path.is_block_device()`

Возвращает `True`, если путь указывает на блочное устройство (или на символическую ссылку, указывающую на блочное устройство), `False` если он указывает на файл другого типа.

`False` также возвращается, если путь не существует или является битой символьной ссылкой; другие ошибки (например, ошибки прав доступа) передаются.

#### `Path.is_char_device()`

Возвращает `True`, если путь указывает на символьное устройство (или на символическую ссылку, указывающую на символьное устройство), `False` если он указывает на файл другого типа.

`False` также возвращается, если путь не существует или является битой символьной ссылкой; другие ошибки (например, ошибки прав доступа) передаются.

#### `Path.iterdir()`

Если путь указывает на каталог, возвращает объекты пути для его содержимого:

```python
>>> 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()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.chmod), но если путь указывает на символьную ссылку, то изменяется режим самой символьной ссылки, а не её цели.

#### `Path.lstat()`

Как [`Path.stat()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.stat), но если путь указывает на симлинк, возвращает информацию о симлинке, а не о его цели.

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

Создаёт новый каталог по указанному пути. Если указан параметр *mode*, он комбинируется со значением `umask` процесса для определения режима файла и флагов доступа. Если путь уже существует, [`FileExistsError`](https://python-all.ru/3.8/library/exceptions.html#FileExistsError) вызывается.

Если *parents* равен true, любые отсутствующие родительские каталоги этого пути создаются по мере необходимости; они создаются с правами по умолчанию без учёта *mode* (имитируя команду POSIX `mkdir -p`).

Если *parents* равен false (по умолчанию), отсутствие родительского каталога вызывает [`FileNotFoundError`](https://python-all.ru/3.8/library/exceptions.html#FileNotFoundError).

Если *exist\_ok* равен false (по умолчанию), [`FileExistsError`](https://python-all.ru/3.8/library/exceptions.html#FileExistsError) возбуждается, если целевой каталог уже существует.

Если *exist\_ok* имеет значение true, [`FileExistsError`](https://python-all.ru/3.8/library/exceptions.html#FileExistsError) исключения будут проигнорированы (аналогично поведению команды POSIX `mkdir -p`), но только если последний компонент пути не является существующим файлом, отличным от каталога.

Изменено в версии 3.5: Добавлен параметр *exist\_ok*.

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

Открывает файл, на который указывает путь, как это делает встроенная функция [`open()`](https://python-all.ru/3.8/library/functions.html#open) :

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

#### `Path.owner()`

Возвращает имя пользователя-владельца файла. [`KeyError`](https://python-all.ru/3.8/library/exceptions.html#KeyError) вызывается, если uid файла не найден в системной базе данных.

#### `Path.read_bytes()`

Возвращает двоичное содержимое файла, на который указывает путь, в виде объекта bytes:

```python
>>> 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)`

Возвращает декодированное содержимое файла, на который указывает путь, в виде строки:

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

Файл открывается, а затем закрывается. Необязательные параметры имеют тот же смысл, что и в [`open()`](https://python-all.ru/3.8/library/functions.html#open).

Новое в версии 3.5.

#### `Path.rename(target)`

Переименовывает этот файл или каталог в указанный *target* и возвращает новый объект Path, указывающий на *target*. В Unix, если *target* существует и является файлом, он будет бесшумно заменён, если у пользователя есть права. *target* может быть как строкой, так и другим объектом пути:

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

Целевой путь может быть абсолютным или относительным. Относительные пути интерпретируются относительно текущей рабочей директории, а *не* директории объекта Path.

Изменено в версии 3.8: Добавлено возвращаемое значение – теперь возвращается новый экземпляр Path.

#### `Path.replace(target)`

Переименовывает этот файл или каталог в указанный *target* и возвращает новый экземпляр Path, указывающий на *target*. Если *target* указывает на существующий файл или каталог, он будет безусловно заменён.

Целевой путь может быть абсолютным или относительным. Относительные пути интерпретируются относительно текущей рабочей директории, а *не* директории объекта Path.

Изменено в версии 3.8: Добавлено возвращаемое значение – теперь возвращается новый экземпляр Path.

#### `Path.resolve(strict=False)`

Делает путь абсолютным, разрешая все символические ссылки. Возвращается новый объект пути:

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

“`..`” компоненты также удаляются (это единственный метод, который это делает):

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

Если путь не существует и *strict* равен `True`, возникает [`FileNotFoundError`](https://python-all.ru/3.8/library/exceptions.html#FileNotFoundError). Если *strict* равен `False`, путь разрешается настолько, насколько возможно, и остаток добавляется без проверки на существование. Если во время разрешения пути встречается бесконечный цикл, возникает [`RuntimeError`](https://python-all.ru/3.8/library/exceptions.html#RuntimeError).

Новое в версии 3.6: Аргумент *strict* (поведение до версии 3.6 – строгое).

#### `Path.rglob(pattern)`

Это аналогично вызову [`Path.glob()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.glob) с добавлением «`**/`» перед указанным относительным *pattern*:

```python
>>> 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)`

Возвращает, указывает ли этот путь на тот же файл, что и *other\_path*, который может быть как объектом Path, так и строкой. Семантика аналогична [`os.path.samefile()`](https://python-all.ru/3.8/library/os.path.html#os.path.samefile) и [`os.path.samestat()`](https://python-all.ru/3.8/library/os.path.html#os.path.samestat).

Исключение [`OSError`](https://python-all.ru/3.8/library/exceptions.html#OSError) может быть возбуждено, если какой-либо из файлов недоступен по какой-либо причине.

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

Новое в версии 3.5.

#### `Path.symlink_to(target, target_is_directory=False)`

Сделать этот путь символической ссылкой на *target*. В Windows *target\_is\_directory* должно иметь значение true (по умолчанию `False`), если цель ссылки является каталогом. В POSIX значение *target\_is\_directory* игнорируется.

```python
>>> 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()`](https://python-all.ru/3.8/library/os.html#os.symlink).

#### `Path.link_to(target)`

Создаёт жёсткую ссылку *target* на этот путь.

> **Предупреждение**
>
> Эта функция не создаёт жёсткую ссылку на *target* для данного пути, несмотря на название функции и имена аргументов. Порядок аргументов (target, link) обратен порядку в [`Path.symlink_to()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.symlink_to), но совпадает с порядком в [`os.link()`](https://python-all.ru/3.8/library/os.html#os.link).

Новое в версии 3.8.

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

Создаёт файл по указанному пути. Если задан *mode*, он комбинируется со значением `umask` процесса для определения режима файла и флагов доступа. Если файл уже существует, функция завершается успешно, если *exist\_ok* равен true (при этом время изменения файла обновляется до текущего), в противном случае вызывается исключение [`FileExistsError`](https://python-all.ru/3.8/library/exceptions.html#FileExistsError).

#### `Path.unlink(missing_ok=False)`

Удаляет этот файл или символическую ссылку. Если путь указывает на каталог, используйте [`Path.rmdir()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.rmdir).

Если *missing\_ok* равно false (по умолчанию), [`FileNotFoundError`](https://python-all.ru/3.8/library/exceptions.html#FileNotFoundError) вызывается, если путь не существует.

Если *missing\_ok* равно true, исключения [`FileNotFoundError`](https://python-all.ru/3.8/library/exceptions.html#FileNotFoundError) будут игнорироваться (аналогично поведению команды POSIX `rm -f`).

Изменено в версии 3.8: Добавлен параметр *missing\_ok*.

#### `Path.write_bytes(data)`

Открывает файл в байтовом режиме, записывает в него *data* и закрывает файл:

```python
>>> 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)`

Открывает файл в текстовом режиме, записывает в него *data* и закрывает файл:

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

Существующий файл с таким же именем перезаписывается. Необязательные параметры имеют тот же смысл, что и в [`open()`](https://python-all.ru/3.8/library/functions.html#open).

Новое в версии 3.5.

## Соответствие инструментам в модуле [`os`](https://python-all.ru/3.8/library/os.html#module-os)

Ниже представлена таблица, сопоставляющая различные функции [`os`](https://python-all.ru/3.8/library/os.html#module-os) с их эквивалентами в [`PurePath`](https://python-all.ru/3.8/library/pathlib.html#pathlib.PurePath)/[`Path`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path).

> **Примечание**
>
> Хотя [`os.path.relpath()`](https://python-all.ru/3.8/library/os.path.html#os.path.relpath) и [`PurePath.relative_to()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.PurePath.relative_to) имеют некоторые пересекающиеся случаи использования, их семантика различается настолько, что не позволяет считать их эквивалентными.

| os and os.path | pathlib |
| --- | --- |
| [`os.path.abspath()`](https://python-all.ru/3.8/library/os.path.html#os.path.abspath) | [`Path.resolve()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.resolve) |
| [`os.chmod()`](https://python-all.ru/3.8/library/os.html#os.chmod) | [`Path.chmod()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.chmod) |
| [`os.mkdir()`](https://python-all.ru/3.8/library/os.html#os.mkdir) | [`Path.mkdir()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.mkdir) |
| [`os.rename()`](https://python-all.ru/3.8/library/os.html#os.rename) | [`Path.rename()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.rename) |
| [`os.replace()`](https://python-all.ru/3.8/library/os.html#os.replace) | [`Path.replace()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.replace) |
| [`os.rmdir()`](https://python-all.ru/3.8/library/os.html#os.rmdir) | [`Path.rmdir()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.rmdir) |
| [`os.remove()`](https://python-all.ru/3.8/library/os.html#os.remove), [`os.unlink()`](https://python-all.ru/3.8/library/os.html#os.unlink) | [`Path.unlink()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.unlink) |
| [`os.getcwd()`](https://python-all.ru/3.8/library/os.html#os.getcwd) | [`Path.cwd()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.cwd) |
| [`os.path.exists()`](https://python-all.ru/3.8/library/os.path.html#os.path.exists) | [`Path.exists()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.exists) |
| [`os.path.expanduser()`](https://python-all.ru/3.8/library/os.path.html#os.path.expanduser) | [`Path.expanduser()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.expanduser) и [`Path.home()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.home) |
| [`os.listdir()`](https://python-all.ru/3.8/library/os.html#os.listdir) | [`Path.iterdir()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.iterdir) |
| [`os.path.isdir()`](https://python-all.ru/3.8/library/os.path.html#os.path.isdir) | [`Path.is_dir()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.is_dir) |
| [`os.path.isfile()`](https://python-all.ru/3.8/library/os.path.html#os.path.isfile) | [`Path.is_file()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.is_file) |
| [`os.path.islink()`](https://python-all.ru/3.8/library/os.path.html#os.path.islink) | [`Path.is_symlink()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.is_symlink) |
| [`os.link()`](https://python-all.ru/3.8/library/os.html#os.link) | [`Path.link_to()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.link_to) |
| [`os.symlink()`](https://python-all.ru/3.8/library/os.html#os.symlink) | [`Path.symlink_to()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.symlink_to) |
| [`os.stat()`](https://python-all.ru/3.8/library/os.html#os.stat) | [`Path.stat()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.stat), [`Path.owner()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.owner), [`Path.group()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.group) |
| [`os.path.isabs()`](https://python-all.ru/3.8/library/os.path.html#os.path.isabs) | [`PurePath.is_absolute()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.PurePath.is_absolute) |
| [`os.path.join()`](https://python-all.ru/3.8/library/os.path.html#os.path.join) | [`PurePath.joinpath()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.PurePath.joinpath) |
| [`os.path.basename()`](https://python-all.ru/3.8/library/os.path.html#os.path.basename) | [`PurePath.name`](https://python-all.ru/3.8/library/pathlib.html#pathlib.PurePath.name) |
| [`os.path.dirname()`](https://python-all.ru/3.8/library/os.path.html#os.path.dirname) | [`PurePath.parent`](https://python-all.ru/3.8/library/pathlib.html#pathlib.PurePath.parent) |
| [`os.path.samefile()`](https://python-all.ru/3.8/library/os.path.html#os.path.samefile) | [`Path.samefile()`](https://python-all.ru/3.8/library/pathlib.html#pathlib.Path.samefile) |
| [`os.path.splitext()`](https://python-all.ru/3.8/library/os.path.html#os.path.splitext) | [`PurePath.suffix`](https://python-all.ru/3.8/library/pathlib.html#pathlib.PurePath.suffix) |