Pathlib用法

首先声明下,本文基本就官网介绍文档的翻译,仅此而已.

pathlib模块可以在不同操作系统上进行路径操作.

该模块中将文件路径分为了非实体路径和实体路径.

Pure paths: 代表非实体路径,不进行I/O操作.

该类型的有三种对象,PurePath,PurePosixPath,PureWindowsPath.

其中PurePosixPath(Unix系统),PureWindowsPath(Windows系统)都继承于PurePath.

concrete paths:实体路径,可以进行I/O操作

该类型也有三种对象,Path,PosixPath,WindowsPath.

其中PosixPath(Unix系统),WindowsPath(Windows系统)都继承于Path.而Path也继承于PurePath.

如果之前没有使用过该模块,也不清楚哪个类适用于什么任务的话,建议使用Path类. 

它根据当前系统实例化了一个实体路径类型的对象.

pure paths(非实体路径)在一些特殊的场景下很有用,比如:你想在Unix平台上操作Windows平台的路径,就不能在

Unix平台上实例化一个WindowPath对象,但可以实例化一个PureWindowsPath对象.

或者在肯定不需要进行具体的I/O访问的前提下也可以使用pure paths类型的路径.

基本使用 

from pathlib import Path

列出指定目录的子目录:

p=Path(r'C:\Users\Desktop\pb')
L=[x for x in p.iterdir() if x.is_dir()]
print(L)

#输出:
[WindowsPath('C:/Userst/Desktop/pb/d1'),WindowsPath('C:/Users/Desktop/pb/d2')]

搜索出指定目录中的py文件:

p=Path(r'C:\Users\Desktop\pb')
PY=[x for x in p.glob('*.py')]
print(PY)

#输出:
[WindowsPath('C:/Users/Desktop/pb/help.py')]

目录树中的导航

p=Path(r'C:\Users\lipgrant\Desktop\pb')
q=p / 'd1' /'text1.txt'
print(q)

#输出:
C:\Users\lipgrant\Desktop\pb\d1\text1.txt

查询path的属性:

print(q.exists())
print(q.is_dir())

#输出:
True
False

文件读取:

with q.open() as f:
    print(f.readline())#只读取了一行

#输出:
123

Pure paths(非实体路径)

Pure pahts(非实体路径)可以对路径进行处理和操作,该路径可以不实际存在,因为Pure pahts类不进行I/O操作.

PurePaths类,PurePosixPath类,PureWindowsPath类,这三个类都属性非实体路径.

class pathlib.PurePath(*pathsegments) 是一个通用的系统路径,根据不同的系统返回对应的类.

比如在Unix系统则返回<class 'pathlib.PurePosixPath'>类.

from pathlib import PurePath

p=PurePath('/test')
print(type(p),'  ',p)

#输出:
<class 'pathlib.PureWindowsPath'>    \test

可以做路径拼接,被拼接的对象可以是字符形式的路径,也可以是对象类型的路径.

from pathlib import PurePath,Path
q1=Path('D:/test','pb','123.txt')
q2=Path('D:/')
q=Path(q2,q1)
print(q)#输出:D:\test\pb\123.txt
p=PurePath('/test','pb','123.txt')
print(p)#输出:\test\pb\123.txt

当给定的路径为空时,表示当前路径

p=PurePath()
print(p)#输出: .

计算的路径时,如果最后输入的是绝对路径,则该最后一个路径作为锚点.

q1=PurePath('C:/test','pb','123.txt')
q2=PurePath('D:/')
q=PurePath(q1,q2)
print(q)
#输出:
D:\

p=PurePath('/test','pb','/log')
print(p)
#输出:
/log

但是在Windows path中,改变当前本地路径并不会清除之前的盘符.

t=PurePath('c:/Windows', '/log')
print(t)
#输出:
c:\log

虚假的斜线和单点(.)将被忽略,而连续的两个点(..)则不会,因为这可能改变路径的连接符的意义.

t1=PurePath('c:///Windows')
t2=PurePath('c:/Windows/./log')
t3=PurePath('c:/Windows/../log')
print(t1)
print(t2)
print(t3)
#输出:
c:\Windows
c:\Windows\log
c:\Windows\..\log

