ਇਸ ਲੈਕਚਰ ਵਿੱਚ, ਅਸੀਂ ਪਾਈਥਨ ਵਿੱਚ ਕਲਾਸਾਂ, ਕੰਸਟਰਕਟਰ ਅਤੇ ਵਿਰਾਸਤ ਬਾਰੇ ਸਿੱਖਾਂਗੇ।
ਇਹ ਸੰਕਲਪ ਇੱਕ ਵੱਡੇ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਅਸਲ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਹਨ ਜਿੱਥੇ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
ਇੱਕਸੁਰ
ਪ੍ਰੋਗਰਾਮਿੰਗ ਵਿੱਚ ਕਲਾਸਾਂ ਜ਼ਰੂਰੀ ਹਨ ਅਤੇ ਉਹ python ਲਈ ਖਾਸ ਨਹੀਂ ਹਨ। ਕਈ ਹੋਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਕਲਾਸਾਂ ਦੀ ਧਾਰਨਾ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ। ਅਸੀਂ ਨਵੀਆਂ ਡਾਟਾ ਕਿਸਮਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਲਈ ਕਲਾਸਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ।
ਹੁਣ ਤੱਕ, ਅਸੀਂ ਪਾਈਥਨ ਵਿੱਚ ਮੂਲ ਡਾਟਾ ਕਿਸਮਾਂ ਜਿਵੇਂ ਕਿ ਨੰਬਰ, ਸਟ੍ਰਿੰਗਜ਼ ਅਤੇ ਬੁਲੀਅਨਜ਼ ਬਾਰੇ ਸਿੱਖਿਆ ਹੈ। ਇਹ ਪਾਈਥਨ ਵਿੱਚ ਬੁਨਿਆਦੀ ਜਾਂ ਸਧਾਰਨ ਡੇਟਾ ਕਿਸਮਾਂ ਹਨ। ਅਸੀਂ ਕੁਝ ਗੁੰਝਲਦਾਰ ਡੇਟਾ ਕਿਸਮਾਂ ਜਿਵੇਂ ਕਿ ਸੂਚੀਆਂ ਅਤੇ ਸ਼ਬਦਕੋਸ਼ਾਂ ਨੂੰ ਵੀ ਦੇਖਿਆ ਹੈ।
ਹਾਲਾਂਕਿ ਇਹ ਕਿਸਮਾਂ ਬਹੁਤ ਲਾਭਦਾਇਕ ਹਨ, ਪਰ ਇਹਨਾਂ ਨੂੰ ਹਮੇਸ਼ਾਂ ਗੁੰਝਲਦਾਰ ਸੰਕਲਪਾਂ ਨੂੰ ਮਾਡਲ ਬਣਾਉਣ ਲਈ ਨਹੀਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ। ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਬਿੰਦੂ, ਜਾਂ ਇੱਕ ਸ਼ਾਪਿੰਗ ਕਾਰਟ ਦੇ ਵਿਚਾਰ ਬਾਰੇ ਸੋਚੋ। ਇੱਕ ਸ਼ਾਪਿੰਗ ਕਾਰਟ ਇੱਕ ਬੂਲੀਅਨ ਜਾਂ ਇੱਕ ਸੂਚੀ ਨਹੀਂ ਹੈ। ਇਹ ਇੱਕ ਵੱਖਰੀ ਕਿਸਮ ਦਾ ਡੇਟਾ ਹੈ। ਇਸ ਲਈ ਅਸੀਂ ਅਸਲ ਧਾਰਨਾਵਾਂ ਨੂੰ ਮਾਡਲ ਬਣਾਉਣ ਲਈ ਨਵੀਆਂ ਕਿਸਮਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਲਈ ਕਲਾਸਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ।
ਹੁਣ, ਆਓ ਪੁਆਇੰਟ ਨਾਮਕ ਇੱਕ ਨਵੀਂ ਡਾਟਾ ਕਿਸਮ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੀਏ। ਇਸ ਨਵੀਂ ਕਿਸਮ ਦੇ ਤਰੀਕੇ ਹੋਣ ਜਾ ਰਹੇ ਹਨ ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਪਹਿਲਾਂ ਜਾਂਚ ਕੀਤੀ ਸੀ।
ਤੁਸੀਂ ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਕਰੋਗੇ:
ਅਸੀਂ "ਕਲਾਸ" ਕੀਵਰਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਕਲਾਸ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਕੇ ਸ਼ੁਰੂ ਕਰਦੇ ਹਾਂ ਅਤੇ ਇਸਦੇ ਬਾਅਦ ਅਸੀਂ ਆਪਣੀ ਕਲਾਸ ਨੂੰ ਇੱਕ ਨਾਮ ਦਿੰਦੇ ਹਾਂ।
class Point
ਹੁਣ, ਮੈਂ ਇੱਥੇ ਵਰਤੇ ਗਏ ਨਾਮਕਰਨ ਸੰਮੇਲਨ ਨੂੰ ਦੇਖੋ। ਮੈਂ ਇੱਥੇ ਪਹਿਲੇ ਅੱਖਰ ਨੂੰ ਵੱਡਾ ਕੀਤਾ ਹੈ, ਇਸ ਨੂੰ ਅਸੀਂ ਇੱਕ ਪਾਸਕਲ ਨਾਮਕਰਨ ਸੰਮੇਲਨ ਕਹਿੰਦੇ ਹਾਂ। ਇਹ ਸੰਮੇਲਨ ਉਸ ਤੋਂ ਵੱਖਰਾ ਹੈ ਜੋ ਅਸੀਂ ਆਪਣੇ ਵੇਰੀਏਬਲ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਨਾਮ ਦੇਣ ਲਈ ਵਰਤਦੇ ਹਾਂ ਜਿਸ ਲਈ ਅਸੀਂ ਹਮੇਸ਼ਾ ਛੋਟੇ ਅੱਖਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ ਅਤੇ ਇੱਕ ਅੰਡਰਸਕੋਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਈ ਸ਼ਬਦਾਂ ਨੂੰ ਵੱਖ ਕਰਦੇ ਹਾਂ। ਪਰ ਕਲਾਸਾਂ ਦਾ ਨਾਮਕਰਨ ਕਰਦੇ ਸਮੇਂ, ਅਸੀਂ ਇਸ ਦੀ ਬਜਾਏ ਕਈ ਸ਼ਬਦਾਂ ਨੂੰ ਵੱਖ ਕਰਨ ਲਈ ਇੱਕ ਅੰਡਰਸਕੋਰ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰਦੇ, ਅਸੀਂ ਹਰ ਸ਼ਬਦ ਦੇ ਪਹਿਲੇ ਅੱਖਰ ਨੂੰ ਵੱਡਾ ਕਰਦੇ ਹਾਂ।
ਸਾਡੀ ਕਲਾਸ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਇੱਕ ਕੌਲਨ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਹੁਣ ਇੱਕ ਬਲਾਕ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ।
class Point:
def move (self):
ਇਸ ਬਲਾਕ ਵਿੱਚ, ਅਸੀਂ ਉਹਨਾਂ ਸਾਰੇ ਫੰਕਸ਼ਨਾਂ ਜਾਂ ਵਿਧੀਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰ ਸਕਦੇ ਹਾਂ ਜੋ ਪੁਆਇੰਟਾਂ ਨਾਲ ਸਬੰਧਤ ਹਨ। ਉਦਾਹਰਨ ਲਈ, ਅਸੀਂ ਇੱਕ ਬਿੰਦੂ ਨੂੰ ਮੂਵ ਕਰਨ ਲਈ "ਮੂਵ" ਨਾਮਕ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰ ਸਕਦੇ ਹਾਂ। ਨੋਟ ਕਰੋ ਕਿ ਜਿਵੇਂ ਹੀ ਅਸੀਂ ਓਪਨ ਬਰੈਕਟ ਟਾਈਪ ਕਰਦੇ ਹਾਂ, PyCharm ਆਪਣੇ ਆਪ ਇੱਥੇ "self" ਜੋੜਦਾ ਹੈ। ਇਹ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਕੀਵਰਡ ਹੈ ਅਤੇ ਮੈਨੂੰ ਜਲਦੀ ਹੀ ਇਸ 'ਤੇ ਵਾਪਸ ਜਾਣ ਦਿਓ। ਚਲੋ ਟਰਮੀਨਲ ਉੱਤੇ "move" ਨੂੰ ਪ੍ਰਿੰਟ ਕਰੀਏ।
print("move")
ਚਲੋ ਇੱਕ ਹੋਰ ਵਿਧੀ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੀਏ ਜਿਵੇਂ ਕਿ "ਡਰਾਅ" ਅਤੇ ਇਸਨੂੰ ਟਰਮੀਨਲ 'ਤੇ ਪ੍ਰਿੰਟ ਕਰੋ।
def draw(self):
print("draw")
ਅਸੀਂ ਆਪਣੀ "ਪੁਆਇੰਟ" ਕਲਾਸ ਦੀ ਪਰਿਭਾਸ਼ਾ ਦੇ ਨਾਲ ਪੂਰਾ ਕਰ ਲਿਆ ਹੈ। ਇਸ ਨਵੀਂ ਕਿਸਮ ਨਾਲ, ਅਸੀਂ ਨਵੀਆਂ ਵਸਤੂਆਂ ਬਣਾ ਸਕਦੇ ਹਾਂ। ਇੱਕ ਕਲਾਸ ਬਸ ਬਲੂਪ੍ਰਿੰਟ ਜਾਂ ਵਸਤੂਆਂ ਨੂੰ ਬਣਾਉਣ ਲਈ ਟੈਂਪਲੇਟ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ ਜੋ ਉਸ ਬਲੂਪ੍ਰਿੰਟ ਦੇ ਅਧਾਰ ਤੇ ਅਸਲ ਉਦਾਹਰਣ ਹਨ। ਇੱਕ ਆਬਜੈਕਟ ਬਣਾਉਣ ਲਈ, ਅਸੀਂ ਆਪਣੀ ਕਲਾਸ ਦਾ ਨਾਮ ਟਾਈਪ ਕਰਦੇ ਹਾਂ ਅਤੇ ਫਿਰ ਇਸਨੂੰ ਫੰਕਸ਼ਨ ਵਾਂਗ ਕਾਲ ਕਰਦੇ ਹਾਂ। ਇਹ ਇੱਕ ਨਵੀਂ ਵਸਤੂ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਫਿਰ ਇਸਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਫਿਰ ਅਸੀਂ ਉਸ ਵਸਤੂ ਨੂੰ ਵੇਰੀਏਬਲ ਵਿੱਚ ਸਟੋਰ ਕਰ ਸਕਦੇ ਹਾਂ। ਮੈਨੂੰ ਤੁਹਾਨੂੰ ਦਿਖਾਉਣ ਦਿਓ:
ਇੱਥੇ ਅਸੀਂ ਇੱਕ "ਪੁਆਇੰਟ1" ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਹੈ ਜੋ ਕਿ ਇੱਕ ਤਿੰਨ-ਅਯਾਮੀ ਬਿੰਦੂ ਹੈ। ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ, ਅਸੀਂ ਟਰਮੀਨਲ 'ਤੇ ਵਿਅਕਤੀਗਤ ਕੋਆਰਡੀਨੇਟਸ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰ ਸਕਦੇ ਹਾਂ।
ਅਸੀਂ ਇਸ ਬਿੰਦੂ ਨਾਲ "ਡਰਾਅ" ਅਤੇ "ਮੂਵ" ਦੋ ਢੰਗਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ।
ਇਸ ਲਈ ਰੀਕੈਪ ਕਰਨ ਲਈ, ਅਸੀਂ ਨਵੀਆਂ ਕਿਸਮਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਲਈ ਕਲਾਸਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ ਅਤੇ ਇਹਨਾਂ ਕਿਸਮਾਂ ਵਿੱਚ ਉਹ ਢੰਗ ਹੋ ਸਕਦੇ ਹਨ ਜੋ ਅਸੀਂ ਕਲਾਸ ਦੇ ਮੁੱਖ ਭਾਗ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂ। ਕਲਾਸਾਂ ਵਿੱਚ ਅਜਿਹੇ ਗੁਣ ਹੋ ਸਕਦੇ ਹਨ ਜੋ ਅਸੀਂ ਆਪਣੇ ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚ ਕਿਤੇ ਵੀ ਸੈੱਟ ਕਰ ਸਕਦੇ ਹਾਂ।
ਨਿਰਮਾਤਾ
ਹੁਣ ਤੱਕ, ਅਸੀਂ ਸਿੱਖਿਆ ਹੈ ਕਿ ਕਲਾਸਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਨਵੀਆਂ ਕਿਸਮਾਂ ਕਿਵੇਂ ਬਣਾਉਣੀਆਂ ਹਨ। ਹੁਣ ਇਸ ਨੂੰ ਲਾਗੂ ਕਰਨ ਵਿੱਚ ਇੱਕ ਛੋਟੀ ਜਿਹੀ ਸਮੱਸਿਆ ਹੈ। ਅਸੀਂ ਕਲਾਸਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਿਨਾਂ x ਜਾਂ y ਕੋਆਰਡੀਨੇਟ ਦੇ ਇੱਕ ਬਿੰਦੂ ਆਬਜੈਕਟ ਬਣਾ ਸਕਦੇ ਹਾਂ ਅਤੇ ਇਹ ਆਦਰਸ਼ ਨਹੀਂ ਹੈ। ਮੈਨੂੰ ਤੁਹਾਨੂੰ ਦਿਖਾਉਣ ਦਿਓ.
ਆਉ ਇੱਕ ਬਿੰਦੂ ਬਣਾਉ ਅਤੇ x ਕੋਆਰਡੀਨੇਟ ਸੈਟ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਇਸਨੂੰ ਪ੍ਰਿੰਟ ਕਰੀਏ। ਸਾਡੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਚਲਾਉਣ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਇੱਕ ਵਿਸ਼ੇਸ਼ਤਾ ਗਲਤੀ ਹੁੰਦੀ ਹੈ:
ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਪੁਆਇੰਟ ਆਬਜੈਕਟ ਵਿੱਚ x ਨਾਂ ਦਾ ਕੋਈ ਗੁਣ ਨਹੀਂ ਹੈ। ਹੁਣ ਸਮੱਸਿਆ ਇਹ ਹੈ ਕਿ x ਜਾਂ y ਕੋਆਰਡੀਨੇਟਸ ਤੋਂ ਬਿਨਾਂ ਪੁਆਇੰਟ ਆਬਜੈਕਟ ਹੋਣਾ ਸੰਭਵ ਹੈ। ਇਸ ਦਾ ਕੋਈ ਮਤਲਬ ਨਹੀਂ ਹੈ ਕਿਉਂਕਿ ਜਦੋਂ ਵੀ ਅਸੀਂ ਕਿਸੇ ਬਿੰਦੂ ਬਾਰੇ ਗੱਲ ਕਰਦੇ ਹਾਂ, ਸਾਨੂੰ ਇਹ ਜਾਣਨ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ ਕਿ ਉਹ ਬਿੰਦੂ ਕਿੱਥੇ ਸਥਿਤ ਹੈ। ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ, ਅਸੀਂ ਇੱਕ ਕੰਸਟਰਕਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ। ਕੰਸਟਰਕਟਰ ਇੱਕ ਅਜਿਹਾ ਫੰਕਸ਼ਨ ਹੁੰਦਾ ਹੈ ਜੋ ਕਿਸੇ ਵਸਤੂ ਨੂੰ ਬਣਾਉਣ ਸਮੇਂ ਕਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
ਇੱਥੇ ਅਸੀਂ ਇੱਕ ਕੰਸਟਰਕਟਰ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਦੇ ਹਾਂ। ਪਹਿਲਾਂ, ਆਓ ਉਪਰੋਕਤ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ x ਅਤੇ y ਕੋਆਰਡੀਨੇਟ ਵੈਲਯੂ ਨੂੰ ਪਾਸ ਕਰੀਏ।
point = Point(10, 20)
print(point.x)
ਹੁਣ, ਸਾਨੂੰ ਇਸ ਕਲਾਸ ਵਿੱਚ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਵਿਧੀ ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ ਜਿਸਨੂੰ ਕੰਸਟਰਕਟਰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਇਸਦਾ ਸੰਟੈਕਸ ਇਸ ਤਰ੍ਹਾਂ ਹੈ:
def __init__(self, x, y):
init
ਸ਼ੁਰੂਆਤੀ ਲਈ ਛੋਟਾ ਹੈ, ਅਤੇ ਇਹ ਉਹ ਫੰਕਸ਼ਨ ਜਾਂ ਵਿਧੀ ਹੈ ਜੋ ਇੱਕ ਨਵੀਂ ਪੁਆਇੰਟ ਆਬਜੈਕਟ ਬਣਨ 'ਤੇ ਕਾਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। x ਅਤੇ y ਨੂੰ ਠੀਕ ਬਾਅਦ ਵਿੱਚ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ self
ਦੋ ਵਾਧੂ ਪੈਰਾਮੀਟਰ ਜੋੜਨ ਲਈ.
ਉਸ ਤੋਂ ਬਾਅਦ, ਸਾਨੂੰ x ਅਤੇ y ਨੂੰ ਪਾਸ ਕੀਤੇ ਮੁੱਲਾਂ ਭਾਵ 10 ਅਤੇ 20 ਨਾਲ ਮੈਪ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ
self.x = x
self.y = y
ਅਸੀਂ ਇਹਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ self
ਮੌਜੂਦਾ ਵਸਤੂ ਦਾ ਹਵਾਲਾ ਦੇਣ ਲਈ ਅਤੇ ਫਿਰ ਅਸੀਂ "x" ਫੰਕਸ਼ਨ ਨੂੰ ਪਾਸ ਕੀਤੇ x ਆਰਗੂਮੈਂਟ ਲਈ x ਗੁਣ ਸੈਟ ਕਰਦੇ ਹਾਂ। ਇਸ ਤਰੀਕੇ ਨਾਲ, ਵਰਤ init
ਵਿਧੀ, ਅਸੀਂ ਆਪਣੀਆਂ ਵਸਤੂਆਂ ਨੂੰ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹਾਂ। ਇਸ ਵਿਧੀ ਨੂੰ ਕੰਸਟਰਕਟਰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਆਉ ਆਪਣਾ ਪ੍ਰੋਗਰਾਮ ਚਲਾਉਂਦੇ ਹਾਂ।
ਹੁਣ, ਅਸੀਂ ਬਾਅਦ ਵਿੱਚ x ਅਤੇ y ਕੋਆਰਡੀਨੇਟਸ ਨੂੰ ਬਦਲ ਸਕਦੇ ਹਾਂ। ਆਓ x ਕੋਆਰਡੀਨੇਟ ਨੂੰ ਅਪਡੇਟ ਕਰੀਏ:
point = Point(10, 20)
point.x = 11
print(point.x)
ਹੁਣ, x ਕੋਆਰਡੀਨੇਟ ਨੂੰ ਮੁੱਲ 11 ਵਿੱਚ ਅੱਪਡੇਟ ਕੀਤਾ ਗਿਆ ਹੈ।
ਕਸਰਤ
ਇੱਥੇ ਤੁਹਾਡੇ ਲਈ ਇੱਕ ਦਿਲਚਸਪ ਅਭਿਆਸ ਹੈ.
ਮੈਂ ਚਾਹੁੰਦਾ ਹਾਂ ਕਿ ਤੁਸੀਂ ਇੱਕ ਨਵੀਂ ਕਿਸਮ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਜਿਸਨੂੰ ਵਿਅਕਤੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਇਹਨਾਂ "ਵਿਅਕਤੀ" ਵਸਤੂਆਂ ਕੋਲ "" ਹੋਣਾ ਚਾਹੀਦਾ ਹੈname
"ਵਿਸ਼ੇਸ਼ਤਾ ਦੇ ਨਾਲ ਨਾਲ"talk()
”.ੰਗ.
ਇਹ ਇੱਕ ਸਧਾਰਨ ਕੰਮ ਹੈ ਅਤੇ ਇਸ ਵਿੱਚ ਦੋ ਮਿੰਟਾਂ ਤੋਂ ਵੱਧ ਸਮਾਂ ਨਹੀਂ ਲੱਗਣਾ ਚਾਹੀਦਾ।
ਦਾ ਹੱਲ
ਕਲਾਸ "ਵਿਅਕਤੀ" ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ:
class Person:
self.name = name
ਅਸੀਂ ਕੰਸਟਰਕਟਰ ਨੂੰ ਬਾਅਦ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਕਰਾਂਗੇ। ਹੁਣ, ਅਸੀਂ "Person" ਆਬਜੈਕਟ ਬਣਾ ਸਕਦੇ ਹਾਂ। ਆਓ ਇਸਨੂੰ ਜੌਨ ਕਹੀਏ
john = Person("John Smith")
print(john.name)
john.talk()
ਹੁਣ, ਕੋਡ ਦੇ ਪਹਿਲੇ ਹਿੱਸੇ 'ਤੇ ਜਾਓ ਅਤੇ ਇੱਕ ਕੰਸਟਰਕਟਰ ਬਣਾਓ।
def __init__(self, name):
ਅੰਤਮ ਕੋਡ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗਾ:
ਤੁਸੀਂ ਕਲਾਸਾਂ ਅਤੇ ਕੰਸਟਰਕਟਰਾਂ ਦੇ ਨਾਲ ਫਾਰਮੈਟ ਕੀਤੀਆਂ ਸਟ੍ਰਿੰਗਾਂ ਅਤੇ ਹੋਰ ਸੰਕਲਪਾਂ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ।
ਵਿਰਾਸਤ
ਵਿਰਾਸਤ ਕਲਾਸਾਂ ਨਾਲ ਜੁੜੀ ਇੱਕ ਹੋਰ ਧਾਰਨਾ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਇੱਕ ਕੋਡ ਦੀ ਮੁੜ ਵਰਤੋਂ ਕਰਨ ਦਿੰਦੀ ਹੈ।
ਕੋਡ ਦੇ ਇਸ ਹਿੱਸੇ 'ਤੇ ਗੌਰ ਕਰੋ.
class Dog:
def walk(self):
print("walk")
ਅਸੀਂ "ਵਾਕ" ਵਿਧੀ ਨਾਲ "ਕੁੱਤੇ" ਦੀ ਕਲਾਸ ਬਣਾਈ ਹੈ। ਇਸ ਵਿਧੀ ਵਿੱਚ, ਅਸੀਂ ਟਰਮੀਨਲ 'ਤੇ ਵਾਕ ਸੰਦੇਸ਼ ਨੂੰ ਸਿਰਫ਼ ਪ੍ਰਿੰਟ ਕਰ ਰਹੇ ਹਾਂ। ਮੰਨ ਲਓ, ਇੱਕ ਅਸਲ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ, ਇੱਥੇ ਸਿਰਫ਼ ਇੱਕ ਲਾਈਨ ਦੀ ਬਜਾਏ ਕੋਡ ਦੀਆਂ 10 ਲਾਈਨਾਂ ਹਨ। ਭਵਿੱਖ ਵਿੱਚ, ਜੇਕਰ ਕਿਸੇ ਹੋਰ ਕਲਾਸ ਨੂੰ "ਵਾਕ" ਵਿਧੀ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਸਾਨੂੰ ਉਹ ਸਾਰਾ ਕੋਡ ਦੁਹਰਾਉਣਾ ਪਵੇਗਾ। ਇਹ ਆਦਰਸ਼ ਨਹੀਂ ਹੈ।
ਪ੍ਰੋਗਰਾਮਿੰਗ ਵਿੱਚ, ਸਾਡੇ ਕੋਲ ਇੱਕ ਸਿਧਾਂਤ ਹੈ ਜਿਸਨੂੰ DRY ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਜੋ ਆਪਣੇ ਆਪ ਨੂੰ ਨਾ ਦੁਹਰਾਉਣ ਲਈ ਛੋਟਾ ਹੈ। ਚਲੋ ਭਵਿੱਖ ਵਿੱਚ ਕਿਸੇ ਸਮੇਂ, ਅਸੀਂ ਆਪਣੀ "ਵਾਕ" ਵਿਧੀ ਵਿੱਚ ਇੱਕ ਸਮੱਸਿਆ ਦਾ ਪਤਾ ਲਗਾਉਂਦੇ ਹਾਂ ਅਤੇ ਜੇਕਰ ਅਸੀਂ ਇਸ ਵਿਧੀ ਨੂੰ ਕਈ ਹੋਰ ਥਾਵਾਂ 'ਤੇ ਦੁਹਰਾਇਆ ਹੈ ਜਾਂ ਡੁਪਲੀਕੇਟ ਕੀਤਾ ਹੈ, ਤਾਂ ਸਾਨੂੰ ਵਾਪਸ ਆਉਣਾ ਪਵੇਗਾ ਅਤੇ ਹਰ ਇੱਕ ਜਗ੍ਹਾ 'ਤੇ ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨਾ ਪਵੇਗਾ ਜੋ ਅਸੀਂ ਇਸ ਨੂੰ ਡੁਪਲੀਕੇਟ ਕੀਤਾ ਹੈ। ਕੋਡ। ਇਸ ਲਈ ਪ੍ਰੋਗਰਾਮਿੰਗ ਵਿੱਚ ਸਾਨੂੰ ਕਿਸੇ ਚੀਜ਼ ਨੂੰ ਦੋ ਵਾਰ ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।
ਇਸ ਸਮੱਸਿਆ ਦੇ ਹੱਲ ਲਈ ਵੱਖੋ-ਵੱਖਰੇ ਤਰੀਕੇ ਹਨ ਪਰ ਇੱਥੇ ਅਸੀਂ ਸਿੱਖਣ ਜਾ ਰਹੇ ਹਾਂ ਜੋ ਸ਼ੁਰੂਆਤ ਕਰਨ ਵਾਲਿਆਂ ਲਈ ਆਸਾਨ ਹੈ ਅਤੇ ਇਸਨੂੰ ਵਿਰਾਸਤ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਹੋਰ ਸ਼੍ਰੇਣੀ "ਥਣਧਾਰੀ" ਬਣਾਵਾਂਗੇ ਅਤੇ ਉਸ ਕਲਾਸ ਵਿੱਚ ਸਾਡੀ "ਵਾਕ" ਵਿਸ਼ੇਸ਼ਤਾ ਨੂੰ ਪਰਿਭਾਸ਼ਤ ਕਰਾਂਗੇ।
class Mammal:
def walk(self):
print("walk")
ਸਾਡੀ "ਮੈਮਲ" ਸ਼੍ਰੇਣੀ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਤੋਂ ਬਾਅਦ ਅਸੀਂ ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਗੁਣਾਂ ਨੂੰ ਪਾਸ ਕਰਨ ਲਈ ਵਿਰਾਸਤ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ:
ਦੋਨੋ ਕੁੱਤੇ ਅਤੇ ਬਿੱਲੀ ਵਰਗ ਆਪਣੇ ਮਾਤਾ-ਪਿਤਾ ਕਲਾਸ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਸਾਰੇ ਕਲਾਸ ਵਿਧੀਆਂ ਨੂੰ ਵਿਰਾਸਤ ਵਿੱਚ ਪ੍ਰਾਪਤ ਕਰ ਰਹੇ ਹਨ। ਹੁਣ, ਅਸੀਂ ਕੁੱਤਿਆਂ ਲਈ ਖਾਸ ਢੰਗਾਂ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਜੋੜ ਸਕਦੇ ਹਾਂ:
class Dog:
def bark(self):
print("bark")
ਲਪੇਟ!
ਇਹ ਸਭ ਕੁਝ ਕਲਾਸਾਂ, ਕੰਸਟਰਕਟਰਾਂ ਅਤੇ ਵਿਰਾਸਤੀ ਧਾਰਨਾਵਾਂ ਵਾਲੀਆਂ ਕਲਾਸਾਂ ਵਿੱਚ ਕੋਡ ਦੀ ਮੁੜ ਵਰਤੋਂ ਬਾਰੇ ਸੀ। ਹੁਣ ਅਸੀਂ ਆਪਣੀ ਲੜੀ ਦੇ ਅੰਤ ਦੇ ਨੇੜੇ ਹਾਂ। ਇਸ ਬਿੰਦੂ ਤੱਕ, ਤੁਹਾਨੂੰ ਪਾਈਥਨ ਵਿੱਚ ਚੰਗੇ, ਪੜ੍ਹਨਯੋਗ ਅਤੇ ਸੰਖੇਪ ਕੋਡ ਬਣਾਉਣ ਦੇ ਯੋਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।
ਅਸੀਂ ਅਗਲੇ ਲੈਕਚਰ ਵਿੱਚ ਮੋਡਿਊਲਾਂ ਅਤੇ ਪੈਕੇਜਾਂ ਦੀ ਧਾਰਨਾ ਦੇਖਾਂਗੇ।
ਕੋਈ ਜਵਾਬ ਛੱਡਣਾ