मैं एक नई रूपरेखा कैसे निकाल सकता हूँ?

Question

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

Comments

सुपरसेट: नई स्ट्रिंग के बजाय कोई भी स्ट्रिंग: stackoverflow.com/questions/1038824/…

— Ciro Santilli Sant

A + उत्तर है, यदि यह आपके प्लेटफ़ॉर्म के लिए open()उपयुक्त 'newline = ...' पैरामीटर वाली फ़ाइल को भूलने के कारण था (सार्वभौमिक newline support), तो आपको इसे स्पष्ट रूप से निकालने की आवश्यकता नहीं हो सकती है।

— एसएमसीआई

Answer 1

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

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

पायथन की rstrip()विधि डिफ़ॉल्ट रूप से अनुगामी व्हाट्सएप के सभी प्रकारों को स्ट्रिप्स करती है , न कि केवल एक नई रेखा के रूप में जो पर्ल के साथ होती है chomp।

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

Comments

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

— ब्रायन डी फॉय

brian d foy: पायथन में इनपुट रिकॉर्ड सेपरेटर नहीं है जैसे कि awk और Perl है।

— पीटर होसी

@csde_rats, यह सच नहीं है: OS X \nयूनिक्स की तरह ही नईलाइन्स के लिए उपयोग करता है । (ओएस एक्स से पहले, मैकओएस ने \rएक लाइन विभाजक के रूप में उपयोग किया था , लेकिन 10 साल पहले समाप्त हो गया।)

— 19

@briandfoy पायथन ने यूनिवर्सल नईलाइन्स के लिए बिल्ट-इन सपोर्ट किया है (केवल पढ़ते समय, लिखते समय नहीं)। आप फ़ाइल को "यू" या "आरयू" मोड में खोलते हैं, और फिर विंडोज, लिनक्स, मैक की परवाह किए बिना, जो कुछ भी, जब तक पाठ आपके पायथन कोड तक पहुंचता है, तब तक नई पंक्ति की किसी भी शैली को "\ n" से बदल दिया जाता है। देखें: python.org/dev/peps/pep-0278

— AlcubierreDrive

मैं आगे जा रहा हूँ और इसे बाहर जादू कर रहा हूँ क्योंकि मैं एक noob हूँ और मैंने यह सोचकर कुछ समय बिताया कि यह काम क्यों नहीं कर रहा था। .strip()स्ट्रिंग को परिवर्तित नहीं करता है (शायद अपरिवर्तनीय स्ट्रिंग्स के साथ कुछ करना है)। यदि कमांड लाइन में नहीं है, तो आप चाहेंगे"string = string.strip()"

— स्क्रिप्ट किटी

Answer 2

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

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

Comments

ध्यान दें: str.splitlines()नई-पंक्तियों कई पात्रों के रूप में व्यवहार करता है (न केवल \r, \n)

— JFS

Answer 3

एंड-ऑफ-लाइन (ईओएल) वर्णों को छीनने का विहित तरीका स्ट्रिंग आरस्ट्रिप () विधि का उपयोग करके किसी भी ट्रेलिंग \ 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'

Rstrip के पैरामीटर के रूप में '\ r \ n' का उपयोग करने का मतलब है कि यह '\ r' या '\ n' के किसी भी अनुगामी संयोजन को हटा देगा। इसीलिए यह उपरोक्त तीनों मामलों में काम करता है।

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

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

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

Comments

ध्यान दें कि आधुनिक Mac OS X एप्लिकेशन \ n का उपयोग करते हैं। केवल पुराने कार्बन ऐप ही मूल रूप से मैक ओएस के लिए लिखे गए हैं \ r का उपयोग करें।

— पीटर होसी

स्पष्टीकरण के लिए धन्यवाद। बेशक, rstrip ('\ r \ n') अभी भी उस मामले में भी काम करता है।

— माइक

वहाँ भी है os.linesep, जिसमें मौजूदा ओएस के लिए ईओएल अनुक्रम शामिल है।

— एली कॉलिन्स