在新的3.6版本的python中,pure paths对象实现了对 os.PathLike方法的支持

os.PathLike方法可以操作所有的Path路径对象.

os.PathLike 是 os.path模块中对路径的操作方法.

PurePosixPath和PureWindowsPath是PurePath的子类,使用方法一致.

一般属性

路径对象是不可变和可哈希的,同一类的路径对象是可以比较和排序的,比较和排序原则遵循各自操作系统.

from pathlib import PurePosixPath,PureWindowsPath
print(PurePosixPath('foo') == PurePosixPath('FOO'))#False
print(PureWindowsPath('foo') == PureWindowsPath('FOO'))#True
print( PureWindowsPath('FOO') in { PureWindowsPath('foo') })#True
print(PureWindowsPath('C:') < PureWindowsPath('d:'))#True

但不同类型路径对象之间的比较永远都是返回False,而且不可进行排序.

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

操作符 

正斜杠是一种增加子路径的操作符.

p = PurePath('/etc')
q= p / 'user'
print(q)

#输出:
\etc\user

需要注意上面提到的'绝对路径原则',如果最后一个元素为绝对路径,则会作为锚点.

上面这个例子,交换下顺序,整个拼接合成结果就不一样了 

p = PurePath('/etc')
q= 'user' / p
print(q)

#输出:
\etc

一个os.PathLike的方法可以将Path路径对象作为参数使用.

import os
p = PurePath('/etc/user')
print(os.fspath(p))
#输出:
\etc\user

一个Path路径对象可以通过str函数转换为字符形式.

p = PureWindowsPath('c:/Program Files')
q=str(p)
print(type(q),':',q)

#输出:
<class 'str'> : c:\Program Files

方法和属性 

 parts属性会以元组形式返回路径的每个部分.仅Windows中会以'//' 显示盘符.

p = PurePath('/usr/bin/python3')
print(p.parts)
#输出:
('\\', 'usr', 'bin', 'python3')

p = PureWindowsPath('c:/Program Files/PSF')
print(p.parts)
#输出:
('c:\\', 'Program Files', 'PSF')

drive属性,如果存在盘符则会以字符形式返回,若不存在则返回空字符.

print(PureWindowsPath('c:/Program Files/').drive) # 'c:'
print(PureWindowsPath('/Program Files/').drive)# ''

root属性, 若存在则返回目录,否则返回空字符

print(PureWindowsPath('c:/Program Files').root)# '/'
print(PureWindowsPath('c:Program Files').root)# ''
print(PureWindowsPath('/Program Files').root)# '/'

 anchor属性,驱动器符和根符的链接符号

print(PureWindowsPath('c:/Program Files').anchor)# c:\
print(PureWindowsPath('c:Program Files').anchor)# c:\
print(PureWindowsPath('/Program Files').anchor)# \

parents属性 ,以一个不可变的序列返回逐级的父目录路径对象

p=PureWindowsPath('c:/foo/bar/setup.py').parents
print(p[0])
#输出:
c:\foo\bar

print(list(p))
#输出:
[PureWindowsPath('c:/foo/bar'), PureWindowsPath('c:/foo'), PureWindowsPath('c:/')]

parent 属性, 返回上一层的父目录路径对象,如果是当前目录或者'/'符,则返回其本身.

p=PureWindowsPath('c:/foo/bar/setup.py').parent
print(p)
print(repr(p))
#输出:
c:\foo\bar
PureWindowsPath('c:/foo/bar')

p1=PureWindowsPath('.').parent
print(p1)
print(repr(p1))
#输出:
.
PureWindowsPath('.')

p2=PureWindowsPath('/').parent
print(p2)
print(repr(p2))
#输出:
\
PureWindowsPath('/')

name属性,字符形式返回除去了所有父目录和盘符的文件或文件名

p1=PureWindowsPath('my/library/hello.py').name
print(p1)# hello.py

p2=PureWindowsPath('my/library').name
print(p2)# library

suffix 属性 ,字符形式返回最后的文件扩展名,不存在则为空字符

