原文： http://zetcode.com/python/pathlib/

Python pathlib教程展示了如何通过pathlib模块使用 Python 中的文件和目录。

pathlib是一个 Python 模块，提供用于处理文件和目录的对象 API。 pathlib是标准模块。

Path是使用文件的核心对象。

  1. $ pip install prettytable
  2. $ pip install more_itertools

在本教程中，我们还将使用prettytable和more_itertools。

words.txt

  1. blue
  2. forest
  3. sky
  4. ocean
  5. rabbit
  6. clue

一些示例使用此简单的文本文件。

Path.cwd和home

我们通过cwd()获得当前工作目录，并通过home()获得主目录。

cwd_home.py

  1. #!/usr/bin/env python
  3. from pathlib import Path
  5. print(f"Current directory: {Path.cwd()}")
  6. print(f"Home directory: {Path.home()}")

该示例打印当前的工作主管和主目录。

  1. $ cwd_home.py
  2. Current directory: C:\Users\Jano\Documents\pyprogs\pathlib
  3. Home directory: C:\Users\Jano

这是一个示例输出。

变更目录

我们使用os' chdir()进入另一个目录。

change_dir.py

  1. #!/usr/bin/env python
  3. from pathlib import Path
  4. from os import chdir
  6. path = Path('..')
  8. print(f'Current working directory: {path.cwd()}')
  10. chdir(path)
  12. print(f'Current working directory: {path.cwd()}')
  14. chdir('..')

我们更改当前的工作目录。 请注意，仅在 Python 程序内部更改目录。

  1. $ change_dir.py
  2. Current working directory: C:\Users\Jano\Documents\pyprogs\pathlib
  3. Current working directory: C:\Users\Jano\Documents\pyprogs

这是一个示例输出。

Path.mkdir

使用mkdir()创建一个新目录。

mkdir.py

  1. #!/usr/bin/env python
  3. from pathlib import Path
  5. path = Path.cwd() / 'new'
  7. path.mkdir()

该示例在当前工作目录内创建一个新目录。

复制文件

借助shutil模块，我们复制了一个文件。

copy_file.py

  1. #!/usr/bin/env python
  3. from pathlib import Path
  4. from shutil import copyfile
  6. source = Path('words.txt')
  7. destination = Path('words_bck.txt')
  9. copyfile(source, destination)

该示例复制了words.txt文件。

  1. source = Path('words.txt')

通过将文件名传递给Path构造器来创建文件对象。

连接路径

路径可以用/运算符或joinpath()方法连接。

join_path.py

  1. #!/usr/bin/env python
  3. from pathlib import Path
  5. path = Path.home()
  7. docs = path / 'Documents'
  8. pictures = path / 'Pictures'
  10. print(docs)
  11. print(pictures)

在示例中，我们使用/将两条路径连接在一起。

  1. $ join_path.py
  2. C:\Users\Jano\Documents
  3. C:\Users\Jano\Pictures

这是输出。

Path.touch

touch()创建一个新的空文件； 它等效于 Linux touch 命令。

touch.py

  1. #!/usr/bin/python3
  3. from pathlib import Path
  5. Path('myfile.txt').touch()

我们创建一个新的空myfile.txt。

Path.rename

rename()重命名文件或目录。

rename.py

  1. #!/usr/bin/env python
  3. from pathlib import Path
  5. path = Path('names.txt')
  7. path.rename('mynames.txt')

该示例将当前工作目录中的names.txt重命名为mynames.txt。

路径名

我们使用绝对文件路径或相对路径来引用文件。 路径具有不同的表示形式。 Windows 使用与 Linux 不同的文件路径。

path_names.py

  1. #!/usr/bin/env python
  3. from pathlib import Path
  5. path = Path('C:/Users/Jano/Downloads/wordpress-5.1.tar.gz')
  7. print(path)
  8. print(path.as_uri())
  9. print(path.as_posix())

