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

පයිතන්හි ඇති නූලකින් ප්‍රමුඛ හා පසුපස සුදු අවකාශය ඉවත් කරන්නේ කෙසේද?

උදාහරණයක් වශයෙන්:

" Hello " --> "Hello"
" Hello"  --> "Hello"
"Hello "  --> "Hello"
"Bob has a cat" --> "Bob has a cat"

එක් ඉඩක් පමණක්ද, නැතහොත් සියලු අඛණ්ඩ අවකාශයන්ද? දෙවැන්න නම්, නූල් වලට දැනටමත් .strip()ක්‍රමයක් තිබේ:

>>> ' Hello '.strip()
'Hello'
>>> ' Hello'.strip()
'Hello'
>>> 'Bob has a cat'.strip()
'Bob has a cat'
>>> '   Hello   '.strip()  # ALL consecutive spaces at both ends removed
'Hello'

කෙසේ වෙතත් ඔබට අවශ්‍ය වන්නේ එක් ඉඩක් පමණක් ඉවත් කිරීමට නම්, ඔබට එය කළ හැක්කේ:

def strip_one_space(s):
    if s.endswith(" "): s = s[:-1]
    if s.startswith(" "): s = s[1:]
    return s

>>> strip_one_space("   Hello ")
'  Hello'

එසේම, str.strip()වෙනත් හිස් අවකාශ අක්ෂරද ඉවත් කරන බව සලකන්න (උදා: ටැබ් සහ නව රේඛා). අවකාශයන් පමණක් ඉවත් කිරීමට, ඔබට තර්කයක් ලෙස ඉවත් කිරීමට අක්‍ෂරය නියම කළ හැකිය strip, එනම්:

>>> "  Hello\n".strip(" ")
'Hello\n'

ඉහත පිළිතුරු වලින් පෙන්වා ඇති පරිදි

myString.strip()

\ n, \ r, \ t, \ f, අවකාශය වැනි ප්‍රමුඛ හා පසුපස සුදු පැහැති අක්ෂර ඉවත් කරයි.

වැඩි නම්යතාවයක් සඳහා පහත සඳහන් දෑ භාවිතා කරන්න

• ප්‍රමුඛ සුදු අවකාශ අක්ෂර පමණක් ඉවත් කරයි :myString.lstrip()
• , පලවා හරින පමණක් අවර whitespace chars:myString.rstrip()
• ඉවත් විශේෂිත whitespace chars: myString.strip('\n')හෝ myString.lstrip('\n\r')හෝ myString.rstrip('\n\t')සහ එසේ මත.

වැඩි විස්තර ලබා ගත හැකි වේ ලේඛන

strip හිස් අවකාශ අක්ෂරවලට පමණක් සීමා නොවේ:

# remove all leading/trailing commas, periods and hyphens
title = title.strip(',.-')

මෙම ඉවත් කරනු ඇත සියලු ප්රමුඛ පෙළේ හා අවර whitespace myString:

myString.strip()

ඔබට තීරුව අවශ්‍යයි ():

myphrases = [ " Hello ", " Hello", "Hello ", "Bob has a cat" ]

for phrase in myphrases:
    print phrase.strip()

ආරම්භකයකු ලෙස මෙම නූල දැකීමෙන් මගේ හිස කැරකෙමින් තිබේ. එබැවින් සරල කෙටිමඟක් ඉදිරිපත් විය.

ප්‍රමුඛ හා පසුපස අවකාශ ඉවත් කිරීමට str.strip () ක්‍රියා කළද එය අක්ෂර අතර ඇති අවකාශ සඳහා කිසිවක් නොකරයි.

words=input("Enter the word to test")
# If I have a user enter discontinous threads it becomes a problem
# input = "   he llo, ho w are y ou  "
n=words.strip()
print(n)
# output "he llo, ho w are y ou" - only leading & trailing spaces are removed 

ඒ වෙනුවට str.replace () භාවිතා කර වැඩි අර්ථයක් සහ අඩු දෝෂයක් සහ වැඩි යමක් කිරීමට. පහත දැක්වෙන කේතයට str.replace () භාවිතය සාමාන්‍යකරණය කළ හැකිය

def whitespace(words):
    r=words.replace(' ','') # removes all whitespace
    n=r.replace(',','|') # other uses of replace
    return n
