සුදු අවකාශය කපා ගන්නේ කෙසේද?

නූලකින් හිස් අවකාශය (අවකාශ සහ ටැබ්) කපා හරින පයිතන් ශ්‍රිතයක් තිබේද?

උදාහරණය: \t example string\t→example string

දෙපස සුදු අවකාශය:

s = "  \t a string example\t  "
s = s.strip()

දකුණු පැත්තේ සුදු අවකාශය:

s = s.rstrip()

වම් පැත්තේ සුදු අවකාශය:

s = s.lstrip()

ලෙස thedz පෙන්වා දෙයි, ඔබ මේ වගේ මෙම කාර්යයන් ඕනෑම අත්තනෝමතික චරිත අහිමි කිරීමට තර්කයක් සැපයීමට හැක:

s = s.strip(' \t\n\r')

මෙම කිසිදු ඉඩක්, අහිමි වනු ඇත \t, \nහෝ \rවම් අත පැත්තේ, දකුණු අත පැත්තේ, හෝ වැල දෙපැත්තෙන්ම අක්ෂර.

ඉහත උදාහරණ මගින් නූල් වල වම් අත සහ දකුණු පසින් පමණක් ඉවත් කරන්න. ඔබට නූලක් මැදින් අක්ෂර ඉවත් කිරීමට අවශ්‍ය නම්, උත්සාහ කරන්න re.sub:

import re
print re.sub('[\s+]', '', s)

එය මුද්‍රණය කළ යුතුය:

astringexample

පයිතන් trimක්‍රමය හැඳින්වෙන්නේ strip:

str.strip() #trim
str.lstrip() #ltrim
str.rstrip() #rtrim

ප්‍රමුඛ හා පසුපස සුදු අවකාශය සඳහා:

s = '   foo    \t   '
print s.strip() # prints "foo"

එසේ නොමැතිනම්, නිත්‍ය ප්‍රකාශනයක් ක්‍රියාත්මක වේ:

import re
pat = re.compile(r'\s+')
s = '  \t  foo   \t   bar \t  '
print pat.sub('', s) # prints "foobar"

ඔබට ඉතා සරල හා මූලික ශ්‍රිතයක් ද භාවිතා කළ හැකිය: str.replace () , සුදු අවකාශ සහ ටැබ් සමඟ ක්‍රියා කරයි:

>>> whitespaces = "   abcd ef gh ijkl       "
>>> tabs = "        abcde       fgh        ijkl"

>>> print whitespaces.replace(" ", "")
abcdefghijkl
>>> print tabs.replace(" ", "")
abcdefghijkl

සරල හා පහසුය.

#how to trim a multi line string or a file

s=""" line one
\tline two\t
line three """

#line1 starts with a space, #2 starts and ends with a tab, #3 ends with a space.

s1=s.splitlines()
print s1
[' line one', '\tline two\t', 'line three ']

print [i.strip() for i in s1]
['line one', 'line two', 'line three']




#more details:

#we could also have used a forloop from the begining:
for line in s.splitlines():
    line=line.strip()
    process(line)

#we could also be reading a file line by line.. e.g. my_file=open(filename), or with open(filename) as myfile:
for line in my_file:
    line=line.strip()
    process(line)

#moot point: note splitlines() removed the newline characters, we can keep them by passing True:
#although split() will then remove them anyway..
s2=s.splitlines(True)
print s2
[' line one\n', '\tline two\t\n', 'line three ']

කිසිවෙකු තවමත් මෙම රීජෙක්ස් විසඳුම් පළ කර නොමැත.

ගැලපීම:

>>> import re
>>> p=re.compile('\\s*(.*\\S)?\\s*')

>>> m=p.match('  \t blah ')
>>> m.group(1)
'blah'

>>> m=p.match('  \tbl ah  \t ')
>>> m.group(1)
'bl ah'

>>> m=p.match('  \t  ')
>>> print m.group(1)
None

සෙවීම (ඔබට “එකම අවකාශ” ආදාන නඩුව වෙනස් ලෙස හැසිරවිය යුතුය):

>>> p1=re.compile('\\S.*\\S')