यह सबसे अच्छा जवाब है: यह केवल नई सुर्खियों को छीनता है, और यह सबसे सामान्य प्लेटफार्मों के लिए सही ढंग से करता है।

— केविनरपे

प्लस +1 उपयोग करने के लिए \nऔर\r

— fechnert

Answer 4

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

$x="a\n";

chomp $x

$xहोने में परिणाम"a" ।

लेकिन अजगर में:

x="a\n"

x.rstrip()

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

Comments

इसके अलावा, पट्टी () दोहराए गए वर्णों को हटा देती है, जबकि चॉप /

— चॉम्प

Answer 5

मैं कुछ इस तरह का उपयोग कर सकते हैं:

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

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

Comments

यह तब भी काम नहीं करेगा जब आप किसी वेब एप्लिकेशन में उपयोगकर्ता द्वारा सबमिट की गई सामग्री को साफ़ करने का प्रयास कर रहे हों। उपयोगकर्ता सामग्री किसी भी स्रोत से आ सकती है और इसमें कोई भी नया चार्ट हो सकता है।

— एपीगुय

अच्छा बिंदु, सिवाय इसके कि आप अपने आधुनिक ओएस पर 'विदेशी' फाइल (एंटीक्यूटेड सिस्टम से) प्रसंस्करण कर सकते हैं।

— ChuckCottrill 2

यह भी ध्यान रखें कि यदि आप किसी फाइल को टेक्स्ट मोड में पढ़ रहे हैं, तो यह विंडोज सिस्टम पर भी काम नहीं करेगा, क्योंकि ट्रेलिंग कैरेक्टर हमेशा '\ n' में बदल जाएगा।

— पागल भौतिकवादी

@MadPhysicist आप सही हैं कि यह इसे रूपांतरित करता है, लेकिन यह अभी भी काम करता है क्योंकि यह जैसा है वैसा ही है rstrip('\r\n')और rstrip()किसी भी वर्ण को तर्क में बदल देगा।

— डॅक्टेअर

Answer 6

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

Answer 7

s = s.rstrip()

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

Answer 8

यह "प्रति \ _" लाइन टर्मिनेटर के लिए बिल्कुल पर्ल के चॉम्प (एरेस पर माइनस बिहेवियर) को दोहराएगा:

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

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

Answer 9

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

या आप हमेशा regexps के साथ geekier मिल सकता है :)

मज़े करो!

Comments

यह मेरे लिए बहुत अच्छा काम करता है कि मैं एक टेक्स्ट फाइल को लाइन एंडिंग के साथ टेक्स्ट के एक लाइन में बदलने की कोशिश करूं। मैं एक नौसिखिया हूँ, इसलिए यह सुनिश्चित करने के लिए बेहतर नहीं है कि यह करने के लिए एक बेहतर तरीका है, लेकिन यह काम किया, धन्यवाद! (स्ट्रिप केवल अंत से काम करने के लिए लग रहा था, आंतरिक रूप से नहीं)

— स्टीव कोच

क्यों नहीं एक की जगह एक बयान का उपयोग करें .replace('\n|\r', '')?

— डोरकनॉ

बस अगर कोई अन्य व्यक्ति @DoorknobofSnow से विचार का उपयोग करना चाहता है, तो रेगेक्स मॉड्यूल का उपयोग करने के लिए यह केवल एक छोटा परिवर्तन है: import re re.sub('\n|\r', '', '\nx\n\r\n')==> 'x'।

— टेलर एड्मिस्टन

इस और regex तकनीक का उपयोग @TaylorEdmiston के रूप में उल्लिखित उचित उत्तर होना चाहिए।

— भार्गव

@Bhargav मैंने इस टिप्पणी के आधार पर एक उत्तर जोड़ा है जैसा कि आपने सुझाव दिया था जबकि कुछ अन्य संबंधित विकल्पों की खोज भी की थी। मैंने यह भी स्पष्ट किया कि मुझे क्यों लगता है कि regex str.rstrip की तुलना में इस समस्या का एक बेहतर समाधान है क्योंकि यह सबसे अधिक उत्तर का उपयोग करता है।

