pathlib.po

# Copyright (C) 2001-2023, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-09-23 07:52+0800\n"
"PO-Revision-Date: 2024-12-23 19:15+0800\n"
"Last-Translator: Adrian Liaw <adrianliaw2000@gmail.com>\n"
"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"
"tw)\n"
"Language: zh_TW\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"
"X-Generator: Poedit 3.4.2\n"

#: ../../library/pathlib.rst:2
msgid ":mod:`!pathlib` --- Object-oriented filesystem paths"
msgstr ":mod:`!pathlib` --- 物件導向檔案系統路徑"

#: ../../library/pathlib.rst:9
msgid "**Source code:** :source:`Lib/pathlib/`"
msgstr "**原始碼：**\\ :source:`Lib/pathlib/`"

#: ../../library/pathlib.rst:15
msgid ""
"This module offers classes representing filesystem paths with semantics "
"appropriate for different operating systems.  Path classes are divided "
"between :ref:`pure paths <pure-paths>`, which provide purely computational "
"operations without I/O, and :ref:`concrete paths <concrete-paths>`, which "
"inherit from pure paths but also provide I/O operations."
msgstr ""
"此模組提供代表檔案系統路徑的類別，能適用不同作業系統的語意。路徑類別分成兩"
"種，一種是\\ :ref:`純路徑 (pure paths) <pure-paths>`，提供沒有 I/O 的單純計算"
"操作，另一種是\\ :ref:`實體路徑 (concrete paths) <concrete-paths>`，繼承自純"
"路徑但也提供 IO 操作。"

#: ../../library/pathlib.rst:21
msgid ""
"Inheritance diagram showing the classes available in pathlib. The\n"
"most basic class is PurePath, which has three direct subclasses:\n"
"PurePosixPath, PureWindowsPath, and Path. Further to these four\n"
"classes, there are two classes that use multiple inheritance:\n"
"PosixPath subclasses PurePosixPath and Path, and WindowsPath\n"
"subclasses PureWindowsPath and Path."
msgstr ""
"顯示 pathlib 中可用類別的繼承圖。\n"
"最基礎的類別是 PurePath，它有三個直接子類別：\n"
"PurePosixPath、PureWindowsPath 和 Path。除了這四個類別之外，\n"
"還有兩個類別使用多重繼承：\n"
"PosixPath 繼承自 PurePosixPath 和 Path，而 WindowsPath 繼承自 "
"PureWindowsPath 和 Path。"

#: ../../library/pathlib.rst:31
msgid ""
"If you've never used this module before or just aren't sure which class is "
"right for your task, :class:`Path` is most likely what you need. It "
"instantiates a :ref:`concrete path <concrete-paths>` for the platform the "
"code is running on."
msgstr ""
"如果你之前從未使用過此模組或不確定哪個類別適合你的任務，那你需要的最有可能"
"是 :class:`Path`。它針對程式執行所在的平台實例化一個\\ :ref:`實體路徑 "
"<concrete-paths>`。"

#: ../../library/pathlib.rst:35
msgid "Pure paths are useful in some special cases; for example:"
msgstr "純路徑在某些特殊情境下是有用的，例如："

#: ../../library/pathlib.rst:37
msgid ""
"If you want to manipulate Windows paths on a Unix machine (or vice versa). "
"You cannot instantiate a :class:`WindowsPath` when running on Unix, but you "
"can instantiate :class:`PureWindowsPath`."
msgstr ""
"如果你想在 Unix 機器上處理 Windows 路徑（或反過來），你無法在 Unix 上實例化 :"
"class:`WindowsPath`，但你可以實例化 :class:`PureWindowsPath`。"

#: ../../library/pathlib.rst:40
msgid ""
"You want to make sure that your code only manipulates paths without actually "
"accessing the OS. In this case, instantiating one of the pure classes may be "
"useful since those simply don't have any OS-accessing operations."
msgstr ""
"你想確保你的程式在操作路徑的時候不會真的存取到 OS。在這個情況下，實例化其中一"
"種純路徑類別可能是有用的，因為它們不會有任何存取 OS 的操作。"

#: ../../library/pathlib.rst:45
msgid ":pep:`428`: The pathlib module -- object-oriented filesystem paths."
msgstr ":pep:`428`：pathlib 模組 -- 物件導向檔案系統路徑。"

#: ../../library/pathlib.rst:48
msgid ""
"For low-level path manipulation on strings, you can also use the :mod:`os."
"path` module."
msgstr "針對字串上的底層路徑操作，你也可以使用 :mod:`os.path` 模組。"

#: ../../library/pathlib.rst:53
msgid "Basic use"
msgstr "基本用法"

#: ../../library/pathlib.rst:55
msgid "Importing the main class::"
msgstr "匯入主要類別： ::"

#: ../../library/pathlib.rst:57
msgid ">>> from pathlib import Path"
msgstr ">>> from pathlib import Path"

#: ../../library/pathlib.rst:59
msgid "Listing subdirectories::"
msgstr "列出子目錄： ::"

#: ../../library/pathlib.rst:61
msgid ""
">>> p = Path('.')\n"
">>> [x for x in p.iterdir() if x.is_dir()]\n"
"[PosixPath('.hg'), PosixPath('docs'), PosixPath('dist'),\n"
" PosixPath('__pycache__'), PosixPath('build')]"
msgstr ""
">>> p = Path('.')\n"
">>> [x for x in p.iterdir() if x.is_dir()]\n"
"[PosixPath('.hg'), PosixPath('docs'), PosixPath('dist'),\n"
" PosixPath('__pycache__'), PosixPath('build')]"

#: ../../library/pathlib.rst:66
msgid "Listing Python source files in this directory tree::"
msgstr "在當前目錄樹下列出 Python 原始碼檔案： ::"

#: ../../library/pathlib.rst:68
msgid ""
">>> list(p.glob('**/*.py'))\n"
"[PosixPath('test_pathlib.py'), PosixPath('setup.py'),\n"
" PosixPath('pathlib.py'), PosixPath('docs/conf.py'),\n"
" PosixPath('build/lib/pathlib.py')]"
msgstr ""
">>> list(p.glob('**/*.py'))\n"
"[PosixPath('test_pathlib.py'), PosixPath('setup.py'),\n"
" PosixPath('pathlib.py'), PosixPath('docs/conf.py'),\n"
" PosixPath('build/lib/pathlib.py')]"

#: ../../library/pathlib.rst:73
msgid "Navigating inside a directory tree::"
msgstr "瀏覽目錄樹內部： ::"

#: ../../library/pathlib.rst:75
msgid ""
">>> p = Path('/etc')\n"
">>> q = p / 'init.d' / 'reboot'\n"
">>> q\n"
"PosixPath('/etc/init.d/reboot')\n"
">>> q.resolve()\n"
"PosixPath('/etc/rc.d/init.d/halt')"
msgstr ""
">>> p = Path('/etc')\n"
">>> q = p / 'init.d' / 'reboot'\n"
">>> q\n"
"PosixPath('/etc/init.d/reboot')\n"
">>> q.resolve()\n"
"PosixPath('/etc/rc.d/init.d/halt')"

#: ../../library/pathlib.rst:82
msgid "Querying path properties::"
msgstr "查詢路徑屬性： ::"

#: ../../library/pathlib.rst:84
msgid ""
">>> q.exists()\n"
"True\n"
">>> q.is_dir()\n"
"False"
msgstr ""
">>> q.exists()\n"
"True\n"
">>> q.is_dir()\n"
"False"

#: ../../library/pathlib.rst:89
msgid "Opening a file::"
msgstr "開啟檔案： ::"

#: ../../library/pathlib.rst:91
msgid ""
">>> with q.open() as f: f.readline()\n"
"...\n"
"'#!/bin/bash\\n'"
msgstr ""
">>> with q.open() as f: f.readline()\n"
"...\n"
"'#!/bin/bash\\n'"

#: ../../library/pathlib.rst:97
msgid "Exceptions"
msgstr "例外"

#: ../../library/pathlib.rst:101
msgid ""
"An exception inheriting :exc:`NotImplementedError` that is raised when an "
"unsupported operation is called on a path object."
msgstr ""
"繼承自 :exc:`NotImplementedError` 的例外，當在路徑物件上呼叫不支援的操作時會"
"被引發。"

#: ../../library/pathlib.rst:110
msgid "Pure paths"
msgstr "純路徑"

#: ../../library/pathlib.rst:112
msgid ""
"Pure path objects provide path-handling operations which don't actually "
"access a filesystem.  There are three ways to access these classes, which we "
"also call *flavours*:"
msgstr ""
"純路徑物件提供處理路徑的操作，實際上不會存取檔案系統。有三種方式可以存取這些"
"類別，我們也稱之為\\ *類型 (flavours)*："

#: ../../library/pathlib.rst:118
msgid ""
"A generic class that represents the system's path flavour (instantiating it "
"creates either a :class:`PurePosixPath` or a :class:`PureWindowsPath`)::"
msgstr ""
"一個通用的類別，表示系統的路徑類型（實例化時會建立一個 :class:"
"`PurePosixPath` 或 :class:`PureWindowsPath`)： ::"

#: ../../library/pathlib.rst:121
msgid ""
">>> PurePath('setup.py')      # Running on a Unix machine\n"
"PurePosixPath('setup.py')"
msgstr ""
">>> PurePath('setup.py')      # 執行在 Unix 機器上\n"
"PurePosixPath('setup.py')"

#: ../../library/pathlib.rst:124
msgid ""
"Each element of *pathsegments* can be either a string representing a path "
"segment, or an object implementing the :class:`os.PathLike` interface where "
"the :meth:`~os.PathLike.__fspath__` method returns a string, such as another "
"path object::"
msgstr ""
"*pathsegments* 中的每個元素可以是以下的其中一種：一個表示路徑片段的字串，或一"
"個物件，它實作了 :class:`os.PathLike` 介面且其中的 :meth:`~os.PathLike."
"__fspath__` 方法會回傳字串，就像是另一個路徑物件： ::"

#: ../../library/pathlib.rst:129
msgid ""
">>> PurePath('foo', 'some/path', 'bar')\n"
"PurePosixPath('foo/some/path/bar')\n"
">>> PurePath(Path('foo'), Path('bar'))\n"
"PurePosixPath('foo/bar')"
msgstr ""
">>> PurePath('foo', 'some/path', 'bar')\n"
"PurePosixPath('foo/some/path/bar')\n"
">>> PurePath(Path('foo'), Path('bar'))\n"
"PurePosixPath('foo/bar')"

#: ../../library/pathlib.rst:134
msgid "When *pathsegments* is empty, the current directory is assumed::"
msgstr "當沒有給 *pathsegments* 的時候，會假設是目前的目錄： ::"

#: ../../library/pathlib.rst:136
msgid ""
">>> PurePath()\n"
"PurePosixPath('.')"
msgstr ""
">>> PurePath()\n"
"PurePosixPath('.')"

#: ../../library/pathlib.rst:139
msgid ""
"If a segment is an absolute path, all previous segments are ignored (like :"
"func:`os.path.join`)::"
msgstr ""
"如果一個片段是絕對路徑，則所有之前的片段會被忽略（類似 :func:`os.path."
"join`)： ::"

#: ../../library/pathlib.rst:142
msgid ""
">>> PurePath('/etc', '/usr', 'lib64')\n"
"PurePosixPath('/usr/lib64')\n"
">>> PureWindowsPath('c:/Windows', 'd:bar')\n"
"PureWindowsPath('d:bar')"
msgstr ""
">>> PurePath('/etc', '/usr', 'lib64')\n"
"PurePosixPath('/usr/lib64')\n"
">>> PureWindowsPath('c:/Windows', 'd:bar')\n"
"PureWindowsPath('d:bar')"

#: ../../library/pathlib.rst:147
msgid ""
"On Windows, the drive is not reset when a rooted relative path segment (e."
"g., ``r'\\foo'``) is encountered::"
msgstr ""
"在 Windows 系統上，當遇到具有根目錄的相對路徑片段（例如 ``r'\\foo'``）時，磁"
"碟機 (drive) 部分不會被重置： ::"

#: ../../library/pathlib.rst:150
msgid ""
">>> PureWindowsPath('c:/Windows', '/Program Files')\n"
"PureWindowsPath('c:/Program Files')"
msgstr ""
">>> PureWindowsPath('c:/Windows', '/Program Files')\n"
"PureWindowsPath('c:/Program Files')"

#: ../../library/pathlib.rst:153
msgid ""
"Spurious slashes and single dots are collapsed, but double dots (``'..'``) "
"and leading double slashes (``'//'``) are not, since this would change the "
"meaning of a path for various reasons (e.g. symbolic links, UNC paths)::"
msgstr ""
"不必要的斜線和單點會被合併，但雙點 (``'..'``) 和前置的雙斜線 (``'//'``) 不會"
"被合併，因為這樣會因為各種原因改變路徑的意義（例如符號連結 (symbolic links)、"
"UNC 路徑）： ::"

#: ../../library/pathlib.rst:157
msgid ""
">>> PurePath('foo//bar')\n"
"PurePosixPath('foo/bar')\n"
">>> PurePath('//foo/bar')\n"
"PurePosixPath('//foo/bar')\n"
">>> PurePath('foo/./bar')\n"
"PurePosixPath('foo/bar')\n"
">>> PurePath('foo/../bar')\n"
"PurePosixPath('foo/../bar')"
msgstr ""
">>> PurePath('foo//bar')\n"
"PurePosixPath('foo/bar')\n"
">>> PurePath('//foo/bar')\n"
"PurePosixPath('//foo/bar')\n"
">>> PurePath('foo/./bar')\n"
"PurePosixPath('foo/bar')\n"
">>> PurePath('foo/../bar')\n"
"PurePosixPath('foo/../bar')"

#: ../../library/pathlib.rst:166
msgid ""
"(a naïve approach would make ``PurePosixPath('foo/../bar')`` equivalent to "
"``PurePosixPath('bar')``, which is wrong if ``foo`` is a symbolic link to "
"another directory)"
msgstr ""
"（一個使得 ``PurePosixPath('foo/../bar')`` 等同於 ``PurePosixPath('bar')`` 的"
"單純方法，但如果 ``foo`` 是指到另一個目錄的符號連結，就會是錯誤的。）"

#: ../../library/pathlib.rst:170
msgid ""
"Pure path objects implement the :class:`os.PathLike` interface, allowing "
"them to be used anywhere the interface is accepted."
msgstr ""
"純路徑物件實作了 :class:`os.PathLike` 介面，使得它們可以在任何接受該介面的地"
"方使用。"

#: ../../library/pathlib.rst:173
msgid "Added support for the :class:`os.PathLike` interface."
msgstr "新增了對於 :class:`os.PathLike` 介面的支援。"

#: ../../library/pathlib.rst:178
msgid ""
"A subclass of :class:`PurePath`, this path flavour represents non-Windows "
"filesystem paths::"
msgstr ""
":class:`PurePath` 的一個子類別，該路徑類型表示非 Windows 檔案系統的路徑： ::"

#: ../../library/pathlib.rst:181
msgid ""
">>> PurePosixPath('/etc/hosts')\n"
"PurePosixPath('/etc/hosts')"
msgstr ""
">>> PurePosixPath('/etc/hosts')\n"
"PurePosixPath('/etc/hosts')"

#: ../../library/pathlib.rst:184 ../../library/pathlib.rst:196
#: ../../library/pathlib.rst:766 ../../library/pathlib.rst:776
#: ../../library/pathlib.rst:791
msgid "*pathsegments* is specified similarly to :class:`PurePath`."
msgstr "*pathsegments* 的指定方式與 :class:`PurePath` 類似。"

#: ../../library/pathlib.rst:188
msgid ""
"A subclass of :class:`PurePath`, this path flavour represents Windows "
"filesystem paths, including `UNC paths`_::"
msgstr ""
":class:`PurePath` 的一個子類別，該路徑類型表示 Windows 檔案系統的路徑，包括  "
"`UNC paths`_： ::"

#: ../../library/pathlib.rst:191
msgid ""
">>> PureWindowsPath('c:/', 'Users', 'Ximénez')\n"
"PureWindowsPath('c:/Users/Ximénez')\n"
">>> PureWindowsPath('//server/share/file')\n"
"PureWindowsPath('//server/share/file')"
msgstr ""
">>> PureWindowsPath('c:/', 'Users', 'Ximénez')\n"
"PureWindowsPath('c:/Users/Ximénez')\n"
">>> PureWindowsPath('//server/share/file')\n"
"PureWindowsPath('//server/share/file')"

#: ../../library/pathlib.rst:200
msgid ""
"Regardless of the system you're running on, you can instantiate all of these "
"classes, since they don't provide any operation that does system calls."
msgstr ""
"不論你使用的是什麼系統，你都可以實例化這些類別，因為它們不提供任何涉及系統呼"
"叫的操作。"

#: ../../library/pathlib.rst:205
msgid "General properties"
msgstr "通用屬性"

#: ../../library/pathlib.rst:207
msgid ""
"Paths are immutable and :term:`hashable`.  Paths of a same flavour are "
"comparable and orderable.  These properties respect the flavour's case-"
"folding semantics::"
msgstr ""
"路徑物件是不可變 (immutable) 且可雜湊 (:term:`hashable`) 的。相同類型的路徑物"
"件可以被比較和排序。這些屬性遵守該類型的大小寫語意規則： ::"

#: ../../library/pathlib.rst:211
msgid ""
">>> PurePosixPath('foo') == PurePosixPath('FOO')\n"
"False\n"
">>> PureWindowsPath('foo') == PureWindowsPath('FOO')\n"
"True\n"
">>> PureWindowsPath('FOO') in { PureWindowsPath('foo') }\n"
"True\n"
">>> PureWindowsPath('C:') < PureWindowsPath('d:')\n"
"True"
msgstr ""
">>> PurePosixPath('foo') == PurePosixPath('FOO')\n"
"False\n"
">>> PureWindowsPath('foo') == PureWindowsPath('FOO')\n"
"True\n"
">>> PureWindowsPath('FOO') in { PureWindowsPath('foo') }\n"
"True\n"
">>> PureWindowsPath('C:') < PureWindowsPath('d:')\n"
"True"

