So teilen Sie einen Dos-Pfad in Python in seine Komponenten auf

Ich habe eine String-Variable, die einen Dos-Pfad darstellt, z.

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

Ich möchte diesen String aufteilen in:

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

Ich habe es versucht split()und replace()aber sie verarbeiten entweder nur den ersten Backslash oder sie fügen Hex-Zahlen in die Zeichenfolge ein.

Ich muss diese Zeichenfolgenvariable irgendwie in eine Rohzeichenfolge konvertieren, damit ich sie analysieren kann.

Was ist der beste Weg, dies zu tun?

Ich sollte auch hinzufügen, dass der Inhalt des varPfads, den ich zu analysieren versuche, tatsächlich der Rückgabewert einer Befehlszeilenabfrage ist. Es sind keine Pfaddaten, die ich selbst generiere. Es ist in einer Datei gespeichert, und das Befehlszeilentool wird den Backslashes nicht entkommen.

Ich bin viele Male von Leuten gebissen worden, die ihre eigenen Pfadfummelfunktionen geschrieben haben und es falsch verstanden haben. Leerzeichen, Schrägstriche, Backslashes, Doppelpunkte - die Möglichkeiten für Verwirrung sind nicht endlos, aber Fehler können trotzdem leicht gemacht werden. Also bin ich ein Stickler für die Verwendung von os.pathund empfehle es auf dieser Basis.