该示例显示了三种不同的文件路径结构。

  1. $ path_names.py
  2. C:\Users\Jano\Downloads\wordpress-5.1.tar.gz
  3. file:///C:/Users/Jano/Downloads/wordpress-5.1.tar.gz
  4. C:/Users/Jano/Downloads/wordpress-5.1.tar.gz

第一个是 Windows 文件路径。 第二个是 URI 样式。 第三个是 POSIX 样式。

相对路径

相对路径从某个给定的工作目录开始，从而避免了提供完整的绝对路径的需要。 例如，从/home/users/jano/目录的角度来看，data.txt是/home/users/jano/data.txt的相对路径。

换句话说，当我们位于/home/users/jano/目录中时，我们可以仅通过文件名data.txt来关联该文件，而无需指定完整路径。

relative_path.py

  1. #!/usr/bin/env python
  3. from pathlib import Path
  5. path = Path('C:/Users/Jano/Downloads/wordpress-5.1.tar.gz')
  7. home = Path.home()
  9. relative = path.relative_to(home)
  10. print(relative)

该示例在给定主目录的情况下打印存档文件的相对路径。

  1. $ relative_path.py
  2. Downloads\wordpress-5.1.tar.gz

这是输出。

Path.parent

使用parent()和parents()，我们可以获得路径的逻辑父级。

parents.py

  1. #!/usr/bin/env python
  3. from pathlib import Path
  5. path = Path('C:/Users/Jano/Documents')
  7. print(f"The parent directory of {path} is {path.parent}")
  8. print(f"The parent of the parent of {path} is {path.parent.parent}")
  10. print(f"All the parents of {path.parent}: ")
  12. print(list(path.parents))

该示例打印路径的父级。

  1. print(f"The parent of the parent of {path} is {path.parent.parent}")

我们可以得到父级的父级。

  1. $ parents.py
  2. The parent directory of C:\Users\Jano\Documents is C:\Users\Jano
  3. The parent of the parent of C:\Users\Jano\Documents is C:\Users
  4. All the parents of C:\Users\Jano:
  5. [WindowsPath('C:/Users/Jano'), WindowsPath('C:/Users'), WindowsPath('C:/')]

这是输出。

路径子元素

路径由子元素组成，例如驱动器或根。

parts.py

  1. #!/usr/bin/env python
  3. from pathlib import Path
  5. path = Path('C:/Users/Jano/Documents')
  7. print(path.parts)
  8. print(path.drive)
  9. print(path.root)

该程序将打印路径的某些部分。

  1. print(path.parts)

通过parts，可以访问路径的各种组件。

  1. print(path.drive)

drive给出一个代表驱动器号或名称的字符串（如果有）。

  1. print(path.root)

root给出一个表示（本地或全局）根的字符串（如果有）。

  1. $ parts.py
  2. ('C:\\', 'Users', 'Jano', 'Documents')
  3. C:
  4. \

这是输出。

以下程序给出了路径的其他部分。

parts2.py

  1. #!/usr/bin/env python
  3. from pathlib import Path
  4. import os
  6. path = Path('C:/Users/Jano/Downloads/wordpress-5.1.tar.gz')
  8. print(f"The stem is: {path.stem}")
  9. print(f"The name is: {path.name}")
  10. print(f"The suffix is: {path.suffix}")
  11. print(f"The anchor is: {path.anchor}")
  13. print(f"File name: {os.path.splitext(path.stem)[0]}")
  15. print("The suffixes: ")
  16. print(path.suffixes)

该程序将打印词干，名称，后缀和锚点。

  1. $ parts2.py
  2. The stem is: wordpress-5.1.tar
  3. The name is: wordpress-5.1.tar.gz
  4. The suffix is: .gz
  5. The anchor is: C:\
  6. File name: wordpress-5.1
  7. The suffixes:
  8. ['.1', '.tar', '.gz']

这是输出。

Path.iterdir

iterdir()产生目录内容的路径对象。

