Đường dẫn python so với đường dẫn

PEP này đề xuất đưa mô-đun của bên thứ ba, pathlib, vào thư viện chuẩn. Việc đưa vào được đề xuất dưới nhãn tạm thời, như được mô tả trong PEP 411. Do đó, các thay đổi API có thể được thực hiện, như một phần của quy trình PEP hoặc sau khi được chấp nhận trong thư viện tiêu chuẩn (và cho đến khi nhãn tạm thời bị xóa)

Nội dung chính Show

Mục đích của thư viện này là cung cấp một hệ thống phân cấp đơn giản gồm các lớp để xử lý các đường dẫn hệ thống tệp và các thao tác phổ biến mà người dùng thực hiện trên chúng

API hướng đối tượng cho đường dẫn hệ thống tệp đã được đề xuất và bị từ chối trong PEP 355. Một số triển khai của bên thứ ba về ý tưởng đường dẫn hệ thống tệp hướng đối tượng tồn tại trong tự nhiên

Con đường lịch sử. mô-đun py của Jason Orendorff, Jason R. Coombs và những người khác, cung cấp một lớp

>>> p = Path('/home/antoine/pathlib/setup.py')
>>> p.name
'setup.py'
>>> p.suffix
'.py'
>>> p.root
'/'
>>> p.parts
('/', 'home', 'antoine', 'pathlib', 'setup.py')
>>> p.relative_to('/home/antoine')
PosixPath('pathlib/setup.py')
>>> p.exists()
True

2-phân lớp

>>> p = Path('/home/antoine/pathlib/setup.py')
>>> p.name
'setup.py'
>>> p.suffix
'.py'
>>> p.root
'/'
>>> p.parts
('/', 'home', 'antoine', 'pathlib', 'setup.py')
>>> p.relative_to('/home/antoine')
PosixPath('pathlib/setup.py')
>>> p.exists()
True

Lớp FilePath hơi chuyên biệt của Twisted;

Một đề xuất AlternativePathClass, phân lớp

>>> p = Path('/home/antoine/pathlib/setup.py')
>>> p.name
'setup.py'
>>> p.suffix
'.py'
>>> p.root
'/'
>>> p.parts
('/', 'home', 'antoine', 'pathlib', 'setup.py')
>>> p.relative_to('/home/antoine')
PosixPath('pathlib/setup.py')
>>> p.exists()
True

4 thay vì

>>> p = Path('/home/antoine/pathlib/setup.py')
>>> p.name
'setup.py'
>>> p.suffix
'.py'
>>> p.root
'/'
>>> p.parts
('/', 'home', 'antoine', 'pathlib', 'setup.py')
>>> p.relative_to('/home/antoine')
PosixPath('pathlib/setup.py')
>>> p.exists()
True

Unipath, một biến thể của cách tiếp cận str-subclassing với hai lớp công khai, một lớp

>>> p = Path('/home/antoine/pathlib/setup.py')
>>> p.name
'setup.py'
>>> p.suffix
'.py'
>>> p.root
'/'
>>> p.parts
('/', 'home', 'antoine', 'pathlib', 'setup.py')
>>> p.relative_to('/home/antoine')
PosixPath('pathlib/setup.py')
>>> p.exists()
True

6 cho các hoạt động không thực hiện I/O và một lớp

>>> p = Path('/home/antoine/pathlib/setup.py')
>>> p.name
'setup.py'
>>> p.suffix
'.py'
>>> p.root
'/'
>>> p.parts
('/', 'home', 'antoine', 'pathlib', 'setup.py')
>>> p.relative_to('/home/antoine')
PosixPath('pathlib/setup.py')
>>> p.exists()
True

3 cho tất cả các hoạt động phổ biến

Đề xuất này cố gắng học hỏi từ những nỗ lực trước đó và từ chối PEP 355

Việc triển khai đề xuất này được theo dõi trong nhánh

>>> p = Path('/home/antoine/pathlib/setup.py')
>>> p.name
'setup.py'
>>> p.suffix
'.py'
>>> p.root
'/'
>>> p.parts
('/', 'home', 'antoine', 'pathlib', 'setup.py')
>>> p.relative_to('/home/antoine')
PosixPath('pathlib/setup.py')
>>> p.exists()
True