#: ../../library/pathlib.rst:220
msgid "Paths of a different flavour compare unequal and cannot be ordered::"
msgstr "不同類型的路徑物件在比較時視為不相等且無法被排序： ::"

#: ../../library/pathlib.rst:222
msgid ""
">>> PureWindowsPath('foo') == PurePosixPath('foo')\n"
"False\n"
">>> PureWindowsPath('foo') < PurePosixPath('foo')\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: '<' not supported between instances of 'PureWindowsPath' and "
"'PurePosixPath'"
msgstr ""
">>> PureWindowsPath('foo') == PurePosixPath('foo')\n"
"False\n"
">>> PureWindowsPath('foo') < PurePosixPath('foo')\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: '<' not supported between instances of 'PureWindowsPath' and "
"'PurePosixPath'"

#: ../../library/pathlib.rst:231
msgid "Operators"
msgstr "運算子"

#: ../../library/pathlib.rst:233
msgid ""
"The slash operator helps create child paths, like :func:`os.path.join`. If "
"the argument is an absolute path, the previous path is ignored. On Windows, "
"the drive is not reset when the argument is a rooted relative path (e.g., "
"``r'\\foo'``)::"
msgstr ""
"斜線運算子 (slash operator) 用於建立子路徑，就像是 :func:`os.path.join` 函式"
"一樣。如果引數是絕對路徑，則忽略前一個路徑。在 Windows 系統上，當引數是具有根"
"目錄的相對路徑（例如，``r'\\foo'``），磁碟機部分不會被重置： ::"

#: ../../library/pathlib.rst:238
msgid ""
">>> p = PurePath('/etc')\n"
">>> p\n"
"PurePosixPath('/etc')\n"
">>> p / 'init.d' / 'apache2'\n"
"PurePosixPath('/etc/init.d/apache2')\n"
">>> q = PurePath('bin')\n"
">>> '/usr' / q\n"
"PurePosixPath('/usr/bin')\n"
">>> p / '/an_absolute_path'\n"
"PurePosixPath('/an_absolute_path')\n"
">>> PureWindowsPath('c:/Windows', '/Program Files')\n"
"PureWindowsPath('c:/Program Files')"
msgstr ""
">>> p = PurePath('/etc')\n"
">>> p\n"
"PurePosixPath('/etc')\n"
">>> p / 'init.d' / 'apache2'\n"
"PurePosixPath('/etc/init.d/apache2')\n"
">>> q = PurePath('bin')\n"
">>> '/usr' / q\n"
"PurePosixPath('/usr/bin')\n"
">>> p / '/an_absolute_path'\n"
"PurePosixPath('/an_absolute_path')\n"
">>> PureWindowsPath('c:/Windows', '/Program Files')\n"
"PureWindowsPath('c:/Program Files')"

#: ../../library/pathlib.rst:251
msgid ""
"A path object can be used anywhere an object implementing :class:`os."
"PathLike` is accepted::"
msgstr ""
"路徑物件可以被用在任何可以接受實作 :class:`os.PathLike` 的物件的地方： ::"

#: ../../library/pathlib.rst:254
msgid ""
">>> import os\n"
">>> p = PurePath('/etc')\n"
">>> os.fspath(p)\n"
"'/etc'"
msgstr ""
">>> import os\n"
">>> p = PurePath('/etc')\n"
">>> os.fspath(p)\n"
"'/etc'"

#: ../../library/pathlib.rst:259
msgid ""
"The string representation of a path is the raw filesystem path itself (in "
"native form, e.g. with backslashes under Windows), which you can pass to any "
"function taking a file path as a string::"
msgstr ""
"路徑的字串表示是原始的檔案系統路徑本身（以原生的形式，例如在 Windows 下是反斜"
"線），你可以將其傳入任何將檔案路徑當作字串傳入的函式： ::"

#: ../../library/pathlib.rst:263
msgid ""
">>> p = PurePath('/etc')\n"
">>> str(p)\n"
"'/etc'\n"
">>> p = PureWindowsPath('c:/Program Files')\n"
">>> str(p)\n"
"'c:\\\\Program Files'"
msgstr ""
">>> p = PurePath('/etc')\n"
">>> str(p)\n"
"'/etc'\n"
">>> p = PureWindowsPath('c:/Program Files')\n"
">>> str(p)\n"
"'c:\\\\Program Files'"

#: ../../library/pathlib.rst:270
msgid ""
"Similarly, calling :class:`bytes` on a path gives the raw filesystem path as "
"a bytes object, as encoded by :func:`os.fsencode`::"
msgstr ""
"類似地，對路徑呼叫 :class:`bytes` 會得到原始檔案系統路徑的 bytes 物件，就像使"
"用 :func:`os.fsencode` 編碼過的一樣： ::"

#: ../../library/pathlib.rst:273
msgid ""
">>> bytes(p)\n"
"b'/etc'"
msgstr ""
">>> bytes(p)\n"
"b'/etc'"

#: ../../library/pathlib.rst:277
msgid ""
"Calling :class:`bytes` is only recommended under Unix.  Under Windows, the "
"unicode form is the canonical representation of filesystem paths."
msgstr ""
"只建議在 Unix 下呼叫 :class:`bytes`。在 Windows 裡，unicode 形式是檔案系統路"
"徑的權威表示方式。"

#: ../../library/pathlib.rst:282
msgid "Accessing individual parts"
msgstr "對個別組成的存取"

#: ../../library/pathlib.rst:284
msgid ""
"To access the individual \"parts\" (components) of a path, use the following "
"property:"
msgstr "可以使用下列屬性來存取路徑的個別「組成」(parts, components)："

#: ../../library/pathlib.rst:289
msgid "A tuple giving access to the path's various components::"
msgstr "一個可存取路徑的各組成的元組： ::"

#: ../../library/pathlib.rst:291
msgid ""
">>> p = PurePath('/usr/bin/python3')\n"
">>> p.parts\n"
"('/', 'usr', 'bin', 'python3')\n"
"\n"
">>> p = PureWindowsPath('c:/Program Files/PSF')\n"
">>> p.parts\n"
"('c:\\\\', 'Program Files', 'PSF')"
msgstr ""
">>> p = PurePath('/usr/bin/python3')\n"
">>> p.parts\n"
"('/', 'usr', 'bin', 'python3')\n"
"\n"
">>> p = PureWindowsPath('c:/Program Files/PSF')\n"
">>> p.parts\n"
"('c:\\\\', 'Program Files', 'PSF')"

#: ../../library/pathlib.rst:299
msgid "(note how the drive and local root are regrouped in a single part)"
msgstr "（特別注意磁碟機跟本地根目錄是如何被重新組合成一個單一組成）"

#: ../../library/pathlib.rst:303
msgid "Methods and properties"
msgstr "方法與屬性"

#: ../../library/pathlib.rst:309
msgid "Pure paths provide the following methods and properties:"
msgstr "純路徑提供以下方法與屬性："

#: ../../library/pathlib.rst:313
msgid ""
"The implementation of the :mod:`os.path` module used for low-level path "
"parsing and joining: either :mod:`posixpath` or :mod:`ntpath`."
msgstr ""
"用於底層路徑剖析和結合的 :mod:`os.path` 模組的實作：可能是 :mod:`posixpath` "
"或 :mod:`ntpath`。"

#: ../../library/pathlib.rst:320
msgid "A string representing the drive letter or name, if any::"
msgstr ""
"若存在則為一個表示磁碟機字母 (drive letter) 或磁碟機名稱 (drive name) 的字"
"串： ::"

#: ../../library/pathlib.rst:322
msgid ""
">>> PureWindowsPath('c:/Program Files/').drive\n"
"'c:'\n"
">>> PureWindowsPath('/Program Files/').drive\n"
"''\n"
">>> PurePosixPath('/etc').drive\n"
"''"
msgstr ""
">>> PureWindowsPath('c:/Program Files/').drive\n"
"'c:'\n"
">>> PureWindowsPath('/Program Files/').drive\n"
"''\n"
">>> PurePosixPath('/etc').drive\n"
"''"

#: ../../library/pathlib.rst:329
msgid "UNC shares are also considered drives::"
msgstr "UNC shares 也被視為磁碟機： ::"

#: ../../library/pathlib.rst:331
msgid ""
">>> PureWindowsPath('//host/share/foo.txt').drive\n"
"'\\\\\\\\host\\\\share'"
msgstr ""
">>> PureWindowsPath('//host/share/foo.txt').drive\n"
"'\\\\\\\\host\\\\share'"

#: ../../library/pathlib.rst:336
msgid "A string representing the (local or global) root, if any::"
msgstr "若存在則為一個表示（本地或全域）根目錄的字串： ::"

#: ../../library/pathlib.rst:338
msgid ""
">>> PureWindowsPath('c:/Program Files/').root\n"
"'\\\\'\n"
">>> PureWindowsPath('c:Program Files/').root\n"
"''\n"
">>> PurePosixPath('/etc').root\n"
"'/'"
msgstr ""
">>> PureWindowsPath('c:/Program Files/').root\n"
"'\\\\'\n"
">>> PureWindowsPath('c:Program Files/').root\n"
"''\n"
">>> PurePosixPath('/etc').root\n"
"'/'"

#: ../../library/pathlib.rst:345
msgid "UNC shares always have a root::"
msgstr "UNC shares 都會有一個根目錄： ::"

#: ../../library/pathlib.rst:347
msgid ""
">>> PureWindowsPath('//host/share').root\n"
"'\\\\'"
msgstr ""
">>> PureWindowsPath('//host/share').root\n"
"'\\\\'"

#: ../../library/pathlib.rst:350
msgid ""
"If the path starts with more than two successive slashes, :class:`~pathlib."
"PurePosixPath` collapses them::"
msgstr ""
"如果路徑以超過兩個連續的斜線開頭，:class:`~pathlib.PurePosixPath` 會合併它"
"們： ::"

#: ../../library/pathlib.rst:353
msgid ""
">>> PurePosixPath('//etc').root\n"
"'//'\n"
">>> PurePosixPath('///etc').root\n"
"'/'\n"
">>> PurePosixPath('////etc').root\n"
"'/'"
msgstr ""
">>> PurePosixPath('//etc').root\n"
"'//'\n"
">>> PurePosixPath('///etc').root\n"
"'/'\n"
">>> PurePosixPath('////etc').root\n"
"'/'"

#: ../../library/pathlib.rst:362
msgid ""
"This behavior conforms to *The Open Group Base Specifications Issue 6*, "
"paragraph `4.11 Pathname Resolution <https://pubs.opengroup.org/"
"onlinepubs/009695399/basedefs/xbd_chap04.html#tag_04_11>`_:"
msgstr ""
"此行為符合 *The Open Group Base Specifications Issue 6*，章節 `4.11 路徑名稱"
"解析 <https://pubs.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap04."
"html#tag_04_11>`_："

#: ../../library/pathlib.rst:366
msgid ""
"*\"A pathname that begins with two successive slashes may be interpreted in "
"an implementation-defined manner, although more than two leading slashes "
"shall be treated as a single slash.\"*"
msgstr ""
"*「以兩個連續斜線開頭的路徑名稱可以根據實作定義的方式來解讀，儘管如此，開頭超"
"過兩個斜線應該視為單一斜線。」*"

#: ../../library/pathlib.rst:372
msgid "The concatenation of the drive and root::"
msgstr "磁碟機與根目錄的結合： ::"

#: ../../library/pathlib.rst:374
msgid ""
">>> PureWindowsPath('c:/Program Files/').anchor\n"
"'c:\\\\'\n"
">>> PureWindowsPath('c:Program Files/').anchor\n"
"'c:'\n"
">>> PurePosixPath('/etc').anchor\n"
"'/'\n"
">>> PureWindowsPath('//host/share').anchor\n"
"'\\\\\\\\host\\\\share\\\\'"
msgstr ""
">>> PureWindowsPath('c:/Program Files/').anchor\n"
"'c:\\\\'\n"
">>> PureWindowsPath('c:Program Files/').anchor\n"
"'c:'\n"
">>> PurePosixPath('/etc').anchor\n"
"'/'\n"
">>> PureWindowsPath('//host/share').anchor\n"
"'\\\\\\\\host\\\\share\\\\'"

#: ../../library/pathlib.rst:386
msgid ""
"An immutable sequence providing access to the logical ancestors of the path::"
msgstr "一個不可變的序列，為路徑邏輯上的祖先 (logical ancestors) 提供存取： ::"

#: ../../library/pathlib.rst:389
msgid ""
">>> p = PureWindowsPath('c:/foo/bar/setup.py')\n"
">>> p.parents[0]\n"
"PureWindowsPath('c:/foo/bar')\n"
">>> p.parents[1]\n"
"PureWindowsPath('c:/foo')\n"
">>> p.parents[2]\n"
"PureWindowsPath('c:/')"
msgstr ""
">>> p = PureWindowsPath('c:/foo/bar/setup.py')\n"
">>> p.parents[0]\n"
"PureWindowsPath('c:/foo/bar')\n"
">>> p.parents[1]\n"
"PureWindowsPath('c:/foo')\n"
">>> p.parents[2]\n"
"PureWindowsPath('c:/')"

#: ../../library/pathlib.rst:397
msgid ""
"The parents sequence now supports :term:`slices <slice>` and negative index "
"values."
msgstr "父序列現在支援 :term:`slices <slice>` 及負的索引值。"

#: ../../library/pathlib.rst:402
msgid "The logical parent of the path::"
msgstr "邏輯上的父路徑： ::"

#: ../../library/pathlib.rst:404
msgid ""
">>> p = PurePosixPath('/a/b/c/d')\n"
">>> p.parent\n"
"PurePosixPath('/a/b/c')"
msgstr ""
">>> p = PurePosixPath('/a/b/c/d')\n"
">>> p.parent\n"
"PurePosixPath('/a/b/c')"

#: ../../library/pathlib.rst:408
msgid "You cannot go past an anchor, or empty path::"
msgstr "你不能越過一個 anchor 或空路徑： ::"

#: ../../library/pathlib.rst:410
msgid ""
">>> p = PurePosixPath('/')\n"
">>> p.parent\n"
"PurePosixPath('/')\n"
">>> p = PurePosixPath('.')\n"
">>> p.parent\n"
"PurePosixPath('.')"
msgstr ""
">>> p = PurePosixPath('/')\n"
">>> p.parent\n"
"PurePosixPath('/')\n"
">>> p = PurePosixPath('.')\n"
">>> p.parent\n"
"PurePosixPath('.')"

#: ../../library/pathlib.rst:418
msgid "This is a purely lexical operation, hence the following behaviour::"
msgstr "這是一個純粹字句上的 (lexical) 運算，因此會有以下行為： ::"

#: ../../library/pathlib.rst:420
msgid ""
">>> p = PurePosixPath('foo/..')\n"
">>> p.parent\n"
"PurePosixPath('foo')"
msgstr ""
">>> p = PurePosixPath('foo/..')\n"
">>> p.parent\n"
"PurePosixPath('foo')"

#: ../../library/pathlib.rst:424
msgid ""
"If you want to walk an arbitrary filesystem path upwards, it is recommended "
"to first call :meth:`Path.resolve` so as to resolve symlinks and eliminate "
"``\"..\"`` components."
msgstr ""
"如果你想要沿任意的檔案系統路徑往上走，建議要先呼叫 :meth:`Path.resolve` 來解"
"析符號連結 (symlink) 及去除其中的 ``”..”``。"

#: ../../library/pathlib.rst:431
msgid ""
"A string representing the final path component, excluding the drive and "
"root, if any::"
msgstr ""
"最後的路徑組成 (final path component) 的字串表示，不包含任何磁碟機或根目"
"錄： ::"

#: ../../library/pathlib.rst:434
msgid ""
">>> PurePosixPath('my/library/setup.py').name\n"
"'setup.py'"
msgstr ""
">>> PurePosixPath('my/library/setup.py').name\n"
"'setup.py'"

#: ../../library/pathlib.rst:437
msgid "UNC drive names are not considered::"
msgstr "UNC 磁碟機名稱並沒有算在內： ::"

#: ../../library/pathlib.rst:439
msgid ""
">>> PureWindowsPath('//some/share/setup.py').name\n"
"'setup.py'\n"
">>> PureWindowsPath('//some/share').name\n"
"''"
msgstr ""
">>> PureWindowsPath('//some/share/setup.py').name\n"
"'setup.py'\n"
">>> PureWindowsPath('//some/share').name\n"
"''"

#: ../../library/pathlib.rst:447
msgid "The last dot-separated portion of the final component, if any::"
msgstr "以點分隔路徑的最後一個部分（如存在）： ::"

#: ../../library/pathlib.rst:449
msgid ""
">>> PurePosixPath('my/library/setup.py').suffix\n"
"'.py'\n"
">>> PurePosixPath('my/library.tar.gz').suffix\n"
"'.gz'\n"
">>> PurePosixPath('my/library').suffix\n"
"''"
msgstr ""
">>> PurePosixPath('my/library/setup.py').suffix\n"
"'.py'\n"
">>> PurePosixPath('my/library.tar.gz').suffix\n"
"'.gz'\n"
">>> PurePosixPath('my/library').suffix\n"
"''"

#: ../../library/pathlib.rst:456
msgid "This is commonly called the file extension."
msgstr "這通常被稱為檔案副檔名。"

#: ../../library/pathlib.rst:460
msgid "A list of the path's suffixes, often called file extensions::"
msgstr "一個路徑後綴 (suffix) 的串列，通常被稱為檔案副檔名： ::"

#: ../../library/pathlib.rst:462
msgid ""
">>> PurePosixPath('my/library.tar.gar').suffixes\n"
"['.tar', '.gar']\n"
">>> PurePosixPath('my/library.tar.gz').suffixes\n"
"['.tar', '.gz']\n"
">>> PurePosixPath('my/library').suffixes\n"
"[]"
msgstr ""
">>> PurePosixPath('my/library.tar.gar').suffixes\n"
"['.tar', '.gar']\n"
">>> PurePosixPath('my/library.tar.gz').suffixes\n"
"['.tar', '.gz']\n"
">>> PurePosixPath('my/library').suffixes\n"
"[]"

