Come dividere un percorso dos nei suoi componenti in Python

Ho una variabile stringa che rappresenta un percorso dos es:

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

Voglio dividere questa stringa in:

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

Ho provato a usare split()e replace()ma elaborano solo la prima barra rovesciata o inseriscono numeri esadecimali nella stringa.

Ho bisogno di convertire questa variabile di stringa in una stringa grezza in qualche modo in modo da poterla analizzare.

Qual'è il miglior modo per farlo?

Dovrei anche aggiungere che il contenuto di varie il percorso che sto cercando di analizzare, è in realtà il valore di ritorno di una query della riga di comando. Non sono i dati del percorso che mi genera. È memorizzato in un file e lo strumento da riga di comando non sfuggirà alle barre rovesciate.

Sono stato morso un sacco di volte da persone che scrivono il proprio percorso giocherellando funzioni e sbagliare. Spazi, barre, barre rovesciate, due punti: le possibilità di confusione non sono infinite, ma gli errori possono essere facilmente commessi comunque. Quindi sono un pignolo per l'uso di os.path, e lo consiglio su tale base.

(Tuttavia, il percorso verso la virtù non è quello più facilmente intrapreso, e molte persone, quando lo trovano, sono tentate di prendere un sentiero scivoloso fino alla dannazione. Non si renderanno conto fino a quando un giorno tutto cadrà a pezzi, e loro - o , più probabilmente, qualcun altro - deve capire perché tutto è andato storto, e si scopre che qualcuno ha creato un nome file che mescola barre e barre rovesciate - e qualcuno suggerisce che la risposta è "non farlo". Don ' sia una di queste persone. Tranne quella che ha confuso barre e barre rovesciate - potresti essere loro se vuoi.)

È possibile ottenere l'unità e il percorso + file in questo modo:

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

Ottieni il percorso e il file:

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

Ottenere i nomi delle singole cartelle non è particolarmente conveniente, ma è il tipo di onesto disagio medio che accresce il piacere di trovare in seguito qualcosa che effettivamente funziona bene:

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

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

        break

folders.reverse()

(Questo appare "\"all'inizio foldersse il percorso era originariamente assoluto. Potresti perdere un po 'di codice se non lo volessi.)

farei

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

Innanzitutto normalizzare la stringa del percorso in una stringa corretta per il sistema operativo. Quindi os.sepdeve essere sicuro da usare come delimitatore nella suddivisione della funzione stringa.

Puoi semplicemente usare l'approccio più Pythonic (IMHO):

import os

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

Che ti darà:

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

L'indizio qui è usare al os.sepposto di '\\'o '/', in quanto ciò rende il sistema indipendente.

Per rimuovere i due punti dalla lettera dell'unità (anche se non vedo alcun motivo per cui vorresti farlo), puoi scrivere:

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

In Python> = 3.4 questo è diventato molto più semplice. Ora puoi usare pathlib.Path.partsper ottenere tutte le parti di un percorso.

Esempio:

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

Su un'installazione Windows di Python 3 questo presupporrà che stai lavorando con percorsi Windows e su * nix supporrà che stai lavorando con percorsi posix. Questo è di solito quello che vuoi, ma se non lo è puoi usare le classi pathlib.PurePosixPatho pathlib.PureWindowsPathsecondo necessità:

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

Modifica: è disponibile anche un backport per Python 2: pathlib2

Il problema qui inizia con come stai creando la stringa in primo luogo.

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

Fatto questo modo, Python sta provando a caso speciale questi: \s, \m, \f, e \T. Nel tuo caso, \fviene trattato come un formfeed (0x0C) mentre le altre barre rovesciate vengono gestite correttamente. Quello che devi fare è uno di questi:

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

Quindi, una volta divisi uno di questi, otterrai il risultato desiderato.

Per una soluzione un po 'più concisa, considerare quanto segue:

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

In realtà non posso dare una vera risposta a questa (dato che sono venuto qui sperando di trovarne una da solo), ma per me il numero di approcci diversi e tutti gli avvertimenti menzionati è l'indicatore più sicuro che il modulo os.path di Python ha un disperato bisogno di questo come funzione integrata.

Il modo funzionale, con un generatore .

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

In azione:

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

Per me funziona:

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

Sicuramente potresti dover rimuovere anche i due punti dal primo componente, ma mantenerlo rende possibile riassemblare il percorso.

Il rmodificatore contrassegna la stringa letteralmente come "raw"; notare come le barre rovesciate integrate non siano raddoppiate.

Le cose su circa mypath.split("\\")sarebbero meglio espresse come mypath.split(os.sep). sepè il separatore di percorso per la tua particolare piattaforma (ad esempio, \per Windows, /per Unix, ecc.) e la build di Python sa quale utilizzare. Se lo usi sep, il tuo codice sarà indipendente dalla piattaforma.

re.split () può aiutare un po 'di più di string.split ()

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

Se si desidera supportare anche i percorsi Linux e Mac, è sufficiente aggiungere un filtro (Nessuno, risultato), quindi rimuoverà lo "" indesiderato dalla divisione () poiché i loro percorsi iniziano con "/" o "//". ad esempio '// mount / ...' o '/ 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']

È possibile ricorsivamente os.path.splitla stringa

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

Provando questo contro alcune stringhe di percorso e riassemblando il percorso con 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

Potrebbe essere necessario trattare il primo elemento dell'elenco in modo diverso a seconda di come si desidera gestire le lettere di unità, i percorsi UNC e i percorsi assoluti e relativi. La modifica dell'ultimo [p]per [os.path.splitdrive(p)]forzare il problema suddividendo la lettera di unità e la directory root in una tupla.

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

Modifica: mi sono reso conto che questa risposta è molto simile a quella data sopra dal user1556435 . Lascio la mia risposta perché la gestione del componente di unità del percorso è diversa.

Proprio come altri hanno spiegato - il tuo problema derivava dall'uso \ , che è il carattere di escape nella stringa letterale / costante. OTOH, se avessi quella stringa del percorso del file da un'altra fonte (letta da file, console o restituita dalla funzione os) - non ci sarebbe stato problema a suddividere in '\\' o r '\'.

E proprio come altri hanno suggerito, se si desidera utilizzare \nel programma letterale, è necessario duplicarlo \\o l'intero letterale deve essere preceduto da r, in questo modo r'lite\ral'o r"lite\ral"per evitare che il parser lo converta \er in carattere CR (ritorno a capo).

C'è un altro modo, però: semplicemente non usare i \percorsi backslash nel tuo codice! Fin dal secolo scorso Windows riconosce e funziona bene con i nomi dei percorsi che usano la barra in avanti come separatore di directory /! In qualche modo non molte persone lo sanno ... ma funziona:

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

Questo a proposito farà funzionare il tuo codice su Unix, Windows e Mac ... perché tutti usano /come separatore di directory ... anche se non vuoi usare le costanti predefinite del modulo os.

Supponiamo di avere un file filedata.txtcon contenuto:

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

Puoi leggere e dividere i percorsi dei file:

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

Uso quanto segue poiché, poiché utilizza la funzione os.path.basename, non aggiunge barre all'elenco restituito. Funziona anche con le barre di qualsiasi piattaforma: ad esempio windows \\ o unix's /. Inoltre, non aggiunge il \\\\ che Windows utilizza per i percorsi del server :)

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

Quindi per '\\\\ server \\ cartella1 \\ cartella2 \\ cartella3 \\ cartella4'

hai capito

[ 'Server', 'cartella1', 'folder2', 'Folder3', 'Folder4']

In realtà non sono sicuro che questo risponda pienamente alla domanda, ma mi sono divertito a scrivere questa piccola funzione che mantiene uno stack, si attacca alle manipolazioni basate su os.path e restituisce l'elenco / stack di elementi.

  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

Sotto la riga di codice è possibile gestire:

1. C: percorso / / path
2. C: // // percorso percorso
3. C: \ percorso \ percorso
4. C: \ percorso \ percorso

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

Uno ricorsivo per il divertimento.

Non è la risposta più elegante, ma dovrebbe funzionare ovunque:

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]

uso ntpath.split()