Jak podzielić ścieżkę DOS na jej komponenty w Pythonie

Mam zmienną typu string, która reprezentuje ścieżkę dos np:

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

Chcę podzielić ten ciąg na:

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

Próbowałem użyć split()i replace()ale albo przetwarzają tylko pierwszy lewy ukośnik, albo wstawiają liczby szesnastkowe do ciągu.

Muszę jakoś przekonwertować tę zmienną łańcuchową na nieprzetworzony ciąg, aby móc ją przeanalizować.

Jak najlepiej to zrobić?

Powinienem również dodać, że zawartość varnp. Ścieżki, którą próbuję przeanalizować, jest w rzeczywistości wartością zwracaną przez zapytanie w wierszu poleceń. To nie dane o ścieżkach, które sam generuję. Jest przechowywany w pliku, a narzędzie wiersza poleceń nie ucieknie przed ukośnikami odwrotnymi.

Wiele razy byłem gryziony przez ludzi piszących własną ścieżkę, bawiąc się funkcjami i robiąc to źle. Spacje, ukośniki, ukośniki odwrotne, dwukropki - możliwości pomyłki nie są nieskończone, ale i tak łatwo popełnić błędy. Więc jestem zwolennikiem stosowania os.pathi polecam go na tej podstawie.

(Jednak droga do cnoty nie należy do najłatwiejszych i wielu ludzi, gdy ją odkrywają, kusi, aby pójść śliską ścieżką prosto do potępienia. Nie zdadzą sobie sprawy, aż pewnego dnia wszystko się rozpadnie, a oni - lub bardziej prawdopodobne jest, że ktoś inny - musi dowiedzieć się, dlaczego wszystko poszło nie tak i okazuje się, że ktoś utworzył nazwę pliku zawierającą ukośniki i ukośniki odwrotne - a ktoś sugeruje, że odpowiedź brzmi „tego nie robić”. Don ' Nie bądź żadną z tych osób. Z wyjątkiem tego, który pomieszał ukośniki i ukośniki - możesz nimi być, jeśli chcesz).

Możesz uzyskać dysk i ścieżkę + plik w ten sposób:

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

Uzyskaj ścieżkę i plik:

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

Uzyskanie poszczególnych nazw folderów nie jest szczególnie wygodne, ale jest to rodzaj uczciwego dyskomfortu, który zwiększa przyjemność późniejszego znalezienia czegoś, co faktycznie działa dobrze:

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

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

        break

folders.reverse()

(Ten Zdejmuje "\"na początku folders, jeśli ścieżka była początkowo absolutna. Można stracić kawałek kodu, jeśli nie chcemy.)

chciałbym zrobić

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

Najpierw znormalizuj ciąg ścieżki do odpowiedniego ciągu dla systemu operacyjnego. Następnie os.sepmusi być bezpieczny do użycia jako separatora w funkcji split.

Możesz po prostu użyć najbardziej Pythonowego podejścia (IMHO):

import os

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

Co da ci:

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

Wskazówka polega na tym, aby użyć os.sepzamiast '\\'lub '/', ponieważ to czyni go niezależnym od systemu.

Aby usunąć dwukropek z litery dysku (chociaż nie widzę żadnego powodu, dla którego chciałbyś to zrobić), możesz napisać:

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

W Pythonie> = 3.4 stało się to znacznie prostsze. Możesz teraz użyć, pathlib.Path.partsaby uzyskać wszystkie części ścieżki.

Przykład:

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

W przypadku instalacji Pythona 3 w systemie Windows zakłada się, że pracujesz ze ścieżkami systemu Windows, a na * nix zakłada, że ​​pracujesz ze ścieżkami posix. Zwykle tego chcesz, ale jeśli tak nie jest, możesz użyć klas pathlib.PurePosixPathlub pathlib.PureWindowsPathw razie potrzeby:

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

Edycja: Dostępna jest również backport do Pythona 2: pathlib2

Problem tutaj zaczyna się od tego, jak tworzysz ciąg w pierwszej kolejności.

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

Sporządzono w ten sposób, Python próbuje szczególnym przypadku to: \s, \m, \f, i \T. W twoim przypadku \fjest traktowany jako wysuw formularza (0x0C), podczas gdy inne ukośniki odwrotne są obsługiwane poprawnie. Musisz wykonać jedną z następujących czynności:

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

Następnie po podzieleniu jednego z nich uzyskasz pożądany wynik.

Aby uzyskać nieco bardziej zwięzłe rozwiązanie, rozważ następujące kwestie:

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

Właściwie nie mogę wnieść prawdziwej odpowiedzi na to pytanie (ponieważ przyszedłem tutaj, mając nadzieję, że sam go znajdę), ale dla mnie liczba różnych podejść i wszystkie wspomniane zastrzeżenia są najpewniejszym wskaźnikiem, że moduł os.path w Pythonie desperacko tego potrzebuje jako funkcja wbudowana.

Sposób funkcjonalny, z generatorem .

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

W akcji:

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

Mi to pasuje:

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

Oczywiście może być konieczne usunięcie okrężnicy z pierwszego składnika, ale zachowanie go umożliwia ponowne złożenie ścieżki.

W rmodyfikujące znaki ciągiem znaków jako „surowe”; zwróć uwagę, że osadzone odwrotne ukośniki nie są podwajane.

To, co dotyczy, mypath.split("\\")byłoby lepiej wyrażone jako mypath.split(os.sep). sepjest separatorem ścieżek dla twojej konkretnej platformy (np. \dla Windows, /dla Uniksa itp.), a kompilacja Pythona wie, której użyć. Jeśli używasz sep, Twój kod będzie niezależny od platformy.

re.split () może pomóc trochę bardziej niż string.split ()

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

Jeśli chcesz również obsługiwać ścieżki Linuksa i Maca, po prostu dodaj filtr (Brak, wynik), aby usunąć niechciany znak „” z metody split (), ponieważ ich ścieżki zaczynają się od „/” lub „//”. na przykład „// mount / ...” lub „/ 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']

Możesz rekurencyjnie os.path.splitciąg

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

Testowanie tego na niektórych ciągach ścieżki i ponowne składanie ścieżki za pomocą 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

Pierwszy element listy może wymagać odmiennego traktowania w zależności od tego, jak chcesz radzić sobie z literami dysków, ścieżkami UNC oraz ścieżkami bezwzględnymi i względnymi. Zmiana ostatniego [p]na [os.path.splitdrive(p)]wymusza problem poprzez podzielenie litery dysku i katalogu głównego na krotkę.

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

Edycja: zdałem sobie sprawę, że ta odpowiedź jest bardzo podobna do tej podanej powyżej przez użytkownika1556435 . Zostawiam swoją odpowiedź, ponieważ obsługa komponentu napędu ścieżki jest inna.

Tak jak inni wyjaśnili - twój problem wynikał z użycia \, który jest znakiem ucieczki w literale / stałej ciągu. OTOH, gdybyś miał ten ciąg ścieżki pliku z innego źródła (odczytany z pliku, konsoli lub zwrócony przez funkcję os) - nie byłoby problemu z podziałem na '\\' lub r '\'.

I tak jak inni sugerowali, jeśli chcesz użyć \w dosłownym programie, musisz albo go zduplikować, \\albo cały literał musi być poprzedzony prefiksem r, tak jak to, r'lite\ral'lub r"lite\ral"aby uniknąć konwersji przez parser tego \i rna znak CR (powrót karetki).

Jest jeszcze jeden sposób - po prostu nie używaj nazw \ścieżek z odwrotnym ukośnikiem w swoim kodzie! Od zeszłego wieku Windows rozpoznaje i działa dobrze z nazwami ścieżek, które używają ukośnika jako separatora katalogu /! Jakoś niewiele osób o tym wie ... ale to działa:

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

To przy okazji sprawi, że twój kod będzie działał na Unix, Windows i Mac ... ponieważ wszystkie z nich używają /jako separatora katalogów ... nawet jeśli nie chcesz używać predefiniowanych stałych modułu os.

Załóżmy, że masz plik filedata.txtz zawartością:

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

Możesz czytać i dzielić ścieżki plików:

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

Używam następującego, ponieważ ponieważ używa funkcji os.path.basename, nie dodaje żadnych ukośników do zwracanej listy. Działa również z ukośnikami dowolnej platformy: tj. \\ lub unixem /. Co więcej, nie dodaje \\\\, którego system Windows używa do ścieżek serwera :)

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

Tak więc dla „\\\\ serwer \\ folder1 \\ folder2 \\ folder3 \\ folder4”

dostajesz

[„serwer”, „folder1”, „folder2”, „folder3”, „folder4”]

Właściwie nie jestem pewien, czy to w pełni odpowiada na pytanie, ale dobrze się bawiłem pisząc tę ​​małą funkcję, która przechowuje stos, trzyma się manipulacji opartych na os.path i zwraca listę / stos elementów.

  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

Poniższy wiersz kodu może obsłużyć:

1. C: / ścieżka / ścieżka
2. C: // ścieżka // ścieżka
3. C: \ ścieżka \ ścieżka
4. C: \ ścieżka \ ścieżka

path = re.split (r '[/// \]', ścieżka)

Jedna rekurencyjna dla zabawy.

Nie jest to najbardziej elegancka odpowiedź, ale powinna działać wszędzie:

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]

posługiwać się ntpath.split()