#: ../../library/pathlib.rst:472
msgid "The final path component, without its suffix::"
msgstr "最後的路徑組成，不包括後綴： ::"

#: ../../library/pathlib.rst:474
msgid ""
">>> PurePosixPath('my/library.tar.gz').stem\n"
"'library.tar'\n"
">>> PurePosixPath('my/library.tar').stem\n"
"'library'\n"
">>> PurePosixPath('my/library').stem\n"
"'library'"
msgstr ""
">>> PurePosixPath('my/library.tar.gz').stem\n"
"'library.tar'\n"
">>> PurePosixPath('my/library.tar').stem\n"
"'library'\n"
">>> PurePosixPath('my/library').stem\n"
"'library'"

#: ../../library/pathlib.rst:484
msgid ""
"Return a string representation of the path with forward slashes (``/``)::"
msgstr "回傳一個使用正斜線 (``/``) 的路徑的字串表示： ::"

#: ../../library/pathlib.rst:486
msgid ""
">>> p = PureWindowsPath('c:\\\\windows')\n"
">>> str(p)\n"
"'c:\\\\windows'\n"
">>> p.as_posix()\n"
"'c:/windows'"
msgstr ""
">>> p = PureWindowsPath('c:\\\\windows')\n"
">>> str(p)\n"
"'c:\\\\windows'\n"
">>> p.as_posix()\n"
"'c:/windows'"

#: ../../library/pathlib.rst:495
msgid ""
"Return whether the path is absolute or not.  A path is considered absolute "
"if it has both a root and (if the flavour allows) a drive::"
msgstr ""
"回傳一個路徑是否是絕對路徑。一個路徑被視為絕對路徑的條件是它同時有根目錄及"
"（如果該系統類型允許的話）磁碟機： ::"

#: ../../library/pathlib.rst:498
msgid ""
">>> PurePosixPath('/a/b').is_absolute()\n"
"True\n"
">>> PurePosixPath('a/b').is_absolute()\n"
"False\n"
"\n"
">>> PureWindowsPath('c:/a/b').is_absolute()\n"
"True\n"
">>> PureWindowsPath('/a/b').is_absolute()\n"
"False\n"
">>> PureWindowsPath('c:').is_absolute()\n"
"False\n"
">>> PureWindowsPath('//some/share').is_absolute()\n"
"True"
msgstr ""
">>> PurePosixPath('/a/b').is_absolute()\n"
"True\n"
">>> PurePosixPath('a/b').is_absolute()\n"
"False\n"
"\n"
">>> PureWindowsPath('c:/a/b').is_absolute()\n"
"True\n"
">>> PureWindowsPath('/a/b').is_absolute()\n"
"False\n"
">>> PureWindowsPath('c:').is_absolute()\n"
"False\n"
">>> PureWindowsPath('//some/share').is_absolute()\n"
"True"

#: ../../library/pathlib.rst:515
msgid "Return whether or not this path is relative to the *other* path."
msgstr "回傳此路徑是否為 *other* 路徑的相對路徑。"

#: ../../library/pathlib.rst:523
msgid ""
"This method is string-based; it neither accesses the filesystem nor treats "
"\"``..``\" segments specially. The following code is equivalent:"
msgstr ""
"該方法是基於字串的；它既不存取檔案系統，也不特別處理 \"``..``\" 片段。以下程"
"式碼是等效的："

#: ../../library/pathlib.rst:534
msgid ""
"Passing additional arguments is deprecated; if supplied, they are joined "
"with *other*."
msgstr "額外引數的傳入已棄用；如果有的話，它們會與 *other* 連接在一起。"

#: ../../library/pathlib.rst:539
msgid ""
"With :class:`PureWindowsPath`, return ``True`` if the path is considered "
"reserved under Windows, ``False`` otherwise.  With :class:`PurePosixPath`, "
"``False`` is always returned."
msgstr ""
"對 :class:`PureWindowsPath` 來說，當路徑在 Windows 下被視為保留的話會回傳 "
"``True``，否則回傳 ``False``。對 :class:`PurePosixPath` 來說，總是回傳 "
"``False``。"

#: ../../library/pathlib.rst:543
msgid ""
"Windows path names that contain a colon, or end with a dot or a space, are "
"considered reserved. UNC paths may be reserved."
msgstr ""
"Windows 路徑名稱中包含冒號或結尾為點或空格會被視為保留。UNC 路徑可能被視為保"
"留。"

#: ../../library/pathlib.rst:547
msgid ""
"This method is deprecated; use :func:`os.path.isreserved` to detect reserved "
"paths on Windows."
msgstr ""
"此方法已被棄用；請使用 :func:`os.path.isreserved` 來檢測 Windows 上的保留路"
"徑。"

#: ../../library/pathlib.rst:553
msgid ""
"Calling this method is equivalent to combining the path with each of the "
"given *pathsegments* in turn::"
msgstr "呼叫此方法會依序結合每個所給定的 *pathsegments* 到路徑上： ::"

#: ../../library/pathlib.rst:556
msgid ""
">>> PurePosixPath('/etc').joinpath('passwd')\n"
"PurePosixPath('/etc/passwd')\n"
">>> PurePosixPath('/etc').joinpath(PurePosixPath('passwd'))\n"
"PurePosixPath('/etc/passwd')\n"
">>> PurePosixPath('/etc').joinpath('init.d', 'apache2')\n"
"PurePosixPath('/etc/init.d/apache2')\n"
">>> PureWindowsPath('c:').joinpath('/Program Files')\n"
"PureWindowsPath('c:/Program Files')"
msgstr ""
">>> PurePosixPath('/etc').joinpath('passwd')\n"
"PurePosixPath('/etc/passwd')\n"
">>> PurePosixPath('/etc').joinpath(PurePosixPath('passwd'))\n"
"PurePosixPath('/etc/passwd')\n"
">>> PurePosixPath('/etc').joinpath('init.d', 'apache2')\n"
"PurePosixPath('/etc/init.d/apache2')\n"
">>> PureWindowsPath('c:').joinpath('/Program Files')\n"
"PureWindowsPath('c:/Program Files')"

#: ../../library/pathlib.rst:568
msgid ""
"Match this path against the provided glob-style pattern.  Return ``True`` if "
"matching is successful, ``False`` otherwise.  For example::"
msgstr ""
"將路徑與 glob 形式的模式 (glob-style pattern) 做比對。如果比對成功則回傳 "
"``True``，否則回傳 ``False``，例如： ::"

#: ../../library/pathlib.rst:571
msgid ""
">>> PurePath('a/b.py').full_match('a/*.py')\n"
"True\n"
">>> PurePath('a/b.py').full_match('*.py')\n"
"False\n"
">>> PurePath('/a/b/c.py').full_match('/a/**')\n"
"True\n"
">>> PurePath('/a/b/c.py').full_match('**/*.py')\n"
"True"
msgstr ""
">>> PurePath('a/b.py').full_match('a/*.py')\n"
"True\n"
">>> PurePath('a/b.py').full_match('*.py')\n"
"False\n"
">>> PurePath('/a/b/c.py').full_match('/a/**')\n"
"True\n"
">>> PurePath('/a/b/c.py').full_match('**/*.py')\n"
"True"

#: ../../library/pathlib.rst:581 ../../library/pathlib.rst:1291
msgid ":ref:`pathlib-pattern-language` documentation."
msgstr ":ref:`pathlib-pattern-language` 文件。"

#: ../../library/pathlib.rst:583
msgid "As with other methods, case-sensitivity follows platform defaults::"
msgstr "像其它方法一樣，是否區分大小寫會遵循平台的預設行為： ::"

#: ../../library/pathlib.rst:585
msgid ""
">>> PurePosixPath('b.py').full_match('*.PY')\n"
"False\n"
">>> PureWindowsPath('b.py').full_match('*.PY')\n"
"True"
msgstr ""
">>> PurePosixPath('b.py').full_match('*.PY')\n"
"False\n"
">>> PureWindowsPath('b.py').full_match('*.PY')\n"
"True"

#: ../../library/pathlib.rst:590
msgid ""
"Set *case_sensitive* to ``True`` or ``False`` to override this behaviour."
msgstr "將 *case_sensitive* 設定成 ``True`` 或 ``False`` 會覆蓋這個行為。"

#: ../../library/pathlib.rst:597
msgid ""
"Match this path against the provided non-recursive glob-style pattern. "
"Return ``True`` if matching is successful, ``False`` otherwise."
msgstr ""
"將路徑與非遞迴 glob 形式的模式 (glob-style pattern) 做比對。如果比對成功則回"
"傳 ``True``，否則回傳 ``False``。"

#: ../../library/pathlib.rst:600
msgid ""
"This method is similar to :meth:`~PurePath.full_match`, but empty patterns "
"aren't allowed (:exc:`ValueError` is raised), the recursive wildcard "
"\"``**``\" isn't supported (it acts like non-recursive \"``*``\"), and if a "
"relative pattern is provided, then matching is done from the right::"
msgstr ""
"此方法類似於 :meth:`~PurePath.full_match`，但不允許空白模式（會引發 :exc:"
"`ValueError`）、不支援遞迴萬用字元 \"``**``\"（它會像非遞迴的 \"``*``\" 一"
"樣），且如果提供相對模式，則會從右邊進行比對： ::"

#: ../../library/pathlib.rst:605
msgid ""
">>> PurePath('a/b.py').match('*.py')\n"
"True\n"
">>> PurePath('/a/b/c.py').match('b/*.py')\n"
"True\n"
">>> PurePath('/a/b/c.py').match('a/*.py')\n"
"False"
msgstr ""
">>> PurePath('a/b.py').match('*.py')\n"
"True\n"
">>> PurePath('/a/b/c.py').match('b/*.py')\n"
"True\n"
">>> PurePath('/a/b/c.py').match('a/*.py')\n"
"False"

#: ../../library/pathlib.rst:612 ../../library/pathlib.rst:1310
#: ../../library/pathlib.rst:1335
msgid "The *pattern* parameter accepts a :term:`path-like object`."
msgstr "*pattern* 參數接受\\ :term:`類路徑物件 <path-like object>`。"

#: ../../library/pathlib.rst:615 ../../library/pathlib.rst:1304
#: ../../library/pathlib.rst:1329
msgid "The *case_sensitive* parameter was added."
msgstr "新增 *case_sensitive* 參數。"

#: ../../library/pathlib.rst:621
msgid ""
"Compute a version of this path relative to the path represented by *other*.  "
"If it's impossible, :exc:`ValueError` is raised::"
msgstr ""
"計算這個路徑相對於 *other* 所表示路徑的版本。如果做不到會引發 :exc:"
"`ValueError`： ::"

#: ../../library/pathlib.rst:624
msgid ""
">>> p = PurePosixPath('/etc/passwd')\n"
">>> p.relative_to('/')\n"
"PurePosixPath('etc/passwd')\n"
">>> p.relative_to('/etc')\n"
"PurePosixPath('passwd')\n"
">>> p.relative_to('/usr')\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"  File \"pathlib.py\", line 941, in relative_to\n"
"    raise ValueError(error_message.format(str(self), str(formatted)))\n"
"ValueError: '/etc/passwd' is not in the subpath of '/usr' OR one path is "
"relative and the other is absolute."
msgstr ""
">>> p = PurePosixPath('/etc/passwd')\n"
">>> p.relative_to('/')\n"
"PurePosixPath('etc/passwd')\n"
">>> p.relative_to('/etc')\n"
"PurePosixPath('passwd')\n"
">>> p.relative_to('/usr')\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"  File \"pathlib.py\", line 941, in relative_to\n"
"    raise ValueError(error_message.format(str(self), str(formatted)))\n"
"ValueError: '/etc/passwd' is not in the subpath of '/usr' OR one path is "
"relative and the other is absolute."

#: ../../library/pathlib.rst:636
msgid ""
"When *walk_up* is false (the default), the path must start with *other*. "
"When the argument is true, ``..`` entries may be added to form the relative "
"path. In all other cases, such as the paths referencing different drives, :"
"exc:`ValueError` is raised.::"
msgstr ""
"當 *walk_up* 是 False（預設值），路徑必須以 *other* 為開始。當此引數是 True，"
"可能會加入 ``..`` 以組成相對路徑。在其他情況下，例如路徑參考到不同的磁碟機，"
"則會引發 :exc:`ValueError`： ::"

#: ../../library/pathlib.rst:641
msgid ""
">>> p.relative_to('/usr', walk_up=True)\n"
"PurePosixPath('../etc/passwd')\n"
">>> p.relative_to('foo', walk_up=True)\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"  File \"pathlib.py\", line 941, in relative_to\n"
"    raise ValueError(error_message.format(str(self), str(formatted)))\n"
"ValueError: '/etc/passwd' is not on the same drive as 'foo' OR one path is "
"relative and the other is absolute."
msgstr ""
">>> p.relative_to('/usr', walk_up=True)\n"
"PurePosixPath('../etc/passwd')\n"
">>> p.relative_to('foo', walk_up=True)\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"  File \"pathlib.py\", line 941, in relative_to\n"
"    raise ValueError(error_message.format(str(self), str(formatted)))\n"
"ValueError: '/etc/passwd' is not on the same drive as 'foo' OR one path is "
"relative and the other is absolute."

#: ../../library/pathlib.rst:651
msgid ""
"This function is part of :class:`PurePath` and works with strings. It does "
"not check or access the underlying file structure. This can impact the "
"*walk_up* option as it assumes that no symlinks are present in the path; "
"call :meth:`~Path.resolve` first if necessary to resolve symlinks."
msgstr ""
"這個函式是 :class:`PurePath` 的一部分且可以在字串上運作。它不會檢查或存取實際"
"的檔案架構。這會影響到 *walk_up* 選項，因為它假設路徑中沒有符號連結；如果需要"
"解析符號連結的話可以先呼叫 :meth:`~Path.resolve`。"

#: ../../library/pathlib.rst:657
msgid ""
"The *walk_up* parameter was added (old behavior is the same as "
"``walk_up=False``)."
msgstr "加入 *walk_up* 參數（舊的行為和 ``walk_up=False`` 相同）。"

#: ../../library/pathlib.rst:662
msgid ""
"Passing additional positional arguments is deprecated; if supplied, they are "
"joined with *other*."
msgstr "額外位置引數的傳入已棄用；如果有的話，它們會與 *other* 連接在一起。"

#: ../../library/pathlib.rst:667
msgid ""
"Return a new path with the :attr:`name` changed.  If the original path "
"doesn't have a name, ValueError is raised::"
msgstr ""
"回傳一個修改 :attr:`name` 後的新路徑。如果原始路徑沒有名稱則引發 "
"ValueError： ::"

#: ../../library/pathlib.rst:670
msgid ""
">>> p = PureWindowsPath('c:/Downloads/pathlib.tar.gz')\n"
">>> p.with_name('setup.py')\n"
"PureWindowsPath('c:/Downloads/setup.py')\n"
">>> p = PureWindowsPath('c:/')\n"
">>> p.with_name('setup.py')\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"  File \"/home/antoine/cpython/default/Lib/pathlib.py\", line 751, in "
"with_name\n"
"    raise ValueError(\"%r has an empty name\" % (self,))\n"
"ValueError: PureWindowsPath('c:/') has an empty name"
msgstr ""
">>> p = PureWindowsPath('c:/Downloads/pathlib.tar.gz')\n"
">>> p.with_name('setup.py')\n"
"PureWindowsPath('c:/Downloads/setup.py')\n"
">>> p = PureWindowsPath('c:/')\n"
">>> p.with_name('setup.py')\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"  File \"/home/antoine/cpython/default/Lib/pathlib.py\", line 751, in "
"with_name\n"
"    raise ValueError(\"%r has an empty name\" % (self,))\n"
"ValueError: PureWindowsPath('c:/') has an empty name"

#: ../../library/pathlib.rst:684
msgid ""
"Return a new path with the :attr:`stem` changed.  If the original path "
"doesn't have a name, ValueError is raised::"
msgstr ""
"回傳一個修改 :attr:`stem` 後的新路徑。如果原始路徑沒有名稱則引發 "
"ValueError： ::"

#: ../../library/pathlib.rst:687
msgid ""
">>> p = PureWindowsPath('c:/Downloads/draft.txt')\n"
">>> p.with_stem('final')\n"
"PureWindowsPath('c:/Downloads/final.txt')\n"
">>> p = PureWindowsPath('c:/Downloads/pathlib.tar.gz')\n"
">>> p.with_stem('lib')\n"
"PureWindowsPath('c:/Downloads/lib.gz')\n"
">>> p = PureWindowsPath('c:/')\n"
">>> p.with_stem('')\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"  File \"/home/antoine/cpython/default/Lib/pathlib.py\", line 861, in "
"with_stem\n"
"    return self.with_name(stem + self.suffix)\n"
"  File \"/home/antoine/cpython/default/Lib/pathlib.py\", line 851, in "
"with_name\n"
"    raise ValueError(\"%r has an empty name\" % (self,))\n"
"ValueError: PureWindowsPath('c:/') has an empty name"
msgstr ""
">>> p = PureWindowsPath('c:/Downloads/draft.txt')\n"
">>> p.with_stem('final')\n"
"PureWindowsPath('c:/Downloads/final.txt')\n"
">>> p = PureWindowsPath('c:/Downloads/pathlib.tar.gz')\n"
">>> p.with_stem('lib')\n"
"PureWindowsPath('c:/Downloads/lib.gz')\n"
">>> p = PureWindowsPath('c:/')\n"
">>> p.with_stem('')\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"  File \"/home/antoine/cpython/default/Lib/pathlib.py\", line 861, in "
"with_stem\n"
"    return self.with_name(stem + self.suffix)\n"
"  File \"/home/antoine/cpython/default/Lib/pathlib.py\", line 851, in "
"with_name\n"
"    raise ValueError(\"%r has an empty name\" % (self,))\n"
"ValueError: PureWindowsPath('c:/') has an empty name"

