Wyodrębnij nazwę pliku ze ścieżki, bez względu na format os / path

Jakiej biblioteki Python mogę użyć do wyodrębnienia nazw plików ze ścieżek, bez względu na system operacyjny lub format ścieżki?

Na przykład chciałbym, aby wszystkie te ścieżki mi zwróciły c:

a/b/c/
a/b/c
\a\b\c
\a\b\c\
a\b\c
a/b/../../a/b/c/
a/b/../../a/b/c

Używanie os.path.splitlub, os.path.basenamejak sugerują inni, nie będzie działać we wszystkich przypadkach: jeśli uruchomisz skrypt w systemie Linux i spróbujesz przetworzyć klasyczną ścieżkę w stylu systemu Windows, zakończy się niepowodzeniem.

Ścieżki systemu Windows mogą używać ukośnika odwrotnego lub ukośnika jako separatora ścieżek. Dlatego ntpathmoduł (który jest równoważny os.path podczas uruchamiania w systemie Windows) będzie działał dla wszystkich ⁽¹⁾ ścieżek na wszystkich platformach.

import ntpath
ntpath.basename("a/b/c")

Oczywiście, jeśli plik kończy się ukośnikiem, basename będzie pusty, więc stwórz własną funkcję, aby sobie z tym poradzić:

def path_leaf(path):
    head, tail = ntpath.split(path)
    return tail or ntpath.basename(head)

Weryfikacja:

>>> paths = ['a/b/c/', 'a/b/c', '\\a\\b\\c', '\\a\\b\\c\\', 'a\\b\\c', 
...     'a/b/../../a/b/c/', 'a/b/../../a/b/c']
>>> [path_leaf(path) for path in paths]
['c', 'c', 'c', 'c', 'c', 'c', 'c']

^{(1) Istnieje jedno zastrzeżenie: nazwy plików w systemie Linux mogą zawierać odwrotne ukośniki . Tak więc w systemie Linux r'a/b\c'zawsze odnosi się do pliku b\cw afolderze, podczas gdy w systemie Windows zawsze odnosi się do cpliku w bpodfolderze afolderu. Jeśli więc na ścieżce używane są zarówno ukośniki do przodu, jak i do tyłu, musisz znać powiązaną platformę, aby móc ją poprawnie interpretować. W praktyce zazwyczaj bezpiecznie jest założyć, że jest to ścieżka systemu Windows, ponieważ odwrotne ukośniki są rzadko używane w nazwach plików Linuksa, ale pamiętaj o tym podczas pisania kodu, aby nie stworzyć przypadkowych luk bezpieczeństwa.}

W rzeczywistości istnieje funkcja, która zwraca dokładnie to, czego chcesz

import os
print(os.path.basename(your_path))

os.path.split to funkcja, której szukasz

head, tail = os.path.split("/tmp/d/a.dat")

>>> print(tail)
a.dat
>>> print(head)
/tmp/d

W python 3

>>> from pathlib import Path    
>>> Path("/tmp/d/a.dat").name
'a.dat'

import os
head, tail = os.path.split('path/to/file.exe')

ogon jest tym, czego chcesz, nazwą pliku.

Zobacz docs moduł Pythona os o szczegóły

import os
file_location = '/srv/volume1/data/eds/eds_report.csv'
file_name = os.path.basename(file_location )  #eds_report.csv
location = os.path.dirname(file_location )    #/srv/volume1/data/eds

W twoim przykładzie musisz również usunąć ukośnik z prawej strony, aby zwrócić c:

>>> import os
>>> path = 'a/b/c/'
>>> path = path.rstrip(os.sep) # strip the slash from the right side
>>> os.path.basename(path)
'c'

Drugi poziom:

>>> os.path.filename(os.path.dirname(path))
'b'

aktualizacja: Myślę, że lazyrdostarczyłem prawidłowej odpowiedzi. Mój kod nie będzie działać ze ścieżkami podobnymi do Windowsa w systemach uniksowych i odwrotnie w porównaniu ze ścieżkami podobnymi do Windowsa w systemie Windows.

fname = str("C:\Windows\paint.exe").split('\\')[-1:][0]

to zwróci: paint.exe

zmień wartość sep funkcji split w odniesieniu do ścieżki lub systemu operacyjnego.

Jeśli chcesz automatycznie uzyskać nazwę pliku, możesz to zrobić

import glob

for f in glob.glob('/your/path/*'):
    print(os.path.split(f)[-1])

Jeśli ścieżka do pliku nie kończy się na „/”, a katalogi oddzielone „/”, użyj następującego kodu. Jak wiemy, ścieżka nie kończy się na „/”.

