ਇਹ ਲੈਕਚਰ ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਹੋਰ ਜ਼ਰੂਰੀ ਢਾਂਚੇ ਬਾਰੇ ਹੈ, ਜਿਸਨੂੰ ਟੂਪਲ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।
ਟੂਪਲਸ
ਟੂਪਲ ਸੂਚੀਆਂ ਦੇ ਸਮਾਨ ਹਨ, ਇਸਲਈ ਅਸੀਂ ਉਹਨਾਂ ਦੀ ਵਰਤੋਂ ਆਈਟਮਾਂ ਦੀ ਸੂਚੀ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਕਰ ਸਕਦੇ ਹਾਂ। ਪਰ ਸੂਚੀਆਂ ਦੇ ਉਲਟ, ਅਸੀਂ ਉਹਨਾਂ ਨੂੰ ਸੋਧ ਨਹੀਂ ਸਕਦੇ, ਨਵੀਆਂ ਆਈਟਮਾਂ ਸ਼ਾਮਲ ਨਹੀਂ ਕਰ ਸਕਦੇ ਜਾਂ ਮੌਜੂਦਾ ਆਈਟਮਾਂ ਨੂੰ ਹਟਾ ਨਹੀਂ ਸਕਦੇ। ਅਸੀਂ ਕਹਿ ਸਕਦੇ ਹਾਂ ਕਿ ਟੂਪਲ ਅਟੱਲ ਹਨ।
ਮੈਨੂੰ ਤੁਹਾਨੂੰ ਦਿਖਾਉਣ ਦਿਓ. ਟੂਪਲਾਂ ਨੂੰ ਸੂਚੀਆਂ ਵਿੱਚ ਵਰਗ ਬਰੈਕਟਾਂ ਦੀ ਬਜਾਏ ਬਰੈਕਟ ਦੁਆਰਾ ਪਛਾਣਿਆ ਜਾਂਦਾ ਹੈ।
numbers = (4, 1, 7, 5, 0, 9)
ਹੁਣ, ਜੇਕਰ ਅਸੀਂ ਟੂਪਲਸ ਲਈ ਵਿਧੀਆਂ ਦੀ ਸੂਚੀ ਨੂੰ ਬਾਹਰ ਕੱਢਦੇ ਹਾਂ, ਤਾਂ ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਸਾਡੇ ਕੋਲ ਐਪੈਂਡ ਜਾਂ ਇਨਸਰਟ ਵਿਧੀਆਂ ਨਹੀਂ ਹਨ ਇਸ ਲਈ ਇਸ ਟੂਪਲ ਵਿੱਚ ਨਵੀਆਂ ਆਈਟਮਾਂ ਸ਼ਾਮਲ ਨਹੀਂ ਕੀਤੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ। ਸਾਡੇ ਕੋਲ ਸਿਰਫ਼ ਦੋ ਤਰੀਕੇ ਹਨ: ਗਿਣਤੀ ਅਤੇ ਸੂਚਕਾਂਕ।
ਅਸੀਂ ਕਿਸੇ ਆਈਟਮ ਦੀਆਂ ਘਟਨਾਵਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ "ਗਿਣਤੀ" ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ। "ਸੂਚਕਾਂਕ" ਦੀ ਵਰਤੋਂ ਕਿਸੇ ਆਈਟਮ ਦੀ ਪਹਿਲੀ ਮੌਜੂਦਗੀ ਦੇ ਸੂਚਕਾਂਕ ਨੂੰ ਲੱਭਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਲਈ, ਅਸੀਂ ਸਿਰਫ ਇੱਕ ਟੂਪਲ ਬਾਰੇ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਾਂ, ਅਤੇ ਅਸੀਂ ਇਸਨੂੰ ਬਦਲ ਨਹੀਂ ਸਕਦੇ। ਤਰੀਕੇ ਨਾਲ, ਇਹ ਹੋਰ ਵਿਧੀਆਂ ਜੋ ਤੁਸੀਂ ਇੱਥੇ ਦੇਖਦੇ ਹੋ, ਦੋ ਅੰਡਰਸਕੋਰਾਂ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ।
ਅਸੀਂ ਇਹਨਾਂ ਨੂੰ ਜਾਦੂ ਦੇ ਤਰੀਕਿਆਂ ਵਜੋਂ ਕਹਿੰਦੇ ਹਾਂ। ਉਹ ਇੱਕ ਉੱਨਤ ਵਿਸ਼ਾ ਹਨ, ਅਤੇ ਅਸੀਂ ਆਪਣੀ ਭਵਿੱਖੀ ਲੜੀ ਵਿੱਚ ਉਹਨਾਂ ਨੂੰ ਛੂਹਾਂਗੇ।
ਅਟੱਲ ਹੋਣ ਤੋਂ ਇਲਾਵਾ, ਟੂਪਲ ਸੂਚੀ ਦੀਆਂ ਜ਼ਿਆਦਾਤਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਸਾਂਝਾ ਕਰਦੇ ਹਨ।
ਵਿਹਾਰਕ ਤੌਰ 'ਤੇ, ਜ਼ਿਆਦਾਤਰ ਸਮਾਂ ਤੁਸੀਂ ਸੂਚੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋਵੋਗੇ, ਪਰ ਟੂਪਲ ਵੀ ਲਾਭਦਾਇਕ ਹਨ। ਜੇ ਤੁਸੀਂ ਆਈਟਮਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਤੁਹਾਡੇ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਕਿਤੇ ਵੀ ਤੁਸੀਂ ਗਲਤੀ ਨਾਲ ਉਸ ਸੂਚੀ ਨੂੰ ਸੰਸ਼ੋਧਿਤ ਨਹੀਂ ਕੀਤਾ ਹੈ, ਤਾਂ ਟੂਪਲ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਬਿਹਤਰ ਹੈ।
ਅਨਪੈਕਿੰਗ
ਇਸ ਭਾਗ ਵਿੱਚ, ਮੈਂ ਤੁਹਾਨੂੰ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਵਿਸ਼ੇਸ਼ਤਾ ਦਿਖਾਉਣ ਜਾ ਰਿਹਾ ਹਾਂ, ਸਾਡੇ ਕੋਲ ਪਾਈਥਨ ਵਿੱਚ ਹੈ ਜਿਸਨੂੰ ਅਨਪੈਕਿੰਗ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।
ਆਉ ਇੱਕ ਟੂਪਲ "ਕੋਆਰਡੀਨੇਟ" ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੀਏ
coordinate = (1, 2, 3)
ਹੁਣ, ਕਲਪਨਾ ਕਰੋ ਕਿ ਇਹ 'x', 'y' ਅਤੇ 'z' ਲਈ ਕੋਆਰਡੀਨੇਟ ਹਨ। ਹੁਣ ਮੰਨ ਲਓ, ਅਸੀਂ ਇਹਨਾਂ ਮੁੱਲਾਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ ਅਤੇ ਇਹਨਾਂ ਨੂੰ ਸਾਡੇ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਕੁਝ ਗੁੰਝਲਦਾਰ ਸਮੀਕਰਨਾਂ ਵਿੱਚ ਵਰਤਣਾ ਚਾਹੁੰਦੇ ਹਾਂ। ਹੋ ਸਕਦਾ ਹੈ, ਅਸੀਂ ਉਹਨਾਂ ਨੂੰ ਇੱਕ ਵੱਡੇ ਗੁੰਝਲਦਾਰ ਫਾਰਮੂਲੇ ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਸ਼ਾਮਲ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ।
ਇਸ ਲਈ, ਇਕੱਠੇ ਸਾਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਕੋਡ ਲਿਖਣਾ ਪਏਗਾ:
coordinate[0] * coordinate[1] * coordinate[2]
ਕੋਡ ਦੀ ਇਹ ਲਾਈਨ ਸਾਰੇ ਕੋਆਰਡੀਨੇਟਸ ਨੂੰ ਗੁਣਾ ਕਰੇਗੀ ਪਰ ਸਾਡੇ ਕੋਡ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਲਿਖਣਾ ਅਯੋਗ ਹੈ। ਪਹਿਲਾਂ, ਆਓ ਇੱਕ ਬਿਹਤਰ ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰੀਏ ਅਤੇ ਇਹਨਾਂ ਕੋਆਰਡੀਨੇਟਾਂ ਨੂੰ ਵੱਖਰੇ ਵੇਰੀਏਬਲ ਵਿੱਚ ਸਟੋਰ ਕਰੀਏ।
x = coordinate[0]
y = coordinate[1]
z = coordinate[2]
ਇਹ ਬਿਹਤਰ ਹੈ। ਸਹੀ? ਇਸ ਲਈ ਹੁਣ ਤੱਕ ਕੁਝ ਨਵਾਂ ਨਹੀਂ। ਹੁਣ, ਮੈਂ ਤੁਹਾਨੂੰ ਅਨਪੈਕਿੰਗ ਨਾਮਕ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਵਿਸ਼ੇਸ਼ਤਾ ਦਿਖਾਵਾਂਗਾ ਅਤੇ ਇਸਦੇ ਨਾਲ, ਅਸੀਂ ਬਹੁਤ ਘੱਟ ਕੋਡ ਨਾਲ ਉਹੀ ਨਤੀਜਾ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਾਂ।
x, y, z, = coordinate
ਹੁਣ, ਕੋਡ ਦੀ ਇਹ ਸਿੰਗਲ ਲਾਈਨ ਉੱਪਰ ਲਿਖੇ ਕੋਡ ਦੀਆਂ ਤਿੰਨ ਲਾਈਨਾਂ ਦੇ ਬਿਲਕੁਲ ਬਰਾਬਰ ਹੈ। ਮੈਂ ਤੁਹਾਨੂੰ ਦੱਸਦਾ ਹਾਂ ਕਿ ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ।
ਜਦੋਂ ਪਾਈਥਨ ਇੰਟਰਪ੍ਰੇਟਰ ਇਸ ਸਟੇਟਮੈਂਟ ਨੂੰ ਵੇਖਦਾ ਹੈ, ਤਾਂ ਇਹ ਇਸ ਟੂਪਲ ਵਿੱਚ ਪਹਿਲੀ ਆਈਟਮ ਪ੍ਰਾਪਤ ਕਰੇਗਾ ਅਤੇ ਇਸਨੂੰ ਵੇਰੀਏਬਲ ਨੂੰ ਸੌਂਪ ਦੇਵੇਗਾ। ਇਸੇ ਤਰ੍ਹਾਂ, ਦੂਜੀ ਅਤੇ ਤੀਜੀ ਆਈਟਮਾਂ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕੀਤੀਆਂ ਜਾਣਗੀਆਂ। ਅਜਿਹਾ ਕਰਦੇ ਹੋਏ, ਅਸੀਂ ਇਸ ਟੂਪਲ ਨੂੰ 3 ਵੇਰੀਏਬਲਾਂ ਵਿੱਚ ਅਨਪੈਕ ਕਰ ਰਹੇ ਹਾਂ। ਆਉ ਆਪਣੇ ਆਉਟਪੁੱਟ ਦੀ ਜਾਂਚ ਕਰੀਏ।
ਅਨਪੈਕਿੰਗ ਸੂਚੀਆਂ ਨਾਲ ਵੀ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।
ਕੋਸ਼
ਅਸੀਂ ਪਾਈਥਨ ਵਿੱਚ ਡਿਕਸ਼ਨਰੀ ਬਾਰੇ ਜਾਣਨ ਜਾ ਰਹੇ ਹਾਂ। ਅਸੀਂ ਉਹਨਾਂ ਸਥਿਤੀਆਂ ਵਿੱਚ ਸ਼ਬਦਕੋਸ਼ਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ ਜਿੱਥੇ ਅਸੀਂ ਜਾਣਕਾਰੀ ਨੂੰ ਸਟੋਰ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ ਜੋ ਮੁੱਖ-ਮੁੱਲ ਦੇ ਜੋੜਿਆਂ ਵਜੋਂ ਆਉਂਦੀ ਹੈ।
ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਨ ਹੈ. ਨਾਮ, ਈਮੇਲ, ਫ਼ੋਨ ਨੰਬਰ, ਪਤਾ, ਆਦਿ ਵਰਗੇ ਗੁਣਾਂ ਦੇ ਝੁੰਡ ਵਾਲੇ ਗਾਹਕ ਬਾਰੇ ਸੋਚੋ। ਹੁਣ ਇਹਨਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਗੁਣ ਦਾ ਇੱਕ ਮੁੱਲ ਹੈ। ਉਦਾਹਰਣ ਲਈ:
name = Jay
email = [email protected]
ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, ਸਾਡੀਆਂ ਕੁੰਜੀਆਂ ਨਾਮ, ਈਮੇਲ ਅਤੇ ਫ਼ੋਨ ਹਨ। ਹਰ ਕੁੰਜੀ ਇੱਕ ਮੁੱਲ ਨਾਲ ਜੁੜੀ ਹੋਈ ਹੈ ਇਸਲਈ ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਅਸੀਂ ਇੱਕ ਸ਼ਬਦਕੋਸ਼ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ। ਇੱਕ ਡਿਕਸ਼ਨਰੀ ਦੇ ਨਾਲ, ਅਸੀਂ ਕੁੰਜੀ-ਮੁੱਲ ਜੋੜਿਆਂ ਦਾ ਇੱਕ ਸਮੂਹ ਸਟੋਰ ਕਰ ਸਕਦੇ ਹਾਂ। ਆਓ ਮੈਂ ਤੁਹਾਨੂੰ ਦਿਖਾਉਂਦਾ ਹਾਂ ਕਿ python ਵਿੱਚ ਡਿਕਸ਼ਨਰੀ ਨੂੰ ਕਿਵੇਂ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਹੈ।
customer = {
"name": "Jay",
"email": "[email protected]",
"age": 30,
"is_verified": True
}
ਕੁੰਜੀ ਨੂੰ ਸਤਰ, ਨੰਬਰ, ਬੁਲੀਅਨ, ਜਾਂ ਕਿਸੇ ਵੀ ਚੀਜ਼ 'ਤੇ ਸੈੱਟ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਕੁੰਜੀਆਂ ਵਿਲੱਖਣ ਹਨ ਅਤੇ ਕੇਵਲ ਇੱਕ ਵਾਰ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ, ਭਾਵ ਮੈਂ ਕਿਸੇ ਹੋਰ ਸੰਖਿਆ ਨਾਲ "ਉਮਰ" ਨੂੰ ਦੁਬਾਰਾ ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਕਰ ਸਕਦਾ ਹਾਂ। ਉਹ ਕੇਸ-ਸੰਵੇਦਨਸ਼ੀਲ ਵੀ ਹਨ।
ਹੁਣ, ਜੇ ਮੈਂ ਟਾਈਪ ਕਰਦਾ ਹਾਂ customer["name"],
ਇਹ ਗਾਹਕ ਦੇ ਨਾਮ ਨੂੰ ਕਾਲ ਕਰੇਗਾ। ਚਲੋ ਇਸਨੂੰ ਟਰਮੀਨਲ 'ਤੇ ਪ੍ਰਿੰਟ ਕਰੀਏ:
ਅਸੀਂ ਸ਼ਬਦਕੋਸ਼ਾਂ ਦੇ ਨਾਲ ਤਰੀਕਿਆਂ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹਾਂ। ਉੱਪਰ ਦਿਖਾਇਆ ਗਿਆ ਉਹੀ ਫੰਕਸ਼ਨ “get” ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਦੁਹਰਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।
ਉਪਰੋਕਤ ਦੋ ਤਰੀਕਿਆਂ ਵਿੱਚ ਇੱਕ ਖਾਸ ਅੰਤਰ ਹੈ। ਮੈਨੂੰ ਇਹ ਦਿਖਾਉਣ ਦਿਓ।
ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਜਦੋਂ ਅਸੀਂ ਸਿਰਫ਼ ਇੱਕ ਗੈਰ-ਮੌਜੂਦ ਕੁੰਜੀ ਨੂੰ ਪ੍ਰਿੰਟ ਕੀਤਾ, ਤਾਂ ਇਸਦਾ ਨਤੀਜਾ ਇੱਕ ਗਲਤੀ ਹੈ। ਦੂਜੇ ਪਾਸੇ, ਗੈਰ-ਮੌਜੂਦ ਕੁੰਜੀ ਨੂੰ ਕਾਲ ਕਰਨ ਲਈ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ "ਕੋਈ ਨਹੀਂ" ਨਤੀਜੇ ਵਿੱਚ ਨਤੀਜਾ ਨਿਕਲਦਾ ਹੈ ਜੋ ਇੱਕ ਮੁੱਲ ਦੀ ਅਣਹੋਂਦ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। "ਪ੍ਰਾਪਤ ਕਰੋ" ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ, ਅਸੀਂ ਇੱਕ ਡਿਫੌਲਟ ਮੁੱਲ ਵੀ ਪ੍ਰਦਾਨ ਕਰ ਸਕਦੇ ਹਾਂ।
ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਇਸ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ "ਜਨਮ ਮਿਤੀ" ਕੁੰਜੀ ਨਹੀਂ ਹੈ, ਤਾਂ ਅਸੀਂ ਇਸਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਪ੍ਰਦਾਨ ਕਰ ਸਕਦੇ ਹਾਂ:
customer.get("birthdate", "Jan 01, 1994")
ਅਸੀਂ ਡਿਕਸ਼ਨਰੀ ਵਿੱਚ ਕਿਸੇ ਵੀ ਕੁੰਜੀ ਨੂੰ ਵੀ ਅਪਡੇਟ ਕਰ ਸਕਦੇ ਹਾਂ, ਇੱਕ ਸੂਚੀ ਦੇ ਸਮਾਨ। ਮੰਨ ਲਓ ਕਿ ਅਸੀਂ ਆਪਣੇ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਨਾਮ ਕੁੰਜੀ ਨੂੰ ਅਪਡੇਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ। ਇੱਥੇ ਅਸੀਂ ਇਸਨੂੰ ਕਿਵੇਂ ਕਰਾਂਗੇ.
customer["name"] = "Shahbaz"
ਸਾਡੇ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਵੀ ਇੱਕ ਨਵੀਂ ਕੁੰਜੀ ਜੋੜਨ ਲਈ ਇੱਕ ਸਮਾਨ ਸੰਟੈਕਸ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਚਲੋ ਇਸੇ ਤਰ੍ਹਾਂ ਦੀ ਕੁੰਜੀ "ਜਨਮ ਮਿਤੀ" ਨੂੰ ਜੋੜੀਏ।
customer["birthdate"] = "Jan 01, 1994"
ਇਸ ਲਈ, ਇਹ ਪਾਈਥਨ ਵਿੱਚ ਸ਼ਬਦਕੋਸ਼ਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀਆਂ ਮੂਲ ਗੱਲਾਂ ਹਨ। ਉਹ ਬਹੁਤ ਮਹੱਤਵਪੂਰਨ ਹਨ ਅਤੇ ਅਸਲ ਸੰਸਾਰ ਵਿੱਚ ਉਹਨਾਂ ਕੋਲ ਬਹੁਤ ਸਾਰੀਆਂ ਐਪਲੀਕੇਸ਼ਨ ਹਨ।
ਕਸਰਤ
ਤੁਸੀਂ ਇੱਕ ਅਜਿਹਾ ਪ੍ਰੋਗਰਾਮ ਲਿਖਣ ਜਾ ਰਹੇ ਹੋ ਜੋ ਅੰਕਾਂ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਸ਼ਬਦਾਂ ਵਿੱਚ ਬਦਲਦਾ ਹੈ:
ਦਾ ਹੱਲ
ਇੱਥੇ ਤੁਹਾਡੇ ਲਈ ਹੱਲ ਹੈ.
phone = input("Phone: ")
digits_mapping = {
"1": "One",
"2": "Two",
"3": "Three",
"4": "Four",
"5": "Five",
"6": "Six",
"7": "Seven",
"8": "Eight",
"9": "Nine",
"0": "Zero"
}
output = " "
for ch in phone:
output += digits_mapping.get(ch, "!") + " "
print(output)
ਇਸੇ ਤਰ੍ਹਾਂ, ਤੁਸੀਂ "ਇਮੋਜੀ ਕਨਵਰਟਰ" ਵਰਗੇ ਹੋਰ ਮਜ਼ੇਦਾਰ ਪ੍ਰੋਗਰਾਮ ਬਣਾ ਸਕਦੇ ਹੋ PYTHONERS ਮਜ਼ੇ ਕਰੋ!
ਲਪੇਟ!
ਮੈਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਤੁਸੀਂ ਇਸ ਲੈਕਚਰ ਦਾ ਆਨੰਦ ਮਾਣਿਆ ਹੋਵੇਗਾ। ਅੱਗੇ, ਅਸੀਂ ਪਾਈਥਨ ਪ੍ਰੋਗਰਾਮਿੰਗ, ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਪੈਰਾਮੀਟਰਾਂ ਦੇ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਪਹਿਲੂ ਵਿੱਚ ਡੁਬਕੀ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ।
ਕੋਈ ਜਵਾਬ ਛੱਡਣਾ