pathlib - 云端在线

程序：

您的姓名

pathlib - pathlib 文档

将文件系统路径作为字符串对象操作很快就会变得很麻烦：多个
呼吁 os.path.join() or os.path.dirname()等。这个模块提供了一组类
以一种简单的、面向对象的方式在路径上提供所有常见的操作。

此模块最适合与 Python 3.2 或更高版本一起使用，但它也与 Python 兼容
2.7.

注意:
该模块已 包括 在 Python 3.4 标准库之后 PEP 428
验收。 您只需要为 Python 3.3 或更早版本安装它。

SEE 另外：
PEP 428：最终 pathlib 设计和 API 的基本原理。

下载

PyPI 上提供了独立版本： http://pypi.python.org/pypi/pathlib/

主要开发现在在 Python 标准库中进行：请参阅 Python
开发者的 指南.

这个独立的 backport 模块的维护库可以在 BitBucket 上找到，
但预计活动会相当低： https://bitbucket.org/pitrou/pathlib/

高水平 查看

该模块提供表示文件系统路径的类，其语义适用于
不同的操作系统。 路径类分为 纯 路径, 提供
没有 I/O 的纯计算操作，以及 具体 路径，继承自纯
路径，但也提供 I/O 操作。 [图片]

如果您以前从未使用过此模块，或者只是不确定哪个课程适合您
任务， 途径 很可能是您需要的。 它实例化一个 具体 径 为平台
代码正在运行。

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

1. 如果您想在 Unix 机器上操作 Windows 路径（反之亦然）。 你不能
实例化一个 窗口路径 在 Unix 上运行时，但您可以实例化
纯Windows路径.

2. 你想确保你的代码只操作路径而不实际访问
操作系统。 在这种情况下，实例化一个纯类可能很有用，因为那些
根本就没有任何操作系统访问操作。

基础课程 用途

导入模块类：

>>> 从路径库导入 *

列出子目录：

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

在此目录树中列出 Python 源文件：

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

在目录树中导航：

>>> p = 路径('/等')
>>> q = p / 'init.d' / '重启'
>>> q
PosixPath('/etc/init.d/重启')
>>> q.resolve()
PosixPath('/etc/rc.d/init.d/halt')

查询路径属性：

>>> q.exists()
真
>>> q.is_dir()
假

打开文件：

>>> 用 q.open() 作为 f: f.readline()
...
'#！/ bin / bash\n'

PURE 路径

纯路径对象提供路径处理操作，这些操作实际上并不访问
文件系统。 可以通过三种方式访问​​这些类，我们也称之为 口味:

程 pathlib.PurePath(*路径段)
代表系统路径风格的通用类（实例化它创建
要么一个 纯正路径 或者 纯Windows路径):

>>> PurePath('setup.py') # 在 Unix 机器上运行
PurePosixPath('setup.py')

的每个元素 路径段 可以是表示一个字符串或字节对象
路径段； 它也可以是另一个路径对象：

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

在规划婴儿食品行业的工艺要求时，安全性和可靠性是工艺设计中最重要的方面。 路径段 为空，则假定当前目录为：

>>> 纯路径()
PurePosixPath('.')

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

>>> 纯路径('/等'，'在/ usr', 'lib64')
PurePosixPath('/usr/lib64')
>>> PureWindowsPath('c:/Windows', 'd:bar')
PureWindowsPath('d:bar')

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

>>> PureWindowsPath('c:/Windows', '/Program Files')
PureWindowsPath('c:/程序文件')

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

>>> 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(*路径段)
的一个子类 纯路径，此路径风格代表非 Windows 文件系统路径：

>>> PurePosixPath('/等')
PurePosixPath('/等')

路径段 类似地指定 纯路径.

程 pathlib.PureWindowsPath(*路径段)
的一个子类 纯路径，此路径风格代表 Windows 文件系统路径：

>>> PureWindowsPath('c:/Program Files/')
PureWindowsPath('c:/程序文件')

路径段 类似地指定 纯路径.

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