def run():
    words=input("Enter the word to test") # take user input
    m=whitespace(words) #encase the def in run() to imporve usability on various functions
    o=m.count('f') # for testing
    return m,o
print(run())
output- ('hello|howareyou', 0)

එකම වෙනසකින් උරුම වන අතරම ප්‍රයෝජනවත් විය හැකිය. කාර්යයන්.

ඔබේ නිමි කේතය හෝ වැඩසටහන් පයිටන් තුළ ක්‍රියාත්මක කිරීමේදී බොහෝ දෝෂ සහිත දෝෂ ඇති කරන "වයිට්ස්පේස්" ඉවත් කිරීම සඳහා. පහත දැක්වෙන දේ කරන්න; පැහැදිලිවම 1,2,3,4,5 පේළියේ දෝෂ (ය) ඉන්ඩෙන්ටේෂන් බව පයිතන් නොකඩවා පැවසුවහොත් ... එම රේඛාව ඉදිරියට සහ පසුපසට සවි කරන්න.

කෙසේ වෙතත්, යතුරු ලියනය කිරීමේ වැරදි, ක්‍රියාකරුවන් යනාදිය සම්බන්ධ වැඩසටහන පිළිබඳ ඔබට තවමත් ගැටළු තිබේ නම්, පයිතන් ඔබට කෑගැසීමට හේතුව කියවීමට වග බලා ගන්න:

පරීක්ෂා කළ යුතු පළමු දෙය නම් ඔබේ ඉන්ඩෙන්ටේෂන් අයිතිය ඔබට තිබීමයි. ඔබ එසේ කරන්නේ නම්, ඔබේ කේතයේ ඇති අවකාශයන් සමඟ මිශ්‍ර ටැබ් තිබේදැයි පරීක්ෂා කරන්න.

මතක තබා ගන්න: කේතය හොඳින් පෙනෙනු ඇත (ඔබට), නමුත් පරිවර්තකය එය ක්‍රියාත්මක කිරීම ප්‍රතික්ෂේප කරයි. ඔබ මෙය සැක කරන්නේ නම්, ඉක්මන් විසඳුමක් වන්නේ ඔබේ කේතය IDLE සංස්කරණ කවුළුවකට ගෙන ඒමයි, ඉන්පසු සංස්කරණය කරන්න ... "ආකෘතිය තේරීමට පෙර මෙනු පද්ධතියෙන් සියල්ල තෝරන්න ..." කලාපය අවලංගු කරන්න. ඔබ අවකාශය සමඟ ටැබ් මිශ්‍ර කර ඇත්නම්, මෙය ඔබගේ සියලු ටැබ් එකවර අවකාශයන් බවට පරිවර්තනය කරයි (සහ ඕනෑම ඉන්ඩෙන්ටේෂන් ගැටළු විසඳන්න).

නූලක ඇති ඕනෑවට වඩා ඉඩ ඉවත් කිරීමට මට අවශ්‍ය විය (නූල් අතර, ආරම්භයේ හෝ අවසානයේ පමණක් නොව). මා මෙය සෑදුවේ වෙනත් ආකාරයකින් එය කරන්නේ කෙසේදැයි මා නොදන්නා බැවිනි:

string = "Name : David         Account: 1234             Another thing: something  " 

ready = False
while ready == False:
    pos = string.find("  ")
    if pos != -1:
       string = string.replace("  "," ")
    else:
       ready = True
print(string)

ඔබට තවත් ද්විත්ව අවකාශයක් නොමැති තෙක් මෙය එක් අවකාශයක ද්විත්ව අවකාශයන් ප්‍රතිස්ථාපනය කරයි

මා සොයන දෙයට විසඳුමක් සොයා ගැනීමට නොහැකි වූ නිසා මම අභිරුචි කාර්යයන් කිහිපයක් නිර්මාණය කළෙමි. ඔබට ඒවා අත්හදා බැලිය හැකිය.

def cleansed(s: str):
    """:param s: String to be cleansed"""
    assert s is not (None or "")
    # return trimmed(s.replace('"', '').replace("'", ""))
    return trimmed(s)


def trimmed(s: str):
    """:param s: String to be cleansed"""
    assert s is not (None or "")
    ss = trim_start_and_end(s).replace('  ', ' ')
    while '  ' in ss:
        ss = ss.replace('  ', ' ')
    return ss


