Como dividir um caminho dos em seus componentes em Python

Eu tenho uma variável de seqüência de caracteres que representa um caminho dos, por exemplo:

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

Eu quero dividir esta string em:

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

Eu tentei usar split()e, replace()mas eles apenas processam a primeira barra invertida ou inserem números hexadecimais na string.

Eu preciso converter essa variável de string em uma string bruta de alguma forma, para que eu possa analisá-la.

Qual é a melhor forma de fazer isso?

Devo acrescentar também que o conteúdo do varcaminho que estou tentando analisar é realmente o valor de retorno de uma consulta de linha de comando. Não são os dados do caminho que eu me gero. Ele é armazenado em um arquivo e a ferramenta de linha de comando não vai escapar das barras invertidas.

Já fui mordido várias vezes por pessoas que escreviam suas próprias funções de mexer no caminho e erravam. Espaços, barras, barras invertidas, dois pontos - as possibilidades de confusão não são infinitas, mas os erros são facilmente cometidos de qualquer maneira. Portanto, sou um defensor do uso os.pathe recomendo-o nessa base.

(No entanto, o caminho para a virtude não é o mais fácil de seguir, e muitas pessoas, ao descobrirem isso, são tentadas a seguir um caminho escorregadio direto para a condenação. Elas não perceberão até que um dia tudo desmoronar, e elas - ou , mais provavelmente, outra pessoa - precisa descobrir por que tudo deu errado, e alguém criou um nome de arquivo que mistura barras e barras invertidas - e algumas pessoas sugerem que a resposta é "não fazer isso". Com exceção de quem misturou barras e barras invertidas - você pode ser elas, se quiser.)

Você pode obter a unidade e o caminho + arquivo assim:

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

Obtenha o caminho e o arquivo:

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

Obter nomes de pastas individuais não é especialmente conveniente, mas é o tipo de desconforto mediano honesto que aumenta o prazer de encontrar algo que realmente funciona bem mais tarde:

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

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

        break

folders.reverse()

(Isso aparece "\"no início de foldersse o caminho era originalmente absoluto. Você pode perder um pouco de código se não quiser.)

eu faria

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

Primeiro normalize a sequência do caminho em uma sequência adequada para o sistema operacional. Em seguida, os.sepdeve ser seguro usá-lo como um delimitador na divisão da função de sequência.

Você pode simplesmente usar a abordagem mais Pythonic (IMHO):

import os

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

O que lhe dará:

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

A dica aqui é usar em os.sepvez de '\\'ou '/', pois isso o torna independente do sistema.

Para remover dois pontos da letra da unidade (embora eu não veja nenhuma razão para fazer isso), você pode escrever:

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

No Python> = 3.4, isso se tornou muito mais simples. Agora você pode usar pathlib.Path.partspara obter todas as partes de um caminho.

Exemplo:

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

Em uma instalação do Python 3 no Windows, isso pressupõe que você esteja trabalhando com caminhos do Windows e, no * nix, assumirá que você está trabalhando com caminhos do posix. Isso geralmente é o que você deseja, mas se não for, pode usar as classes pathlib.PurePosixPathou pathlib.PureWindowsPathconforme necessário:

>>> 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: Há também um backport para python 2 disponível: pathlib2

O problema aqui começa com como você está criando a string em primeiro lugar.

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

Feito desta forma, Python está tentando caso especial estes: \s, \m, \f, e \T. No seu caso, \festá sendo tratado como um avanço de página (0x0C) enquanto as outras barras invertidas são tratadas corretamente. O que você precisa fazer é um destes:

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

Depois de dividir um desses, você obterá o resultado desejado.

Para uma solução um pouco mais concisa, considere o seguinte:

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

Na verdade, não posso contribuir com uma resposta real para essa (como eu vim aqui esperando encontrar uma), mas para mim o número de abordagens diferentes e todas as advertências mencionadas é o indicador mais seguro de que o módulo os.path do Python precisa desesperadamente disso. como uma função interna.

A maneira funcional, com um gerador .

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

Em ação:

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

Funciona para mim:

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

Claro, talvez você precise remover o cólon do primeiro componente, mas mantê-lo possibilita a remontagem do caminho.

O rmodificador marca a string literal como "bruta"; observe como as barras invertidas incorporadas não são duplicadas.

O material sobre about mypath.split("\\")seria melhor expresso como mypath.split(os.sep). sepé o separador de caminho para sua plataforma específica (por exemplo, \para Windows, /Unix etc.), e a compilação Python sabe qual usar. Se você usar sep, seu código será independente de plataforma.

re.split () pode ajudar um pouco mais do que string.split ()

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

Se você também deseja oferecer suporte a caminhos Linux e Mac, basta adicionar filtro (Nenhum, resultado), para remover os '' indesejados da divisão (), pois os caminhos começam com '/' ou '//'. por exemplo '// 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']

Você pode recursivamente os.path.splita string

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

Testando isso em algumas cadeias de caminho e remontando o caminho com 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

O primeiro elemento da lista pode precisar ser tratado de maneira diferente, dependendo de como você deseja lidar com letras de unidade, caminhos UNC e caminhos absolutos e relativos. Alterar o último [p]para [os.path.splitdrive(p)]força o problema dividindo a letra da unidade e o diretório raiz em uma 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']

Edit: Eu percebi que esta resposta é muito semelhante à dada acima pelo user1556435 . Estou deixando minha resposta, pois a manipulação do componente da unidade do caminho é diferente.

Assim como outros explicaram - o problema foi causado pelo uso \, que é um caractere de escape na string literal / constante. OTOH, se você tivesse a sequência do caminho do arquivo de outra fonte (lida do arquivo, console ou retornada pela função os) - não haveria problemas de divisão em '\\' ou r '\'.

E, assim como outros sugeriram, se você quiser usar \no literal programa, você tem que quer duplicá-lo \\ou todo o literal tem de ser precedido por r, como assim r'lite\ral'ou r"lite\ral"para evitar o analisador converter esse \e rpara CR caracteres (retorno de carro).

Porém, há mais uma maneira - apenas não use \nomes de caminho de barra invertida no seu código! Desde o século passado, o Windows reconhece e funciona bem com nomes de caminho que usam barra como separador de diretório /! De alguma forma, muitas pessoas não sabem disso .. mas funciona:

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

A propósito, isso fará com que seu código funcione no Unix, Windows e Mac ... porque todos eles usam /como separador de diretório ... mesmo que você não queira usar as constantes predefinidas do módulo os.

Vamos supor que você tenha um arquivo filedata.txtcom conteúdo:

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

Você pode ler e dividir os caminhos do arquivo:

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

Eu uso o seguinte, pois, como ele usa a função os.path.basename, ele não adiciona nenhuma barra à lista retornada. Também funciona com as barras de qualquer plataforma: por exemplo, \\ da janela ou / do unix. Além disso, ele não adiciona o \\\\ que o Windows usa para os caminhos do 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

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

você recebe

['servidor', 'pasta1', 'pasta2', 'pasta3', 'pasta4']

Na verdade, não tenho certeza se isso responde totalmente à pergunta, mas me diverti escrevendo essa pequena função que mantém uma pilha, adere às manipulações baseadas no os.path e retorna a lista / pilha de itens.

  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

A linha de código abaixo pode lidar com:

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

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

Um recursivo para a diversão.

Não é a resposta mais elegante, mas deve funcionar em qualquer lugar:

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]

usar ntpath.split()