如何在Python中将Dos路径拆分为其组件

我有一个代表dos路径的字符串变量，例如：

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

我想将此字符串拆分为：

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

我尝试使用split()和，replace()但是它们要么只处理第一个反斜杠，要么将十六进制数字插入字符串。

我需要以某种方式将此字符串变量转换为原始字符串，以便对其进行解析。

最好的方法是什么？

我还应该补充一点，var即我要解析的路径的内容实际上是命令行查询的返回值。我生成的不是路径数据。它存储在文件中，命令行工具不会转义反斜杠。

人们一直在编写自己的路径摆弄功能并弄错了它，这使我倍感痛苦。空格，斜杠，反斜杠，冒号-混乱的可能性并非无止境，但无论如何还是容易犯错误。因此，我非常喜欢使用os.path，并在此基础上推荐使用。

（但是，通往美德的途径并不是最容易采用的途径，许多人在发现这一点时总是倾向于走一条湿滑的道路直指该死。他们直到一天都不会意识到一切都崩溃了，他们- ，更有可能是其他人-必须弄清楚为什么一切都出错了，结果是有人制作了一个包含斜杠和反斜杠的文件名-有人建议答案是“不要这样做”。这些人中的任何一个。除了将斜杠和反斜杠混在一起的人之外，如果您愿意，可以成为他们。）

您可以这样获得驱动器和路径+文件：

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

获取路径和文件：

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

获取各个文件夹的名称并不是特别方便，但这是一种诚实的中间不适，这增加了以后找到实际可行的东西的乐趣：

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

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

        break

folders.reverse()

（如果该路径最初是绝对路径"\"，folders则会在此路径的开头弹出a 。如果不希望这样做，可能会丢失一些代码。）

我会做

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

首先，将路径字符串标准化为适合操作系统的字符串。然后os.sep必须安全地用作字符串函数分割中的定界符。

您可以简单地使用最Python化的方法（IMHO）：

import os

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

这会给你：

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

这里的提示是使用os.sep而不是'\\'或'/'，因为这使它独立于系统。

要从驱动器号中删除冒号（尽管我看不到您要这样做的任何原因），您可以编写：

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

在Python> = 3.4中，这变得更加简单。现在，您可以pathlib.Path.parts用来获取路径的所有部分。

例：

>>> 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')

在Windows安装的Python 3上，这将假定您正在使用Windows路径，而在* nix上，将假定您正在使用posix路径。这通常是您想要的，但是如果不是，则可以使用类pathlib.PurePosixPath或pathlib.PureWindowsPath根据需要：

>>> 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')

编辑：还有一个反向移植到python 2可用：pathlib2

这里的问题始于如何首先创建字符串。

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

使用这种方式时，巨蟒试图特殊情况下，这些：\s，\m，\f，和\T。在您的情况下，\f被视为换页（0x0C），而其他反斜杠的处理正确。您需要执行以下操作之一：

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

然后，将其中任何一个拆分后，您将获得所需的结果。

对于更简洁的解决方案，请考虑以下事项：

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

我实际上无法对此做出真正的回答（因为我来这里只是为了找到一个我自己），但是对我来说，不同方法的数量以及所提到的所有警告是最确定的指标，表明Python的os.path模块迫切需要这一点。作为内置功能。

具有生成器的功能方式。

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

实际上：

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

这个对我有用：

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

当然，您可能还需要从第一个组件中去除冒号，但是保留它可以重新组装路径。

该r修改标记字符串文字为“原始”; 注意嵌入的反斜杠如何不加倍。

关于的内容mypath.split("\\")最好用表示mypath.split(os.sep)。sep是您特定平台（例如\Windows，/Unix等）的路径分隔符，Python构建知道使用哪个平台。如果您使用sep，那么您的代码将与平台无关。

re.split（）比string.split（）可以提供更多帮助

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

如果您还想支持Linux和Mac路径，只需添加filter（None，result），由于它的路径以'/'或'//'开头，因此它将从split（）中删除不需要的''。例如'// mount / ...'或'/ 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']

您可以递归os.path.split的字符串

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

针对一些路径字符串进行测试，然后使用 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

根据您要如何处理驱动器号，UNC路径以及绝对和相对路径，可能需要对列表的第一个元素进行不同的处理。更改最后一个[p]以[os.path.splitdrive(p)]将驱动器号和目录根拆分为元组来强制问题。

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']

编辑：我已经意识到，这个答案是非常相似的，上面给出的user1556435。我留下我的答案，因为路径的驱动器组件的处理方式不同。

就像其他人解释的那样-您的问题源于使用\，这是字符串文字/常量中的转义字符。OTOH，如果您有另一个来源的文件路径字符串（从文件，控制台读取或由os函数返回）-在'\\'或r'\'上拆分不会有问题。

就如同其他人则建议，如果你想使用\的程序的文字，你必须要么复制它\\或整个文本必须由前缀r，像这样r'lite\ral'或r"lite\ral"避免解析器转换是\和r对CR（回车）字符。

不过，还有另一种方法-就是不要\在代码中使用反斜杠路径名！自从上个世纪以来，Windows认识到使用正斜杠作为目录分隔符的路径名并可以很好地工作/！不知何故，没有多少人知道..但是它起作用：

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

顺便说一下，这将使您的代码在Unix，Windows和Mac上运行...因为它们全部都/用作目录分隔符...即使您不想使用module的预定义常量os。

假设您有一个filedata.txt包含内容的文件：

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

您可以读取和分割文件路径：

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

我使用以下命令，因为它使用os.path.basename函数，因此不会在返回的列表中添加任何斜杠。它也适用于任何平台的斜杠：即窗口的\\或Unix的/。而且，它不会添加Windows用于服务器路径的\\\\ ：）

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

因此对于'\\\\ server \\ folder1 \\ folder2 \\ folder3 \\ folder4'

你得到

['服务器'，'文件夹1'，'文件夹2'，'文件夹3'，'文件夹4']

我实际上不确定这是否可以完全回答问题，但是我很开心地编写了这个小功能，该功能可以保持堆栈，坚持使用基于os.path的操作并返回项目的列表/堆栈。

  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

下面的代码行可以处理：

1. C：/路径/路径
2. C：//路径//路径
3. C：\路径\路径
4. C：\路径\路径

路径= re.split（r'[/// \]'，路径）

一种递归的乐趣。

这不是最优雅的答案，但是应该可以在任何地方使用：

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]

用 ntpath.split()