Як розділити 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повинен бути безпечним для використання в якості роздільника при розділенні функції рядків.

Ви можете просто використовувати найбільш пітонічний підхід (ІМХО):

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"

Зроблено так, 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]

Я не можу реально відповісти на це (оскільки я прийшов сюди, сподіваючись знайти його сам), але для мене кількість різних підходів і всіх згаданих застережень є найвірнішим показником того, що модуль os.path Python відчайдушно потребує цього як вбудована функція.

Функціональний спосіб, з генератором .

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, результат), щоб він видалив небажаний '' з 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 . Я залишаю свою відповідь, оскільки управління компонентами приводу шляху відрізняється.

Так само, як пояснили інші - ваша проблема виникла з використання \, що є символом втечі в рядковому буквальному / постійному. 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's /. І крім того, він не додає \\\\, що 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

Так для '\\\\ сервера \\ папка1 \\ папка2 \\ папка3 \\ папка4'

Ви отримуєте

['сервер', 'папка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. С: / шлях / шлях
2. C: // шлях // шлях
3. C: \ шлях \ шлях
4. C: \ шлях \ шлях

path = 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()