[系统运维]pathlib --- 面向对象的文件系统路径

纯路径

• 无论你正运行什么系统，你都可以实例化这些类，因为它们提供的操作不做任何系统调用。
• 纯路径对象提供了不实际访问文件系统的路径处理操作。有三种方式来访问这些类，也是不同的风格：

class pathlib.PurePath(*pathsegments):一个通用的类，代表当前系统的路径风格（实例化为PurePosixPath 或者PureWindowsPath）

一个通用的类，代表当前系统的路径风格（实例化为PurePosixPath 或者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')

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

class pathlib.PurePosixPath(*pathsegments):一个PurePath 的子类，路径风格不同于Windows 文件系统

一个PurePath 的子类，路径风格不同于Windows 文件系统:

PurePosixPath('/etc') # PurePosixPath('/etc')

• pathsegments 参数的指定和PurePath 相同。

class pathlib.PureWindowsPath(*pathsegments):PurePath 的一个子类，路径风格为Windows 文件系统路径

PurePath 的一个子类，路径风格为Windows 文件系统路径:

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

pathsegments 参数的指定和PurePath 相同。

路径的比较与排序:PureWindowsPath(‘FOO’) in { PureWindowsPath(‘foo’) }

路径是不可变并可哈希的。相同风格的路径可以排序与比较。这些性质尊重对应风格的大小写转换语义:

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() 一样

斜杠/ 操作符有助于创建子路径，就像os.path.join() 一样:

from pathlib import Path, PurePath

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

文件对象可用于任何接受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'

• 只推荐在Unix 下调用bytes。在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.parents:返回当前路径的全部父路径

• 该属性返回当前路径的全部父路径

from pathlib import Path

p = Path('c:/foo/bar/setup.py')
print(list(p.parents))  # [WindowsPath('c:/foo/bar'), WindowsPath('c:/foo'), WindowsPath('c:/')]
print(list(p.parts))  # ['c:\\', 'foo', 'bar', 'setup.py']

PurePath.parent:该属性返回当前路径的上一级路径，相当于parents[0]的返回值,win系统不支持

• win系统不支持
• 该属性返回当前路径的上一级路径，相当于parents[0]的返回值

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

你不能超过一个anchor 或空路径:

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

p = PurePosixPath('.')
p.parent # PurePosixPath('.')

注解: 这是一个单纯的词法操作，因此有以下行为:

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

如果你想要向上移动任意文件系统路径，推荐先使用Path.resolve() 来解析符号链接以及消除"…" 组件。

PurePath.name:返回当前路径中的文件名

该属性返回当前路径中的文件名

from pathlib import Path

p = Path('c:/foo/bar/setup.py')
print(p.name) # setup.py

PurePath.suffix:返回当前路径中的文件后缀名

• 该属性返回当前路径中的文件后缀名

from pathlib import Path

p = Path('c:/foo/bar/setup.py')
print(p.suffix) # .py

PurePath.suffixes:返回当前路径中的文件所有后缀名

• 该属性返回当前路径中的文件所有后缀名

from pathlib import Path

p = Path('my/library.tar.gar')
print(p.suffixes) # ['.tar', '.gar']

PurePath.stem:除去后缀

最后一个路径组件，除去后缀:

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

PurePosixPath('my/library.tar').stem # 'library'

PurePosixPath('my/library').stem # 'library'

PurePath.joinpath(*other):将多个路径连接在一起

• 将多个路径连接在一起

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):匹配指定通配符

• 判断当前路径是否匹配指定通配符，并且匹配是从右侧完成的

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

PurePath.relative_to(*other):去除基准路径之后的结果

• 获取当前路径中去除基准路径之后的结果
• 如果不可计算，则抛出ValueError:

from pathlib import Path

p = Path('/etc/passwd')
print(p.relative_to('/'))  # etc\passwd
print(p.relative_to('/etc'))  # passwd
print(p.relative_to('/usr'))
"""
File "<stdin>", line 1, in <module>
File "pathlib.py", line 694, in relative_to
.format(str(self), str(formatted)))
ValueError: '/etc/passwd' is not in the subpath of '/usr' OR one path is relative?
,!and the other absolute.
"""

PurePath.with_name(name):将当前路径中的文件名(连后缀都替换)替换成新文件名

