पायथन में अपने घटकों में एक डॉस पथ को कैसे विभाजित किया जाए

Question

मेरे पास एक स्ट्रिंग चर है जो डॉस मार्ग का प्रतिनिधित्व करता है जैसे:

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

मैं इस स्ट्रिंग में विभाजित करना चाहता हूं:

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

मैं का उपयोग कर की कोशिश की है split()और replace()लेकिन वे या तो केवल स्ट्रिंग में पहले बैकस्लैश या वे हेक्स संख्या डालने की प्रक्रिया।

मुझे किसी भी तरह से इस स्ट्रिंग चर को एक कच्चे स्ट्रिंग में बदलने की आवश्यकता है ताकि मैं इसे पार्स कर सकूं।

ऐसा करने का सबसे अच्छा तरीका क्या है?

मुझे यह भी जोड़ना चाहिए कि जिस सामग्री को varमैं पार्स करने की कोशिश कर रहा हूं, वह वास्तव में कमांड लाइन क्वेरी का रिटर्न मान है। यह पथ डेटा नहीं है जो मैं स्वयं उत्पन्न करता हूं। एक फ़ाइल में संग्रहीत है, और कमांड लाइन उपकरण बैकस्लैश से बचने के लिए नहीं जा रहा है।

Comments

जैसा कि आप इन उत्तरों की समीक्षा करते हैं, याद रखें कि os.path.splitयह आपके लिए काम नहीं कर रहा है क्योंकि आप उस स्ट्रिंग को ठीक से नहीं बचा रहे हैं।

— जेड स्मिथ

आपको स्ट्रिंग से बचने या रॉस्ट्रिंग का उपयोग करने की आवश्यकता है: गलत व्याख्या करने r"d:\stuff\morestuff\furtherdown\THEFILE.txt"जैसी चीजों को रोकने के लिए \s।

— 18

Answer 1

मुझे कई बार लोगों ने अपने रास्ते बनाने के कामों के बोझ से काट लिया है और यह गलत हो रहा है। रिक्त स्थान, स्लैश, बैकस्लैश, कॉलन - भ्रम की संभावनाएं अंतहीन नहीं हैं, लेकिन गलतियों को आसानी से वैसे भी किया जाता है। इसलिए मैं इसके इस्तेमाल के लिए एक स्टिकर हूं os.path, और उस आधार पर इसकी सिफारिश करता हूं ।

(हालांकि, पुण्य का रास्ता सबसे आसानी से नहीं लिया जाता है, और जब यह पता चलता है तो बहुत से लोग सीधे लानत के लिए फिसलन का रास्ता अपनाते हैं। उन्हें तब तक एहसास नहीं होगा जब तक एक दिन सब कुछ टुकड़ों में नहीं हो जाता, और वे - या , अधिक संभावना है, किसी और को - बाहर काम करना पड़ता है कि सब कुछ गलत क्यों हो गया है, और यह पता चला है कि किसी ने एक फाइलनाम बनाया है जो स्लैश और बैकस्लैश को मिलाता है - और कुछ व्यक्ति का सुझाव है कि उत्तर "ऐसा नहीं करना है"। इन लोगों में से कोई भी मत बनो। केवल उन लोगों को छोड़कर, जो स्लैश और बैकस्लैश मिलाते हैं - यदि आप चाहें तो आप उन्हें हो सकते हैं।)

आप इस तरह से ड्राइव और पाथ + फाइल प्राप्त कर सकते हैं:

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

पथ और फ़ाइल प्राप्त करें:

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

व्यक्तिगत फ़ोल्डर नामों को प्राप्त करना विशेष रूप से सुविधाजनक नहीं है, लेकिन यह ईमानदारी से काम करने वाली बेचैनी का प्रकार है जो बाद में कुछ पाने की खुशी को बढ़ाता है जो वास्तव में अच्छा काम करता है:

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

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

        break

folders.reverse()

