Python: obtenha um caminho relativo ao comparar dois caminhos absolutos

Diga, eu tenho dois caminhos absolutos. Preciso verificar se o local referente a um dos caminhos é descendente do outro. Se for verdade, preciso descobrir o caminho relativo do descendente a partir do ancestral. Qual é uma boa maneira de implementar isso em Python? Alguma biblioteca da qual eu possa me beneficiar?

os.path.commonprefix () e os.path.relpath () são seus amigos:

>>> print os.path.commonprefix(['/usr/var/log', '/usr/var/security'])
'/usr/var'
>>> print os.path.commonprefix(['/tmp', '/usr/var'])  # No common prefix: the root is the common prefix
'/'

Assim, você pode testar se o prefixo comum é um dos caminhos, ou seja, se um dos caminhos é um ancestral comum:

paths = […, …, …]
common_prefix = os.path.commonprefix(list_of_paths)
if common_prefix in paths:
    …

Você pode encontrar os caminhos relativos:

relative_paths = [os.path.relpath(path, common_prefix) for path in paths]

Você pode até manipular mais de dois caminhos, com esse método, e testar se todos os caminhos estão todos abaixo de um deles.

PS : dependendo da aparência de seus caminhos, primeiro você deve executar alguma normalização (isso é útil em situações em que não se sabe se elas sempre terminam com '/' ou não, ou se alguns deles são relativos). Funções relevantes incluem os.path.abspath () e os.path.normpath () .

PPS : como Peter Briggs mencionou nos comentários, a abordagem simples descrita acima pode falhar:

>>> os.path.commonprefix(['/usr/var', '/usr/var2/log'])
'/usr/var'

mesmo que não/usr/var seja um prefixo comum dos caminhos. Forçar todos os caminhos a terminarem com '/' antes de chamar resolve esse problema (específico).commonprefix()

PPPS : como o bluenote10 mencionou, a adição de uma barra não resolve o problema geral. Aqui está sua pergunta seguinte: Como contornar a falácia do os.path.commonprefix do Python?

PPPPS : a partir do Python 3.4, temos o pathlib , um módulo que fornece um ambiente de manipulação de caminhos mais saudável . Eu acho que o prefixo comum de um conjunto de caminhos pode ser obtido obtendo todos os prefixos de cada caminho (com PurePath.parents()), fazendo a interseção de todos esses conjuntos pai e selecionando o prefixo comum mais longo.

PPPPPS : Python 3.5 introduziu uma solução adequada para esta pergunta :,os.path.commonpath() que retorna um caminho válido.

os.path.relpath:

Retorne um caminho de arquivo relativo para o caminho do diretório atual ou de um ponto de início opcional.

>>> from os.path import relpath
>>> relpath('/usr/var/log/', '/usr/var')
'log'
>>> relpath('/usr/var/log/', '/usr/var/sad/')
'../log'

Portanto, se o caminho relativo começar com '..'- isso significa que o segundo caminho não é descendente do primeiro caminho.

No Python3 você pode usar PurePath.relative_to:

Python 3.5.1 (default, Jan 22 2016, 08:54:32)
>>> from pathlib import Path

>>> Path('/usr/var/log').relative_to('/usr/var/log/')
PosixPath('.')

>>> Path('/usr/var/log').relative_to('/usr/var/')
PosixPath('log')

>>> Path('/usr/var/log').relative_to('/etc/')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/local/Cellar/python3/3.5.1/Frameworks/Python.framework/Versions/3.5/lib/python3.5/pathlib.py", line 851, in relative_to
    .format(str(self), str(formatted)))
ValueError: '/usr/var/log' does not start with '/etc'

Outra opção é

>>> print os.path.relpath('/usr/var/log/', '/usr/var')
log

Uma descrição da sugestão de jme, usando pathlib, em Python 3.

from pathlib import Path
parent = Path(r'/a/b')
son = Path(r'/a/b/c/d')            
​
if parent in son.parents or parent==son:
    print(son.relative_to(parent)) # returns Path object equivalent to 'c/d'

Pure Python2 sem dep:

def relpath(cwd, path):
    """Create a relative path for path from cwd, if possible"""
    if sys.platform == "win32":
        cwd = cwd.lower()
        path = path.lower()
    _cwd = os.path.abspath(cwd).split(os.path.sep)
    _path = os.path.abspath(path).split(os.path.sep)
    eq_until_pos = None
    for i in xrange(min(len(_cwd), len(_path))):
        if _cwd[i] == _path[i]:
            eq_until_pos = i
        else:
            break
    if eq_until_pos is None:
        return path
    newpath = [".." for i in xrange(len(_cwd[eq_until_pos+1:]))]
    newpath.extend(_path[eq_until_pos+1:])
    return os.path.join(*newpath) if newpath else "."

Edit: Veja a resposta do jme para a melhor maneira com o Python3.

Usando pathlib, você tem a seguinte solução:

Digamos que queremos verificar se soné um descendente de parente ambos são Pathobjetos. Podemos obter uma lista das partes no caminho list(parent.parts). Então, apenas verificamos que o início do filho é igual à lista de segmentos do pai.

>>> lparent = list(parent.parts)
>>> lson = list(son.parts)
>>> if lson[:len(lparent)] == lparent:
>>> ... #parent is a parent of son :)

Se você deseja obter a parte restante, basta fazer

>>> ''.join(lson[len(lparent):])

É uma string, mas é claro que você pode usá-la como construtora de outro objeto Path.