8 của kho lưu trữ Mercurial của pathlib

Cơ sở để biểu diễn các đường dẫn hệ thống tệp bằng cách sử dụng các lớp chuyên dụng cũng giống như đối với các loại đối tượng không trạng thái khác, chẳng hạn như ngày, giờ hoặc địa chỉ IP. Python đang dần chuyển từ việc sao chép nghiêm ngặt các API của ngôn ngữ C sang cung cấp các bản tóm tắt tốt hơn, hữu ích hơn xung quanh tất cả các loại chức năng phổ biến. Ngay cả khi PEP này không được chấp nhận, có khả năng một ngày nào đó một hình thức trừu tượng hóa xử lý hệ thống tệp khác sẽ được áp dụng vào thư viện chuẩn

Thật vậy, nhiều người sẽ thích xử lý ngày và giờ bằng cách sử dụng các đối tượng cấp cao do mô-đun

>>> p = Path('/home/antoine/pathlib/setup.py')
>>> p.name
'setup.py'
>>> p.suffix
'.py'
>>> p.root
'/'
>>> p.parts
('/', 'home', 'antoine', 'pathlib', 'setup.py')
>>> p.relative_to('/home/antoine')
PosixPath('pathlib/setup.py')
>>> p.exists()
True

9 cung cấp hơn là sử dụng dấu thời gian dạng số và API mô-đun

>>> PurePath('setup.py')
PurePosixPath('setup.py')

0. Ngoài ra, việc sử dụng một lớp chuyên dụng cho phép kích hoạt các hành vi mong muốn theo mặc định, ví dụ như trường hợp không phân biệt chữ hoa chữ thường của các đường dẫn Windows

Mô-đun pathlib thực hiện một hệ thống phân cấp đơn giản của các lớp

 | ---------| | | | | v +---------------+ | | PurePosixPath | +---------------+ | | | | |   | |   | |   | |   | v   v +-----------+ | | PosixPath | +-----------+

+----------+ | PurePath |-------- | | | +----------+ | | | | | | v | +-----------------+ | | | | | | | PureWindowsPath | | | | | | +-----------------+ v | +------+ | | | | -------| Path |------ | | | | | +------+ | | | | | | v v +-------------+ | | | | | WindowsPath | | | | +-------------+

Hệ thống phân cấp này phân chia các lớp đường dẫn theo hai chiều

một lớp đường dẫn có thể là thuần túy hoặc cụ thể. các lớp thuần túy chỉ hỗ trợ các hoạt động không cần thực hiện bất kỳ I/O thực tế nào, đó là hầu hết các hoạt động thao tác đường dẫn;
một lớp đường dẫn có hương vị nhất định theo loại đường dẫn hệ điều hành mà nó đại diện. pathlib thực hiện hai hương vị. Đường dẫn Windows cho ngữ nghĩa hệ thống tệp được thể hiện trong hệ thống Windows, đường dẫn POSIX cho các hệ thống khác

Bất kỳ lớp thuần túy nào cũng có thể được khởi tạo trên bất kỳ hệ thống nào. ví dụ: bạn có thể thao tác các đối tượng

>>> PurePath('setup.py')
PurePosixPath('setup.py')

1 trong Windows, đối tượng

>>> PurePath('setup.py')
PurePosixPath('setup.py')

2 trong Unix, v.v. Tuy nhiên, các lớp cụ thể chỉ có thể được khởi tạo trên một hệ thống phù hợp. thực sự, sẽ dễ bị lỗi khi bắt đầu thực hiện I/O với các đối tượng

>>> PurePath('setup.py')
PurePosixPath('setup.py')

3 trong Unix hoặc ngược lại

Hơn nữa, có hai lớp cơ sở cũng hoạt động như các nhà máy phụ thuộc vào hệ thống.

>>> PurePath('setup.py')
PurePosixPath('setup.py')

4 sẽ khởi tạo một

>>> PurePath('setup.py')
PurePosixPath('setup.py')

1 hoặc một

>>> PurePath('setup.py')
PurePosixPath('setup.py')

2 tùy thuộc vào hệ điều hành. Tương tự,

