Cara membagi path dos menjadi komponen-komponennya dengan Python

Saya memiliki variabel string yang mewakili path dos, misalnya:

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

Saya ingin membagi string ini menjadi:

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

Saya telah mencoba menggunakan split()dan replace()tetapi mereka hanya memproses backslash pertama atau mereka memasukkan angka hex ke dalam string.

Saya perlu mengubah variabel string ini menjadi string mentah entah bagaimana sehingga saya dapat menguraikannya.

Apa cara terbaik untuk melakukan ini?

Saya juga harus menambahkan bahwa isi varyaitu jalan yang saya coba uraikan, sebenarnya adalah nilai balik dari permintaan baris perintah. Bukan jalur data yang saya hasilkan sendiri. Ini disimpan dalam file, dan alat baris perintah tidak akan lepas dari garis miring terbalik.

Saya telah digigit banyak kali oleh orang-orang menulis fungsi mengutak-atik jalur mereka sendiri dan salah. Ruang, garis miring, garis miring terbalik, titik dua - kemungkinan kebingungan tidak terbatas, tetapi kesalahan tetap mudah dilakukan. Jadi saya ngotot untuk penggunaan os.path, dan merekomendasikannya atas dasar itu.

(Namun, jalan menuju kebajikan bukanlah yang paling mudah diambil, dan banyak orang ketika menemukan ini tergoda untuk mengambil jalan yang licin langsung ke kutukan. Mereka tidak akan menyadari sampai suatu hari semuanya hancur berkeping-keping, dan mereka - atau , lebih mungkin, orang lain - harus mencari tahu mengapa semuanya salah, dan ternyata seseorang membuat nama file yang mencampuradukkan garis miring dan garis miring terbalik - dan beberapa orang menyarankan bahwa jawabannya adalah "tidak melakukan itu". "Jangan menjadi salah satu dari orang-orang ini. Kecuali untuk orang yang mencampuradukkan garis miring dan garis miring terbalik - Anda bisa menjadi mereka jika Anda mau.)

Anda bisa mendapatkan drive dan path + file seperti ini:

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

Dapatkan path dan file:

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

Mendapatkan nama-nama folder individual tidak terlalu nyaman, tetapi itu adalah jenis ketidaknyamanan lumayan menengah yang mempertinggi kesenangan kemudian menemukan sesuatu yang benar-benar berfungsi dengan baik:

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

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

        break

folders.reverse()

(Ini muncul "\"di awal foldersjika path awalnya absolut. Anda bisa kehilangan sedikit kode jika Anda tidak menginginkannya.)

Saya akan lakukan

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

Pertama menormalkan string path menjadi string yang tepat untuk OS. Maka os.sepharus aman untuk digunakan sebagai pembatas dalam fungsi string split.

Anda cukup menggunakan pendekatan Pythonic (IMHO) yang paling:

import os

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

Yang akan memberi Anda:

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

Petunjuk di sini adalah untuk menggunakan os.sepalih-alih '\\'atau '/', karena ini membuatnya sistem independen.

Untuk menghapus titik dua dari huruf drive (walaupun saya tidak melihat alasan mengapa Anda ingin melakukan itu), Anda dapat menulis:

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

Dalam Python> = 3,4 ini menjadi jauh lebih sederhana. Anda sekarang dapat menggunakan pathlib.Path.partsuntuk mendapatkan semua bagian dari jalan.

Contoh:

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

Pada instalasi Windows dari Python 3 ini akan menganggap bahwa Anda bekerja dengan jalur Windows, dan pada * nix itu akan menganggap bahwa Anda bekerja dengan jalur posix. Ini biasanya yang Anda inginkan, tetapi jika tidak, Anda bisa menggunakan kelas pathlib.PurePosixPathatau pathlib.PureWindowsPathsesuai kebutuhan:

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

Sunting: Ada juga backport ke python 2 yang tersedia: pathlib2

Masalahnya di sini dimulai dengan bagaimana Anda membuat string di tempat pertama.

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

Dilakukan dengan cara ini, Python sedang mencoba untuk kasus khusus ini: \s, \m, \f, dan \T. Dalam kasus Anda, \fsedang diperlakukan sebagai formfeed (0x0C) sementara backslash lainnya ditangani dengan benar. Yang perlu Anda lakukan adalah salah satunya:

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

Kemudian setelah Anda membagi salah satu dari ini, Anda akan mendapatkan hasil yang Anda inginkan.

Untuk solusi yang lebih ringkas, pertimbangkan hal berikut:

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

Saya tidak bisa benar-benar menyumbangkan jawaban nyata untuk yang ini (karena saya datang ke sini berharap untuk menemukan sendiri), tetapi bagi saya jumlah pendekatan yang berbeda dan semua peringatan yang disebutkan adalah indikator paling pasti bahwa modul os.path Python sangat membutuhkan ini sebagai fungsi bawaan.

Cara fungsional, dengan generator .

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

Beraksi:

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

Ini bekerja untuk saya:

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

Tentu Anda mungkin perlu juga menghapus usus besar dari komponen pertama, tetapi menjaganya agar tetap memungkinkan untuk merakit kembali jalan.

The rtanda pengubah string literal sebagai "mentah"; perhatikan bagaimana backslash tertanam tidak digandakan.

Hal-hal tentang mypath.split("\\")akan lebih baik dinyatakan sebagai mypath.split(os.sep). sepadalah pemisah jalur untuk platform khusus Anda (misalnya, \untuk Windows, /untuk Unix, dll.), dan bangunan Python tahu mana yang akan digunakan. Jika Anda menggunakan sep, maka kode Anda akan menjadi platform agnostik.

re.split () dapat membantu sedikit lebih banyak daripada string.split ()

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

Jika Anda juga ingin mendukung jalur Linux dan Mac, cukup tambahkan filter (Tidak ada, hasil), sehingga akan menghapus '' yang tidak diinginkan dari split () karena jalurnya dimulai dengan '/' atau '//'. misalnya '// mount / ...' atau '/ 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']

Anda dapat secara rekursif os.path.splitstring

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

Menguji ini terhadap beberapa string path, dan memasang kembali path dengan 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

Elemen pertama dari daftar mungkin perlu diperlakukan berbeda tergantung pada bagaimana Anda ingin berurusan dengan huruf drive, jalur UNC dan jalur absolut dan relatif. Mengubah yang terakhir [p]untuk [os.path.splitdrive(p)]memaksa masalah dengan memecah huruf drive dan direktori root menjadi tuple.

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

Sunting: Saya menyadari bahwa jawaban ini sangat mirip dengan yang diberikan di atas oleh user1556435 . Saya meninggalkan jawaban saya karena penanganan komponen drive jalur berbeda.

Seperti yang dijelaskan orang lain - masalah Anda berasal dari penggunaan \, yaitu karakter pelarian dalam string literal / konstan. OTOH, jika Anda memiliki string path file dari sumber lain (baca dari file, konsol atau dikembalikan dengan fungsi os) - tidak akan ada masalah pemisahan pada '\\' atau r '\'.

Dan seperti yang disarankan orang lain, jika Anda ingin menggunakannya \dalam program literal, Anda harus menduplikasinya \\atau seluruh literal harus diawali dengan r, seperti demikian r'lite\ral'atau r"lite\ral"untuk menghindari parser mengonversi itu \danr ke karakter CR (carriage return).

Ada satu cara lagi - jangan gunakan backslash \pathnames dalam kode Anda! Sejak abad terakhir Windows mengenali dan bekerja dengan baik dengan nama path yang menggunakan forward slash sebagai pemisah direktori /! Entah bagaimana tidak banyak orang tahu itu .. tetapi ia bekerja:

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

Ngomong-ngomong, kode Anda berfungsi di Unix, Windows, dan Mac ... karena semuanya digunakan /sebagai pemisah direktori ... bahkan jika Anda tidak ingin menggunakan konstanta yang sudah ditentukan sebelumnya dari modul os.

Anggap Anda memiliki file filedata.txtdengan konten:

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

Anda dapat membaca dan membagi jalur file:

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

Saya menggunakan berikut ini karena menggunakan fungsi os.path.basename itu tidak menambahkan garis miring ke daftar yang dikembalikan. Ini juga berfungsi dengan garis miring platform apa pun: yaitu jendela \ atau \ /. Dan lebih jauh lagi, ini tidak menambahkan Windows yang digunakan untuk jalur server :)

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

Jadi untuk '\\ server \\ folder1 \\ folder2 \\ folder3 \\ folder4'

Anda mendapatkan

['server', 'folder1', 'folder2', 'folder3', 'folder4']

Saya tidak benar-benar yakin apakah ini sepenuhnya menjawab pertanyaan, tetapi saya bersenang-senang menulis fungsi kecil ini yang menyimpan setumpuk, menempel pada manipulasi berbasis os.path, dan mengembalikan daftar / tumpukan item.

  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

Baris kode di bawah ini dapat menangani:

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

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

Satu rekursif untuk bersenang-senang.

Bukan jawaban yang paling elegan, tetapi harus bekerja di mana saja:

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]

menggunakan ntpath.split()