#: ../../library/pathlib.rst:708
msgid ""
"Return a new path with the :attr:`suffix` changed.  If the original path "
"doesn't have a suffix, the new *suffix* is appended instead.  If the "
"*suffix* is an empty string, the original suffix is removed::"
msgstr ""
"回傳一個修改 :attr:`suffix` 後的新路徑。如果原始路徑沒有後綴，新的 *suffix* "
"會附加在後面。如果 *suffix* 是一個空字串，原來的後綴會被移除： ::"

#: ../../library/pathlib.rst:712
msgid ""
">>> p = PureWindowsPath('c:/Downloads/pathlib.tar.gz')\n"
">>> p.with_suffix('.bz2')\n"
"PureWindowsPath('c:/Downloads/pathlib.tar.bz2')\n"
">>> p = PureWindowsPath('README')\n"
">>> p.with_suffix('.txt')\n"
"PureWindowsPath('README.txt')\n"
">>> p = PureWindowsPath('README.txt')\n"
">>> p.with_suffix('')\n"
"PureWindowsPath('README')"
msgstr ""
">>> p = PureWindowsPath('c:/Downloads/pathlib.tar.gz')\n"
">>> p.with_suffix('.bz2')\n"
"PureWindowsPath('c:/Downloads/pathlib.tar.bz2')\n"
">>> p = PureWindowsPath('README')\n"
">>> p.with_suffix('.txt')\n"
"PureWindowsPath('README.txt')\n"
">>> p = PureWindowsPath('README.txt')\n"
">>> p.with_suffix('')\n"
"PureWindowsPath('README')"

#: ../../library/pathlib.rst:725
msgid ""
"Create a new path object of the same type by combining the given "
"*pathsegments*. This method is called whenever a derivative path is created, "
"such as from :attr:`parent` and :meth:`relative_to`. Subclasses may override "
"this method to pass information to derivative paths, for example::"
msgstr ""
"透過結合給定的 *pathsegments* 建立一個相同型別的新路徑物件，當一個衍生路徑被"
"建立的時候會呼叫這個方法，例如從 :attr:`parent` 和 :meth:`relative_to` 建立衍"
"生路徑。子類別可以覆寫此方法來傳遞資訊給衍生路徑，例如： ::"

#: ../../library/pathlib.rst:730
msgid ""
"from pathlib import PurePosixPath\n"
"\n"
"class MyPath(PurePosixPath):\n"
"    def __init__(self, *pathsegments, session_id):\n"
"        super().__init__(*pathsegments)\n"
"        self.session_id = session_id\n"
"\n"
"    def with_segments(self, *pathsegments):\n"
"        return type(self)(*pathsegments, session_id=self.session_id)\n"
"\n"
"etc = MyPath('/etc', session_id=42)\n"
"hosts = etc / 'hosts'\n"
"print(hosts.session_id)  # 42"
msgstr ""
"from pathlib import PurePosixPath\n"
"\n"
"class MyPath(PurePosixPath):\n"
"    def __init__(self, *pathsegments, session_id):\n"
"        super().__init__(*pathsegments)\n"
"        self.session_id = session_id\n"
"\n"
"    def with_segments(self, *pathsegments):\n"
"        return type(self)(*pathsegments, session_id=self.session_id)\n"
"\n"
"etc = MyPath('/etc', session_id=42)\n"
"hosts = etc / 'hosts'\n"
"print(hosts.session_id)  # 42"

#: ../../library/pathlib.rst:751
msgid "Concrete paths"
msgstr "實體路徑"

#: ../../library/pathlib.rst:753
msgid ""
"Concrete paths are subclasses of the pure path classes.  In addition to "
"operations provided by the latter, they also provide methods to do system "
"calls on path objects.  There are three ways to instantiate concrete paths:"
msgstr ""
"實體路徑是純路徑類別的子類別。除了後者本來就有提供的操作，它們也提供方法可以"
"對路徑物件做系統呼叫。有三種方式可以實例化實體路徑："

#: ../../library/pathlib.rst:759
msgid ""
"A subclass of :class:`PurePath`, this class represents concrete paths of the "
"system's path flavour (instantiating it creates either a :class:`PosixPath` "
"or a :class:`WindowsPath`)::"
msgstr ""
":class:`PurePath` 的子類別，此類別表示系統的路徑類型的實體路徑（實例化時會建"
"立一個 :class:`PosixPath` 或 :class:`WindowsPath`）： ::"

#: ../../library/pathlib.rst:763
msgid ""
">>> Path('setup.py')\n"
"PosixPath('setup.py')"
msgstr ""
">>> Path('setup.py')\n"
"PosixPath('setup.py')"

#: ../../library/pathlib.rst:770
msgid ""
"A subclass of :class:`Path` and :class:`PurePosixPath`, this class "
"represents concrete non-Windows filesystem paths::"
msgstr ""
":class:`Path` 和 :class:`PurePosixPath` 的子類別，此類別表示實體非 Windows 檔"
"案系統路徑： ::"

#: ../../library/pathlib.rst:773
msgid ""
">>> PosixPath('/etc/hosts')\n"
"PosixPath('/etc/hosts')"
msgstr ""
">>> PosixPath('/etc/hosts')\n"
"PosixPath('/etc/hosts')"

#: ../../library/pathlib.rst:778
msgid ""
"Raises :exc:`UnsupportedOperation` on Windows. In previous versions, :exc:"
"`NotImplementedError` was raised instead."
msgstr ""
"在 Windows 上會引發 :exc:`UnsupportedOperation`。在先前版本中，則是引發 :exc:"
"`NotImplementedError`。"

#: ../../library/pathlib.rst:785
msgid ""
"A subclass of :class:`Path` and :class:`PureWindowsPath`, this class "
"represents concrete Windows filesystem paths::"
msgstr ""
":class:`Path` 和 :class:`PureWindowsPath` 的子類別，此類別表示實體 Windows 檔"
"案系統路徑： ::"

#: ../../library/pathlib.rst:788
msgid ""
">>> WindowsPath('c:/', 'Users', 'Ximénez')\n"
"WindowsPath('c:/Users/Ximénez')"
msgstr ""
">>> WindowsPath('c:/', 'Users', 'Ximénez')\n"
"WindowsPath('c:/Users/Ximénez')"

#: ../../library/pathlib.rst:793
msgid ""
"Raises :exc:`UnsupportedOperation` on non-Windows platforms. In previous "
"versions, :exc:`NotImplementedError` was raised instead."
msgstr ""
"在非 Windows 平台上會引發 :exc:`UnsupportedOperation`。在先前版本中，則是引"
"發 :exc:`NotImplementedError`。"

#: ../../library/pathlib.rst:798
msgid ""
"You can only instantiate the class flavour that corresponds to your system "
"(allowing system calls on non-compatible path flavours could lead to bugs or "
"failures in your application)::"
msgstr ""
"你只能實例化對應你的系統的類別類型（允許在不相容的路徑類型上做系統呼叫可能在"
"你的應用程式導致漏洞或故障）： ::"

#: ../../library/pathlib.rst:802
msgid ""
">>> import os\n"
">>> os.name\n"
"'posix'\n"
">>> Path('setup.py')\n"
"PosixPath('setup.py')\n"
">>> PosixPath('setup.py')\n"
"PosixPath('setup.py')\n"
">>> WindowsPath('setup.py')\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"  File \"pathlib.py\", line 798, in __new__\n"
"    % (cls.__name__,))\n"
"UnsupportedOperation: cannot instantiate 'WindowsPath' on your system"
msgstr ""
">>> import os\n"
">>> os.name\n"
"'posix'\n"
">>> Path('setup.py')\n"
"PosixPath('setup.py')\n"
">>> PosixPath('setup.py')\n"
"PosixPath('setup.py')\n"
">>> WindowsPath('setup.py')\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"  File \"pathlib.py\", line 798, in __new__\n"
"    % (cls.__name__,))\n"
"UnsupportedOperation: cannot instantiate 'WindowsPath' on your system"

#: ../../library/pathlib.rst:816
msgid ""
"Some concrete path methods can raise an :exc:`OSError` if a system call "
"fails (for example because the path doesn't exist)."
msgstr ""
"有些實體路徑方法會在系統呼叫失敗（例如因為路徑不存在）時引發 :exc:`OSError`。"

#: ../../library/pathlib.rst:821
msgid "Parsing and generating URIs"
msgstr "剖析和產生 URI"

#: ../../library/pathlib.rst:823
msgid ""
"Concrete path objects can be created from, and represented as, 'file' URIs "
"conforming to :rfc:`8089`."
msgstr ""
"實體路徑物件可以從符合 :rfc:`8089` 中的 'file' URI 建立，也可以以該形式來表"
"示。"

#: ../../library/pathlib.rst:828
msgid ""
"File URIs are not portable across machines with different :ref:`filesystem "
"encodings <filesystem-encoding>`."
msgstr ""
"檔案 URI 在跨不同\\ :ref:`檔案系統編碼 <filesystem-encoding>`\\ 的機器上是無"
"法移植的。"

#: ../../library/pathlib.rst:833
msgid "Return a new path object from parsing a 'file' URI. For example::"
msgstr "從剖析 'file' URI 回傳新的路徑物件。例如： ::"

#: ../../library/pathlib.rst:835
msgid ""
">>> p = Path.from_uri('file:///etc/hosts')\n"
"PosixPath('/etc/hosts')"
msgstr ""
">>> p = Path.from_uri('file:///etc/hosts')\n"
"PosixPath('/etc/hosts')"

#: ../../library/pathlib.rst:838
msgid "On Windows, DOS device and UNC paths may be parsed from URIs::"
msgstr "在 Windows 上，從 URI 可以剖析 DOS 裝置和 UNC 路徑： ::"

#: ../../library/pathlib.rst:840
msgid ""
">>> p = Path.from_uri('file:///c:/windows')\n"
"WindowsPath('c:/windows')\n"
">>> p = Path.from_uri('file://server/share')\n"
"WindowsPath('//server/share')"
msgstr ""
">>> p = Path.from_uri('file:///c:/windows')\n"
"WindowsPath('c:/windows')\n"
">>> p = Path.from_uri('file://server/share')\n"
"WindowsPath('//server/share')"

#: ../../library/pathlib.rst:845
msgid "Several variant forms are supported::"
msgstr "支援多種變形： ::"

#: ../../library/pathlib.rst:847
msgid ""
">>> p = Path.from_uri('file:////server/share')\n"
"WindowsPath('//server/share')\n"
">>> p = Path.from_uri('file://///server/share')\n"
"WindowsPath('//server/share')\n"
">>> p = Path.from_uri('file:c:/windows')\n"
"WindowsPath('c:/windows')\n"
">>> p = Path.from_uri('file:/c|/windows')\n"
"WindowsPath('c:/windows')"
msgstr ""
">>> p = Path.from_uri('file:////server/share')\n"
"WindowsPath('//server/share')\n"
">>> p = Path.from_uri('file://///server/share')\n"
"WindowsPath('//server/share')\n"
">>> p = Path.from_uri('file:c:/windows')\n"
"WindowsPath('c:/windows')\n"
">>> p = Path.from_uri('file:/c|/windows')\n"
"WindowsPath('c:/windows')"

#: ../../library/pathlib.rst:856
msgid ""
":exc:`ValueError` is raised if the URI does not start with ``file:``, or the "
"parsed path isn't absolute."
msgstr ""
"如果 URI 不是 ``file:`` 開頭，或是剖析後的路徑不是絕對路徑，則會引發 :exc:"
"`ValueError`。"

#: ../../library/pathlib.rst:864
msgid ""
"Represent the path as a 'file' URI.  :exc:`ValueError` is raised if the path "
"isn't absolute."
msgstr ""
"以 'file' URI 來表示路徑。如果路徑不是絕對的則會引發 :exc:`ValueError`。"

#: ../../library/pathlib.rst:867
msgid ""
">>> p = PosixPath('/etc/passwd')\n"
">>> p.as_uri()\n"
"'file:///etc/passwd'\n"
">>> p = WindowsPath('c:/Windows')\n"
">>> p.as_uri()\n"
"'file:///c:/Windows'"
msgstr ""
">>> p = PosixPath('/etc/passwd')\n"
">>> p.as_uri()\n"
"'file:///etc/passwd'\n"
">>> p = WindowsPath('c:/Windows')\n"
">>> p.as_uri()\n"
"'file:///c:/Windows'"

#: ../../library/pathlib.rst:876
msgid ""
"For historical reasons, this method is also available from :class:`PurePath` "
"objects. However, its use of :func:`os.fsencode` makes it strictly impure."
msgstr ""
"因為歷史上的原因，此方法也可以從 :class:`PurePath` 物件上使用。然而，它使用 :"
"func:`os.fsencode` 而讓它完全不純粹。"

#: ../../library/pathlib.rst:882
msgid "Expanding and resolving paths"
msgstr "擴展和解析路徑"

#: ../../library/pathlib.rst:886
msgid ""
"Return a new path object representing the user's home directory (as returned "
"by :func:`os.path.expanduser` with ``~`` construct). If the home directory "
"can't be resolved, :exc:`RuntimeError` is raised."
msgstr ""
"回傳一個代表使用者家目錄的新的路徑物件（像以 ``~`` 構成的 :func:`os.path."
"expanduser` 的回傳一樣）。如果無法解析家目錄，會引發 :exc:`RuntimeError`。"

#: ../../library/pathlib.rst:892
msgid ""
">>> Path.home()\n"
"PosixPath('/home/antoine')"
msgstr ""
">>> Path.home()\n"
"PosixPath('/home/antoine')"

#: ../../library/pathlib.rst:900
msgid ""
"Return a new path with expanded ``~`` and ``~user`` constructs, as returned "
"by :meth:`os.path.expanduser`. If a home directory can't be resolved, :exc:"
"`RuntimeError` is raised."
msgstr ""
"回傳一個展開 ``~`` 和 ``~user`` 構成的新路徑，像 :meth:`os.path.expanduser` "
"回傳的一樣。如果無法解析家目錄，會引發 :exc:`RuntimeError`。"

#: ../../library/pathlib.rst:906
msgid ""
">>> p = PosixPath('~/films/Monty Python')\n"
">>> p.expanduser()\n"
"PosixPath('/home/eric/films/Monty Python')"
msgstr ""
">>> p = PosixPath('~/films/Monty Python')\n"
">>> p.expanduser()\n"
"PosixPath('/home/eric/films/Monty Python')"

#: ../../library/pathlib.rst:915
msgid ""
"Return a new path object representing the current directory (as returned by :"
"func:`os.getcwd`)::"
msgstr ""
"回傳一個代表目前目錄的新的路徑物件（像 :func:`os.getcwd` 回傳的一樣）： ::"

#: ../../library/pathlib.rst:918
msgid ""
">>> Path.cwd()\n"
"PosixPath('/home/antoine/pathlib')"
msgstr ""
">>> Path.cwd()\n"
"PosixPath('/home/antoine/pathlib')"

#: ../../library/pathlib.rst:924
msgid ""
"Make the path absolute, without normalization or resolving symlinks. Returns "
"a new path object::"
msgstr ""
"將路徑轉換為絕對路徑，不進行標準化或解析符號連結。回傳一個新的路徑物件： ::"

#: ../../library/pathlib.rst:927
msgid ""
">>> p = Path('tests')\n"
">>> p\n"
"PosixPath('tests')\n"
">>> p.absolute()\n"
"PosixPath('/home/antoine/pathlib/tests')"
msgstr ""
">>> p = Path('tests')\n"
">>> p\n"
"PosixPath('tests')\n"
">>> p.absolute()\n"
"PosixPath('/home/antoine/pathlib/tests')"

#: ../../library/pathlib.rst:936
msgid ""
"Make the path absolute, resolving any symlinks.  A new path object is "
"returned::"
msgstr "將路徑轉換為絕對路徑，解析所有符號連結。回傳一個新的路徑物件： ::"

#: ../../library/pathlib.rst:939
msgid ""
">>> p = Path()\n"
">>> p\n"
"PosixPath('.')\n"
">>> p.resolve()\n"
"PosixPath('/home/antoine/pathlib')"
msgstr ""
">>> p = Path()\n"
">>> p\n"
"PosixPath('.')\n"
">>> p.resolve()\n"
"PosixPath('/home/antoine/pathlib')"

#: ../../library/pathlib.rst:945
msgid ""
"\"``..``\" components are also eliminated (this is the only method to do "
"so)::"
msgstr "同時也會消除 \"``..``\" 的路徑組成（只有此方法這樣做）： ::"

#: ../../library/pathlib.rst:947
msgid ""
">>> p = Path('docs/../setup.py')\n"
">>> p.resolve()\n"
"PosixPath('/home/antoine/pathlib/setup.py')"
msgstr ""
">>> p = Path('docs/../setup.py')\n"
">>> p.resolve()\n"
"PosixPath('/home/antoine/pathlib/setup.py')"

#: ../../library/pathlib.rst:951
msgid ""
"If a path doesn't exist or a symlink loop is encountered, and *strict* is "
"``True``, :exc:`OSError` is raised.  If *strict* is ``False``, the path is "
"resolved as far as possible and any remainder is appended without checking "
"whether it exists."
msgstr ""
"如果路徑不存在或遇到符號連結迴圈，且 *strict* 為 ``True``，則引發 :exc:"
"`OSError`。如果 *strict* 為 ``False``，則將盡可能解析該路徑，並將任何剩餘部分"
"追加到路徑中，而不檢查其是否存在。"

#: ../../library/pathlib.rst:956
msgid "The *strict* parameter was added (pre-3.6 behavior is strict)."
msgstr "新增 *strict* 參數（在 3.6 版本之前的行為是嚴格的）。"

#: ../../library/pathlib.rst:959
msgid ""
"Symlink loops are treated like other errors: :exc:`OSError` is raised in "
"strict mode, and no exception is raised in non-strict mode. In previous "
"versions, :exc:`RuntimeError` is raised no matter the value of *strict*."
msgstr ""
"在嚴格模式下，符號連結迴圈會像其他錯誤一樣來處理：:exc:`OSError` 會被引發，而"
"在非嚴格模式下，不會引發任何例外。在先前版本中，不管 *strict* 的值是什麼，都"
"會引發 :exc:`RuntimeError`。"

