పైథాన్‌లో స్ట్రింగ్‌ను ఎలా విభజించాలి

పైథాన్‌లో స్ట్రింగ్‌ను విభజించడం చాలా సులభం. పైథాన్ అంతర్నిర్మిత 'స్ప్లిట్ ()' ఫంక్షన్‌ను ఉపయోగించి మీరు దీనిని సాధించవచ్చు.

ది విభజన () పైథాన్‌లోని పద్ధతి ప్రతి పదాన్ని స్ట్రింగ్‌లో కామా ఉపయోగించి వేరు చేసి, దానిని పదాల జాబితాగా మారుస్తుంది. ఈ గైడ్ మీరు పైథాన్‌లో స్ట్రింగ్‌ను విభజించే వివిధ మార్గాల్లో మిమ్మల్ని నడిపిస్తుంది.

---

---

ssd చనిపోయిందని ఎలా చెప్పాలి

పైథాన్ స్ప్లిట్ పద్ధతిని ఎలా ఉపయోగించాలి

ముందుగా చెప్పినట్లుగా, అప్రమేయంగా, పైథాన్ అంతర్నిర్మితమైనది విభజన () ఫంక్షన్ కామాలతో వేరు చేయబడిన వ్యక్తిగత పదాలుగా స్ట్రింగ్‌ను విచ్ఛిన్నం చేస్తుంది. కానీ ఇది రెండు ఐచ్ఛిక వాదనలను అంగీకరిస్తుంది మరియు వాక్యనిర్మాణం ఎలా ఉంటుందో ఇక్కడ ఉంది:

string.split([separatng criteria], [break point or max_split])


మీరు పేర్కొన్నప్పుడు a విభజన ప్రమాణాలు , ఫంక్షన్ స్ట్రింగ్ లోపల ఆ ప్రమాణాలను గుర్తించి, ఆ సమయంలో విభజనను ప్రారంభిస్తుంది. లేకపోతే, డిఫాల్ట్‌గా, అది ఖాళీ స్థలం ఉన్న చోట స్ట్రింగ్‌ని విభజిస్తుంది.

ఇది ఎలా పనిచేస్తుందో తెలుసుకోవడానికి క్రింది ఉదాహరణను చూడండి. ఇక్కడ, తెల్లని ఖాళీలు డిఫాల్ట్‌గా విభజన ప్రమాణాలు, ఎందుకంటే మేము ఒకదాన్ని పేర్కొనలేదు:

myTexts = 'How to split a text in Python'
splitString = myTexts.split()
print(splitString)
Output: ['How', 'to', 'split', 'a', 'text', 'in', 'Python']


ఎలాగో చూద్దాం విభజన () మీరు విభజన ప్రమాణాలను పేర్కొన్నప్పుడు పద్ధతి పనిచేస్తుంది. ఈ ఉదాహరణలో, కామా అనేది వేరు చేసే ప్రమాణం:

myTexts = 'How to split, a text in, Python'
print(myTexts.split(', '))


మెరుగైన అవగాహన కోసం, దిగువ ఉదాహరణ కోడ్ చుక్క ఉన్న చోట తీగలను విభజిస్తుంది. కాబట్టి ఇక్కడ చుక్కలు విభజన ప్రమాణాలు:

---

---

myTexts = 'How to split.a text in.Python'
print(myTexts.split('.'))
Output: ['How to split', 'a text in', 'Python']


max_split స్ట్రింగ్‌లో గరిష్ట సంఖ్యలో విరామాలను పేర్కొనే పూర్ణాంకం. మరీ ముఖ్యంగా, స్ట్రింగ్ విచ్ఛిన్నమయ్యే పాయింట్‌ని ఇది సూచిస్తుంది.

కాబట్టి మీరు నిర్దిష్ట పాయింట్‌లలో స్ట్రింగ్‌ను విచ్ఛిన్నం చేయడానికి కుండలీకరణాల్లో ఆ విలువను చేర్చవచ్చు.

---

---

ఉదాహరణకు, దిగువ కోడ్ టెక్స్ట్‌లను రెండుగా విచ్ఛిన్నం చేస్తుంది మరియు రెండవ కామాలో ఆగిపోతుంది:

myTexts = 'How, to, split, a, text, in, Python'
print(myTexts.split(', ', 2))
Output: ['How', 'to', 'split, a, text, in, Python']


ఇది మరింతగా ఎలా పనిచేస్తుందో చూడటానికి, దిగువ కోడ్‌లోని స్ట్రింగ్‌ని వేరు చేసి, రెండవ డాట్‌లో ఆపేలా చేయండి:

myTexts = 'How.to split.a text.in.Python'
print(myTexts.split('.', 2))
Output: ['How', 'to split', 'a text.in.Python']


కాగా విభజన () పద్ధతి అక్షరాలను స్ట్రింగ్‌లను విచ్ఛిన్నం చేయదు, మీరు దీనిని ఉపయోగించి దీనిని సాధించవచ్చు కోసం లూప్:

myTexts = 'How to split a text in Python'
Alphabets = []
for each in myTexts:
alphas = each
Alphabets.append(alphas)
print(Alphabets)


సంబంధిత: పైథాన్‌లో జాబితాను ఎలా జోడించాలి

మేము పైన కోడ్‌లో చేసినట్లుగా జాబితాకు జోడించడానికి బదులుగా, మీరు కోడ్‌ని తగ్గించవచ్చు జాబితా గ్రహణశక్తిని ఉపయోగించడం :