( यदि पथ मूल रूप से निरपेक्ष था "\", foldersतो यह शुरू होता है । यदि आप ऐसा नहीं चाहते तो आप थोड़ा सा कोड खो सकते हैं।)

Comments

@brone - मैं बैकस्लैश से बचने के बारे में चिंता करने की तुलना में इस समाधान का उपयोग करना पसंद करता हूं। धन्यवाद!

— बीबंड

मुझे गलत साबित होने में खुशी होगी, लेकिन मुझे लगता है कि सुझाव दिया गया समाधान काम नहीं करता है अगर कोई रास्ता जैसे कि इस "C: \ usr \ rs0 \ my0 \111111102.log" का उपयोग किया जाता है (जब तक कि प्रारंभिक इनपुट एक कच्चा स्ट्रिंग नहीं है )?

— शीरीचर्ड

ऐसा लगता है कि यह ठीक से एक पथ को विभाजित नहीं करेगा यदि इसमें केवल OSX में एक निर्देशिका शामिल है जैसे "/ पथ / से / मेरे / फ़ोल्डर /", यह प्राप्त करने के लिए कि आप शुरुआत में इन दो पंक्तियों को जोड़ना चाहते हैं: if path.endswith("/"):और path = path[:-1]।

— केविन लंदन

मैं @Tompa

— jaycode

मैं संग में jaycode : तोम्पा के समाधान है विहित दृष्टिकोण और स्वीकार किए जाते हैं जवाब किया जाना चाहिए था। यह अत्यधिक जटिल, अक्षम, और त्रुटि-प्रवण विकल्प उत्पादन कोड पर मस्टर को पारित करने में विफल रहता है। प्रयास करने का कोई उचित कारण नहीं है ... (और निश्चित रूप से,) पुनरावृत्तियों को अलग-अलग पार्स करने के लिए जब सरल स्ट्रिंग विभाजन कोड की केवल एक पंक्ति के साथ सफल होता है ।

— सेसिल करी

Answer 2

मुझे क्या करना होगा

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

पहले ओएस के लिए एक उचित स्ट्रिंग में पथ स्ट्रिंग को सामान्य करें। तब os.sepस्ट्रिंग फ़ंक्शन विभाजन में सीमांकक के रूप में उपयोग करने के लिए सुरक्षित होना चाहिए।

Comments

एक सही जवाब: यह सामने आया है । विहित समाधान निश्चित रूप से सबसे सरल है। देखो! इसके लिए यह सुरुचिपूर्ण और संकलित है और इसमें कोई अपर्याप्त किनारे के मामले नहीं हैं।

— सेसिल करी

एक-लाइनर के रूप में,os.path.normpath(a_path).split(os.path.sep)

— डैनियल फैरेल

यह पथ = रूट के लिए काम नहीं करता है। उस स्थिति में, path.split का परिणाम ['', ''] है। वास्तव में, सामान्य रूप से यह विभाजन () समाधान खाली-स्ट्रिंग नाम (जिसे उपयुक्त स्लैश द्वारा प्रतिस्थापित किया जा सकता है) के साथ एक बाईं ओर की निर्देशिका देता है। मुख्य समस्या यह है कि एक एकल स्लैश (आगे या पीछे ओएस पर निर्भर करता है) रूट निर्देशिका का नाम है, जबकि पथ में कहीं और यह एक विभाजक है ।

— 2

यह एक lstrip के साथ तो बेहतर काम करेगा? os.path.normpath(path).lstrip(os.path.sep).split(os.path.sep)

— विदर्भ

@ user60561 ऐसा इसलिए है क्योंकि लिनक्स पर, बैकस्लैश फ़ाइलनाम में एक अनुमत चरित्र है, जबकि विंडोज पर एक फॉरवर्ड स्लैश नहीं है। यही कारण है कि विंडोज पर, normpathएक विभाजक के रूप में आगे स्लैश को पहचान लेंगे। लिनक्स पर, normpathबस यह मान लेंगे कि आपके पास एक निर्देशिका है \1\2और इसके अंदर एक फ़ाइल या निर्देशिका है 3।

— वोजिस्लाव स्टोजकोविक

Answer 3

आप बस सबसे पाइथोनिक दृष्टिकोण (IMHO) का उपयोग कर सकते हैं:

import os

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

जो आपको देगा:

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

यहाँ सुराग os.sepइसके बजाय '\\'या का उपयोग करने के लिए है '/', क्योंकि यह इसे स्वतंत्र बनाता है।

ड्राइव लेटर से कोलन हटाने के लिए (हालांकि मुझे कोई कारण नहीं दिखता कि आप ऐसा क्यों करना चाहते हैं), आप लिख सकते हैं:

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

Comments

यह काम करता है some times। अन्य समय (कम से कम खिड़कियों पर) आपको ऐसे रास्ते मिलेंगे जो दिखते हैं folder\folder2\folder3/file.txt। इसका बेहतर पहले पथ (os.path.normpath) को सामान्य करने के लिए और फिर विभाजित करें।

— विक्की

यह जवाब लगभग वहीं था । जैसा कि विक्की का सुझाव है, स्ट्रिंग स्प्लिट मंत्रों को सामान्य-किनारे के मामलों (जैसे, /foo//bar) से पहले पथनामों को सामान्य करने में विफलता । अधिक मजबूत समाधान के लिए टॉमपा का उत्तर देखें ।

— सेसिल करी

Answer 4

पायथन में = = 3.4 यह बहुत सरल हो गया है। अब आप pathlib.Path.partsएक पथ के सभी भागों को प्राप्त करने के लिए उपयोग कर सकते हैं ।

उदाहरण:

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

पायथन 3 के एक विंडोज इंस्टॉलेशन पर यह मान लिया जाएगा कि आप विंडोज रास्तों के साथ काम कर रहे हैं, और * निक्स पर यह मान लेंगे कि आप पॉजिक्स रास्तों के साथ काम कर रहे हैं। यह आमतौर पर आप क्या चाहते हैं, लेकिन अगर यह नहीं है तो आप कक्षाओं का उपयोग कर सकते हैं pathlib.PurePosixPathया pathlib.PureWindowsPathआवश्यकतानुसार:

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

संपादित करें: अजगर 2 के लिए एक बैकपोर्ट भी उपलब्ध है: pathlib2

Comments

पाथ.पार्ट्स वह है जो मैं हमेशा से चाहता हूं, लेकिन मैंने कभी नहीं जाना कि यह आज तक अस्तित्व में है।

— JamEnergy

क्यों यह एक अच्छा देशी अजगर समारोह के चारों ओर लपेटा नहीं गया है?

— एडुआर्डो पिगनैटेली

यह जवाब है!

— नैरिएज

Answer 5

यहां समस्या यह है कि आप पहली बार में स्ट्रिंग कैसे बना रहे हैं।

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

: इस तरह से हो गया, अजगर विशेष मामला इन करने के लिए कोशिश कर रहा है \s, \m, \f, और \T। आपके मामले में, \fएक फॉर्मफीड (0x0C) के रूप में माना जा रहा है , जबकि अन्य बैकस्लैश को सही तरीके से संभाला जाता है। आपको इनमें से क्या करने की आवश्यकता है:

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

एक बार जब आप इनमें से किसी एक को विभाजित करते हैं, तो आपको वह परिणाम मिलेगा जो आप चाहते हैं।

Comments

@W। क्रेग ट्रेडर - धन्यवाद, लेकिन यह पथ एक नहीं है जिसे मैं खुद उत्पन्न करता हूं - यह मेरे पास दूसरे कार्यक्रम से वापस आता है और मुझे इस डेटा को एक चर में संग्रहीत करना होगा। मुझे यकीन नहीं है कि एक चर में संग्रहीत डेटा को "कच्चे पाठ" में कैसे परिवर्तित किया जाए।

— बीबंड जूल

"कच्चे पाठ" जैसी कोई चीज नहीं है ... यह सिर्फ यह है कि आप इसे स्रोत में कैसे दर्शाते हैं। या तो स्ट्रिंग के लिए r "" प्रीपेंड करें, या इसे .replace ('\\', '/') के माध्यम से पास करें

— Marco Mariani

@BeeBand, आप अन्य प्रोग्राम से डेटा कैसे वापस पा रहे हैं? क्या आप इसे एक फ़ाइल, एक पाइप, एक सॉकेट से पढ़ रहे हैं? यदि हां, तो आपको कुछ भी करने की आवश्यकता नहीं है; बैकस्लैश को दोगुना करने या कच्चे तारों का उपयोग करने का एकमात्र कारण स्ट्रिंग स्थिरांक को पायथन कोड में रखना है। दूसरी ओर, यदि दूसरा प्रोग्राम दोगुना-बैकस्लैश उत्पन्न कर रहा है, तो आप अपना पथ विभाजित करने से पहले उसे साफ करना चाहेंगे।

— क्रेग ट्रेडर

@W। क्रेग ट्रेडर - मैं इसे एक फ़ाइल से पढ़ रहा हूं, जो दूसरे प्रोग्राम द्वारा लिखा जाता है। मैं किसी कारण से काम नहीं कर पाया split()या नहीं कर पाया replace()- मुझे हेक्स मान मिलता रहा। आप सही हैं, मुझे लगता है कि मैं कच्चे स्ट्रिंग विचार के साथ गलत पेड़ को भौंक रहा था - मुझे लगता है कि मैं सिर्फ split()गलत तरीके से उपयोग कर रहा था । क्योंकि मैंने इनमें से कुछ समाधानों का उपयोग करने की कोशिश की split()और वे अब मेरे लिए काम करते हैं।

— बीबंड

Answer 6

कुछ अधिक संक्षिप्त समाधान के लिए, निम्नलिखित पर विचार करें:

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

Comments

इस समस्या का यह मेरा पसंदीदा समाधान है। बहुत अच्छा।

— विल मूर

यदि पथ समाप्त होता है तो यह काम नहीं करता है /। इसके अलावा, अगर आपका रास्ता शुरू होता है तो आपको सूची की शुरुआत में एक खाली स्ट्रिंग देता है/

— Sorig

Answer 7

मैं वास्तव में इस एक के लिए एक वास्तविक उत्तर का योगदान नहीं कर सकता (जैसा कि मैं यहां खुद को खोजने की उम्मीद कर रहा हूं), लेकिन मेरे लिए अलग-अलग दृष्टिकोणों और उल्लिखित सभी कैवियट्स की संख्या सबसे महत्वपूर्ण संकेतक है जो पायथन के ओएस.पाथ मॉड्यूल की सख्त जरूरत है एक अंतर्निहित कार्य के रूप में।

Answer 8

एक जनरेटर के साथ कार्यात्मक तरीका ।

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

कार्रवाई में:

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

Answer 9

इससे मेरा काम बनता है:

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

सुनिश्चित करें कि आपको पहले घटक से बृहदान्त्र को हटाने की आवश्यकता हो सकती है, लेकिन इसे रखने से पथ को फिर से इकट्ठा करना संभव हो जाता है।

rसंशोधक के निशान के रूप में "कच्चे" स्ट्रिंग शाब्दिक; ध्यान दें कि कैसे एम्बेडेड बैकस्लैश दोगुना नहीं हैं।

Comments

@unwind - rअपनी स्ट्रिंग के सामने, इसका क्या मतलब है?

— बीबंड जूल

कच्चे तार का मतलब है - यह \ अक्षर से बच जाता है। जब भी आप पथ कर रहे हों, इसका उपयोग करना उपयोगी है।

— वेन वर्नर

@BeeBand: आपको देखभाल करने की आवश्यकता नहीं है; r "" सिर्फ एक चीज है जो कोड के संकलन / पार्सिंग के दौरान मायने रखती है, यह ऐसी चीज नहीं है जो एक बार पार्स होने के बाद स्ट्रिंग की संपत्ति बन जाती है। इसका मतलब सिर्फ यह है कि "यहां एक स्ट्रिंग शाब्दिक है, लेकिन किसी भी बैकस्लैश की व्याख्या नहीं करें क्योंकि बैकस्लैश होने के अलावा कोई अन्य अर्थ नहीं है"।

— खोलना

मुझे लगता है कि यह उल्लेख करना आपके लिए मददगार हो सकता है कि माइनस अच्छी तरह से इसे कठिन कोडिंग के बजाय a.split (os.sep) का उपयोग करके अधिक अस्पष्ट है?

— टिम मैकजिल्टन

मैं समझाने के लिए एक मौका लापता के लिए आप downvote करने के लिए है os.path.splitऔर os.pathsep, उन दोनों पर विचार कहीं अधिक है कि तुम क्या लिखा है की तुलना में पोर्टेबल हैं। यह अब ओपी के लिए कोई मायने नहीं रखता है, लेकिन यह तब होगा जब वह कुछ ऐसा लिख ​​रहा है जिसे प्लेटफार्मों को स्थानांतरित करने की आवश्यकता है।

— जेड स्मिथ

Answer 10

के बारे में सामान mypath.split("\\")बेहतर के रूप में व्यक्त किया जाएगा mypath.split(os.sep)। sepआपके विशेष प्लेटफॉर्म के लिए पथ विभाजक है (जैसे, \विंडोज के लिए, /यूनिक्स के लिए, आदि), और पायथन बिल्ड जानता है कि किसका उपयोग करना है। यदि आप उपयोग करते हैं sep, तो आपका कोड प्लेटफ़ॉर्म एग्नॉस्टिक होगा।

Comments

या os.path.split। आप इसके साथ सावधान रहना चाहते हैं os.pathsep, क्योंकि यह :ओएस एक्स (और os.path.splitठीक से हैंडल /) में पायथन के मेरे संस्करण पर है ।

— जैड स्मिथ

तुम्हारा मतलब है os.sep, नहीं os.pathsep। os.sepडॉक्स में ज्ञान का पालन करें : ध्यान दें कि यह जानना पर्याप्त नहीं है कि पैथनामेस को समाहित करने में सक्षम हो या नहीं - os.path.split () और os.path.join () का उपयोग करें।

— जॉन-एरिक

Answer 11

re.split () थोड़ा और फिर string.split () में मदद कर सकता है

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

यदि आप भी लिनक्स और मैक रास्तों का समर्थन करना चाहते हैं, तो केवल फ़िल्टर (कोई नहीं, परिणाम) जोड़ें, इसलिए यह अवांछित '' को विभाजन से हटा देगा () क्योंकि उनके पथ '/' या '//' से शुरू होते हैं। उदाहरण के लिए '// माउंट / ...' या '/ 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']

Answer 12

आप पुनरावर्ती os.path.splitस्ट्रिंग कर सकते हैं

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

कुछ पथ तारों के खिलाफ यह परीक्षण करना, और पथ को फिर से जोड़ना 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

सूची के पहले तत्व को ड्राइव अक्षरों, यूएनसी पथों और निरपेक्ष और सापेक्ष पथों के साथ आप कैसे व्यवहार करना चाहते हैं, इसके आधार पर अलग तरीके से इलाज करने की आवश्यकता हो सकती है। ड्राइव लेटर और डायरेक्टरी रूट को एक ट्यूपल में विभाजित करके इस मुद्दे [p]को [os.path.splitdrive(p)]बल देने के लिए अंतिम को बदलना ।

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

संपादित करें: मैंने महसूस किया है कि इस सवाल का जवाब बहुत के समान है ऊपर दिए गए है कि द्वारा user1556435 । मैं अपना जवाब छोड़ रहा हूं क्योंकि पथ के ड्राइव घटक की हैंडलिंग अलग है।

Answer 13

जैसे अन्य लोगों ने समझाया - आपकी समस्या का उपयोग करने से उपजी है \, जो स्ट्रिंग शाब्दिक / निरंतर में चरित्र से बच रही है। OTOH, यदि आपके पास एक अन्य स्रोत से फ़ाइल पथ स्ट्रिंग (फ़ाइल से पढ़ा, कंसोल या ओएस फ़ंक्शन द्वारा लौटाया गया है) - '\\' या r '\' पर विभाजन की समस्या नहीं होती।

और जैसे अन्य लोगों ने सुझाव दिया है, यदि आप \प्रोग्राम शाब्दिक में उपयोग करना चाहते हैं, तो आपको इसे डुप्लिकेट करना होगा \\या पूरे शाब्दिक को उपसर्ग करना होगा r, जैसे कि r'lite\ral'या तो r"lite\ral"पार्सर को परिवर्तित करने से बचने के लिए \औरr सीआर (कैरिज रिटर्न) चरित्र के लिए।

हालांकि एक और तरीका है - बस \अपने कोड में बैकस्लैश पाथनाम का उपयोग न करें ! पिछली शताब्दी के बाद से विंडोज पहचानता है और ठीक से काम करता है, जो कि मार्ग विभाजक के रूप में फॉरवर्ड स्लैश का उपयोग करता है /! किसी तरह बहुत से लोग नहीं जानते कि .. लेकिन यह काम करता है:

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

इस तरह से यह आपके कोड को यूनिक्स, विंडोज और मैक पर काम करेगा ... क्योंकि ये सभी /निर्देशिका विभाजक के रूप में उपयोग करते हैं ... भले ही आप मॉड्यूल के पूर्वनिर्धारित स्थिरांक का उपयोग नहीं करना चाहते हों os।

Comments

दुर्भाग्य से डेटा मुझे एक और प्रोग्राम से वापस किया जा रहा है जिसे मैं अपनी पायथन स्क्रिप्ट से चलाता हूं। मेरे पास '\' या '/' का उपयोग करने का कोई नियंत्रण नहीं है - यह तीसरा पार्टी कार्यक्रम है जो इसे निर्धारित करता है (शायद एक मंच के आधार पर)।

— बीबंड जूल

@BeeBand: आह, तब आपको परीक्षण के दौरान आपके द्वारा अनुभव की गई समस्या नहीं होगी, जब आपने अपने कार्यक्रम में स्ट्रिंग को शाब्दिक रूप में प्रदान किया था। या आप पथ प्राप्त करने के बाद निम्नलिखित दुष्ट हैक कर सकते हैं: var = var.replace('\\','/')- साथ \ बदलें / और आगे की स्लैश के साथ काम करना केवल :)