#: ../../library/pathlib.rst:967
msgid ""
"Return the path to which the symbolic link points (as returned by :func:`os."
"readlink`)::"
msgstr "回傳符號連結指向的路徑（如 :func:`os.readlink` 的回傳值）： ::"

#: ../../library/pathlib.rst:970
msgid ""
">>> p = Path('mylink')\n"
">>> p.symlink_to('setup.py')\n"
">>> p.readlink()\n"
"PosixPath('setup.py')"
msgstr ""
">>> p = Path('mylink')\n"
">>> p.symlink_to('setup.py')\n"
">>> p.readlink()\n"
"PosixPath('setup.py')"

#: ../../library/pathlib.rst:977
msgid ""
"Raises :exc:`UnsupportedOperation` if :func:`os.readlink` is not available. "
"In previous versions, :exc:`NotImplementedError` was raised."
msgstr ""
"如果 :func:`os.readlink` 不可用，會引發 :exc:`UnsupportedOperation`。在先前版"
"本中，則是引發 :exc:`NotImplementedError`。"

#: ../../library/pathlib.rst:983
msgid "Querying file type and status"
msgstr "查詢檔案類型和狀態"

#: ../../library/pathlib.rst:987
msgid ""
":meth:`~Path.exists`, :meth:`~Path.is_dir`, :meth:`~Path.is_file`, :meth:"
"`~Path.is_mount`, :meth:`~Path.is_symlink`, :meth:`~Path.is_block_device`, :"
"meth:`~Path.is_char_device`, :meth:`~Path.is_fifo`, :meth:`~Path.is_socket` "
"now return ``False`` instead of raising an exception for paths that contain "
"characters unrepresentable at the OS level."
msgstr ""
":meth:`~Path.exists`、:meth:`~Path.is_dir`、:meth:`~Path.is_file`、:meth:"
"`~Path.is_mount`、:meth:`~Path.is_symlink`、:meth:`~Path.is_block_device`、:"
"meth:`~Path.is_char_device`、:meth:`~Path.is_fifo`、:meth:`~Path.is_socket` "
"遇到路徑包含 OS 層無法表示的字元時現在會回傳 ``False`` 而不是引發例外。"

#: ../../library/pathlib.rst:997
msgid ""
"Return an :class:`os.stat_result` object containing information about this "
"path, like :func:`os.stat`. The result is looked up at each call to this "
"method."
msgstr ""
"回傳一個包含該路徑資訊的 :class:`os.stat_result` 物件，像 :func:`os.stat` 一"
"樣。每次呼叫此方法都會重新查詢結果。"

#: ../../library/pathlib.rst:1000
msgid ""
"This method normally follows symlinks; to stat a symlink add the argument "
"``follow_symlinks=False``, or use :meth:`~Path.lstat`."
msgstr ""
"此方法通常會跟隨 (follow) 符號連結；想要取得符號連結的資訊，可以加上引數 "
"``follow_symlinks=False`` 或使用 :meth:`~Path.lstat`。"

#: ../../library/pathlib.rst:1005
msgid ""
">>> p = Path('setup.py')\n"
">>> p.stat().st_size\n"
"956\n"
">>> p.stat().st_mtime\n"
"1327883547.852554"
msgstr ""
">>> p = Path('setup.py')\n"
">>> p.stat().st_size\n"
"956\n"
">>> p.stat().st_mtime\n"
"1327883547.852554"

#: ../../library/pathlib.rst:1011 ../../library/pathlib.rst:1039
#: ../../library/pathlib.rst:1054 ../../library/pathlib.rst:1069
#: ../../library/pathlib.rst:1600 ../../library/pathlib.rst:1616
#: ../../library/pathlib.rst:1637
msgid "The *follow_symlinks* parameter was added."
msgstr "新增 *follow_symlinks* 參數。"

#: ../../library/pathlib.rst:1017
msgid ""
"Like :meth:`Path.stat` but, if the path points to a symbolic link, return "
"the symbolic link's information rather than its target's."
msgstr ""
"類似 :meth:`Path.stat`，但如果該路徑指向一個符號連結，則回傳符號連結的資訊而"
"不是其指向的目標。"

#: ../../library/pathlib.rst:1023
msgid "Return ``True`` if the path points to an existing file or directory."
msgstr "如果路徑指向存在的檔案或目錄則回傳 ``True``。"

#: ../../library/pathlib.rst:1025
msgid ""
"This method normally follows symlinks; to check if a symlink exists, add the "
"argument ``follow_symlinks=False``."
msgstr ""
"此方法通常會跟隨符號連結；如果想檢查符號連結是否存在，可以加上引數 "
"``follow_symlinks=False``。"

#: ../../library/pathlib.rst:1030
msgid ""
">>> Path('.').exists()\n"
"True\n"
">>> Path('setup.py').exists()\n"
"True\n"
">>> Path('/etc').exists()\n"
"True\n"
">>> Path('nonexistentfile').exists()\n"
"False"
msgstr ""
">>> Path('.').exists()\n"
"True\n"
">>> Path('setup.py').exists()\n"
"True\n"
">>> Path('/etc').exists()\n"
"True\n"
">>> Path('nonexistentfile').exists()\n"
"False"

#: ../../library/pathlib.rst:1045
msgid ""
"Return ``True`` if the path points to a regular file, ``False`` if it points "
"to another kind of file."
msgstr ""
"如果該路徑指向一個普通檔案則回傳 ``True``，如果指向其他類型的檔案則回傳 "
"``False``。"

#: ../../library/pathlib.rst:1048 ../../library/pathlib.rst:1063
#: ../../library/pathlib.rst:1111 ../../library/pathlib.rst:1120
#: ../../library/pathlib.rst:1129 ../../library/pathlib.rst:1138
msgid ""
"``False`` is also returned if the path doesn't exist or is a broken symlink; "
"other errors (such as permission errors) are propagated."
msgstr ""
"如果路徑不存在或者是一個斷掉的符號連結則也會回傳 ``False``；其他錯誤（例如權"
"限錯誤）則會傳遞出來。"

#: ../../library/pathlib.rst:1051
msgid ""
"This method normally follows symlinks; to exclude symlinks, add the argument "
"``follow_symlinks=False``."
msgstr ""
"此方法通常會跟隨符號連結；如果想將符號連結除外，可以加上引數 "
"``follow_symlinks=False``。"

#: ../../library/pathlib.rst:1060
msgid ""
"Return ``True`` if the path points to a directory, ``False`` if it points to "
"another kind of file."
msgstr ""
"如果該路徑指向一個目錄則回傳 ``True``，如果指向其他類型的檔案則回傳 "
"``False``。"

#: ../../library/pathlib.rst:1066
msgid ""
"This method normally follows symlinks; to exclude symlinks to directories, "
"add the argument ``follow_symlinks=False``."
msgstr ""
"此方法通常會跟隨符號連結；如果想將對目錄的符號連結除外，可以加上引數 "
"``follow_symlinks=False``。"

#: ../../library/pathlib.rst:1075
msgid ""
"Return ``True`` if the path points to a symbolic link, ``False`` otherwise."
msgstr "如果該路徑指向一個符號連結則回傳 ``True``，否則回傳 ``False``。"

#: ../../library/pathlib.rst:1077
msgid ""
"``False`` is also returned if the path doesn't exist; other errors (such as "
"permission errors) are propagated."
msgstr ""
"如果該路徑不存在也會回傳 ``False``；其他錯誤（例如權限錯誤）則會傳遞出來。"

#: ../../library/pathlib.rst:1083
msgid ""
"Return ``True`` if the path points to a junction, and ``False`` for any "
"other type of file. Currently only Windows supports junctions."
msgstr ""
"如果該路徑指向一個連接點 (junction) 則回傳 ``True``，對其他類型的檔案則回傳 "
"``False``。目前只有 Windows 支援連接點。"

#: ../../library/pathlib.rst:1091
msgid ""
"Return ``True`` if the path is a :dfn:`mount point`: a point in a file "
"system where a different file system has been mounted.  On POSIX, the "
"function checks whether *path*'s parent, :file:`path/..`, is on a different "
"device than *path*, or whether :file:`path/..` and *path* point to the same "
"i-node on the same device --- this should detect mount points for all Unix "
"and POSIX variants.  On Windows, a mount point is considered to be a drive "
"letter root (e.g. ``c:\\``), a UNC share (e.g. ``\\\\server\\share``), or a "
"mounted filesystem directory."
msgstr ""
"如果路徑是一個 :dfn:`mount point`\\ （一個檔案系統裡掛載不同檔案系統的存取"
"點）則回傳 ``True``。在 POSIX 上，此函式檢查 *path* 的父路徑 :file:`path/..` "
"是否和 *path* 在不同的裝置上，或者 :file:`path/..` 和 *path* 是否指向相同裝置"
"的相同 i-node ── 這對於所有 Unix 和 POSIX 變體來說應該會偵測出掛載點。在 "
"Windows 上，一個掛載點被視為一個根磁碟機字母（例如 ``c:\\``）、一個 UNC share"
"（例如 ``\\\\server\\share``）或是掛載的檔案系統目錄。"

#: ../../library/pathlib.rst:1102
msgid "Windows support was added."
msgstr "加入對 Windows 的支援。"

#: ../../library/pathlib.rst:1108
msgid ""
"Return ``True`` if the path points to a Unix socket (or a symbolic link "
"pointing to a Unix socket), ``False`` if it points to another kind of file."
msgstr ""
"如果該路徑指向一個 Unix socket（或者是一個指向 Unix socket 的符號連結）則會回"
"傳 ``True``，如果指向其他類型的檔案則回傳 ``False``。"

#: ../../library/pathlib.rst:1117
msgid ""
"Return ``True`` if the path points to a FIFO (or a symbolic link pointing to "
"a FIFO), ``False`` if it points to another kind of file."
msgstr ""
"如果該路徑指向一個 FIFO（或者是一個指向 FIFO 的符號連結）則會回傳 ``True``，"
"如果指向其他類型的檔案則回傳 ``False``。"

#: ../../library/pathlib.rst:1126
msgid ""
"Return ``True`` if the path points to a block device (or a symbolic link "
"pointing to a block device), ``False`` if it points to another kind of file."
msgstr ""
"如果該路徑指向一個區塊裝置 (block device)（或者是一個指向區塊裝置的符號連結）"
"則會回傳 ``True``，如果指向其他類型的檔案則回傳 ``False``。"

#: ../../library/pathlib.rst:1135
msgid ""
"Return ``True`` if the path points to a character device (or a symbolic link "
"pointing to a character device), ``False`` if it points to another kind of "
"file."
msgstr ""
"如果該路徑指向一個字元裝置 (character device)（或者是一個指向字元裝置的符號連"
"結）則會回傳 ``True``，如果指向其他類型的檔案則回傳 ``False``。"

#: ../../library/pathlib.rst:1144
msgid ""
"Return whether this path points to the same file as *other_path*, which can "
"be either a Path object, or a string.  The semantics are similar to :func:"
"`os.path.samefile` and :func:`os.path.samestat`."
msgstr ""
"回傳此路徑是否指向與 *other_path* 相同的檔案，*other_path* 可以是路徑 (Path) "
"物件或字串。其語義類似於 :func:`os.path.samefile` 和 :func:`os.path."
"samestat`。"

#: ../../library/pathlib.rst:1148
msgid ""
"An :exc:`OSError` can be raised if either file cannot be accessed for some "
"reason."
msgstr "若任何一個檔案因為某些原因無法存取，則引發 :exc:`OSError`。"

#: ../../library/pathlib.rst:1153
msgid ""
">>> p = Path('spam')\n"
">>> q = Path('eggs')\n"
">>> p.samefile(q)\n"
"False\n"
">>> p.samefile('spam')\n"
"True"
msgstr ""
">>> p = Path('spam')\n"
">>> q = Path('eggs')\n"
">>> p.samefile(q)\n"
"False\n"
">>> p.samefile('spam')\n"
"True"

#: ../../library/pathlib.rst:1164
msgid "Reading and writing files"
msgstr "讀取和寫入檔案"

#: ../../library/pathlib.rst:1169
msgid ""
"Open the file pointed to by the path, like the built-in :func:`open` "
"function does::"
msgstr "開啟該路徑指向的檔案，像內建的 :func:`open` 函式做的一樣： ::"

#: ../../library/pathlib.rst:1172
msgid ""
">>> p = Path('setup.py')\n"
">>> with p.open() as f:\n"
"...     f.readline()\n"
"...\n"
"'#!/usr/bin/env python3\\n'"
msgstr ""
">>> p = Path('setup.py')\n"
">>> with p.open() as f:\n"
"...     f.readline()\n"
"...\n"
"'#!/usr/bin/env python3\\n'"

#: ../../library/pathlib.rst:1181
msgid "Return the decoded contents of the pointed-to file as a string::"
msgstr "將路徑指向的檔案的解碼內容以字串形式回傳： ::"

#: ../../library/pathlib.rst:1183 ../../library/pathlib.rst:1216
msgid ""
">>> p = Path('my_text_file')\n"
">>> p.write_text('Text file contents')\n"
"18\n"
">>> p.read_text()\n"
"'Text file contents'"
msgstr ""
">>> p = Path('my_text_file')\n"
">>> p.write_text('Text file contents')\n"
"18\n"
">>> p.read_text()\n"
"'Text file contents'"

#: ../../library/pathlib.rst:1189
msgid ""
"The file is opened and then closed. The optional parameters have the same "
"meaning as in :func:`open`."
msgstr "該檔案被打開並且隨後關閉。可選參數的含義與 :func:`open` 中的相同。"

#: ../../library/pathlib.rst:1194 ../../library/pathlib.rst:1227
msgid "The *newline* parameter was added."
msgstr "新增 *newline* 參數。"

#: ../../library/pathlib.rst:1200
msgid "Return the binary contents of the pointed-to file as a bytes object::"
msgstr "將路徑指向的檔案的二進位內容以一個位元組物件回傳： ::"

#: ../../library/pathlib.rst:1202 ../../library/pathlib.rst:1236
msgid ""
">>> p = Path('my_binary_file')\n"
">>> p.write_bytes(b'Binary file contents')\n"
"20\n"
">>> p.read_bytes()\n"
"b'Binary file contents'"
msgstr ""
">>> p = Path('my_binary_file')\n"
">>> p.write_bytes(b'Binary file contents')\n"
"20\n"
">>> p.read_bytes()\n"
"b'Binary file contents'"

#: ../../library/pathlib.rst:1213
msgid ""
"Open the file pointed to in text mode, write *data* to it, and close the "
"file::"
msgstr "以文字模式開啟指向的檔案，將 *data* 寫到檔案，並關閉檔案:: ："

#: ../../library/pathlib.rst:1222
msgid ""
"An existing file of the same name is overwritten. The optional parameters "
"have the same meaning as in :func:`open`."
msgstr ""
"一個名稱相同的已存在檔案會被覆寫。可選參數和 :func:`open` 的參數有相同意義。"

#: ../../library/pathlib.rst:1233
msgid ""
"Open the file pointed to in bytes mode, write *data* to it, and close the "
"file::"
msgstr "以位元組模式開啟指向的檔案，將 *data* 寫到檔案，並關閉檔案:: ："

#: ../../library/pathlib.rst:1242
msgid "An existing file of the same name is overwritten."
msgstr "一個名稱相同的已存在檔案會被覆寫。"

#: ../../library/pathlib.rst:1248
msgid "Reading directories"
msgstr "讀取目錄"

#: ../../library/pathlib.rst:1252
msgid ""
"When the path points to a directory, yield path objects of the directory "
"contents::"
msgstr "當該路徑指向一個目錄，會 yield 目錄裡面的路徑物件： ::"

#: ../../library/pathlib.rst:1255
msgid ""
">>> p = Path('docs')\n"
">>> for child in p.iterdir(): child\n"
"...\n"
"PosixPath('docs/conf.py')\n"
"PosixPath('docs/_templates')\n"
"PosixPath('docs/make.bat')\n"
"PosixPath('docs/index.rst')\n"
"PosixPath('docs/_build')\n"
"PosixPath('docs/_static')\n"
"PosixPath('docs/Makefile')"
msgstr ""
">>> p = Path('docs')\n"
">>> for child in p.iterdir(): child\n"
"...\n"
"PosixPath('docs/conf.py')\n"
"PosixPath('docs/_templates')\n"
"PosixPath('docs/make.bat')\n"
"PosixPath('docs/index.rst')\n"
"PosixPath('docs/_build')\n"
"PosixPath('docs/_static')\n"
"PosixPath('docs/Makefile')"

#: ../../library/pathlib.rst:1266
msgid ""
"The children are yielded in arbitrary order, and the special entries ``'.'`` "
"and ``'..'`` are not included.  If a file is removed from or added to the "
"directory after creating the iterator, it is unspecified whether a path "
"object for that file is included."
msgstr ""
"子路徑會以任意順序被 yield，且不會包含特殊項目 ``'.'`` 和 ``'..'``。如果一個"
"檔案在建立這個疊代器之後加到該目錄或從目錄刪除，這個檔案的路徑物件是否會被包"
"含是沒有明定的。"

#: ../../library/pathlib.rst:1271
msgid ""
"If the path is not a directory or otherwise inaccessible, :exc:`OSError` is "
"raised."
msgstr "如果路徑不是目錄或無法存取，則會引發 :exc:`OSError`。"

#: ../../library/pathlib.rst:1276
msgid ""
"Glob the given relative *pattern* in the directory represented by this path, "
"yielding all matching files (of any kind)::"
msgstr ""
"在該路徑表示的目錄裡，以 glob 方式比對所給定的相對 *pattern*，並 yield 所有比"
"對到的檔案（任意類型）： ::"

