ਪਾਈਥਨ ਵਿੱਚ ਵੱਡੇ ਅਤੇ ਛੋਟੇ ਅੱਖਰਾਂ ਦੀ ਹੇਰਾਫੇਰੀ ਲਈ ਸਤਰ ਵਿਧੀਆਂ ਦੀ ਸੂਚੀ

ਪਾਇਥਨ ਦੀ ਸਤਰ ਕਿਸਮ (str) ਵੱਡੇ ਅਤੇ ਛੋਟੇ ਅੱਖਰਾਂ ਦੀ ਹੇਰਾਫੇਰੀ ਲਈ ਸੁਵਿਧਾਜਨਕ ਤਰੀਕਿਆਂ ਨਾਲ ਮਿਆਰੀ ਆਉਂਦੀ ਹੈ। ਤੁਸੀਂ ਵੱਡੇ ਅਤੇ ਛੋਟੇ ਅੱਖਰਾਂ ਵਿੱਚ ਬਦਲ ਸਕਦੇ ਹੋ ਅਤੇ ਕੇਸ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ।

• String Methods — Built-in Types — Python 3.10.0 Documentation

ਹੇਠਾਂ ਦਿੱਤੀ ਜਾਣਕਾਰੀ ਇੱਥੇ ਦਿੱਤੀ ਗਈ ਹੈ।

• ਵੱਡੇ ਅਤੇ ਛੋਟੇ ਅੱਖਰਾਂ ਵਿੱਚ ਬਦਲਣਾ
  • ਮੁੱਢਲੀ ਵਰਤੋਂ
  • ਪੂਰੇ-ਆਕਾਰ ਅਤੇ ਅੱਧ-ਆਕਾਰ ਦੇ ਅੱਖਰਾਂ ਨੂੰ ਸੰਭਾਲਣਾ
  • 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() ਜਾਂ Lower() ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।

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

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

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

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