— Nas Banov

यह वास्तव में एक बुराई हैक है: ओ)

— बीबंड

@BeeBand: यही कारण है कि मैं चेतावनी दी है। जब मैं कहता हूं कि कुछ बुराई है, तो मेरा मतलब यह नहीं है कि इसका उपयोग कभी नहीं किया जाना चाहिए - लेकिन किसी को बहुत जागरूक होना चाहिए कि वे इसका उपयोग क्यों कर रहे हैं और अनपेक्षित परिणामों के बारे में सतर्क हैं। इस मामले में, एक बहुत ही असंभव परिणाम यह है कि यदि यह यूनिक्स फ़ाइल सिस्टम पर फ़ाइल या निर्देशिका नाम (यह वास्तव में कठिन लेकिन संभव है) में उपयोग के साथ उपयोग किया जाता है - तो यह कोड 'टूट जाएगा'

— Nas Banov

Answer 14

मान लें कि आपके पास filedata.txtसामग्री के साथ एक फ़ाइल है:

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

आप फ़ाइल पथ पढ़ और विभाजित कर सकते हैं:

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

Comments

यह वास्तव में काम करता है, धन्यवाद! लेकिन मैंने ब्रोन के समाधान को चुना क्योंकि मैं बैकस्लैश से बचने के बारे में चिंता नहीं करना पसंद करता हूं।