>>> p = Path('/home/antoine/pathlib/setup.py')
>>> p.name
'setup.py'
>>> p.suffix
'.py'
>>> p.root
'/'
>>> p.parts
('/', 'home', 'antoine', 'pathlib', 'setup.py')
>>> p.relative_to('/home/antoine')
PosixPath('pathlib/setup.py')
>>> p.exists()
True

3 sẽ khởi tạo một

>>> PurePath('setup.py')
PurePosixPath('setup.py')

8 hoặc một

>>> PurePath('setup.py')
PurePosixPath('setup.py')

Dự kiến rằng, trong hầu hết các trường hợp sử dụng, sử dụng lớp

>>> p = Path('/home/antoine/pathlib/setup.py')
>>> p.name
'setup.py'
>>> p.suffix
'.py'
>>> p.root
'/'
>>> p.parts
('/', 'home', 'antoine', 'pathlib', 'setup.py')
>>> p.relative_to('/home/antoine')
PosixPath('pathlib/setup.py')
>>> p.exists()
True

3 là đủ, đó là lý do tại sao nó có tên ngắn nhất trong tất cả các lớp

Trong đề xuất này, các lớp đường dẫn không xuất phát từ một kiểu dựng sẵn. Điều này trái ngược với một số đề xuất lớp Đường dẫn khác được bắt nguồn từ

>>> p = Path('/home/antoine/pathlib/setup.py')
>>> p.name
'setup.py'
>>> p.suffix
'.py'
>>> p.root
'/'
>>> p.parts
('/', 'home', 'antoine', 'pathlib', 'setup.py')
>>> p.relative_to('/home/antoine')
PosixPath('pathlib/setup.py')
>>> p.exists()
True