>>> m=p1.search('  \tblah  \t ')
>>> m.group()
'blah'

>>> m=p1.search('  \tbl ah  \t ')
>>> m.group()
'bl ah'

>>> m=p1.search('  \t  ')
>>> m.group()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'group'

ඔබ භාවිතා කරන්නේ නම් re.sub, ඔබට අභ්යන්තර සුදු අවකාශය ඉවත් කළ හැකිය, එය නුසුදුසු විය හැකිය.

වයිට්ස්පේස් හි අවකාශය, ටැබ් සහ සීආර්එල්එෆ් ඇතුළත් වේ . එබැවින් අපට භාවිතා කළ හැකි අලංකාර සහ එක්-ලයිනර් නූල් ශ්‍රිතයක් පරිවර්තනය වේ.

' hello apple'.translate(None, ' \n\t\r')

නැතහොත් ඔබට සවිස්තරාත්මක වීමට අවශ්‍ය නම්

import string
' hello  apple'.translate(None, string.whitespace)

(re.sub ('+', '', (my_str.replace ('\ n', '')))) තීරුව ()

මෙය සියලු අනවශ්‍ය අවකාශයන් සහ නව රේඛා අක්‍ෂර ඉවත් කරනු ඇත. මෙම උපකාරය බලාපොරොත්තු වේ

import re
my_str = '   a     b \n c   '
formatted_str = (re.sub(' +', ' ',(my_str.replace('\n',' ')))).strip()

මෙහි ප්‍රති result ලය වනු ඇත:

'a b \ nc' 'ab c' ලෙස වෙනස් වේ

    something = "\t  please_     \t remove_  all_    \n\n\n\nwhitespaces\n\t  "

    something = "".join(something.split())

ප්‍රතිදානය:

කරුණාකර_රෙමෝව්_ඇල්_විට්ස්පේස්

    something = "\t  please     \t remove  all   extra \n\n\n\nwhitespaces\n\t  "
    something = " ".join(something.split())

ප්‍රතිදානය:

කරුණාකර සියලු අමතර හිස් අවකාශයන් ඉවත් කරන්න

පයිතන් 3 භාවිතා කරන්නේ නම්: ඔබේ මුද්‍රණ ප්‍රකාශයේ, sep = "" සමඟ අවසන් කරන්න. එමඟින් සියලු අවකාශයන් වෙන් කරනු ඇත.

උදාහරණයක්:

txt="potatoes"
print("I love ",txt,"",sep="")

මෙය මුද්‍රණය කරනු ඇත: මම අර්තාපල් වලට කැමතියි.

ඒ වෙනුවට: මම අර්තාපල් වලට කැමතියි.

ඔබගේ නඩුවේදී, ඔබ \ t පදින්න උත්සාහ කරන බැවින්, sep = "\ t" කරන්න

විවිධාකාර අවබෝධයකින් යුතුව මෙහි විසඳුම් කිහිපයක් දෙස බැලූ මම කල්පනා කළේ නූල් කොමාවකින් වෙන් කර ඇත්නම් කුමක් කළ යුතුද යන්නයි.

ගැටලුව වන්නේ

සම්බන්ධතා තොරතුරු සීඑස්වී සැකසීමට උත්සාහ කරන අතරතුර, මට මෙම ගැටලුවට විසඳුමක් අවශ්‍ය විය: බාහිර සුදු අවකාශය සහ සමහර කුණු කපන්න, නමුත් පසුපස කොමාව සහ අභ්‍යන්තර සුදු අවකාශය ආරක්ෂා කරන්න. සම්බන්ධතා පිළිබඳ සටහන් අඩංගු ක්ෂේත්‍රයක් සමඟ වැඩ කිරීම, මට අවශ්‍ය වූයේ කුණු කසළ ඉවත් කිරීමට ය. සියලු විරාම ලකුණු සහ දහයියා ඉවත් කරමින්, පසුව නැවත ගොඩනඟා ගැනීමට මට අවශ්‍ය නොවූ නිසා සංයුක්ත ටෝකන අතර ඇති සුදු අවකාශය නැති කර ගැනීමට මට අවශ්‍ය නොවීය.