— बीबंड

पायथोनिक नहीं है क्योंकि यह फाइलसिस्टम आश्रित है।

— जेबी

Answer 15

मैं निम्नलिखित का उपयोग करता हूं क्योंकि यह os.path.basename फ़ंक्शन का उपयोग करता है यह लौटी सूची में कोई स्लैश नहीं जोड़ता है। यह किसी भी प्लेटफ़ॉर्म के स्लैश के साथ भी काम करता है: यानी विंडो का \\ या यूनिक्स का /। और इसके अलावा, यह \\\\ कि सर्वर पथ के लिए विंडोज़ का उपयोग नहीं करता है :)

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

तो '\\\\ server \\ folder1 \\ folder2 \\ folder3 \\ folder4' के लिए

आपको मिला

[ 'सर्वर', 'फ़ोल्डर 1', 'folder2', 'folder3', 'folder4']

Comments

यह अपरिवर्तनीय का पालन नहीं करता है जो आपके परिणाम को os.path.join()मूल स्ट्रिंग को वापस करना चाहिए। मैं कहूंगा कि आपके उदाहरण इनपुट के लिए सही आउटपुट है [r'\\','server','folder1','folder2','folder3','folder4']। यानी क्या os.path.split()करता है

— जॉन-एरिक

Answer 16

