Python中的路径操作

港控/mmm° 2022-02-09 08:13 328阅读 0赞

# 路径操作 #

### 目录结构 ###

*  路径操作
 *   *  os模块中的path对象(3.4版本之前)
     *   *  常用方法
     *  pathlib模块中的Path对象(3.4版本开始使用)
     *   *  Path中的全局方法
         *  Path中的判断方法
         *  绝对路径(Path)
         *  路径重构(Path)
         *  文件信息(Path)
         *  文件操作(Path)
         *  目录结构(Path)
         *  匹配查找(Path)
     *  os模块，操作系统平台
     *  总结

## os模块中的path对象(3.4版本之前) ##

*  path属性os模块，from os import path

### 常用方法 ###

*  os.path.join(path,\*paths)->str \#拼接路径
    
        from os import path
        p = path.join("a","b")
        p2 = path.join("e:/a/b","c")
        print(type(p),p)
        print(type(p2),p2)
    
    ![path005][]
 *  os.path.exists§->True|False \#判断字符串路径或文件是否存在
    
     *  p 字符串路径
 *  os.path.split§->(路径，基名) \#切割路径字符串，获取路径和基名
 *  os.path.dirname§->str路径 \#获取路径字符串的路径
 *  os.path.basename§->str基名 \#获取路径字符串的基名
 *  os.path.relpath(p )->str路径 \#获取文件路径的相对路径
    
     *  简单示例：
    
        from os import path
        path.abspath(""),path.relpath('D:/MyPythonUse/Mypython/a/b')
    
    ![path007][]
 *  os.path.abspath§->str \# 获取路径字符串的绝对路径
    
     *  os.path.abspath("") 和 os.path.abspath(".") 表示当前路径的绝对路径
 *  os.path.splitdrive§->(磁盘名，路径) \#windows系统上使用，获取路径所在磁盘的盘符
    
     *  path.splitdrive(“c:/a/b/text.py”) \#(‘c:’, ‘/a/b/text.py’)
 *  os.path.samefile(src,dst) \#判断两个路径是否指向同一个文件
 *  os.path.normpath(p )->os.path \#正常化路径，取消双斜杠
 *  os.path.normcase(p )->os.path \#将路径大小写规范。
    
     *  如果是linux系统或者Mac OS系统，不做处理
     *  如果是windows系统上，将路径全部转换成小写，并将"/“转成”\\\\"
 *  其他相关方法可以查看python API
    
     *  os.path.getatime(path)
     *  os.path.getsize(path) \#获取文件大小
     *  os.path.isabs(path) \#是否是绝对路径
     *  os.path.isdir(path) \#判断路径是否是当前路径

## pathlib模块中的Path对象(3.4版本开始使用) ##

*  Path路径对象，属于pathlib模块,在python3.4版本后开始提供
    
        from pathlib import Path
    
     *  Path类关系图  
        ![path002][]
 *  Path(\*pathsegments)->PosixPath|WindowsPath 根据路径创建Path对象
    
     *  pathsegments 路径字符串
     *  PosixPath 在linux下调用会返回PosixPath对象
     *  WindowsPath 在windows下调用会返回WindowsPath对象
     *  初始化简单示例
    
        from pathlib import Path
        p = Path() #当前目录 Path(.) Path("")都是表示当前目录
        p = Path('a','b','c/d') #当前目录下的a/b/c/d
        p = Path("/etc") #表示跟下的etc目录
 *  操作符号/
    
     *  语法：
        
         *  Path对象/Path对象
         *  Path对象/字符串 或者 字符串 / Path对象
     *  示例：
    
        p = Path("c:/a/b")
        p = "d/e" / p/"g" #注意组合后为：WindowsPath('c:/a/b/g') 盘符前的不合法路径会被忽略
        p2 = Path("c/d")
        p2 = "e/f"/ ("g/h"/p2)/"g" #WindowsPath('e/f/g/h/c/d/g') 注意括号和p2的位置

**注意：WindowsPath和PosixPath的父类都是PurePath**

*  路径的比较： 在windows中文件名称是不区分大小写的，为了方便判断路径是否一致可以使用路径对象Path来进行比较的路径大小
    
     *  PureWindowsPath(“fab”) == PureWindowsPath(“FaB”) \#返回True
     *  PureWindowsPath(“c:”) < PureWindowsPath(“D:”) \#返回True
     *  windows下演示
    
        p1 = Path("c:")
        p2 = Path("D:")
        print(p1<p2)
        
        p3 = Path("c:/","a","b") #注意，使用盘符时，要带上/,或者后面的路径最前面带上/
        p4 = Path("c:/a/b")
        print(p3==p4,p3,p4)
    
    ![path001][]
 *  linux系统中文件名是区分大小写，所以有：
    
     *  PurePosixPath(“fab”) == PurePosixPath(“FaB”) \#返回False  
        ![path003][]