2. Họ cũng không giả vờ thực hiện giao thức tuần tự. nếu bạn muốn một đường dẫn hoạt động như một chuỗi, bạn phải tra cứu một thuộc tính chuyên dụng (thuộc tính

>>> PurePath('a///b/c/./d/')
PurePosixPath('a/b/c/d')

Lý do chính đằng sau việc không kế thừa từ

>>> p = Path('/home/antoine/pathlib/setup.py')
>>> p.name
'setup.py'
>>> p.suffix
'.py'
>>> p.root
'/'
>>> p.parts
('/', 'home', 'antoine', 'pathlib', 'setup.py')
>>> p.relative_to('/home/antoine')
PosixPath('pathlib/setup.py')
>>> p.exists()
True

2 là để ngăn việc vô tình thực hiện các thao tác với một chuỗi đại diện cho một đường dẫn và một chuỗi không, e. g.

>>> PurePath('a///b/c/./d/')
PurePosixPath('a/b/c/d')

4. Vì các thao tác với một chuỗi sẽ không nhất thiết dẫn đến một đường dẫn hệ thống tệp hợp lệ hoặc được mong đợi, "rõ ràng tốt hơn là ẩn" bằng cách tránh các thao tác vô tình với các chuỗi bằng cách không phân lớp nó. Một bài đăng trên blog của một nhà phát triển cốt lõi Python đi sâu vào chi tiết hơn về lý do đằng sau quyết định thiết kế cụ thể này

Các đối tượng đường dẫn là bất biến, điều này làm cho chúng có thể băm được và cũng ngăn ngừa một loại lỗi lập trình

Ít chức năng từ hệ điều hành. đường dẫn được sử dụng lại. Nhiều hệ điều hành. các chức năng đường dẫn bị ràng buộc bởi khả năng tương thích ngược với hành vi khó hiểu hoặc sai rõ ràng (ví dụ: thực tế là

>>> PurePath('a///b/c/./d/')
PurePosixPath('a/b/c/d')

5 đơn giản hóa “. ” các thành phần đường dẫn mà không giải quyết các liên kết tượng trưng trước)

Các con đường có cùng hương vị có thể so sánh được và có thứ tự, dù tinh khiết hay không

>>> PurePosixPath('a') == PurePosixPath('b')
False
>>> PurePosixPath('a') < PurePosixPath('b')
True
>>> PurePosixPath('a') == PosixPath('a')
True

So sánh và sắp xếp các đối tượng đường dẫn Windows không phân biệt chữ hoa chữ thường

>>> PureWindowsPath('a') == PureWindowsPath('A')
True

Đường dẫn của các hương vị khác nhau luôn so sánh không bằng nhau và không thể sắp xếp

>>> PurePosixPath('a') == PureWindowsPath('a')
False
>>> PurePosixPath('a') < PureWindowsPath('a')
Traceback (most recent call last):
  File "", line 1, in 
TypeError: unorderable types: PurePosixPath() < PureWindowsPath()

Các đường dẫn so sánh không bằng nhau và không thể sắp xếp theo thứ tự với các thể hiện của các loại dựng sẵn (chẳng hạn như

>>> p = Path('/home/antoine/pathlib/setup.py')
>>> p.name
'setup.py'
>>> p.suffix
'.py'
>>> p.root
'/'
>>> p.parts
('/', 'home', 'antoine', 'pathlib', 'setup.py')
>>> p.relative_to('/home/antoine')
PosixPath('pathlib/setup.py')
>>> p.exists()
True

2) và bất kỳ loại nào khác

API cố gắng cung cấp các ký hiệu hữu ích trong khi tránh ma thuật. Vài ví dụ

>>> p = Path('/home/antoine/pathlib/setup.py')
>>> p.name
'setup.py'
>>> p.suffix
'.py'
>>> p.root
'/'
>>> p.parts
('/', 'home', 'antoine', 'pathlib', 'setup.py')
>>> p.relative_to('/home/antoine')
PosixPath('pathlib/setup.py')
>>> p.exists()
True

Triết lý của API

>>> PurePath('setup.py')
PurePosixPath('setup.py')

4 là cung cấp một mảng nhất quán các thao tác thao tác đường dẫn hữu ích, mà không làm lộ ra một mớ hỗn độn các chức năng như

>>> PurePath('a///b/c/./d/')
PurePosixPath('a/b/c/d')

Đầu tiên một vài quy ước

Tất cả các đường dẫn có thể có một ổ đĩa và một gốc. Đối với đường dẫn POSIX, ổ đĩa luôn trống
Một đường dẫn tương đối không có ổ đĩa cũng như root
Đường dẫn POSIX là tuyệt đối nếu nó có gốc. Đường dẫn Windows là tuyệt đối nếu nó có cả ổ đĩa và gốc. Một đường dẫn Windows UNC (e. g.
```
>>> PurePath('a///b/c/./d/')
PurePosixPath('a/b/c/d')
```
9) luôn có một ổ đĩa và một thư mục gốc (ở đây, lần lượt là
```
>>> PurePath('docs', 'Makefile')
PurePosixPath('docs/Makefile')
```
0 và
```
>>> PurePath('docs', 'Makefile')
PurePosixPath('docs/Makefile')
```
1)
Một đường dẫn có ổ đĩa hoặc gốc được cho là được neo. Neo của nó là phần nối của ổ đĩa và gốc. Trong POSIX, "neo" giống như "tuyệt đối"

Chúng tôi sẽ trình bày cách xây dựng và nối với nhau vì chúng có ngữ nghĩa tương tự nhau

Cách đơn giản nhất để xây dựng một đường dẫn là chuyển cho nó biểu diễn chuỗi của nó

________số 8_______

Các dấu phân cách đường dẫn không liên quan và các thành phần

>>> PurePath('docs', 'Makefile')
PurePosixPath('docs/Makefile')

2 bị loại bỏ

>>> PurePath('a///b/c/./d/')
PurePosixPath('a/b/c/d')

Nếu bạn vượt qua một số đối số, chúng sẽ tự động được nối với nhau

>>> PurePath('docs', 'Makefile')
PurePosixPath('docs/Makefile')

Tham gia ngữ nghĩa tương tự như os. đường dẫn. tham gia, trong đó các đường dẫn được neo bỏ qua thông tin từ các thành phần đã tham gia trước đó

>>> PurePath('/etc', '/usr', 'bin')
PurePosixPath('/usr/bin')

Tuy nhiên, với đường dẫn Windows, ổ đĩa được giữ lại khi cần thiết

>>> PureWindowsPath('c:/foo', '/Windows')
PureWindowsPath('c:/Windows')
>>> PureWindowsPath('c:/foo', 'd:')
PureWindowsPath('d:')

Ngoài ra, các dấu tách đường dẫn được chuẩn hóa thành mặc định của nền tảng

>>> PurePosixPath('a') == PurePosixPath('b')
False
>>> PurePosixPath('a') < PurePosixPath('b')
True
>>> PurePosixPath('a') == PosixPath('a')
True

Các dấu phân cách đường dẫn không liên quan và các thành phần

>>> PurePath('docs', 'Makefile')
PurePosixPath('docs/Makefile')

2 bị loại bỏ, nhưng không loại bỏ các thành phần

>>> PurePath('docs', 'Makefile')
PurePosixPath('docs/Makefile')

>>> PurePosixPath('a') == PurePosixPath('b')
False
>>> PurePosixPath('a') < PurePosixPath('b')
True
>>> PurePosixPath('a') == PosixPath('a')
True

Nhiều dấu gạch chéo đầu được xử lý khác nhau tùy thuộc vào hương vị của đường dẫn. Chúng luôn được giữ lại trên đường dẫn Windows (do ký hiệu UNC)

>>> PurePosixPath('a') == PurePosixPath('b')
False
>>> PurePosixPath('a') < PurePosixPath('b')
True
>>> PurePosixPath('a') == PosixPath('a')
True

Trên POSIX, chúng bị thu gọn trừ khi có chính xác hai dấu gạch chéo ở đầu, đây là trường hợp đặc biệt trong thông số kỹ thuật POSIX trên (điều này cũng cần thiết để tương thích với Cygwin)

>>> PurePosixPath('a') == PurePosixPath('b')
False
>>> PurePosixPath('a') < PurePosixPath('b')
True
>>> PurePosixPath('a') == PosixPath('a')
True

Việc gọi hàm tạo mà không có bất kỳ đối số nào sẽ tạo ra một đối tượng đường dẫn trỏ đến “thư mục hiện tại” logic (không tra cứu đường dẫn tuyệt đối của nó, đó là công việc của phương thức lớp

>>> PurePath('docs', 'Makefile')
PurePosixPath('docs/Makefile')

5 trên các đường dẫn cụ thể)

>>> PurePosixPath('a') == PurePosixPath('b')
False
>>> PurePosixPath('a') < PurePosixPath('b')
True
>>> PurePosixPath('a') == PosixPath('a')
True

Để đại diện cho một con đường (e. g. để chuyển nó đến thư viện của bên thứ ba), chỉ cần gọi _______33_______6 trên đó

>>> PurePosixPath('a') == PurePosixPath('b')
False
>>> PurePosixPath('a') < PurePosixPath('b')
True
>>> PurePosixPath('a') == PosixPath('a')
True

Để buộc biểu diễn chuỗi bằng dấu gạch chéo về phía trước, hãy sử dụng phương thức

>>> PurePath('docs', 'Makefile')
PurePosixPath('docs/Makefile')

>>> PurePosixPath('a') == PurePosixPath('b')
False
>>> PurePosixPath('a') < PurePosixPath('b')
True
>>> PurePosixPath('a') == PosixPath('a')
True

Để có được biểu diễn byte (có thể hữu ích trong các hệ thống Unix), hãy gọi

>>> PurePath('docs', 'Makefile')
PurePosixPath('docs/Makefile')

8 trên đó, sử dụng nội bộ

>>> PurePath('docs', 'Makefile')
PurePosixPath('docs/Makefile')

>>> PurePosixPath('a') == PurePosixPath('b')
False
>>> PurePosixPath('a') < PurePosixPath('b')
True
>>> PurePosixPath('a') == PosixPath('a')
True

Để biểu diễn đường dẫn dưới dạng URI

>>> PurePath('/etc', '/usr', 'bin')
PurePosixPath('/usr/bin')

0, hãy gọi phương thức

>>> PurePath('/etc', '/usr', 'bin')
PurePosixPath('/usr/bin')

>>> PurePosixPath('a') == PurePosixPath('b')
False
>>> PurePosixPath('a') < PurePosixPath('b')
True
>>> PurePosixPath('a') == PosixPath('a')
True

repr() của một đường dẫn luôn sử dụng dấu gạch chéo lên, ngay cả trong Windows, để dễ đọc và để nhắc nhở người dùng rằng dấu gạch chéo lên là được

>>> PurePosixPath('a') == PurePosixPath('b')
False
>>> PurePosixPath('a') < PurePosixPath('b')
True
>>> PurePosixPath('a') == PosixPath('a')
True

Một số thuộc tính đơn giản được cung cấp trên mọi đường dẫn (mỗi đường dẫn có thể trống)

>>> PureWindowsPath('a') == PureWindowsPath('A')
True

Một đường dẫn có thể được nối với một đường dẫn khác bằng cách sử dụng toán tử

>>> PurePath('/etc', '/usr', 'bin')
PurePosixPath('/usr/bin')

>>> PureWindowsPath('a') == PureWindowsPath('A')
True

Như với hàm tạo, nhiều thành phần đường dẫn có thể được chỉ định, được thu gọn hoặc riêng biệt

>>> PureWindowsPath('a') == PureWindowsPath('A')
True

Một phương thức joinpath() cũng được cung cấp, với hành vi tương tự

>>> PureWindowsPath('a') == PureWindowsPath('A')
True

Phương thức

>>> PurePath('/etc', '/usr', 'bin')
PurePosixPath('/usr/bin')

3 trả về một đường dẫn mới, với tên đã thay đổi

>>> PureWindowsPath('a') == PureWindowsPath('A')
True

Nó không thành công với

>>> PurePath('/etc', '/usr', 'bin')
PurePosixPath('/usr/bin')

4 nếu đường dẫn không có tên thực

>>> PureWindowsPath('a') == PureWindowsPath('A')
True

Phương thức

>>> PurePath('/etc', '/usr', 'bin')
PurePosixPath('/usr/bin')

5 trả về một đường dẫn mới với hậu tố đã thay đổi. Tuy nhiên, nếu đường dẫn không có hậu tố, hậu tố mới sẽ được thêm vào

>>> PureWindowsPath('a') == PureWindowsPath('A')
True

Phương pháp

>>> PurePath('/etc', '/usr', 'bin')
PurePosixPath('/usr/bin')

6 tính toán sự khác biệt tương đối của một đường dẫn đến một đường dẫn khác

>>> PureWindowsPath('a') == PureWindowsPath('A')
True

ValueError được nâng lên nếu phương thức không thể trả về một giá trị có ý nghĩa

>>> PureWindowsPath('a') == PureWindowsPath('A')
True

Thuộc tính

>>> PurePath('a///b/c/./d/')
PurePosixPath('a/b/c/d')

2 trả về một bộ cung cấp quyền truy cập trình tự chỉ đọc vào các thành phần của đường dẫn

>>> PureWindowsPath('a') == PureWindowsPath('A')
True

Đường dẫn Windows xử lý ổ đĩa và thư mục gốc dưới dạng một thành phần đường dẫn duy nhất

>>> PurePosixPath('a') == PureWindowsPath('a')
False
>>> PurePosixPath('a') < PureWindowsPath('a')
Traceback (most recent call last):
  File "", line 1, in 
TypeError: unorderable types: PurePosixPath() < PureWindowsPath()

(tách chúng ra sẽ là sai, vì

>>> PurePath('/etc', '/usr', 'bin')
PurePosixPath('/usr/bin')

8 không phải là cha của

>>> PurePath('/etc', '/usr', 'bin')
PurePosixPath('/usr/bin')

Thuộc tính

>>> PureWindowsPath('c:/foo', '/Windows')
PureWindowsPath('c:/Windows')
>>> PureWindowsPath('c:/foo', 'd:')
PureWindowsPath('d:')

0 trả về cha logic của đường dẫn

>>> PurePosixPath('a') == PureWindowsPath('a')
False
>>> PurePosixPath('a') < PureWindowsPath('a')
Traceback (most recent call last):
  File "", line 1, in 
TypeError: unorderable types: PurePosixPath() < PureWindowsPath()

Thuộc tính

>>> PureWindowsPath('c:/foo', '/Windows')
PureWindowsPath('c:/Windows')
>>> PureWindowsPath('c:/foo', 'd:')
PureWindowsPath('d:')

1 trả về một chuỗi bất biến của tổ tiên logic của đường dẫn

>>> PurePosixPath('a') == PureWindowsPath('a')
False
>>> PurePosixPath('a') < PureWindowsPath('a')
Traceback (most recent call last):
  File "", line 1, in 
TypeError: unorderable types: PurePosixPath() < PureWindowsPath()

>>> PureWindowsPath('c:/foo', '/Windows')
PureWindowsPath('c:/Windows')
>>> PureWindowsPath('c:/foo', 'd:')
PureWindowsPath('d:')

2 trả về Đúng nếu đường dẫn là tương đối (xem định nghĩa ở trên), Sai nếu không

>>> PureWindowsPath('c:/foo', '/Windows')
PureWindowsPath('c:/Windows')
>>> PureWindowsPath('c:/foo', 'd:')
PureWindowsPath('d:')

3 trả về True nếu đường dẫn Windows là đường dẫn dành riêng, chẳng hạn như

>>> PureWindowsPath('c:/foo', '/Windows')
PureWindowsPath('c:/Windows')
>>> PureWindowsPath('c:/foo', 'd:')
PureWindowsPath('d:')

4 hoặc

>>> PureWindowsPath('c:/foo', '/Windows')
PureWindowsPath('c:/Windows')
>>> PureWindowsPath('c:/foo', 'd:')
PureWindowsPath('d:')

5. Nó luôn trả về Sai cho các đường dẫn POSIX

>>> PureWindowsPath('c:/foo', '/Windows')
PureWindowsPath('c:/Windows')
>>> PureWindowsPath('c:/foo', 'd:')
PureWindowsPath('d:')

6 khớp đường dẫn với mẫu toàn cầu. Nó hoạt động trên các bộ phận riêng lẻ và khớp từ bên phải

>>> PurePosixPath('a') == PureWindowsPath('a')
False
>>> PurePosixPath('a') < PureWindowsPath('a')
Traceback (most recent call last):
  File "", line 1, in 
TypeError: unorderable types: PurePosixPath() < PureWindowsPath()

Hành vi này tôn trọng những kỳ vọng sau

Một mẫu đơn giản chẳng hạn như “*. py” khớp với các đường dẫn dài tùy ý miễn là phần cuối khớp với nhau, e. g. “/usr/foo/bar. py”
Các mẫu dài hơn cũng có thể được sử dụng để khớp phức tạp hơn, chẳng hạn như. g. “/usr/foo/*. py” khớp với “/usr/foo/bar. py”

Ngoài các hoạt động của API thuần túy, các đường dẫn cụ thể cung cấp các phương thức bổ sung thực sự truy cập vào hệ thống tệp để truy vấn hoặc thay đổi thông tin

Classmethod

>>> PurePath('docs', 'Makefile')
PurePosixPath('docs/Makefile')

5 tạo một đối tượng đường dẫn trỏ đến thư mục làm việc hiện tại ở dạng tuyệt đối

>>> PurePosixPath('a') == PureWindowsPath('a')
False
>>> PurePosixPath('a') < PureWindowsPath('a')
Traceback (most recent call last):
  File "", line 1, in 
TypeError: unorderable types: PurePosixPath() < PureWindowsPath()

>>> PureWindowsPath('c:/foo', '/Windows')
PureWindowsPath('c:/Windows')
>>> PureWindowsPath('c:/foo', 'd:')
PureWindowsPath('d:')

8 trả về kết quả stat() của tệp;

>>> PurePosixPath('a') == PureWindowsPath('a')
False
>>> PurePosixPath('a') < PureWindowsPath('a')
Traceback (most recent call last):
  File "", line 1, in 
TypeError: unorderable types: PurePosixPath() < PureWindowsPath()

Các phương thức cấp cao hơn giúp kiểm tra loại tệp

>>> PurePosixPath('a') == PureWindowsPath('a')
False
>>> PurePosixPath('a') < PureWindowsPath('a')
Traceback (most recent call last):
  File "", line 1, in 
TypeError: unorderable types: PurePosixPath() < PureWindowsPath()

Chủ sở hữu tệp và tên nhóm (chứ không phải id số) được truy vấn thông qua các phương thức tương ứng

>>> PurePosixPath('a') == PureWindowsPath('a')
False
>>> PurePosixPath('a') < PureWindowsPath('a')
Traceback (most recent call last):
  File "", line 1, in 
TypeError: unorderable types: PurePosixPath() < PureWindowsPath()

Phương thức

>>> PurePosixPath('a') == PurePosixPath('b')
False
>>> PurePosixPath('a') < PurePosixPath('b')
True
>>> PurePosixPath('a') == PosixPath('a')
True

00 tạo một đường dẫn tuyệt đối, giải quyết bất kỳ liên kết tượng trưng nào trên đường đi (như lệnh gọi POSIX realpath()). Đây là thao tác duy nhất sẽ loại bỏ các thành phần đường dẫn “

>>> PurePosixPath('a') == PurePosixPath('b')
False
>>> PurePosixPath('a') < PurePosixPath('b')
True
>>> PurePosixPath('a') == PosixPath('a')
True

01”. Trên Windows, phương pháp này cũng sẽ cẩn thận để trả về đường dẫn chuẩn (với vỏ bên phải)

Việc truy cập thư mục đơn giản (không đệ quy) được thực hiện bằng cách gọi phương thức iterdir(), phương thức này trả về một trình vòng lặp trên các đường dẫn con

>>> PurePosixPath('a') == PureWindowsPath('a')
False
>>> PurePosixPath('a') < PureWindowsPath('a')
Traceback (most recent call last):
  File "", line 1, in 
TypeError: unorderable types: PurePosixPath() < PureWindowsPath()

Điều này cho phép lọc đơn giản thông qua việc hiểu danh sách

>>> PurePosixPath('a') == PureWindowsPath('a')
False
>>> PurePosixPath('a') < PureWindowsPath('a')
Traceback (most recent call last):
  File "", line 1, in 
TypeError: unorderable types: PurePosixPath() < PureWindowsPath()

Toàn cầu đơn giản và đệ quy cũng được cung cấp

>>> p = Path('/home/antoine/pathlib/setup.py')
>>> p.name
'setup.py'
>>> p.suffix
'.py'
>>> p.root
'/'
>>> p.parts
('/', 'home', 'antoine', 'pathlib', 'setup.py')
>>> p.relative_to('/home/antoine')
PosixPath('pathlib/setup.py')
>>> p.exists()
True

Phương thức

>>> PurePosixPath('a') == PurePosixPath('b')
False
>>> PurePosixPath('a') < PurePosixPath('b')
True
>>> PurePosixPath('a') == PosixPath('a')
True

02 cung cấp API mở tệp tương tự như phương thức

>>> PurePosixPath('a') == PurePosixPath('b')
False
>>> PurePosixPath('a') < PurePosixPath('b')
True
>>> PurePosixPath('a') == PosixPath('a')
True

02 dựng sẵn

>>> p = Path('/home/antoine/pathlib/setup.py')
>>> p.name
'setup.py'
>>> p.suffix
'.py'
>>> p.root
'/'
>>> p.parts
('/', 'home', 'antoine', 'pathlib', 'setup.py')
>>> p.relative_to('/home/antoine')
PosixPath('pathlib/setup.py')
>>> p.exists()
True

Một số hoạt động hệ thống tập tin phổ biến được cung cấp dưới dạng phương thức. _______25_______04, _______25_______05, _______25_______06, _______25_______07, _______25_______08, _______25_______09, _______25_______10, _______25_______11, _______25_______12. Có thể cung cấp nhiều hoạt động hơn, ví dụ như một số chức năng của mô-đun Shutil

Tài liệu chi tiết về API được đề xuất có thể được tìm thấy tại tài liệu pathlib

Toán tử chia xuất hiện đầu tiên trong một cuộc thăm dò về toán tử nối đường dẫn. Các phiên bản đầu tiên của pathlib đã sử dụng dấu ngoặc vuông (i. e.

>>> PurePosixPath('a') == PurePosixPath('b')
False
>>> PurePosixPath('a') < PurePosixPath('b')
True
>>> PurePosixPath('a') == PosixPath('a')
True

13) thay vì

Phương thức joinpath() ban đầu được gọi là join(), nhưng một số người phản đối rằng nó có thể bị nhầm lẫn với str. join() có ngữ nghĩa khác nhau. Do đó, nó được đổi tên thành joinpath()

Người dùng Windows coi đường dẫn hệ thống tệp là không phân biệt chữ hoa chữ thường và mong muốn các đối tượng đường dẫn quan sát đặc điểm đó, mặc dù trong một số trường hợp hiếm gặp, một số tệp gắn kết hệ thống tệp nước ngoài có thể phân biệt chữ hoa chữ thường trong Windows

programming python

Đường dẫn python so với đường dẫn

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội