दिलचस्प पोस्ट
प्ले स्टोर पर प्रकाशित ऐप Google मानचित्र एपीआई और फेसबुक एपीआई के साथ संवाद नहीं कर सकता है कास्टिंग सूची <T> – सहानुभूति / भ्रष्टाचार समस्या mysqli: क्या यह एक कथन में कई क्वेरी तैयार कर सकता है? छत्ता आंतरिक तालिकाओं और बाहरी तालिकाओं के बीच अंतर? HTML.ActionLink एक बटन या एक छवि के रूप में, एक लिंक नहीं विशिष्ट आईडी मूल्यों के आधार पर MySQL आदेश सीएसएस का प्रयोग करके आप कैसे आसानी से क्षैतिज एक <div> केंद्र कर सकते हैं? ActiveRecord.find (array_of_ids), आदेश को सुरक्षित रखें मैं कैसे मोंगोडीबी में समकक्ष सम्मिलित हों? "UpdateSourceTrigger = PropertyChanged" एक विंडोज फोन 7 पाठ बॉक्स के लिए बराबर है क्यों दस्तावेज़ डॉक्स को componentDidMount में AJAX करने की सलाह देते हैं, घटक नहीं WillMount? फोनगैप प्लगइन: Base64 स्ट्रिंग को एक पीएनजी छवि को एंड्रॉइड में कन्वर्ट करने के लिए कैसे करें जैक्सन के साथ धारावाहिक ऊर्जा पायथन में सिंटैक्स त्रुटि विसंगति? JQuery के साथ एक शब्द हाइलाइट करें

मैं Python में एक नई लाइन (chomp) को कैसे निकाल सकता / सकती हूं?

पर्ल के chomp फ़ंक्शन के पायथन समतुल्य क्या है, जो स्ट्रिंग के अंतिम वर्ण को हटा देता है यदि यह एक नई पंक्ति है?

वेब के समाधान से एकत्रित समाधान "मैं Python में एक नई लाइन (chomp) को कैसे निकाल सकता / सकती हूं?"

विधि rstrip() कोशिश करें (डॉक्टर पायथन 2 और पायथन 3 देखें )

 >>> 'test string\n'.rstrip() 'test string' 

पायथन की rstrip() विधि हर तरह की rstrip() सफेद स्थान को डिफ़ॉल्ट रूप से स्ट्रिप्स करती है , केवल एक नई लाइन नहीं है, जैसा कि पर्ल rstrip() साथ करता है

 >>> 'test string \n \r\n\n\r \n\n'.rstrip() 'test string' 

केवल नई लाइनों को पट्टी करने के लिए:

 >>> 'test string \n \r\n\n\r \n\n'.rstrip('\n') 'test string \n \r\n\n\r ' 

वहाँ भी तरीकों lstrip() और strip() :

 >>> s = " \n\r\n \n abc def \n\r\n \n " >>> s.strip() 'abc def' >>> s.lstrip() 'abc def \n\r\n \n ' >>> s.rstrip() ' \n\r\n \n abc def' 

और मैं कहूंगा कि नए अक्षरों के बिना बिना लाइन पाने का "अजवायनिक" तरीका अलग-अलग है ()।

 >>> text = "line 1\nline 2\r\nline 3\nline 4" >>> text.splitlines() ['line 1', 'line 2', 'line 3', 'line 4'] 

अंत-लाइन-रेखा (ईओएल) वर्णों को पट्टी करने के लिए वैधानिक तरीका स्ट्रिंग rstrip () विधि का उपयोग करने के लिए किसी भी पीछे \ r या \ n को हटाने का तरीका है मैक, विंडोज, और यूनिक्स ईओएल वर्णों के लिए यहां दिए गए उदाहरण हैं।

 >>> 'Mac EOL\r'.rstrip('\r\n') 'Mac EOL' >>> 'Windows EOL\r\n'.rstrip('\r\n') 'Windows EOL' >>> 'Unix EOL\n'.rstrip('\r\n') 'Unix EOL' 

आरस्ट्रिप के पैरामीटर के रूप में '\ r \ n' का प्रयोग करने का अर्थ है कि यह '\ r' या '\ n' का कोई पीछे वाला संयोजन छीन जाएगा। यही कारण है कि यह ऊपर के सभी तीन मामलों में काम करता है