### Path中的全局方法 ###

*  cwd()->Path \#获取当前工作路径

from pathlib import Path
    p = Path("d:/a/b")
    print(Path.cwd(),p.cwd()) #输出结果为：D:\MyPythonUse\Mypython D:\MyPythonUse\Mypython

*  home()->Path \#获取当前用户的家目录

### Path中的判断方法 ###

*  exists() \#目录或文件是否存在
 *  is\_dir() \#是否是目录，目录存在返回True
 *  is\_file() \#是否是普通文件，文件存在返回True。
 *  is\_fifo() \#是否是FiFO文件，如果文件路径是链接文件，链接文件指向FIFO文件，并未断开，则为True,否则为False
 *  is\_symlink() \#是否是软连接
 *  is\_block\_device() \#是否是块设备
 *  is\_char\_device() \#是否是字符设备
 *  is\_absolute() \#是否是绝对路径

### 绝对路径(Path) ###

*  resolve() \#返回一个新的路径，这个路径就是当前Path对象的绝对路径，如果是软连接则直接被解析。注意无法识别windows的快捷方式。
 *  absolute() \#获取绝对路径，也无法识别windows的快捷方式

### 路径重构(Path) ###

**注意：PurePath对象中的方法。Path继承了PurePath对象**

*  joinpath(\*other)-> \#路径重铸，类似于path.join方法
    
     *  简单示例：
    
        >>> 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')
 *  with\_name(name)->Path \#返回一个名称已经修改的新路径。如果原始路径没有名称会引发ValueError异常
    
     *  name:新的名称
    
        >>> 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
 *  with\_suffix(suffix)->Path \#修改Path对象中的后缀为suffix
    
     *  suffix \#新的后缀
     *  **注意**：如果源Path没有后缀，会添加后缀，如果新后缀为“”空，则会删除原后缀，
    
        >>> 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')
 *  relative\_to(\*other)->Path \#计算当前路径相对于other路径的相对路径，如果无法做相对路径，会出现ValueError异常
    
     *  other：可以是单个值，则直接表示相对的目标路径。如果是多个值，会将多个other链接成一个路径作为目标路径
    
        >>> p = Path("/a/b/c/d/e/f")
        >>> p.relative_to("/a","b","c"),p.relative_to("/a/b/c/d")
        (WindowsPath('d/e/f'), WindowsPath('e/f'))
        >>> 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: '/a/b/c/d/e/f' does not start with '/usr'

### 文件信息(Path) ###

*  lstat() \#路径所指向的文件状态信息，如果文件时符号链接文件，则返回符号链接文件自己的状态。即不跟进链接文件
 *  stat() \#路径所指向的文件状态信息,如果文件时符号链接文件，则返回链接文件所指向的文件信息，即跟进链接文件。类似于os.stat()
    
     *  st\_size 文件大小
     *  st\_mode 文件权限
     *  st\_ino
     *  st\_dev
     *  st\_nlink
     *  st\_uid
     *  st\_size
     *  st\_atime
     *  st\_mtime
     *  st\_ctime

p = Path("text")
    print(p.exists()) #检查文件是否存在
    stat = p.stat()
    print(stat.st_size)
    print(stat)

输出结果为：  
![path004][]

*  owner() \#获取文件的所有者名称，即uid，如果文件没有uid属性，会出现KeyError异常。

### 文件操作(Path) ###

