పైథాన్ స్ట్రింగ్ స్వాప్‌కేస్() పద్ధతి

పైథాన్ స్ట్రింగ్ “swapcase()” పద్ధతిని ఉపయోగించి పెద్ద అక్షరాలు చిన్న అక్షరానికి మార్చబడతాయి, అయితే చిన్న అక్షరాలు పెద్ద అక్షరానికి మార్చబడతాయి. ఈ ఫంక్షన్ స్ట్రింగ్‌లోని ఏవైనా చిహ్నాలు లేదా సంఖ్యలను విస్మరిస్తుంది.

ఉదాహరణ 1: పైథాన్‌లో పైథాన్ స్ట్రింగ్ స్వాప్‌కేస్() పద్ధతిని ఉపయోగించడం

ఈ ప్రదర్శనలో, చిన్న అక్షరాలు క్యాపిటల్ క్యారెక్టర్‌లుగా మార్చబడతాయి మరియు పైథాన్ భాష యొక్క “స్వాప్‌కేస్()” పద్ధతిని ఉపయోగిస్తాయి. క్యాపిటల్ మరియు లోయర్ రైటింగ్ స్టైల్స్‌లో రెండు ఏకకాల అక్షరాల సెట్‌లు ఉపయోగించబడతాయి మరియు ఒక సెట్‌లోని ప్రతి అక్షరం సాధారణంగా మరొకదానిలో సమానమైనదాన్ని కలిగి ఉంటుంది. 'A' వంటి పెద్ద అక్షరాలు, పెద్ద అక్షరాలు కాకుండా, చిన్న అక్షరాలు 'a' వంటి చిన్న, తక్కువ సమానమైన అక్షరాలు. పైథాన్ స్ట్రింగ్‌లోని అక్షరాల కేస్‌ను మార్చడానికి “swapcase()” ఫంక్షన్‌ను అందిస్తుంది. పైథాన్ యొక్క “స్వాప్‌కేస్()” ఫంక్షన్ అన్ని కేస్-సెన్సిటివ్ క్యారెక్టర్‌ల కేసుల స్విచ్‌తో స్ట్రింగ్ కాపీని ఉత్పత్తి చేస్తుంది.

మొదటి విలువను చూడటం ద్వారా కోడ్‌ని ప్రారంభిద్దాం, ఇది 'ఆమె అరటిపండ్లను ఇష్టపడుతుంది' అనే వచనంతో కూడిన స్ట్రింగ్ విలువ, మీరు దిగువ చిత్రంలో చూడగలరు, ఈ విలువలో ఉపయోగించిన ప్రతి అక్షరం పెద్ద అక్షరంతో ఉంటుంది. ఈ స్ట్రింగ్ విలువ 'string1' వేరియబుల్‌లో నిల్వ చేయబడుతుంది, ఇది మేము ముందుగా ప్రారంభించాము. దానిని అనుసరించి, మేము 'string1' పరామితితో 'swapcase()' అని పిలుస్తాము ఎందుకంటే ఈ 'string1' స్ట్రింగ్ విలువను కలిగి ఉంటుంది. ఈ పద్ధతి కొత్త స్ట్రింగ్‌ను కలిగి ఉన్న అవుట్‌పుట్‌ను అందిస్తుంది, దీనిలో స్ట్రింగ్ విలువలో చేర్చబడిన అన్ని పెద్ద-కేస్ అక్షరాలు చిన్న అక్షరాలకు మార్చబడతాయి. “swapcase()” పద్ధతి యొక్క ఫలితం ప్రారంభించబడిన వేరియబుల్ “ఫలితం”లో నిల్వ చేయబడుతుంది.

అప్పుడు మేము 'ప్రింట్()' ఫంక్షన్‌ని పిలుస్తాము, కుండలీకరణాల మధ్య 'ఫలితం' అనే వాదనను పాస్ చేస్తాము, ఎందుకంటే ఫలితం అక్కడ ఉంచబడుతుంది మరియు మేము దానిని ప్రదర్శించాలనుకుంటున్నాము.

ఇది అవుట్‌పుట్‌ను ప్రదర్శిస్తుంది, ఇందులో అసలైన స్ట్రింగ్‌లోని అన్ని అక్షరాలు చిన్న అక్షరానికి మార్చబడిన కొత్త స్ట్రింగ్‌ను కలిగి ఉంటుంది. 'ఆమె అరటిపండ్లను ఇష్టపడుతుంది' అనేది ప్రదర్శించబడే విలువ.

