విషయ సూచిక[దాచు][చూపండి]
క్రాష్ కోర్సులో మూడవ ఉపన్యాసానికి స్వాగతం.
ఈ ఉపన్యాసంలో, పైథాన్లో స్ట్రింగ్లతో వ్యవహరించడం నేర్చుకుంటాము. మీ పాప్కార్న్ని సిద్ధం చేసి, గట్టిగా కూర్చోండి.
స్ట్రింగ్స్
ముందుగా, కోట్ల గురించి మాట్లాడండి మరియు పైథాన్లో వారు ప్రవేశపెట్టే గందరగోళాన్ని తొలగించండి.
ముందు చెప్పినట్లుగా, పైథాన్లోని ఫంక్షన్ తర్వాత మనం సింగిల్ మరియు డబుల్ కోట్లను ఉపయోగించవచ్చు. దీనికి ఒక నిర్దిష్ట ప్రయోజనం ఉంది. మీరు ఇలాంటివి ప్రింట్ చేయాలనుకుంటున్నారని అనుకుందాం.
print('This is Shahbaz's computer')
ఇప్పుడు పై ఎక్స్ప్రెషన్లో, “షాబాజ్”లో ఉన్నట్లుగా రెండవ కోట్ తర్వాత ఉన్న ప్రతిదీ పైథాన్ ఇంటర్ప్రెటర్ ద్వారా గుర్తించబడదు ఎందుకంటే పైథాన్ రెండవ కోట్ను స్ట్రింగ్ ముగింపుగా తీసుకుంటుంది. ఆ సందర్భంలో, మీరు స్ట్రింగ్ను ఇలా ప్రకటించడానికి డబుల్ కోట్లను ఉపయోగించాలనుకుంటున్నారు:
print("This is Shahbaz's computer")
ఇది ఇతర మార్గంలో కూడా వర్తింపజేయవచ్చు మరియు స్ట్రింగ్ లోపల డబుల్ కొటేషన్లు ఉంటే మేము ఒకే కోట్లను ఉపయోగించవచ్చు. ఉదా
print('This "computer" belongs to Shahbaz')
ఇప్పుడు మీరు బహుళ పంక్తులలో ఉండే స్ట్రింగ్ను ప్రింట్ చేయాలనుకుంటే, స్ట్రింగ్ను జతచేయడానికి మీరు ట్రిపుల్ కోట్లను ఉపయోగించాలి. ఈ కోట్లు స్ట్రింగ్లోని కంటెంట్పై ఆధారపడి సింగిల్ లేదా డబుల్ కూడా కావచ్చు. ఉదాహరణకి:
ఇప్పుడు మీరు స్ట్రింగ్ నుండి నిర్దిష్ట అక్షరాన్ని ప్రింట్ చేయాలనుకుంటున్నారని అనుకుందాం. మీరు ఎలా చేస్తారు?
పైథాన్ ఇంటర్ప్రెటర్ స్ట్రింగ్లోని అక్షరాలను ఇలా ఇండెక్స్ చేస్తుంది:
మీరు టెర్మినల్లో చూడగలిగినట్లుగా, 'h' మాత్రమే ముద్రించబడింది. ఎందుకంటే చతురస్రాకార బ్రాకెట్లలో 3ని వేరియబుల్ తర్వాత వ్రాయడం ద్వారా టెర్మినల్లో ప్రింట్ చేయడానికి మన స్ట్రింగ్లోని మూడవ అక్షరాన్ని మాత్రమే ఎంచుకున్నాము. పైథాన్ ఇంటర్ప్రెటర్ పెద్ద తీగలను సులభతరం చేయడానికి అక్షరాలను ప్రతికూలంగా సూచిక చేస్తుంది. అంటే '-1' అనేది స్ట్రింగ్లోని చివరి సంఖ్య మరియు మొదలైనవి. స్పేస్లు ఇండెక్స్ చేయబడలేదని గుర్తుంచుకోండి, అంటే పై స్ట్రింగ్లో 21 ఇండెక్స్డ్ స్పేస్లు మాత్రమే ఉంటాయి.
మీరు స్ట్రింగ్ నుండి అక్షరాల శ్రేణిని కూడా ఎంచుకోవచ్చు. ఉదా
HashDork = ('Python Course by Shahbaz')
print(HashDork[0:3])
ఈ ప్రోగ్రామ్ టెర్మినల్లో 'Pyt'ని ప్రింట్ చేస్తుంది. ఇండెక్స్ 3 దీని నుండి మినహాయించబడింది.
HashDork = ('Python Course by Shahbaz')
print(HashDork[2:])
అదే పద్ధతిలో, మనం ముగింపు సూచికను సరఫరా చేయకపోతే, పైథాన్ మొదటి సూచిక తర్వాత మొత్తం స్ట్రింగ్ను ప్రింట్ చేస్తుంది. ఈ ప్రోగ్రామ్ యొక్క అవుట్పుట్ 'థాన్ కోర్స్ బై షాబాజ్'గా ఉంటుంది. ఇది వైస్ వెర్సాను కలిగి ఉంది. అంటే మనం మొదటి సూచికను కోల్పోతే, ప్రారంభం నుండి చివరిగా నిర్వచించిన సూచిక వరకు మొత్తం స్ట్రింగ్ ముద్రించబడుతుంది.
ఇండెక్సింగ్ బ్రాకెట్లలో కోలన్ మాత్రమే ఉన్న ప్రోగ్రామ్ టెర్మినల్పై పూర్తి స్ట్రింగ్ను అందిస్తుంది.
వ్యాయామం
ఇక్కడ ఒక ఆసక్తికరమైన వ్యాయామం ఉంది
[1:-1] యొక్క ఇండెక్స్ విరామాన్ని నిర్వచించే ప్రోగ్రామ్ను వ్రాయండి. అవుట్పుట్ ఎలా ఉంటుందో అనుకుంటున్నారు. మీరే ప్రయత్నించండి.
ఫార్మాట్ చేయబడిన స్ట్రింగ్స్
మీరు మీ వేరియబుల్స్తో కొంత వచనాన్ని డైనమిక్గా రూపొందించే సందర్భాల్లో ఫార్మాట్ చేసిన స్ట్రింగ్లు ప్రత్యేకంగా ఉపయోగపడతాయి. నన్ను చూపించనివ్వు.
మనకు మొదటి పేరు మరియు చివరి పేరు అనే రెండు వేరియబుల్స్ ఉన్నాయని అనుకుందాం.
first_name = 'Shahbaz'
last_name = 'Bhatti'
ఇప్పుడు మనం టెర్మినల్లో 'షాబాజ్ [భట్టి] ఒక కోడర్' అని ప్రింట్ చేయాలనుకుంటున్నాము. మేము దానిని ఎలా చేస్తాము? మేము ఈ విధంగా మూడవ వేరియబుల్ను పరిచయం చేస్తాము:
message = 'first_name + ' [' + last_name + '] is a coder'
ఇప్పుడు మనం ఈ ప్రోగ్రామ్ని ప్రింట్ చేసి రన్ చేస్తే, టెర్మినల్లో మనకు 'షాబాజ్ [భట్టి] ఈజ్ ఎ కోడర్' వస్తుంది.
ఈ విధానం సంపూర్ణంగా పని చేస్తున్నప్పటికీ, ఇది అనువైనది కాదు ఎందుకంటే మా వచనం మరింత క్లిష్టంగా మారినప్పుడు అవుట్పుట్ను దృశ్యమానం చేయడం కష్టమవుతుంది. ఇక్కడే మేము ఫార్మాట్ చేసిన స్ట్రింగ్లను ఉపయోగిస్తాము, అవి అవుట్పుట్ను దృశ్యమానం చేయడం మాకు సులభతరం చేస్తాయి.
మూడవ వేరియబుల్ 'మెసేజ్'ని మార్చి, ఫార్మాట్ చేసిన స్ట్రింగ్ను పరిచయం చేద్దాం. ఫార్మాట్ చేయబడిన స్ట్రింగ్లను నిర్వచించడానికి, మీ స్ట్రింగ్లను 'f'తో ప్రిఫిక్స్ చేసి, ఆపై మీ స్ట్రింగ్లలో డైనమిక్గా విలువలను ఇన్సర్ట్ చేయడానికి కర్లీ బ్రేస్లను ఉపయోగించండి. మా ప్రోగ్రామ్ ఇలా కనిపిస్తుంది:
first_name = 'Shahbaz'
last_name = 'Bhatti'
message = f'{first_name} [{last_name}] is a coder'
ఫార్మాట్ చేయబడిన స్ట్రింగ్లను నిర్వచించడానికి, మీ స్ట్రింగ్లను Fతో ప్రిఫిక్స్ చేసి, ఆపై మీ స్ట్రింగ్లలో డైనమిక్గా విలువలను ఇన్సర్ట్ చేయడానికి కర్లీ బ్రేస్లను ఉపయోగించండి.
పైథాన్ స్ట్రింగ్స్తో మీరు చేయగల మంచి విషయాలు
పైథాన్ స్ట్రింగ్స్తో మీరు చేయగలిగే కొన్ని అద్భుతమైన విషయాలను నేను మీకు చూపించబోతున్నాను.
1. స్ట్రింగ్లోని అక్షరాల సంఖ్య
కాబట్టి వేరియబుల్ని నిర్వచించడం ద్వారా ప్రారంభిద్దాం:
message = 'Shahbaz Bhatti is a Coder '
ఇప్పుడు నేను పై స్ట్రింగ్లోని అక్షరాల సంఖ్యను గుర్తించాలనుకుంటే, పైథాన్లో అంతర్నిర్మిత ఫంక్షన్ ”లెన్” ఉంది. ఈ ఫంక్షన్తో వేరియబుల్ని ఇలా ప్రింట్ చేయండి
print(len(message))
మీరు వినియోగదారు నుండి ఇన్పుట్ అందుకున్నప్పుడు ఇది ప్రత్యేకంగా ఉపయోగపడుతుంది. ఉదాహరణకు, మీరు ఆన్లైన్లో ఫారమ్ను పూరించినప్పుడు, ప్రతి ఇన్పుట్ ఫీల్డ్ తరచుగా పరిమితిని కలిగి ఉంటుందని మీరు గమనించారు. ఉదాహరణకు, మీరు మీ పేరు కోసం 50 అక్షరాలను కలిగి ఉండవచ్చు, కాబట్టి ఈ ”లెన్” ఫంక్షన్ని ఉపయోగించి మేము ఇన్పుట్ ఫీల్డ్లోని అక్షరాల సంఖ్యపై పరిమితిని అమలు చేయవచ్చు.
2. స్ట్రింగ్లోని అక్షరాలను పెద్ద అక్షరం లేదా చిన్న అక్షరానికి మార్చడం
మేము డాట్ ఆపరేటర్ ద్వారా స్ట్రింగ్-సంబంధిత ఫంక్షన్లను యాక్సెస్ చేయవచ్చు. మీరు మీ వేరియబుల్ పేరును టైప్ చేయవచ్చు మరియు దాని ముందు చుక్కను ఉంచడం ద్వారా, మీరు అటువంటి అన్ని ఫంక్షన్ల జాబితాను చూడవచ్చు.
ఇప్పుడు మరింత ఖచ్చితమైన పరంగా, మీరు ఈ ఫంక్షన్లను పద్ధతులుగా సూచిస్తారు, ఇది భవిష్యత్తులో మనం చూడాలనుకుంటున్న ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్లోని పదం, కానీ ప్రస్తుతానికి, నేను మీరు తీసివేయాలనుకుంటున్నది, అది ఫంక్షన్ అయినప్పుడు వేరొకదానికి చెందినది లేదా ఏదో ఒక రకమైన వస్తువుకు సంబంధించినది, మేము ఆ ఫంక్షన్ను ఒక పద్ధతిగా సూచిస్తాము. ఈ సందర్భంలో, మేము స్ట్రింగ్ను పెద్ద అక్షరంలోకి మార్చడానికి “అప్పర్” పద్ధతిని ఉపయోగిస్తాము.
ఈ ఫంక్షన్ స్ట్రింగ్కు ప్రత్యేకమైనది కాబట్టి, మేము దీనిని ఒక పద్ధతిగా సూచిస్తాము. దీనికి విరుద్ధంగా “లెన్” మరియు “ప్రింట్” సాధారణ ప్రయోజన విధులు, అవి తీగలు లేదా సంఖ్యలు లేదా ఇతర రకాల వస్తువులకు చెందినవి కావు. ఇది ఫంక్షన్ మరియు పద్ధతి మధ్య ప్రాథమిక వ్యత్యాసం.
ఇప్పుడు, దీన్ని ప్రింట్ చేద్దాం.
message = 'Shahbaz Bhatti is a coder'
print(message.upper())
మరియు మేము మా స్ట్రింగ్ను పెద్ద అక్షరంలో పొందినట్లు చూడవచ్చు. అదేవిధంగా, స్ట్రింగ్ను చిన్న అక్షరంలోకి మార్చడానికి మనకు “తక్కువ” పద్ధతి ఉంది. మీరు స్ట్రింగ్లోని ప్రతి పదాన్ని క్యాపిటలైజ్ చేయడానికి “శీర్షిక” పద్ధతిని కూడా ఉపయోగించవచ్చు.
పద్ధతి మా అసలు స్ట్రింగ్ను మార్చదని లేదా సవరించదని గమనించండి. వాస్తవానికి, ఇది కొత్త స్ట్రింగ్ను సృష్టించి, దాన్ని తిరిగి ఇస్తుంది.
3. స్ట్రింగ్లోని అక్షరాల క్రమాన్ని కనుగొనండి
స్ట్రింగ్లోని నిర్దిష్ట అక్షరం యొక్క సూచికను కనుగొనడానికి మరొక పద్ధతిని ప్రయత్నిద్దాం.
రకం:
message.find('b')
అదే వేరియబుల్ తర్వాత మరియు దానిని ప్రింట్ చేయండి. ఇది ఈ సందర్భంలో 4 అయిన స్ట్రింగ్లో 'b' అక్షరం యొక్క మొదటి సంభవం యొక్క సూచికను ముద్రిస్తుంది.
ఈ పద్ధతి కేస్ సెన్సిటివ్ అని గమనించండి మరియు స్ట్రింగ్లో అక్షరం కనుగొనబడకపోతే ఇది -1ని అందిస్తుంది. ఇది అక్షరాల క్రమం కోసం కూడా ఉపయోగించవచ్చు.
ఉదాహరణకు, కింది ప్రోగ్రామ్:
message = 'Shahbaz Bhatti is a coder'
print(message.find('coder'))
"కోడర్" క్రమం ఇండెక్స్ 20 నుండి ప్రారంభమైనందున "20" విలువను అందిస్తుంది.
4. స్ట్రింగ్లో అక్షరాన్ని భర్తీ చేయడం
స్ట్రింగ్లోని అక్షరం లేదా అక్షరాల క్రమాన్ని భర్తీ చేయడానికి మీరు "రీప్లేస్" పద్ధతిని ఉపయోగించవచ్చు. దీన్ని చర్యలో చూద్దాం.
message = 'Shahbaz Bhatti is a coder'
print(message.replace('coder', 'programmer'))
ఈ ప్రోగ్రామ్ "కోడర్" అనే పదాన్ని "ప్రోగ్రామర్"తో భర్తీ చేస్తుంది మరియు దానిని టెర్మినల్లో ప్రింట్ చేస్తుంది.
5. స్ట్రింగ్లో అక్షరం యొక్క ఉనికిని తనిఖీ చేయండి
ఇప్పుడు మీరు మీ స్ట్రింగ్లోని అక్షరం లేదా అక్షరం యొక్క క్రమాన్ని తనిఖీ చేయాలనుకున్న సందర్భాలు ఉన్నాయి. ఆ పరిస్థితుల్లో, మీరు మీ వ్యక్తీకరణను ఇలా ఫార్మాట్ చేయవచ్చు:
message = 'Shahbaz Bhatti is a coder'
ప్రింట్ (సందేశంలో 'పైథాన్')
ఇప్పుడు ఇది బూలియన్ ఫంక్షన్ని అందిస్తుంది. అంటే "నిజం" లేదా "తప్పు". ఇలా;
ఈ పద్ధతులు మరియు విధులన్నీ కేస్-సెన్సిటివ్ అని దయచేసి గమనించండి.
ముగించు!
తీగలకు ఇంకా చాలా ఉన్నాయి, మనం ముందుకు సాగుతున్నప్పుడు క్రమంగా నేర్చుకుంటాము. తరువాత, మేము పైథాన్లో అంకగణిత కార్యకలాపాలను నిర్వహించడం నేర్చుకుంటాము.
సమాధానం ఇవ్వూ