ਇਹ ਲੈਕਚਰ ਪਾਈਥਨ ਵਿੱਚ ਮੋਡਿਊਲਾਂ ਅਤੇ ਪੈਕੇਜਾਂ ਦੇ ਦੁਆਲੇ ਫੈਲੇਗਾ।
ਉਹ ਤੁਹਾਡੇ ਕੋਡ ਨੂੰ ਫਾਈਲਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਸੰਗਠਿਤ ਕਰਨ ਦਾ ਇੱਕ ਤਰੀਕਾ ਹਨ ਅਤੇ ਅਸਲ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਹਨ ਜੇਕਰ ਤੁਸੀਂ ਪਾਈਥਨ ਨਾਲ ਵੈਬ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਣ ਦਾ ਇਰਾਦਾ ਰੱਖਦੇ ਹੋ
ਮੋਡੀਊਲ
ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਮੋਡੀਊਲ ਅਸਲ ਵਿੱਚ ਕੁਝ ਪਾਈਥਨ ਕੋਡ ਵਾਲੀ ਇੱਕ ਫਾਈਲ ਹੈ ਜਿਸਦੀ ਵਰਤੋਂ ਅਸੀਂ ਆਪਣੇ ਕੋਡ ਨੂੰ ਫਾਈਲਾਂ ਵਿੱਚ ਸੰਗਠਿਤ ਕਰਨ ਲਈ ਕਰਦੇ ਹਾਂ। ਇਸ ਨੂੰ ਸੁਪਰਮਾਰਕੀਟ ਦੇ ਭਾਗਾਂ ਵਾਂਗ ਸੋਚੋ। ਜਦੋਂ ਤੁਸੀਂ ਕਿਸੇ ਸੁਪਰਮਾਰਕੀਟ ਵਿੱਚ ਜਾਂਦੇ ਹੋ ਤਾਂ ਉੱਥੇ ਫਲਾਂ, ਸਬਜ਼ੀਆਂ, ਸਫਾਈ ਉਤਪਾਦਾਂ ਆਦਿ ਲਈ ਵੱਖ-ਵੱਖ ਸੈਕਸ਼ਨ ਹੁੰਦੇ ਹਨ। ਤੁਹਾਨੂੰ ਸਾਰੇ ਉਤਪਾਦਾਂ ਦੇ ਨਾਲ ਇੱਕ ਸੈਕਸ਼ਨ ਨਹੀਂ ਦਿਖਾਈ ਦਿੰਦਾ।
ਪ੍ਰੋਗਰਾਮਿੰਗ ਵਿੱਚ ਵੀ ਇਹੀ ਧਾਰਨਾ ਹੈ। main.py ਵਿੱਚ ਸਾਰੇ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਕਲਾਸਾਂ ਦੇ ਨਾਲ ਸਾਡੇ ਸਾਰੇ ਕੋਡ ਲਿਖਣ ਦੀ ਬਜਾਏ, ਅਸੀਂ ਆਪਣੇ ਕੋਡ ਨੂੰ ਕਈ ਫਾਈਲਾਂ ਵਿੱਚ ਵੰਡਦੇ ਹਾਂ। ਹਰੇਕ ਫਾਈਲ ਨੂੰ ਇੱਕ ਮੋਡੀਊਲ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਇਸ ਨਾਲ, ਨਾ ਸਿਰਫ਼ ਸਾਡਾ ਕੋਡ ਬਿਹਤਰ ਢੰਗ ਨਾਲ ਸੰਗਠਿਤ ਅਤੇ ਢਾਂਚਾਗਤ ਹੈ, ਸਗੋਂ ਸਾਡੇ ਕੋਲ ਆਪਣੇ ਕੋਡ ਦੀ ਮੁੜ ਵਰਤੋਂ ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਵੀ ਹੈ। ਆਓ ਇਸ ਨੂੰ ਇੱਕ ਉਦਾਹਰਣ ਦੁਆਰਾ ਵੇਖੀਏ.
ਆਉ ਵਜ਼ਨ ਨੂੰ ਪੌਂਡ ਤੋਂ ਕਿਲੋਗ੍ਰਾਮ ਅਤੇ ਇਸ ਦੇ ਉਲਟ ਬਦਲਣ ਲਈ ਦੋ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੀਏ।
def lbs_to_kg(weight):
return weight * 0.45
def kg_to_lbs(weight):
return weight / 0.45
ਹੁਣ, ਅਸੀਂ ਇਹਨਾਂ ਦੋ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਲੈ ਸਕਦੇ ਹਾਂ ਅਤੇ ਉਹਨਾਂ ਨੂੰ "ਕਨਵਰਟਰਸ" ਨਾਮਕ ਇੱਕ ਵੱਖਰੇ ਮੋਡੀਊਲ ਵਿੱਚ ਪਾ ਸਕਦੇ ਹਾਂ, ਅਤੇ ਫਿਰ ਇਸਨੂੰ ਕਿਸੇ ਵੀ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਆਯਾਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜਿਸਨੂੰ ਇਹਨਾਂ ਕਨਵਰਟਰ ਫੰਕਸ਼ਨਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਆਓ ਮੈਂ ਤੁਹਾਨੂੰ ਦਿਖਾਵਾਂ ਕਿ ਇਹ ਕਿਵੇਂ ਕਰਨਾ ਹੈ।
ਆਉ ਸਾਡੇ ਪ੍ਰੋਜੈਕਟ ਪੈਨਲ ਨੂੰ ਖੋਲ੍ਹੀਏ ਅਤੇ ਪ੍ਰੋਜੈਕਟ ਉੱਤੇ ਸੱਜਾ-ਕਲਿੱਕ ਕਰੀਏ ਅਤੇ ਇੱਕ ਨਵੀਂ ਫਾਈਲ ਜੋੜੀਏ। ਅਸੀਂ ਇਸ ਫਾਈਲ ਨੂੰ "Converters.py" ਕਹਿਣ ਜਾ ਰਹੇ ਹਾਂ।
ਹੁਣ ਡਿਫਾਲਟ ਫਾਈਲ ਤੋਂ ਕੋਡ ਨੂੰ ਕਾਪੀ ਕਰੋ ਅਤੇ ਇਸਨੂੰ "Converters.py" ਵਿੱਚ ਪੇਸਟ ਕਰੋ।
ਇਸ ਨਾਲ, ਅਸੀਂ ਆਪਣੇ ਮੁੱਖ ਮੋਡੀਊਲ ਨੂੰ ਸਾਫ਼ ਕਰ ਲਿਆ ਹੈ ਅਤੇ ਇਹ ਵੱਖ-ਵੱਖ ਫੰਕਸ਼ਨਾਂ ਨਾਲ ਫੁੱਲਿਆ ਨਹੀਂ ਹੈ। ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਕਲਾਸਾਂ ਦੇ ਨਾਲ ਹੋਰ ਫੰਕਸ਼ਨ ਲਿਖਦੇ ਹਾਂ, ਅਸੀਂ ਉਹਨਾਂ ਨੂੰ ਉਹਨਾਂ ਦੇ ਅਨੁਸਾਰੀ ਮੋਡੀਊਲ ਵਿੱਚ ਰੱਖਦੇ ਹਾਂ। ਇੱਕ ਮੋਡੀਊਲ ਵਿੱਚ ਸਾਰੇ ਸੰਬੰਧਿਤ ਫੰਕਸ਼ਨ ਅਤੇ ਕਲਾਸਾਂ ਹੋਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ। ਹੁਣ, ਅਸੀਂ ਕਨਵਰਟਰਸ ਮੋਡੀਊਲ ਨੂੰ ਸਾਡੇ ਐਪ ਮੋਡੀਊਲ ਵਿੱਚ ਇੰਪੋਰਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਲਿਖੋ import converters
".py" ਐਕਸਟੈਂਸ਼ਨ ਦੇ ਬਿਨਾਂ ਸਿਖਰ 'ਤੇ।
ਅਸੀਂ ਵਿਧੀਆਂ ਦੇ ਸਮਾਨ ਇੱਕ ਡਾਟ ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਮੋਡੀਊਲ ਦੇ ਮੈਂਬਰਾਂ ਤੱਕ ਪਹੁੰਚ ਕਰ ਸਕਦੇ ਹਾਂ।
ਆਓ 70 ਕਿਲੋਗ੍ਰਾਮ ਨੂੰ ਪੌਂਡ ਵਿੱਚ ਬਦਲੀਏ:
ਮੋਡੀਊਲ ਆਯਾਤ ਕਰਨ ਲਈ ਇੱਕ ਹੋਰ ਸੰਟੈਕਸ ਵੀ ਹੈ। ਪੂਰੇ ਮੋਡੀਊਲ ਨੂੰ ਆਯਾਤ ਕਰਨ ਦੀ ਬਜਾਏ, ਅਸੀਂ ਉਸ ਮੋਡੀਊਲ ਤੋਂ ਖਾਸ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਆਯਾਤ ਕਰ ਸਕਦੇ ਹਾਂ। ਅਸੀਂ ਟਾਈਪ ਕਰ ਸਕਦੇ ਹਾਂ from Converters import
ਅਤੇ ਉਪਲਬਧ ਫੰਕਸ਼ਨਾਂ ਦੀ ਸੂਚੀ ਦਿਖਾਉਣ ਲਈ "ਕੰਟਰੋਲ + ਸਪੇਸ" ਦਬਾਓ। ਇਸਦੇ ਨਾਲ, ਅਸੀਂ ਇਸ ਫੰਕਸ਼ਨ ਨੂੰ ਸਿੱਧਾ ਕਾਲ ਕਰ ਸਕਦੇ ਹਾਂ।
ਕਸਰਤ
ਇਹ ਤੁਹਾਡੀ ਕਸਰਤ ਹੈ।
ਇਹ ਲੈਕਚਰ ਤੋਂ ਇੱਕ ਅਭਿਆਸ ਨਾਲ ਸਬੰਧਤ ਹੈ ਜਿੱਥੇ ਅਸੀਂ ਚਰਚਾ ਕੀਤੀ ਸੀ "ਲੂਪਾਂ ਲਈਜਿੱਥੇ ਅਸੀਂ ਸੂਚੀ ਵਿੱਚੋਂ ਸਭ ਤੋਂ ਵੱਡੀ ਸੰਖਿਆ ਲੱਭਣ ਲਈ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਲਿਖਿਆ ਹੈ
numbers = [8, 3, 6, 10, 5]
max = numbers[0]
for number in numbers:
if number > max:
max = number
print(max)
ਇਸ ਕੋਡ ਦਾ ਵਰਤਮਾਨ ਵਿੱਚ ਕੋਈ ਸੰਗਠਨ ਨਹੀਂ ਹੈ। ਸਾਡੇ ਕੋਲ ਕੋਈ ਫੰਕਸ਼ਨ ਜਾਂ ਮੋਡੀਊਲ ਨਹੀਂ ਹਨ ਅਤੇ ਪ੍ਰੋਗਰਾਮ ਇੱਕ ਸਿੰਗਲ ਫਾਈਲ ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ। ਇਹ ਛੋਟੇ ਪ੍ਰੋਗਰਾਮਾਂ ਲਈ ਠੀਕ ਹੈ ਪਰ ਜਿਵੇਂ-ਜਿਵੇਂ ਤੁਹਾਡੇ ਪ੍ਰੋਗਰਾਮ ਵਧਦੇ ਹਨ, ਤੁਹਾਨੂੰ ਆਪਣੇ ਕੋਡ ਨੂੰ ਕਲਾਸਾਂ ਅਤੇ ਮੌਡਿਊਲਾਂ ਵਿੱਚ ਠੀਕ ਤਰ੍ਹਾਂ ਸੰਗਠਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇਸ ਲਈ, ਇਸ ਅਭਿਆਸ ਦੇ ਹਿੱਸੇ ਵਜੋਂ, ਮੈਂ ਚਾਹੁੰਦਾ ਹਾਂ ਕਿ ਤੁਸੀਂ ਇੱਕ ਫੰਕਸ਼ਨ ਲਿਖੋ, ਇਸਨੂੰ ਕਾਲ ਕਰੋ find_max
. ਇਸ ਫੰਕਸ਼ਨ ਨੂੰ ਇੱਕ ਸੂਚੀ ਲੈਣੀ ਚਾਹੀਦੀ ਹੈ ਅਤੇ ਉਸ ਸੂਚੀ ਵਿੱਚ ਸਭ ਤੋਂ ਵੱਡੀ ਸੰਖਿਆ ਵਾਪਸ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ। ਇਸ ਤੋਂ ਬਾਅਦ ਅੱਗੇ ਵਧੋ ਅਤੇ ਇਸ ਫੰਕਸ਼ਨ ਨੂੰ ਇੱਕ ਵੱਖਰੇ ਮੋਡੀਊਲ ਵਿੱਚ ਰੱਖੋ, ਇਸਨੂੰ ਇੱਥੋਂ ਕੱਢੋ ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਮਾਡਿਊਲ ਵਿੱਚ ਰੱਖੋ utils
. ਇਸ ਮੋਡੀਊਲ ਵਿੱਚ ਉਪਯੋਗਤਾ ਫੰਕਸ਼ਨਾਂ ਦਾ ਇੱਕ ਸਮੂਹ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਨੂੰ ਆਯਾਤ ਕਰੋ utils
ਮੌਜੂਦਾ ਮੋਡੀਊਲ ਵਿੱਚ ਮੋਡੀਊਲ ਅਤੇ ਕਾਲ ਕਰੋ find_max
ਫੰਕਸ਼ਨ. ਅੰਤ ਵਿੱਚ, ਨਤੀਜਾ ਪ੍ਰਾਪਤ ਕਰੋ ਅਤੇ ਇਸਨੂੰ ਟਰਮੀਨਲ 'ਤੇ ਪ੍ਰਿੰਟ ਕਰੋ।
ਇਹ ਅਭਿਆਸ ਥੋੜਾ ਚੁਣੌਤੀਪੂਰਨ ਹੈ ਪਰ ਆਸਾਨੀ ਨਾਲ ਸੰਭਵ ਹੈ।
ਦਾ ਹੱਲ
ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਕੇ ਸ਼ੁਰੂ ਕਰੋ find_max
ਅਤੇ ਇੱਕ ਪੈਰਾਮੀਟਰ ਜੋੜੋ ਜਿਸਨੂੰ ਨੰਬਰ ਕਹਿੰਦੇ ਹਨ। ਇਸ ਫੰਕਸ਼ਨ ਦੇ ਅੰਦਰ, ਸੂਚੀ ਵਿੱਚ ਸਭ ਤੋਂ ਵੱਡੀ ਸੰਖਿਆ ਲੱਭਣ ਲਈ ਐਲਗੋਰਿਦਮ ਲਿਖੋ।
def find_max(numbers):
max = numbers[0]
for number in numbers:
if number > max:
max = number
return max
ਇਸ ਕੋਡ ਨੂੰ ਇੱਕ ਮੋਡੀਊਲ ਦੇ ਰੂਪ ਵਿੱਚ "utils.py" ਫਾਈਲ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕਰੋ।
ਸਾਡੇ ਮੁੱਖ ਪ੍ਰੋਗਰਾਮ 'ਤੇ ਵਾਪਸ ਜਾਓ, ਸਿਰਫ਼ ਦੋ ਸੰਟੈਕਸ ਵਿੱਚੋਂ ਕਿਸੇ ਇੱਕ ਦੁਆਰਾ ਮੋਡੀਊਲ ਨੂੰ ਆਯਾਤ ਕਰੋ ਅਤੇ ਸਿਰਫ਼ ਤਰਕ ਨੂੰ ਲਾਗੂ ਕਰੋ।
ਇੱਕ ਗੱਲ, ਮੈਨੂੰ ਤੁਹਾਡੇ ਧਿਆਨ ਵਿੱਚ ਲਿਆਉਣ ਦੀ ਲੋੜ ਹੈ ਕਿ ਉਹ ਕਮਜ਼ੋਰ ਹੈ max
. ਇਸ ਦਾ ਕਾਰਨ ਹੈ max
ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ ਹੈ ਅਤੇ ਅਸੀਂ ਇਸਨੂੰ ਦੁਬਾਰਾ ਪਰਿਭਾਸ਼ਿਤ ਕਰ ਰਹੇ ਹਾਂ। ਇਸ ਲਈ ਇਹ ਇੱਕ ਚੇਤਾਵਨੀ ਹੈ ਪਾਈਥਨ ਕੰਪਾਈਲਰ ਕਿ ਅਸੀਂ ਹੁਣ ਮੈਕਸ ਨੂੰ ਇਸਦੇ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ ਵਜੋਂ ਨਹੀਂ ਵਰਤ ਸਕਦੇ ਹਾਂ।
ਪਾਈਥਨ ਵਿੱਚ ਬਿਲਟ-ਇਨ ਮੋਡੀਊਲ
ਪਾਈਥਨ ਇੱਕ ਮਿਆਰੀ ਲਾਇਬ੍ਰੇਰੀ ਦੇ ਨਾਲ ਆਉਂਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਆਮ ਕੰਮਾਂ ਜਿਵੇਂ ਕਿ ਈਮੇਲ ਭੇਜਣਾ, ਮਿਤੀ ਅਤੇ ਸਮੇਂ ਨਾਲ ਕੰਮ ਕਰਨਾ, ਬੇਤਰਤੀਬ ਮੁੱਲ ਅਤੇ ਪਾਸਵਰਡ ਬਣਾਉਣਾ ਆਦਿ ਲਈ ਕਈ ਮੋਡਿਊਲ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ। ਪਾਇਥਨ ਵਿੱਚ ਪਹਿਲਾਂ ਹੀ ਬਹੁਤ ਸਾਰੇ ਮੋਡੀਊਲ ਬਣਾਏ ਗਏ ਹਨ ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਪਹਿਲਾਂ ਹੀ ਬਹੁਤ ਸਾਰੀਆਂ ਕਾਰਜਸ਼ੀਲਤਾ ਹਨ ਜੋ ਅਸੀਂ ਦੁਬਾਰਾ ਵਰਤ ਸਕਦੇ ਹਾਂ। ਤੁਸੀਂ ਇਹ ਮੋਡੀਊਲ ਲੱਭ ਸਕਦੇ ਹੋ ਇਥੇ.
ਪੈਕੇਜ
ਪੈਕੇਜ ਮੂਲ ਰੂਪ ਵਿੱਚ ਸਾਡੇ ਕੋਡ ਨੂੰ ਮੋਡਿਊਲਾਂ ਦੇ ਸਿਖਰ 'ਤੇ ਵਿਵਸਥਿਤ ਕਰਨ ਦਾ ਇੱਕ ਹੋਰ ਤਰੀਕਾ ਹੈ। ਇੱਕ ਅਸਲੀ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਸੈਂਕੜੇ ਜਾਂ ਹਜ਼ਾਰਾਂ ਮੋਡੀਊਲ ਹੋ ਸਕਦੇ ਹਨ ਅਤੇ ਸਮੇਂ ਦੇ ਨਾਲ ਸਾਡੀ ਡਾਇਰੈਕਟਰੀ ਬਹੁਤ ਸਾਰੀਆਂ ਫਾਈਲਾਂ ਨਾਲ ਫੁੱਲ ਜਾਵੇਗੀ। ਇਸਲਈ, ਇੱਕ ਬਿਹਤਰ ਪਹੁੰਚ ਇੱਕ ਪੈਕੇਜ ਦੇ ਅੰਦਰ ਸਬੰਧਿਤ ਮੈਡਿਊਲਾਂ ਨੂੰ ਸੰਗਠਿਤ ਕਰਨਾ ਹੈ ਜੋ ਪੈਕੇਜ ਨੂੰ ਮਲਟੀਪਲ ਮੈਡਿਊਲਾਂ ਲਈ ਇੱਕ ਕੰਟੇਨਰ ਬਣਾਉਂਦਾ ਹੈ।
ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਇੱਕ ਨਵੀਂ ਡਾਇਰੈਕਟਰੀ ਜੋੜੀ ਜਾਂਦੀ ਹੈ ਅਤੇ ਸਾਰੇ ਸੰਬੰਧਿਤ ਮੋਡੀਊਲ ਉਸ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਇੱਕ ਉਦਾਹਰਨ ਦੇ ਤੌਰ ਤੇ, ਇੱਕ ਮਾਲ ਬਾਰੇ ਸੋਚੋ. ਇੱਕ ਮਾਲ ਵਿੱਚ ਪੁਰਸ਼ਾਂ, ਔਰਤਾਂ ਅਤੇ ਬੱਚਿਆਂ ਦੇ ਲਿਬਾਸ ਲਈ ਵੱਖ-ਵੱਖ ਸੈਕਸ਼ਨ ਹਨ ਜੋ ਪੈਕੇਜਾਂ ਵਾਂਗ ਹਨ। ਹਰੇਕ ਭਾਗ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੇ ਉਤਪਾਦਾਂ ਜਿਵੇਂ ਕਿ ਜੁੱਤੀਆਂ, ਟੀ-ਸ਼ਰਟਾਂ ਅਤੇ ਜੈਕਟਾਂ ਲਈ ਵੱਖ-ਵੱਖ ਖੇਤਰ ਹਨ। ਇਹਨਾਂ ਨੂੰ ਮੋਡੀਊਲ ਸਮਝੋ।
ਆਓ ਦੇਖੀਏ, ਪਾਈਥਨ ਵਿੱਚ ਪੈਕੇਜ ਕਿਵੇਂ ਬਣਾਉਣੇ ਅਤੇ ਵਰਤਣੇ ਹਨ।
ਪਹਿਲਾਂ, ਪ੍ਰੋਜੈਕਟ ਪੈਨਲ ਤੋਂ ਇੱਕ ਨਵੀਂ ਡਾਇਰੈਕਟਰੀ ਸ਼ਾਮਲ ਕਰੋ। ਚਲੋ ਇਸਨੂੰ "ਈ-ਕਾਮਰਸ" ਕਹਿੰਦੇ ਹਾਂ। ਇਸ ਪੈਕੇਜ ਵਿੱਚ ਇੱਕ ਈ-ਕਾਮਰਸ ਐਪਲੀਕੇਸ਼ਨ ਨਾਲ ਸਬੰਧਤ ਸਾਰੇ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਹੋਣਗੇ।
ਇਹ ਅਜੇ ਵੀ ਇੱਕ ਖਾਲੀ ਡਾਇਰੈਕਟਰੀ ਹੈ ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਪੈਕੇਜ ਵਿੱਚ ਬਦਲਣ ਲਈ, ਸਾਨੂੰ ਇਸ ਵਿੱਚ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਫਾਈਲ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ। ਇਸ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਇੱਕ ਨਵੀਂ ਪਾਈਥਨ ਫਾਈਲ ਸ਼ਾਮਲ ਕਰੋ ਅਤੇ ਉਸ ਫਾਈਲ ਨੂੰ “__init__” ਨਾਮ ਦਿਓ। ਇਹ ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਸੰਮੇਲਨ ਹੈ ਅਤੇ ਜਦੋਂ ਪਾਈਥਨ ਦੁਭਾਸ਼ੀਏ ਇੱਕ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਇਸ ਨਾਮ ਵਾਲੀ ਇੱਕ ਫਾਈਲ ਨੂੰ ਵੇਖਦਾ ਹੈ, ਤਾਂ ਇਹ ਇਸ ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਇੱਕ ਪੈਕੇਜ ਵਜੋਂ ਮੰਨਦਾ ਹੈ।
ਸਾਡੇ ਕੋਲ ਇੱਕ ਪੈਕੇਜ ਬਣਾਉਣ ਲਈ ਇੱਕ ਵਿਕਲਪਿਕ ਅਤੇ ਸੰਖੇਪ ਤਰੀਕਾ ਵੀ ਹੈ। ਸਿਰਫ਼ ਪ੍ਰੋਜੈਕਟ ਪੈਨਲ 'ਤੇ ਸੱਜਾ-ਕਲਿੱਕ ਕਰੋ ਅਤੇ ਸੂਚੀ ਵਿੱਚੋਂ ਇੱਕ ਪਾਈਥਨ ਪੈਕੇਜ ਬਣਾਓ। ਇਸਨੂੰ "ਈ-ਕਾਮਰਸ" ਨਾਮ ਦਿਓ ਅਤੇ ਬੱਸ. ਇਹ ਆਪਣੇ ਆਪ "__init__" ਨਾਮ ਦੀ ਪਾਈਥਨ ਫਾਈਲ ਨਾਲ ਇੱਕ ਡਾਇਰੈਕਟਰੀ ਬਣਾ ਦੇਵੇਗਾ।
ਹੁਣ, ਆਉ ਪੈਕੇਜ ਵਿੱਚ ਇੱਕ ਮੋਡੀਊਲ ਬਣਾਉ ਅਤੇ ਇਸਨੂੰ "ਸ਼ਿਪਿੰਗ" ਨਾਮ ਦੇਈਏ। ਇਸ ਮੋਡੀਊਲ ਵਿੱਚ, ਆਓ ਸ਼ਿਪਿੰਗ ਲਾਗਤਾਂ ਦੀ ਗਣਨਾ ਕਰਨ ਲਈ ਇੱਕ ਸਧਾਰਨ ਫੰਕਸ਼ਨ ਬਣਾਈਏ।
def calc_shipping():
print("calc_shipping")
ਸਾਡੇ ਮੁੱਖ ਮੋਡੀਊਲ ਵਿੱਚ ਇਸ ਫੰਕਸ਼ਨ ਨੂੰ ਐਕਸੈਸ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਇਸਨੂੰ ਈ-ਕਾਮਰਸ ਪੈਕੇਜ ਦੁਆਰਾ ਐਕਸੈਸ ਕਰਨਾ ਹੋਵੇਗਾ। ਇੱਕ ਵਾਰ ਫਿਰ ਸਾਡੇ ਕੋਲ ਇਸ ਮੋਡੀਊਲ ਨੂੰ ਆਯਾਤ ਕਰਨ ਦੇ ਦੋ ਤਰੀਕੇ ਹਨ।
ਪਹਿਲੀ ਵਿਧੀ ਵਿੱਚ, ਅਸੀਂ ਪੂਰੇ ਮੋਡੀਊਲ ਨੂੰ ਆਯਾਤ ਕਰ ਸਕਦੇ ਹਾਂ ਅਤੇ ਫਿਰ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਕਾਲ ਕਰ ਸਕਦੇ ਹਾਂ:
import eCommerce.shipping
eCommerce.shipping.calc_shipping()
ਹਾਲਾਂਕਿ, ਇਸ ਪਹੁੰਚ ਨਾਲ, ਇਸ ਮੋਡੀਊਲ ਵਿੱਚ ਫੰਕਸ਼ਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਨੂੰ ਕਾਲ ਕਰਨ ਲਈ ਇਸਦੇ ਨਾਲ ਅਗੇਤਰ ਲਗਾਉਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ eCommerce.shipping.
ਇਹ ਬਹੁਤ ਜ਼ੁਬਾਨੀ ਹੈ. ਇਸ ਲਈ, ਪੈਕੇਜਾਂ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਅਸੀਂ ਅਕਸਰ ਦੂਜੀ ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ ਅਤੇ ਵਰਤਦੇ ਹਾਂ from
ਬਿਆਨ
from eCommerce.shipping import calc_shipping
calc_shipping()
ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਮੋਡੀਊਲ ਵਿੱਚ ਕਈ ਫੰਕਸ਼ਨ ਹਨ ਤਾਂ ਤੁਸੀਂ ਉਹਨਾਂ ਵਿਚਕਾਰ ਕਾਮਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਉਹਨਾਂ ਸਾਰਿਆਂ ਨੂੰ ਇੱਕ ਲਾਈਨ ਵਿੱਚ ਆਯਾਤ ਕਰ ਸਕਦੇ ਹੋ। ਮੰਨ ਲਓ ਕਿ ਸਾਡੇ ਸ਼ਿਪਿੰਗ ਮੋਡੀਊਲ ਵਿੱਚ ਟੈਕਸ ਦੀ ਗਣਨਾ ਕਰਨ ਲਈ ਇੱਕ ਹੋਰ ਫੰਕਸ਼ਨ ਹੈ। ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਆਯਾਤ ਕੀਤਾ ਜਾਵੇਗਾ:
from eCommerce.shipping import calc_shipping, calc_tax
ਤੁਸੀਂ ਵਿਅਕਤੀਗਤ ਮੋਡੀਊਲ ਵੀ ਆਯਾਤ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਪ੍ਰੋਗਰਾਮ ਦੇ ਬਾਅਦ ਦੇ ਪੜਾਅ 'ਤੇ ਬੁਲਾਏ ਜਾਣ ਵਾਲੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਛੱਡ ਸਕਦੇ ਹੋ। ਆਉ ਮੋਡੀਊਲ ਸ਼ਿਪਿੰਗ ਨੂੰ ਆਯਾਤ ਕਰੀਏ ਅਤੇ ਫਿਰ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਨ ਲਈ ਇੱਕ ਡਾਟ ਆਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰੀਏ calc_shipping.
from eCommerce import shipping
shipping.calc_shipping()
ਲਪੇਟ!
ਪਾਇਥਨ ਵਿੱਚ ਪੈਕੇਜ ਅਤੇ ਮੋਡੀਊਲ ਬਹੁਤ ਮਹੱਤਵਪੂਰਨ ਹਨ। ਖਾਸ ਤੌਰ 'ਤੇ, ਜਦੋਂ ਤੁਸੀਂ Django ਵਰਗੇ ਫਰੇਮਵਰਕ ਨਾਲ ਕੰਮ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਜੋ ਬਿਲਡਿੰਗ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨ ਪਾਈਥਨ ਦੇ ਨਾਲ. ਅਸੀਂ ਇੱਕ ਹੋਰ ਪਾਈਥਨ ਕੋਰਸ ਦੌਰਾਨ ਜੰਜੋ ਨੂੰ ਦੇਖਾਂਗੇ।
ਇਸ ਲੜੀ ਦਾ ਇਹ ਆਖਰੀ ਪਰੰਪਰਾਗਤ ਲੈਕਚਰ ਸੀ। ਅਗਲਾ ਲੈਕਚਰ ਸਾਡੇ ਆਮ ਫਾਰਮੈਟ ਤੋਂ ਭਟਕ ਜਾਵੇਗਾ ਅਤੇ ਅਸੀਂ ਪਾਈਥਨ ਵਿੱਚ ਕੁਝ ਮਹੱਤਵਪੂਰਨ ਵਰਤੋਂ ਦੇ ਕੇਸਾਂ ਨੂੰ ਸਿੱਖਾਂਗੇ। ਇਹ ਇਸ ਲੜੀ ਦੇ ਅੰਤ ਦੀ ਨਿਸ਼ਾਨਦੇਹੀ ਕਰੇਗਾ ਅਤੇ ਅਸੀਂ ਸਾਡੀ ਅਗਲੀ ਪਾਈਥਨ ਲੜੀ 'ਤੇ ਜਾਵਾਂਗੇ। ਇਸਦੇ ਲਈ ਬਣੇ ਰਹੋ।
ਕੋਈ ਜਵਾਬ ਛੱਡਣਾ