y = [each for each in myTexts]
print(y)


పైథాన్ స్ప్లిట్ ఫంక్షన్‌తో వర్డ్ కౌంటర్‌ను సృష్టించండి

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

myTexts = 'How to split a text in Python'
print(len(myTexts.split()))
Output: 7


ప్రత్యేక ఫైల్‌లో పదాలను లెక్కించడానికి పై కోడ్‌ని సవరించండి. దీన్ని చేయడానికి మీరు ఒక ఫంక్షన్‌ను సృష్టించవచ్చు. కానీ ఇక్కడ, మీరు టెక్స్ట్ ఉన్న ఫైల్‌ను తెరిచి చదవాలి.

ముందుగా వచనాన్ని విభజించి, అంతర్నిర్మిత ఉపయోగించి ఫలిత విభజన యొక్క పొడవును తిరిగి ఇవ్వడం ద్వారా గణనను అమలు చేయండి లెన్ () ఫంక్షన్:

def countWords(file):
myFile = open(file, 'r')
File = myFile.read()
splitString = File.split()
return len(splitString)
print(countWords('[Path to Yourfile.txt]'))


ఇది కొంచెం గమ్మత్తైనది అయినప్పటికీ, మీరు దీనిని ఉపయోగించి కూడా చేయవచ్చు కోసం లూప్ మాత్రమే:

def countWords(file):
myFile = open(file, 'r')
File = myFile.read()
File = [File]
for files in File:
return files.count(' ') + 1
print(countWords('[Path to Yourfile.txt]'))


సంబంధిత: పైథాన్‌లో ఫైల్‌ను ఎలా తెరవాలి, చదవాలి మరియు వ్రాయాలి

చేయడానికి కోసం లూప్ ప్రతి పదాన్ని విడిగా చదవండి, పై కోడ్‌లో మేము చేసినట్లుగా మీరు మీ ఫైల్‌ని ప్రత్యేక జాబితాలో చేర్చాలి. అదనంగా, కుండలీకరణాలలో ఖాళీ కోట్‌ల మధ్య ఖాళీని ఉంచడం ద్వారా పద గణనను అమలు చేయండి. లేకపోతే, అది మీకు తప్పు అవుట్‌పుట్ ఇస్తుంది.

కాబట్టి కోడ్ ప్రతి పదం మధ్య ఖాళీలను లెక్కించి, ఆపై మొత్తం సంఖ్యకు 1 జోడించడం ద్వారా వాస్తవ పదాల సంఖ్యను పొందడం ద్వారా పనిచేస్తుంది.

మీ కోడ్‌ను సరళీకృతం చేయండి

ది విభజన () ఫంక్షన్ ఒక విలువైన పైథాన్ సాధనం, మరియు మీరు చూసినట్లుగా, ఫైల్‌లోని పదాలను లెక్కించడానికి మీరు దాన్ని ఉపయోగించవచ్చు. మీరు కోరుకున్నట్లుగా మీరు ఇతర సమస్యలను కూడా పరిష్కరించవచ్చు. పైథాన్‌లో అనేక ఇతర అంతర్నిర్మిత విధులు ఉన్నాయి, ఇవి సంక్లిష్ట కార్యకలాపాలను త్వరగా మరియు సమర్ధవంతంగా సులభతరం చేస్తాయి.

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

షేర్ చేయండి షేర్ చేయండి ట్వీట్ ఇమెయిల్ పైథాన్ నేర్చుకోవడం? తీగలను ఎలా మార్చాలో ఇక్కడ ఉంది

పైథాన్‌లో స్ట్రింగ్‌లను ఉపయోగించడం మరియు మార్చడం కష్టంగా అనిపించవచ్చు, కానీ ఇది మోసపూరితంగా సూటిగా ఉంటుంది.

తదుపరి చదవండి సంబంధిత అంశాలు

• ప్రోగ్రామింగ్
• పైథాన్
• కోడింగ్ ట్యుటోరియల్స్

రచయిత గురుంచి ఇదిసౌ ఒమిసోలా(94 కథనాలు ప్రచురించబడ్డాయి)

ఇడోవు ఏదైనా స్మార్ట్ టెక్ మరియు ఉత్పాదకతపై మక్కువ చూపుతుంది. తన ఖాళీ సమయంలో, అతను కోడింగ్‌తో ఆడుతాడు మరియు అతను విసుగు చెందినప్పుడు చెస్‌బోర్డ్‌కు మారతాడు, కానీ అతను ఒక్కోసారి రొటీన్ నుండి దూరంగా ఉండడాన్ని కూడా ఇష్టపడతాడు. ఆధునిక సాంకేతిక పరిజ్ఞానం చుట్టూ ప్రజలకు మార్గం చూపించాలనే అతని అభిరుచి అతన్ని మరింత రాయడానికి ప్రేరేపిస్తుంది.

ఇడోవు ఒమిసోలా నుండి మరిన్ని

మా వార్తాలేఖకు సభ్యత్వాన్ని పొందండి

టెక్ చిట్కాలు, సమీక్షలు, ఉచిత ఈబుక్‌లు మరియు ప్రత్యేకమైన డీల్స్ కోసం మా వార్తాలేఖలో చేరండి!

సభ్యత్వం పొందడానికి ఇక్కడ క్లిక్ చేయండి