def trim_start_and_end(s: str):
    """:param s: String to be cleansed"""
    assert s is not (None or "")
    return trim_start(trim_end(s))


def trim_start(s: str):
    """:param s: String to be cleansed"""
    assert s is not (None or "")
    chars = []
    for c in s:
        if c is not ' ' or len(chars) > 0:
            chars.append(c)
    return "".join(chars).lower()


def trim_end(s: str):
    """:param s: String to be cleansed"""
    assert s is not (None or "")
    chars = []
    for c in reversed(s):
        if c is not ' ' or len(chars) > 0:
            chars.append(c)
    return "".join(reversed(chars)).lower()


s1 = '  b Beer '
s2 = 'Beer  b    '
s3 = '      Beer  b    '
s4 = '  bread butter    Beer  b    '

cdd = trim_start(s1)
cddd = trim_end(s2)
clean1 = cleansed(s3)
clean2 = cleansed(s4)

print("\nStr: {0} Len: {1} Cleansed: {2} Len: {3}".format(s1, len(s1), cdd, len(cdd)))
print("\nStr: {0} Len: {1} Cleansed: {2} Len: {3}".format(s2, len(s2), cddd, len(cddd)))
print("\nStr: {0} Len: {1} Cleansed: {2} Len: {3}".format(s3, len(s3), clean1, len(clean1)))
print("\nStr: {0} Len: {1} Cleansed: {2} Len: {3}".format(s4, len(s4), clean2, len(clean2)))

ඔබට වමේ සහ දකුණේ සිට නිශ්චිත ඉඩ ප්‍රමාණයක් කැපීමට අවශ්‍ය නම් , ඔබට මෙය කළ හැකිය:

def remove_outer_spaces(text, num_of_leading, num_of_trailing):
    text = list(text)
    for i in range(num_of_leading):
        if text[i] == " ":
            text[i] = ""
        else:
            break

    for i in range(1, num_of_trailing+1):
        if text[-i] == " ":
            text[-i] = ""
        else:
            break
    return ''.join(text)

txt1 = "   MY name is     "
print(remove_outer_spaces(txt1, 1, 1))  # result is: "  MY name is    "
print(remove_outer_spaces(txt1, 2, 3))  # result is: " MY name is  "
print(remove_outer_spaces(txt1, 6, 8))  # result is: "MY name is"

මෙය සාමාන්‍ය ප්‍රකාශනයකින් ද කළ හැකිය

import re

input  = " Hello "
output = re.sub(r'^\s+|\s+$', '', input)
# output = 'Hello'

පයිතන්හි ඇති නූලකින් ප්‍රමුඛ හා පසුපස සුදු අවකාශය ඉවත් කරන්නේ කෙසේද?

එබැවින් පහත විසඳුම මඟින් ප්‍රමුඛ හා පසුපස සුදු අවකාශයන් මෙන්ම අතරමැදි සුදු අවකාශයන් ද ඉවත් කරනු ඇත. බහුවිධ හිස් අවකාශයකින් තොරව ඔබට පැහැදිලි නූල් අගයන් ලබා ගැනීමට අවශ්‍ය නම් වැනි.

>>> str_1 = '     Hello World'
>>> print(' '.join(str_1.split()))
Hello World
>>>
>>>
>>> str_2 = '     Hello      World'
>>> print(' '.join(str_2.split()))
Hello World
>>>
>>>
>>> str_3 = 'Hello World     '
>>> print(' '.join(str_3.split()))
Hello World
>>>
>>>
>>> str_4 = 'Hello      World     '
>>> print(' '.join(str_4.split()))
Hello World
>>>
>>>
>>> str_5 = '     Hello World     '
>>> print(' '.join(str_5.split()))
Hello World
>>>
>>>
>>> str_6 = '     Hello      World     '
>>> print(' '.join(str_6.split()))
Hello World
>>>
>>>
>>> str_7 = 'Hello World'
>>> print(' '.join(str_7.split()))
Hello World

ඔබට පෙනෙන පරිදි මෙය නූලෙහි ඇති බහු අවකාශයන් ඉවත් කරයි (ප්‍රතිදානය Hello Worldසියල්ලන්ටම වේ). ස්ථානය වැදගත් නැත. නමුත් ඔබට සැබවින්ම ප්‍රමුඛ හා පසුපස සුදු අවකාශ අවශ්‍ය නම්, එවිට strip()සොයා ගනු ඇත.