ਵਿਸ਼ਾ - ਸੂਚੀ[ਛੁਪਾਓ][ਦਿਖਾਓ]
ਕਰੈਸ਼ ਕੋਰਸ ਵਿੱਚ ਤੀਜੇ ਲੈਕਚਰ ਵਿੱਚ ਤੁਹਾਡਾ ਸੁਆਗਤ ਹੈ।
ਇਸ ਲੈਕਚਰ ਵਿੱਚ, ਅਸੀਂ ਪਾਇਥਨ ਵਿੱਚ ਸਟ੍ਰਿੰਗਸ ਨਾਲ ਨਜਿੱਠਣਾ ਸਿੱਖਾਂਗੇ। ਆਪਣਾ ਪੌਪਕਾਰਨ ਤਿਆਰ ਕਰੋ ਅਤੇ ਕੱਸ ਕੇ ਬੈਠੋ।
ਸਤਰ
ਪਹਿਲਾਂ, ਆਓ ਕੋਟਸ ਬਾਰੇ ਗੱਲ ਕਰੀਏ ਅਤੇ ਪਾਈਥਨ ਵਿੱਚ ਪੇਸ਼ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਉਲਝਣ ਨੂੰ ਦੂਰ ਕਰੀਏ।
ਜਿਵੇਂ ਕਿ ਪਹਿਲਾਂ ਦੱਸਿਆ ਗਿਆ ਹੈ, ਅਸੀਂ ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਫੰਕਸ਼ਨ ਤੋਂ ਬਾਅਦ ਸਿੰਗਲ ਅਤੇ ਡਬਲ ਕੋਟਸ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ। ਇਸ ਦੀ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਉਪਯੋਗਤਾ ਹੈ। ਮੰਨ ਲਓ ਕਿ ਤੁਸੀਂ ਇਸ ਤਰ੍ਹਾਂ ਦਾ ਕੁਝ ਪ੍ਰਿੰਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ।
print('This is Shahbaz's computer')
ਹੁਣ ਉਪਰੋਕਤ ਸਮੀਕਰਨ ਵਿੱਚ, "ਸ਼ਾਹਬਾਜ਼" ਦੇ ਦੂਜੇ ਹਵਾਲੇ ਤੋਂ ਬਾਅਦ ਸਭ ਕੁਝ ਪਾਈਥਨ ਦੁਭਾਸ਼ੀਏ ਦੁਆਰਾ ਅਣਜਾਣ ਹੋ ਜਾਵੇਗਾ ਕਿਉਂਕਿ ਪਾਈਥਨ ਸਟਰਿੰਗ ਦੇ ਅੰਤ ਵਿੱਚ ਦੂਜੇ ਹਵਾਲੇ ਨੂੰ ਲਵੇਗਾ। ਉਸ ਸਥਿਤੀ ਵਿੱਚ, ਤੁਸੀਂ ਸਤਰ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਘੋਸ਼ਿਤ ਕਰਨ ਲਈ ਡਬਲ ਕੋਟਸ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ:
print("This is Shahbaz's computer")
ਇਸ ਨੂੰ ਦੂਜੇ ਤਰੀਕੇ ਨਾਲ ਵੀ ਲਾਗੂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਅਸੀਂ ਸਿੰਗਲ ਕੋਟਸ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ ਜੇਕਰ ਸਤਰ ਦੇ ਅੰਦਰ ਦੋਹਰੇ ਹਵਾਲੇ ਹਨ। ਜਿਵੇਂ ਕਿ
print('This "computer" belongs to Shahbaz')
ਹੁਣ ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਸਟ੍ਰਿੰਗ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਜੋ ਕਈ ਲਾਈਨਾਂ ਨੂੰ ਫੈਲਾਉਂਦੀ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਸਤਰ ਨੂੰ ਨੱਥੀ ਕਰਨ ਲਈ ਤੀਹਰੀ ਕੋਟਸ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਪਵੇਗੀ। ਸਤਰ ਦੀ ਸਮੱਗਰੀ ਦੇ ਆਧਾਰ 'ਤੇ ਇਹ ਕੋਟਸ ਸਿੰਗਲ ਜਾਂ ਡਬਲ ਵੀ ਹੋ ਸਕਦੇ ਹਨ। ਉਦਾਹਰਣ ਲਈ:
ਹੁਣ ਮੰਨ ਲਓ ਕਿ ਤੁਸੀਂ ਸਟ੍ਰਿੰਗ ਤੋਂ ਇੱਕ ਖਾਸ ਅੱਖਰ ਪ੍ਰਿੰਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ। ਤੁਸੀਂ ਇਹ ਕਿਵੇਂ ਕਰੋਗੇ?
ਪਾਈਥਨ ਇੰਟਰਪ੍ਰੇਟਰ ਸਤਰ ਵਿੱਚ ਅੱਖਰਾਂ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਇੰਡੈਕਸ ਕਰਦਾ ਹੈ:
ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਟਰਮੀਨਲ ਵਿੱਚ ਦੇਖ ਸਕਦੇ ਹੋ, ਸਿਰਫ 'h' ਪ੍ਰਿੰਟ ਕੀਤਾ ਗਿਆ ਹੈ। ਅਜਿਹਾ ਇਸ ਲਈ ਕਿਉਂਕਿ ਅਸੀਂ ਟਰਮੀਨਲ 'ਤੇ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ ਆਪਣੀ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਸਿਰਫ਼ ਤੀਸਰੇ ਅੱਖਰ ਨੂੰ ਚੁਣਿਆ ਹੈ, 3 ਵਰਗਾਕਾਰ ਬਰੈਕਟਾਂ ਵਿੱਚ ਵੇਰੀਏਬਲ ਦੇ ਬਾਅਦ ਲਿਖੋ। ਪਾਇਥਨ ਇੰਟਰਪ੍ਰੇਟਰ ਵੀ ਵੱਡੀਆਂ ਸਤਰਾਂ ਨੂੰ ਸਰਲ ਬਣਾਉਣ ਲਈ ਅੱਖਰਾਂ ਨੂੰ ਨਕਾਰਾਤਮਕ ਵਿੱਚ ਸੂਚੀਬੱਧ ਕਰਦਾ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ '-1' ਸਤਰ ਵਿੱਚ ਆਖਰੀ ਨੰਬਰ ਹੋਵੇਗਾ ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਹੀ। ਨੋਟ ਕਰੋ ਕਿ ਸਪੇਸ ਇੰਡੈਕਸਡ ਨਹੀਂ ਹਨ ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਉਪਰੋਕਤ ਸਤਰ ਵਿੱਚ ਸਿਰਫ 21 ਇੰਡੈਕਸਡ ਸਪੇਸ ਹੋਣਗੇ।
ਤੁਸੀਂ ਸਤਰ ਵਿੱਚੋਂ ਅੱਖਰਾਂ ਦੀ ਇੱਕ ਲੜੀ ਵੀ ਚੁਣ ਸਕਦੇ ਹੋ। ਜਿਵੇਂ ਕਿ
HashDork = ('Python Course by Shahbaz')
print(HashDork[0:3])
ਇਹ ਪ੍ਰੋਗਰਾਮ ਟਰਮੀਨਲ 'ਤੇ 'Pyt' ਨੂੰ ਪ੍ਰਿੰਟ ਕਰੇਗਾ। ਇੰਡੈਕਸ 3 ਨੂੰ ਇਸ ਤੋਂ ਬਾਹਰ ਰੱਖਿਆ ਗਿਆ ਹੈ।
HashDork = ('Python Course by Shahbaz')
print(HashDork[2:])
ਇਸੇ ਤਰ੍ਹਾਂ, ਜੇਕਰ ਅਸੀਂ ਅੰਤਮ ਸੂਚਕਾਂਕ ਦੀ ਸਪਲਾਈ ਨਹੀਂ ਕਰਦੇ ਹਾਂ, ਤਾਂ ਪਾਈਥਨ ਪਹਿਲੇ ਸੂਚਕਾਂਕ ਤੋਂ ਬਾਅਦ ਪੂਰੀ ਸਤਰ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰੇਗਾ। ਇਸ ਪ੍ਰੋਗਰਾਮ ਦਾ ਆਉਟਪੁੱਟ 'ਥੌਨ ਕੋਰਸ ਬਾਏ ਸ਼ਾਹਬਾਜ਼' ਹੋਵੇਗਾ। ਇਹ ਉਲਟ ਰੱਖਦਾ ਹੈ. ਭਾਵ ਜੇਕਰ ਅਸੀਂ ਪਹਿਲੀ ਸੂਚਕਾਂਕ ਨੂੰ ਖੁੰਝਦੇ ਹਾਂ ਤਾਂ ਸ਼ੁਰੂ ਤੋਂ ਲੈ ਕੇ ਆਖਰੀ ਪਰਿਭਾਸ਼ਿਤ ਸੂਚਕਾਂਕ ਤੱਕ ਸਾਰੀ ਸਤਰ ਪ੍ਰਿੰਟ ਹੋ ਜਾਵੇਗੀ।
ਇੰਡੈਕਸਿੰਗ ਬਰੈਕਟਾਂ ਵਿੱਚ ਕੇਵਲ ਕੌਲਨ ਵਾਲਾ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਟਰਮੀਨਲ 'ਤੇ ਪੂਰੀ ਸਤਰ ਪ੍ਰਦਾਨ ਕਰੇਗਾ।
ਐਕਸਸਰਕਸ
ਇੱਥੇ ਇੱਕ ਦਿਲਚਸਪ ਅਭਿਆਸ ਹੈ
ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਲਿਖੋ ਜੋ [1:-1] ਦੇ ਸੂਚਕਾਂਕ ਅੰਤਰਾਲ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ। ਤੁਸੀਂ ਕੀ ਸੋਚਦੇ ਹੋ ਕਿ ਆਉਟਪੁੱਟ ਹੋਵੇਗੀ. ਇਸ ਨੂੰ ਆਪਣੇ ਆਪ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ.
ਫਾਰਮੈਟ ਕੀਤੀਆਂ ਸਤਰ
ਫਾਰਮੈਟ ਕੀਤੀਆਂ ਸਟ੍ਰਿੰਗਾਂ ਖਾਸ ਤੌਰ 'ਤੇ ਉਹਨਾਂ ਸਥਿਤੀਆਂ ਵਿੱਚ ਉਪਯੋਗੀ ਹੁੰਦੀਆਂ ਹਨ ਜਿੱਥੇ ਤੁਸੀਂ ਆਪਣੇ ਵੇਰੀਏਬਲਾਂ ਨਾਲ ਗਤੀਸ਼ੀਲ ਤੌਰ 'ਤੇ ਕੁਝ ਟੈਕਸਟ ਤਿਆਰ ਕਰਦੇ ਹੋ। ਮੈਨੂੰ ਤੁਹਾਨੂੰ ਦਿਖਾਉਣ ਦਿਓ.
ਮੰਨ ਲਓ ਸਾਡੇ ਕੋਲ ਦੋ ਵੇਰੀਏਬਲ ਹਨ, ਪਹਿਲਾ ਨਾਮ ਅਤੇ ਆਖਰੀ ਨਾਮ।
first_name = 'Shahbaz'
last_name = 'Bhatti'
ਹੁਣ ਅਸੀਂ ਟਰਮੀਨਲ 'ਤੇ 'ਸ਼ਾਹਬਾਜ਼ [ਭੱਟੀ] ਇੱਕ ਕੋਡਰ ਹੈ' ਪ੍ਰਿੰਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ। ਅਸੀਂ ਇਹ ਕਿਵੇਂ ਕਰਾਂਗੇ? ਅਸੀਂ ਇਸ ਤਰ੍ਹਾਂ ਦਾ ਤੀਜਾ ਵੇਰੀਏਬਲ ਪੇਸ਼ ਕਰਾਂਗੇ:
message = 'first_name + ' [' + last_name + '] is a coder'
ਹੁਣ ਜੇਕਰ ਅਸੀਂ ਇਸ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਪ੍ਰਿੰਟ ਅਤੇ ਰਨ ਕਰਦੇ ਹਾਂ, ਤਾਂ ਸਾਨੂੰ ਟਰਮੀਨਲ 'ਤੇ 'ਸ਼ਾਹਬਾਜ਼ [ਭੱਟੀ] ਇੱਕ ਕੋਡਰ ਹੈ' ਮਿਲੇਗਾ।
ਹਾਲਾਂਕਿ ਇਹ ਪਹੁੰਚ ਪੂਰੀ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦੀ ਹੈ, ਇਹ ਆਦਰਸ਼ ਨਹੀਂ ਹੈ ਕਿਉਂਕਿ ਜਿਵੇਂ ਕਿ ਸਾਡਾ ਟੈਕਸਟ ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਹੋ ਜਾਂਦਾ ਹੈ, ਆਉਟਪੁੱਟ ਦੀ ਕਲਪਨਾ ਕਰਨਾ ਔਖਾ ਹੋ ਜਾਂਦਾ ਹੈ। ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਅਸੀਂ ਫਾਰਮੈਟ ਕੀਤੀਆਂ ਸਤਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ, ਉਹ ਸਾਡੇ ਲਈ ਆਉਟਪੁੱਟ ਦੀ ਕਲਪਨਾ ਕਰਨਾ ਆਸਾਨ ਬਣਾਉਂਦੇ ਹਨ।
ਆਉ ਤੀਜੇ ਵੇਰੀਏਬਲ 'ਮੈਸੇਜ' ਨੂੰ ਬਦਲੀਏ ਅਤੇ ਇੱਕ ਫਾਰਮੈਟ ਕੀਤੀ ਸਤਰ ਪੇਸ਼ ਕਰੀਏ। ਫਾਰਮੈਟ ਕੀਤੀਆਂ ਸਟ੍ਰਿੰਗਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਲਈ, ਆਪਣੀਆਂ ਸਟ੍ਰਿੰਗਾਂ ਨੂੰ 'f' ਨਾਲ ਅਗੇਤਰ ਲਗਾਓ ਅਤੇ ਫਿਰ ਆਪਣੀਆਂ ਸਤਰਾਂ ਵਿੱਚ ਗਤੀਸ਼ੀਲ ਰੂਪ ਵਿੱਚ ਮੁੱਲਾਂ ਨੂੰ ਸੰਮਿਲਿਤ ਕਰਨ ਲਈ ਕਰਲੀ ਬਰੇਸ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਸਾਡਾ ਪ੍ਰੋਗਰਾਮ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗਾ:
first_name = 'Shahbaz'
last_name = 'Bhatti'
message = f'{first_name} [{last_name}] is a coder'
ਫਾਰਮੈਟ ਕੀਤੀਆਂ ਸਟ੍ਰਿੰਗਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਲਈ, ਆਪਣੀਆਂ ਸਟ੍ਰਿੰਗਾਂ ਨੂੰ ਇੱਕ F ਨਾਲ ਅਗੇਤਰ ਲਗਾਓ ਅਤੇ ਫਿਰ ਆਪਣੀਆਂ ਸਤਰਾਂ ਵਿੱਚ ਗਤੀਸ਼ੀਲ ਰੂਪ ਵਿੱਚ ਮੁੱਲਾਂ ਨੂੰ ਸੰਮਿਲਿਤ ਕਰਨ ਲਈ ਕਰਲੀ ਬਰੇਸ ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਵਧੀਆ ਚੀਜ਼ਾਂ ਜੋ ਤੁਸੀਂ ਪਾਈਥਨ ਸਟ੍ਰਿੰਗਸ ਨਾਲ ਕਰ ਸਕਦੇ ਹੋ
ਮੈਂ ਤੁਹਾਨੂੰ ਕੁਝ ਬਹੁਤ ਵਧੀਆ ਚੀਜ਼ਾਂ ਦਿਖਾਉਣ ਜਾ ਰਿਹਾ ਹਾਂ ਜੋ ਤੁਸੀਂ ਪਾਈਥਨ ਸਟ੍ਰਿੰਗਜ਼ ਨਾਲ ਕਰ ਸਕਦੇ ਹੋ।
1. ਇੱਕ ਸਤਰ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਸੰਖਿਆ
ਤਾਂ ਆਓ ਇੱਕ ਵੇਰੀਏਬਲ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਕੇ ਸ਼ੁਰੂ ਕਰੀਏ:
message = 'Shahbaz Bhatti is a Coder '
ਹੁਣ ਜੇਕਰ ਮੈਂ ਉਪਰੋਕਤ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਸੰਖਿਆ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹਾਂ, ਤਾਂ ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ "len" ਹੈ। ਬਸ ਇਸ ਤਰ੍ਹਾਂ ਇਸ ਫੰਕਸ਼ਨ ਨਾਲ ਵੇਰੀਏਬਲ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰੋ
print(len(message))
ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਲਾਭਦਾਇਕ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਉਪਭੋਗਤਾ ਤੋਂ ਇੰਪੁੱਟ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹੋ। ਉਦਾਹਰਨ ਲਈ, ਤੁਸੀਂ ਦੇਖਿਆ ਹੈ ਕਿ ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ ਫਾਰਮ ਔਨਲਾਈਨ ਭਰਦੇ ਹੋ, ਤਾਂ ਹਰੇਕ ਇਨਪੁਟ ਖੇਤਰ ਦੀ ਅਕਸਰ ਇੱਕ ਸੀਮਾ ਹੁੰਦੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਤੁਹਾਡੇ ਕੋਲ ਤੁਹਾਡੇ ਨਾਮ ਲਈ 50 ਅੱਖਰ ਹੋ ਸਕਦੇ ਹਨ, ਇਸਲਈ ਇਸ "len" ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਸੀਂ ਇੱਕ ਇਨਪੁਟ ਖੇਤਰ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਗਿਣਤੀ 'ਤੇ ਇੱਕ ਸੀਮਾ ਲਾਗੂ ਕਰ ਸਕਦੇ ਹਾਂ।
2. ਇੱਕ ਸਤਰ ਵਿੱਚ ਅੱਖਰਾਂ ਨੂੰ ਵੱਡੇ ਜਾਂ ਛੋਟੇ ਅੱਖਰਾਂ ਵਿੱਚ ਬਦਲਣਾ
ਅਸੀਂ ਡਾਟ ਆਪਰੇਟਰ ਰਾਹੀਂ ਸਟ੍ਰਿੰਗ-ਸਬੰਧਤ ਫੰਕਸ਼ਨਾਂ ਤੱਕ ਪਹੁੰਚ ਕਰ ਸਕਦੇ ਹਾਂ। ਤੁਸੀਂ ਆਪਣਾ ਵੇਰੀਏਬਲ ਨਾਮ ਟਾਈਪ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸਦੇ ਅੱਗੇ ਇੱਕ ਬਿੰਦੀ ਲਗਾ ਕੇ, ਤੁਸੀਂ ਅਜਿਹੇ ਸਾਰੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਸੂਚੀ ਵੇਖ ਸਕਦੇ ਹੋ।
ਹੁਣ ਵਧੇਰੇ ਸਟੀਕ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਤੁਸੀਂ ਇਹਨਾਂ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਵਿਧੀਆਂ ਦੇ ਰੂਪ ਵਿੱਚ ਕਹਿੰਦੇ ਹੋ, ਇਹ ਆਬਜੈਕਟ-ਓਰੀਐਂਟਡ ਪ੍ਰੋਗਰਾਮਿੰਗ ਵਿੱਚ ਇੱਕ ਸ਼ਬਦ ਹੈ ਜਿਸਨੂੰ ਅਸੀਂ ਭਵਿੱਖ ਵਿੱਚ ਦੇਖਣਾ ਚਾਹੁੰਦੇ ਹਾਂ, ਪਰ ਹੁਣ ਲਈ, ਮੈਂ ਤੁਹਾਨੂੰ ਜੋ ਲੈਣਾ ਚਾਹੁੰਦਾ ਹਾਂ, ਉਹ ਹੈ ਜਦੋਂ ਇੱਕ ਫੰਕਸ਼ਨ ਕਿਸੇ ਹੋਰ ਚੀਜ਼ ਨਾਲ ਸਬੰਧਤ ਹੈ ਜਾਂ ਕਿਸੇ ਕਿਸਮ ਦੀ ਵਸਤੂ ਲਈ ਵਿਸ਼ੇਸ਼ ਹੈ, ਅਸੀਂ ਉਸ ਫੰਕਸ਼ਨ ਨੂੰ ਇੱਕ ਵਿਧੀ ਦੇ ਰੂਪ ਵਿੱਚ ਕਹਿੰਦੇ ਹਾਂ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਅਸੀਂ ਸਟ੍ਰਿੰਗ ਨੂੰ ਵੱਡੇ ਅੱਖਰਾਂ ਵਿੱਚ ਬਦਲਣ ਲਈ "ਅਪਰ" ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ।
ਕਿਉਂਕਿ ਇਹ ਫੰਕਸ਼ਨ ਇੱਕ ਸਟ੍ਰਿੰਗ ਲਈ ਖਾਸ ਹੈ, ਅਸੀਂ ਇਸਨੂੰ ਇੱਕ ਵਿਧੀ ਦੇ ਤੌਰ ਤੇ ਕਹਿੰਦੇ ਹਾਂ। ਇਸਦੇ ਉਲਟ "len" ਅਤੇ "ਪ੍ਰਿੰਟ" ਆਮ-ਉਦੇਸ਼ ਵਾਲੇ ਫੰਕਸ਼ਨ ਹਨ, ਉਹ ਸਤਰ ਜਾਂ ਸੰਖਿਆਵਾਂ ਜਾਂ ਹੋਰ ਕਿਸਮ ਦੀਆਂ ਵਸਤੂਆਂ ਨਾਲ ਸਬੰਧਤ ਨਹੀਂ ਹਨ। ਇਹ ਇੱਕ ਫੰਕਸ਼ਨ ਅਤੇ ਇੱਕ ਵਿਧੀ ਵਿੱਚ ਬੁਨਿਆਦੀ ਅੰਤਰ ਹੈ।
ਹੁਣ, ਆਓ ਇਸ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰੀਏ.
message = 'Shahbaz Bhatti is a coder'
print(message.upper())
ਅਤੇ ਅਸੀਂ ਦੇਖ ਸਕਦੇ ਹਾਂ ਕਿ ਸਾਨੂੰ ਸਾਡੀ ਸਤਰ ਵੱਡੇ ਅੱਖਰਾਂ ਵਿੱਚ ਮਿਲੀ ਹੈ। ਇਸੇ ਤਰ੍ਹਾਂ, ਸਾਡੇ ਕੋਲ ਸਟ੍ਰਿੰਗ ਨੂੰ ਛੋਟੇ ਅੱਖਰਾਂ ਵਿੱਚ ਬਦਲਣ ਲਈ "ਲੋਅਰ" ਵਿਧੀ ਹੈ। ਤੁਸੀਂ ਸਤਰ ਦੇ ਹਰੇਕ ਸ਼ਬਦ ਨੂੰ ਵੱਡਾ ਕਰਨ ਲਈ "ਸਿਰਲੇਖ" ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ।
ਨੋਟ ਕਰੋ ਕਿ ਵਿਧੀ ਸਾਡੀ ਮੂਲ ਸਤਰ ਨੂੰ ਬਦਲਦੀ ਜਾਂ ਸੋਧਦੀ ਨਹੀਂ ਹੈ। ਅਸਲ ਵਿੱਚ, ਇਹ ਇੱਕ ਨਵੀਂ ਸਤਰ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ।
3. ਇੱਕ ਸਤਰ ਵਿੱਚ ਅੱਖਰਾਂ ਦਾ ਕ੍ਰਮ ਲੱਭੋ
ਆਉ ਸਟਰਿੰਗ ਵਿੱਚ ਕਿਸੇ ਖਾਸ ਅੱਖਰ ਦੀ ਸੂਚਕਾਂਕ ਨੂੰ ਲੱਭਣ ਲਈ ਇੱਕ ਹੋਰ ਢੰਗ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ।
ਕਿਸਮ:
message.find('b')
ਉਸੇ ਵੇਰੀਏਬਲ ਤੋਂ ਬਾਅਦ ਅਤੇ ਇਸਨੂੰ ਪ੍ਰਿੰਟ ਕਰੋ. ਇਹ ਸਤਰ ਵਿੱਚ ਅੱਖਰ 'b' ਦੀ ਪਹਿਲੀ ਮੌਜੂਦਗੀ ਦਾ ਸੂਚਕਾਂਕ ਪ੍ਰਿੰਟ ਕਰੇਗਾ ਜੋ ਕਿ ਇਸ ਕੇਸ ਵਿੱਚ 4 ਹੈ।
ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਵਿਧੀ ਕੇਸ-ਸੰਵੇਦਨਸ਼ੀਲ ਹੈ ਅਤੇ ਇਹ -1 ਵਾਪਸ ਆ ਜਾਵੇਗੀ ਜੇਕਰ ਅੱਖਰ ਸਤਰ ਵਿੱਚ ਨਹੀਂ ਮਿਲਦਾ ਹੈ। ਇਹ ਅੱਖਰਾਂ ਦੇ ਕ੍ਰਮ ਲਈ ਵੀ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।
ਉਦਾਹਰਨ ਲਈ, ਹੇਠ ਦਿੱਤੇ ਪ੍ਰੋਗਰਾਮ:
message = 'Shahbaz Bhatti is a coder'
print(message.find('coder'))
"20" ਮੁੱਲ ਵਾਪਸ ਕਰੇਗਾ ਕਿਉਂਕਿ ਕ੍ਰਮ "ਕੋਡਰ" ਸੂਚਕਾਂਕ 20 ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ।
4. ਇੱਕ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਇੱਕ ਅੱਖਰ ਨੂੰ ਬਦਲਣਾ
ਤੁਸੀਂ ਇੱਕ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਇੱਕ ਅੱਖਰ ਜਾਂ ਅੱਖਰਾਂ ਦੇ ਕ੍ਰਮ ਨੂੰ ਬਦਲਣ ਲਈ "ਬਦਲੋ" ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਆਓ ਇਸ ਨੂੰ ਕਾਰਵਾਈ ਵਿੱਚ ਵੇਖੀਏ.
message = 'Shahbaz Bhatti is a coder'
print(message.replace('coder', 'programmer'))
ਇਹ ਪ੍ਰੋਗਰਾਮ "ਕੋਡਰ" ਸ਼ਬਦ ਨੂੰ "ਪ੍ਰੋਗਰਾਮਰ" ਨਾਲ ਬਦਲ ਦੇਵੇਗਾ ਅਤੇ ਇਸਨੂੰ ਟਰਮੀਨਲ 'ਤੇ ਪ੍ਰਿੰਟ ਕਰੇਗਾ।
5. ਇੱਕ ਸਤਰ ਵਿੱਚ ਇੱਕ ਅੱਖਰ ਦੀ ਮੌਜੂਦਗੀ ਦੀ ਜਾਂਚ ਕਰੋ
ਹੁਣ ਅਜਿਹੇ ਮੌਕੇ ਹਨ ਜਦੋਂ ਤੁਸੀਂ ਆਪਣੀ ਸਤਰ ਵਿੱਚ ਇੱਕ ਅੱਖਰ ਦੀ ਮੌਜੂਦਗੀ ਜਾਂ ਅੱਖਰ ਦੇ ਕ੍ਰਮ ਦੀ ਜਾਂਚ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ। ਉਹਨਾਂ ਸਥਿਤੀਆਂ ਵਿੱਚ, ਤੁਸੀਂ ਆਪਣੇ ਸਮੀਕਰਨ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਵਰਤ ਸਕਦੇ ਹੋ:
message = 'Shahbaz Bhatti is a coder'
ਪ੍ਰਿੰਟ (ਸੁਨੇਹੇ ਵਿੱਚ 'ਪਾਈਥਨ')
ਹੁਣ ਇਹ ਇੱਕ ਬੁਲੀਅਨ ਫੰਕਸ਼ਨ ਵਾਪਸ ਕਰੇਗਾ। ਭਾਵ “ਸੱਚ” ਜਾਂ “ਗਲਤ”। ਇਸ ਤਰ੍ਹਾਂ;
ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਇਹ ਸਾਰੀਆਂ ਵਿਧੀਆਂ ਅਤੇ ਫੰਕਸ਼ਨ ਕੇਸ-ਸੰਵੇਦਨਸ਼ੀਲ ਹਨ।
ਲਪੇਟ!
ਸਤਰ ਵਿੱਚ ਹੋਰ ਵੀ ਬਹੁਤ ਕੁਝ ਹੈ, ਜੋ ਅਸੀਂ ਹੌਲੀ-ਹੌਲੀ ਸਿੱਖ ਲਵਾਂਗੇ ਜਿਵੇਂ ਅਸੀਂ ਅੱਗੇ ਵਧਦੇ ਹਾਂ। ਅੱਗੇ, ਅਸੀਂ Python ਵਿੱਚ ਅੰਕਗਣਿਤ ਦੀਆਂ ਕਾਰਵਾਈਆਂ ਕਰਨਾ ਸਿੱਖਾਂਗੇ।
ਕੋਈ ਜਵਾਬ ਛੱਡਣਾ