#: ../../library/pathlib.rst:1279
msgid ""
">>> sorted(Path('.').glob('*.py'))\n"
"[PosixPath('pathlib.py'), PosixPath('setup.py'), PosixPath('test_pathlib."
"py')]\n"
">>> sorted(Path('.').glob('*/*.py'))\n"
"[PosixPath('docs/conf.py')]\n"
">>> sorted(Path('.').glob('**/*.py'))\n"
"[PosixPath('build/lib/pathlib.py'),\n"
" PosixPath('docs/conf.py'),\n"
" PosixPath('pathlib.py'),\n"
" PosixPath('setup.py'),\n"
" PosixPath('test_pathlib.py')]"
msgstr ""
">>> sorted(Path('.').glob('*.py'))\n"
"[PosixPath('pathlib.py'), PosixPath('setup.py'), PosixPath('test_pathlib."
"py')]\n"
">>> sorted(Path('.').glob('*/*.py'))\n"
"[PosixPath('docs/conf.py')]\n"
">>> sorted(Path('.').glob('**/*.py'))\n"
"[PosixPath('build/lib/pathlib.py'),\n"
" PosixPath('docs/conf.py'),\n"
" PosixPath('pathlib.py'),\n"
" PosixPath('setup.py'),\n"
" PosixPath('test_pathlib.py')]"

#: ../../library/pathlib.rst:1293
msgid ""
"By default, or when the *case_sensitive* keyword-only argument is set to "
"``None``, this method matches paths using platform-specific casing rules: "
"typically, case-sensitive on POSIX, and case-insensitive on Windows. Set "
"*case_sensitive* to ``True`` or ``False`` to override this behaviour."
msgstr ""
"預設情況下，或者當 *case_sensitive* 僅限關鍵字引數被設定為 ``None`` 的時候，"
"此方法會使用平台特定的大小寫規則來比對路徑；通常在 POSIX 上會區分大小寫，而"
"在 Windows 上不區分大小寫。將 *case_sensitive* 設成 ``True`` 或 ``False`` 會"
"覆寫這個行為。"

#: ../../library/pathlib.rst:1298
msgid ""
"By default, or when the *recurse_symlinks* keyword-only argument is set to "
"``False``, this method follows symlinks except when expanding \"``**``\" "
"wildcards. Set *recurse_symlinks* to ``True`` to always follow symlinks."
msgstr ""
"預設情況下，或者當 *recurse_symlinks* 僅限關鍵字引數被設定為 ``False`` 的時"
"候，此方法會跟隨符號連結，除非在擴展 \"``**``\" 萬用字元時。將 "
"*recurse_symlinks* 設成 ``True`` 以總是跟隨符號連結。"

#: ../../library/pathlib.rst:1302
msgid ""
"Raises an :ref:`auditing event <auditing>` ``pathlib.Path.glob`` with "
"arguments ``self``, ``pattern``."
msgstr ""
"引發一個附帶引數 ``self``、``pattern`` 的\\ :ref:`稽核事件 <auditing>` "
"``pathlib.Path.glob``。"

#: ../../library/pathlib.rst:1307 ../../library/pathlib.rst:1332
msgid "The *recurse_symlinks* parameter was added."
msgstr "新增 *recurse_symlinks* 參數。"

#: ../../library/pathlib.rst:1313
msgid ""
"Any :exc:`OSError` exceptions raised from scanning the filesystem are "
"suppressed. In previous versions, such exceptions are suppressed in many "
"cases, but not all."
msgstr ""
"從掃描檔案系統引發的任何 :exc:`OSError` 例外都會被抑制。在先前版本中，在許多"
"情況下這種例外都會被抑制，但不是所有情況。"

#: ../../library/pathlib.rst:1321
msgid ""
"Glob the given relative *pattern* recursively.  This is like calling :func:"
"`Path.glob` with \"``**/``\" added in front of the *pattern*."
msgstr ""
"遞迴地 glob 給定的相對 *pattern*。這相當於在給定的相對 *pattern* 前面加上 "
"\"``**/``\" 並呼叫 :func:`Path.glob`。"

#: ../../library/pathlib.rst:1325
msgid ":ref:`pathlib-pattern-language` and :meth:`Path.glob` documentation."
msgstr ":ref:`pathlib-pattern-language` 和 :meth:`Path.glob` 文件。"

#: ../../library/pathlib.rst:1327
msgid ""
"Raises an :ref:`auditing event <auditing>` ``pathlib.Path.rglob`` with "
"arguments ``self``, ``pattern``."
msgstr ""
"引發一個附帶引數 ``self``、``pattern`` 的\\ :ref:`稽核事件 <auditing>` "
"``pathlib.Path.rglob``。"

#: ../../library/pathlib.rst:1341
msgid ""
"Generate the file names in a directory tree by walking the tree either top-"
"down or bottom-up."
msgstr "透過由上而下或由下而上地走訪目錄樹產生目錄樹裡的檔案名稱。"

#: ../../library/pathlib.rst:1344
msgid ""
"For each directory in the directory tree rooted at *self* (including *self* "
"but excluding '.' and '..'), the method yields a 3-tuple of ``(dirpath, "
"dirnames, filenames)``."
msgstr ""
"對每個以 *self* 為根且在目錄樹裡的目錄（包含 *self* 但不包含 '.' 和 '..' ），"
"此方法會 yield 一個 ``(dirpath, dirnames, filenames)`` 的三元素元組。"

#: ../../library/pathlib.rst:1348
msgid ""
"*dirpath* is a :class:`Path` to the directory currently being walked, "
"*dirnames* is a list of strings for the names of subdirectories in *dirpath* "
"(excluding ``'.'`` and ``'..'``), and *filenames* is a list of strings for "
"the names of the non-directory files in *dirpath*. To get a full path (which "
"begins with *self*) to a file or directory in *dirpath*, do ``dirpath / "
"name``. Whether or not the lists are sorted is file system-dependent."
msgstr ""
"*dirpath* 是一個目前走訪到的目錄的 :class:`Path`，*dirnames* 是一個 "
"*dirpath* 裡的子目錄名稱的字串串列（不包含 ``'.'`` 和 ``'..'`` ），而 "
"*filenames* 是一個 *dirpath* 裡非目錄檔案名稱的字串串列。要取得在 *dirpath* "
"裡檔案或目錄的完整路徑（以 *self* 開頭），可以使用 ``dirpath / name``。會根據"
"檔案系統來決定串列是否有排序。"

#: ../../library/pathlib.rst:1356
msgid ""
"If the optional argument *top_down* is true (which is the default), the "
"triple for a directory is generated before the triples for any of its "
"subdirectories (directories are walked top-down).  If *top_down* is false, "
"the triple for a directory is generated after the triples for all of its "
"subdirectories (directories are walked bottom-up). No matter the value of "
"*top_down*, the list of subdirectories is retrieved before the triples for "
"the directory and its subdirectories are walked."
msgstr ""
"如果可選引數 *top_down* 是 true（預設值），一個目錄的三元素元組會在其任何子目"
"錄的三元素元組之前產生（目錄是由上而下走訪）。如果 *top_down* 是 false，一個"
"目錄的三元素元組會在其所有子目錄的三元素元組之後產生（目錄是由下而上走訪）。"
"不論 *top_down* 的值是什麼，子目錄的串列會在走訪該目錄及其子目錄的三元素元組"
"之前取得。"

#: ../../library/pathlib.rst:1364
msgid ""
"When *top_down* is true, the caller can modify the *dirnames* list in-place "
"(for example, using :keyword:`del` or slice assignment), and :meth:`Path."
"walk` will only recurse into the subdirectories whose names remain in "
"*dirnames*. This can be used to prune the search, or to impose a specific "
"order of visiting, or even to inform :meth:`Path.walk` about directories the "
"caller creates or renames before it resumes :meth:`Path.walk` again. "
"Modifying *dirnames* when *top_down* is false has no effect on the behavior "
"of :meth:`Path.walk` since the directories in *dirnames* have already been "
"generated by the time *dirnames* is yielded to the caller."
msgstr ""
"當 *top_down* 是 true，呼叫者可以原地 (in-place) 修改 *dirnames* 串列（例如使"
"用 :keyword:`del` 或切片賦值 (slice assignment)），且 :meth:`Path.walk` 只會"
"遞迴進名稱依然留在 *dirnames* 裡的子目錄。這可以用來修剪搜尋，或者強加特定順"
"序的訪問，或者甚至在繼續 :meth:`Path.walk` 之前，用來告訴 :meth:`Path.walk` "
"關於呼叫者建立或重新命名的目錄。當 *top_down* 是 false 的時候，修改 "
"*dirnames* 對 :meth:`Path.walk` 的行為沒有影響，因為 *dirnames* 裡的目錄已經"
"在 *dirnames* yield 給呼叫者之前被產生。"

#: ../../library/pathlib.rst:1374
msgid ""
"By default, errors from :func:`os.scandir` are ignored.  If the optional "
"argument *on_error* is specified, it should be a callable; it will be called "
"with one argument, an :exc:`OSError` instance. The callable can handle the "
"error to continue the walk or re-raise it to stop the walk. Note that the "
"filename is available as the ``filename`` attribute of the exception object."
msgstr ""
"預設來自 :func:`os.scandir` 的錯誤會被忽略。如果指定了可選引數 *on_error*\\ "
"（它應該要是一個可呼叫物件），它會被以一個 :exc:`OSError` 實例為引數來呼叫。"
"這個可呼叫物件可以處理錯誤以繼續走訪，或者再次引發錯誤來停止走訪。注意，檔案"
"名稱可以從例外物件的 ``filename`` 屬性來取得。"

#: ../../library/pathlib.rst:1380
msgid ""
"By default, :meth:`Path.walk` does not follow symbolic links, and instead "
"adds them to the *filenames* list. Set *follow_symlinks* to true to resolve "
"symlinks and place them in *dirnames* and *filenames* as appropriate for "
"their targets, and consequently visit directories pointed to by symlinks "
"(where supported)."
msgstr ""
"預設 :meth:`Path.walk` 不會跟隨符號連結，而是會把它們加到 *filenames* 串列。"
"將 *follow_symlinks* 設定為 true 會解析符號連結，並將它們根據其指向的目標放在"
"適當的 *dirnames* 和 *filenames*，而因此訪問到符號連結指向的目錄（在有支援符"
"號連結的地方）。"

#: ../../library/pathlib.rst:1387
msgid ""
"Be aware that setting *follow_symlinks* to true can lead to infinite "
"recursion if a link points to a parent directory of itself. :meth:`Path."
"walk` does not keep track of the directories it has already visited."
msgstr ""
"需要注意的是如果符號連結指向一個其本身的父目錄，則將 *follow_symlinks* 設定"
"為 true 會導致無窮的遞迴。:meth:`Path.walk` 不會紀錄其已經訪問過的目錄。"

#: ../../library/pathlib.rst:1392
msgid ""
":meth:`Path.walk` assumes the directories it walks are not modified during "
"execution. For example, if a directory from *dirnames* has been replaced "
"with a symlink and *follow_symlinks* is false, :meth:`Path.walk` will still "
"try to descend into it. To prevent such behavior, remove directories from "
"*dirnames* as appropriate."
msgstr ""
":meth:`Path.walk` 假設其走訪的目錄在執行過程中不會被修改。舉例來說，如果在 "
"*dirnames* 裡的目錄已經被一個符號連結取代，且 *follow_symlinks* 是 false，:"
"meth:`Path.walk` 依然會試著往下進入它。為了防止這樣的行為，可以從 *dirnames* "
"適當地移除目錄。"

#: ../../library/pathlib.rst:1400
msgid ""
"Unlike :func:`os.walk`, :meth:`Path.walk` lists symlinks to directories in "
"*filenames* if *follow_symlinks* is false."
msgstr ""
"如果 *follow_symlinks* 是 false，和 :func:`os.walk` 行為不同的是 :meth:`Path."
"walk` 會將指向目錄的符號連結放在 *filenames* 串列。"

#: ../../library/pathlib.rst:1403
msgid ""
"This example displays the number of bytes used by all files in each "
"directory, while ignoring ``__pycache__`` directories::"
msgstr ""
"這個範例會顯示在每個目錄裡所有檔案使用的位元組數量，同時間忽略 "
"``__pycache__`` 目錄： ::"

#: ../../library/pathlib.rst:1406
msgid ""
"from pathlib import Path\n"
"for root, dirs, files in Path(\"cpython/Lib/concurrent\")."
"walk(on_error=print):\n"
"  print(\n"
"      root,\n"
"      \"consumes\",\n"
"      sum((root / file).stat().st_size for file in files),\n"
"      \"bytes in\",\n"
"      len(files),\n"
"      \"non-directory files\"\n"
"  )\n"
"  if '__pycache__' in dirs:\n"
"        dirs.remove('__pycache__')"
msgstr ""
"from pathlib import Path\n"
"for root, dirs, files in Path(\"cpython/Lib/concurrent\")."
"walk(on_error=print):\n"
"  print(\n"
"      root,\n"
"      \"consumes\",\n"
"      sum((root / file).stat().st_size for file in files),\n"
"      \"bytes in\",\n"
"      len(files),\n"
"      \"non-directory files\"\n"
"  )\n"
"  if '__pycache__' in dirs:\n"
"        dirs.remove('__pycache__')"

#: ../../library/pathlib.rst:1419
msgid ""
"This next example is a simple implementation of :func:`shutil.rmtree`. "
"Walking the tree bottom-up is essential as :func:`rmdir` doesn't allow "
"deleting a directory before it is empty::"
msgstr ""
"下一個範例是 :func:`shutil.rmtree` 的一個簡單的實作方式。由下而上走訪目錄樹是"
"必要的，因為 :func:`rmdir` 不允許在目錄為空之前刪除它： ::"

#: ../../library/pathlib.rst:1423
msgid ""
"# Delete everything reachable from the directory \"top\".\n"
"# CAUTION:  This is dangerous! For example, if top == Path('/'),\n"
"# it could delete all of your files.\n"
"for root, dirs, files in top.walk(top_down=False):\n"
"    for name in files:\n"
"        (root / name).unlink()\n"
"    for name in dirs:\n"
"        (root / name).rmdir()"
msgstr ""
"# 刪除可從 \"top\" 目錄到達的所有東西。\n"
"# 注意：這是危險的！例如，如果 top == Path('/')，\n"
"# 它可能會刪除你所有的檔案。\n"
"for root, dirs, files in top.walk(top_down=False):\n"
"    for name in files:\n"
"        (root / name).unlink()\n"
"    for name in dirs:\n"
"        (root / name).rmdir()"

#: ../../library/pathlib.rst:1436
msgid "Creating files and directories"
msgstr "建立檔案和目錄"

#: ../../library/pathlib.rst:1440
msgid ""
"Create a file at this given path.  If *mode* is given, it is combined with "
"the process's ``umask`` value to determine the file mode and access flags.  "
"If the file already exists, the function succeeds when *exist_ok* is true "
"(and its modification time is updated to the current time), otherwise :exc:"
"`FileExistsError` is raised."
msgstr ""
"根據給定路徑來建立一個檔案。如果 *mode* 有給定，它會與行程的 ``umask`` 值結"
"合，以確定檔案模式和存取旗標。當檔案已經存在時，若 *exist_ok* 為 true 則函式"
"不會失敗（其變更時間會被更新為當下時間），否則會引發 :exc:`FileExistsError`。"

#: ../../library/pathlib.rst:1447
msgid ""
"The :meth:`~Path.open`, :meth:`~Path.write_text` and :meth:`~Path."
"write_bytes` methods are often used to create files."
msgstr ""
":meth:`~Path.open`、:meth:`~Path.write_text` 和 :meth:`~Path.write_bytes` 方"
"法通常用於建立檔案。"

#: ../../library/pathlib.rst:1453
msgid ""
"Create a new directory at this given path.  If *mode* is given, it is "
"combined with the process's ``umask`` value to determine the file mode and "
"access flags.  If the path already exists, :exc:`FileExistsError` is raised."
msgstr ""
"在給定路徑下建立一個新的目錄。如果有給 *mode* 則會結合行程 (process) 的 "
"``umask`` 值來決定檔案模式與存取旗標 (access flag)。如果路徑已經存在，會引"
"發 :exc:`FileExistsError`。"

#: ../../library/pathlib.rst:1458
msgid ""
"If *parents* is true, any missing parents of this path are created as "
"needed; they are created with the default permissions without taking *mode* "
"into account (mimicking the POSIX ``mkdir -p`` command)."
msgstr ""
"如果 *parents* 是 true，則任何缺少的父路徑都會依需要被建立；它們不考慮 "
"*mode* 而會以預設的權限來建立（模仿 POSIX 的 ``mkdir -p`` 指令）。"

#: ../../library/pathlib.rst:1462
msgid ""
"If *parents* is false (the default), a missing parent raises :exc:"
"`FileNotFoundError`."
msgstr ""
"如果 *parents* 是 false（預設值），缺少的父路徑會引發 :exc:"
"`FileNotFoundError`。"

#: ../../library/pathlib.rst:1465
msgid ""
"If *exist_ok* is false (the default), :exc:`FileExistsError` is raised if "
"the target directory already exists."
msgstr ""
"如果 *exist_ok* 是 false（預設值），則當目標目錄已經存在的話會引發 :exc:"
"`FileExistsError`。"

#: ../../library/pathlib.rst:1468
msgid ""
"If *exist_ok* is true, :exc:`FileExistsError` will not be raised unless the "
"given path already exists in the file system and is not a directory (same "
"behavior as the POSIX ``mkdir -p`` command)."
msgstr ""
"如果 *exist_ok* 是 true，只有當最後的路徑組成不是一個已存在的非目錄檔案，:"
"exc:`FileExistsError` 例外會被忽略（與 POSIX 的 ``mkdir -p`` 指令行為相同）。"

#: ../../library/pathlib.rst:1472
msgid "The *exist_ok* parameter was added."
msgstr "新增 *exist_ok* 參數。"

#: ../../library/pathlib.rst:1478
msgid "Make this path a symbolic link pointing to *target*."
msgstr "使這個路徑成為一個指向 *target* 的符號連結。"