दुर्लभ मामलों में यह अति सूक्ष्म अंतर है उदाहरण के लिए, मुझे एक बार एक टेक्स्ट फ़ाइल की प्रक्रिया करनी थी जिसमें एचएल 7 संदेश होता था। एचएल 7 मानक को उसके ईओएल चरित्र के रूप में एक अनुगामी '\ r' की आवश्यकता है विंडोज मशीन जिस पर मैं इस संदेश का उपयोग कर रहा था, उसका अपना '\ r \ n' ईओएल चरित्र जोड़ा गया था। इसलिए, प्रत्येक पंक्ति का अंत '\ r \ r \ n' जैसा दिखता है आरस्ट्रिप ('\ r \ n') का उपयोग करके पूरे '\ r \ r \ n' को हटा दिया जाएगा जो कि मैं क्या चाहता था। उस मामले में, मैंने केवल पिछले दो अक्षर को कटा हुआ बजाए।

नोट करें कि पर्ल के chomp फ़ंक्शन के विपरीत, यह स्ट्रिंग के अंत में सभी निर्दिष्ट वर्णों को पट्टी करेगा, न कि केवल एक:

 >>> "Hello\n\n\n".rstrip("\n") "Hello" 

ध्यान दें कि rstrip बिल्कुल पर्ल के chomp () की तरह कार्य नहीं करता है क्योंकि यह स्ट्रिंग को संशोधित नहीं करता है। यही है, पर्ल में:

 $x="a\n"; chomp $x 

$x होने वाला परिणाम "a"

लेकिन पायथन में:

 x="a\n" x.rstrip() 

इसका मतलब यह होगा कि x का मान अभी भी "a\n" । यहां तक ​​कि x=x.rstrip() हमेशा एक ही परिणाम नहीं देता है, क्योंकि यह स्ट्रिंग के अंत से सभी रिक्त स्थान को स्ट्रिप्स करता है, न कि सिर्फ एक ही नई लाइन।

मैं ऐसा कुछ इस्तेमाल कर सकता हूं:

 import os s = s.rstrip(os.linesep) 

मुझे लगता है कि rstrip("\n") साथ समस्या यह है कि आप शायद यह सुनिश्चित करना चाहते हैं कि लाइन विभाजक पोर्टेबल है (कुछ पुरानी प्रणालियां "\r\n" का उपयोग करने के लिए अफवाह हैं)। दूसरी पकड़ है कि rstrip बार-बार रिक्त स्थान rstrip लेगी। उम्मीद है कि os.linesep में सही वर्ण होंगे। मेरे लिए उपरोक्त काम

आप line = line.rstrip('\n') उपयोग कर सकते हैं। यह स्ट्रिंग के अंत से सभी नयी पंक्तियों को छीन देगा, न सिर्फ एक।

 s = s.rstrip() 

स्ट्रिंग s के अंत में सभी नई लाइनों को निकाल देगा असाइनमेंट की आवश्यकता है क्योंकि rstrip मूल स्ट्रिंग को संशोधित करने के बजाय एक नई स्ट्रिंग देता है।

 "line 1\nline 2\r\n...".replace('\n', '').replace('\r', '') >>> 'line 1line 2...' 

या आप हमेशा regexps के साथ geekier प्राप्त कर सकते हैं 🙂

मज़े करो!

"foo".rstrip(os.linesep) साथ सावधानी: यह केवल उस प्लेटफ़ॉर्म के लिए नए अक्षरों को "foo".rstrip(os.linesep) देगा जहां आपका पायथन निष्पादित किया जा रहा है। कल्पना कीजिए कि आप लिनक्स के अंतर्गत एक विंडोज़ फ़ाइल की तर्ज पर चिमनी कर रहे हैं, उदाहरण के लिए:

 $ python Python 2.7.1 (r271:86832, Mar 18 2011, 09:09:48) [GCC 4.5.0 20100604 [gcc-4_5-branch revision 160292]] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> import os, sys >>> sys.platform 'linux2' >>> "foo\r\n".rstrip(os.linesep) 'foo\r' >>> 

इसके बजाय "foo".rstrip("\r\n") उपयोग करें, जैसा कि माइक ऊपर बताता है।

आप पट्टी का उपयोग कर सकते हैं:

 line = line.strip() 

डेमो:

 >>> "\n\n hello world \n\n".strip() 'hello world' 

पायथन के प्रलेखन में एक उदाहरण बस line.strip() का उपयोग करता है। line.strip()

पर्ल के chomp फ़ंक्शन केवल एक स्ट्रिंग के अंत से एक लाइनब्रेक अनुक्रम निकालता है, अगर यह वास्तव में वहाँ है

यहां बताया गया है कि मैं पायथन में क्या करने की योजना बना रहा हूं, अगर process को इस फ़ाइल से प्रत्येक पंक्ति के लिए कुछ उपयोगी कार्य करने के लिए आवश्यक रूप से कार्य करना है:

 import os sep_pos = -len(os.linesep) with open("file.txt") as f: for line in f: if line[sep_pos:] == os.linesep: line = line[:sep_pos] process(line) 