— टेलर एड्मिस्टन

Answer 10

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

line = line.strip()

डेमो:

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

Comments

इस समाधान की कोशिश की, लेकिन यह लाइन में अग्रणी रिक्त स्थान को छीन लेता है।

— तारिक

@ तारिक आप

— Hackaholic

rstrip, सभी अनुगामी व्हाट्सएप को हटा देगा, चॉम्प के विपरीत जो कि केवल एक नई लाइन पर डिलीट होता है।

— फ्लिम

Answer 11

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

हालांकि, मेरा मुख्य बिंदु यह है कि ज्यादातर 1 लाइन समाप्त होने पर चॉम्प हटाता है, जबकि रैस्ट्रिप जितना संभव हो उतना हटा देगा।

यहाँ आप देख सकते हैं rstrip को हटाने के सभी newlines:

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

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

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

Comments

कुडोस, आप केवल एक ही हैं जो इस बहुत महत्वपूर्ण विवरण को इंगित करते हैं। हालाँकि, जैसा कि ऊपर किसी ने उल्लेख किया है, यदि आप एक अलग सिस्टम से फाइल पढ़ रहे हैं तो os.linesep का उपयोग करना काम नहीं करेगा। यह पायथन में थोड़ा और काम कर सकता है, वास्तव में लाइन के अंत का निरीक्षण करना।

— branmearns

Answer 12

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

$ 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")इसके बजाय का उपयोग करें , जैसा कि ऊपर माइक कहते हैं।

Comments

ध्यान देने वाली दूसरी बात यह है कि यह एक नईलाइन पर नहीं, बल्कि सभी नईलाइनों के विपरीत है chomp।

— फ्लिम

Answer 13

पायथन के प्रलेखन में एक उदाहरण बस उपयोग करता है 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)

Comments

अंत में, एक उत्तर जो केवल एक बार इसे हटाता है (जैसे वास्तविक धूमधाम ...) और ओएस पोर्टेबल है!

— सिरो सेंटिल्ली 冠状 病毒 i i 法轮功 ''

Answer 14

मैं पायथन में कार्यक्रम नहीं करता हूं, लेकिन मैं python.org पर अक्सर पूछे जाने वाले प्रश्न के लिए python.org पर S.rstrip ("\ r \ n") की वकालत करता हूं।

Answer 15

import re

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

Comments

यह टैब व्हाट्सएप को भी हटाने जा रहा है, जिसे मूल प्रश्न अनुरोध नहीं करता है। (द टी कैरेक्टर के कारण)

— नूह 21

Answer 16

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

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)

Comments

नोट: के साथ operator.methodcallerऔर map( itertools.imapPy2 पर) आप सी परत को यह काम धक्का कर सकते हैं, अजगर स्तर जनरेटर कोड से परहेज (और इस तरह, एक सा तेजी से चल हालांकि बेशक मैं / हे भूमि के ऊपर जाने की संभावना छोटे लाभ मुखौटा करने के लिए है): for line in map(operator.methodcaller('rstrip', '\r\n'), infile):। यह अभी भी बाहर फैक्टर किया जा सकता है def chomped_lines(it): return map(operator.methodcaller('rstrip', '\r\n'), it)।

— शैडो रेंजर

Answer 17

विशेष मामले के लिए समाधान समाधान:

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

foobar= foobar[:-1]

अपने नए चरित्र को खत्म करने के लिए।

Comments

कभी-कभी न्यूलाइन एक अंतिम चरित्र नहीं होता है , लेकिन अंतिम वाले, विशेष रूप से खिड़कियों पर, जैसा कि अन्य ने बताया है।

— काकोवस्की

Answer 18

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

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

Answer 19

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

''.join(s.splitlines())

निम्नलिखित वास्तव में एक अनुगामी newline को हटाता है (जैसा कि chomp होगा, मुझे विश्वास है)। स्प्लिट्स Trueमें keependsतर्क के रूप में पास होने से परिसीमन बरकरार रहता है। फिर, केवल अंतिम "लाइन" पर सीमांकक को हटाने के लिए फिर से विभाजित किया जाता है:

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

