પાયથોનમાં અપરકેસ અને લોઅરકેસ અક્ષરોની હેરફેર માટે સ્ટ્રિંગ પદ્ધતિઓની સૂચિ

બિઝનેસ

પાયથોનનો શબ્દમાળા પ્રકાર (str) અપરકેસ અને લોઅરકેસ અક્ષરોની હેરફેર માટે અનુકૂળ પદ્ધતિઓ સાથે પ્રમાણભૂત આવે છે. તમે અપરકેસ અને લોઅરકેસ વચ્ચે કન્વર્ટ કરી શકો છો અને કેસ નક્કી કરી શકો છો.

નીચેની માહિતી અહીં આપવામાં આવી છે.

  • અપરકેસ અને લોઅરકેસ અક્ષરો વચ્ચે રૂપાંતર
    • મૂળભૂત ઉપયોગ
    • પૂર્ણ-કદના અને અડધા-કદના અક્ષરોનું સંચાલન
    • str.upper()બધા અક્ષરોને અપરકેસમાં કન્વર્ટ કરો
    • str.lower()બધા અક્ષરોને લોઅરકેસમાં કન્વર્ટ કરો
    • str.capitalize()પહેલા અક્ષરને અપરકેસમાં અને બાકીના અક્ષરને લોઅરકેસમાં કન્વર્ટ કરો.
    • str.title()શબ્દના પહેલા અક્ષરને અપરકેસમાં અને બાકીના અક્ષરને લોઅરકેસમાં કન્વર્ટ કરો.
    • str.swapcase()અપરકેસ અક્ષરોને લોઅરકેસમાં અને લોઅરકેસ અક્ષરોને અપરકેસમાં કન્વર્ટ કરો.
  • અપરકેસ અને લોઅરકેસ અક્ષરો નક્કી કરો
    • str.isupper(): બધા અક્ષરો અપરકેસ છે કે કેમ તે નક્કી કરો
    • str.islower(): બધા અક્ષરો લોઅરકેસ છે કે કેમ તે નક્કી કરો.
    • str.istitle(): તે શીર્ષક કેસ છે કે કેમ તે નક્કી કરો.
  • કેસ-અસંવેદનશીલ રીતે શબ્દમાળાઓની તુલના કરો

અપરકેસ અને લોઅરકેસ અક્ષરો વચ્ચે રૂપાંતર

મૂળભૂત ઉપયોગ

પ્રથમ, હું મૂળભૂત ઉપયોગ સમજાવીશ. અમે ઉદાહરણ તરીકે બધા અક્ષરોને મોટા કરવા માટે upper() પદ્ધતિનો ઉપયોગ કરીશું, પરંતુ તે જ અન્ય પદ્ધતિઓ પર લાગુ થાય છે.

સગવડ માટે, અમે “રૂપાંતરણ” લખીએ છીએ, પરંતુ પાયથોનમાં, સ્ટ્રિંગ પ્રકાર (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

પૂર્ણ-કદના અને અડધા-કદના અક્ષરોનું સંચાલન

જો અક્ષર કેસ-સંવેદનશીલ હોય, જેમ કે મૂળાક્ષર, તો તે સિંગલ-બાઈટ અને ડબલ-બાઈટ બંને અક્ષરોમાં રૂપાંતરિત થશે.

અક્ષરો કે જે કેસ-સંવેદનશીલ નથી, જેમ કે સંખ્યાઓ અને ચાઇનીઝ અક્ષરો, યથાવત રહે છે. ઉદાહરણ upper() માટે છે, પરંતુ તે જ અન્ય પદ્ધતિઓ પર લાગુ થાય છે.

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

જો તમે કેસ-અસંવેદનશીલ સરખામણી કરવા માંગો છો, તો તમે બેને કન્વર્ટ કરવા અને તેમની સરખામણી કરવા માટે upper() અથવા low() નો ઉપયોગ કરી શકો છો.

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