一般用途总体评估
路径是不可变的和可散列的。 相同风味的路径具有可比性和可排序性。
这些属性尊重风味的大小写折叠语义：

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

不同风味的路径比较不相等且无法排序：

>>> PureWindowsPath('foo') == PurePosixPath('foo')
假
>>> PureWindowsPath('foo') < PurePosixPath('foo')
追溯（最近一次通话）：
文件 ” "，第 1 行，在
类型错误：无法排序的类型：PureWindowsPath() < PurePosixPath()

运营商
斜线运算符有助于创建子路径，类似于 os.path.加入:

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

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

>>> p = PurePath('/等')
>>> str(p)
'/等'
>>> p = PureWindowsPath('c:/Program Files')
>>> str(p)
'c:\\程序文件'

同样，调用 字节 在路径上给出原始文件系统路径作为字节对象，如
编码者 os.fsencode:

>>> 字节（p）
b'/等'

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

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

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

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

（注意驱动器和本地根是如何重新组合成一个部分的）

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

纯路径驱动器
表示驱动器号或名称的字符串（如果有）：

>>> PureWindowsPath('c:/Program Files/').drive
'C：'
>>> PureWindowsPath('/Program Files/').drive
''
>>> PurePosixPath('/等'）。驾驶
''

UNC 共享也被视为驱动器：

>>> PureWindowsPath('//host/share/foo.txt').drive
'\\\\主机\\共享'

纯路径文件
表示（本地或全局）根的字符串，如果有的话：

>>> PureWindowsPath('c:/Program Files/').root
'\\'
>>> PureWindowsPath('c:Program Files/').root
''
>>> PurePosixPath('/等'）。根
'/'

UNC 共享始终有一个根：

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

PurePath.锚点
驱动器和根的连接：

>>> 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:/')

纯路径文件
路径的逻辑父级：

>>> 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')

如果要向上走任意文件系统路径，建议
第一个电话 路径.resolve() 以便解决符号链接并消除 “ ..”
组件。

纯路径名
表示最终路径组件的字符串，不包括驱动器和根目录，如果
任何：

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

不考虑 UNC 驱动器名称：

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

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

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

PurePath.后缀
路径的文件扩展名列表：

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

纯路径
最后的路径组件，不带后缀：

>>> PurePosixPath('my/library.tar.gz').stem
'库.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:/窗口'

PurePath.as_uri()
将路径表示为 文件 URI。 值错误 如果路径不是绝对的，则会引发。

>>> p = PurePosixPath('/ etc / passwd文件')
>>> p.as_uri()
'文件：/// etc / passwd文件'
>>> p = PureWindowsPath('c:/Windows')
>>> p.as_uri()
'文件:///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()
通过 纯Windows路径， 返回 真 如果路径在 Windows 下被认为是保留的，
假 除此以外。 和 纯正路径, 假 总是返回。

>>> 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:/程序文件')

PurePath.match(模式)
将此路径与提供的 glob 样式模式匹配。 返回 真 如果匹配
成功了， 假 除此以外。

If 模式 是相对的，路径可以是相对的也可以是绝对的，并且匹配
从右侧完成：

>>> PurePath('a/b.py').match('*.py')
真
>>> PurePath('/a/b/c.py').match('b/*.py')
真
>>> PurePath('/a/b/c.py').match('a/*.py')
假

If 模式 是绝对的，路径必须是绝对的，并且整个路径必须匹配：

>>> PurePath('/a.py').match('/*.py')
真
>>> PurePath('a/b.py').match('/*.py')
假

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

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

PurePath.relative_to(*其他)
计算此路径相对于由表示的路径的版本 other. 如果是
不可能，引发了 ValueError：

>>> p = PurePosixPath('/ etc / passwd文件')
>>> p.relative_to('/')
PurePosixPath('etc/passwd')
>>> p.relative_to('/等')
PurePosixPath('passwd')
>>> p.relative_to('在/ usr')
追溯（最近一次通话）：
文件 ” "，第 1 行，在
文件“pathlib.py”，第 694 行，在 relative_to 中
.format（str（self），str（格式化）））
值错误：'/ etc / passwd文件' 不以 ' 开头在/ usr'

PurePath.with_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')
追溯（最近一次通话）：
文件 ” "，第 1 行，在
文件“/home/antoine/cpython/default/Lib/pathlib.py”，第 751 行，在 with_name 中
raise ValueError("%r 有一个空名称" % (self,))
ValueError: PureWindowsPath('c:/') 有一个空名称

PurePath.with_suffix(后缀)
返回一条新路径 后缀 改变了。 如果原始路径没有
后缀，新 后缀 改为附加：

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

具体 路径

具体路径是纯路径类的子类。 除了操作
由后者提供，它们还提供了对路径对象进行系统调用的方法。
实例化具体路径有以下三种方式：

程 pathlib.Path(*路径段)
的一个子类 纯路径，这个类代表系统路径的具体路径
风味（实例化它会创建一个 路径 或者 窗口路径):

>>> 路径（'setup.py'）
PosixPath('setup.py')

路径段 类似地指定 纯路径.

程 pathlib.PosixPath(*路径段)
的一个子类 途径 和 纯正路径，这个类代表具体的非Windows
文件系统路径：

>>> PosixPath('/等')
PosixPath('/等')

路径段 类似地指定 纯路径.

程 pathlib.WindowsPath(*路径段)
的一个子类 途径 和 纯Windows路径，这个类代表具体的Windows
文件系统路径：

>>> WindowsPath('c:/程序文件/')
WindowsPath('c:/程序文件')

路径段 类似地指定 纯路径.

您只能实例化与您的系统相对应的类风味（允许
对不兼容路径风格的系统调用可能会导致您的程序中出现错误或故障
应用）：

>>> 导入操作系统
>>> 操作系统名称
'posix'
>>> 路径（'setup.py'）
PosixPath('setup.py')
>>> PosixPath('setup.py')
PosixPath('setup.py')
>>> WindowsPath('setup.py')
追溯（最近一次通话）：
文件 ” "，第 1 行，在
文件“pathlib.py”，第 798 行，在 __new__ 中
% (cls.__name__,))
NotImplementedError: 无法在您的系统上实例化“WindowsPath”