Answer 20

मैं अपनी नियमित अभिव्यक्ति आधारित उत्तर को एक उत्तर से दूसरे पोस्ट की टिप्पणियों में पोस्ट कर रहा हूं। मुझे लगता है कि उपयोग 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संभव के रूप में पीछे चल रहे पात्रों में से कई के रूप में स्ट्रिप्स, इसलिए इस तरह की स्ट्रिंग foo\n\n\nकी एक झूठी सकारात्मक में परिणाम होगा fooआप की रक्षा करना चाहता था हो सकता है, जबकि एकल अनुगामी छीनने के बाद अन्य नई सुर्खियाँ।)

Comments

आप गैर-कैप्चरिंग समूह को अपने अंतिम दृष्टिकोण के लिए भी, regex के साथ छोड़ सकते हैं r'\r?\n$'। संभावना से अधिक कुशल, चूंकि रेगेक्स इंजन में वैकल्पिक रूप से अनुकूलन करने में कठिन समय होता है। यह भी ध्यान दें कि यदि आप इसे कई बार करने जा रहे हैं, तो यह काफी तेज होगा (विशेषकर यदि आप अन्य reउपयोगों के साथ परस्पर क्रिया कर रहे हैं ) re.compileएक बार सामने वाले के अभिव्यक्ति के लिए, तो subसंकलित रेगेक्स ऑब्जेक्ट की विधि का उपयोग करें ; मॉड्यूल फ़ंक्शन पायथन स्तर हैं और पहले संकलित रेगेक्स के लिए एक कैश की जांच करें (यदि गायब है / कैशिंग), तो मिलान विधि को कॉल करें; लुकअप में मदद करता है कि लंघन।

— शैडो रेंजर

इसके अलावा, साइड-नोट: चूंकि आप \nसीधे मिलान करने का प्रयास कर रहे हैं, इसलिए आप \Zओवर $(या सिर्फ मैच) का उपयोग करना चाह सकते हैं \r?$, क्योंकि $अंतर्निहित स्ट्रिंग के अंत में न्यूलाइन से ठीक पहले मिलान कर सकते हैं)।

— शैडो रेंजर

Answer 21

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

Comments

जो उदाहरण मुझे चाहिए था! तो rstrip ("\ r \ n") लाइन के अंत में किसी भी संयोजन में '\ n' और 'r' दोनों को छीन लेगा!

— Agostino

@ एगोस्टिनो को "\r\n"उदाहरण के लिए प्रदान करने की आवश्यकता नहीं है : ' spacious \n\r\n\r \n\n'.rstrip()उत्पादन' spacious'

— ऑलिब्रे

@olibre आपके द्वारा सुझाए गए कोड को अन्य रिक्त / स्थान वर्णों को भी छीन लेगा, जो कि किसी की आवश्यकता नहीं है। वास्तव में, मुझे केवल ईओएल पात्रों के संयोजन की आवश्यकता थी। फिर भी, यह इंगित करने के लिए धन्यवाद।

— अगस्तियो

Answer 22

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

line = line.rstrip("\n")

या

line = line.strip("\n")

आपको इस जटिल सामान की कोई आवश्यकता नहीं है

Comments

ध्यान दें कि यह chomp के समान नहीं है।

— फ्लिम

Answer 23

