පසුපසින් සිටින නව රේඛාවක් ඉවත් කරන්නේ කෙසේද?

පර්ල්ගේ chompශ්‍රිතයට සමාන පයිතන් යනු කුමක්ද? එය නව රේඛාවක් නම් නූලක අවසාන අක්‍ෂරය ඉවත් කරයි.

ක්‍රමය උත්සාහ කරන්න rstrip()(doc Python 2 සහ Python 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'

අළුත් රේඛා අක්ෂර පසුපස නොගෙන රේඛා ලබා ගැනීම සඳහා “පයිතොනික්” ක්‍රමය බෙදීම් () යැයි මම කියමි.

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

එන්-පේළියේ (ඊඕඑල්) අක්ෂර ඉවත් කිරීමට කැනොනිකල් ක්‍රමය නම් r r හෝ ri n යන ඕනෑම ඉවත් කිරීමක් ඉවත් කිරීම සඳහා නූල් rstrip () ක්‍රමය භාවිතා කිරීමයි. මැක්, වින්ඩෝස් සහ යුනික්ස් ඊඕඑල් අක්ෂර සඳහා උදාහරණ මෙන්න.

>>> '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 පණිවිඩයක් අඩංගු පෙළ ගොනුවක් සැකසීමට සිදු විය. එච්එල් 7 ප්‍රමිතියට එහි ඊඕඑල් අක්‍ෂරය ලෙස පසුපසින් '\ r' අවශ්‍ය වේ. මම මෙම පණිවිඩය භාවිතා කළ වින්ඩෝස් යන්ත්‍රය තමන්ගේම '\ r \ n' EOL අක්‍ෂරය එකතු කර ඇත. එබැවින්, එක් එක් පේළියේ අවසානය '\ r \ r \ n' ලෙස පෙනුනි. Rstrip ('\ r \ n') භාවිතා කිරීම මට අවශ්‍ය වූ මුළු '\ r \ r \ n' ඉවත් කිරීමට ඉඩ තිබුණි. එවැනි අවස්ථාවක, මම ඒ වෙනුවට අන්තිම අක්ෂර දෙක කපා දැමුවෙමි.

පර්ල්ගේ chompශ්‍රිතය මෙන් නොව , මෙය එක් අක්ෂරයකට පමණක් නොව, සියලු නිශ්චිත අකුරු ඉවත් කරනු ඇත.

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

Rstrip හරියටම පර්ල්ගේ chomp () මෙන් ක්‍රියා නොකරන බව සලකන්න. එනම්, පර්ල් හි:

$x="a\n";

chomp $x

ප්‍රති results ල $xවීම "a".

නමුත් පයිතන්හි:

x="a\n"

x.rstrip()

එහි වටිනාකම තවමත් පවතින බව එයින් අදහස් xවේ . පවා එය නූල්, වැඩිම එක් නව පේළියකට යොමු කිරීමේ අක්ෂරය නොව අවසානයේ සිට සියලු whitespace තීරු ලෙස සෑම විටම, එම ප්රතිඵලය දෙන්නේ නැහැ. "a\n"x=x.rstrip()

මම මේ වගේ දෙයක් භාවිතා කළ හැකිය:

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

මම හිතන්නේ ගැටලුව rstrip("\n")වන්නේ රේඛා බෙදුම්කරු අතේ ගෙන යා හැකි බවට වග බලා ගැනීමට ඔබට අවශ්‍ය වනු ඇත. (සමහර පෞරාණික පද්ධති භාවිතා කිරීමට කටකතා පැතිර ඇත "\r\n"). අනෙක් ගොචා යනු rstripනැවත නැවතත් සුදු අවකාශය ඉවත් කිරීමයි. os.linesepනිවැරදි අක්ෂර අඩංගු වේ යැයි බලාපොරොත්තු වෙමු . ඉහත කරුණු මා වෙනුවෙන් වැඩ කරයි.

ඔබට භාවිතා කළ හැකිය line = line.rstrip('\n'). මෙය එක් නවකථාවක් පමණක් නොව නූල් කෙළවරේ සිට ඉවත් කරයි.

s = s.rstrip()

නූල අවසානයේ සියලුම නව රේඛා ඉවත් sකරයි. පැවරුම අවශ්‍ය වන්නේ rstripමුල් නූල වෙනස් කිරීම වෙනුවට නව නූලක් ලබා දෙන බැවිනි .

මෙය "\ n" රේඛීය ටර්මිනේටරය සඳහා හරියටම පර්ල්ගේ චොම්ප් (අරා වල behavior ණ හැසිරීම) අනුකරණය කරයි:

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 \ n සැලකිල්ලට ගනී)

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

හෝ ඔබට සැමවිටම රීජෙක්ස් සමඟ ගීකර් ලබා ගත හැකිය :)

විනෝද වන්න!

ඔබට තීරුව භාවිතා කළ හැකිය:

line = line.strip()

නිරූපණය:

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

rstrip බොහෝ මට්ටම් වල chomp ලෙසම කරන්නේ නැත. Http://perldoc.perl.org/functions/chomp.html කියවන්න ඇත්ත වශයෙන්ම චොම්ප් ඉතා සංකීර්ණ බව බලන්න.

කෙසේ වෙතත්, මගේ ප්‍රධාන කාරණය නම්, චොම්ප් උපරිම වශයෙන් පේළි 1 ක් ඉවත් කරන අතර rstrip මඟින් හැකි තරම් ප්‍රමාණයක් ඉවත් කරනු ඇත.