*  chmod(mode) \#根改路径指向文件的权限,类似于os.chmod()
    
     *  mode int类型，可以使用8进制描述。例如0o775
     *  注意，如果指向的是符号链接文件，这会跟进符号链接文件所指向的文件
 *  lchmod(mode) \#针对符号链接文件，只改变符号链接文件的权限，而不是跟进符号链接所指向的文件。
 *  touch(mode=0o666,exit\_ok=True) \#创建文件
    
     *  mode \#模式，默认值为0o666 表示创建文件。
     *  exit\_ok \#是否忽略文件存在异常。默认值为True，
        
         *  True \#如果创建的文件已经存在，就只修改文件的时间戳。不抛出异常
         *  False \#如果文件已经存在，抛出FileExistsError异常
 *  unlink() \#删除文件或符号链接，如果Path指向一个目录会调用Path.rmdir()
 *  rmdir() \#删除空目录,非空目录会报错。注意,Path对象没有提供判断目录为空的方法
    
     *  简单示例，判断目录为空的方法
    
        from pathlib import Path
        def isNoneDir(dirname:Path):
            try:
                stat = dirname.lstat()
            except Exception:
                return Exception
            else:
                if dirname.is_dir():
                    for i in dirname.iterdir():
                        break
                    else:
                        return True
                return False
        p = Path("")
        for i in p.iterdir():
            print(i.name,"\t\t空目录" if isNoneDir(i) else "")
 *  mkdir(mode=0o777, parents=False, exist\_ok=False) \#创建Path路径中的文件或目录
    
     *  mode 权限，默认为777
     *  parents 是否创建父目录，
        
         *  True表示父目录不存在就创建。 等同于mkdir -p
         *  False表示父目录不存在，则抛出FileNotFoundError
     *  exist\_ok参数，在3.5版本加入。是否忽略路径存在异常
        
         *  False 路径存在，抛出FileExistsError异常
         *  True 忽略路径存在异常FileExistsError
 *  rename(target) \#重命名文件。将Path文件对象重命名为 target文件路径对象。相当于mv操作。
    
     *  target \#目标Path对象，可以是str文件路径
     *  注意：
        
         *  如果原Path路径指向一个文件夹，则会移动源文夹下所有内容到target对象
         *  **如果源文件为一个目录，则会移动整个目录**
 *  open(mode=‘r’,buffering=-1,encoding=None,errors=None,newline=None)->文件对象 ，类似于open方法。返回一个文件对象
    
     *  mode 打开路径的默认模式，默认为读取模式打开
     *  buffering 缓冲区，详细介绍请参考系统的open函数[文件操作][Link 1]
     *  errors 什么样的编码错误将被捕获。默认值为None
     *  newline 文本模式中，换行的转换。默认值为None。可选为None,“空串”，"\\r","\\n","\\r\\n" 详细请参考[文件操作][Link 1]
 *  read\_bytes() \#以"rb"二进制读取模式读取路径对应文件，并返回二进制流
 *  read\_text(encoding=None,errors=None) \#以"rt"方式读取路径对应文件，返回文本。
    
     *  encoding 编码格式
     *  errors 什么样的编码错误将被捕获。默认值为None
        
         *  None表示有编码错误将抛出ValueError异常；ignore表示忽略
 *  write\_bytes(data) \#以"wb"方式写入数据到路径对应文件
    
     *  data 要写入的二进制数据 bytes类型
 *  write\_text(data,encoding=None,errors=None) \#以"wt"方式写入字符串到路径对应文件
    
     *  data 要写入的文本数据，str类型
     *  encoding 编码格式
     *  errors 什么样的编码错误将被捕获。默认值为None
        
         *  None表示有编码错误将抛出ValueError异常；ignore表示忽略
     *  简单示例：
    
        p = Path("gdy.txt")
        p.write_bytes(b"abc")
        p.write_text("你是誰") #因为是w模式，所以之前写入的内容abc会被清空
        with p.open(mode="a+") as f: #已a模式打开，会在尾部追加
            f.write("ab你好")
        p.read_text() #读取所有内容

![path006][]

### 目录结构(Path) ###

*  iterdir() \#迭代当前目录，不递归。
    
     *  简单示例 --输出当前路径下哪些是文件，哪些是目录
    
        from pathlib import Path
        arrdir = { *Path("").iterdir()} #获取当前目录下的所有文件
        mdir = { i for i in filter(lambda p: p.is_dir() ,arrdir)} #取出为目录的Path对象
        text = arrdir - mdir   #取出非目录Path对象
        print("目录：",[*map(lambda x:x.name,mdir)])
        print("文件：",[*map(lambda x:x.name,text)])

### 匹配查找(Path) ###