p1=PureWindowsPath('my/library/setup.py').suffix
print(p1)# .py

p2=PureWindowsPath('my/library.tar.gz').suffix
print(p2)# .gz

p3=PureWindowsPath('my/library').suffix
print(p3)# ''

suffixes 属性, 列表返回所有扩展名.

p1=PureWindowsPath('my/library/setup.py').suffixes
print(p1) # ['.py']

p2=PureWindowsPath('my/library.tar.gz').suffixes
print(p2) # ['.tar', '.gz']

p3=PureWindowsPath('my/library').suffixes
print(p3) # []

stem 属性,去除最后一个扩展名的文件名

p1=PureWindowsPath('my/library/setup.py').stem
print(p1) # setup

p2=PureWindowsPath('my/library.tar.gz').stem
print(p2) # library.tar

p3=PureWindowsPath('my/library').stem
print(p3) # library

as_posix 方法,将反斜杠转换为正斜杠

p = PureWindowsPath('c:\windows')
print(p) # c:\windows
print( p.as_posix()) # c:/windows

as_uri 方法,将绝对路径转换为URI格式,如果不是绝对路径则报错 

p = PureWindowsPath('c:\windows')
print( p.as_uri())# file:///c:/windows

is_absolute 方法,判断是否为绝对路径 

print(PureWindowsPath('c:/a/b').is_absolute())# True
print(PureWindowsPath('/a/b').is_absolute())# False

is_reserved 方法, 是Windows下保留了路径，则返回True，否则返回False,Unix永远是False.

print(PureWindowsPath('nul').is_reserved())# True
print(PureWindowsPath('/a/b').is_reserved())# False

joinpath 方法 ,按照顺序合成路径.

print(PureWindowsPath('/etc').joinpath('passwd')) # \etc\passwd
print(PureWindowsPath('/etc').joinpath(PureWindowsPath('passwd'))) # \etc\passwd
print(PureWindowsPath('/etc').joinpath('init.d', 'apache2')) # \etc\init.d\apache2

match 方法,判断路径是否与给定的模式相匹配

如果模式的绝对路径,那么被判断的路径也必须是绝对路径,否则返回Fasle,无法匹配.

同时大小写不敏感的

print(PurePath('a/b.py').match('*.py')) # True
print(PurePath('/a/b/c.py').match('b/*.py')) # True
print(PurePath('/a/b/c.py').match('a/*.py')) # False
print(PurePath('/a.py').match('/*.py'))# True
print(PurePath('a/b.py').match('/*.py'))# False
print(PureWindowsPath('b.py').match('*.PY'))# True

relative_to 方法,返回给定路径的相对路径,若不存在就报错

p = PureWindowsPath('/my/lib/abc')
print( p.relative_to('/my'))
print( p.relative_to('/my/lib'))

#输出:
lib\abc
abc

with_name 方法,返回指定变文件名的路径对象,原路径对象不变.

p = PureWindowsPath('c:/Downloads/pathlib.tar.gz')
print(p.with_name('setup.py'))
print(p)

#输出:
c:\Downloads\setup.py
c:\Downloads\pathlib.tar.gz

with_suffix 方法, 修改原路径对象的扩展名,若原对象无则为其添加新的扩展名

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

Concrete paths 

Concrete paths(实体路径)整个都是 PurePath的子类,只是额外添加了一些外的功能和操作.

实体路径也是三个对象是Path,PosixPath,WindowsPath.

其实Path是核心对象,继承于PurePath.

PosixPath(Unix系统),WindowsPath(Windows系统)都同时继承于Path和PurePath.

需要注意的,因为是实体路径,需要进行I/O操作的,所以只能实例和操作系统匹配的对象,否则报错.

import os
from pathlib import Path,PosixPath,WindowsPath
print(os.name)# nt

p=Path('hello.py')
print(type(p)) # <class 'pathlib.WindowsPath'>

p1=WindowsPath('hello.py')
print(p1) # hello.py

p2=PosixPath('hello.py')
print(p2) # NotImplementedError: cannot instantiate 'PosixPath' on your system

方法 

得益于继承关系,实体类型的路径对象在非实体类型的基础上增加了一下的方法