regex සහ රටා: [\s_]+?\W+

රටාව ඕනෑම සුදු පැහැති අක්ෂරයක තනි අවස්ථා සොයන අතර 1 සිට අසීමිත වාර ගණනක් දක්වා කම්මැලි ලෙස (හැකි තරම් අක්ෂර කිහිපයක්) අවධාරනය කරයි (හැකි තරම් අක්‍ෂර කිහිපයක්) ඒ සමඟ [\s_]+?වචන නොවන අක්ෂර 1 සිට අසීමිත ප්‍රමාණයක් දක්වා පැමිණේ. මේ සමඟ කාලය: \W+(සමාන වේ[^a-zA-Z0-9_] ). නිශ්චිතවම, මෙය හිස් අවකාශයේ සැරිසරයි: ශුන්‍ය අක්ෂර (\ 0), ටැබ් (\ t), නව රේඛා (\ n), සංග්‍රහ ඉදිරියට (\ f), කරත්ත ප්‍රතිලාභ (\ r).

මෙහි ඇති වාසිය දෙගුණයක් ලෙස මම දකිමි:

1. එය ඔබට එකට තබා ගැනීමට අවශ්‍ය විය හැකි සම්පූර්ණ වචන / ටෝකන අතර ඇති හිස් අවකාශය ඉවත් නොකරන බවත්;

2. පයිතන් විසින් සාදන ලද නූල් ක්‍රමය strip(), වම් සහ දකුණු කෙළවරේ පමණක් නොපවතින අතර පෙරනිමි ආර්ග් ශුන්‍ය අක්ෂර වේ (පහත උදාහරණය බලන්න: නව රේඛා කිහිපයක් පෙළෙහි strip()ඇති අතර රීජෙක්ස් රටාව කරන අතරතුර ඒවා සියල්ල ඉවත් නොකරයි) .text.strip(' \n\t\r')

මෙය OPs ප‍්‍රශ්නයෙන් ඔබ්බට ගියත්, මම සිතූ පරිදි, පෙළ දත්ත තුළ අපට අමුතු, ව්යාධිජනක සිදුවීම් ඇති විය හැකි අවස්ථා ඕනෑ තරම් තිබේ (සමහර පා in වල ගැලවීමේ චරිත අවසන් වූ ආකාරය). එපමණක් නොව, ලැයිස්තු වැනි නූල් වලදී, පරිසීමකය සුදු පැහැති අක්ෂර දෙකක් හෝ '-,' හෝ '- ,,,,' වැනි වචන නොවන අක්ෂර දෙකක් වෙන් නොකරන්නේ නම් පරිසීමකය තුරන් කිරීමට අපට අවශ්‍ය නැත.

සැ.යු: CSV හි පරිසීමකය ගැන කතා නොකරයි. CSV තුළ දත්ත ලැයිස්තුගත වූ අවස්ථා වලදී පමණි, එනම් උපස්ථර වල සීඑස් නූලකි.

සම්පුර්ණ හෙළිදරව් කිරීම: මම මාසයක් පමණ පෙළ හසුරුවමින් සිටිමි, සහ පසුගිය සති දෙක තුළ පමණක් රීජෙක්ස් කරන්න, එබැවින් මට මග හැරී ඇති සියුම් වෙනස්කම් ඇති බව මට විශ්වාසයි. එයින් කියැවෙන්නේ, කුඩා නූල් එකතු කිරීම සඳහා (මගේ පේළි 12,000 ක පේළියක සහ අමුතු තීරු 40 ක), බාහිර අක්ෂර ඉවත් කිරීම සඳහා සමත් වීමෙන් පසු අවසාන පියවරක් ලෙස, මෙය සුවිශේෂී ලෙස හොඳින් ක්‍රියාත්මක වේ, විශේෂයෙන් ඔබ අමතර සුදු අවකාශයක් හඳුන්වා දුන්නොත් වචන නොවන අක්‍ෂරයකින් සම්බන්ධ වූ පෙළ වෙන් කිරීමට අවශ්‍ය නමුත් මීට පෙර කිසිවක් නොතිබූ තැන අවකාශය එක් කිරීමට අවශ්‍ය නැත.

