స్ట్రిప్ పద్ధతిలో ఐచ్ఛిక పరామితి ఉంది. ఈ పరామితి విస్మరించబడినప్పుడు, ఈ పద్ధతి స్ట్రింగ్ డేటా నుండి ప్రారంభ మరియు ముగింపు నుండి ఖాళీని తొలగిస్తుంది. కానీ మీరు స్ట్రింగ్ యొక్క ప్రారంభ మరియు ముగింపు నుండి నిర్దిష్ట అక్షరాన్ని తీసివేయాలనుకుంటే, మీరు పద్ధతి కోసం అక్షరాన్ని ఆర్గ్యుమెంట్ విలువగా సెట్ చేయాలి. స్ట్రింగ్ నుండి నిర్దిష్ట అక్షరాలను తీసివేసిన తర్వాత ఇది ప్రధాన స్ట్రింగ్ విలువను అందిస్తుంది. పైథాన్‌లో స్ట్రిప్ పద్ధతి యొక్క వివిధ ఉపయోగాలు క్రింది ఉదాహరణలో చూపబడ్డాయి.
ఉదాహరణ -1: ఖాళీని తొలగించడానికి స్ట్రిప్ పద్ధతిని ఉపయోగించండి
కింది స్క్రిప్ట్ వాదన లేకుండా స్ట్రిప్ పద్ధతిని ఉపయోగించడాన్ని చూపుతుంది. ఇక్కడ, రెండు వేరియబుల్స్ పేరు పెట్టబడ్డాయి వినియోగదారు పేరు మరియు పాస్వర్డ్ నిర్వచించబడ్డాయి. వినియోగదారు పేరు విలువ ప్రారంభంలో స్థలాన్ని కలిగి ఉంటుంది మరియు పాస్వర్డ్ విలువ ముగింపులో స్థలాన్ని కలిగి ఉంటుంది. మొదటి లో ఉంటే స్టేట్‌మెంట్, వేరియబుల్స్ విలువలు విలువలు నుండి ఖాళీని తీసివేయకుండా సరిపోల్చబడతాయి మరియు అది తప్పుగా తిరిగి వస్తుంది. రెండవ if స్టేట్‌మెంట్‌లో, స్ట్రిప్ () పద్ధతి వేరియబుల్స్‌తో విలువలు నుండి ఏదైనా ప్రారంభ మరియు ముగింపు ఖాళీలను తీసివేయడానికి ఉపయోగించబడుతుంది.
#!/usr/bin/env పైథాన్ 3
# ప్రారంభ మరియు ముగింపు స్థలంతో రెండు స్ట్రింగ్ విలువలను నిర్వచించండి
వినియోగదారు పేరు= ' అడ్మిన్'
పాస్వర్డ్= 'హలో 123'
# ఖాళీని తీసివేయకుండా తీగలను సరిపోల్చండి
ముద్రణ('స్ట్రిప్ పద్ధతి లేకుండా అవుట్పుట్:')
ఉంటే(వినియోగదారు పేరు== 'అడ్మిన్' మరియుపాస్వర్డ్== 'హలో 123'):
ముద్రణ('ధృవీకరించబడిన వినియోగదారు n')
లేకపోతే:
ముద్రణ('ప్రమాణీకరించబడని వినియోగదారు n')
# ఖాళీని తీసివేయడం ద్వారా తీగలను సరిపోల్చండి
ముద్రణ('స్ట్రిప్ పద్ధతితో అవుట్పుట్:')
ఉంటే(వినియోగదారు పేరుస్ట్రిప్() == 'అడ్మిన్' మరియుపాస్వర్డ్స్ట్రిప్() == 'హలో 123'):
ముద్రణ('ధృవీకరించబడిన వినియోగదారు')
లేకపోతే:
ముద్రణ('ప్రమాణీకరించబడని వినియోగదారు')
అవుట్పుట్:
మొదటి అవుట్పుట్ ' ప్రామాణీకరించబడని వినియోగదారు ' మరియు రెండవ అవుట్పుట్ ' ప్రామాణీకరించబడిన వినియోగదారు '.
ఉదాహరణ -2: నిర్దిష్ట అక్షరాన్ని తొలగించడానికి స్ట్రిప్ పద్ధతిని ఉపయోగించండి
మీరు స్ట్రింగ్ విలువ నుండి నిర్దిష్ట అక్షరాన్ని తొలగించాలనుకుంటే, మీరు స్ట్రిప్ పద్ధతి యొక్క ఐచ్ఛిక వాదనను ఉపయోగించాలి. కింది స్క్రిప్ట్ స్ట్రిప్ పద్ధతి యొక్క ఐచ్ఛిక వాదన యొక్క ఉపయోగాన్ని చూపుతుంది. స్ట్రింగ్ విలువ ఇన్‌పుట్‌గా తీసుకోబడుతుంది మరియు పేరున్న వేరియబుల్‌లో నిల్వ చేయబడుతుంది స్ట్రింగ్ 1 మరియు ఒక అక్షరం ఇన్‌పుట్‌గా తీసుకోబడుతుంది మరియు పేరున్న వేరియబుల్‌లో నిల్వ చేయబడుతుంది చార్ 1 . తరువాత, చార్ 1 స్ట్రిప్ పద్ధతిలో వాదనగా ఉపయోగించబడుతుంది. విలువ ఉంటే చార్ 1 లో ఒకటి లేదా అనేక సార్లు ఉంది స్ట్రింగ్ 1 ప్రారంభంలో లేదా ముగింపులో ఆ అక్షరాలు తీసివేయబడతాయి మరియు కొత్త వేరియబుల్‌లో కొత్త విలువను నిల్వ చేస్తాయి, న్యూస్ట్రింగ్ . అసలు స్ట్రింగ్ మారదు.
#!/usr/bin/env పైథాన్ 3
# స్ట్రింగ్ డేటాను ఇన్‌పుట్‌గా తీసుకోండి
స్ట్రింగ్ 1= ఇన్పుట్('స్ట్రింగ్‌ని నమోదు చేయండి n')
# అక్షర డేటాను ఇన్‌పుట్‌గా తీసుకోండి
చార్ 1= ఇన్పుట్(స్ట్రింగ్ నుండి తీసివేయడానికి అక్షరాన్ని నమోదు చేయండి n')
# స్ట్రింగ్ డేటా యొక్క రెండు వైపుల నుండి అక్షరాన్ని తొలగించండి
న్యూస్ట్రింగ్=స్ట్రింగ్ 1.స్ట్రిప్(చార్ 1)
# అసలు స్ట్రింగ్‌ను ముద్రించండి
ముద్రణ('అసలు స్ట్రింగ్: n%s '%స్ట్రింగ్ 1)
# స్ట్రిప్పింగ్ తర్వాత స్ట్రింగ్‌ను ప్రింట్ చేయండి
ముద్రణ(స్ట్రింగ్ నుండి '%c' తీసివేసిన తర్వాత అవుట్పుట్: n%s '%(చార్ 1,న్యూస్ట్రింగ్))
అవుట్పుట్:
స్క్రిప్ట్ రన్ చేయండి. ఇక్కడ, ' $$$ పైథాన్ ఒక ఉన్నత స్థాయి భాష $$ ' అవుట్‌పుట్‌లో ఇన్పుట్ స్ట్రింగ్‌గా తీసుకోబడింది మరియు '$' ఒక అక్షరాన్ని తీసివేసినట్లుగా తీసుకోబడింది. స్ట్రిప్ () పద్ధతి అన్నింటినీ తీసివేస్తుంది '$' ఇన్పుట్ స్ట్రింగ్ ప్రారంభం మరియు ముగింపు నుండి.
ఉదాహరణ -3: బహుళ అక్షరాలను తొలగించడానికి స్ట్రిప్ ఉపయోగించండి
మునుపటి రెండు ఉదాహరణలు స్ట్రింగ్ డేటా నుండి ఖాళీని లేదా నిర్దిష్ట అక్షరాన్ని తొలగిస్తాయి. కానీ కొన్నిసార్లు మీరు స్ట్రింగ్ నుండి బహుళ అక్షరాలను తీసివేయవలసి ఉంటుంది. కింది స్క్రిప్ట్ స్ట్రింగ్ విలువ యొక్క రెండు వైపుల నుండి బహుళ అక్షరాలను తీసివేసే మార్గాన్ని చూపుతుంది. స్క్రిప్ట్ ఒక URL చిరునామా మరియు వినియోగదారు నుండి బహుళ అక్షరాలను వేరియబుల్స్‌లో ఇన్పుట్ మరియు స్టోర్‌గా తీసుకుంటుంది, url మరియు చార్లిస్ట్ . ఇక్కడ, వినియోగదారు 'y' లేదా 'Y' నొక్కే వరకు స్క్రిప్ట్‌ని అమలు చేయడానికి అనంతమైన లూప్ ఉపయోగించబడుతుంది. లూప్ యొక్క ప్రతి పునరావృతంలో, ఒరిజినల్ స్ట్రింగ్ మరియు స్ట్రిప్పింగ్ తర్వాత కొత్త స్ట్రింగ్ ముద్రించబడతాయి.
#!/usr/bin/env పైథాన్ 3# అనంతమైన లూప్‌ను నిర్వచించండి
అయితే(నిజమే):
# ఒక URL చిరునామాను ఇన్‌పుట్‌గా తీసుకోండి
url= ఇన్పుట్('URL చిరునామాను నమోదు చేయండి n')
# స్ట్రింగ్ డేటాను ఇన్‌పుట్‌గా తీసుకోండి
చార్లిస్ట్= ఇన్పుట్('తీసివేయడానికి అక్షరాలను నమోదు చేయండి n')
స్ట్రింగ్ డేటా యొక్క రెండు వైపుల నుండి అక్షరాన్ని తీసివేయండి
ఎక్కడ మ్యాచ్ అవుతుంది ''
న్యూస్ట్రింగ్=urlస్ట్రిప్(చార్లిస్ట్)
# అసలు స్ట్రింగ్‌ను ముద్రించండి
ముద్రణ('అసలు స్ట్రింగ్: n%s '%url)
# స్ట్రిప్పింగ్ తర్వాత స్ట్రింగ్‌ను ప్రింట్ చేయండి
ముద్రణ(అక్షరాలను తొలగించిన తర్వాత అవుట్పుట్ n%s '% newString)
# స్క్రిప్ట్‌ను కొనసాగించాలా వద్దా అని వినియోగదారుని అడగండి
సమాధానం= ఇన్పుట్('మీరు నిష్క్రమించాలనుకుంటున్నారా (y/n)?')
# సమాధానం 'y' లేదా 'Y' అయితే లూప్‌ను రద్దు చేయండి
ఉంటే (సమాధానం== 'మరియు' లేదాసమాధానం== 'మరియు'):
విరామం
అవుట్పుట్:
అవుట్‌పుట్‌లో, లూప్ రెండుసార్లు పునరావృతమవుతుంది. మొదటి పునరుక్తిలో, బహుళ అక్షరాలు, 'Http: //' ఇన్పుట్ స్ట్రింగ్ యొక్క రెండు వైపుల నుండి శోధించబడుతుంది మరియు తీసివేయబడుతుంది, ' http://www.google.com ' . తరువాత, ' n ' లూప్‌ను కొనసాగించడానికి మరియు స్క్రిప్ట్‌ను మళ్లీ అమలు చేయడానికి ఇన్‌పుట్‌గా నొక్కబడుతుంది. రెండవ పునరావృతంలో, ' www.com ఇన్పుట్ స్ట్రింగ్ నుండి అక్షరాలు శోధించబడతాయి మరియు తీసివేయబడతాయి, www.linuxhint.com . ఇప్పుడు, 'మరియు' అనంతమైన లూప్‌ను ముగించడానికి మరియు స్క్రిప్ట్ నుండి నిష్క్రమించడానికి నొక్కబడుతుంది.
ముగింపు:
స్ట్రింగ్ విలువ యొక్క రెండు వైపుల నుండి ఖాళీ, ఒకే అక్షరం మరియు బహుళ అక్షరాలను తీసివేయడానికి స్ట్రిప్ పద్ధతి యొక్క ఉపయోగం ఈ ట్యుటోరియల్ యొక్క ఉదాహరణలలో చూపబడింది. మీరు స్ట్రింగ్ ప్రారంభం నుండి అక్షరాలను తీసివేయాలనుకుంటే, మీరు ఉపయోగించాల్సి ఉంటుంది స్ట్రిప్ () పద్ధతి, మరియు మీరు స్ట్రింగ్ చివర నుండి అక్షరాలను తీసివేయాలనుకుంటే అప్పుడు మీరు ఉపయోగించాల్సి ఉంటుంది rstrip () పద్ధతి. పైథాన్ స్ట్రింగ్ స్ట్రిప్ పద్ధతిని ఎలా ఉపయోగించాలి
రచయిత వీడియో చూడండి: ఇక్కడ