స్క్రిప్ట్ యొక్క రెండవ భాగంలో, మేము చిన్న అక్షరాన్ని పెద్ద అక్షరానికి మారుస్తాము. మేము చివరి విభాగంలో పెద్ద అక్షరాలను చిన్న అక్షరాలకు మార్చాము తప్ప, ఈ విభాగం మునుపటి మాదిరిగానే ఉంటుంది. ఫలితంగా, చిన్న అక్షరాలతో కూడిన అన్ని అంశాలతో సహా మేము కొత్త స్ట్రింగ్‌ని పొందాము. ఇప్పుడు పరిస్థితి తారుమారైంది కాబట్టి కోడ్‌ని ప్రారంభిద్దాం. స్ట్రింగ్ విలువ 'నేను నా పెంపుడు జంతువులను ప్రేమిస్తున్నాను'; మీరు గమనిస్తే, అన్ని పదాలు చిన్న అక్షరాలతో వ్రాయబడ్డాయి. ఈ విలువ సృష్టించబడిన వేరియబుల్ “string1”లో సేవ్ చేయబడుతోంది. స్ట్రింగ్ “swapcase()” పద్ధతి తర్వాత పంక్తిలో ఉపయోగించబడుతుంది మరియు దాని పరామితి, వేరియబుల్ “string2” పాస్ చేయబడింది ఎందుకంటే ఇది స్ట్రింగ్ విలువను కలిగి ఉంటుంది. 'ప్రింట్()' ఫంక్షన్ అప్పుడు ప్రారంభించబడుతుంది మరియు దానికి 'ఫలితం' ఆర్గ్యుమెంట్ అందించబడుతుంది ఎందుకంటే ఇది 'swapcase()' పద్ధతి యొక్క అంతిమ ఫలితాన్ని కలిగి ఉంటుంది.

మేము మునుపటి కోడ్‌లోని స్ట్రింగ్ విలువలోని అన్ని చిన్న అక్షరాలను ఉపయోగించాము కాబట్టి, దిగువ చిత్రంలో చూసినట్లుగా, “swapcase()” వాటిని అన్నింటినీ పెద్ద అక్షరాలుగా మారుస్తుంది. కొత్త స్ట్రింగ్ ప్రదర్శించబడుతుంది, దీనిలో స్ట్రింగ్ విలువలో ఉన్న ప్రతి అక్షరం ఇప్పుడు పెద్ద అక్షరాలలో ఉంది మరియు ఒక్క అక్షరం కూడా చిన్న అక్షరాలలో లేదు.

కోడ్ యొక్క మూడవ విభాగంలో, మేము ఒకే సమయంలో పెద్ద మరియు చిన్న అక్షరాలను మారుస్తాము. మొదటి రెండు విభాగాలలో, మేము మొదట స్ట్రింగ్ విలువను చిన్న అక్షరానికి మార్చాము మరియు రెండవది, మేము దానిని పెద్ద అక్షరానికి మార్చాము. అయితే, ఈ విభాగంలో, మేము దీన్ని కలిసి చేస్తాము. మేము స్ట్రింగ్ విలువను తీసుకుంటాము, దీనిలో మేము కొన్ని పెద్ద అక్షరాలు మరియు కొన్ని చిన్న అక్షరాలను తీసుకుంటాము మరియు దానిలో “swapcase()”ని వర్తింపజేస్తాము. ఇది మీకు చిన్న అక్షరాలు పెద్ద అక్షరాలలో మరియు పెద్ద అక్షరాలు చిన్న అక్షరాలలో కనిపించే స్ట్రింగ్‌ను మీకు అందిస్తుంది.

'sHE lOvE play wItH DoGs' అనే స్ట్రింగ్ విలువను సృష్టించి, దానిని 'string3' వేరియబుల్‌కు కేటాయించడం ద్వారా కోడ్‌ను ప్రారంభిద్దాం. ఈ స్ట్రింగ్ విలువ చిన్న మరియు పెద్ద అక్షరాలు రెండింటినీ కలిగి ఉంటుంది. దానిని అనుసరించి, మేము “swapcase()” పద్ధతిని ఉపయోగిస్తాము మరియు “string3” పరామితిని పాస్ చేస్తాము ఎందుకంటే మేము ఇప్పటికే స్ట్రింగ్ విలువను అందులో సేవ్ చేసాము. అప్పుడు, ఫలితం అక్కడ సేవ్ చేయబడినందున మరియు మేము దానిని ప్రదర్శించాలనుకుంటున్నాము, మేము 'ప్రింట్ ()' ఫంక్షన్ అని పిలుస్తాము, ఆర్గ్యుమెంట్ 'ఫలితం' ను పాస్ చేస్తాము.

స్ట్రింగ్‌లోని పెద్ద అక్షరాలు అవుట్‌పుట్‌లో పెద్ద అక్షరానికి రూపాంతరం చెందుతాయి మరియు స్ట్రింగ్ మూలకాలలో ఉన్న పెద్ద అక్షరాలు చిన్న అక్షరానికి మార్చబడతాయి.

ఉదాహరణ 2: పైథాన్ స్ట్రింగ్ స్వాప్‌కేస్() పద్ధతిని అదనపు క్యారెక్టర్ రకాలతో అమలు చేయడం

పైథాన్ స్ట్రింగ్ వివిధ అక్షర రకాలు “swapcase()” పద్ధతిని విస్మరిస్తుంది. ప్రస్తుత స్ట్రింగ్‌లో అనేక అక్షర రకాలు ఉంటే, “swapcase()” పద్ధతి వాటిని విస్మరిస్తుంది మరియు అక్షర అక్షరాలను మాత్రమే తగిన సందర్భంలో మారుస్తుంది.

