Cách chia đường dẫn dos thành các thành phần của nó trong Python

Tôi có một biến chuỗi đại diện cho một đường dẫn dos, ví dụ:

var = "d:\stuff\morestuff\furtherdown\THEFILE.txt"

Tôi muốn chia chuỗi này thành:

[ "d", "stuff", "morestuff", "furtherdown", "THEFILE.txt" ]

Tôi đã thử sử dụng split()và replace()họ chỉ xử lý dấu gạch chéo đầu tiên hoặc họ chèn số hex vào chuỗi.

Tôi cần phải chuyển đổi biến chuỗi này thành một chuỗi thô bằng cách nào đó để tôi có thể phân tích nó.

Cách tốt nhất để làm điều này là gì?

Tôi cũng nên thêm rằng nội dung của varđường dẫn mà tôi đang cố phân tích, thực sự là giá trị trả về của một truy vấn dòng lệnh. Đó không phải là dữ liệu đường dẫn mà tôi tự tạo ra. Nó được lưu trữ trong một tệp và công cụ dòng lệnh sẽ không thoát khỏi dấu gạch chéo ngược.

Tôi đã bị cắn rất nhiều lần bởi những người viết các chức năng thay đổi đường dẫn của chính họ và hiểu sai. Dấu cách, dấu gạch chéo, dấu gạch chéo ngược, dấu hai chấm - khả năng gây nhầm lẫn không phải là vô tận, nhưng dù sao cũng có thể dễ dàng mắc lỗi. Vì vậy, tôi là một người gắn bó cho việc sử dụng os.pathvà giới thiệu nó trên cơ sở đó.

(Tuy nhiên, con đường dẫn đến đức hạnh không phải là con đường dễ dàng nhất, và nhiều người khi tìm thấy điều này bị cám dỗ đi một con đường trơn trượt đến chết tiệt. Họ sẽ không nhận ra cho đến một ngày mọi thứ sụp đổ, và họ - hoặc , nhiều khả năng, một người khác - phải tìm ra lý do tại sao mọi thứ đã sai, và hóa ra ai đó đã tạo một tên tệp trộn lẫn dấu gạch chéo và dấu gạch chéo ngược - và một số người cho rằng câu trả lời là "không làm điều đó". Không phải là bất kỳ ai trong số những người này. Ngoại trừ người đã trộn lẫn dấu gạch chéo và dấu gạch chéo ngược - bạn có thể là họ nếu bạn muốn.)

Bạn có thể lấy ổ đĩa và đường dẫn + tệp như thế này:

drive, path_and_file = os.path.splitdrive(path)

Nhận đường dẫn và tệp:

path, file = os.path.split(path_and_file)

Lấy tên thư mục riêng lẻ không đặc biệt thuận tiện, nhưng đó là loại khó chịu trung thực trung thực làm tăng niềm vui sau này khi tìm thấy thứ gì đó thực sự hoạt động tốt:

folders = []
while 1:
    path, folder = os.path.split(path)

    if folder != "":
        folders.append(folder)
    else:
        if path != "":
            folders.append(path)

        break

folders.reverse()