#: ../../library/pathlib.rst:1480
msgid ""
"On Windows, a symlink represents either a file or a directory, and does not "
"morph to the target dynamically.  If the target is present, the type of the "
"symlink will be created to match. Otherwise, the symlink will be created as "
"a directory if *target_is_directory* is true or a file symlink (the default) "
"otherwise.  On non-Windows platforms, *target_is_directory* is ignored."
msgstr ""
"在 Windows 上，符號連結代表一個檔案或目錄，且不會隨著目標 (target) 動態改變。"
"如果目標存在，則符號連結的類型會被建立來符合其目標。否則如果 "
"*target_is_directory* 是 true，該符號連結會被建立成目錄，如果不是則建立成檔案"
"（預設值）。在非 Windows 平台上，*target_is_directory* 會被忽略。"

#: ../../library/pathlib.rst:1488
msgid ""
">>> p = Path('mylink')\n"
">>> p.symlink_to('setup.py')\n"
">>> p.resolve()\n"
"PosixPath('/home/antoine/pathlib/setup.py')\n"
">>> p.stat().st_size\n"
"956\n"
">>> p.lstat().st_size\n"
"8"
msgstr ""
">>> p = Path('mylink')\n"
">>> p.symlink_to('setup.py')\n"
">>> p.resolve()\n"
"PosixPath('/home/antoine/pathlib/setup.py')\n"
">>> p.stat().st_size\n"
"956\n"
">>> p.lstat().st_size\n"
"8"

#: ../../library/pathlib.rst:1498
msgid ""
"The order of arguments (link, target) is the reverse of :func:`os.symlink`'s."
msgstr "引數的順序 (link, target) 和 :func:`os.symlink` 相反。"

#: ../../library/pathlib.rst:1501
msgid ""
"Raises :exc:`UnsupportedOperation` if :func:`os.symlink` is not available. "
"In previous versions, :exc:`NotImplementedError` was raised."
msgstr ""
"如果 :func:`os.symlink` 不可用，會引發 :exc:`UnsupportedOperation`。在先前版"
"本中，則是引發 :exc:`NotImplementedError`。"

#: ../../library/pathlib.rst:1508
msgid "Make this path a hard link to the same file as *target*."
msgstr "使這個路徑成為與 *target* 相同檔案的一個硬連結 (hard link)。"

#: ../../library/pathlib.rst:1511
msgid ""
"The order of arguments (link, target) is the reverse of :func:`os.link`'s."
msgstr "引數的順序 (link, target) 和 :func:`os.link` 相反。"

#: ../../library/pathlib.rst:1516
msgid ""
"Raises :exc:`UnsupportedOperation` if :func:`os.link` is not available. In "
"previous versions, :exc:`NotImplementedError` was raised."
msgstr ""
"如果 :func:`os.link` 不可用，會引發 :exc:`UnsupportedOperation`。在先前版本"
"中，則是引發 :exc:`NotImplementedError`。"

#: ../../library/pathlib.rst:1522
msgid "Renaming and deleting"
msgstr "重新命名和刪除"

#: ../../library/pathlib.rst:1526
msgid ""
"Rename this file or directory to the given *target*, and return a new :class:"
"`!Path` instance pointing to *target*.  On Unix, if *target* exists and is a "
"file, it will be replaced silently if the user has permission. On Windows, "
"if *target* exists, :exc:`FileExistsError` will be raised. *target* can be "
"either a string or another path object::"
msgstr ""
"將此檔案或目錄重新命名為給定的 *target* ，並回傳一個新的 :class:`!Path` 實例"
"指向該 *target*。在 Unix 系統上，若 *target* 存在且為一個檔案，若使用者有權"
"限，則會在不顯示訊息的情況下進行取代。在 Windows 系統上，若 *target* 存在，則"
"會引發 :exc:`FileExistsError` 錯誤。*target* 可以是字串或另一個路徑物件： ::"

#: ../../library/pathlib.rst:1532
msgid ""
">>> p = Path('foo')\n"
">>> p.open('w').write('some text')\n"
"9\n"
">>> target = Path('bar')\n"
">>> p.rename(target)\n"
"PosixPath('bar')\n"
">>> target.open().read()\n"
"'some text'"
msgstr ""
">>> p = Path('foo')\n"
">>> p.open('w').write('some text')\n"
"9\n"
">>> target = Path('bar')\n"
">>> p.rename(target)\n"
"PosixPath('bar')\n"
">>> target.open().read()\n"
"'some text'"

#: ../../library/pathlib.rst:1541 ../../library/pathlib.rst:1557
msgid ""
"The target path may be absolute or relative. Relative paths are interpreted "
"relative to the current working directory, *not* the directory of the :class:"
"`!Path` object."
msgstr ""
"目標路徑可以是絕對路徑或相對路徑。相對路徑會相對於當前的工作目錄進行解釋，*而"
"不是*\\ 相對於 :class:`!Path` 物件所在的目錄。"

#: ../../library/pathlib.rst:1545
msgid ""
"It is implemented in terms of :func:`os.rename` and gives the same "
"guarantees."
msgstr "此功能是使用 :func:`os.rename` 實現的，並提供相同的保證。"

#: ../../library/pathlib.rst:1547 ../../library/pathlib.rst:1561
msgid "Added return value, return the new :class:`!Path` instance."
msgstr "新增了回傳值，回傳新的 :class:`!Path` 實例。"

#: ../../library/pathlib.rst:1553
msgid ""
"Rename this file or directory to the given *target*, and return a new :class:"
"`!Path` instance pointing to *target*.  If *target* points to an existing "
"file or empty directory, it will be unconditionally replaced."
msgstr ""
"將此檔案或目錄重新命名為給定的 *target*，並回傳一個指向 *target* 的新 :class:"
"`!Path` 實例。如果 *target* 指向一個現有的檔案或空目錄，它將被無條件地取代。"

#: ../../library/pathlib.rst:1567
msgid ""
"Remove this file or symbolic link.  If the path points to a directory, use :"
"func:`Path.rmdir` instead."
msgstr "移除這個檔案或符號連結。如果路徑指向目錄，請改用 :func:`Path.rmdir`。"

#: ../../library/pathlib.rst:1570
msgid ""
"If *missing_ok* is false (the default), :exc:`FileNotFoundError` is raised "
"if the path does not exist."
msgstr ""
"如果 *missing_ok* 是 false（預設值），:exc:`FileNotFoundError` 會在路徑不存在"
"時被引發。"

#: ../../library/pathlib.rst:1573
msgid ""
"If *missing_ok* is true, :exc:`FileNotFoundError` exceptions will be ignored "
"(same behavior as the POSIX ``rm -f`` command)."
msgstr ""
"如果 *missing_ok* 是 true，:exc:`FileNotFoundError` 例外會被忽略（行為與 "
"POSIX ``rm -f`` 指令相同）。"

#: ../../library/pathlib.rst:1576
msgid "The *missing_ok* parameter was added."
msgstr "新增 *missing_ok* 參數。"

#: ../../library/pathlib.rst:1582
msgid "Remove this directory.  The directory must be empty."
msgstr "移除此目錄。該目錄必須為空。"

#: ../../library/pathlib.rst:1586
msgid "Permissions and ownership"
msgstr "權限和所有權"

#: ../../library/pathlib.rst:1590
msgid ""
"Return the name of the user owning the file. :exc:`KeyError` is raised if "
"the file's user identifier (UID) isn't found in the system database."
msgstr ""
"回傳擁有該檔案的用戶名稱。如果在系統資料庫中找不到該檔案的使用者識別字 "
"(UID)，則會引發 :exc:`KeyError`。"

#: ../../library/pathlib.rst:1593
msgid ""
"This method normally follows symlinks; to get the owner of the symlink, add "
"the argument ``follow_symlinks=False``."
msgstr ""
"此方法通常會跟隨符號連結；如果想取得符號連結的擁有者，可以加上引數 "
"``follow_symlinks=False``。"

#: ../../library/pathlib.rst:1596
msgid ""
"Raises :exc:`UnsupportedOperation` if the :mod:`pwd` module is not "
"available. In earlier versions, :exc:`NotImplementedError` was raised."
msgstr ""
"如果 :mod:`pwd` 模組不可用，會引發 :exc:`UnsupportedOperation`。在先前版本"
"中，則是引發 :exc:`NotImplementedError`。"

#: ../../library/pathlib.rst:1606
msgid ""
"Return the name of the group owning the file. :exc:`KeyError` is raised if "
"the file's group identifier (GID) isn't found in the system database."
msgstr ""
"回傳擁有該檔案的群組名稱。如果在系統資料庫裡找不到檔案的群組識別字 (GID) 會引"
"發 :exc:`KeyError`。"

#: ../../library/pathlib.rst:1609
msgid ""
"This method normally follows symlinks; to get the group of the symlink, add "
"the argument ``follow_symlinks=False``."
msgstr ""
"此方法通常會跟隨符號連結；如果想取得符號連結的群組，可以加上引數 "
"``follow_symlinks=False``。"

#: ../../library/pathlib.rst:1612
msgid ""
"Raises :exc:`UnsupportedOperation` if the :mod:`grp` module is not "
"available. In earlier versions, :exc:`NotImplementedError` was raised."
msgstr ""
"如果 :mod:`grp` 模組不可用，會引發 :exc:`UnsupportedOperation`。在先前版本"
"中，則是引發 :exc:`NotImplementedError`。"

#: ../../library/pathlib.rst:1622
msgid "Change the file mode and permissions, like :func:`os.chmod`."
msgstr "修改檔案模式 (file mode) 與權限，像 :func:`os.chmod` 一樣。"

#: ../../library/pathlib.rst:1624
msgid ""
"This method normally follows symlinks. Some Unix flavours support changing "
"permissions on the symlink itself; on these platforms you may add the "
"argument ``follow_symlinks=False``, or use :meth:`~Path.lchmod`."
msgstr ""
"此方法通常會跟隨符號連結。一些 Unix 類型支援修改符號連結本身的權限；在這些平"
"台上你可以加上引數 ``follow_symlinks=False`` 或使用 :meth:`~Path.lchmod`。"

#: ../../library/pathlib.rst:1630
msgid ""
">>> p = Path('setup.py')\n"
">>> p.stat().st_mode\n"
"33277\n"
">>> p.chmod(0o444)\n"
">>> p.stat().st_mode\n"
"33060"
msgstr ""
">>> p = Path('setup.py')\n"
">>> p.stat().st_mode\n"
"33277\n"
">>> p.chmod(0o444)\n"
">>> p.stat().st_mode\n"
"33060"

#: ../../library/pathlib.rst:1643
msgid ""
"Like :meth:`Path.chmod` but, if the path points to a symbolic link, the "
"symbolic link's mode is changed rather than its target's."
msgstr ""
"類似 :meth:`Path.chmod`，但如果該路徑指向一個符號連結，則符號連結的模式 "
"(mode) 會被改變而不是其指向的目標。"

#: ../../library/pathlib.rst:1650
msgid "Pattern language"
msgstr "模式語言 (pattern language)"

#: ../../library/pathlib.rst:1652
msgid ""
"The following wildcards are supported in patterns for :meth:`~PurePath."
"full_match`, :meth:`~Path.glob` and :meth:`~Path.rglob`:"
msgstr ""
"以下的萬用字元在 :meth:`~PurePath.full_match`、:meth:`~Path.glob` 和 :meth:"
"`~Path.rglob` 的模式中被支援："

#: ../../library/pathlib.rst:1655
msgid "``**`` (entire segment)"
msgstr "``**``\\（整個片段）"

#: ../../library/pathlib.rst:1656
msgid "Matches any number of file or directory segments, including zero."
msgstr "匹配任何數量的檔案或目錄片段，包括零個。"

#: ../../library/pathlib.rst:1657
msgid "``*`` (entire segment)"
msgstr "``*``\\（整個片段）"

#: ../../library/pathlib.rst:1658
msgid "Matches one file or directory segment."
msgstr "匹配一個檔案或目錄的片段。"

#: ../../library/pathlib.rst:1659
msgid "``*`` (part of a segment)"
msgstr "``*``\\（片段的一部分）"

#: ../../library/pathlib.rst:1660
msgid "Matches any number of non-separator characters, including zero."
msgstr "匹配任意數量的非分隔字元，包括零個。"

#: ../../library/pathlib.rst:1661
msgid "``?``"
msgstr "``?``"

#: ../../library/pathlib.rst:1662
msgid "Matches one non-separator character."
msgstr "匹配一個非分隔字元。"

#: ../../library/pathlib.rst:1663
msgid "``[seq]``"
msgstr "``[seq]``"

#: ../../library/pathlib.rst:1664
msgid "Matches one character in *seq*."
msgstr "匹配一個在 *seq* 中的字元。"

#: ../../library/pathlib.rst:1665
msgid "``[!seq]``"
msgstr "``[!seq]``"

#: ../../library/pathlib.rst:1666
msgid "Matches one character not in *seq*."
msgstr "匹配一個不在 *seq* 中的字元。"

#: ../../library/pathlib.rst:1668
msgid ""
"For a literal match, wrap the meta-characters in brackets. For example, "
"``\"[?]\"`` matches the character ``\"?\"``."
msgstr ""
"對於文本 (literal) 匹配，可以用方括號包裝元字元 (meta-characters)。例如，"
"``\"[?]\"`` 會匹配字元 ``\"?\"``。"

#: ../../library/pathlib.rst:1671
msgid "The \"``**``\" wildcard enables recursive globbing. A few examples:"
msgstr "\"``**``\" 萬用字元讓它可以做遞迴 glob。例如："

#: ../../library/pathlib.rst:1674
msgid "Pattern"
msgstr "模式"

#: ../../library/pathlib.rst:1674
msgid "Meaning"
msgstr "意涵"

#: ../../library/pathlib.rst:1676
msgid "\"``**/*``\""
msgstr "\"``**/*``\""

#: ../../library/pathlib.rst:1676
msgid "Any path with at least one segment."
msgstr "至少有一個片段的路徑。"

#: ../../library/pathlib.rst:1677
msgid "\"``**/*.py``\""
msgstr "\"``**/*.py``\""

#: ../../library/pathlib.rst:1677
msgid "Any path with a final segment ending \"``.py``\"."
msgstr "最後一個片段以 \"``.py``\" 結尾的任何路徑。"

#: ../../library/pathlib.rst:1678
msgid "\"``assets/**``\""
msgstr "\"``assets/**``\""

#: ../../library/pathlib.rst:1678
msgid "Any path starting with \"``assets/``\"."
msgstr "任何以 \"``assets/``\" 開頭的路徑。"

#: ../../library/pathlib.rst:1679
msgid "\"``assets/**/*``\""
msgstr "\"``assets/**/*``\""

#: ../../library/pathlib.rst:1679
msgid ""
"Any path starting with \"``assets/``\", excluding \"``assets/``\" itself."
msgstr "任何以 \"``assets/``\" 開頭的路徑，不包括 \"``assets/``\" 本身。"

#: ../../library/pathlib.rst:1683
msgid ""
"Globbing with the \"``**``\" wildcard visits every directory in the tree. "
"Large directory trees may take a long time to search."
msgstr ""
"Glob 使用 ``**`` 萬用字元會訪問目錄樹中的每個目錄。對於大型的目錄樹，搜尋可能"
"需要花費很長的時間。"

#: ../../library/pathlib.rst:1686
msgid ""
"Globbing with a pattern that ends with \"``**``\" returns both files and "
"directories. In previous versions, only directories were returned."
msgstr ""
"Glob 使用結尾為 ``**`` 的模式會同時回傳檔案和目錄。在先前版本中，只會回傳目"
"錄。"

#: ../../library/pathlib.rst:1690
msgid ""
"In :meth:`Path.glob` and :meth:`~Path.rglob`, a trailing slash may be added "
"to the pattern to match only directories."
msgstr ""
"在 :meth:`Path.glob` 和 :meth:`~Path.rglob` 中，可以在模式後面加上斜線以只匹"
"配目錄。"

#: ../../library/pathlib.rst:1693
msgid ""
"Globbing with a pattern that ends with a pathname components separator (:"
"data:`~os.sep` or :data:`~os.altsep`) returns only directories."
msgstr ""
"Glob 使用以路徑名稱組成的分隔符號（:data:`~os.sep` 或 :data:`~os.altsep`）作"
"結尾的模式則只會回傳目錄。"

#: ../../library/pathlib.rst:1699
msgid "Comparison to the :mod:`glob` module"
msgstr "與 :mod:`glob` 模組的比較"

#: ../../library/pathlib.rst:1701
msgid ""
"The patterns accepted and results generated by :meth:`Path.glob` and :meth:"
"`Path.rglob` differ slightly from those by the :mod:`glob` module:"
msgstr ""
":meth:`Path.glob` 和 :meth:`Path.rglob` 接受的模式和產生的結果與 :mod:`glob` "
"模組略有不同："

#: ../../library/pathlib.rst:1704
msgid ""
"Files beginning with a dot are not special in pathlib. This is like passing "
"``include_hidden=True`` to :func:`glob.glob`."
msgstr ""
"pathlib 中以點開頭的檔案並不特別。這和將 ``include_hidden=True`` 傳遞給 :"
"func:`glob.glob` 相同。"

#: ../../library/pathlib.rst:1706
msgid ""
"\"``**``\" pattern components are always recursive in pathlib. This is like "
"passing ``recursive=True`` to :func:`glob.glob`."
msgstr ""
"``**`` 模式組成在 pathlib 中總是遞迴的。這與將 ``recursive=True`` 傳遞給 :"
"func:`glob.glob` 相同。"

#: ../../library/pathlib.rst:1708
msgid ""
"\"``**``\" pattern components do not follow symlinks by default in pathlib. "
"This behaviour has no equivalent in :func:`glob.glob`, but you can pass "
"``recurse_symlinks=True`` to :meth:`Path.glob` for compatible behaviour."
msgstr ""
"在 pathlib 中，``**`` 模式組成預設不跟隨符號連結。這在 :func:`glob.glob` 中沒"
"有等效的行為，但你可以將 ``recurse_symlinks=True`` 傳遞給 :meth:`Path.glob` "
"以獲得相容的行為。"

