పైథాన్‌లో పెద్ద అక్షరాలు మరియు చిన్న అక్షరాలను మార్చడానికి స్ట్రింగ్ పద్ధతుల జాబితా

వ్యాపారం

పైథాన్ యొక్క స్ట్రింగ్ రకం (str) పెద్ద అక్షరాలు మరియు చిన్న అక్షరాలను మార్చటానికి అనుకూలమైన పద్ధతులతో ప్రామాణికంగా వస్తుంది. మీరు పెద్ద అక్షరం మరియు చిన్న అక్షరం మధ్య మార్చవచ్చు మరియు కేసును నిర్ణయించవచ్చు.

కింది సమాచారం ఇక్కడ అందించబడింది.

  • పెద్ద అక్షరం మరియు చిన్న అక్షరాల మధ్య మార్చడం
    • ప్రాథమిక వినియోగం
    • పూర్తి-పరిమాణం మరియు సగం-పరిమాణ అక్షరాలను నిర్వహించడం
    • str.upper()అన్ని అక్షరాలను పెద్ద అక్షరానికి మార్చండి
    • str.lower()అన్ని అక్షరాలను చిన్న అక్షరానికి మార్చండి
    • str.capitalize()మొదటి అక్షరాన్ని పెద్ద అక్షరానికి మరియు మిగిలిన అక్షరాన్ని చిన్న అక్షరానికి మార్చండి.
    • str.title()పదంలోని మొదటి అక్షరాన్ని పెద్ద అక్షరానికి మరియు మిగిలిన అక్షరాన్ని చిన్న అక్షరానికి మార్చండి.
    • str.swapcase()పెద్ద అక్షరాలను చిన్న అక్షరానికి మరియు చిన్న అక్షరాలను పెద్ద అక్షరానికి మార్చండి.
  • పెద్ద మరియు చిన్న అక్షరాలను నిర్ణయించండి
    • str.isupper(): అన్ని అక్షరాలు పెద్ద అక్షరంతో ఉన్నాయో లేదో నిర్ణయించండి
    • str.islower(): అన్ని అక్షరాలు చిన్న అక్షరాలు ఉంటే నిర్ణయించండి.
    • str.istitle(): ఇది టైటిల్ కేస్ కాదా అని నిర్ణయించండి.
  • కేస్-సెన్సిటివ్ పద్ధతిలో స్ట్రింగ్‌లను సరిపోల్చండి

పెద్ద అక్షరం మరియు చిన్న అక్షరాల మధ్య మార్చడం

ప్రాథమిక వినియోగం

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

సౌలభ్యం కోసం, మేము “మార్పిడి” అని వ్రాస్తాము, కానీ పైథాన్‌లో, స్ట్రింగ్ రకం (str) వస్తువులు నవీకరించబడవు, కాబట్టి అసలు స్ట్రింగ్ (ఉదాహరణలో s_org) మార్చబడదు.

s_org = 'pYThon proGramminG laNguAge'

print(s_org.upper())
# PYTHON PROGRAMMING LANGUAGE

print(s_org)
# pYThon proGramminG laNguAge

మీరు మార్చబడిన స్ట్రింగ్‌ను తర్వాత ఉపయోగించాలనుకుంటే, మీరు దానిని క్రింది విధంగా కొత్త వేరియబుల్‌లో నిల్వ చేయవచ్చు.

s_new = s_org.upper()
print(s_new)
# PYTHON PROGRAMMING LANGUAGE

అసలు వేరియబుల్‌ని ఓవర్‌రైట్ చేయడం కూడా సాధ్యమే.

s_org = s_org.upper()
print(s_org)
# PYTHON PROGRAMMING LANGUAGE

పూర్తి-పరిమాణం మరియు సగం-పరిమాణ అక్షరాలను నిర్వహించడం

వర్ణమాల వంటి అక్షరం కేస్-సెన్సిటివ్ అయితే, అది సింగిల్-బైట్ మరియు డబుల్-బైట్ అక్షరాలుగా మార్చబడుతుంది.

సంఖ్యలు మరియు చైనీస్ అక్షరాలు వంటి కేస్-సెన్సిటివ్ లేని అక్షరాలు మారవు. ఉదాహరణ అప్పర్(), కానీ అదే ఇతర పద్ధతులకు వర్తిస్తుంది.

s_org = 'Pyhon Ｐｙｔｈｏｎ 123'

print(s_org.upper())
# PYHON ＰＹＴＨＯＮ 123

str.upper(): అన్ని అక్షరాలను పెద్ద అక్షరానికి మార్చండి

s_org = 'pYThon proGramminG laNguAge'

print(s_org.upper())
# PYTHON PROGRAMMING LANGUAGE

str.lower(): అన్ని అక్షరాలను చిన్న అక్షరానికి మార్చండి

s_org = 'pYThon proGramminG laNguAge'

print(s_org.lower())
# python programming language

str.capitalize(): మొదటి అక్షరాన్ని పెద్ద అక్షరానికి, మిగిలిన అక్షరాన్ని చిన్న అక్షరానికి మార్చండి

s_org = 'pYThon proGramminG laNguAge'

print(s_org.capitalize())
# Python programming language

str.title(): పదంలోని మొదటి అక్షరాన్ని పెద్ద అక్షరానికి మరియు మిగిలిన అక్షరాన్ని చిన్న అక్షరానికి మార్చండి

టైటిల్ కేస్ అని పిలవబడేదిగా మార్చడం.

s_org = 'pYThon proGramminG laNguAge'

print(s_org.title())
# Python Programming Language

str.swapcase(): పెద్ద అక్షరాన్ని చిన్న అక్షరానికి, చిన్న అక్షరాన్ని పెద్ద అక్షరానికి మార్చండి

