PEP 428 - The pathlib module -- object-oriented filesystem paths

PEP: 428
Title: The pathlib module -- object-oriented filesystem paths
Version: d93a7320b0f5
Last-Modified: 2013-11-22 12:30:31 -0500 (Fri, 22 Nov 2013)
Author: Antoine Pitrou <solipsis at>
Status: Final
Type: Standards Track
Created: 30-July-2012
Python-Version: 3.4


This PEP proposes the inclusion of a third-party module, pathlib [1] , in the standard library. The inclusion is proposed under the provisional label, as described in PEP 411 . Therefore, API changes can be done, either as part of the PEP process, or after acceptance in the standard library (and until the provisional label is removed).

The aim of this library is to provide a simple hierarchy of classes to handle filesystem paths and the common operations users do over them.


The implementation of this proposal is tracked in the pep428 branch of pathlib's Mercurial repository [6] .

Why an object-oriented API

The rationale to represent filesystem paths using dedicated classes is the same as for other kinds of stateless objects, such as dates, times or IP addresses. Python has been slowly moving away from strictly replicating the C language's APIs to providing better, more helpful abstractions around all kinds of common functionality. Even if this PEP isn't accepted, it is likely that another form of filesystem handling abstraction will be adopted one day into the standard library.

Indeed, many people will prefer handling dates and times using the high-level objects provided by the datetime module, rather than using numeric timestamps and the time module API. Moreover, using a dedicated class allows to enable desirable behaviours by default, for example the case insensitivity of Windows paths.


Class hierarchy

The pathlib [1] module implements a simple hierarchy of classes:

                |          |
       ---------| PurePath |--------
       |        |          |       |
       |        +----------+       |
       |             |             |
       |             |             |
       v             |             v
+---------------+    |    +-----------------+
|               |    |    |                 |
| PurePosixPath |    |    | PureWindowsPath |
|               |    |    |                 |
+---------------+    |    +-----------------+
       |             v             |
       |          +------+         |
       |          |      |         |
       |   -------| Path |------   |
       |   |      |      |     |   |
       |   |      +------+     |   |
       |   |                   |   |
       |   |                   |   |
       v   v                   v   v
  +-----------+           +-------------+
  |           |           |             |
  | PosixPath |           | WindowsPath |
  |           |           |             |
  +-----------+           +-------------+

This hierarchy divides path classes along two dimensions:

  • a path class can be either pure or concrete: pure classes support only operations that don't need to do any actual I/O, which are most path manipulation operations; concrete classes support all the operations of pure classes, plus operations that do I/O.
  • a path class is of a given flavour according to the kind of operating system paths it represents. pathlib [1] implements two flavours: Windows paths for the filesystem semantics embodied in Windows systems, POSIX paths for other systems.

Any pure class can be instantiated on any system: for example, you can manipulate PurePosixPath objects under Windows, PureWindowsPath objects under Unix, and so on. However, concrete classes can only be instantiated on a matching system: indeed, it would be error-prone to start doing I/O with WindowsPath objects under Unix, or vice-versa.

Furthermore, there are two base classes which also act as system-dependent factories: PurePath will instantiate either a PurePosixPath or a PureWindowsPath depending on the operating system. Similarly, Path will instantiate either a PosixPath or a WindowsPath .

It is expected that, in most uses, using the Path class is adequate, which is why it has the shortest name of all.

No confusion with builtins

In this proposal, the path classes do not derive from a builtin type. This contrasts with some other Path class proposals which were derived from str . They also do not pretend to implement the sequence protocol: if you want a path to act as a sequence, you have to lookup a dedicated attribute (the parts attribute).

Not behaving like one of the basic builtin types also minimizes the potential for confusion if a path is combined by accident with genuine builtin types.


Path objects are immutable, which makes them hashable and also prevents a class of programming errors.

Sane behaviour

Little of the functionality from os.path is reused. Many os.path functions are tied by backwards compatibility to confusing or plain wrong behaviour (for example, the fact that os.path.abspath() simplifies ".." path components without resolving symlinks first).


Paths of the same flavour are comparable and orderable, whether pure or not:

>>> PurePosixPath('a') == PurePosixPath('b')
>>> PurePosixPath('a') < PurePosixPath('b')
>>> PurePosixPath('a') == PosixPath('a')

Comparing and ordering Windows path objects is case-insensitive:

>>> PureWindowsPath('a') == PureWindowsPath('A')

Paths of different flavours always compare unequal, and cannot be ordered:

>>> PurePosixPath('a') == PureWindowsPath('a')
>>> PurePosixPath('a') < PureWindowsPath('a')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: PurePosixPath() < PureWindowsPath()

Paths compare unequal to, and are not orderable with instances of builtin types (such as str ) and any other types.

Useful notations

The API tries to provide useful notations all the while avoiding magic. Some examples:

>>> p = Path('/home/antoine/pathlib/')
>>> p.suffix
>>> p.root
('/', 'home', 'antoine', 'pathlib', '')
>>> p.relative_to('/home/antoine')
>>> p.exists()

Pure paths API

The philosophy of the PurePath API is to provide a consistent array of useful path manipulation operations, without exposing a hodge-podge of functions like os.path does.


First a couple of conventions:

  • All paths can have a drive and a root. For POSIX paths, the drive is always empty.
  • A relative path has neither drive nor root.
  • A POSIX path is absolute if it has a root. A Windows path is absolute if it has both a drive and a root. A Windows UNC path (e.g. \\host\share\myfile.txt ) always has a drive and a root (here, \\host\share and \ , respectively).
  • A path which has either a drive or a root is said to be anchored. Its anchor is the concatenation of the drive and root. Under POSIX, "anchored" is the same as "absolute".


We will present construction and joining together since they expose similar semantics.

The simplest way to construct a path is to pass it its string representation:

>>> PurePath('')

Extraneous path separators and "." components are eliminated:

>>> PurePath('a///b/c/./d/')

If you pass several arguments, they will be automatically joined:

>>> PurePath('docs', 'Makefile')

Joining semantics are similar to os.path.join, in that anchored paths ignore the information from the previously joined components:

>>> PurePath('/etc', '/usr', 'bin')

However, with Windows paths, the drive is retained as necessary:

>>> PureWindowsPath('c:/foo', '/Windows')
>>> PureWindowsPath('c:/foo', 'd:')

Also, path separators are normalized to the platform default:

>>> PureWindowsPath('a/b') == PureWindowsPath('a\\b')

Extraneous path separators and "." components are eliminated, but not ".." components:

>>> PurePosixPath('a//b/./c/')
>>> PurePosixPath('a/../b')

Multiple leading slashes are treated differently depending on the path flavour. They are always retained on Windows paths (because of the UNC notation):

>>> PureWindowsPath('//some/path')

On POSIX, they are collapsed except if there are exactly two leading slashes, which is a special case in the POSIX specification on pathname resolution [7] (this is also necessary for Cygwin compatibility):

>>> PurePosixPath('///some/path')
>>> PurePosixPath('//some/path')

Calling the constructor without any argument creates a path object pointing to the logical "current directory" (without looking up its absolute path, which is the job of the cwd() classmethod on concrete paths):

>>> PurePosixPath()


To represent a path (e.g. to pass it to third-party libraries), just call str() on it:

>>> p = PurePath('/home/antoine/pathlib/')
>>> str(p)
>>> p = PureWindowsPath('c:/windows')
>>> str(p)

To force the string representation with forward slashes, use the as_posix() method:

>>> p.as_posix()

To get the bytes representation (which might be useful under Unix systems), call bytes() on it, which internally uses os.fsencode() :

>>> bytes(p)

To represent the path as a file: URI, call the as_uri() method:

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

The repr() of a path always uses forward slashes, even under Windows, for readability and to remind users that forward slashes are ok:

>>> p = PureWindowsPath('c:/Windows')
>>> p


Several simple properties are provided on every path (each can be empty):

>>> p = PureWindowsPath('c:/Downloads/pathlib.tar.gz')
>>> p.root
>>> p.anchor
>>> p.stem
>>> p.suffix
>>> p.suffixes
['.tar', '.gz']

Deriving new paths


A path can be joined with another using the / operator:

>>> p = PurePosixPath('foo')
>>> p / 'bar'
>>> p / PurePosixPath('bar')
>>> 'bar' / p

As with the constructor, multiple path components can be specified, either collapsed or separately:

>>> p / 'bar/xyzzy'
>>> p / 'bar' / 'xyzzy'

A joinpath() method is also provided, with the same behaviour:

>>> p.joinpath('Python')

Changing the path's final component

The with_name() method returns a new path, with the name changed:

>>> p = PureWindowsPath('c:/Downloads/pathlib.tar.gz')
>>> p.with_name('')

It fails with a ValueError if the path doesn't have an actual name:

>>> p = PureWindowsPath('c:/')
>>> p.with_name('')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "", line 875, in with_name
    raise ValueError("%r has an empty name" % (self,))
ValueError: PureWindowsPath('c:/') has an empty name

The with_suffix() method returns a new path with the suffix changed. However, if the path has no suffix, the new suffix is added:

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

Making the path relative

The relative_to() method computes the relative difference of a path to another:

>>> PurePosixPath('/usr/bin/python').relative_to('/usr')

ValueError is raised if the method cannot return a meaningful value:

>>> PurePosixPath('/usr/bin/python').relative_to('/etc')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "", line 926, in relative_to
    .format(str(self), str(formatted)))
ValueError: '/usr/bin/python' does not start with '/etc'

Sequence-like access

The parts property returns a tuple providing read-only sequence access to a path's components:

>>> p = PurePosixPath('/etc/init.d')
('/', 'etc', 'init.d')

Windows paths handle the drive and the root as a single path component:

>>> p = PureWindowsPath('c:/')
('c:\\', '')

(separating them would be wrong, since C: is not the parent of C:\\ ).

The parent property returns the logical parent of the path:

>>> p = PureWindowsPath('c:/python33/bin/python.exe')
>>> p.parent

The parents property returns an immutable sequence of the path's logical ancestors:

>>> p = PureWindowsPath('c:/python33/bin/python.exe')
>>> len(p.parents)
>>> p.parents[0]
>>> p.parents[1]
>>> p.parents[2]


is_relative() returns True if the path is relative (see definition above), False otherwise.

is_reserved() returns True if a Windows path is a reserved path such as CON or NUL . It always returns False for POSIX paths.

match() matches the path against a glob pattern. It operates on individual parts and matches from the right:

>>> p = PurePosixPath('/usr/bin')
>>> p.match('/usr/b*')
>>> p.match('usr/b*')
>>> p.match('b*')
>>> p.match('/u*')

This behaviour respects the following expectations:

  • A simple pattern such as "*.py" matches arbitrarily long paths as long as the last part matches, e.g. "/usr/foo/".
  • Longer patterns can be used as well for more complex matching, e.g. "/usr/foo/*.py" matches "/usr/foo/".

Concrete paths API

In addition to the operations of the pure API, concrete paths provide additional methods which actually access the filesystem to query or mutate information.


The classmethod cwd() creates a path object pointing to the current working directory in absolute form:

>>> Path.cwd()

File metadata

The stat() returns the file's stat() result; similarly, lstat() returns the file's lstat() result (which is different iff the file is a symbolic link):

>>> p.stat()
posix.stat_result(st_mode=33277, st_ino=7483155, st_dev=2053, st_nlink=1, st_uid=500, st_gid=500, st_size=928, st_atime=1343597970, st_mtime=1328287308, st_ctime=1343597964)

Higher-level methods help examine the kind of the file:

>>> p.exists()
>>> p.is_file()
>>> p.is_dir()
>>> p.is_symlink()
>>> p.is_socket()
>>> p.is_fifo()
>>> p.is_block_device()
>>> p.is_char_device()

The file owner and group names (rather than numeric ids) are queried through corresponding methods:

>>> p = Path('/etc/shadow')
>>> p.owner()

Path resolution

The resolve() method makes a path absolute, resolving any symlink on the way (like the POSIX realpath() call). It is the only operation which will remove " .. " path components. On Windows, this method will also take care to return the canonical path (with the right casing).

Directory walking

Simple (non-recursive) directory access is done by calling the iterdir() method, which returns an iterator over the child paths:

>>> p = Path('docs')
>>> for child in p.iterdir(): child

This allows simple filtering through list comprehensions:

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

Simple and recursive globbing is also provided:

>>> for child in p.glob('**/*.py'): child

File opening

The open() method provides a file opening API similar to the builtin open() method:

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

Filesystem modification

Several common filesystem operations are provided as methods: touch() , mkdir() , rename() , replace() , unlink() , rmdir() , chmod() , lchmod() , symlink_to() . More operations could be provided, for example some of the functionality of the shutil module.

Detailed documentation of the proposed API can be found at the pathlib docs [8] .


Division operator

The division operator came out first in a poll [9] about the path joining operator. Initial versions of pathlib [1] used square brackets (i.e. __getitem__ ) instead.


The joinpath() method was initially called join(), but several people objected that it could be confused with str.join() which has different semantics. Therefore it was renamed to joinpath().


Windows users consider filesystem paths to be case-insensitive and expect path objects to observe that characteristic, even though in some rare situations some foreign filesystem mounts may be case-sensitive under Windows.

In the words of one commenter,

"If glob("*.py") failed to find SETUP.PY on Windows, that would be a usability disaster".

—Paul Moore in


Notice: While Javascript is not essential for this website, your interaction with the content will be limited. Please turn Javascript on for the full experience.