方法
除了纯路径方法之外，具体路径还提供以下方法。 许多
这些方法可以提高 操作系统错误 如果系统调用失败（例如因为路径
不存在）：

类方法 路径.cwd()
返回一个表示当前目录的新路径对象（由
os.getcwd()):

>>> 路径.cwd()
PosixPath('/home/antoine/pathlib')

路径.stat()
返回有关此路径的信息（类似于 os.stat（））。 结果看了
在每次调用此方法时启动。

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

路径.chmod（模式）
更改文件模式和权限，例如 os.chmod():

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

路径存在（）
路径是否指向现有文件或目录：

>>> 从路径库导入 *
>>> 路径('.').exists()
真
>>> 路径('setup.py').exists()
真
>>> 路径('/等'). 存在()
真
>>> 路径('不存在的文件').exists()
假

Path.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')]

注意:
使用 ”**" 大型目录树中的模式可能会消耗过多的数量
时间。

路径.group()
返回拥有该文件的组的名称。 密钥错误 如果文件的 gid 被引发
在系统数据库中找不到。

路径.is_dir()
回程 真 如果路径指向目录（或指向
目录）， 假 如果它指向另一种文件。

假 如果路径不存在或符号链接损坏，也会返回； 其他
错误（例如权限错误）被传播。

路径.is_file()
回程 真 如果路径指向常规文件（或指向
常规文件）， 假 如果它指向另一种文件。

假 如果路径不存在或符号链接损坏，也会返回； 其他
错误（例如权限错误）被传播。

Path.is_symlink()
回程 真 如果路径指向符号链接， 假 除此以外。

假 如果路径不存在，也会返回； 其他错误（例如权限
错误）被传播。

Path.is_socket()
回程 真 如果路径指向 Unix 套接字（或指向
Unix 套接字）， 假 如果它指向另一种文件。