• 将当前路径中的文件名(连后缀都替换)替换成新文件名
• 如果原本路径没有name，ValueError 被抛出:

from pathlib import Path

p = Path('c:/Downloads/pathlib.tar.gz')
print(p.with_name('set_up.py')) # c:\Downloads\set_up.py
p = Path('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_stem(stem):将当前路径中的文件名(后缀不替换)替换成新文件名

• 将当前路径中的文件名(后缀不替换)替换成新文件名
• 如果原路径没有名称，则会引发ValueError:

from pathlib import Path

p = Path('c:/Downloads/draft.txt')
print(p.with_stem('final'))  # c:\Downloads\final.txt

d = Path('c:/Downloads/pathlib.tar.gz')  # c:\Downloads\lib.gz
print(d.with_stem('lib'))

p = Path('c:/')
print(p.with_stem(''))
"""
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/home/antoine/cpython/default/Lib/pathlib.py", line 861, in with_stem
return self.with_name(stem + self.suffix)
File "/home/antoine/cpython/default/Lib/pathlib.py", line 851, in with_name
raise ValueError("%r has an empty name" % (self,))
ValueError: PureWindowsPath('c:/') has an empty name
"""

PurePath.with_suffix(suffix):将当前路径中的文件后缀名替换成新的后缀名(可去除后缀名)

• 将当前路径中的文件后缀名替换成新的后缀名(可去除后缀名)

from pathlib import Path

p = Path('c:/Downloads/pathlib.tar.gz')
print(p.with_suffix('.bz2'))  # c:\Downloads\.bz2.gz

p = Path('README')
print(p.with_suffix('.txt'))  # README.txt

p = Path('README.txt')
print(p.with_suffix(''))  # README

PurePath.as_uri():将当前路径转换成file URL

• 将当前路径转换成file URL
• 如果并非绝对路径，抛出ValueError。

from pathlib import Path

p = Path('c:/Windows')
print(p.as_uri()) # file:///c:/Windows

PurePath.is_relative_to(*other):返回此路径是否相对于other 的路径

• 返回此路径是否相对于other 的路径。

p = PurePath('/etc/passwd')
p.is_relative_to('/etc') # True

p.is_relative_to('/usr') # False

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.as_posix():将当前路径转换成UNIX风格的路径,返回使用正斜杠（/）的路径字符串

• 将当前路径转换成UNIX风格的路径
• 返回使用正斜杠（/）的路径字符串:

p = PureWindowsPath('c:\\windows')
str(p) #'c:\\windows'

p.as_posix() # '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，如果路径是被Windows 保留的则返回True，否则False。在PurePosixPath，总是返回False

• 在PureWindowsPath，如果路径是被Windows 保留的则返回True，否则False。在PurePosixPath，总是返回False。

PureWindowsPath('nul').is_reserved() # True

PurePosixPath('nul').is_reserved() # False

• 当保留路径上的文件系统被调用，则可能出现玄学失败或者意料之外的效应。

具体路径

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

class pathlib.Path(*pathsegments):一个PurePath 的子类,此类以当前系统的路径风格表示路径(实例化为PosixPath或WindowsPath)

• 一个PurePath 的子类,此类以当前系统的路径风格表示路径(实例化为PosixPath或WindowsPath):

from pathlib import Path

print(Path('setup.py'))  # setup.py
print(type(Path('setup.py')))  # <class 'pathlib.WindowsPath'>

• pathsegments 参数的指定和PurePath相同

class pathlib.PosixPath(*pathsegments):一个Path和PurePosixPath的子类，此类表示一个非Windows文件系统的具体路径

• 一个Path和PurePosixPath的子类，此类表示一个非Windows文件系统的具体路径:

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

• pathsegments 参数的指定和PurePath相同。

class pathlib.WindowsPath(*pathsegments):Path 和PureWindowsPath的子类，从类表示一个Windows文件系统的具体路径

• 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
"""

方法

Path.cwd():获取当前工作路径

• 获取当前工作路径(和os.getcwd()返回的相同):

from pathlib import Path

print(Path.cwd()) # C:\Users\luckiness\Desktop\新建文件夹

Path.home():返回用户的主目录

• 返回用户的主目录,(与带~构造的os.path.expanduser()所返回的相同)。如果无法解析主目录，则会引发RuntimeError

from pathlib import Path

print(Path.home()) # C:\Users\luckiness

Path.stat(*, follow_symlinks=True):访问文件信息

• 返回路径信息, 同os.stat()

资料来源：https://vimsky.com/examples/usage/python-os-stat-method.html
https://blog.csdn.net/djw931017/article/details/87797517

from pathlib import Path

p = Path('q.py')

# 跨平台通用
print(p.stat().st_atime)  # 数据的最后访问时间
print(p.stat().st_atime_ns)  # 与st_atime相同，但是时间以纳秒为单位表示为整数
print(p.stat().st_ctime)  # 文件创建时间
print(p.stat().st_ctime_ns)  # 与st_ctime相同，但是时间以纳秒为单位表示为整数
print(p.stat().st_mtime)  # 获取文件最后一次修改的信息
print(p.stat().st_mtime_ns)  # 与st_mtime相同，但是时间以纳秒为单位表示为整数
print(p.stat().st_size)  # 表示文件的大小(以字节为单位)
print(p.stat().st_mode)  # 表示文件类型和文件模式位(权限)

# linux使用
# print(p.stat().st_blksize) # 系统块的大小,文件的块大小
# print(p.stat().st_blocks) # 文件所占块数 文件包含的块数
# print(p.stat().st_creator)
# print(p.stat().st_flags) # 它代表用户定义的文件标志。
# print(p.stat().st_gen)
# print(p.stat().st_rdev) # 是针对驱动的字符设备和块设备文件的主次设备号
# print(p.stat().st_rsize)
# print(p.stat().st_type)
# print(p.stat().st_birthtime) # 在Mac上，以及一些其他基于Unix的操作系统才能用，linux用不了

# 不常使用(win能用，linux不清楚，没去试过)
print(p.stat().st_file_attributes)
print(p.stat().st_gid)  # 它代表文件所有者的组标识符
print(p.stat().st_nlink)  # 链向此文件的连接数(硬连接)
print(p.stat().st_reparse_tag)
print(p.stat().st_uid)  # 它代表文件所有者的用户标识符
print(p.stat().st_dev)  # 文件所在设备的ID，存的是文件本身存储设备的设备号,也就是硬盘的设备号
print(p.stat().st_ino)  # 它表示Unix上的inode编号和Windows平台上的文件索引

print(Path('.').stat())
"""
os.stat_result(st_mode=16895, st_ino=6192449487735963, st_dev=2264441811, st_nlink=1, st_uid=0, st_gid=0, st_size=4096, st_atime=1650182099, st_mtime=1650182099, st_ctime=1645858203)
"""

Path.lstat():和Path.stat() 一样

• 就和Path.stat() 一样，但是如果路径指向符号链接，则是返回符号链接而不是目标的信息

Path.chmod(mode, *, follow_symlinks=True):更改路径权限

• 更改路径权限, 类似os.chmod()

p = Path('setup.py')
p.stat().st_mode # 33277

p.chmod(0o444)
p.stat().st_mode # 33060

Path.lchmod(mode):用于修改连接文件权限,参考os.lchmod()方法

• 用于修改连接文件权限
• 参考os.lchmod()方法

Path.exists():该文件是否存在

• 判断此路径是否指向一个已存在的文件或目录

from pathlib import Path

print(Path('.').exists())
print(Path('1.py').exists())
print(Path('./etc').exists())  # 与该py文件处于同一目录
print(Path('nonexistentfile').exists())

• 注解: 如果路径指向一个符号链接，exists()返回此符号链接是否指向存在的文件或目录

Path.expanduser():展开~返回主目录

• 展开~返回主目录,与os.path.expanduser() 所返回的相同。如果无法解析主目录，则会引发RuntimeError。

from pathlib import Path

p = Path('~/1.py')
print(p.expanduser())  # C:\Users\luckiness\1.py 返回主目录+文件名

Path.glob(pattern):解析相对于此路径的通配符pattern，产生所有匹配的文件

• 解析相对于此路径的通配符pattern，产生所有匹配的文件:

from pathlib import Path

# glob返回的是一个生成器
print(list(Path('.').glob('*.py')))  # [WindowsPath('1.py'), WindowsPath('3.py'), WindowsPath('q.py')]
print(list(Path('.').glob('*/1.*')))  # [WindowsPath('etc/1.py'), WindowsPath('etc/1.txt')]

• pattern 的形式与fnmatch 的相同，还增加了”**” 表示” 此目录以及所有子目录，递归”。换句话说，它启用递归通配:

from pathlib import Path

print(list(Path('.').glob('**/*.py')))
"""
[WindowsPath('1.py'), WindowsPath('3.py'), WindowsPath('q.py'), WindowsPath('etc/1.py'),
 WindowsPath('venv/Lib/site-packages/pip/__init__.py'),
 WindowsPath('venv/Lib/site-packages/pip/__main__.py'),
 WindowsPath('venv/Lib/site-packages/pip/_internal/build_env.py'),
 WindowsPath('venv/Lib/site-packages/pip/_internal/cache.py'),
 WindowsPath('venv/Lib/site-packages/pip/_internal/configuration.py'),
 WindowsPath('venv/Lib/site-packages/pip/_internal/exceptions.py'),
 WindowsPath('venv/Lib/site-packages/pip/_internal/main.py'),
 WindowsPath('venv/Lib/site-packages/pip/_internal/pyproject.py'),
 WindowsPath('venv/Lib/site-packages/pip/_internal/self_outdated_check.py'),
 WindowsPath('venv/Lib/site-packages/pip/_internal/__init__.py'),
 ...
 WindowsPath('venv/Lib/site-packages/_distutils_hack/__init__.py')]
"""

• 注解: 在一个较大的目录树中使用”**” 模式可能会消耗非常多的时间。

Path.rglob(pattern):相当于Path(‘.’).glob(‘**/*.py’)

• 相当于Path(‘.’).glob(‘**/*.py’)

from pathlib import Path

print(list(Path('.').rglob('*.py'))) # 相当于print(list(Path('.').glob('**/*.py')))

Path.is_dir():路径是否指向文件夹

• 如果路径指向一个目录（或者一个指向目录的符号链接）则返回True，如果指向其他类型的文件则返回False。
• 当路径不存在或者是一个破损的符号链接时也会返回False

from pathlib import Path

print(Path('1.py').is_dir())
print(Path('etc').is_dir())

Path.is_file():路径是否指向文件

• 如果路径指向一个正常的文件（或者一个指向正常文件的符号链接）则返回True，如果指向其他类型的文件则返回False。
• 当路径不存在或者是一个破损的符号链接时也会返回False

from pathlib import Path

print(Path('1.py').is_file())
print(Path('etc').is_file())

Path.iterdir():遍历目录的子目录或者文件

• 遍历目录的子目录或者文件
• 子条目会以任意顺序生成，并且不包括特殊条目’.’ 和’…’

from collections import Counter
from pathlib import Path

p = Path('.')
for child in p.iterdir():
    print(child)
gen = (i.suffix for i in p.iterdir())
print(Counter(gen))
"""
.idea
.vscode
1.py
3.py
etc
htmlout.html
q.py
venv
Counter({'': 4, '.py': 3, '.html': 1})
"""

Path.mkdir(mode=511, parents=False, exist_ok=False):创建文件夹

• 新建给定路径的目录。如果给出了mode ，它将与当前进程的umask值合并来决定文件模式和访问标志。如果路径已经存在，则抛出FileExistsError。
• 如果parents 为true，任何找不到的父目录都会伴随着此路径被创建；它们会以默认权限被创建，而不考虑mode设置（模仿POSIX 的mkdir -p命令）。
• 如果parents 为false（默认），则找不到的父级目录会导致FileNotFoundError 被抛出。
• 如果exist_ok 为false（默认），则在目标已存在的情况下抛出FileExistsError。
• 如果exist_ok 为true，则FileExistsError 异常将被忽略（和POSIX mkdir -p命令行为相同），但是只有在最后一个路径组件不是现存的非目录文件时才生效。

from pathlib import Path

p = Path('dir/subdir/3dir')
print(p.mkdir(parents=True)) # 没有返回值，返回值为None

Path.touch(mode=438, exist_ok=True):创建文件

• 将给定的路径创建为文件。如果给出了mode 它将与当前进程的umask 值合并以确定文件的模式和访问标志。如果文件已经存在，则当exist_ok为true 则函数仍会成功（并且将它的修改事件更新为当前事件），否则抛出FileExistsError。

from pathlib import Path

p = Path('mylink.txt')
p.touch(exist_ok=False)

如果路径比较深，可以先创建文件夹，再创建文件

from pathlib import Path

m = Path("lu")
m.mkdir()
p = Path(m, 'mylink.txt')
p.touch()

Path.open(mode=’r’, buffering=- 1, encoding=None, errors=None, newline=None):打开路径指向的文件

• 打开路径指向的文件，就像内置的open()函数所做的一样:

from pathlib import Path

p = Path('etc/1.txt')
with p.open() as f:
    print(f.readline())

p = Path('foo.txt')
p.open('w').write('some text') 
target = Path('bar.txt')
p.rename(target)
print(target.open().read()) # 也有这种用法

Path.read_text(encoding=None, errors=None):读取文件内容

• 以字符串形式返回路径指向的文件的解码后文本内容
• 文件先被打开然后关闭。有和open() 一样的可选形参。

from pathlib import Path

p = Path('etc/1.txt')
print(p.read_text()) # sdssddssd

Path.write_text(data, encoding=None, errors=None, newline=None):写入文本

• 将文件以文本模式打开，写入data 并关闭:
• 同名的现有文件会被覆盖。可选形参的含义与open()的相同

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

Path.read_bytes():二进制读

• 以字节对象的形式返回路径指向的文件的二进制内容:

from pathlib import Path

p = Path('etc/1.txt')
print(p.read_bytes()) # b'sdssddssd'

Path.write_bytes(data):二进制写

• 将文件以二进制模式打开，写入data 并关闭:
• 一个同名的现存文件将被覆盖。

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

p.read_bytes() # b'Binary file contents'

Path.rename(target):重命名文件或文件夹，也可以移动文件

• 当target为str时，重命名文件或文件夹，当target是Path时，重命名并移动文件
• 在Unix上，如果target存在且为一个文件，如果用户有足够权限，则它将被静默地替换
• target可以是一个字符串或者另一个路径对象

from pathlib import Path

p = Path('foo1.txt')
p.open('w').write('some text')
target = Path('bar1.txt')
p.rename(target)
print(target.open().read())

# 移动目录
p = Path('bar1.txt')
target = Path('./etc/bar1.txt')
# target = Path('./etc/bar2.txt') #  [WinError 183] 当文件已存在时，无法创建该文件。这时候应该用replace
p.rename(target)
print(target.open().read())

Path.replace(target):移动文件，覆盖文件

• 将文件名目录重命名为给定的target，并返回一个新的指向target 的Path 实例。
• 如果target 指向一个现有文件或目录，则它将被无条件地替换(思考：这是不是和rename的区别)

from pathlib import Path

p = Path('bar.txt')
target = Path('./etc/1.txt')
p.replace(target)

Path.resolve(strict=False):将路径绝对化，解析任何符号链接

将路径绝对化，解析任何符号链接

from pathlib import Path

p = Path('.')
print(p.resolve())

b = Path('..')
print(b.resolve())
"""
C:\Users\luckiness\Desktop\新建文件夹
C:\Users\luckiness\Desktop
"""

Path.rmdir():删除文件夹

• 删除空文件夹

from pathlib import Path

# Path('etc').rmdir()  # 目录不是空的，删除失败
# Path('dir').rmdir()  # 含有空文件夹，也是删除失败
Path('dir/subdir/3dir').rmdir()  # 删除成功

Path.unlink(missing_ok=False):删除文件

• 移除此文件或符号链接。如果路径指向目录，则用Path.rmdir() 代替。
• 如果missing_ok 为假值（默认），则如果路径不存在将会引发FileNotFoundError。
• 如果missing_ok 为真值，则FileNotFoundError 异常将被忽略（和POSIX rm -f 命令的行为相同）。
• 在3.8 版更改: 增加了missing_ok 形参。

from pathlib import Path

m = Path("etc/1.txt")
m.unlink()  # 删除文件，文件夹还在

删除文件和文件夹：

from pathlib import Path

p = Path('etc')
m = Path(p, "1.py")
m.unlink()  # 删除文件，文件夹还在
p.rmdir()  # 删除文件后，删除文件夹

Path.group(): 返回拥有此文件的用户组

• 返回拥有此文件的用户组。如果文件的GID 无法在系统数据库中找到，将抛出KeyError 。

from pathlib import Path

print(Path('1.py').group()) # win系统会报错

Path.is_mount():检测挂载点

如果路径是一个挂载点<mount point>：在文件系统中被其他不同的文件系统挂载的地点。
在POSIX 系统，此函数检查path 的父级——path/…是否处于一个和path 不同的设备中，或者file:path/… 和path是否指向相同设备的相同i-node ——这能检测所有Unix以及POSIX 变种上的挂载点。Windows上未实现。

Path.is_symlink():如果路径指向符号链接则返回True，否则False

• 如果路径指向符号链接则返回True，否则False。
• 如果路径不存在也返回False
• 笔者也不知道怎么用

Path.is_socket():如果路径指向一个Unix socket 文件（或者指向Unix socket 文件的符号链接）则返回True

• 如果路径指向一个Unix socket 文件（或者指向Unix socket 文件的符号链接）则返回True，如果指向其他类型的文件则返回False。
• 当路径不存在或者是一个破损的符号链接时也会返回False；

Path.is_fifo(): 如果路径指向一个先进先出存储（或者指向先进先出存储的符号链接）则返回True

• 如果路径指向一个先进先出存储（或者指向先进先出存储的符号链接）则返回True ，指向其他类型的文件则返回False。
• 当路径不存在或者是一个破损的符号链接时也会返回False；

Path.is_block_device(): 如果文件指向一个块设备（或者指向块设备的符号链接）则返回True

• 如果文件指向一个块设备（或者指向块设备的符号链接）则返回True，指向其他类型的文件则返回False。
• 当路径不存在或者是一个破损的符号链接时也会返回False；

Path.is_char_device():如果路径指向一个字符设备（或指向字符设备的符号链接）则返回True

• 如果路径指向一个字符设备（或指向字符设备的符号链接）则返回True，指向其他类型的文件则返回False。
• 当路径不存在或者是一个破损的符号链接时也会返回False

Path.owner():返回拥有此文件的用户名

• 返回拥有此文件的用户名。如果文件的UID 无法在系统数据库中找到，则抛出KeyError。

Path.readlink():返回符号链接所指向的路径（即os.readlink() 的返回值）

• 返回符号链接所指向的路径（即os.readlink() 的返回值）:

from pathlib import Path

p = Path('etc')
p.symlink('1.py')
print(p.readlink()) # 'WindowsPath' object has no attribute 'symlink'

Path.samefile(other_path):返回此目录是否指向与可能是字符串或者另一个路径对象的other_path 相同的文件

• 返回此目录是否指向与可能是字符串或者另一个路径对象的other_path 相同的文件。语义类似于os.path.samefile() 与os.path.samestat()。
• 如果两者都以同一原因无法访问，则抛出OSError

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

p.samefile('spam') # True

Path.symlink_to(target,target_is_directory=False):将此路径创建为指向target 的符号链接。在Windows 下，如果链接的目标是一个目录则target_is_directory必须为true(默认为False)。在POSIX 下，target_is_directory的值将被忽略

• 将此路径创建为指向target 的符号链接。在Windows 下，如果链接的目标是一个目录则target_is_directory必须为true(默认为False)。在POSIX 下，target_is_directory的值将被忽略
• 注解: 参数的顺序（link, target) 和os.symlink() 是相反的

from pathlib import Path

p = Path('mylink')  # 该链接拥有1.py文件的信息
# 这里会报OSError: [WinError 1314] 客户端没有所需的特权。: '1.py' -> 'mylink'，需要以管理员运行python.exe
p.symlink_to('1.py') 
print(p.resolve())
print(p.stat().st_size)

Path.hardlink_to(target):将此路径设为一个指向与target 相同文件的硬链接

• 将此路径设为一个指向与target 相同文件的硬链接。
• 注解: 参数顺序(link, target) 和os.link() 是相反的。

对应的os 模块的工具

资料来源：https://www.cnblogs.com/heniu/p/12872604.html

阅读世界，共赴山海

423全民读书节，邀你共读