*  glob(pattern)->生成器对象 \#匹配指定目录
    
     *  pattern 通配符给定模式
     *  常用通配符：
        
         *  ? \#代表一个字符
         *  \* \#代表任意个字符
         *  \[abc\]或\[a-z\]表示一个字符
     *  简单示例：
    
        from pathlib import Path
        p = Path("")
        list(p.glob("test*")) #返回当前目录对象下的test开头文件
        list(p.glob("**/*.py")) #递归所有目录，查找已.py结尾的文件，等同于list(p.rglob("*.txt"))
        list(p.glob(**/*)) #递归p路径下的所有文件
 *  rglob(pattern)->生成器对象 \#递归匹配指定目录
    
     *  pattern 通过给定的模式，递归目录。
     *  常用通配符：
        
         *  ? \#代表一个字符
         *  \* \#代表任意个字符
         *  \[abc\]或\[a-z\]表示一个字符
     *  简单示例
    
        from pathlib import Path
        p = Path("")
        list(p.rglob("*.???")) #匹配扩展民为3个字符的文件。等价于list(p.glob(**/*.???))
        list(p.rglob("[a-z]*.???")) #匹配字母开头的且扩展名是3个字符的文件
 *  match(pattern)->True|False \#匹配路径中是否是指定格式的路径。模式匹配，匹配到，返回True。
    
     *  **注意：不会检查路径是否存在**
     *  pattern 通配符给定模式
     *  常用通配符：
        
         *  ? \#代表一个字符
         *  \* \#代表任意个字符
         *  \[abc\]或\[a-z\]表示一个字符
     *  简单示例：
    
        Path("a/b.py").match("*.py") #True #检查路径是否以.py结尾的文件
        Path("/a/b/c.py").match("b/*.py") #True #检查.py结尾的文件上级目录是否是b
        Path("/a/b/c.py").match("a/*.py") #False
        Path("/a/b/c.py").match("a/*/*.py")#True
        Path("/a/b/d/c.py").match("a/*/*.py") #False
        Path("/a/b/c.py").match("a/**/*.py") #True
        Path("/a/b/c.py").match("**/*.py") #True

## os模块，操作系统平台 ##

<table> 
 <thead> 
  <tr> 
   <th align="left">属性或方法</th> 
   <th align="left">结果</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><a href="http://os.name" rel="nofollow">os.name</a></td> 
   <td align="left">windows是nt,linux是posix</td> 
  </tr> 
  <tr> 
   <td align="left">os.uname()</td> 
   <td align="left">*nix支持</td> 
  </tr> 
  <tr> 
   <td align="left">sys.platform</td> 
   <td align="left">windows显示win32,linux显示linux</td> 
  </tr> 
 </tbody> 
</table>

*  常用方法
 *  os.listdit(strpath)->list 获取指定目录内容列表，不递归
    
     *  strpath str类型的路径
     *  list 返回值是个list，存放strpath目录下的所有文件名称。
     *  注意：获取当前路径下的文件方法为：os.listdir()或者os.listdir(".")
 *  os.open(path, flags, mode=0o777, \*, dir\_fd=None)->文件描述符 \#打开文件
    
     *  path 要打开的文件
     *  flags 打开时的文件标记
        
         *  常用标记有，如果需要了解跟多请参考帮助文档
         *  os.O\_RDONLY \#只读方式打开
         *  os.O\_WRONLY \#只写方式打开
         *  os.O\_RDWR \#读写方式打开
         *  os.O\_APPEND \#追加方式打开
         *  os.O\_CREAT \#创建文件
         *  os.O\_EXCL \#
         *  os.O\_TRUNC \#
 *  os.read(fd,n)->bytes \#从文件描述符fd中读取n个字节
    
     *  fd：文件描述符
     *  n :要读取的字节个数
 *  os.write(fd,str) \#
    
     *  fd：文件描述符
     *  str： bytes类型，要写入的字节
 *  os.close(fd) \#关闭文件描述符  
    简单综合示例：

fd = os.open("text4.txt",os.O_CREAT) #创建文件
    os.close(fd)
    fd = os.open("text4.txt",os.O_WRONLY) #只写方式打开
    os.write(fd,"你好".encode()) 
    os.close(fd)
    fd = os.open("text4.txt",os.O_RDONLY) #只读方式打开
    print(os.read(fd,1000))
    os.close(fd)

![path008][]

*  os.stat(path,\*,dir\_fd=None,follow\_symlinks=True) \#获取文件状态
    
     *  本质上调用系统的stat方法
     *  path：路径的string或者bytes。或者fd文件描述符
     *  follow\_symlinks True 返回文件本身信息，False 如果是 软连接则显示软连接本身。对于软连接本身，可以使用os.lstat方法
 *  os.lstat \#获取链接文件本身的stat信息，即元数据信息
 *  os.chmod(path,mode,\*,dir\_fd=None,follow\_symlink=True)
    
     *  path:路径的string或者 bytes.或者fd文件描述符
     *  mode 权限：例如：0o777
 *  os.chown(path,uid,gid) 改变文件的属主，属组，但需要足够的权限
 *  os.symlink(src,dst,target\_is\_directory=False,\*,dir\_fd=none) 创建指向src的链接文件
    
     *  src 源文件路径
     *  dst 目标文件路径
 *  os.mkdir(path,mode=0o777,\*,dir\_fd=None) \#创建目录，如果目录已经存在报FileExistsError异常。如果父目录不存在也会报错
    
     *  path:创建目录路径
     *  mode：权限，默认值为0o777
     *  dir\_fd:文件描述符，默认值为None 在版本3.3后加入。注意：如果平台不支持，会抛出异常NotImplementedError
 *  os.makedirs(name,mode=0o777,exist\_ok=False) \#创建目录，如果目录中父目录不存在，就直接创建。
    
     *  name: 要创建的目录路径
     *  mode: 创建目录时的目录权限，默认是777
     *  exist\_ok: 默认值为False 表示如果目录存在就抛出异常。
        
         *  False :如果目录已经存在，就报错
         *  True :如果目录存在，不报错，即忽略目录是否存在。