大部分的方法如果执行失败都会抛出OSError

cwd 方法,返回一个与系统相对应的新的当前路径的路径对象.

print(type(Path.cwd()),Path.cwd())
#输出:
<class 'pathlib.WindowsPath'>  '/home/antoine/pathlib

home 方法,返回一个与系统相对应的新的用户信息路径的路径对象

print(type(Path.home()),Path.home())
#输出:
<class 'pathlib.WindowsPath'> C:\Users\lip

 stat 方法,返回指定路径的相关信息(大小,创建时间等).类似os.stat()

p=Path(r'C:\Users\lipgrant\Desktop\pb')
print(p.stat())
print(p.stat().st_atime)
#输出:
os.stat_result(st_mode=33206, st_ino=4503599627595562, st_dev=3830539736, st_nlink=1, st_uid=0, st_gid=0, st_size=3515, st_atime=1545727861, st_mtime=1545189439, st_ctime=1545727861)
1545727861.0480485

chmod 方法 ,改变文件的模式,类似os.chmod().

p = Path('setup.py') 
print(p.stat().st_mode) # 33277
p.chmod(0o444)
print( p.stat().st_mode) # 33060

exists 方法 ,判断路径是否存在

print(Path('.').exists())# True
print(Path('setup.py').exists())# True
print(Path('nonexistentfile').exists())# False

expanduser  方法,将给定路径中的'~'符号转换为用户信息路径.

p=Path('~/help.py')
print(p.expanduser())
#输出:
C:\Users\lip\help.py

glob(pattern) 方法,以生成器方式返回指定路径中与pattern相匹配的路径对象

如果使用'**/'符号,表示将递归的查询

p=Path('\Desktop\pb')
print(list(p.glob('*.py')))
print(list(p.glob('**/*.py')))
#输出:
[WindowsPath('/Desktop/pb/help.py')]
[WindowsPath('/Desktop/pb/help.py'), WindowsPath('/Desktop/pb/d1/help1.py'), WindowsPath('/Desktop/pb/d2/help2.py')]

group 方法, 返回指定路径的组名称,Window不支持,所以无例子.

is_dir 方法, 判断给定的路径是否为文件夹.

p1=Path('\Desktop\pb\help.py')
print(p1.is_dir()) #Fasle

p2=Path('\Desktop\pb')
print(p2.is_dir()) #True

is_file 方法,判断给定的路径是否是文件. 

p1=Path('\Desktop\pb\help.py')
print(p1.is_file()) #True

p2=Path('\Desktop\pb')
print(p2.is_file()) #False

is_symlink 方法 ,判断给定的路径是否是软连接(symbolic link).

只是不是软连接就返回False,不管路径是否存在或者发生其他错误.

p=Path('\Desktop\pb')
print(p.is_symlink()) #False

is_socket 方法,判断给定的路径是否是Unix套接字.

p2=Path('\Desktop\pb')
print(p2.is_socket()) #False

is_fifo 方法,判断给定的路径是否是FIFO类型

p=Path('\Desktop\pb')
print(p.is_fifo()) #False

is_block_devic  方法,Windows不支持,判断是否是块设备(block device)类型.无例子

is_char_device 方法,判断是否是字符设备(character device )

p=Path('\Desktop\pb')
print(p.is_char_device()) #False

iterdir 方法 ,以生成器的方式返回指定路径中的所有文件或文件夹的路径对象

p1=Path('\Desktop\pb')
print(list(p1.iterdir()))
#输出:
[WindowsPath('/Desktop/pb/d1'), WindowsPath('/Desktop/pb/d2'), WindowsPath('/Desktop/pb/help.py')]

lchmod 方法,类似chmod,但是针对块设备(block device)类型.略

lstat 方法,类似stat,但是针对设备(block device)类型.略

mkdir 方法,根据给定的路径创建文件,有三个参数.

mode:表示文件类似,默认值是0o777.

parents:默认值false,表示父目录不完整则报错,True表示自动父目录填充为当前路径的父目录

exist_ok:默认值false,表示若存在相同路径则报错,Ture表示不报错但对原路径文件也不做操作