rstrip chomp के रूप में एक ही बात नहीं है, इतने सारे स्तर पर। पढ़ें http://perldoc.perl.org/functions/chomp.html और देखें कि वास्तव में chomp बहुत जटिल है।

हालांकि, मेरा मुख्य मुद्दा यह है कि कम से कम 1 लाइन समाप्त होने पर chomp निकाल देता है, जबकि rstrip जितना हो सके उतना ही निकाल देगा।

यहां आप आरस्ट्रिप को सभी नई लाइनों को निकाल सकते हैं:

 >>> 'foo\n\n'.rstrip(os.linesep) 'foo' 

ठेठ पर्ल chomp उपयोग के एक बहुत करीब सन्निकटन re.sub के साथ पूरा किया जा सकता है, इस तरह:

 >>> re.sub(os.linesep + r'\Z','','foo\n\n') 'foo\n' 

मैं पायथन में प्रोग्राम नहीं करता, लेकिन मैं अजगर 2.2 या बाद के संस्करण के लिए python.org पर एक प्रश्न पर आया हूं। एसआरस्ट्रिप ("\ r \ n"

 import re r_unwanted = re.compile("[\n\t\r]") r_unwanted.sub("", your_text) 

विशेष केस के लिए वैकल्पिक हल:

यदि नया अक्षर अंतिम वर्ण है (जैसा कि अधिकांश फाइल इनपुट के मामले में है), तो संग्रह में किसी भी तत्व के लिए आप निम्नानुसार इंडेक्स कर सकते हैं:

 foobar= foobar[:-1] 

अपने नए चरित्र को बाहर निकालने के लिए

यदि आपका प्रश्न एकाधिक लाइन स्ट्र ऑब्जेक्ट (ओल्डस्ट्रैक) में सभी लाइन ब्रेक को साफ करना है, तो आप उसे डेलीमिटर '\ n' के अनुसार एक सूची में विभाजित कर सकते हैं और फिर इस सूची को एक नए स्ट्र (न्यूस्ट्रैक) में जोड़ सकते हैं।

newstr = "".join(oldstr.split('\n'))

यह "\ n" रेखा टर्मिनेटर के लिए वास्तव में पर्ल के क्रोम (सरणियों पर शून्य व्यवहार) को दोहराना होगा:

 def chomp(x): if x.endswith("\r\n"): return x[:-2] if x.endswith("\n"): return x[:-1] return x 

(ध्यान दें: यह 'जगह' स्ट्रिंग को संशोधित नहीं करता है, यह अतिरिक्त अनुक्रमित व्हाइटस्पेस को पट्टी नहीं करता है, खाते में \ r \ n लेता है)

महज प्रयोग करें :

 line = line.rstrip("\n") 

या

 line = line.strip("\n") 

आपको इस जटिल सामान की कोई ज़रूरत नहीं है

 >>> ' spacious '.rstrip() ' spacious' >>> "AABAA".rstrip("A") 'AAB' >>> "ABBA".rstrip("AB") # both AB and BA are stripped '' >>> "ABCABBA".rstrip("AB") 'ABC' 

तीन तरह के लाइन समापन हैं जो आम तौर पर हम मुठभेड़ करते हैं: \n , \r और \r\n re.sub में एक साधारण सरल अभिव्यक्ति, अर्थात् r"\r?\n?$" , उन सभी को पकड़ने में सक्षम है।

(और हम उन्हें पकड़ लेंगे , क्या मैं सही हूं?)

 import re re.sub(r"\r?\n?$", "", the_text, 1) 

आखिरी तर्क के साथ, हम एक को प्रतिस्थापित घटनाओं की संख्या को सीमित करते हैं, कुछ हद तक चुम्प की नकल करते हैं। उदाहरण:

 import re text_1 = "hellothere\n\n\n" text_2 = "hellothere\n\n\r" text_3 = "hellothere\n\n\r\n" a = re.sub(r"\r?\n?$", "", text_1, 1) b = re.sub(r"\r?\n?$", "", text_2, 1) c = re.sub(r"\r?\n?$", "", text_3, 1) 

… जहां a == b == c True

मुझे लगता है कि इटोरेटर के माध्यम से chomped लाइनों को प्राप्त करने में सक्षम होने के लिए सुविधाजनक है, जिस तरह से आप किसी फ़ाइल ऑब्जेक्ट से संयुक्त राष्ट्र के चिपचिपा लाइन प्राप्त कर सकते हैं। आप निम्न कोड के साथ ऐसा कर सकते हैं:

 def chomped_lines(it): return map(operator.methodcaller('rstrip', '\r\n'), it) 

नमूना उपयोग:

 with open("file.txt") as infile: for line in chomped_lines(infile): process(line) 

सभी को पकड़ो:

 line = line.rstrip('\r|\n') 

यदि आप गति के बारे में चिंतित हैं (कहें कि आपके पास तार की एक लकीर सूची है) और आप नई लाइन की प्रकृति को जानते हैं, स्ट्रिंग स्कीइसिंग वास्तव में rstrip से अधिक तेज है यह स्पष्ट करने के लिए एक छोटी सी परीक्षा:

 import time loops = 50000000 def method1(loops=loops): test_string = 'num\n' t0 = time.time() for num in xrange(loops): out_sting = test_string[:-1] t1 = time.time() print('Method 1: ' + str(t1 - t0)) def method2(loops=loops): test_string = 'num\n' t0 = time.time() for num in xrange(loops): out_sting = test_string.rstrip() t1 = time.time() print('Method 2: ' + str(t1 - t0)) method1() method2() 

आउटपुट:

 Method 1: 3.92700004578 Method 2: 6.73000001907 

ऐसा लगता है कि पर्ल के कॉम्प के लिए एकदम सही एनालॉग नहीं है विशेष रूप से, आरस्ट्रिप मल्टी-कैरेक्टर न्यूलाइन डिलीमीटर को \r\n जैसे संभाल नहीं सकते हैं। हालांकि, स्प्लिटलाइंस के रूप में यहां बताया गया है । किसी अन्य प्रश्न पर मेरे उत्तर के बाद, आप स्ट्रिंग से सभी नई लाइनों को हटाने / बदलने के लिए जुड़ने और अलग-अलग लाइनों को जोड़ सकते हैं:

 ''.join(s.splitlines()) 

निम्नलिखित एक अनुक्रमित नई लाइन को हटा दिया जाता है (जैसा कि मैं chomp होगा, मेरा मानना ​​है)। True रूप में उत्तीर्ण के रूप में keepends को बनाए रखने के लिए विखंडित को विखंडित तर्क। उसके बाद, अंतिम पंक्ति "केवल" पर सीमांकक को निकालने के लिए स्प्लिटलाइन को फिर से कहा जाता है:

 def chomp(s): if len(s): lines = s.splitlines(True) last = lines.pop() return ''.join(lines + last.splitlines()) else: return '' 

मैं अपने नियमित अभिव्यक्ति के आधार पर एक उत्तर को उछा रहा हूँ जो मैंने पहले एक अन्य उत्तर की टिप्पणी में पोस्ट किया था। मुझे लगता है कि re उपयोग करने से इस समस्या का str.rstrip से अधिक स्पष्ट समाधान है।

 >>> import re 

यदि आप एक या एक से अधिक अनुगामी नए अक्षरों को निकालना चाहते हैं:

 >>> re.sub(r'[\n\r]+$', '', '\nx\r\n') '\nx' 

यदि आप हर जगह नए लाइन वर्ण को हटाना चाहते हैं (न केवल अनुगामी):

 >>> re.sub(r'[\n\r]+', '', '\nx\r\n') 'x' 

यदि आप केवल 1-2 अनुगामी नयी पंक्तियों को निकालना चाहते हैं (यानी, \r , \n , \r\n , \n\r , \r\r , \n\n )

 >>> re.sub(r'[\n\r]{1,2}$', '', '\nx\r\n\r\n') '\nx\r' >>> re.sub(r'[\n\r]{1,2}$', '', '\nx\r\n\r') '\nx\r' >>> re.sub(r'[\n\r]{1,2}$', '', '\nx\r\n') '\nx' 

मुझे लगता है कि ज्यादातर लोग वास्तव में यहाँ क्या चाहते हैं, केवल एक अनुगामी नए चरित्र के एक घटना को दूर करना है, या तो \r\n या \n और कुछ और नहीं।

 >>> re.sub(r'(?:\r\n|\n)$', '', '\nx\n\n', count=1) '\nx\n' >>> re.sub(r'(?:\r\n|\n)$', '', '\nx\r\n\r\n', count=1) '\nx\r\n' >>> re.sub(r'(?:\r\n|\n)$', '', '\nx\r\n', count=1) '\nx' >>> re.sub(r'(?:\r\n|\n)$', '', '\nx\n', count=1) '\nx' 

(द?: एक गैर कैप्चरिंग समूह बनाने के लिए है।)

(जिस तरह से यह नहीं है '...'.rstrip('\n', '').rstrip('\r', '') जो इस धागे पर अन्य ठोकरें को स्पष्ट नहीं हो सकता है str.rstrip रूप में कई str.rstrip पात्रों के रूप में str.rstrip स्ट्रिप्स, तो foo\n\n\n तरह एक स्ट्रिंग का परिणाम foo एक झूठी सकारात्मक हो सकता है, जबकि आप एक ही पीछे की छेड़छाड़ के बाद अन्य नई लाइनों को संरक्षित करना चाहते थे।)