మేము కోడ్ యొక్క స్ట్రింగ్ విలువ విభాగంలో అక్షర రకం మరియు సంఖ్యా రకం అక్షరాలను ఉపయోగిస్తాము. కోడ్‌ను అమలు చేయడం ద్వారా ప్రారంభిద్దాం. స్ట్రింగ్ విలువ “నా రోల్ నంబర్ 161068” వేరియబుల్ “str1”లో నిల్వ చేయబడుతుంది. ఈ విలువలో రెండు అక్షర రకాలు ఉన్నాయి, చూడవచ్చు. తరువాత, కింది పంక్తిలో, మేము 'str1'తో 'swapcase()' పద్ధతిని వర్తింపజేస్తాము, ఇది స్ట్రింగ్ విలువను నిల్వ చేస్తుంది కాబట్టి మేము పారామీటర్‌గా ఇచ్చాము. మేము స్ట్రింగ్ 'swapcase()' పద్ధతిని ఉపయోగించడం యొక్క ఫలితాన్ని కలిగి ఉన్న 'ఫలితం' అనే వేరియబుల్‌ని కలిగి ఉన్నాము. ప్రింట్() ఫంక్షన్ ఫలితాన్ని ప్రదర్శించడానికి ఉపయోగించబడుతుంది. ఇది ఈ ఫంక్షన్ యొక్క కుండలీకరణాల్లో 'ఫలితం' అనే వాదనతో పిలువబడుతుంది.

స్ట్రింగ్‌లోని మూలకం మార్చబడిన కొత్త స్ట్రింగ్‌ను అవుట్‌పుట్ చూపుతుంది, పెద్ద అక్షరం అక్షరాలు చిన్న అక్షరానికి మార్చబడ్డాయి మరియు చిన్న అక్షరాలు పెద్ద అక్షరానికి మార్చబడ్డాయి. అయినప్పటికీ, స్ట్రింగ్ యొక్క సంఖ్యా అక్షరం, “161068” మార్చబడలేదు ఎందుకంటే ఈ పద్ధతి ఇతర అక్షరాల రకాలను మార్చదు.

మేము కోడ్ యొక్క మునుపటి విభాగంలోని స్ట్రింగ్‌లోని సంఖ్యా అక్షరాన్ని ఎలా ఉపయోగించామో అదే విధంగా, మేము ఈ కోడ్ విభాగంలోని స్ట్రింగ్ విలువలోని చిహ్నాలు, సంఖ్యలు మరియు అక్షరాలను ఉపయోగిస్తున్నాము. అయినప్పటికీ, మేము గుర్తులు, సంఖ్యలు లేదా అక్షరాలకు ఎటువంటి మార్పు లేకుండా నిర్ధారిస్తాము ఎందుకంటే ఫంక్షన్ వాటిని విస్మరిస్తుంది. పాత్రల విషయంలో మాత్రమే మార్పు ఉంటుంది.

మేము సృష్టించిన వేరియబుల్ “str1”లో “అలెక్స్‌కు 79% మార్కులు వచ్చాయి మరియు నోహ్ వారి పరీక్షలో 98% మార్కులు పొందారు” అనే స్ట్రింగ్ విలువను నిల్వ చేసే కోడ్‌ను వ్రాయడం ద్వారా ప్రారంభించండి. 'swapcase()' పద్ధతి తరువాత పంక్తిలో 'str1' పరామితితో ఉపయోగించబడుతుంది. తరువాత, కింది పంక్తిలో, మేము 'ప్రింట్()' ఫంక్షన్‌ని పిలుస్తాము, వేరియబుల్ 'ఫలితం'ని ఆర్గ్యుమెంట్‌గా అందజేస్తాము ఎందుకంటే మేము దానిలోని “swapcase()” పద్ధతిని ఉపయోగించి ఫలితాన్ని గతంలో సేవ్ చేసాము.

ఈ విధానం ఇతర అక్షర రకాన్ని విస్మరించినందున ఇది సంఖ్య లేదా '%' చిహ్నాన్ని ప్రభావితం చేయలేదు. ఉదాహరణలో వలె, చిన్న అక్షరాలు పెద్ద అక్షరంగా రూపాంతరం చెందుతాయి మరియు పెద్ద అక్షరాలు చిన్న అక్షరాలుగా మార్చబడతాయి.

ముగింపు

పైథాన్‌లో పనిచేసేటప్పుడు అక్షరాలను మార్చుకోవడం ఒక ఉపయోగకరమైన టెక్నిక్. మొదటి ఉదాహరణ కోసం, మేము పెద్ద అక్షరాన్ని చిన్న అక్షరంగా మార్చాము మరియు దీనికి విరుద్ధంగా. రెండవ ఉదాహరణలో, మేము ఈ పద్ధతిని ఇతర అక్షరాల రకాలతో ఉపయోగించాము ఎందుకంటే ఈ పద్ధతి సంఖ్యలు మరియు చిహ్నాలను విస్మరిస్తుంది. అందువల్ల, ఇది అక్షర అక్షరాల విషయంలో తప్ప మరేదైనా మార్చలేదు.