假 如果路径不存在或符号链接损坏，也会返回； 其他
错误（例如权限错误）被传播。

路径.is_fifo()
回程 真 如果路径指向 FIFO（或指向 FIFO 的符号链接），
假 如果它指向另一种文件。

假 如果路径不存在或符号链接损坏，也会返回； 其他
错误（例如权限错误）被传播。

Path.is_block_device()
回程 真 如果路径指向块设备（或指向
块设备）， 假 如果它指向另一种文件。

假 如果路径不存在或符号链接损坏，也会返回； 其他
错误（例如权限错误）被传播。

Path.is_char_device()
回程 真 如果路径指向字符设备（或指向
到字符设备）， 假 如果它指向另一种文件。

假 如果路径不存在或符号链接损坏，也会返回； 其他
错误（例如权限错误）被传播。

路径.iterdir()
当路径指向一个目录时，产生目录内容的路径对象：

>>> p = Path('文档')
>>> 对于 p.iterdir() 中的 child：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')

路径.lchmod（模式）
喜欢 路径.chmod() 但是，如果路径指向符号链接，则符号链接的
模式被改变而不是它的目标。

路径.lstat()
喜欢 路径.stat() 但是，如果路径指向符号链接，则返回符号链接
链接的信息而不是其目标的信息。

路径.mkdir(mode=0o777, 父母=假）
在此给定路径上创建一个新目录。 如果 模式 是给定的，它与
过程' 遮罩 值来确定文件模式和访问标志。 如果路径
已经存在， 操作系统错误 被提出。

If 父母 为真，此路径的任何缺失父项都根据需要创建； 他们
使用默认权限创建，无需获取 模式 考虑到
（模仿 POSIX MKDIR -p 命令）。

If 父母 为假（默认值），缺少的父母提出 操作系统错误.

Path.open(mode='r', 缓冲=-1， 编码=无， 错误=无， 换行=无）
打开路径指向的文件，就像内置的 打开（） 功能：

>>> p = Path('setup.py')
>>> 使用 p.open() 作为 f：
... f.readline()
...
'#！/usr/bin/环境 蟒蛇3\n'

路径.所有者()
返回拥有该文件的用户的名称。 密钥错误 如果文件的 uid，则引发
在系统数据库中找不到。

Path.rename（目标）
将此文件或目录重命名为给定的 目标. 目标 可以是字符串
或另一个路径对象：

>>> p = Path('foo')
>>> p.open('w').write('some text')
9
>>> target = Path('bar')
>>> p.rename(目标)
>>> target.open().read()
'一些文字'

Path.replace(目标)
将此文件或目录重命名为给定的 目标。 如果 目标 指向一个现有的
文件或目录，它将被无条件替换。

此方法仅适用于 Python 3.3； 它会提高 未实现错误 on
以前的 Python 版本。

路径.resolve()
使路径成为绝对路径，解析任何符号链接。 返回一个新的路径对象：

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

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

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

如果路径不存在，一个 操作系统错误 被提出。 如果无限循环是
沿解析路径遇到， 运行时错误 被提出。

Path.rglob（模式）
这就像打电话 地球仪（） 用“**" 在给定的前面添加 模式:

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

路径.rmdir()
删除此目录。 该目录必须为空。

Path.symlink_to（目标， target_is_directory=假）
将此路径设为指向的符号链接 目标. 在 Windows 下， 目标是目录 必须
为真（默认 假) 如果链接的目标是目录。 在 POSIX 下，
目标是目录的值被忽略。

>>> 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.符号链接()的。

Path.touch（模式= 0o777， 存在_ok=真）
在此给定路径创建一个文件。 如果 模式 是给定的，它与
过程' 遮罩 值来确定文件模式和访问标志。 如果文件
已经存在，如果函数成功 存在_ok 是真的（及其修改
时间更新为当前时间），否则 操作系统错误 被提出。

路径.unlink()
删除此文件或符号链接。 如果路径指向目录，请使用
路径.rmdir() 代替。

使用 onworks.net 服务在线使用 pathlib