import os
path_str = "/var/www/index.html"
print(os.path.basename(path_str))

Ale w niektórych przypadkach, na przykład adresy URL kończą się na „/”, a następnie użyj następującego kodu

import os
path_str = "/home/some_str/last_str/"
split_path = path_str.rsplit("/",1)
print(os.path.basename(split_path[0]))

ale gdy Twoja ścieżka jest zapisywana jako „\”, co zwykle znajduje się w ścieżkach systemu Windows, możesz użyć następujących kodów

import os
path_str = "c:\\var\www\index.html"
print(os.path.basename(path_str))

import os
path_str = "c:\\home\some_str\last_str\\"
split_path = path_str.rsplit("\\",1)
print(os.path.basename(split_path[0]))

Możesz połączyć obie funkcje w jedną funkcję, sprawdzając typ systemu operacyjnego i zwracając wynik.

Działa to również w systemie Linux i Windows ze standardową biblioteką

paths = ['a/b/c/', 'a/b/c', '\\a\\b\\c', '\\a\\b\\c\\', 'a\\b\\c',
         'a/b/../../a/b/c/', 'a/b/../../a/b/c']

def path_leaf(path):
    return path.strip('/').strip('\\').split('/')[-1].split('\\')[-1]

[path_leaf(path) for path in paths]

Wyniki:

['c', 'c', 'c', 'c', 'c', 'c', 'c']

Oto rozwiązanie tylko do wyrażenia regularnego, które wydaje się działać z każdą ścieżką systemu operacyjnego w dowolnym systemie operacyjnym.

Nie jest potrzebny żaden inny moduł ani wstępne przetwarzanie:

import re

def extract_basename(path):
  """Extracts basename of a given path. Should Work with any OS Path on any OS"""
  basename = re.search(r'[^\\/]+(?=[\\/]?$)', path)
  if basename:
    return basename.group(0)


paths = ['a/b/c/', 'a/b/c', '\\a\\b\\c', '\\a\\b\\c\\', 'a\\b\\c',
         'a/b/../../a/b/c/', 'a/b/../../a/b/c']

print([extract_basename(path) for path in paths])
# ['c', 'c', 'c', 'c', 'c', 'c', 'c']


extra_paths = ['C:\\', 'alone', '/a/space in filename', 'C:\\multi\nline']

print([extract_basename(path) for path in extra_paths])
# ['C:', 'alone', 'space in filename', 'multi\nline']

Aktualizacja:

Jeśli chcesz tylko potencjalną nazwę pliku, jeśli jest obecny (czyli /a/b/to dir i tak jest c:\windows\), zmienić regex: r'[^\\/]+(?![\\/])$'. W przypadku „wyrażenia regularnego zakwestionowanego” zmienia to pozytywne spojrzenie w przód dla jakiegoś ukośnika na negatywne spojrzenie w przód, powodując, że ścieżki, które kończą się tym ukośnikiem, nie zwracają niczego zamiast ostatniego podkatalogu w nazwie ścieżki. Oczywiście nie ma gwarancji, że potencjalna nazwa pliku faktycznie odnosi się do pliku i do tego os.path.is_dir()lub os.path.is_file()będzie musiał zostać zastosowany.

Będzie to pasować w następujący sposób:

/a/b/c/             # nothing, pathname ends with the dir 'c'
c:\windows\         # nothing, pathname ends with the dir 'windows'
c:hello.txt         # matches potential filename 'hello.txt'
~it_s_me/.bashrc    # matches potential filename '.bashrc'
c:\windows\system32 # matches potential filename 'system32', except
                    # that is obviously a dir. os.path.is_dir()
                    # should be used to tell us for sure

Wyrażenie regularne można przetestować tutaj .

Może po prostu moje wszystko w jednym rozwiązaniu bez ważnych nowych (patrz plik tymczasowy do tworzenia plików tymczasowych: D)

import tempfile
abc = tempfile.NamedTemporaryFile(dir='/tmp/')
abc.name
abc.name.replace("/", " ").split()[-1] 

Uzyskiwanie wartości abc.namebędzie ciągiem takim: '/tmp/tmpks5oksk7' Mogę zastąpić /spacją, .replace("/", " ")a następnie wywołać split(). To zwróci listę, a ja otrzymam ostatni element listy[-1]

Nie trzeba importować żadnego modułu.

Nigdy nie widziałem ścieżek podwójnie odwróconych, czy istnieją? Wbudowana funkcja modułu python oskończy się niepowodzeniem. Wszystkie inne działają, również podane przez ciebie zastrzeżenie dotyczące os.path.normpath():

