Dos yolu Python'daki bileşenlerine nasıl bölünür

Bir dos yolu temsil eden bir dize değişkeni örneğin:

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

Bu dize bölmek istiyorum:

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

Kullanmayı denedim split()ve replace()sadece ilk ters eğik çizgiyi işliyorlar veya dizeye onaltılık sayılar ekliyorlar.

Ayrıştırmak için bir şekilde bu dize değişkeni ham bir dizeye dönüştürmek gerekiyor.

Bunu yapmanın en iyi yolu nedir?

Ayrıca varayrıştırmaya çalıştığım yolun içeriği aslında bir komut satırı sorgusunun dönüş değeri olduğunu eklemeliyim . Kendi oluşturduğum yol verisi değil. Bir dosyada saklanır ve komut satırı aracı ters eğik çizgilerden kaçmayacaktır.

Kendi yolunu kuran ve yanlış anlayan insanlar tarafından birçok kez ısırıldım. Alanlar, eğik çizgiler, ters eğik çizgiler, iki nokta üst üste - karışıklık olasılıkları sonsuz değildir, ancak yine de hatalar kolayca yapılır. Bu yüzden kullanımı için bir çöpçüyüm os.pathve bu temelde tavsiye ederim.

(Ancak, erdemin yolu en kolay alınan yol değildir ve bunu bulurken birçok insan doğrudan lanetlemeye kaygan bir yol izlemeye caziptir. Bir güne kadar her şey parçalanana kadar fark etmezler ve , büyük olasılıkla, başka biri - neden her şeyin yanlış gittiğini bulmalı ve birisi eğik çizgileri ve ters eğik çizgileri karıştıran bir dosya adı yaptı - ve bazı kişi cevabın "bunu yapmamak" olduğunu öne sürüyor. Bu insanlardan herhangi biri olmayın. Eğik çizgileri ve ters eğik çizgileri karıştıranlar hariç - isterseniz onlar olabilirsiniz.)

Sürücü ve yol + dosyasını şu şekilde alabilirsiniz:

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

Yolu ve dosyayı alın:

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

Bireysel klasör adlarını almak özellikle uygun değildir, ancak daha sonra gerçekten iyi çalışan bir şey bulma zevkini artıran dürüst orta halli rahatsızlıktır:

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

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

        break

folders.reverse()