(Der Weg zur Tugend ist jedoch nicht der leichteste, und viele Menschen, die dies finden, sind versucht, einen rutschigen Weg direkt zur Verdammnis zu gehen. Sie werden erst eines Tages erkennen, dass alles in Stücke fällt, und sie - oder Wahrscheinlich muss jemand anderes herausfinden, warum alles schief gelaufen ist, und es stellt sich heraus, dass jemand einen Dateinamen erstellt hat, der Schrägstriche und Backslashes mischt. Eine Person schlägt vor, dass die Antwort "das nicht tun" lautet. Don ' Ich bin keiner dieser Leute. Außer dem, der Schrägstriche und Backslashes verwechselt hat - du könntest sie sein, wenn du willst.)

Sie können das Laufwerk und die Pfad + Datei wie folgt abrufen:

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

Holen Sie sich den Pfad und die Datei:

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

Das Abrufen der einzelnen Ordnernamen ist nicht besonders praktisch, aber es ist die Art von ehrlichem, mittelmäßigem Unbehagen, die das Vergnügen erhöht, später etwas zu finden, das tatsächlich gut funktioniert:

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

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

        break

folders.reverse()

(Dies erscheint "\"am Anfang, folderswenn der Pfad ursprünglich absolut war. Sie könnten ein bisschen Code verlieren, wenn Sie das nicht wollten.)

Ich würde es tun

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

Normalisieren Sie zuerst die Pfadzeichenfolge in eine geeignete Zeichenfolge für das Betriebssystem. Dann os.sepmuss es sicher sein, als Trennzeichen bei der Aufteilung von Zeichenfolgenfunktionen verwendet zu werden.

Sie können einfach den pythonischsten Ansatz (IMHO) verwenden:

import os

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

Welches wird Ihnen geben:

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

Der Hinweis hier ist, os.sepanstelle von '\\'oder zu verwenden '/', da dies das System unabhängig macht.

Um den Doppelpunkt aus dem Laufwerksbuchstaben zu entfernen (obwohl ich keinen Grund sehe, warum Sie das tun möchten), können Sie schreiben:

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

In Python> = 3.4 ist dies viel einfacher geworden. Sie können jetzt pathlib.Path.partsalle Teile eines Pfads abrufen.

Beispiel:

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

Bei einer Windows-Installation von Python 3 wird davon ausgegangen, dass Sie mit Windows-Pfaden arbeiten, und bei * nix wird davon ausgegangen, dass Sie mit Posix-Pfaden arbeiten. Dies ist normalerweise das, was Sie wollen, aber wenn dies nicht der Fall ist, können Sie die Klassen verwenden pathlib.PurePosixPathoder pathlib.PureWindowsPathnach Bedarf:

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

Bearbeiten: Es gibt auch einen Backport zu Python 2: pathlib2

Das Problem beginnt hier zunächst damit, wie Sie die Zeichenfolge erstellen.

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

Geschah diese Weise wird versucht , Python zu speziellem Fall dieser: \s, \m, \f, und \T. In Ihrem Fall \fwird es als Formfeed (0x0C) behandelt, während die anderen Backslashes korrekt behandelt werden. Was Sie tun müssen, ist eine der folgenden:

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

Sobald Sie eine dieser Optionen aufgeteilt haben, erhalten Sie das gewünschte Ergebnis.

Beachten Sie für eine etwas präzisere Lösung Folgendes:

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

Ich kann keine wirkliche Antwort auf diese Frage geben (da ich hierher gekommen bin, um selbst eine zu finden), aber für mich ist die Anzahl der unterschiedlichen Ansätze und alle genannten Vorbehalte der sicherste Indikator dafür, dass Pythons os.path-Modul dies dringend benötigt als eingebaute Funktion.

Der funktionale Weg mit einem Generator .

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

In Aktion:

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

Für mich geht das:

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

Sicher, Sie müssen möglicherweise auch den Doppelpunkt aus der ersten Komponente entfernen, aber wenn Sie ihn beibehalten, können Sie den Pfad wieder zusammensetzen.

Der rModifikator markiert das Zeichenfolgenliteral als "raw". Beachten Sie, dass eingebettete Backslashes nicht verdoppelt werden.

Das Zeug über ungefähr mypath.split("\\")würde besser ausgedrückt werden als mypath.split(os.sep). sepist das Pfadtrennzeichen für Ihre bestimmte Plattform (z. B. \für Windows, /Unix usw.), und der Python-Build weiß, welches verwendet werden soll. Wenn Sie verwenden sep, ist Ihr Code plattformunabhängig.

re.split () kann etwas mehr helfen als string.split ()

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

Wenn Sie auch Linux- und Mac-Pfade unterstützen möchten, fügen Sie einfach einen Filter hinzu (Keine, Ergebnis), damit das unerwünschte '' aus dem split () entfernt wird, da deren Pfade mit '/' oder '//' beginnen. Zum Beispiel '// mount / ...' oder '/ 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']

Sie können os.path.splitdie Zeichenfolge rekursiv ausführen

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

Testen Sie dies anhand einiger Pfadzeichenfolgen und setzen Sie den Pfad mit neu zusammen 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

Das erste Element der Liste muss möglicherweise unterschiedlich behandelt werden, je nachdem, wie Sie mit Laufwerksbuchstaben, UNC-Pfaden sowie absoluten und relativen Pfaden umgehen möchten. Ändern des letzten [p]zu [os.path.splitdrive(p)]Kräften den Laufwerksbuchstaben und Verzeichnis Wurzel aus in ein Tupel , das Problem durch die Spaltung.

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

Bearbeiten: Ich habe festgestellt, dass diese Antwort der oben von user1556435 angegebenen sehr ähnlich ist . Ich lasse meine Antwort offen, da die Behandlung der Laufwerkskomponente des Pfads unterschiedlich ist.

Genau wie andere erklärt haben - Ihr Problem ergab sich aus der Verwendung von \Escape-Zeichen in Zeichenfolgenliteral / -konstante. OTOH, wenn Sie diese Dateipfadzeichenfolge von einer anderen Quelle hätten (aus Datei, Konsole gelesen oder von der OS-Funktion zurückgegeben), hätte es keine Probleme bei der Aufteilung auf '\\' oder r '\' gegeben.

Und genau wie andere vorgeschlagen, wenn Sie verwenden möchten , \in Programm wörtlichen, müssen Sie entweder zu duplizieren \\oder das gesamte wörtliche hat durch vorangestellt werden r, wie so r'lite\ral'oder r"lite\ral"den Parser zu vermeiden , die Umwandlung dieser \und rCR (Carriage Return).

Es gibt jedoch noch einen weiteren Weg - verwenden Sie \in Ihrem Code nur keine Backslash- Pfadnamen! Seit dem letzten Jahrhundert erkennt und funktioniert Windows gut mit Pfadnamen, die Schrägstriche als Verzeichnistrennzeichen verwenden /! Irgendwie wissen das nicht viele Leute .. aber es funktioniert:

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

Dadurch funktioniert Ihr Code übrigens unter Unix, Windows und Mac ... da alle /als Verzeichnistrennzeichen verwendet werden ... auch wenn Sie die vordefinierten Konstanten des Moduls nicht verwenden möchten os.

Angenommen, Sie haben eine Datei filedata.txtmit Inhalten:

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

Sie können die Dateipfade lesen und teilen:

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

Ich verwende Folgendes, da es die Funktion os.path.basename verwendet und der zurückgegebenen Liste keine Schrägstriche hinzufügt. Es funktioniert auch mit Schrägstrichen jeder Plattform: dh Windows \\ oder Unix /. Außerdem wird nicht das \\\\ hinzugefügt, das Windows für Serverpfade verwendet :)

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

Also für '\\\\ Server \\ Ordner1 \\ Ordner2 \\ Ordner3 \\ Ordner4'

du erhältst

['Server', 'Ordner1', 'Ordner2', 'Ordner3', 'Ordner4']

Ich bin mir nicht sicher, ob dies die Frage vollständig beantwortet, aber es hat mir Spaß gemacht, diese kleine Funktion zu schreiben, die einen Stapel behält, sich an os.path-basierte Manipulationen hält und die Liste / den Stapel von Elementen zurückgibt.

  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

Die folgende Codezeile kann Folgendes verarbeiten:

1. C: / Pfad / Pfad
2. C: // Pfad // Pfad
3. C: \ Pfad \ Pfad
4. C: \ Pfad \ Pfad

path = re.split (r '[/// \]', path)

Eine rekursive für den Spaß.

Nicht die eleganteste Antwort, sollte aber überall funktionieren:

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]

verwenden ntpath.split()