వాక్యనిర్మాణం:
స్ట్రింగ్.క్యాపిటలైజ్()ఈ పద్ధతి ఎటువంటి వాదనను ఉపయోగించదు మరియు అసలు స్ట్రింగ్ యొక్క కంటెంట్ను సవరించిన తర్వాత ఇది కొత్త స్ట్రింగ్ను అందిస్తుంది. అసలు స్ట్రింగ్ మారదు. పైథాన్లోని వివిధ రకాల డేటాపై ఈ పద్ధతి యొక్క ఉపయోగాలు ఉదాహరణలతో క్రింద వివరించబడ్డాయి.
ఉదాహరణ -1: సాధారణ స్ట్రింగ్లో క్యాపిటలైజ్ పద్ధతిని ఉపయోగించండి
ఉదాహరణలో మూడు విభిన్న రకాల టెక్స్ట్ డేటాలో క్యాపిటలైజ్ () పద్ధతి వర్తించబడుతుంది. మొదట, చిన్న అక్షరంతో ప్రారంభమయ్యే టెక్స్ట్ మార్పిడి కోసం ఉపయోగించబడుతుంది. టెక్స్ట్ యొక్క మొదటి అక్షరం పెద్ద అక్షరం మరియు టెక్స్ట్ యొక్క మిగిలిన అక్షరాలు పెద్ద అక్షరం () పద్ధతి ద్వారా చిన్న అక్షరాలుగా ఉంటాయి. తరువాత, అన్ని పెద్ద అక్షరాలతో కూడిన టెక్స్ట్ మార్పిడి కోసం ఉపయోగించబడుతుంది మరియు సంఖ్యతో మొదలయ్యే టెక్స్ట్ మార్పిడి కోసం ఉపయోగించబడుతుంది.
#!/usr/bin/env పైథాన్ 3
# స్ట్రింగ్ విలువను నిర్వచించండి
myString= 'LinuxHint కి స్వాగతం'
క్యాపిటలైజ్ పద్ధతి ద్వారా స్ట్రింగ్ని మార్చండి
కన్వర్టెడ్ స్ట్రింగ్=myString.క్యాపిటలైజ్()
# అసలు స్ట్రింగ్ను ముద్రించండి
ముద్రణ('మొదటి అసలైన స్ట్రింగ్: %s'%myString)
# కన్వర్టెడ్ స్ట్రింగ్ను ప్రింట్ చేయండి
ముద్రణ('మార్చబడిన మొదటి స్ట్రింగ్: %s n'% కన్వర్టెడ్ స్ట్రింగ్)
# అన్ని పెద్ద అక్షరాలతో స్ట్రింగ్ను నిర్వచించండి
myString2= 'నేను పైథాన్ ప్రోగ్రామింగ్ను ఇష్టపడుతున్నాను'
క్యాపిటలైజ్ పద్ధతి ద్వారా స్ట్రింగ్ని మార్చండి
కన్వర్టెడ్ స్ట్రింగ్ 2=myString2.క్యాపిటలైజ్()
# అసలు స్ట్రింగ్ను ముద్రించండి
ముద్రణ('రెండవ అసలు స్ట్రింగ్: %s'%myString2)
# కన్వర్టెడ్ స్ట్రింగ్ను ప్రింట్ చేయండి
ముద్రణ('రెండవ మార్చబడిన స్ట్రింగ్: %s n'% కన్వర్టెడ్ స్ట్రింగ్ 2)
# సంఖ్యతో ప్రారంభమయ్యే స్ట్రింగ్ను నిర్వచించండి
myString3= '7827 రిడ్వ్యూ కోర్టు సమ్మర్విల్లే, SC 29483'
క్యాపిటలైజ్ పద్ధతి ద్వారా స్ట్రింగ్ని మార్చండి
కన్వర్టెడ్ స్ట్రింగ్ 3=myString3.క్యాపిటలైజ్()
# అసలు స్ట్రింగ్ను ముద్రించండి
ముద్రణ('మూడవ అసలు స్ట్రింగ్: %s'%myString3)
# కన్వర్టెడ్ స్ట్రింగ్ను ప్రింట్ చేయండి
ముద్రణ('మార్చబడిన మూడవ స్ట్రింగ్: %s n'% కన్వర్టెడ్ స్ట్రింగ్ 3)
అవుట్పుట్:
స్క్రిప్ట్ అమలు చేసిన తర్వాత కింది అవుట్పుట్ కనిపిస్తుంది.
ఉదాహరణ -2: స్ట్రింగ్ యొక్క ప్రతి పదాన్ని పెద్ద అక్షరంగా మార్చడానికి క్యాపిటలైజ్ పద్ధతిని ఉపయోగించండి
టెక్స్ట్లోని ప్రతి పదం యొక్క మొదటి అక్షరం ఎలా పెద్ద అక్షరం కాగలదో కింది ఉదాహరణలో చూపబడింది. మొదట, బహుళ పదాల టెక్స్ట్ విలువ వినియోగదారు నుండి ఇన్పుట్గా తీసుకోబడుతుంది. స్ప్లిట్ () పద్ధతిని ఉపయోగించి ఏదైనా టెక్స్ట్ విలువను సబ్స్ట్రింగ్గా విభజించవచ్చు. స్ప్లిట్ () పద్ధతి టెక్స్ట్ను స్పేస్ ఆధారంగా విభజించడానికి మరియు పదాల జాబితాను తిరిగి ఇవ్వడానికి ఇక్కడ ఉపయోగించబడుతుంది. మార్చబడిన వచనాన్ని నిల్వ చేయడానికి newString వేరియబుల్ ఇక్కడ ఉపయోగించబడుతుంది. జాబితాలోని ప్రతి అంశాన్ని చదవడానికి మరియు ప్రతి వస్తువులోని మొదటి అక్షరాన్ని క్యాపిటలైజ్ చేయడానికి మరియు మార్చిన విలువను న్యూస్ట్రింగ్లో నిల్వ చేయడానికి లూప్ ఉపయోగించబడుతుంది. కావలసిన అవుట్పుట్ను రూపొందించడానికి న్యూస్ట్రింగ్ యొక్క మునుపటి విలువ కొత్త విలువతో కలిపి ఉంటుంది. తరువాత, అసలైన టెక్స్ట్ మరియు కన్వర్టెడ్ టెక్స్ట్ రెండూ తేడాను చూడటానికి ప్రింట్ చేయబడతాయి.
#!/usr/bin/env పైథాన్ 3
# స్ట్రింగ్ ఇన్పుట్ తీసుకోండి
టెక్స్ట్= ఇన్పుట్('వచనాన్ని నమోదు చేయండి n')
# స్పేస్ ఆధారంగా వచనాన్ని విభజించండి
strList=టెక్స్ట్విభజన()
# కన్వర్టెడ్ స్ట్రింగ్ను నిల్వ చేయడానికి వేరియబుల్ను నిర్వచించండి
న్యూస్ట్రింగ్= ''
# జాబితాను పునరావృతం చేయండి
కోసంగంటలులోstrList:
# ప్రతి జాబితా అంశాన్ని క్యాపిటలైజ్ చేయండి మరియు విలీనం చేయండి
న్యూస్ట్రింగ్ +=గంటలుక్యాపిటలైజ్()+''
# అసలు స్ట్రింగ్ను ముద్రించండి
ముద్రణ('అసలు స్ట్రింగ్: %s'%టెక్స్ట్)
# కన్వర్టెడ్ స్ట్రింగ్ను ప్రింట్ చేయండి
ముద్రణ(మార్చబడిన స్ట్రింగ్: %s n'% newString)
అవుట్పుట్:
కింది అవుట్పుట్లో, ‘ఐ పైథాన్ ప్రోగ్రామింగ్’ ఇన్పుట్గా తీసుకోబడుతుంది మరియు క్యాపిటలైజ్ () మరియు స్ప్లిట్ () పద్ధతులను వర్తింపజేసిన తర్వాత, అవుట్పుట్ ‘ఐథాన్ పైథాన్ ప్రోగ్రామింగ్’.
ఉదాహరణ -3: బహుళ వాక్యాల వచనంలో ప్రతి వాక్యం యొక్క మొదటి అక్షరాన్ని పెద్ద అక్షరం చేయండి.
మునుపటి రెండు ఉదాహరణలలో, క్యాపిటలైజ్ () పద్ధతి ఒకే పంక్తి వచనంలో వర్తించబడుతుంది. కానీ కొన్నిసార్లు, ఫైల్ కంటెంట్ లేదా బహుళ వాక్యాల సుదీర్ఘ వచనంతో పనిచేయడం అవసరం మరియు ఫైల్ యొక్క ప్రతి పంక్తిలోని మొదటి అక్షరాన్ని పెద్ద అక్షరం లేదా టెక్స్ట్ యొక్క ప్రతి వాక్యం యొక్క మొదటి అక్షరాన్ని క్యాపిటలైజ్ చేయడం అవసరం. క్యాపిటల్ () స్ప్లిట్ () తో పద్ధతి ఈ సమస్యను పరిష్కరించడానికి ఉపయోగించవచ్చు. సుదీర్ఘ వచనం యొక్క ప్రతి వాక్యం యొక్క మొదటి అక్షరాన్ని క్యాపిటలైజ్ చేయడానికి మార్గం ఉదాహరణను చూపుతుంది. ఇక్కడ, టెక్స్ట్ అనే వేరియబుల్ మూడు వాక్యాల స్ట్రింగ్ విలువతో నిర్వచించబడింది. మొదట, మూడు వాక్యాల జాబితాను రూపొందించడానికి స్ప్లిట్ () పద్ధతిని ఉపయోగించి టెక్స్ట్ విలువ ‘.’ ఆధారంగా విభజించబడింది. తరువాత, లూప్ కోసం ఉదాహరణ 2 వంటి ప్రతి వాక్యంలోని మొదటి అక్షరాన్ని క్యాపిటలైజ్ చేయడానికి ఉపయోగిస్తారు. అనవసరమైన ఖాళీని తొలగించడానికి స్ట్రిప్ () పద్ధతి ఉపయోగించబడుతుంది మరియు చివరి అదనపు ‘.’ స్థాన విలువను ఉపయోగించడం ద్వారా కొత్త టెక్స్ట్ నుండి తీసివేయబడుతుంది.
#!/usr/bin/env పైథాన్ 3# సుదీర్ఘ వచనాన్ని నిర్వచించండి
టెక్స్ట్= 'పైథాన్ ఒక వివరణాత్మక, ఉన్నత-స్థాయి, సాధారణ-ప్రయోజన ప్రోగ్రామింగ్ భాష.
గైడో వాన్ రోసమ్ సృష్టించారు. ఇది మొదటిసారిగా 1991 లో విడుదలైంది. '
# స్పేస్ ఆధారంగా వచనాన్ని విభజించండి
లైన్లిస్ట్=టెక్స్ట్విభజన('.')
# కన్వర్టెడ్ స్ట్రింగ్ను నిల్వ చేయడానికి వేరియబుల్ను నిర్వచించండి
కొత్త టెక్స్ట్= ''
# జాబితాను పునరావృతం చేయండి
కోసంగంటలులోలైన్లిస్ట్:
# ప్రారంభం మరియు ముగింపు నుండి ఖాళీని తీసివేయండి
గంటలు=గంటలుస్ట్రిప్()
# ప్రతి జాబితా అంశాన్ని క్యాపిటలైజ్ చేయండి మరియు 'తో విలీనం చేయండి.'
కొత్త టెక్స్ట్ +=గంటలుక్యాపిటలైజ్()+'. '
# చివరి చుక్కను తొలగించండి
కొత్త టెక్స్ట్=కొత్త టెక్స్ట్[: -2]
# అసలు స్ట్రింగ్ను ముద్రించండి
ముద్రణ('అసలు వచనం: n%s '%టెక్స్ట్)
# కన్వర్టెడ్ స్ట్రింగ్ను ప్రింట్ చేయండి
ముద్రణ(' nమార్చబడిన వచనం: n%s '%కొత్త వచనం)
అవుట్పుట్:
ఒరిజినల్ టెక్స్ట్ మరియు కన్వర్టెడ్ టెక్స్ట్ రెండూ అవుట్పుట్లో చూపించబడ్డాయి.
ముగింపు:
మీరు స్ట్రింగ్ డేటాతో పని చేసినప్పుడు మరియు స్ట్రింగ్ యొక్క మొదటి అక్షరం లేదా స్ట్రింగ్ యొక్క ప్రతి పదం యొక్క మొదటి అక్షరం లేదా సుదీర్ఘ టెక్స్ట్ యొక్క ప్రతి వాక్యం యొక్క మొదటి అక్షరం పెద్ద అక్షరం కావాల్సినప్పుడు పెద్ద అక్షరం () పద్ధతిని మరొక పద్ధతిలో ఉపయోగించవచ్చు పని చేయండి. ఇక్కడ పేర్కొన్న పనులు ఉదాహరణలతో ఈ వ్యాసంలో చూపబడ్డాయి. బహుళ ప్రయోజనాల కోసం స్ట్రింగ్ డేటాపై క్యాపిటల్ () పద్ధతిని ఉపయోగించడానికి ఈ కథనం పాఠకులకు సహాయపడుతుందని నేను ఆశిస్తున్నాను.
రచయిత వీడియో చూడండి: ఇక్కడ