Как разделить путь DOS на его компоненты в Python

У меня есть строковая переменная, которая представляет путь 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если путь изначально был абсолютным. Вы можете потерять немного кода, если не хотите этого.)

я бы сделал

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

Сначала нормализуйте строку пути в правильную строку для ОС. Тогда os.sepдолжно быть безопасно использовать в качестве разделителя в строковой функции split.

Вы можете просто использовать самый Pythonic подход (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')

При установке Python 3 для Windows это предполагает, что вы работаете с путями 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"

Сделано так, Python пытается частный случай это: \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, просто добавьте фильтр (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']

Изменить: я понял, что этот ответ очень похож на тот, который приведен выше пользователем 1556435 . Я оставляю свой ответ, так как обработка компонента пути отличается.

Как и другие объяснили, ваша проблема возникла из-за использования \escape-символа в строковом литерале / константе. 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 ... потому что все они используют в /качестве разделителя каталогов ... даже если вы не хотите использовать предопределенные константы модуля 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'

ты получаешь

[ 'Сервер', 'Folder1', 'folder2', 'folder3', 'Folder4']

На самом деле я не уверен, что это полностью отвечает на вопрос, но я весело провел время, написав эту маленькую функцию, которая хранит стек, придерживается манипуляций на основе 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()