s = '''Hello  World \t\n\r\tHi There'''
# import the module string   
import string
# use the method translate to convert 
s.translate({ord(c): None for c in string.whitespace}
>>'HelloWorldHiThere'

रेगेक्स के साथ

s = '''  Hello  World 
\t\n\r\tHi '''
print(re.sub(r"\s+", "", s), sep='')  # \s matches all white spaces
>HelloWorldHi

बदलें \ n, \ t, \ r

s.replace('\n', '').replace('\t','').replace('\r','')
>'  Hello  World Hi '

रेगेक्स के साथ

s = '''Hello  World \t\n\r\tHi There'''
regex = re.compile(r'[\n\r\t]')
regex.sub("", s)
>'Hello  World Hi There'

साथ जुड़ें

s = '''Hello  World \t\n\r\tHi There'''
' '.join(s.split())
>'Hello  World Hi There'

Answer 24

वहाँ लाइन अंत के तीन प्रकार है कि हम सामान्य रूप से मुठभेड़ कर रहे हैं: \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।

Comments

तुम भी पूर्ण नियमित अभिव्यक्ति की जरूरत नहीं है। rstrip("\r\n")एक पकड़ है सब। कोशिश करो print(text_2.rstrip('\r\n'))।

— एगोस्टिनो

@Agostino: यह सच है कि str.rstrip()समस्या को हल करता है। यह इस बात पर निर्भर करता है कि आपको कौन सी जरूरत है। यह समाधान विशेष रूप से उन मामलों के लिए किया जाता है जब आपको केवल अंतिम को हटाने की आवश्यकता होती है "\n", "\r"या "\r\n"उन सभी को नहीं (यदि "\n"स्ट्रिंग में कई हैं )। re.sub(r"\r?\n?$", "", text_1, 1)रिटर्न "hellothere\n\n"और text_1.rstrip("\r\n")रिटर्न "hellothere"जो एक अलग स्ट्रिंग है।

— इंटरनेट

जो मैं कहने की कोशिश कर रहा हूं, वह यह str.strip()है कि कैच-ऑल कभी-कभी बहुत समस्या है।

— इंटरनेट

Answer 25

यदि आप गति के बारे में चिंतित हैं (कहते हैं कि आपके पास स्ट्रिंग्स की एक लूओंग सूची है) और आप जानते हैं कि न्यूलाइन चार की प्रकृति, स्ट्रिंग स्लाइसिंग वास्तव में 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

Comments

मुझे पता है कि मुझे संभवतः फ़ंक्शन के अंदर "वैश्विक लूप" का उपयोग करना चाहिए, लेकिन यह भी काम करता है।

— स्टीफन मिलर

इस परीक्षा .. गलत और नहीं उचित है में method1तुम सिर्फ अंतिम वर्ण, कोई बात नहीं क्या, में बंद काटना कर रहे हैं पहले चेक, अगर स्ट्रिंग के अंत अवांछित वर्ण हैं और उन्हें बंद कांट-छांट कर, सिर्फ तभी जब कुछ पाए गए। कृपया किरदारों के लिए कुछ जांच लागू करें और एगिन का परीक्षण करें! method2.rstrip()method1

— spky

जैसा कि मैंने उत्तर में परिचय में कहा था: यदि आप न्यूलाइन चार की प्रकृति को जानते हैं, तो यह उपयोगी है। यदि आप हां नहीं करते हैं, तो आपको स्पष्ट रूप से कुछ प्रकार के चरित्र जांच को लागू करने की आवश्यकता है - या बस rstrip का उपयोग करें। मेरा मतलब यह नहीं था कि मैं "अनुचित" हो सकता हूं, लेकिन मुझे कुछ स्थितियों में इस पर ध्यान नहीं देना चाहिए कि यह इतना महत्वहीन अंतर है।

— स्टीफन मिलर

Answer 26

---

यह विंडोज़ और लिनक्स दोनों के लिए काम करेगा (यदि आप केवल पुनः समाधान के लिए देख रहे हैं तो री सब के साथ थोड़ा महंगा है)

import re 
if re.search("(\\r|)\\n$", line):
    line = re.sub("(\\r|)\\n$", "", line)

---

Comments

re.searchजहां आपको सिर्फ जरूरत है वहां क्यों इस्तेमाल करें re.sub?

— वेजेंड्रिया

Answer 27

पहले विभाजित रेखाएं फिर उन्हें किसी भी विभाजक द्वारा शामिल करें जो आपको पसंद है:

x = ' '.join(x.splitlines())

एक आकर्षण की तरह काम करना चाहिए।

Answer 28

सभी को पकड़ें:

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

Comments

rstripनियमित अभिव्यक्ति नहीं लेता है। "hi|||\n\n".rstrip("\r|\n")रिटर्न"hi"

— फ्लिम