(Điều này xuất hiện "\"khi bắt đầu foldersnếu đường dẫn ban đầu là tuyệt đối. Bạn có thể mất một chút mã nếu bạn không muốn điều đó.)

tôi sẽ làm

import os
path = os.path.normpath(path)
path.split(os.sep)

Đầu tiên, chuẩn hóa chuỗi đường dẫn thành một chuỗi thích hợp cho HĐH. Sau đó, os.sepphải an toàn để sử dụng như một dấu phân cách trong phân chia hàm chuỗi.

Bạn chỉ có thể sử dụng phương pháp Pythonic nhất (IMHO):

import os

your_path = r"d:\stuff\morestuff\furtherdown\THEFILE.txt"
path_list = your_path.split(os.sep)
print path_list

Mà sẽ cung cấp cho bạn:

['d:', 'stuff', 'morestuff', 'furtherdown', 'THEFILE.txt']

Manh mối ở đây là sử dụng os.septhay vì '\\'hoặc '/', vì điều này làm cho hệ thống độc lập.

Để xóa dấu hai chấm khỏi ký tự ổ đĩa (mặc dù tôi không thấy bất kỳ lý do nào khiến bạn muốn làm điều đó), bạn có thể viết:

path_list[0] = path_list[0][0]

Trong Python> = 3,4, điều này đã trở nên đơn giản hơn nhiều. Bây giờ bạn có thể sử dụng pathlib.Path.partsđể có được tất cả các phần của một con đường.

Thí dụ:

>>> from pathlib import Path
>>> Path('C:/path/to/file.txt').parts
('C:\\', 'path', 'to', 'file.txt')
>>> Path(r'C:\path\to\file.txt').parts
('C:\\', 'path', 'to', 'file.txt')

Trên bản cài đặt Windows 3 của Python 3, điều này sẽ cho rằng bạn đang làm việc với các đường dẫn Windows và trên * nix, nó sẽ cho rằng bạn đang làm việc với các đường dẫn posix. Đây thường là những gì bạn muốn, nhưng nếu không, bạn có thể sử dụng các lớp pathlib.PurePosixPathhoặc pathlib.PureWindowsPathkhi cần:

>>> from pathlib import PurePosixPath, PureWindowsPath
>>> PurePosixPath('/path/to/file.txt').parts
('/', 'path', 'to', 'file.txt')
>>> PureWindowsPath(r'C:\path\to\file.txt').parts
('C:\\', 'path', 'to', 'file.txt')
>>> PureWindowsPath(r'\\host\share\path\to\file.txt').parts
('\\\\host\\share\\', 'path', 'to', 'file.txt')

Chỉnh sửa: Ngoài ra còn có một backport cho python 2: pathlib2

Vấn đề ở đây bắt đầu từ cách bạn tạo chuỗi ở vị trí đầu tiên.

a = "d:\stuff\morestuff\furtherdown\THEFILE.txt"

Thực hiện theo cách này, Python đang cố gắng trường hợp đặc biệt sau đây: \s, \m, \f, và \T. Trong trường hợp của bạn, \fđang được coi là một nguồn cấp dữ liệu mẫu (0x0C) trong khi các dấu gạch chéo ngược khác được xử lý chính xác. Những gì bạn cần làm là một trong những điều sau:

b = "d:\\stuff\\morestuff\\furtherdown\\THEFILE.txt"      # doubled backslashes
c = r"d:\stuff\morestuff\furtherdown\THEFILE.txt"         # raw string, no doubling necessary

Sau đó, khi bạn chia một trong hai thứ này, bạn sẽ nhận được kết quả bạn muốn.

Đối với một giải pháp ngắn gọn hơn, hãy xem xét những điều sau đây:

def split_path(p):
    a,b = os.path.split(p)
    return (split_path(a) if len(a) and len(b) else []) + [b]

Tôi thực sự không thể đóng góp một câu trả lời thực sự cho câu hỏi này (vì tôi đến đây với hy vọng tìm thấy một mình), nhưng với tôi số cách tiếp cận khác nhau và tất cả các cảnh báo được đề cập là chỉ số chắc chắn nhất mà mô-đun os.path của Python rất cần điều này như một chức năng tích hợp.

Các cách chức năng, với một máy phát điện .

def split(path):
    (drive, head) = os.path.splitdrive(path)
    while (head != os.sep):
        (head, tail) = os.path.split(head)
        yield tail

Trong hành động:

>>> print([x for x in split(os.path.normpath('/path/to/filename'))])
['filename', 'to', 'path']

Nó hoạt động với tôi:

>>> a=r"d:\stuff\morestuff\furtherdown\THEFILE.txt"
>>> a.split("\\")
['d:', 'stuff', 'morestuff', 'furtherdown', 'THEFILE.txt']

Chắc chắn bạn có thể cần phải loại bỏ dấu hai chấm từ thành phần đầu tiên, nhưng việc giữ nó làm cho nó có thể lắp ráp lại đường dẫn.

Công cụ rsửa đổi đánh dấu chuỗi ký tự là "thô"; chú ý cách dấu gạch chéo ngược không được nhân đôi.

Các công cụ về mypath.split("\\")sẽ được thể hiện tốt hơn như mypath.split(os.sep). seplà dấu phân cách đường dẫn cho nền tảng cụ thể của bạn (ví dụ: \cho Windows, /cho Unix, v.v.) và bản dựng Python biết nên sử dụng cái nào. Nếu bạn sử dụng sep, thì mã của bạn sẽ là bất khả tri.

re.split () có thể giúp thêm một chút sau đó chuỗi.split ()

import re    
var = "d:\stuff\morestuff\furtherdown\THEFILE.txt"
re.split( r'[\\/]', var )
['d:', 'stuff', 'morestuff', 'furtherdown', 'THEFILE.txt']

Nếu bạn cũng muốn hỗ trợ các đường dẫn Linux và Mac, chỉ cần thêm bộ lọc (Không có kết quả), do đó, nó sẽ xóa '' không mong muốn khỏi split () vì các đường dẫn của chúng bắt đầu bằng '/' hoặc '//'. ví dụ '// mount / ...' hoặc '/ var / tmp /'

import re    
var = "/var/stuff/morestuff/furtherdown/THEFILE.txt"
result = re.split( r'[\\/]', var )
filter( None, result )
['var', 'stuff', 'morestuff', 'furtherdown', 'THEFILE.txt']

Bạn có thể đệ quy os.path.splitchuỗi

import os
def parts(path):
    p,f = os.path.split(path)
    return parts(p) + [f] if f else [p]

Kiểm tra điều này với một số chuỗi đường dẫn và gắn lại đường dẫn với os.path.join

>>> for path in [
...         r'd:\stuff\morestuff\furtherdown\THEFILE.txt',
...         '/path/to/file.txt',
...         'relative/path/to/file.txt',
...         r'C:\path\to\file.txt',
...         r'\\host\share\path\to\file.txt',
...     ]:
...     print parts(path), os.path.join(*parts(path))
... 
['d:\\', 'stuff', 'morestuff', 'furtherdown', 'THEFILE.txt'] d:\stuff\morestuff\furtherdown\THEFILE.txt
['/', 'path', 'to', 'file.txt'] /path\to\file.txt
['', 'relative', 'path', 'to', 'file.txt'] relative\path\to\file.txt
['C:\\', 'path', 'to', 'file.txt'] C:\path\to\file.txt
['\\\\', 'host', 'share', 'path', 'to', 'file.txt'] \\host\share\path\to\file.txt

Phần tử đầu tiên của danh sách có thể cần được xử lý khác nhau tùy thuộc vào cách bạn muốn xử lý ký tự ổ đĩa, đường dẫn UNC và đường dẫn tuyệt đối và tương đối. Thay đổi cái cuối cùng [p]để [os.path.splitdrive(p)]buộc vấn đề bằng cách tách ký tự ổ đĩa và thư mục gốc thành một bộ.

import os
def parts(path):
    p,f = os.path.split(path)
    return parts(p) + [f] if f else [os.path.splitdrive(p)]

[('d:', '\\'), 'stuff', 'morestuff', 'furtherdown', 'THEFILE.txt']
[('', '/'), 'path', 'to', 'file.txt']
[('', ''), 'relative', 'path', 'to', 'file.txt']
[('C:', '\\'), 'path', 'to', 'file.txt']
[('', '\\\\'), 'host', 'share', 'path', 'to', 'file.txt']

Chỉnh sửa: Tôi đã nhận ra rằng câu trả lời này rất giống với câu trả lời ở trên của user1556435 . Tôi đang để lại câu trả lời của mình vì việc xử lý thành phần ổ đĩa của đường dẫn là khác nhau.

Giống như những người khác đã giải thích - vấn đề của bạn bắt nguồn từ việc sử dụng \, đó là ký tự thoát trong chuỗi ký tự / hằng. OTOH, nếu bạn có chuỗi đường dẫn tệp đó từ một nguồn khác (đọc từ tệp, bảng điều khiển hoặc được trả về bởi chức năng os) - sẽ không có vấn đề gì khi chia tách trên '\' hoặc r '\'.

Và giống như những người khác đề xuất, nếu bạn muốn sử dụng \theo nghĩa đen của chương trình, bạn phải sao chép nó \\hoặc toàn bộ nghĩa đen phải được thêm tiền tố r, như vậy r'lite\ral'hoặc r"lite\ral"để tránh trình phân tích cú pháp chuyển đổi ký tự đó \và rthành ký tự CR (trả về vận chuyển).

Mặc dù vậy, có một cách nữa - chỉ cần không sử dụng \tên đường dẫn dấu gạch chéo ngược trong mã của bạn! Từ thế kỷ trước, Windows nhận ra và hoạt động tốt với các tên đường dẫn sử dụng dấu gạch chéo chuyển tiếp làm dấu phân cách thư mục /! Bằng cách nào đó không nhiều người biết điều đó .. nhưng nó hoạt động:

>>> var = "d:/stuff/morestuff/furtherdown/THEFILE.txt"
>>> var.split('/')
['d:', 'stuff', 'morestuff', 'furtherdown', 'THEFILE.txt']

Nhân tiện, điều này sẽ làm cho mã của bạn hoạt động trên Unix, Windows và Mac ... bởi vì tất cả chúng đều sử dụng /như dấu tách thư mục ... ngay cả khi bạn không muốn sử dụng các hằng số mô-đun được xác định trước os.

Giả sử bạn có một tệp filedata.txtcó nội dung:

d:\stuff\morestuff\furtherdown\THEFILE.txt
d:\otherstuff\something\otherfile.txt

Bạn có thể đọc và phân chia đường dẫn tệp:

>>> for i in open("filedata.txt").readlines():
...     print i.strip().split("\\")
... 
['d:', 'stuff', 'morestuff', 'furtherdown', 'THEFILE.txt']
['d:', 'otherstuff', 'something', 'otherfile.txt']

Tôi sử dụng như sau vì nó sử dụng hàm os.path.basename, nó không thêm bất kỳ dấu gạch chéo nào vào danh sách trả về. Nó cũng hoạt động với các dấu gạch chéo của bất kỳ nền tảng nào: tức là cửa sổ \ hoặc unix's /. Và hơn nữa, nó không thêm \ \ \ mà windows sử dụng cho đường dẫn máy chủ :)

def SplitPath( split_path ):
    pathSplit_lst   = []
    while os.path.basename(split_path):
        pathSplit_lst.append( os.path.basename(split_path) )
        split_path = os.path.dirname(split_path)
    pathSplit_lst.reverse()
    return pathSplit_lst

Vì vậy, đối với '\ \ \ máy chủ \ thư mục1 \ thư mục2 \ thư mục3 \ thư mục4'

bạn lấy

['Máy chủ', 'thư mục1', 'thư mục2', 'thư mục3', 'thư mục4']

Tôi thực sự không chắc chắn nếu điều này trả lời đầy đủ câu hỏi, nhưng tôi đã có một thời gian vui vẻ khi viết hàm nhỏ này giữ một ngăn xếp, dính vào các thao tác dựa trên os.path và trả về danh sách / ngăn xếp các mục.

  9 def components(path):
 10     ret = []
 11     while len(path) > 0:
 12         path, crust = split(path)
 13         ret.insert(0, crust)
 14
 15     return ret
 16

Dòng mã dưới đây có thể xử lý:

1. C: / đường dẫn / đường dẫn
2. C: // đường dẫn // đường dẫn
3. C: \ path \ path
4. C: \ path \ path

đường dẫn = re.split (r '[/// \]', đường dẫn)

Một đệ quy cho vui.

Không phải là câu trả lời tao nhã nhất, nhưng nên hoạt động ở mọi nơi:

import os

def split_path(path):
    head = os.path.dirname(path)
    tail = os.path.basename(path)
    if head == os.path.dirname(head):
        return [tail]
    return split_path(head) + [tail]

sử dụng ntpath.split()