Comment diviser un chemin DOS en ses composants en Python

J'ai une variable de chaîne qui représente un chemin dos, par exemple:

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

Je veux diviser cette chaîne en:

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

J'ai essayé d'utiliser split()et replace()mais ils ne traitent que la première barre oblique inverse ou ils insèrent des nombres hexadécimaux dans la chaîne.

J'ai besoin de convertir cette variable de chaîne en une chaîne brute afin de pouvoir l'analyser.

Quelle est la meilleure façon de procéder?

Je devrais également ajouter que le contenu de varie le chemin que j'essaie d'analyser, est en fait la valeur de retour d'une requête de ligne de commande. Ce ne sont pas des données de chemin que je génère moi-même. Il est stocké dans un fichier et l'outil de ligne de commande n'échappera pas aux barres obliques inverses.

J'ai été mordu de nombreuses fois par des gens qui écrivent leurs propres fonctions de violon et se trompent. Espaces, barres obliques, barres obliques inverses, deux-points - les possibilités de confusion ne sont pas infinies, mais des erreurs sont faciles de toute façon. Je suis donc très perspicace pour l'utilisation de os.path, et je le recommande sur cette base.

(Cependant, le chemin de la vertu n'est pas celui qui est le plus facile à emprunter, et beaucoup de gens, lorsqu'ils le trouvent, sont tentés de prendre un chemin glissant directement vers la damnation. Ils ne réaliseront pas avant qu'un jour tout tombe en morceaux, et ils - ou , plus probablement, quelqu'un d'autre - doit trouver pourquoi tout a mal tourné, et il s'avère que quelqu'un a créé un nom de fichier qui mélange des barres obliques inverses et des barres obliques inverses - et quelqu'un suggère que la réponse est "ne pas faire cela". Don ' t être l'une de ces personnes. À l'exception de celle qui a mélangé des barres obliques inverses et des barres obliques inverses - vous pourriez être elles si vous le souhaitez.)

Vous pouvez obtenir le lecteur et le chemin + le fichier comme ceci:

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

Récupérez le chemin et le fichier:

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

Obtenir les noms de dossiers individuels n'est pas particulièrement pratique, mais c'est le genre d'inconfort moyen honnête qui augmente le plaisir de trouver plus tard quelque chose qui fonctionne bien:

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

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

        break

folders.reverse()

(Cela apparaît "\"au début de folderssi le chemin était à l'origine absolu. Vous pourriez perdre un peu de code si vous ne le vouliez pas.)

je ferais

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

Commencez par normaliser la chaîne de chemin en une chaîne appropriée pour le système d'exploitation. Ensuite, il os.sepdoit être sûr de l'utiliser comme délimiteur dans la fonction de chaîne fractionnée.

Vous pouvez simplement utiliser l'approche la plus pythonique (IMHO):

import os

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

Ce qui vous donnera:

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

L'indice ici est d'utiliser à la os.sepplace de '\\'ou '/', car cela le rend indépendant du système.

Pour supprimer deux points de la lettre de lecteur (bien que je ne vois aucune raison pour laquelle vous voudriez le faire), vous pouvez écrire:

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

En Python> = 3.4, cela est devenu beaucoup plus simple. Vous pouvez maintenant utiliserpathlib.Path.parts pour obtenir toutes les parties d'un chemin.

Exemple:

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

Sur une installation Windows de Python 3, cela supposera que vous travaillez avec des chemins Windows, et sur * nix, cela supposera que vous travaillez avec des chemins posix. C'est généralement ce que vous voulez, mais si ce n'est pas le cas, vous pouvez utiliser les classes pathlib.PurePosixPathou pathlib.PureWindowsPathselon vos besoins:

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

Edit: Il existe également un backport vers python 2 disponible: pathlib2

Le problème ici commence par la façon dont vous créez la chaîne en premier lieu.

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

Fait de cette façon, Python essaie de cas particulier celles - ci: \s, \m, \fet \T. Dans votre cas, \fest traité comme un saut de page (0x0C) tandis que les autres barres obliques inverses sont gérées correctement. Voici ce que vous devez faire:

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

Ensuite, une fois que vous avez divisé l'un ou l'autre, vous obtiendrez le résultat souhaité.

Pour une solution un peu plus concise, considérez ce qui suit:

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

Je ne peux pas réellement apporter une vraie réponse à celle-ci (car je suis venu ici en espérant en trouver une moi-même), mais pour moi, le nombre d'approches différentes et toutes les mises en garde mentionnées est l'indicateur le plus sûr que le module os.path de Python en a désespérément besoin. comme fonction intégrée.

La manière fonctionnelle, avec un générateur .

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

En action:

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

Ça marche pour moi:

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

Bien sûr, vous devrez peut-être également supprimer les deux points du premier composant, mais le garder permet de réassembler le chemin.

Le rmodificateur marque la chaîne littérale comme "brute"; remarquez que les contre-obliques intégrées ne sont pas doublées.

Le truc à propos de mypath.split("\\")serait mieux exprimé comme mypath.split(os.sep). sepest le séparateur de chemin pour votre plate-forme particulière (par exemple, \pour Windows, /pour Unix, etc.), et la construction Python sait laquelle utiliser. Si vous utilisez sep, votre code sera indépendant de la plate-forme.

re.split () peut aider un peu plus que string.split ()

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

Si vous souhaitez également prendre en charge les chemins Linux et Mac, ajoutez simplement un filtre (Aucun, résultat), afin de supprimer les "" indésirables de split () puisque leurs chemins commencent par "/" ou "//". par exemple '// mount / ...' ou '/ 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']

Vous pouvez récursivement os.path.splitla chaîne

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

Tester cela par rapport à certaines chaînes de chemin et réassembler le chemin avec 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

Le premier élément de la liste peut devoir être traité différemment selon la manière dont vous souhaitez traiter les lettres de lecteur, les chemins UNC et les chemins absolus et relatifs. Changer le dernier [p]pour [os.path.splitdrive(p)]forcer le problème en divisant la lettre de lecteur et la racine du répertoire en un tuple.

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

Edit: J'ai réalisé que cette réponse est très similaire à celle donnée ci-dessus par user1556435 . Je laisse ma réponse car la gestion du composant d'entraînement du chemin est différente.

Tout comme d'autres l'ont expliqué - votre problème provenait de l'utilisation \, qui est un caractère d'échappement dans une chaîne littérale / constante. OTOH, si vous aviez cette chaîne de chemin de fichier d'une autre source (lue à partir du fichier, de la console ou renvoyée par la fonction os) - il n'y aurait pas eu de problème de division sur '\\' ou r '\'.

Et tout comme d'autres l'ont suggéré, si vous voulez utiliser \dans le littéral du programme, vous devez soit le dupliquer, \\soit tout le littéral doit être préfixé par r, comme ça r'lite\ral'ou r"lite\ral"pour éviter que l'analyseur ne convertisse cela \etr en caractère CR (retour chariot).

Il existe cependant un autre moyen: n'utilisez simplement pas de \noms de chemin de barre oblique inverse dans votre code! Depuis le siècle dernier, Windows reconnaît et fonctionne très bien avec les chemins d'accès qui utilisent la barre oblique comme séparateur de répertoire /! Peu de gens le savent, mais cela fonctionne:

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

Cela permettra à votre code de fonctionner sous Unix, Windows et Mac ... car ils l'utilisent tous /comme séparateur de répertoire ... même si vous ne voulez pas utiliser les constantes prédéfinies du moduleos .

Supposons que vous ayez un fichier filedata.txtavec du contenu:

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

Vous pouvez lire et diviser les chemins de fichiers:

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

J'utilise ce qui suit car puisqu'il utilise la fonction os.path.basename, il n'ajoute aucune barre oblique à la liste renvoyée. Il fonctionne également avec les barres obliques de n'importe quelle plate-forme: c'est-à-dire \\ de fenêtre ou / d'Unix. Et de plus, il n'ajoute pas le \\\\ que Windows utilise pour les chemins du serveur :)

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

Donc pour '\\\\ server \\ folder1 \\ folder2 \\ folder3 \\ folder4'

vous obtenez

['serveur', 'dossier1', 'dossier2', 'dossier3', 'dossier4']

Je ne suis pas vraiment sûr que cela réponde entièrement à la question, mais je me suis amusé à écrire cette petite fonction qui garde une pile, s'en tient aux manipulations basées sur os.path et renvoie la liste / pile d'éléments.

  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

La ligne de code ci-dessous peut gérer:

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

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

Un récursif pour le plaisir.

Pas la réponse la plus élégante, mais devrait fonctionner partout:

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]

utilisation ntpath.split()