#: ../../library/pathlib.rst:1711
msgid ""
"Like all :class:`PurePath` and :class:`Path` objects, the values returned "
"from :meth:`Path.glob` and :meth:`Path.rglob` don't include trailing slashes."
msgstr ""
"與所有 :class:`PurePath` 和 :class:`Path` 物件一樣，從 :meth:`Path.glob` 和 :"
"meth:`Path.rglob` 回傳的值不包含結尾斜線。"

#: ../../library/pathlib.rst:1714
msgid ""
"The values returned from pathlib's ``path.glob()`` and ``path.rglob()`` "
"include the *path* as a prefix, unlike the results of ``glob."
"glob(root_dir=path)``."
msgstr ""
"pathlib 的 ``path.glob()`` 和 ``path.rglob()`` 回傳的值包含了 *path* 作為前"
"綴，而 ``glob.glob(root_dir=path)`` 的結果則不會如此。"

#: ../../library/pathlib.rst:1717
msgid ""
"The values returned from pathlib's ``path.glob()`` and ``path.rglob()`` may "
"include *path* itself, for example when globbing \"``**``\", whereas the "
"results of ``glob.glob(root_dir=path)`` never include an empty string that "
"would correspond to *path*."
msgstr ""
"pathlib 的 ``path.glob()`` 和 ``path.rglob()`` 回傳的值可能包含 *path* 本身，"
"例如當使用 \"``**``\" 做 glob 的時候，然而 ``glob.glob(root_dir=path)`` 的結"
"果則永遠不會包含一個對應到 *path* 的空字串。"

#: ../../library/pathlib.rst:1724
msgid "Comparison to the :mod:`os` and :mod:`os.path` modules"
msgstr "與 :mod:`os` 和 :mod:`os.path` 模組的比較"

#: ../../library/pathlib.rst:1726
msgid ""
"pathlib implements path operations using :class:`PurePath` and :class:`Path` "
"objects, and so it's said to be *object-oriented*. On the other hand, the :"
"mod:`os` and :mod:`os.path` modules supply functions that work with low-"
"level ``str`` and ``bytes`` objects, which is a more *procedural* approach. "
"Some users consider the object-oriented style to be more readable."
msgstr ""
"pathlib 使用 :class:`PurePath` 和 :class:`Path` 物件來實作路徑操作，因此它被"
"稱為是\\ *物件導向*\\ 的。另一方面，:mod:`os` 和 :mod:`os.path` 模組提供能夠"
"與底層 ``str`` 和 ``bytes`` 物件互動的函式，這是一種更\\ *程序式*\\ 的方法。"
"有些使用者認為物件導向的風格更易讀。"

#: ../../library/pathlib.rst:1732
msgid ""
"Many functions in :mod:`os` and :mod:`os.path` support ``bytes`` paths and :"
"ref:`paths relative to directory descriptors <dir_fd>`. These features "
"aren't available in pathlib."
msgstr ""
":mod:`os` 和 :mod:`os.path` 中的許多函式支援 ``bytes`` 路徑和\\ :ref:`相對路"
"徑的目錄描述器 (paths relative to directory descriptors) <dir_fd>`。這些功能"
"在 pathlib 中不可用。"

#: ../../library/pathlib.rst:1736
msgid ""
"Python's ``str`` and ``bytes`` types, and portions of the :mod:`os` and :mod:"
"`os.path` modules, are written in C and are very speedy. pathlib is written "
"in pure Python and is often slower, but rarely slow enough to matter."
msgstr ""
"Python 的 ``str`` 和 ``bytes`` 型別，以及 :mod:`os` 和 :mod:`os.path` 模組的"
"一些部分，是用 C 寫的且非常快速。pathlib 是用純 Python 寫的且通常比較慢，但很"
"少會慢到足以產生影響。"

#: ../../library/pathlib.rst:1740
msgid ""
"pathlib's path normalization is slightly more opinionated and consistent "
"than :mod:`os.path`. For example, whereas :func:`os.path.abspath` eliminates "
"\"``..``\" segments from a path, which may change its meaning if symlinks "
"are involved, :meth:`Path.absolute` preserves these segments for greater "
"safety."
msgstr ""
"pathlib 的路徑正規化略比 :mod:`os.path` 更武斷和一致。例如，儘管 :func:`os."
"path.abspath` 會從路徑中移除 \"``..``\" 片段，如果包含符號連結的話這可能會改"
"變其意義，而 :meth:`Path.absolute` 則會保留這些片段以增加安全性。"

#: ../../library/pathlib.rst:1745
msgid ""
"pathlib's path normalization may render it unsuitable for some applications:"
msgstr "pathlib 的路徑正規化可能會使它不適合某些應用程式："

#: ../../library/pathlib.rst:1747
msgid ""
"pathlib normalizes ``Path(\"my_folder/\")`` to ``Path(\"my_folder\")``, "
"which changes a path's meaning when supplied to various operating system "
"APIs and command-line utilities. Specifically, the absence of a trailing "
"separator may allow the path to be resolved as either a file or directory, "
"rather than a directory only."
msgstr ""
"pathlib 將 ``Path(\"my_folder/\")`` 正規化為 ``Path(\"my_folder\")``，這會在"
"提供給各種操作系統 API 和命令列工具時改變路徑的意義。具體來說，缺少結尾分隔符"
"號可能會允許該路徑被解析為檔案或目錄，而不只是目錄。"

#: ../../library/pathlib.rst:1752
msgid ""
"pathlib normalizes ``Path(\"./my_program\")`` to ``Path(\"my_program\")``, "
"which changes a path's meaning when used as an executable search path, such "
"as in a shell or when spawning a child process. Specifically, the absence of "
"a separator in the path may force it to be looked up in :envvar:`PATH` "
"rather than the current directory."
msgstr ""
"pathlib 將 ``Path(\"./my_program\")`` 正規化為 ``Path(\"my_program\")``，這會"
"在作為執行檔搜尋路徑使用時改變路徑的意義，例如在 shell 或在衍生 (spawn) 子行"
"程時。具體來說，在路徑中缺少分隔符號可能會使其強制在 :envvar:`PATH` 中尋找，"
"而不是當前目錄。"

#: ../../library/pathlib.rst:1758
msgid ""
"As a consequence of these differences, pathlib is not a drop-in replacement "
"for :mod:`os.path`."
msgstr "因為這些差異，pathlib 不是 :mod:`os.path` 的直接替代品。"

#: ../../library/pathlib.rst:1763
msgid "Corresponding tools"
msgstr "對應工具"

#: ../../library/pathlib.rst:1765
msgid ""
"Below is a table mapping various :mod:`os` functions to their corresponding :"
"class:`PurePath`/:class:`Path` equivalent."
msgstr ""
"以下是一張表格，對應許多 :mod:`os` 函式及其相符於 :class:`PurePath`/:class:"
"`Path` 的項目。"

#: ../../library/pathlib.rst:1769
msgid ":mod:`os` and :mod:`os.path`"
msgstr ":mod:`os` 和 :mod:`os.path`"

#: ../../library/pathlib.rst:1769
msgid ":mod:`pathlib`"
msgstr ":mod:`pathlib`"

#: ../../library/pathlib.rst:1771
msgid ":func:`os.path.dirname`"
msgstr ":func:`os.path.dirname`"

#: ../../library/pathlib.rst:1771
msgid ":attr:`PurePath.parent`"
msgstr ":attr:`PurePath.parent`"

#: ../../library/pathlib.rst:1772
msgid ":func:`os.path.basename`"
msgstr ":func:`os.path.basename`"

#: ../../library/pathlib.rst:1772
msgid ":attr:`PurePath.name`"
msgstr ":attr:`PurePath.name`"

#: ../../library/pathlib.rst:1773
msgid ":func:`os.path.splitext`"
msgstr ":func:`os.path.splitext`"

#: ../../library/pathlib.rst:1773
msgid ":attr:`PurePath.stem`, :attr:`PurePath.suffix`"
msgstr ":attr:`PurePath.stem` 和 :attr:`PurePath.suffix`"

#: ../../library/pathlib.rst:1774
msgid ":func:`os.path.join`"
msgstr ":func:`os.path.join`"

#: ../../library/pathlib.rst:1774
msgid ":meth:`PurePath.joinpath`"
msgstr ":meth:`PurePath.joinpath`"

#: ../../library/pathlib.rst:1775
msgid ":func:`os.path.isabs`"
msgstr ":func:`os.path.isabs`"

#: ../../library/pathlib.rst:1775
msgid ":meth:`PurePath.is_absolute`"
msgstr ":meth:`PurePath.is_absolute`"

#: ../../library/pathlib.rst:1776
msgid ":func:`os.path.relpath`"
msgstr ":func:`os.path.relpath`"

#: ../../library/pathlib.rst:1776
msgid ":meth:`PurePath.relative_to` [1]_"
msgstr ":meth:`PurePath.relative_to` [1]_"

#: ../../library/pathlib.rst:1777
msgid ":func:`os.path.expanduser`"
msgstr ":func:`os.path.expanduser`"

#: ../../library/pathlib.rst:1777
msgid ":meth:`Path.expanduser` [2]_"
msgstr ":meth:`Path.expanduser` [2]_"

#: ../../library/pathlib.rst:1778
msgid ":func:`os.path.realpath`"
msgstr ":func:`os.path.realpath`"

#: ../../library/pathlib.rst:1778
msgid ":meth:`Path.resolve`"
msgstr ":meth:`Path.resolve`"

#: ../../library/pathlib.rst:1779
msgid ":func:`os.path.abspath`"
msgstr ":func:`os.path.abspath`"

#: ../../library/pathlib.rst:1779
msgid ":meth:`Path.absolute` [3]_"
msgstr ":meth:`Path.absolute` [3]_"

#: ../../library/pathlib.rst:1780
msgid ":func:`os.path.exists`"
msgstr ":func:`os.path.exists`"

#: ../../library/pathlib.rst:1780
msgid ":meth:`Path.exists`"
msgstr ":meth:`Path.exists`"

#: ../../library/pathlib.rst:1781
msgid ":func:`os.path.isfile`"
msgstr ":func:`os.path.isfile`"

#: ../../library/pathlib.rst:1781
msgid ":meth:`Path.is_file`"
msgstr ":meth:`Path.is_file`"

#: ../../library/pathlib.rst:1782
msgid ":func:`os.path.isdir`"
msgstr ":func:`os.path.isdir`"

#: ../../library/pathlib.rst:1782
msgid ":meth:`Path.is_dir`"
msgstr ":meth:`Path.is_dir`"

#: ../../library/pathlib.rst:1783
msgid ":func:`os.path.islink`"
msgstr ":func:`os.path.islink`"

#: ../../library/pathlib.rst:1783
msgid ":meth:`Path.is_symlink`"
msgstr ":meth:`Path.is_symlink`"

#: ../../library/pathlib.rst:1784
msgid ":func:`os.path.isjunction`"
msgstr ":func:`os.path.isjunction`"

#: ../../library/pathlib.rst:1784
msgid ":meth:`Path.is_junction`"
msgstr ":meth:`Path.is_junction`"

#: ../../library/pathlib.rst:1785
msgid ":func:`os.path.ismount`"
msgstr ":func:`os.path.ismount`"

#: ../../library/pathlib.rst:1785
msgid ":meth:`Path.is_mount`"
msgstr ":meth:`Path.is_mount`"

#: ../../library/pathlib.rst:1786
msgid ":func:`os.path.samefile`"
msgstr ":func:`os.path.samefile`"

#: ../../library/pathlib.rst:1786
msgid ":meth:`Path.samefile`"
msgstr ":meth:`Path.samefile`"

#: ../../library/pathlib.rst:1787
msgid ":func:`os.getcwd`"
msgstr ":func:`os.getcwd`"

#: ../../library/pathlib.rst:1787
msgid ":meth:`Path.cwd`"
msgstr ":meth:`Path.cwd`"

#: ../../library/pathlib.rst:1788
msgid ":func:`os.stat`"
msgstr ":func:`os.stat`"

#: ../../library/pathlib.rst:1788
msgid ":meth:`Path.stat`"
msgstr ":meth:`Path.stat`"

#: ../../library/pathlib.rst:1789
msgid ":func:`os.lstat`"
msgstr ":func:`os.lstat`"

#: ../../library/pathlib.rst:1789
msgid ":meth:`Path.lstat`"
msgstr ":meth:`Path.lstat`"

#: ../../library/pathlib.rst:1790
msgid ":func:`os.listdir`"
msgstr ":func:`os.listdir`"

#: ../../library/pathlib.rst:1790
msgid ":meth:`Path.iterdir`"
msgstr ":meth:`Path.iterdir`"

#: ../../library/pathlib.rst:1791
msgid ":func:`os.walk`"
msgstr ":func:`os.walk`"

#: ../../library/pathlib.rst:1791
msgid ":meth:`Path.walk` [4]_"
msgstr ":meth:`Path.walk` [4]_"

#: ../../library/pathlib.rst:1792
msgid ":func:`os.mkdir`, :func:`os.makedirs`"
msgstr ":func:`os.mkdir`、:func:`os.makedirs`"

#: ../../library/pathlib.rst:1792
msgid ":meth:`Path.mkdir`"
msgstr ":meth:`Path.mkdir`"

#: ../../library/pathlib.rst:1793
msgid ":func:`os.link`"
msgstr ":func:`os.link`"

#: ../../library/pathlib.rst:1793
msgid ":meth:`Path.hardlink_to`"
msgstr ":meth:`Path.hardlink_to`"

#: ../../library/pathlib.rst:1794
msgid ":func:`os.symlink`"
msgstr ":func:`os.symlink`"

#: ../../library/pathlib.rst:1794
msgid ":meth:`Path.symlink_to`"
msgstr ":meth:`Path.symlink_to`"

#: ../../library/pathlib.rst:1795
msgid ":func:`os.readlink`"
msgstr ":func:`os.readlink`"

#: ../../library/pathlib.rst:1795
msgid ":meth:`Path.readlink`"
msgstr ":meth:`Path.readlink`"

#: ../../library/pathlib.rst:1796
msgid ":func:`os.rename`"
msgstr ":func:`os.rename`"

#: ../../library/pathlib.rst:1796
msgid ":meth:`Path.rename`"
msgstr ":meth:`Path.rename`"

#: ../../library/pathlib.rst:1797
msgid ":func:`os.replace`"
msgstr ":func:`os.replace`"

#: ../../library/pathlib.rst:1797
msgid ":meth:`Path.replace`"
msgstr ":meth:`Path.replace`"

#: ../../library/pathlib.rst:1798
msgid ":func:`os.remove`, :func:`os.unlink`"
msgstr ":func:`os.remove`、:func:`os.unlink`"

#: ../../library/pathlib.rst:1798
msgid ":meth:`Path.unlink`"
msgstr ":meth:`Path.unlink`"

#: ../../library/pathlib.rst:1799
msgid ":func:`os.rmdir`"
msgstr ":func:`os.rmdir`"

#: ../../library/pathlib.rst:1799
msgid ":meth:`Path.rmdir`"
msgstr ":meth:`Path.rmdir`"

#: ../../library/pathlib.rst:1800
msgid ":func:`os.chmod`"
msgstr ":func:`os.chmod`"

#: ../../library/pathlib.rst:1800
msgid ":meth:`Path.chmod`"
msgstr ":meth:`Path.chmod`"

#: ../../library/pathlib.rst:1801
msgid ":func:`os.lchmod`"
msgstr ":func:`os.lchmod`"

#: ../../library/pathlib.rst:1801
msgid ":meth:`Path.lchmod`"
msgstr ":meth:`Path.lchmod`"

#: ../../library/pathlib.rst:1805
msgid "Footnotes"
msgstr "註腳"

#: ../../library/pathlib.rst:1806
msgid ""
":func:`os.path.relpath` calls :func:`~os.path.abspath` to make paths "
"absolute and remove \"``..``\" parts, whereas :meth:`PurePath.relative_to` "
"is a lexical operation that raises :exc:`ValueError` when its inputs' "
"anchors differ (e.g. if one path is absolute and the other relative.)"
msgstr ""
":func:`os.path.relpath` 會呼叫 :func:`~os.path.abspath` 來將路徑變成絕對路徑"
"並移除 \"``..``\" 部分，而 :meth:`PurePath.relative_to` 是一個文本上的操作，"
"當它輸入的錨點不同時（例如一個是絕對路徑，另一個則是相對路徑）會引發 :exc:"
"`ValueError`。"

#: ../../library/pathlib.rst:1810
msgid ""
":func:`os.path.expanduser` returns the path unchanged if the home directory "
"can't be resolved, whereas :meth:`Path.expanduser` raises :exc:"
"`RuntimeError`."
msgstr ""
":func:`os.path.expanduser` 會在無法解析家目錄時回傳原始路徑，而 :meth:`Path."
"expanduser` 則會引發 :exc:`RuntimeError`。"

#: ../../library/pathlib.rst:1813
msgid ""
":func:`os.path.abspath` removes \"``..``\" components without resolving "
"symlinks, which may change the meaning of the path, whereas :meth:`Path."
"absolute` leaves any \"``..``\" components in the path."
msgstr ""
":func:`os.path.abspath` 將 \"``..``\" 組成移除而不解析符號連結，這可能會改變"
"路徑的意義，而 :meth:`Path.absolute` 則會保留路徑中任何 \"``..``\" 組成。"

#: ../../library/pathlib.rst:1816
msgid ""
":func:`os.walk` always follows symlinks when categorizing paths into "
"*dirnames* and *filenames*, whereas :meth:`Path.walk` categorizes all "
"symlinks into *filenames* when *follow_symlinks* is false (the default.)"
msgstr ""
"當分類路徑成 *dirnames* 和 *filenames* 時 :func:`os.walk` 總是跟隨符號連結，"
"而 :meth:`Path.walk` 在 *follow_symlinks* 為 false（預設值）時，會將所有符號"
"連結都分類為 *filenames*。"

#: ../../library/pathlib.rst:11
msgid "path"
msgstr "path（路徑）"

#: ../../library/pathlib.rst:11
msgid "operations"
msgstr "operations（操作）"