## 总结 ##

*  os和os.path中的方法对应pathlib中的方法

<table> 
 <thead> 
  <tr> 
   <th align="left">os and os.path</th> 
   <th align="left">pathlib</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">os.path.abspath()</td> 
   <td align="left">Path.resolve()</td> 
  </tr> 
  <tr> 
   <td align="left">os.chmod()</td> 
   <td align="left">Path.chmod()</td> 
  </tr> 
  <tr> 
   <td align="left">os.mkdir()</td> 
   <td align="left">Path.mkdir()</td> 
  </tr> 
  <tr> 
   <td align="left">os.rename()</td> 
   <td align="left">Path.rename()</td> 
  </tr> 
  <tr> 
   <td align="left">os.replace()</td> 
   <td align="left">Path.replace()</td> 
  </tr> 
  <tr> 
   <td align="left">os.rmdir()</td> 
   <td align="left">Path.rmdir()</td> 
  </tr> 
  <tr> 
   <td align="left">os.remove(), os.unlink()</td> 
   <td align="left">Path.unlink()</td> 
  </tr> 
  <tr> 
   <td align="left">os.getcwd()</td> 
   <td align="left">Path.cwd()</td> 
  </tr> 
  <tr> 
   <td align="left">os.path.exists()</td> 
   <td align="left">Path.exists()</td> 
  </tr> 
  <tr> 
   <td align="left">os.path.expanduser()</td> 
   <td align="left">Path.expanduser() and Path.home()</td> 
  </tr> 
  <tr> 
   <td align="left">os.path.isdir()</td> 
   <td align="left">Path.is_dir()</td> 
  </tr> 
  <tr> 
   <td align="left">os.path.isfile()</td> 
   <td align="left">Path.is_file()</td> 
  </tr> 
  <tr> 
   <td align="left">os.path.islink()</td> 
   <td align="left">Path.is_symlink()</td> 
  </tr> 
  <tr> 
   <td align="left">os.stat() Path.stat(),</td> 
   <td align="left">Path.owner(), Path.group()</td> 
  </tr> 
  <tr> 
   <td align="left">os.path.isabs()</td> 
   <td align="left">PurePath.is_absolute()</td> 
  </tr> 
  <tr> 
   <td align="left">os.path.join()</td> 
   <td align="left">PurePath.joinpath()</td> 
  </tr> 
  <tr> 
   <td align="left">os.path.basename()</td> 
   <td align="left"><a href="http://PurePath.name" rel="nofollow">PurePath.name</a></td> 
  </tr> 
  <tr> 
   <td align="left">os.path.dirname()</td> 
   <td align="left">PurePath.parent</td> 
  </tr> 
  <tr> 
   <td align="left">os.path.samefile()</td> 
   <td align="left">Path.samefile()</td> 
  </tr> 
  <tr> 
   <td align="left">os.path.splitext()</td> 
   <td align="left">PurePath.suffix</td> 
  </tr> 
 </tbody> 
</table>

[path005]: /images/20220209/de3d783a594d4fa9b2db0358367c6b9e.png
[path007]: /images/20220209/13d9a02c96d2406b98f9ab3805ea5647.png
[path002]: /images/20220209/c78c22cd690241aaa6df48f1fce67786.png
[path001]: /images/20220209/0bb3db339d5e4fa6b9b9ce0ca407337f.png
[path003]: /images/20220209/8b75e0b7b26d453e8515d0ce8fb84ad3.png
[path004]: /images/20220209/251d54f0036d4686b11e861d9e2f7190.png
[Link 1]: https://github.com/1263351411/xdd.github.io/blob/master/Python/python%E5%9F%BA%E6%9C%AC%E7%9F%A5%E8%AF%86/%E6%96%87%E4%BB%B6IO%E6%93%8D%E4%BD%9C/1.%E6%96%87%E4%BB%B6%E6%93%8D%E4%BD%9C.md
[path006]: /images/20220209/70ffd497df4e4a53b31b16cfcdd28c7e.png
[path008]: /images/20220209/da7763e89a2a41fd853727e67ece9b50.png