பைத்தானில் பெரிய மற்றும் சிறிய எழுத்துக்களை கையாளும் சரம் முறைகளின் பட்டியல்

வணிக

பைத்தானின் சரம் வகை (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() சரம் ஒரு தலைப்பு வழக்காக இருந்தால் சரி (வார்த்தையின் முதல் எழுத்து பெரிய எழுத்து, மீதமுள்ளவை சிறிய எழுத்து), இல்லையெனில் தவறானவை என வழங்கும்.

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