मुझे वास्तव में यकीन नहीं है कि यह पूरी तरह से सवाल का जवाब देता है, लेकिन मेरे पास इस छोटे से कार्य को लिखने का एक मजेदार समय था जो एक स्टैक रखता है, ऑस्प-आधारित जोड़तोड़ से चिपक जाता है, और आइटमों की सूची / स्टैक को वापस करता है।

  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

Answer 17

कोड की नीचे की रेखा संभाल सकती है:

1. सी: / path / पथ
2. सी: // पथ // पथ
3. C: \ पथ \ पथ
4. C: \ पथ \ पथ

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

Answer 18

मस्ती के लिए एक पुनरावर्ती।

सबसे सुंदर जवाब नहीं, लेकिन हर जगह काम करना चाहिए:

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]

Comments

वास्तव में, क्षमा करें। सवाल को ध्यान से पढ़ना चाहिए था ... एक 'डॉस' का रास्ता।

— डुगनु

Answer 19

उपयोग ntpath.split()

Comments

जब मैं os.path.split () का उपयोग मैं मिलता है, ( d:\\stuff, morestuff\x0curtherdown\thefile.mux)

— BeeBand

जैसा कि BeeBand ने बताया, os.path.split () वास्तव में वांछित काम नहीं करता है।

— खोलना

क्षमा करें, मुझे सिर्फ एहसास हुआ कि os.path केवल आपके ओएस पर निर्भर करता है। ntpath डॉस रास्तों को पार्स करेगा।

— deft_code

ntpath के साथ भी मुझे अभी भी मिल रहा हैd:\\stuff, morestuff\x0curtherdown\thefile.mux

— BeeBand

@BeeBand: अपने स्ट्रिंग से बचने के साथ आपके मुद्दे। '\x0c'फार्म फ़ीड चरित्र है। फ़ॉर्म फ़ीड वर्ण बनाने का तरीका '\ f' है। यदि आप वास्तव में शाब्दिक स्ट्रिंग '\ f' चाहते हैं तो आपके पास दो विकल्प हैं: '\\f'या r'\f'।

— deft_code