Python හි ලොකු අකුරු සහ කුඩා අකුරු හැසිරවීම සඳහා තන්තු ක්‍රම ලැයිස්තුව

ව්යාපාරික

Python’s string type (str) විශාල අකුරු සහ කුඩා අකුරු හැසිරවීම සඳහා පහසු ක්‍රම සමඟ සම්මත වේ. ඔබට විශාල අකුරු සහ කුඩා අකුරු අතර පරිවර්තනය කර නඩුව තීරණය කළ හැකිය.

පහත තොරතුරු මෙහි දක්වා ඇත.

  • ලොකු අකුරු සහ කුඩා අකුරු අතර පරිවර්තනය
    • මූලික භාවිතය
    • සම්පූර්ණ ප්‍රමාණයේ සහ අර්ධ ප්‍රමාණයේ අක්ෂර හැසිරවීම
    • str.upper()සියලුම අකුරු ලොකු අකුරට පරිවර්තනය කරන්න
    • str.lower()සියලුම අකුරු කුඩා අකුරට පරිවර්තනය කරන්න
    • str.capitalize()පළමු අකුර ලොකු අකුරට සහ ඉතිරිය කුඩා අකුරට පරිවර්තනය කරන්න.
    • str.title()වචනයක මුල් අකුර ලොකු අකුරටත් ඉතිරිය කුඩා අකුරටත් පරිවර්තනය කරන්න.
    • str.swapcase()ලොකු අකුරු කුඩා අකුරු සහ කුඩා අකුරු ලොකු අකුරු බවට පරිවර්තනය කරන්න.
  • ලොකු අකුරු සහ කුඩා අකුරු තීරණය කරන්න
    • str.isupper(): සියලුම අකුරු ලොකු අකුරුද යන්න තීරණය කරන්න
    • str.islower(): සියලුම අක්ෂර කුඩා අකුරුද යන්න තීරණය කරන්න.
    • str.istitle(): එය මාතෘකා නඩුවක් දැයි තීරණය කරන්න.
  • කේස් සංවේදී නොවන ආකාරයෙන් නූල් සසඳන්න

ලොකු අකුරු සහ කුඩා අකුරු අතර පරිවර්තනය

මූලික භාවිතය

පළමුව, මම මූලික භාවිතය පැහැදිලි කරමි. උදාහරණයක් ලෙස සියලුම අකුරු කැපිටල් කිරීමට අපි ඉහල() ක්‍රමය භාවිතා කරමු, නමුත් අනෙකුත් ක්‍රම වලටද එයම අදාල වේ.

පහසුව සඳහා, අපි “පරිවර්තනය” ලියන්නෙමු, නමුත් Python හි, string ආකාරයේ (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

ලොකු අකුරු සහ කුඩා අකුරු තීරණය කරන්න

පහත උදාහරණ වලදී, ‘python’ වැනි තන්තු වචන වලින් ක්‍රම කෙලින්ම කැඳවනු ලැබේ, නමුත් පෙර උදාහරණවල මෙන් විචල්‍යවල ගබඩා කිරීමේදී එයම සත්‍ය වේ.

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(): නඩුව මාතෘකා නඩුවක් දැයි තීරණය කරන්න.

string මාතෘකා නඩුවක් නම් 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