¿Cómo determinar si una ruta es un subdirectorio de otra?

Question

Me dan una lista de rutas que necesito para verificar los archivos dentro. Por supuesto, si se me proporciona una raíz y un subdirectorio, no es necesario procesar el subdirectorio. Por ejemplo

c:\test // process this 
c:\test\pics // do not process this 
c:\test2 // process this 

¿Cómo puedo saber (multiplataforma) que un camino no es un subdirectorio del otro. Preferentemente, me gustaría que fuera multiplataforma, y ​​no me preocupan los enlaces simbólicos, siempre que no sean cíclicos (en el peor de los casos, termino procesando los datos dos veces).

ACTUALIZACIÓN: aquí está el código que terminé usando, gracias a @FJ

def unique_path_roots(paths): 
    visited = set() 
    paths = list(set(paths)) 

    for path in sorted(paths,key=cmp_to_key(locale.strcoll)): 
     path = normcase(normpath(realpath(path))) 

     head, tail = os.path.split(path) 
     while head and tail: 
      if head in visited: 
       break 
      head, tail = os.path.split(head) 
     else: 
      yield path 
      visited.add(path) 

Answer 1

Me gustaría mantener un conjunto de directorios que ya se ha procesado, y luego para cada nuevo cheque camino para ver si alguno de sus directorios padre ya existen en ese conjunto antes de su procesamiento:

import os.path 

visited = set() 
for path in path_list: 
    head, tail = os.path.split(path) 
    while head and tail: 
     if head in visited: 
      break 
     head, tail = os.path.split(head) 
    else: 
     process(path) 
     visited.add(path) 

Tenga en cuenta que path_list deben ser ordenados de manera que los subdirectorios son siempre después de que sus directorios padre si es que existen.

Answer 2

Rastree los directorios que ya ha procesado (en forma normalizada) y no los procese nuevamente si ya los ha visto. Algo como esto debería funcionar:

from os.path import realpath, normcase, sep 

dirs = [r"C:\test", r"C:\test\pics", r"C:\test2"] 

processed = [] 

for dir in dirs: 
    dir = normcase(realpath(dir)) + sep 
    if not any(dir.startswith(p) for p in processed): 
     processed.append(dir) 
     process(dir)   # your code here 

Answer 3

def is_subdir(path, directory): 
    path = os.path.realpath(path) 
    directory = os.path.realpath(directory) 

    relative = os.path.relpath(path, directory) 

    if relative.startswith(os.pardir): 
     return False 
    else: 
     return True 

Answer 4

fijos y simplificados jgoeders 's versión:

def is_subdir(suspect_child, suspect_parent): 
    suspect_child = os.path.realpath(suspect_child) 
    suspect_parent = os.path.realpath(suspect_parent) 

    relative = os.path.relpath(suspect_child, start=suspect_parent) 

    return not relative.startswith(os.pardir) 

Answer 5

Aquí es una función de utilidad is_subdir me ocurrió.

• Python3.x compatible (trabaja con bytes y str, igualando os.path que también es compatible con ambos).
• Normaliza las rutas de comparación.
  (jerarquía principal y caso a trabajar en ms-windows).
• Evita el uso de os.path.relpath que generará una excepción en ms-windows si las rutas están en unidades diferentes. (C:\foo ->D:\bar)

Código:

def is_subdir(path, directory): 
    """ 
    Returns true if *path* in a subdirectory of *directory*. 
    """ 
    import os 
    from os.path import normpath, normcase, sep 
    path = normpath(normcase(path)) 
    directory = normpath(normcase(directory)) 
    if len(path) > len(directory): 
     sep = sep.encode('ascii') if isinstance(directory, bytes) else sep 
     if path.startswith(directory.rstrip(sep) + sep): 
      return True 
    return False