పెద్ద అక్షరాలు మరియు చిన్న అక్షరాలను మార్చుకోండి.

s_org = 'pYThon proGramminG laNguAge'

print(s_org.swapcase())
# PytHON PROgRAMMINg LAnGUaGE

పెద్ద మరియు చిన్న అక్షరాలను నిర్ణయించండి

కింది ఉదాహరణలలో, పద్ధతులు నేరుగా ‘పైథాన్’ వంటి స్ట్రింగ్ లిటరల్స్ నుండి పిలువబడతాయి, అయితే మునుపటి ఉదాహరణలలో వలె వేరియబుల్స్‌లో నిల్వ చేసినప్పుడు అదే నిజం.

str.isupper(): అన్ని అక్షరాలు పెద్ద అక్షరంగా ఉన్నాయో లేదో నిర్ణయించండి

isupper() కనీసం ఒక కేస్-సెన్సిటివ్ క్యారెక్టర్‌ని కలిగి ఉంటే మరియు అవన్నీ అప్పర్‌కేస్ అయితే ఒప్పు అని మరియు లేకపోతే తప్పు అని చూపుతుంది.

print('PYTHON'.isupper())
# True

print('Python'.isupper())
# False

పాత్ర కేస్-సెన్సిటివ్ అయితే, డబుల్ బైట్ అక్షరాలు కూడా నిర్ణయించబడతాయి.

print('ＰＹＴＨＯＮ'.isupper())
# True

కేస్-సెన్సిటివ్ క్యారెక్టర్‌ని కూడా చేర్చినట్లయితే, కేస్-సెన్సిటివ్ క్యారెక్టర్ విస్మరించబడుతుంది, కానీ కేస్-సెన్సిటివ్ క్యారెక్టర్ చేర్చకపోతే (అన్ని అక్షరాలు కేస్-ఇన్‌సెన్సిటివ్) నిర్ణయం తప్పు.

print('PYTHON 123'.isupper())
# True

print('123'.isupper())
# False

str.islower(): అన్ని అక్షరాలు చిన్న అక్షరాలు కాదా అని నిర్ణయించండి

islower() అది కనీసం ఒక కేస్-సెన్సిటివ్ క్యారెక్టర్‌ని కలిగి ఉంటే మరియు అవన్నీ చిన్న అక్షరాలు మరియు తప్పు అయితే ఒప్పు అని చూపుతుంది.

print('python'.islower())
# True

print('Python'.islower())
# False

పాత్ర కేస్-సెన్సిటివ్ అయితే, డబుల్ బైట్ అక్షరాలు కూడా నిర్ణయించబడతాయి.

print('ｐｙｔｈｏｎ'.islower())
# True

కేస్-సెన్సిటివ్ క్యారెక్టర్‌ని కూడా చేర్చినట్లయితే, కేస్-సెన్సిటివ్ క్యారెక్టర్ విస్మరించబడుతుంది, కానీ కేస్-సెన్సిటివ్ క్యారెక్టర్ చేర్చకపోతే (అన్ని అక్షరాలు కేస్-ఇన్‌సెన్సిటివ్) నిర్ణయం తప్పు.

print('python 123'.islower())
# True

print('123'.islower())
# False

str.istitle(): కేసు టైటిల్ కేస్ కాదా అని నిర్ణయించండి.

స్ట్రింగ్ టైటిల్ కేస్ అయితే istitle() true అని చూపుతుంది (పదం యొక్క మొదటి అక్షరం పెద్ద అక్షరం, మిగిలినవి చిన్న అక్షరం), లేకపోతే తప్పు.

print('Python Programming Language'.istitle())
# True

print('PYTHON Programming Language'.istitle())
# False

ఇది కేస్-ఇన్‌సెన్సిటివ్ క్యారెక్టర్‌లను కలిగి ఉన్నట్లయితే, కేస్-ఇన్‌సెన్సిటివ్ క్యారెక్టర్‌ల ముందు చిన్న అక్షరం ఉంటే అది తప్పు అవుతుంది.

print('★Python Programming Language'.istitle())
# True

print('Python★ Programming Language'.istitle())
# True

print('Py★thon Programming Language'.istitle())
# False

ఎగువ ఉదాహరణ వంటి అనేక స్ట్రింగ్‌లు లేవని గమనించండి, అయితే ఆర్డినల్ సంఖ్యలు మరియు ఇతర సందర్భాల్లో సంఖ్యలను చేర్చడం వాస్తవికమైనది.

print('The 1st Team'.istitle())
# False

print('The 1St Team'.istitle())
# True

కేస్-సెన్సిటివ్ అక్షరాలు ఏవీ చేర్చబడకపోతే (అన్ని అక్షరాలు కేస్-ఇన్సెన్సిటివ్), తప్పు.

print('123'.istitle())
# False

కేస్-సెన్సిటివ్ పద్ధతిలో స్ట్రింగ్‌లను సరిపోల్చండి

తీగలను పోల్చినప్పుడు, వివిధ పెద్ద అక్షరాలు మరియు చిన్న అక్షరాలు సమానమైనవిగా పరిగణించబడవు.

s1 = 'python'
s2 = 'PYTHON'

print(s1 == s2)
# False

మీరు కేస్-ఇన్‌సెన్సిటివ్ పోలికను చేయాలనుకుంటే, రెండింటిని మార్చడానికి మరియు వాటిని సరిపోల్చడానికి మీరు ఎగువ() లేదా దిగువ()ని ఉపయోగించవచ్చు.

print(s1.upper() == s2.upper())
# True

print(s1.lower() == s2.lower())
# True

print(s1.capitalize() == s2.capitalize())
# True

print(s1.title() == s2.title())
# True
Copied title and URL