උදාහරණයක්:

import re


text = "\"portfolio, derp, hello-world, hello-, -world, founders, mentors, :, ?, %, ,>, , ffib, biff, 1, 12.18.02, 12,  2013, 9874890288, .., ..., ...., , ff, series a, exit, general mailing, fr, , , ,, co founder, pitch_at_palace, ba, _slkdjfl_bf, sdf_jlk, )_(, jim.somedude@blahblah.com, ,dd invites,subscribed,, master, , , ,  dd invites,subscribed, , , , \r, , \0, ff dd \n invites, subscribed, , ,  , , alumni spring 2012 deck: https: www.dropbox.com s, \n i69rpofhfsp9t7c practice 20ignition - 20june \t\n .2134.pdf 2109                                                 \n\n\n\nklkjsdf\""

print(f"Here is the text as formatted:\n{text}\n")
print()
print("Trimming both the whitespaces and the non-word characters that follow them.")
print()
trim_ws_punctn = re.compile(r'[\s_]+?\W+')
clean_text = trim_ws_punctn.sub(' ', text)
print(clean_text)
print()
print("what about 'strip()'?")
print(f"Here is the text, formatted as is:\n{text}\n")
clean_text = text.strip(' \n\t\r')  # strip out whitespace?
print()
print(f"Here is the text, formatted as is:\n{clean_text}\n")

print()
print("Are 'text' and 'clean_text' unchanged?")
print(clean_text == text)

මෙම ප්‍රතිදානයන්:

Here is the text as formatted:

"portfolio, derp, hello-world, hello-, -world, founders, mentors, :, ?, %, ,>, , ffib, biff, 1, 12.18.02, 12,  2013, 9874890288, .., ..., ...., , ff, series a, exit, general mailing, fr, , , ,, co founder, pitch_at_palace, ba, _slkdjfl_bf, sdf_jlk, )_(, jim.somedude@blahblah.com, ,dd invites,subscribed,, master, , , ,  dd invites,subscribed, ,, , , ff dd 
 invites, subscribed, , ,  , , alumni spring 2012 deck: https: www.dropbox.com s, 
 i69rpofhfsp9t7c practice 20ignition - 20june 
 .2134.pdf 2109                                                 



klkjsdf" 

using regex to trim both the whitespaces and the non-word characters that follow them.

"portfolio, derp, hello-world, hello-, world, founders, mentors, ffib, biff, 1, 12.18.02, 12, 2013, 9874890288, ff, series a, exit, general mailing, fr, co founder, pitch_at_palace, ba, _slkdjfl_bf, sdf_jlk,  jim.somedude@blahblah.com, dd invites,subscribed,, master, dd invites,subscribed, ff dd invites, subscribed, alumni spring 2012 deck: https: www.dropbox.com s, i69rpofhfsp9t7c practice 20ignition 20june 2134.pdf 2109 klkjsdf"

Very nice.
What about 'strip()'?

Here is the text, formatted as is:

"portfolio, derp, hello-world, hello-, -world, founders, mentors, :, ?, %, ,>, , ffib, biff, 1, 12.18.02, 12,  2013, 9874890288, .., ..., ...., , ff, series a, exit, general mailing, fr, , , ,, co founder, pitch_at_palace, ba, _slkdjfl_bf, sdf_jlk, )_(, jim.somedude@blahblah.com, ,dd invites,subscribed,, master, , , ,  dd invites,subscribed, ,, , , ff dd 
 invites, subscribed, , ,  , , alumni spring 2012 deck: https: www.dropbox.com s, 
 i69rpofhfsp9t7c practice 20ignition - 20june 
 .2134.pdf 2109                                                 



klkjsdf"


Here is the text, after stipping with 'strip':