list_dirs.py

  1. #!/usr/bin/env python
  3. from pathlib import Path
  5. path = Path('C:/Users/Jano/Documents')
  7. dirs = [e for e in path.iterdir() if e.is_dir()]
  8. print(dirs)

该示例打印指定目录的子目录。 我们检查路径对象是否为is_dir()目录。

以下示例在指定目录内打印文件。

list_files.py

  1. #!/usr/bin/env python
  3. from pathlib import Path
  5. path = Path('C:/Users/Jano/Documents')
  7. files = [e for e in path.iterdir() if e.is_file()]
  8. print(files)

我们检查路径对象是否为is_file()文件。

路径遍历

球形模式使用通配符指定文件名集。 例如，*.txt表示所有名称以.txt结尾的文件。 *是代表任何字符串的通配符。 另一个常见的通配符是问号（？），代表一个字符。

路径提供glob()和rglob()。 后者用于递归glob。 它将**/添加到给定模式的前面。

globbing.py

  1. #!/usr/bin/env python
  3. from pathlib import Path
  5. path = Path('C:/Users/Jano/Documents/pyprogs')
  7. for e in path.rglob('*.py'):
  8.     print(e)
  10. # for e in path.glob('**/*.py'):
  11. #     print(e)

该示例打印指定目录及其所有子目录中的所有 Python 文件。 请注意，此类操作可能非常耗时。

  1. for e in path.rglob('*.py'):
  2. print(e)
  4. # for e in path.glob('**/*.py'):
  5. #     print(e)

这两个操作是等效的。

路径树

以下示例是一个工具，它以分层树结构输出指定目录的内容。

tree.py

  1. #!/usr/bin/env python
  3. from pathlib import Path
  5. def tree(directory):
  7.     print(f'+ {directory}')
  9.     for path in sorted(directory.rglob('*')):
  11.         depth = len(path.relative_to(directory).parts)
  12.         spacer = '    ' * depth
  14.         # print(f'{spacer}+ {path.name}')
  16.         if path.is_file():
  17.             print(f'{spacer}f {path.name}')
  18.         else:
  19.             print(f'{spacer}d {path.name}')
  21. path = Path.home() / 'Downloads'
  23. tree(path)

该程序以树形结构输出Downloads目录的内容。

按扩展名计数文件

在以下示例中，我们按扩展名对所有文件进行计数。 我们将collections的Counter用于任务。

count_files.py

  1. #!/usr/bin/env python
  3. import collections
  4. from pathlib import Path
  6. docs = Path.home() / 'Documents'
  8. files = [path.suffix for path in docs.iterdir() if path.is_file() and path.suffix]
  9. data = collections.Counter(files)
  11. print(data)
  13. for key, val in data.items(): 
  14.     print(f'{key}: {val}')

该示例对在Documents目录中按扩展名分组的文件进行计数。

  1. files = [path.suffix for path in docs.iterdir() if path.is_file() and path.suffix]

在列表推导式中，我们确保路径对象是带有is_file()的文件，并且该文件具有en扩展名。 文件可能没有扩展名。 特别是在 Unix 系统上。

  1. $ count_files.py
  2. Counter({'.txt': 7, '.pdf': 3, '.ini': 1, '.zip': 1, '.rtf': 1})
  3. .pdf: 3
  4. .txt: 7
  5. .ini: 1
  6. .zip: 1
  7. .rtf: 1

这是一个示例输出。

Path.read_text

read_text()以字符串形式读取文件的内容。 该文件被打开，然后关闭。 可选参数的含义与open()中的含义相同。

read_text.py

  1. #!/usr/bin/env python
  3. from pathlib import Path
  5. path = Path('words.txt')
  7. content = path.read_text()
  8. print(content)

该示例使用read_text()读取words.txt文件的内容。

  1. $ read_text.py
  2. blue
  3. forest
  4. sky
  5. ocean
  6. rabbit
  7. clue

这是输出。

Path.open读取文件

open()会打开路径指向的文件，就像内置的open()函数一样。

read_with_open.py

  1. #!/usr/bin/env python
  3. from pathlib import Path
  5. path = Path('words.txt')
  7. with path.open() as f: 
  8.     lines = f.readlines()
  9.     print(lines)
  11. for line in lines:
  12.     print(line.rstrip())

该示例使用open()打开words.txt文件，并使用readlines()读取内容。

Path读取二进制文件

可以使用read_bytes()读取图像等二进制文件。

read_bytes.py

  1. #!/usr/bin/env python
  3. from pathlib import Path
  4. import binascii
  5. from more_itertools import sliced
  7. path = Path('sid.jpg')
  9. hexed = binascii.hexlify(path.read_bytes())
  10. mybytes = list(sliced(hexed, 2))
  12. i = 0
  14. for b in mybytes:
  16.     print(b.decode("utf-8") , end=' ')
  17.     i += 1
  19.     if (i % 30 == 0):
  20.         print()

该示例读取 JPEG 图片并将其以十六进制表示形式打印到终端。

路径write_text

write_text以文本模式打开文件，向其中写入数据，然后关闭文件。

write_text.py

  1. #!/usr/bin/python3
  3. from pathlib import Path
  5. path = Path('myfile.txt')
  6. path.touch()
  8. path.write_text('This is myfile.txt')

该示例使用touch()创建一个新的空文件，并使用write_text()将一些文本数据写入该文件。

新文章

内容管理系统通常根据当年和月份将其新创建的文章放在目录结构中。 下一个示例对此进行了演示。

new_article.py

  1. #!/usr/bin/env python
  3. from pathlib import Path
  4. import datetime
  6. now = datetime.datetime.now()
  7. year = now.year
  8. month = now.month
  10. name = input('Enter article name:')
  12. path1 = Path('articles') / str(year) / str(month)
  13. path1.mkdir(parents=True)
  15. path2 = path1 /  f'{name}.txt'
  17. path2.touch()
  19. print(f'Article created at: {path2}')

该程序要求用户输入。 它根据当前年份和月份创建一个新的文本文件。

PrettyTable示例

处理文件和目录时，可以使用PrettyTable模块获得更好的输出。

simple_table.py

  1. #!/usr/bin/env python
  3. from pathlib import Path
  4. import datetime
  5. from prettytable import PrettyTable
  7. path = Path('C:/Users/Jano/Documents/')
  9. pt = PrettyTable()
  10. pt.field_names = ["File name", "Size", "Created"]
  12. pt.align["File name"] = "l"
  13. pt.align["Size"] = "r"
  14. pt.align["Created"] = "l"
  16. for e in path.glob('**/*.txt'):
  18.     created = datetime.datetime.fromtimestamp(e.stat().st_ctime)
  19.     size = e.stat().st_size
  20.     pt.add_row([e.name, size, f"{created:%Y-%m-%d}"])
  22. print(pt)

该示例在一个漂亮的表中显示Documents内的所有文本文件。 该表包含三列：文件名，大小和创建日期。

  1. $ simple_table.py
  2. +-------------------------------------------------------+-------+------------+
  3. | File name                                             |  Size | Created    |
  4. +-------------------------------------------------------+-------+------------+
  5. | data.txt                                              |     0 | 2019-02-27 |
  6. | eternal_return.txt                                    | 10467 | 2019-03-03 |
  7. | potvrdenie.txt                                        |   773 | 2019-01-14 |
  8. | text_processing.txt                                   |   750 | 2019-02-18 |
  9. | website-inspire.txt                                   |    62 | 2019-03-03 |
  10. | words.txt                                             |    31 | 2018-12-30 |
  11. | Úvod do Symfony.txt                                   |  7613 | 2019-03-04 |
  12. | robots.txt                                            |   240 | 2019-01-01 |
  13. | robots.txt                                            |   240 | 2019-02-03 |
  14. ...

这是样本部分输出。

在本教程中，我们介绍了标准的 Python pathlib模块。

您可能也对以下相关教程感兴趣： PrettyTable 教程， Python argparse教程， Python 教程。