p=Path('Desktop\pb\d2')
p.mkdir(exist_ok=False)
#报错:
FileExistsError: [WinError 183] 当文件已存在时，无法创建该文件。: '\\Desktop\\pb\\d2'


p.mkdir(exist_ok=True)#不报错

p=Path('pb\d2')
p.mkdir(parents=True)#不报错,自动填充父级路径

p.mkdir(parents=False)
#报错:
FileNotFoundError: [WinError 3] 系统找不到指定的路径

open  方法,打开该路径的文件,与内置方法open一致.

p = Path('setup.py') 
with p.open() as f: 
    print(f.readline())

#输出:
'#!/usr/bin/env python3\n'
 

owner 方法,Window不支持,略 

read_bytes 方法,以二进制方法读取指定的路径

p=Path('\Desktop\pb\d1\text1.txt')

print(p.read_bytes())
#输出:
b'123\r\n456'

read_text 方法,以 encoding指定的编码方法读取指定的路径

p=Path('\Desktop\pb\d1\text1.txt')
print(p.read_text(encoding='utf-8'))
#输出:
123
456

rename 方法 ,重命名文件.

最好使用Path对象,使用字符会报错,虽然官方说可以使用字符.

p=Path('pb/d1/text.txt')
p1=Path('pb/d1/wendang.txt')
p.rename(p1)#此时p1对象已经代表之前的p对象了,因为文件名被修改.
print(p1.name)
#输出:
wendang.txt

replace(target) 方法, 重命名或替换(本质是删除文件)

如果target是不存在的路径,则将之前路径重命名为target

如果target是存在的,则target替换到之前的路径,等于保留target而删除之前的路径

p1=Path('C:/Users/lipgrant/Desktop/pb/d1')
p2=Path('C:/Users/lipgrant/Desktop/pb/d2')
p3=Path('C:/Users/lipgrant/Desktop/pb/d3')#不存在的

p1.replace(p3)#表示将p1的文件重命名为p3
p3.replace(p2)#表示p2替换p3,则p3被删除,仅保留p2

resolve 方法,让路径绝对化.有一个strict参数.

strict默认为False,表示该路径可以不实际存在,若为True,则该路径必须实际存在

注意给定的路径是否为绝对路径会导致不同的结果

p=Path('.')
print(p.absolute())#D:\Pycharm

p1=Path('pb/d2')
print(p1.absolute())#D:\Pycharm\pb\d2

p2=Path('/pb/d2')
print(p2.absolute())#D:\pb\d2

rglob  方法,类似于golb方法使用'**/*'符号,等同于对给定路径进行递归匹配

p=Path('\Desktop\pb')
print(list(p.rglob('*.py')))

#输出:
[WindowsPath('/Desktop/pb/help.py'), WindowsPath('/Desktop/pb/d1/help1.py'), WindowsPath('/Desktop/pb/d2/help2.py')]

rmdir  方法,被删除的文件夹必须输空的

p=Path('\Desktop\pb\d2')
p.rmdir()#该文件被删除

samefile 方法 ,判断是否是相同的路径,文件必须实际存在

p=Path(r'\Desktop\pb\d3')
p1=Path(r'\Desktop\pb\d3')
p2=r'\Desktop\pb\d3'
print(p.samefile(p1))#Ture
print(p.samefile(p2))#Ture

symlink_to  方法,按照官方指导在Windows上也无法执行,略

touch 方法, 创建指定类型的文件(不是文件夹)

exist_ok参数默认为True,表示若存在不报错也不进行覆盖,False表示存在是报错

p=Path('Desktop\pb\d1.txt')
p.touch(exist_ok=True)

unlink 方法,与symlink_to  对应的移除方法,略

write_bytes 方法,为指定文件写入二进制数据.覆盖原文件的内容,没有添加模式

p=Path('\Desktop\pb\d1.txt')
p.write_bytes(b'7891234')

write_text  方法,为指定的文件写入指定编码的内容,覆盖原文件内容,无添加模式

p=Path('\Desktop\pb\d1.txt')
p.write_text('你好',encoding='utf-8')