Cómo dividir una ruta de dos en sus componentes en Python

Tengo una variable de cadena que representa una ruta de dos por ejemplo:

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

Quiero dividir esta cadena en:

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

He intentado usar split()y replace()pero solo procesan la primera barra diagonal inversa o insertan números hexadecimales en la cadena.

Necesito convertir esta variable de cadena en una cadena sin procesar de alguna manera para poder analizarla.

¿Cuál es la mejor manera de hacer esto?

También debo agregar que el contenido de, vares decir, la ruta que estoy tratando de analizar, es en realidad el valor de retorno de una consulta de línea de comando. No son datos de ruta los que yo mismo genero. Está almacenado en un archivo, y la herramienta de línea de comando no va a escapar de las barras diagonales inversas.

He sido mordido muchas veces por personas que escriben sus propias funciones de violín y se equivocan. Espacios, barras, barras invertidas, dos puntos: las posibilidades de confusión no son infinitas, pero de todos modos los errores se cometen fácilmente. Por lo tanto, soy muy exigente con el uso os.pathy lo recomiendo sobre esa base.

(Sin embargo, el camino hacia la virtud no es el más fácil de tomar, y muchas personas al encontrar esto se sienten tentadas a tomar un camino resbaladizo directo a la condenación. No se darán cuenta hasta que un día todo se haga pedazos, y ellos ... o , lo más probable es que alguien más tenga que averiguar por qué todo salió mal y resulta que alguien creó un nombre de archivo que mezcla barras y barras diagonales inversas, y alguien sugiere que la respuesta es "no hacer eso". t sea cualquiera de estas personas. Excepto por el que mezcló barras y barras invertidas, podrían ser ellas si lo desean).

Puede obtener la unidad y la ruta + archivo de esta manera:

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

Obtenga la ruta y el archivo:

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

Obtener los nombres de las carpetas individuales no es especialmente conveniente, pero es el tipo de incomodidad honesta que aumenta el placer de encontrar algo que realmente funciona bien:

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

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

        break

folders.reverse()

(Aparece un "\"al comienzo folderssi la ruta era originalmente absoluta. Podría perder un poco de código si no lo deseara).

yo lo haría

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

Primero normalice la cadena de ruta en una cadena adecuada para el sistema operativo. Entonces os.sepdebe ser seguro de usar como delimitador en la división de la función de cadena.

Simplemente puede usar el enfoque más pitónico (en mi humilde opinión):

import os

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

Lo que te dará:

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

La clave aquí es usar en os.seplugar de '\\'o '/', ya que esto lo hace independiente del sistema.

Para eliminar los dos puntos de la letra de la unidad (aunque no veo ninguna razón por la que quiera hacer eso), puede escribir:

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

En Python> = 3.4 esto se ha vuelto mucho más simple. Ahora puede usar pathlib.Path.partspara obtener todas las partes de una ruta.

Ejemplo:

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

En una instalación de Windows de Python 3, esto supondrá que está trabajando con rutas de Windows, y en * nix asumirá que está trabajando con rutas posix. Esto suele ser lo que desea, pero si no es así, puede usar las clases pathlib.PurePosixPatho pathlib.PureWindowsPathsegún sea necesario:

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

Editar: También hay un backport para python 2 disponible: pathlib2

El problema aquí comienza con cómo estás creando la cadena en primer lugar.

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

Hecho de esta manera, Python está tratando de caso especial siguientes: \s, \m, \f, y \T. En su caso, \fse trata como un avance de página (0x0C) mientras que las demás barras invertidas se manejan correctamente. Lo que debe hacer es uno de estos:

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

Luego, una vez que separe cualquiera de estos, obtendrá el resultado que desea.

Para una solución algo más concisa, considere lo siguiente:

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

En realidad, no puedo aportar una respuesta real a esta (ya que vine aquí con la esperanza de encontrarla yo mismo), pero para mí la cantidad de enfoques diferentes y todas las advertencias mencionadas es el indicador más seguro de que el módulo os.path de Python necesita desesperadamente esto como una función incorporada.

La forma funcional, con un generador .

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

En acción:

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

Esto funciona para mi:

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

Claro que es posible que también necesite quitar el colon del primer componente, pero mantenerlo hace posible volver a ensamblar la ruta.

El rmodificador marca el literal de cadena como "sin procesar"; observe cómo las barras invertidas incrustadas no se duplican.

Las cosas acerca de sobre mypath.split("\\")se expresarían mejor como mypath.split(os.sep). sepes el separador de ruta para su plataforma particular (por ejemplo, \para Windows, /para Unix, etc.), y la compilación de Python sabe cuál usar. Si lo usa sep, entonces su código será independiente de la plataforma.

re.split () puede ayudar un poco más que string.split ()

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

Si también desea admitir rutas de Linux y Mac, simplemente agregue el filtro (Ninguno, resultado), para que elimine el '' no deseado de la división () ya que sus rutas comienzan con '/' o '//'. por ejemplo '// 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']

Puedes recursivamente os.path.splitla cadena

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

Probar esto contra algunas cadenas de ruta y volver a montar la ruta 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

Es posible que el primer elemento de la lista deba tratarse de manera diferente según cómo desee tratar las letras de unidad, las rutas UNC y las rutas absolutas y relativas. Cambiar el último [p]a [os.path.splitdrive(p)]fuerza el problema dividiendo la letra de unidad y la raíz del directorio en 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']

Editar: me he dado cuenta de que esta respuesta es muy similar a la dada anteriormente por el usuario1556435 . Dejo mi respuesta, ya que el manejo del componente de unidad de la ruta es diferente.

Al igual que otros explicaron: su problema surgió del uso \, que es el carácter de escape en cadena literal / constante. OTOH, si tuviera esa cadena de ruta de archivo de otra fuente (leída desde un archivo, consola o devuelta por la función os), no habría habido problemas para dividirse en '\\' o r '\'.

Y al igual que otros sugirieron, si desea usar \en el literal del programa, debe duplicarlo \\o todo el literal debe tener el prefijo r, así r'lite\ral'o r"lite\ral"para evitar que el analizador convierta eso \y el carácter rCR (retorno de carro).

Sin embargo, hay una forma más: ¡simplemente no use \nombres de ruta de barra invertida en su código! Desde el siglo pasado, Windows reconoce y funciona bien con nombres de ruta que usan barra diagonal como separador de directorios /. De alguna manera, no mucha gente lo sabe ... pero funciona:

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

Por cierto, esto hará que su código funcione en Unix, Windows y Mac ... porque todos ellos se usan /como separador de directorios ... incluso si no desea usar las constantes predefinidas del módulo os.

Supongamos que tiene un archivo filedata.txtcon contenido:

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

Puede leer y dividir las rutas de archivo:

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

Uso lo siguiente, ya que usa la función os.path.basename, no agrega barras a la lista devuelta. También funciona con barras inclinadas de cualquier plataforma: es decir, windows \ \ o unix's /. Y además, no agrega el \\\\ que Windows usa para las rutas del servidor :)

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

Entonces, para '\\\\ server \\ folder1 \\ folder2 \\ folder3 \\ folder4'

usted obtiene

['servidor', 'carpeta1', 'carpeta2', 'carpeta3', 'carpeta4']

No estoy seguro de si esto responde completamente a la pregunta, pero me divertí mucho escribiendo esta pequeña función que mantiene una pila, se adhiere a las manipulaciones basadas en os.path y devuelve la lista / pila de elementos.

  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

Debajo de la línea de código puede manejar:

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

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

Uno recursivo para la diversión.

No es la respuesta más elegante, pero debería funcionar en todas partes:

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]

utilizar ntpath.split()