"portfolio, derp, hello-world, hello-, -world, founders, mentors, :, ?, %, ,>, , ffib, biff, 1, 12.18.02, 12,  2013, 9874890288, .., ..., ...., , ff, series a, exit, general mailing, fr, , , ,, co founder, pitch_at_palace, ba, _slkdjfl_bf, sdf_jlk, )_(, jim.somedude@blahblah.com, ,dd invites,subscribed,, master, , , ,  dd invites,subscribed, ,, , , ff dd 
 invites, subscribed, , ,  , , alumni spring 2012 deck: https: www.dropbox.com s, 
 i69rpofhfsp9t7c practice 20ignition - 20june 
 .2134.pdf 2109                                                 



klkjsdf"
Are 'text' and 'clean_text' unchanged? 'True'

එබැවින් තීරු වරකට එක් සුදු අවකාශයක් ඉවත් කරයි. එබැවින් OPs නඩුවේදී, strip()හොඳයි. නමුත් දේවල් වඩාත් සංකීර්ණ වුවහොත්, රීජෙක්ස් සහ ඒ හා සමාන රටාවක් වඩාත් සාමාන්‍ය සැකසුම් සඳහා යම් වටිනාකමක් ලබා දිය හැකිය.

එය ක්‍රියාවෙන් බලන්න

පරිවර්තනය කිරීමට උත්සාහ කරන්න

>>> import string
>>> print '\t\r\n  hello \r\n world \t\r\n'

  hello 
 world  
>>> tr = string.maketrans(string.whitespace, ' '*len(string.whitespace))
>>> '\t\r\n  hello \r\n world \t\r\n'.translate(tr)
'     hello    world    '
>>> '\t\r\n  hello \r\n world \t\r\n'.translate(tr).replace(' ', '')
'helloworld'

ඔබට නූලෙහි ආරම්භය හා අවසානය වන විට හිස් අවකාශය කපා දැමීමට අවශ්‍ය නම්, ඔබට මේ වගේ දෙයක් කළ හැකිය:

some_string = "    Hello,    world!\n    "
new_string = some_string.strip()
# new_string is now "Hello,    world!"

මෙය Qt හි QString :: trimmed () ක්‍රමයට සමාන ලෙස ක්‍රියා කරයි, එමඟින් එය ප්‍රමුඛ හා පසුපස සුදු අවකාශය ඉවත් කරන අතරම අභ්‍යන්තර සුදු අවකාශය තනිවම තබයි.

Qt හි QString :: සරල () ක්‍රමයට ඔබ කැමති නම්, එය ප්‍රමුඛ හා පසුපස සුදු අවකාශය ඉවත් කරනවා පමණක් නොව, අඛණ්ඩව අභ්‍යන්තර අවකාශය එක් අභ්‍යවකාශ අක්ෂරයකට “කොටු කරයි”, ඔබට මේ .split()හා " ".joinසමාන සංයෝජනයක් භාවිතා කළ හැකිය :

some_string = "\t    Hello,  \n\t  world!\n    "
new_string = " ".join(some_string.split())
# new_string is now "Hello, world!"

මෙම අන්තිම උදාහරණයේ දී, අභ්‍යන්තර සුදු අවකාශයේ එක් එක් අනුක්‍රමය තනි අවකාශයකින් ප්‍රතිස්ථාපනය වන අතර, නූල ආරම්භයේ හා අවසානයේ සුදු අවකාශය කපා දමයි.

සාමාන්යයෙන්, මම පහත ක්රමය භාවිතා කරමි:

>>> myStr = "Hi\n Stack Over \r flow!"
>>> charList = [u"\u005Cn",u"\u005Cr",u"\u005Ct"]
>>> import re
>>> for i in charList:
        myStr = re.sub(i, r"", myStr)

>>> myStr
'Hi Stack Over  flow'

සටහන: මෙය "\ n", "\ r" සහ "\ t" ඉවත් කිරීම සඳහා පමණි. එය අමතර අවකාශයන් ඉවත් නොකරයි.

මෙය සියලු සුදු අවකාශය සහ නව රේඛා නූලක ආරම්භයේ සහ අවසානයෙන් ඉවත් කරයි:

>>> s = "  \n\t  \n   some \n text \n     "
>>> re.sub("^\s+|\s+$", "", s)
>>> "some \n text"