සියලු නව රේඛා ඉවත් කිරීම rstrip මෙහිදී ඔබට දැක ගත හැකිය:

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

සාමාන්‍ය පර්ල් චොම්ප් භාවිතය පිළිබඳ වඩාත් ආසන්න තක්සේරුවක් re.sub සමඟ සිදු කළ හැකිය, මේ ආකාරයට:

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

ප්‍රවේශම් වන්න "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")මයික් ඉහත සඳහන් කළ පරිදි ඒ වෙනුවට භාවිතා කරන්න .

ක Python හි ප්රලේඛනය උදාහරණයක් හුදෙක් භාවිතා 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)

මම පයිතන් හි වැඩසටහන් කරන්නේ නැත, නමුත් මට python.org හි නිතර අසන පැන හමු විය. පයිතන් 2.2 හෝ ඊට පසුව S.rstrip ("\ r \ n") වෙනුවෙන් පෙනී සිටියේය.

import re

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

ඔබේ ප්‍රශ්නය නම්, සියලු රේඛා බිඳීම් බහු රේඛා str වස්තුවක (oldstr) පිරිසිදු කිරීම නම්, ඔබට එය '\ n' පරිසීමාවට අනුව ලැයිස්තුවකට බෙදිය හැකි අතර පසුව මෙම ලැයිස්තුවට නව str (newstr) ලෙස සම්බන්ධ කරන්න.

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

ගොනු වස්තුවකින් ඔබට තෝරා නොගත් රේඛා ලබා ගත හැකි ක්‍රමයට සමාන්තරව, ඉරේටරය හරහා චොම්ප් කරන ලද රේඛා ලබා ගැනීමට හැකිවීම පහසු බව මට පෙනේ. පහත කේතය සමඟ ඔබට එය කළ හැකිය:

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)

විශේෂ අවස්ථා සඳහා විසඳුම් විසඳුම:

නව රේඛා අක්‍ෂරය අවසාන අක්‍ෂරය නම් (බොහෝ ගොනු ආදාන වලදී මෙන්), එකතුවෙහි ඇති ඕනෑම අංගයක් සඳහා ඔබට පහත පරිදි සුචිගත කළ හැකිය:

foobar= foobar[:-1]

ඔබගේ නව රේඛා චරිතය කපා දැමීමට.

පර්ල්ගේ චොම්ප් සඳහා පරිපූර්ණ ඇනලොග් නොමැති බව පෙනේ . විශේෂයෙන්, rstrip වැනි බහු-අක්ෂර නව රේඛා පරිමිතීන් හැසිරවිය නොහැක \r\n. කෙසේ වෙතත්, මෙහි පෙන්වා ඇති පරිදි භේදය රේඛා කරයි . වෙනත් ප්‍රශ්නයකට මගේ පිළිතුර අනුගමනය කිරීමෙන් , ඔබට සියලු නව රේඛා නූලකින් ඉවත් කිරීමට / ප්‍රතිස්ථාපනය කිරීමට එක්වීම සහ බෙදීම් ඒකාබද්ධ කළ හැකිය :s

''.join(s.splitlines())

පහත සඳහන් කොටස් ඉවත් හරියටම එක් අගින් ඇද නව පේළියකට යොමු කිරීමේ අක්ෂරය (chomp ලෙස, මම විශ්වාස කරන්නේ). පසුකර Trueලෙස keependssplitlines කිරීමට තර්කය ක්රමයන්හි කිරීමේ බලය රඳවා ගෙන සිටී. අන්තිම "පේළියේ" පරිසීමක ඉවත් කිරීම සඳහා ස්ප්ලිට්ලයින් නැවත කැඳවනු ලැබේ:

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'

ඔබ අවර නව පේළියකට යොමු කිරීමේ අක්ෂරය chars 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ඔබ ආරක්ෂා කිරීමට අවශ්ය විය හැක ෙහයින්ද, පසුපසින් එකක් ඉවත් කිරීමෙන් පසු වෙනත් නව රේඛා.)

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

භාවිතා කරන්න:

line = line.rstrip("\n")

හෝ

line = line.strip("\n")

ඔබට මෙම සංකීර්ණ දේවල් කිසිවක් අවශ්‍ය නොවේ

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'

අප සාමාන්යයෙන් මුහුණ එම රේඛාව අවසානය වර්ග තුනක් ඇත: \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.

ඔබ වේගය ගැන සැලකිලිමත් වන්නේ නම් (ඔබට නූල් ලැයිස්තුවක් ඇති බව පවසන්න) සහ නව රේඛා වර්‍ගයේ ස්වභාවය ඔබ දන්නවා නම්, නූල් කැපීම ඇත්ත වශයෙන්ම 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

මෙය වින්ඩෝස් සහ ලිනක්ස් සඳහා ක්‍රියා කරනු ඇත (ඔබ නැවත විසඳුමක් පමණක් සොයන්නේ නම් නැවත උප සමඟ තරමක් මිල අධික වේ)

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

සියල්ල අල්ලා ගන්න:

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

පළමු බෙදීම් රේඛා ඉන්පසු ඔබ කැමති ඕනෑම බෙදුම්කරුවෙකු සමඟ සම්බන්ධ වන්න:

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

චාම් එකක් වගේ වැඩ කළ යුතුයි.