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]
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
3; - 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
2; - 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[] True8 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[] True9 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
+----------+ | | ---------| PurePath |-------- | | | | | +----------+ | | | | | | | v | v +---------------+ | +-----------------+ | | | | | | PurePosixPath | | | PureWindowsPath | | | | | | +---------------+ | +-----------------+ | v | | +------+ | | | | | | -------| Path |------ | | | | | | | | | +------+ | | | | | | | | | | v v v v +-----------+ +-------------+ | | | | | PosixPath | | 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[] True3 sẽ khởi tạo một
>>> PurePath['setup.py'] PurePosixPath['setup.py']8 hoặc một
>>> PurePath['setup.py'] PurePosixPath['setup.py']3
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[] True3 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[] True2. 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']2]
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[] True2 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['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'] >> 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[] True2] 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']8.
Đầ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['a'] == PosixPath['a'] True0
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']4
>>> PurePosixPath['a'] == PurePosixPath['b'] False >>> PurePosixPath['a'] >> PurePosixPath['a'] == PosixPath['a'] True1
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['a'] == PosixPath['a'] True2
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['a'] == PosixPath['a'] True3
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['a'] == PosixPath['a'] True4
Để đạ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['a'] == PosixPath['a'] True5
Để 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']7
>>> PurePosixPath['a'] == PurePosixPath['b'] False >>> PurePosixPath['a'] >> PurePosixPath['a'] == PosixPath['a'] True6
Để 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']9
>>> PurePosixPath['a'] == PurePosixPath['b'] False >>> PurePosixPath['a'] >> PurePosixPath['a'] == PosixPath['a'] True7
Để 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']1
>>> PurePosixPath['a'] == PurePosixPath['b'] False >>> PurePosixPath['a'] >> PurePosixPath['a'] == PosixPath['a'] True8
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['a'] == PosixPath['a'] True9
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'] True0
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']2
>>> PureWindowsPath['a'] == PureWindowsPath['A'] True1
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'] True2
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'] True3
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'] True4
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'] True5
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'] True6
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'] True7
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'] True8
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'] True9
Đườ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'] >> PurePath['/etc', '/usr', 'bin'] PurePosixPath['/usr/bin']8 không phải là cha của
>>> PurePath['/etc', '/usr', 'bin'] PurePosixPath['/usr/bin']9]
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['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['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'] >> 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['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'] >> PurePosixPath['a'] == PureWindowsPath['a'] False >>> PurePosixPath['a'] >> PurePosixPath['a'] == PureWindowsPath['a'] False >>> PurePosixPath['a'] >> PurePosixPath['a'] == PurePosixPath['b'] False >>> PurePosixPath['a'] >> PurePosixPath['a'] == PosixPath['a'] True00 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['a'] == PosixPath['a'] True01”. 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'] >> PurePosixPath['a'] == PureWindowsPath['a'] False >>> PurePosixPath['a'] >> 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[] True0
Phương thức
>>> PurePosixPath['a'] == PurePosixPath['b'] False >>> PurePosixPath['a'] >> PurePosixPath['a'] == PosixPath['a'] True02 cung cấp API mở tệp tương tự như phương thức
>>> PurePosixPath['a'] == PurePosixPath['b'] False >>> PurePosixPath['a'] >> PurePosixPath['a'] == PosixPath['a'] True02 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[] True1
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['a'] == PosixPath['a'] True13] 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