该模块提供表示文件系统路径的类，其语义适用于不同的操作系统。路径类在纯路径之间划分，纯路径提供纯粹的计算操作而没有I / O，以及具体路径，它继承纯路径但也提供I / O操作。

../_images/pathlib-inheritance.png

如果你之前从未使用过这个模块，或者只是不确定哪个类适合你的任务，那Path很可能就是你需要的。它实例化运行代码的平台的具体路径。

纯路径在某些特殊情况下很有用; 例如：

  1. 如果要在Unix计算机上操作Windows路径（反之亦然）。WindowsPath在Unix上运行时无法实例化，但可以实例化PureWindowsPath。
  2. 您希望确保您的代码仅在不实际访问操作系统的情况下操作路径。在这种情况下，实例化其中一个纯类可能很有用，因为那些只是没有任何操作系统访问操作。

也可以看看

PEP 428：pathlib模块 – 面向对象的文件系统路径。

也可以看看

对于字符串的低级路径操作，您也可以使用该 os.path模块。

基本用法

导入主类：

>>>
>>> from pathlib import Path

 

列出子目录：

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

 

在此目录树中列出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('/etc')
>>> q = p / 'init.d' / 'reboot'
>>> q
PosixPath('/etc/init.d/reboot')
>>> q.resolve()
PosixPath('/etc/rc.d/init.d/halt')

 

查询路径属性：

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

 

打开文件：

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

 

纯粹的路径

纯路径对象提供了实际上不访问文件系统的路径处理操作。有三种方法可以访问这些类，我们也称之为flavors：

class pathlib.PurePath（* pathsegments ）
表示系统路径风格的泛型类（实例化它创建a PurePosixPath或a PureWindowsPath）：

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

 

pathsegments的每个元素可以是表示路径段os.PathLike的字符串，实现返回字符串的接口的对象，或者是另一个路径对象：

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

 

当pathsegments为空时，假定当前目录：

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

 

当给出几个绝对路径时，最后一个被视为锚点（模仿os.path.join()行为）：

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

 

但是，在Windows路径中，更改本地根目录不会丢弃先前的驱动器设置：

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

 

虚假的斜线和单点都会折叠，但是双点（'..'）不会，因为这会改变符号链接面中路径的含义：

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

 

（一种天真的方法会PurePosixPath('foo/../bar')等同于PurePosixPath('bar')，如果foo是另一个目录的符号链接则是错误的）

纯路径对象实现os.PathLike接口，允许在接受接口的任何地方使用它们。

版本3.6中已更改：添加了对os.PathLike界面的支持。

class pathlib.PurePosixPath（* pathsegments ）
PurePath此路径flavor的子类表示非Windows文件系统路径：

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

 

pathsegments类似于指定PurePath。

class pathlib.PureWindowsPath（* pathsegments ）
PurePath此路径flavor的子类表示Windows文件系统路径：

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

 

pathsegments类似于指定PurePath。

无论您运行的系统如何，您都可以实例化所有这些类，因为它们不提供任何进行系统调用的操作。

一般属性

路径是不可变的和可清除的。相同风味的路径是可比较和可订购的。这些属性尊重风味的案例折叠语义：

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

 

不同风味的路径比较不平等且无法订购：

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

 

运营商

斜杠运算符有助于创建子路径，类似于os.path.join()：

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

 

可以在os.PathLike 接受对象实现的任何位置使用路径对象：

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

 

路径的字符串表示形式是原始文件系统路径本身（以本机形式，例如在Windows下使用反斜杠），您可以将该文件路径作为字符串传递给任何函数：

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

 

类似地，调用bytes路径将原始文件系统路径作为字节对象，由os.fsencode()以下编码：

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

 

注意

bytes只在Unix下推荐调用。在Windows下，unicode表单是文件系统路径的规范表示。

访问各个部分

要访问路径的各个“部件”（组件），请使用以下属性：

PurePath.parts
一个元组，可以访问路径的各个组件：

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

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

 

（注意驱动器和本地根如何重新组合在一个部件中）

方法和属性

纯路径提供以下方法和属性：

PurePath.drive
表示驱动器号或名称的字符串（如果有）：

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

 

UNC股票也被视为驱动器：

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

 

PurePath.root
表示（本地或全局）根的字符串（如果有）：

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

 

UNC股票总是有根：

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

 

PurePath.anchor
驱动器和根的串联：

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

 

PurePath.parents
提供对路径逻辑祖先的访问的不可变序列：

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

 

PurePath.parent
路径的逻辑父级：

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

 

你不能通过锚点或空路径：

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

 

注意

这是一个纯粹的词法操作，因此有以下行为：

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

 

如果要向上走任意文件系统路径，建议先调用Path.resolve()以解析符号链接并消除“..”组件。

PurePath.name
表示最终路径组件的字符串，不包括驱动器和根目录（如果有）：

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

 

不考虑UNC驱动器名称：

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

 

PurePath.suffix
最终组件的文件扩展名（如果有）：

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

 

PurePath.suffixes
路径文件扩展名列表：

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

 

PurePath.stem
最终路径组件，没有后缀：

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

 

PurePath.as_posix（）
使用正斜杠（/）返回路径的字符串表示形式：

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

 

PurePath.as_uri（）
将路径表示为fileURI。 ValueError如果路径不是绝对路径则会引发。

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

 

PurePath.is_absolute（）
返回路径是否绝对。如果路径同时具有根和（如果风味允许）驱动器，则该路径被视为绝对路径：

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

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

 

PurePath.is_reserved（）
随着PureWindowsPath，返回True如果路径被认为是Windows下的保留，False否则。随着PurePosixPath，False总是返回。

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

 

保留路径上的文件系统调用可能会神秘失败或出现意外影响。

PurePath.joinpath（*其他）
调用此方法相当于将路径依次与每个其他参数组合：

>>>
>>> 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（模式）
将此路径与提供的glob样式模式匹配。True 如果匹配成功False则返回，否则返回。

如果pattern是相对的，则路径可以是相对路径或绝对路径，并且匹配是从右侧完成的：

>>>
>>> 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是绝对的，则路径必须是绝对路径，并且整个路径必须匹配：

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

 

与其他方法一样，可以观察到区分大小写：

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

 

PurePath.relative_to（*其他）
相对于其他路径表示的路径计算此路径的版本 。如果不可能，则会引发ValueError：

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

 

PurePath.with_name（名字）
返回带有name更改的新路径。如果原始路径没有名称，则引发ValueError：

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

 

PurePath.with_suffix（后缀）
返回带有suffix更改的新路径。如果原始路径没有后缀，则会添加新后缀。如果 后缀为空字符串，则删除原始后缀：

>>>
>>> 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此类的子类表示系统路径flavor的具体路径（实例化它创建a PosixPath或a WindowsPath）：

>>>
>>> Path('setup.py')
PosixPath('setup.py')
pathsegments类似于指定PurePath。

 

class pathlib.PosixPath（* pathsegments ）
的子类Path和PurePosixPath，这个类表示具体的非Windows文件系统的路径：

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

 

pathsegments类似于指定PurePath。

class pathlib.WindowsPath（* pathsegments ）
的子类Path和PureWindowsPath，这个类代表具体的Windows文件系统的路径：

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

 

pathsegments类似于指定PurePath。

您只能实例化与您的系统对应的类风格（允许对不兼容的路径风格进行系统调用可能导致应用程序中的错误或失败）：

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

 

方法

除纯路径方法外，具体路径还提供以下方法。OSError如果系统调用失败，许多这些方法都会引发（例如因为路径不存在）：

classmethod Path.cwd（）
返回表示当前目录的新路径对象（返回方式os.getcwd()）：

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

 

classmethod Path.home（）
返回代表用户的主目录（如返回的新路径对象os.path.expanduser()与~结构）：

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

 

版本3.5中的新功能。

Path.stat（）
返回有关此路径的信息（与此类似os.stat()）。查看每次调用此方法的结果。

>>>
>>> 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（）
路径是指向现有文件还是目录：

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

 

注意

如果路径指向符号链接，则exists()返回符号链接指向现有文件或目录。

Path.expanduser（）
返回带有扩展~和~user构造的新路径，如下所示os.path.expanduser()：

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

 

版本3.5中的新功能。

Path.glob（模式）
Glob 此路径表示的目录中的给定模式，产生所有匹配的文件（任何类型）：

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

 

“ **”模式表示“此目录和所有子目录，递归”。换句话说，它启用递归通配：

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

 

注意

**在大型目录树中使用“ ”模式可能会消耗过多的时间。

Path.group（）
返回拥有该文件的组的名称。 KeyError如果在系统数据库中找不到文件的gid，则引发此问题。
Path.is_dir（）
返回True如果路径指向目录（或指向目录的符号链接），False如果它指向另一个类型的文件。

False如果路径不存在或符号链断坏，也会返回; 传播其他错误（例如权限错误）。

Path.is_file（）
返回True如果路径指向一个普通文件（或指向一个普通文件的符号链接），False如果它指向另一个类型的文件。

False如果路径不存在或符号链断坏，也会返回; 传播其他错误（例如权限错误）。

Path.is_mount（）
True如果路径是安装点，则返回：文件系统中已安装其他文件系统的点。在POSIX上，该函数检查路径的父节点是否在与路径path/..不同的设备上，或者路径是否指向同一设备上的同一个节点 – 这应该检测所有Unix和POSIX变体的安装点。未在Windows上实现。path/..

版本3.7中的新功能。

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（）
当路径指向目录时，产生目录内容的路径对象：

>>>
>>> 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（模式）
就像Path.chmod()但是，如果路径指向符号链接，该符号链接的方式被改变，而不是它的目标的。
Path.lstat（）
就像Path.stat()但是，如果路径指向符号链接，返回符号链接的信息，而不是它的目标的。
Path.mkdir（mode = 0o777，parents = False，exist_ok = False ）
在此给定路径创建一个新目录。如果给出了mode，则将其与进程’ umask值组合以确定文件模式和访问标志。如果路径已经存在，FileExistsError 则引发。

如果父母是真的，那么根据需要创建这条路径的任何失踪父母; 它们是使用默认权限创建的，不考虑 模式（模仿POSIX 命令）。mkdir -p

如果父母是假的（默认），则父母失踪 FileNotFoundError。

如果exist_ok为false（默认值），FileExistsError则在目标目录已存在时引发。

如果exist_ok为true，FileExistsError则将忽略异常（与POSIX 命令相同的行为），但仅当最后一个路径组件不是现有的非目录文件时。mkdir -p

在3.5版本中更改：将exist_ok加入参数。

Path.open（mode =’r’，buffering = -1，encoding = None，errors = None，newline = None ）
打开路径指向的文件，就像内置open() 函数一样：

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

 

Path.owner（）
返回拥有该文件的用户的名称。 KeyError如果在系统数据库中找不到文件的uid，则引发此异常。
Path.read_bytes（）
将指向文件的二进制内容作为字节对象返回：

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

 

版本3.5中的新功能。

Path.read_text（encoding = None，errors = None ）
将指向文件的已解码内容作为字符串返回：

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

 

该文件打开然后关闭。可选参数的含义与中的相同open()。

版本3.5中的新功能。

Path.rename（目标）
将此文件或目录重命名为给定目标。在Unix上，如果 target存在并且是一个文件，如果用户有权限，它将被静默替换。 target可以是字符串或其他路径对象：

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

 

Path.replace（目标）
将此文件或目录重命名为给定目标。如果target指向现有文件或目录，则将无条件地替换它。
Path.resolve（严格=假）
使路径绝对，解析任何符号链接。返回一个新的路径对象：

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

 

“ ..”组件也被删除（这是唯一的方法）：

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

 

如果路径不存在，并严格为True，FileNotFoundError 提高。如果严格的是False，路径尽可能解决任何其余没有检查它是否存在追加。如果在分辨率路径上遇到无限循环，RuntimeError 则引发。

新的3.6版：在严格的论证。

Path.rglob（模式）
这就像在给定模式前添加Path.glob()“ **” 一样调用：

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

 

Path.rmdir（）
删除此目录。该目录必须为空。
Path.samefile（other_path ）
返回此路径是否指向与other_path相同的文件，other_path可以是Path对象，也可以是字符串。语义类似于os.path.samefile()和os.path.samestat()。

一OSError，如果两个文件不能因为某些原因被访问可以提高。

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

 

版本3.5中的新功能。

使此路径成为目标的符号链接。在Windows下，如果链接的目标是目录，则 target_is_directory必须为true（默认False）。在POSIX下，target_is_directory的值被忽略。

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

 

注意

参数的顺序（链接，目标）与os.symlink()‘s 的反转。

Path.touch（mode = 0o666，exist_ok = True ）
在此给定路径创建文件。如果给出了mode，则将其与进程’ umask值组合以确定文件模式和访问标志。如果文件已经存在，则如果exist_ok 为true（并且其修改时间更新为当前时间），则函数成功，否则FileExistsError引发。
删除此文件或符号链接。如果路径指向目录，请Path.rmdir()改用。
Path.write_bytes（数据）
打开指向字节模式的文件，向其写入数据，然后关闭文件：

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

 

将覆盖现有的同名文件。

版本3.5中的新功能。

Path.write_text（data，encoding = None，errors = None ）
打开文本模式指向的文件，向其写入数据，然后关闭文件：

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

 

版本3.5中的新功能。

对应os模块中的工具

下面是将各种os函数映射到其对应 PurePath/ Path等效的表。

注意

虽然os.path.relpath()并且PurePath.relative_to()有一些重叠的用例，但它们的语义差别很大，因此不能认为它们是等价的。

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