( Yol "\"başlangıçta mutlaksa başlangıcında bir belirir folders. Bunu istemediyseniz biraz kod kaybedebilirsiniz.)

yapardım

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

İlk olarak yol dizesini işletim sistemi için uygun bir dizeye normalleştirin. O zaman os.sepstring fonksiyonunda bir sınırlayıcı olarak kullanmak güvenli olmalıdır.

En Pythonic yaklaşımını (IMHO) kullanabilirsiniz:

import os

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

Hangi size verecek:

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

Buradaki ipucu , sistemi bağımsız kıldığı için veya os.sepyerine kullanmaktır .'\\''/'

Sürücü harfinden iki nokta üst üste işaretini kaldırmak için (bunu neden yapmak istediğinizin herhangi bir nedenini görmeme rağmen), şunu yazabilirsiniz:

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

Python> = 3.4'te bu çok daha basit hale geldi. Artık pathlib.Path.partsbir yolun tüm parçalarını almak için kullanabilirsiniz .

Misal:

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

Python 3'ün Windows kurulumunda bu, Windows yollarıyla çalıştığınızı varsayar ve * nix'de posix yollarıyla çalıştığınızı varsayar. Genellikle istediğiniz budur, ancak değilse sınıfları pathlib.PurePosixPathveya pathlib.PureWindowsPathgerektiği gibi kullanabilirsiniz :

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

Düzenleme: Ayrıca python 2 için bir backport var: pathlib2

Buradaki sorun, dizeyi nasıl oluşturduğunuzla başlar.

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

Bu şekilde yapılması, Python özel durum bu çalışıyor \s, \m, \f, ve \T. Sizin durumunuzda, \fdiğer ters eğik çizgiler doğru şekilde işlenirken form besleme (0x0C) olarak işlem görüyor. Yapmanız gerekenlerden biri:

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

Sonra bunlardan herhangi birini böldüğünüzde, istediğiniz sonucu elde edersiniz.

Biraz daha özlü bir çözüm için aşağıdakileri göz önünde bulundurun:

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

Aslında buna gerçek bir cevap veremem (buraya kendimi bulmayı umarak geldim), ama bana göre farklı yaklaşımların sayısı ve belirtilen tüm uyarılar Python'un os.path modülünün umutsuzca buna ihtiyaç duyduğu en kesin göstergedir. yerleşik bir işlev olarak.

Bir jeneratör ile fonksiyonel yol .

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

Eylemde:

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

Benim için çalışıyor:

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

Tabii ki, kolonu ilk bileşenden çıkarmanız gerekebilir, ancak bunu korumak yolu yeniden birleştirmeyi mümkün kılar.

rDeğiştirici işaretleri "ham" olarak düz dize; gömülü ters eğik çizgilerin nasıl iki katına çıkmadığına dikkat edin.

Hakkında şeyler mypath.split("\\")daha iyi ifade edilecektir mypath.split(os.sep). sepplatformunuz için yol ayırıcıdır (örneğin, \Windows /için, Unix için, vb.) ve Python derlemesi hangisini kullanacağınızı bilir. Eğer kullanırsanız sep, sonra kod platformu agnostik olacaktır.

re.split (), string.split () öğesinden biraz daha fazla yardımcı olabilir

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

Linux ve Mac yollarını da desteklemek istiyorsanız, filtre ekleyin (Yok, sonuç), böylece yolları '/' veya '//' ile başladığı için istenmeyen '' öğesini split () 'den kaldıracaktır. örneğin '// mount / ...' veya '/ 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']

Dizeyi özyinelemeli os.path.splitolarak

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

Bunu bazı yol dizelerine karşı test etmek ve yolu yeniden birleştirmek 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

Listenin ilk öğesine, sürücü harfleriyle, UNC yollarıyla ve mutlak ve göreli yollarla nasıl başa çıkmak istediğinize bağlı olarak farklı davranılması gerekebilir. Geçen değiştirme [p]için [os.path.splitdrive(p)]bölerek kuvvetlerin bir başlığın içine sürücü harfini ve dizin kök out sorunu.

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: Bu cevap yukarıda user1556435 tarafından verilene çok benzer olduğunu fark ettim . Yolun sürücü bileşeninin işlenmesi farklı olduğundan cevabımı bırakıyorum.

Diğerleri açıkladığı gibi - sorununuz \dize değişmez / sabit dize kaçış karakteri kullanmaktan kaynaklandı . OTOH, bu dosya yolu dizesini başka bir kaynaktan alsaydı (dosyadan, konsoldan veya os işleviyle döndürülürse) - '\\' veya r '\' üzerinde bölme sorunu olmazdı.

Kullanmak istediğiniz takdirde Ve diğerleri önerdi tıpkı \programı sabit içinde, bunu çoğaltmak ya zorunda \\veya tüm edebi önek olarak zorundadır rşöyle, r'lite\ral'ya r"lite\ral"böyle dönüştürme ayrıştırıcı önlemek \ve rCR için (satırbaşı) karakterini.

Yine de bir yol daha var - \kodunuzda ters eğik çizgi yol adları kullanmayın ! Geçen yüzyıldan beri Windows, dizin ayırıcı olarak eğik çizgi kullanan yol adlarını tanır ve iyi çalışır /! Bir şekilde pek çok insan bunu bilmiyor .. ama işe yarıyor:

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

Bu arada, kodunuzun Unix, Windows ve Mac üzerinde çalışmasını sağlarsınız ... çünkü /modülün önceden tanımlanmış sabitlerini kullanmak istemeseniz bile hepsi dizin ayırıcı olarak kullanılır os.

filedata.txtİçeriğe sahip bir dosyanız olduğunu varsayalım :

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

Dosya yollarını okuyabilir ve bölebilirsiniz:

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

Aşağıdakileri, os.path.basename işlevini kullandığından, döndürülen listeye eğik çizgi eklemediği için kullanıyorum. Ayrıca herhangi bir platformun eğik çizgileri ile çalışır: örn. Pencerenin \\ veya unix's /. Dahası, pencerelerin sunucu yolları için kullandığı \\\\ ifadesini eklemez :)

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

Yani '\\\\ sunucu \\ klasör1 \\ klasör2 \\ klasör3 \\ klasör4'

anladın

[ 'Sunucu', 'Folder1'ı', 'klasörün2', 'Folder3'ı', 'Klasör4']

Aslında bu soruya tam olarak cevap verip vermediğinden emin değilim, ancak bir yığını tutan, os.path tabanlı manipülasyonlara yapışan ve öğelerin listesini / yığınını döndüren bu küçük işlevi yazarken eğlenceli zaman geçirdim.

  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şağıdaki kod satırı işleyebilir:

1. C: / yol / yolu
2. C: // yolu // yolu
3. C: \ yol \ yol
4. C: \ yol \ yol

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

Eğlence için bir özyinelemeli.

En zarif cevap değil, her yerde çalışmalı:

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]

kullanım ntpath.split()