paths = ['a/b/c/', 'a/b/c', '\\a\\b\\c', '\\a\\b\\c\\', 'a\\b\\c', 
...     'a/b/../../a/b/c/', 'a/b/../../a/b/c', 'a/./b/c', 'a\b/c']
for path in paths:
    os.path.basename(os.path.normpath(path))

Separator systemu Windows może znajdować się w nazwie pliku Unix lub ścieżce systemu Windows. Separator uniksowy może istnieć tylko na ścieżce uniksowej. Obecność separatora uniksowego wskazuje ścieżkę inną niż Windows.

Poniższe spowoduje usunięcie (odcięcie końcowego separatora) według separatora specyficznego dla systemu operacyjnego, a następnie podzielenie i zwrócenie najwyższej wartości z prawej strony. To brzydkie, ale proste w oparciu o powyższe założenie. Jeśli założenie jest nieprawidłowe, zaktualizuj, a ja zaktualizuję tę odpowiedź, aby pasowała do bardziej dokładnych warunków.

a.rstrip("\\\\" if a.count("/") == 0 else '/').split("\\\\" if a.count("/") == 0 else '/')[-1]

przykładowy kod:

b = ['a/b/c/','a/b/c','\\a\\b\\c','\\a\\b\\c\\','a\\b\\c','a/b/../../a/b/c/','a/b/../../a/b/c']

for a in b:

    print (a, a.rstrip("\\" if a.count("/") == 0 else '/').split("\\" if a.count("/") == 0 else '/')[-1])

Dla kompletności, oto pathlibrozwiązanie dla Python 3.2+:

>>> from pathlib import PureWindowsPath

>>> paths = ['a/b/c/', 'a/b/c', '\\a\\b\\c', '\\a\\b\\c\\', 'a\\b\\c', 
...          'a/b/../../a/b/c/', 'a/b/../../a/b/c']

>>> [PureWindowsPath(path).name for path in paths]
['c', 'c', 'c', 'c', 'c', 'c', 'c']

Działa to zarówno w systemie Windows, jak i Linux.

Zarówno w Pythonie 2, jak i 3, używając modułu pathlib2 :

import posixpath  # to generate unix paths
from pathlib2 import PurePath, PureWindowsPath, PurePosixPath

def path2unix(path, nojoin=True, fromwinpath=False):
    """From a path given in any format, converts to posix path format
    fromwinpath=True forces the input path to be recognized as a Windows path (useful on Unix machines to unit test Windows paths)"""
    if not path:
        return path
    if fromwinpath:
        pathparts = list(PureWindowsPath(path).parts)
    else:
        pathparts = list(PurePath(path).parts)
    if nojoin:
        return pathparts
    else:
        return posixpath.join(*pathparts)

Stosowanie:

In [9]: path2unix('lala/lolo/haha.dat')
Out[9]: ['lala', 'lolo', 'haha.dat']

In [10]: path2unix(r'C:\lala/lolo/haha.dat')
Out[10]: ['C:\\', 'lala', 'lolo', 'haha.dat']

In [11]: path2unix(r'C:\lala/lolo/haha.dat') # works even with malformatted cases mixing both Windows and Linux path separators
Out[11]: ['C:\\', 'lala', 'lolo', 'haha.dat']

Z twoją walizką testową:

In [12]: testcase = paths = ['a/b/c/', 'a/b/c', '\\a\\b\\c', '\\a\\b\\c\\', 'a\\b\\c',
    ...: ...     'a/b/../../a/b/c/', 'a/b/../../a/b/c']

In [14]: for t in testcase:
    ...:     print(path2unix(t)[-1])
    ...:
    ...:
c
c
c
c
c
c
c

Chodzi tutaj o konwersję wszystkich ścieżek w ujednoliconą wewnętrzną reprezentację pathlib2z różnymi dekoderami w zależności od platformy. Na szczęście pathlib2zawiera ogólny nazwany dekoder, PurePathktóry powinien działać na dowolnej ścieżce. Jeśli to nie zadziała, możesz wymusić rozpoznanie ścieżki systemu Windows za pomocą fromwinpath=True. Spowoduje to podzielenie łańcucha wejściowego na części, ostatni to liść, którego szukasz, stąd path2unix(t)[-1].

Jeśli argument nojoin=False, ścieżka zostanie ponownie połączona, tak że wynik będzie po prostu łańcuchem wejściowym przekonwertowanym na format uniksowy, co może być przydatne do porównania podścieżek na różnych platformach.