ਪਾਈਥਨ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦੀ ਵਿਸ਼ਾਲ ਦੁਨੀਆ ਵਿੱਚ, ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦਾ ਇੱਕ ਸਮੂਹ ਹੈ ਜੋ ਅਕਸਰ ਸ਼ੁਰੂਆਤ ਕਰਨ ਵਾਲਿਆਂ ਦੁਆਰਾ ਅਣਦੇਖਿਆ ਜਾਂਦਾ ਹੈ, ਫਿਰ ਵੀ ਭਾਸ਼ਾ ਦੇ ਈਕੋਸਿਸਟਮ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਮਹੱਤਵ ਰੱਖਦਾ ਹੈ।
ਮੈਜਿਕ ਵਿਧੀਆਂ ਪੂਰਵ ਵਿਧੀਆਂ ਦਾ ਇੱਕ ਸਮੂਹ ਹਨdefiਪਾਈਥਨ ਵਿੱਚ ਨਾਈਟਸ ਜੋ ਵਿਸ਼ੇਸ਼ ਸਿੰਟੈਕਟਿਕ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ। ਉਹ ਆਸਾਨੀ ਨਾਲ ਸ਼ੁਰੂਆਤ ਅਤੇ ਅੰਤ 'ਤੇ ਆਪਣੇ ਡਬਲ ਡੈਸ਼ ਦੁਆਰਾ ਪਛਾਣੇ ਜਾਂਦੇ ਹਨ, ਜਿਵੇਂ __init__, __call__, __len__ … ਆਦਿ
ਮੈਜਿਕ ਵਿਧੀਆਂ ਕਸਟਮ ਆਬਜੈਕਟ ਨੂੰ ਬਿਲਟ-ਇਨ ਪਾਈਥਨ ਕਿਸਮਾਂ ਦੇ ਸਮਾਨ ਵਿਵਹਾਰ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀਆਂ ਹਨ।
ਇਸ ਲੇਖ ਵਿਚ, ਅਸੀਂ ਸ਼ਕਤੀਸ਼ਾਲੀ ਡੰਡਰ ਫੰਕਸ਼ਨਾਂ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਤ ਕਰਾਂਗੇ. ਅਸੀਂ ਉਹਨਾਂ ਦੇ ਉਦੇਸ਼ ਦੀ ਪੜਚੋਲ ਕਰਾਂਗੇ ਅਤੇ ਉਹਨਾਂ ਦੀ ਵਰਤੋਂ ਬਾਰੇ ਚਰਚਾ ਕਰਾਂਗੇ।
ਭਾਵੇਂ ਤੁਸੀਂ ਪਾਈਥਨ ਦੇ ਨਵੇਂ ਜਾਂ ਤਜਰਬੇਕਾਰ ਪ੍ਰੋਗਰਾਮਰ ਹੋ, ਇਸ ਲੇਖ ਦਾ ਉਦੇਸ਼ ਤੁਹਾਨੂੰ ਡੰਡਰ ਫੰਕਸ਼ਨਾਂ ਦੀ ਇੱਕ ਵਿਆਪਕ ਸਮਝ ਪ੍ਰਦਾਨ ਕਰਨਾ ਹੈ, ਜਿਸ ਨਾਲ ਤੁਹਾਡੇ ਪਾਈਥਨ ਕੋਡਿੰਗ ਅਨੁਭਵ ਨੂੰ ਵਧੇਰੇ ਕੁਸ਼ਲ ਅਤੇ ਆਨੰਦਦਾਇਕ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।
ਯਾਦ ਰੱਖੋ, ਪਾਈਥਨ ਦਾ ਜਾਦੂ ਨਾ ਸਿਰਫ਼ ਇਸਦੀ ਸਾਦਗੀ ਅਤੇ ਬਹੁਪੱਖੀਤਾ ਵਿੱਚ ਹੈ, ਸਗੋਂ ਡੰਡਰ ਫੰਕਸ਼ਨਾਂ ਵਰਗੀਆਂ ਇਸ ਦੀਆਂ ਸ਼ਕਤੀਸ਼ਾਲੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚ ਵੀ ਹੈ।
ਸ਼ਾਇਦ ਸਭ ਦਾ ਸਭ ਤੋਂ ਬੁਨਿਆਦੀ ਡੰਡਰ ਫੰਕਸ਼ਨ. ਇਹ ਉਹ ਜਾਦੂਈ ਤਰੀਕਾ ਹੈ ਜਿਸ ਨੂੰ ਪਾਇਥਨ ਆਪਣੇ ਆਪ ਕਾਲ ਕਰਦਾ ਹੈ ਜਦੋਂ ਵੀ ਅਸੀਂ ਕੋਈ ਨਵੀਂ ਵਸਤੂ ਬਣਾਉਂਦੇ ਹਾਂ (ਜਾਂ ਜਿਵੇਂ ਕਿ ਨਾਮ ਤੋਂ ਪਤਾ ਲੱਗਦਾ ਹੈ, ਸ਼ੁਰੂ ਕਰਨਾ)।__init__
ਕਲਾਸ ਪੀਜ਼ਾ:
def __init__(ਸਵੈ, ਆਕਾਰ, ਟੌਪਿੰਗਜ਼):
self.size = ਆਕਾਰ
self.toppings = toppings
# ਆਓ ਹੁਣ ਇੱਕ ਪੀਜ਼ਾ ਬਣਾਉਂਦੇ ਹਾਂ
my_pizza = ਪੀਜ਼ਾ ('ਵੱਡਾ', ['ਪੀਪੇਰੋਨੀ', 'ਮਸ਼ਰੂਮ'])
print(my_pizza.size) # ਇਹ ਪ੍ਰਿੰਟ ਕਰੇਗਾ: ਵੱਡਾ
print(my_pizza.toppings) # ਇਹ ਪ੍ਰਿੰਟ ਕਰੇਗਾ: ['ਪੇਪੇਰੋਨੀ', 'ਮਸ਼ਰੂਮ']
ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, ਪੀਜ਼ਾ ਨਾਮਕ ਇੱਕ ਕਲਾਸ ਬਣਾਈ ਗਈ ਹੈ। ਅਸੀਂ ਆਪਣੇ __init__ ਫੰਕਸ਼ਨ ਨੂੰ ਸ਼ੁਰੂਆਤੀ ਸਮੇਂ ਤੇ ਨਿਰਧਾਰਤ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਸੈਟ ਅਪ ਕਰਦੇ ਹਾਂ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਸਾਡੇ ਕਸਟਮ ਆਬਜੈਕਟ ਲਈ ਵਿਸ਼ੇਸ਼ਤਾ ਵਜੋਂ ਸੈਟ ਕਰਦੇ ਹਾਂ।
ਇੱਥੇ, ਇਹ ਕਲਾਸ ਦੀ ਉਦਾਹਰਣ ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਇਸ ਲਈ ਜਦੋਂ ਅਸੀਂ self.size = ਆਕਾਰ ਲਿਖਦੇ ਹਾਂ, ਅਸੀਂ ਕਹਿ ਰਹੇ ਹਾਂ, "ਹੇ, ਇਸ ਪੀਜ਼ਾ ਵਸਤੂ ਦਾ ਇੱਕ ਵਿਸ਼ੇਸ਼ਤਾ ਆਕਾਰ ਹੈ size, ਅਤੇ ਮੈਂ ਚਾਹੁੰਦਾ ਹਾਂ ਕਿ ਇਹ ਉਹ ਆਕਾਰ ਹੋਵੇ ਜੋ ਮੈਂ ਪ੍ਰਦਾਨ ਕੀਤਾ ਸੀ ਜਦੋਂ ਮੈਂ ਆਬਜੈਕਟ ਬਣਾਇਆ ਸੀ"।
ਇਹ ਪਾਈਥਨ ਦਾ ਜਾਦੂਈ ਤਰੀਕਾ ਹੈ ਜੋ ਸਾਨੂੰ ਇਸਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ defiਸਾਡੀ ਕਸਟਮ ਆਈਟਮ ਲਈ ਵਰਣਨ ਕਰੋ।
ਜਦੋਂ ਤੁਸੀਂ ਕਿਸੇ ਵਸਤੂ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਦੇ ਹੋ ਜਾਂ ਇਸਨੂੰ ਵਰਤਦੇ ਹੋਏ ਇੱਕ ਸਤਰ ਵਿੱਚ ਬਦਲਦੇ ਹੋ str(), ਪਾਈਥਨ ਚੈੱਕ ਕਰੋ ਕਿ ਕੀ ਤੁਹਾਡੇ ਕੋਲ ਹੈ defiਮੈਂ ਇੱਕ ਢੰਗ ਲੈ ਕੇ ਆਇਆ ਹਾਂ __str__ ਉਸ ਵਸਤੂ ਦੀ ਕਲਾਸ ਲਈ.
ਜੇਕਰ ਅਜਿਹਾ ਹੈ, ਤਾਂ ਆਬਜੈਕਟ ਨੂੰ ਇੱਕ ਸਤਰ ਵਿੱਚ ਬਦਲਣ ਲਈ ਉਸ ਢੰਗ ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਅਸੀਂ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਆਪਣੇ ਪੀਜ਼ਾ ਉਦਾਹਰਨ ਨੂੰ ਵਧਾ ਸਕਦੇ ਹਾਂ __str__ ਹੇਠ ਦਿੱਤੇ ਅਨੁਸਾਰ:
ਕਲਾਸ ਪੀਜ਼ਾ: def __init__(self, size, toppings): self.size = size self.toppings = toppings def __str__(self): {', '.join(self.toppings) ਨਾਲ f"A {self.size} ਪੀਜ਼ਾ ਵਾਪਸ ਕਰੋ )}" my_pizza = Pizza('large', ['pepperoni', 'mushrooms']) print(my_pizza) # ਇਹ ਪ੍ਰਿੰਟ ਕਰੇਗਾ: ਪੇਪਰੋਨੀ, ਮਸ਼ਰੂਮਜ਼ ਵਾਲਾ ਇੱਕ ਵੱਡਾ ਪੀਜ਼ਾ
__repr____str__ ਫੰਕਸ਼ਨ ਕਿਸੇ ਵਸਤੂ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦਾ ਵਰਣਨ ਕਰਨ ਦਾ ਇੱਕ ਗੈਰ ਰਸਮੀ ਤਰੀਕਾ ਹੈ। ਦੂਜੇ ਪਾਸੇ, __repr__ ਦੀ ਵਰਤੋਂ ਕਸਟਮ ਆਬਜੈਕਟ ਦਾ ਵਧੇਰੇ ਰਸਮੀ, ਵਿਸਤ੍ਰਿਤ ਅਤੇ ਅਸਪਸ਼ਟ ਵਰਣਨ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
ਜੇ ਤੁਸੀਂ ਕਾਲ ਕਰੋ repr() ਕਿਸੇ ਵਸਤੂ 'ਤੇ ਜਾਂ ਤੁਸੀਂ ਕੰਸੋਲ ਵਿੱਚ ਆਬਜੈਕਟ ਦਾ ਨਾਮ ਟਾਈਪ ਕਰਦੇ ਹੋ, ਪਾਈਥਨ ਇੱਕ ਢੰਗ ਲੱਭੇਗਾ __repr__.
Se __str__ ਇਹ ਨਹੀਂ ਹੈ defiਨਾਈਟ, ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰੇਗਾ __repr__ ਇੱਕ ਬੈਕਅੱਪ ਦੇ ਤੌਰ ਤੇ ਜਦੋਂ ਆਬਜੈਕਟ ਨੂੰ ਛਾਪਣ ਜਾਂ ਇਸਨੂੰ ਇੱਕ ਸਤਰ ਵਿੱਚ ਬਦਲਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹੋ। ਇਸ ਲਈ ਇਹ ਅਕਸਰ ਇੱਕ ਚੰਗਾ ਵਿਚਾਰ ਹੁੰਦਾ ਹੈ defiਘੱਟੋ-ਘੱਟ ਖਤਮ __repr__, ਭਾਵੇਂ ਤੁਸੀਂ ਨਹੀਂ ਕਰਦੇ defiਬਾਹਰ ਆਉਂਦਾ ਹੈ __str__.
ਇੱਥੇ ਅਸੀਂ ਕਿਵੇਂ ਕਰ ਸਕਦੇ ਹਾਂ defiਖਤਮ __repr__ ਸਾਡੇ ਪੀਜ਼ਾ ਉਦਾਹਰਨ ਲਈ:
ਕਲਾਸ ਪੀਜ਼ਾ:
def __init__(ਸਵੈ, ਆਕਾਰ, ਟੌਪਿੰਗਜ਼):
self.size = ਆਕਾਰ
self.toppings = toppings
def __repr__(ਸਵੈ):
ਵਾਪਸੀ f"Pizza('{self.size}', {self.toppings})"
my_pizza = ਪੀਜ਼ਾ ('ਵੱਡਾ', ['ਪੀਪੇਰੋਨੀ', 'ਮਸ਼ਰੂਮ'])
print(repr(my_pizza)) # ਇਹ ਪ੍ਰਿੰਟ ਕਰੇਗਾ: Pizza('lage', ['pepperoni', 'mushrooms'])
__repr__ ਤੁਹਾਨੂੰ ਇੱਕ ਸਤਰ ਦਿੰਦਾ ਹੈ ਜੋ ਤੁਸੀਂ ਪੀਜ਼ਾ ਆਬਜੈਕਟ ਨੂੰ ਦੁਬਾਰਾ ਬਣਾਉਣ ਲਈ ਪਾਈਥਨ ਕਮਾਂਡ ਦੇ ਤੌਰ ਤੇ ਚਲਾ ਸਕਦੇ ਹੋ, ਜਦੋਂ ਕਿ __str__ ਤੁਹਾਨੂੰ ਇੱਕ ਹੋਰ ਮਨੁੱਖੀ ਵਰਣਨ ਦਿੰਦਾ ਹੈ. ਮੈਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਇਹ ਤੁਹਾਨੂੰ ਇਹਨਾਂ ਡੰਡਰ ਤਰੀਕਿਆਂ ਨੂੰ ਥੋੜਾ ਬਿਹਤਰ ਚਬਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰੇਗਾ!
ਪਾਈਥਨ ਵਿੱਚ, ਅਸੀਂ ਸਾਰੇ ਜਾਣਦੇ ਹਾਂ ਕਿ ਆਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਨੰਬਰ ਜੋੜਨਾ ਸੰਭਵ ਹੈ +, ਜਿਵੇਂ 3 + 5.
ਪਰ ਉਦੋਂ ਕੀ ਜੇ ਅਸੀਂ ਕੁਝ ਕਸਟਮ ਆਬਜੈਕਟ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਨੂੰ ਜੋੜਨਾ ਚਾਹੁੰਦੇ ਹਾਂ?
ਡੰਡਰ ਫੰਕਸ਼ਨ __add__ ਇਹ ਸਾਨੂੰ ਅਜਿਹਾ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਇਹ ਸਾਨੂੰ ਕਰਨ ਦੀ ਯੋਗਤਾ ਦਿੰਦਾ ਹੈ defiਆਪਰੇਟਰ ਦੇ ਵਿਵਹਾਰ ਨੂੰ ਖਤਮ ਕਰੋ + ਸਾਡੀਆਂ ਵਿਅਕਤੀਗਤ ਆਈਟਮਾਂ 'ਤੇ।
ਇਕਸਾਰਤਾ ਦੇ ਹਿੱਤ ਵਿੱਚ, ਮੰਨ ਲਓ ਕਿ ਅਸੀਂ ਚਾਹੁੰਦੇ ਹਾਂ defiਦੇ ਵਿਵਹਾਰ ਨੂੰ ਖਤਮ ਕਰੋ + ਸਾਡੇ ਪੀਜ਼ਾ ਉਦਾਹਰਨ 'ਤੇ. ਦੱਸ ਦਈਏ ਕਿ ਜਦੋਂ ਵੀ ਅਸੀਂ ਦੋ ਜਾਂ ਦੋ ਤੋਂ ਵੱਧ ਪੀਜ਼ਾ ਇਕੱਠੇ ਜੋੜਦੇ ਹਾਂ, ਤਾਂ ਇਹ ਆਪਣੇ ਆਪ ਹੀ ਉਨ੍ਹਾਂ ਦੀਆਂ ਸਾਰੀਆਂ ਟੌਪਿੰਗਾਂ ਨੂੰ ਜੋੜ ਦੇਵੇਗਾ। ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਦਾ ਦਿਖਾਈ ਦੇ ਸਕਦਾ ਹੈ:
ਕਲਾਸ ਪੀਜ਼ਾ:
def __init__(ਸਵੈ, ਆਕਾਰ, ਟੌਪਿੰਗਜ਼):
self.size = ਆਕਾਰ
self.toppings = toppings
def __add__(ਸਵੈ, ਹੋਰ):
ਜੇਕਰ ਨਹੀਂ ਤਾਂ (ਹੋਰ, ਪੀਜ਼ਾ):
ਟਾਈਪ ਈਰਰ ਵਧਾਓ ("ਤੁਸੀਂ ਸਿਰਫ ਇੱਕ ਹੋਰ ਪੀਜ਼ਾ ਜੋੜ ਸਕਦੇ ਹੋ!")
new_toppings = self.toppings + other.toppings
ਰਿਟਰਨ ਪੀਜ਼ਾ (self.size, new_toppings)
# ਆਓ ਦੋ ਪੀਜ਼ਾ ਬਣਾਈਏ
pizza1 = ਪੀਜ਼ਾ ('ਵੱਡਾ', ['ਪੇਪੇਰੋਨੀ', 'ਮਸ਼ਰੂਮ'])
pizza2 = ਪੀਜ਼ਾ ('ਵੱਡਾ', ['ਜੈਤੂਨ', 'ਅਨਾਨਾਸ'])
# ਅਤੇ ਹੁਣ ਆਓ ਉਹਨਾਂ ਨੂੰ "ਐਡ" ਕਰੀਏ
combined_pizza = pizza1 + pizza2
print(combined_pizza.toppings) # ਇਹ ਪ੍ਰਿੰਟ ਕਰੇਗਾ: ['ਪੇਪੇਰੋਨੀ', 'ਮਸ਼ਰੂਮ', 'ਜੈਤੂਨ', 'ਅਨਾਨਾਸ']
ਇਸੇ ਤਰ੍ਹਾਂ ਡੰਡਰ ਨੂੰ __add__, ਅਸੀਂ ਵੀ ਕਰ ਸਕਦੇ ਹਾਂ defiਹੋਰ ਅੰਕਗਣਿਤ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਪੂਰਾ ਕਰੋ ਜਿਵੇਂ ਕਿ __sub__ (ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਘਟਾਓ -) ਈ __mul__ (ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਗੁਣਾ ਕਰਨ ਲਈ *).
ਇਹ ਡੰਡਰ ਵਿਧੀ ਸਾਨੂੰ ਆਗਿਆ ਦਿੰਦੀ ਹੈ defiਫੰਕਸ਼ਨ ਨੂੰ ਪੂਰਾ ਕਰੋ len() ਸਾਡੀਆਂ ਅਨੁਕੂਲਿਤ ਆਈਟਮਾਂ ਲਈ ਵਾਪਸ ਆਉਣਾ ਚਾਹੀਦਾ ਹੈ.
ਪਾਈਥਨ ਵਰਤਦਾ ਹੈ len() ਇੱਕ ਡੇਟਾ ਢਾਂਚੇ ਦੀ ਲੰਬਾਈ ਜਾਂ ਆਕਾਰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਜਿਵੇਂ ਕਿ ਇੱਕ ਸੂਚੀ ਜਾਂ ਸਤਰ।
ਸਾਡੇ ਉਦਾਹਰਣ ਦੇ ਸੰਦਰਭ ਵਿੱਚ, ਅਸੀਂ ਕਹਿ ਸਕਦੇ ਹਾਂ ਕਿ ਇੱਕ ਪੀਜ਼ਾ ਦੀ "ਲੰਬਾਈ" ਇਸ ਵਿੱਚ ਟੌਪਿੰਗ ਦੀ ਗਿਣਤੀ ਹੈ। ਇੱਥੇ ਅਸੀਂ ਇਸਨੂੰ ਕਿਵੇਂ ਲਾਗੂ ਕਰ ਸਕਦੇ ਹਾਂ:
ਕਲਾਸ ਪੀਜ਼ਾ:
def __init__(ਸਵੈ, ਆਕਾਰ, ਟੌਪਿੰਗਜ਼):
self.size = ਆਕਾਰ
self.toppings = toppings
def __len__(ਸਵੈ):
ਵਾਪਸੀ ਲੈਨ (self.toppings)
# ਆਓ ਇੱਕ ਪੀਜ਼ਾ ਬਣਾਈਏ
my_pizza = ਪੀਜ਼ਾ ('ਵੱਡਾ', ['ਪੇਪੇਰੋਨੀ', 'ਮਸ਼ਰੂਮ', 'ਜੈਤੂਨ'])
print(len(my_pizza)) # ਇਹ ਪ੍ਰਿੰਟ ਕਰੇਗਾ: 3
__len__ ਵਿਧੀ ਵਿੱਚ, ਅਸੀਂ ਸਿਰਫ ਸੂਚੀ ਦੀ ਲੰਬਾਈ ਵਾਪਸ ਕਰਦੇ ਹਾਂ toppings. ਹੁਣ, len(my_pizza) ਇਹ ਸਾਨੂੰ ਦੱਸੇਗਾ ਕਿ ਇਸ 'ਤੇ ਕਿੰਨੇ ਟੌਪਿੰਗ ਹਨ my_pizza.
ਇਹ ਡੰਡਰ ਵਿਧੀ ਵਸਤੂਆਂ ਨੂੰ ਦੁਹਰਾਉਣ ਯੋਗ ਹੋਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ, ਯਾਨੀ ਇਸਨੂੰ ਲੂਪ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।
ਅਜਿਹਾ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਵੀ ਚਾਹੀਦਾ ਹੈ defiਫੰਕਸ਼ਨ ਨੂੰ ਪੂਰਾ ਕਰੋ __next__, ਇਸ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ defiਉਸ ਵਿਹਾਰ ਨੂੰ ਨਿਸ਼ ਕਰੋ ਜਿਸ ਨੂੰ ਦੁਹਰਾਓ ਵਿੱਚ ਅਗਲਾ ਮੁੱਲ ਵਾਪਸ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ਇਸ ਨੂੰ ਘਟਨਾ 'ਤੇ ਦੁਹਰਾਉਣਯੋਗ ਸੰਕੇਤ ਵੀ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਕ੍ਰਮ ਵਿੱਚ ਕੋਈ ਹੋਰ ਤੱਤ ਨਹੀਂ ਹਨ। ਅਸੀਂ ਆਮ ਤੌਰ 'ਤੇ ਇੱਕ ਅਪਵਾਦ ਸੁੱਟ ਕੇ ਇਸਨੂੰ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ StopIteration.
ਸਾਡੇ ਪੀਜ਼ਾ ਉਦਾਹਰਨ ਲਈ, ਮੰਨ ਲਓ ਕਿ ਅਸੀਂ ਟੌਪਿੰਗਜ਼ ਨੂੰ ਦੁਹਰਾਉਣਾ ਚਾਹੁੰਦੇ ਹਾਂ। ਅਸੀਂ ਆਪਣੀ ਪੀਜ਼ਾ ਕਲਾਸ ਨੂੰ ਦੁਹਰਾਉਣ ਯੋਗ ਬਣਾ ਸਕਦੇ ਹਾਂ defiਇੱਕ ਢੰਗ ਹੈ __iter__:
ਕਲਾਸ ਪੀਜ਼ਾ:
def __init__(ਸਵੈ, ਆਕਾਰ, ਟੌਪਿੰਗਜ਼):
self.size = ਆਕਾਰ
self.toppings = toppings
def __iter__(ਸਵੈ):
self.n = 0
ਆਪਣੇ ਆਪ ਨੂੰ ਵਾਪਸ
def __ਅਗਲਾ__(ਸਵੈ):
ਜੇਕਰ self.n < len(self.toppings):
ਨਤੀਜਾ = self.toppings[self.n]
self.n += 1
ਵਾਪਸੀ ਦਾ ਨਤੀਜਾ
ਹੋਰ:
StopIteration ਵਧਾਓ
# ਆਓ ਇੱਕ ਪੀਜ਼ਾ ਬਣਾਈਏ
my_pizza = ਪੀਜ਼ਾ ('ਵੱਡਾ', ['ਪੇਪੇਰੋਨੀ', 'ਮਸ਼ਰੂਮ', 'ਜੈਤੂਨ'])
# ਅਤੇ ਹੁਣ ਆਓ ਇਸ ਨੂੰ ਦੁਹਰਾਈਏ
my_pizza ਵਿੱਚ ਟਾਪਿੰਗ ਲਈ:
ਪ੍ਰਿੰਟ (ਟੌਪਿੰਗ)
ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਲੂਪ ਕਾਲਾਂ ਲਈ __iter__, ਜੋ ਇੱਕ ਕਾਊਂਟਰ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ (self.n) ਅਤੇ ਪੀਜ਼ਾ ਆਬਜੈਕਟ ਆਪਣੇ ਆਪ ਵਾਪਸ ਕਰਦਾ ਹੈ (self).
ਫਿਰ, ਲੂਪ ਕਾਲਾਂ ਲਈ __next__ ਬਦਲੇ ਵਿੱਚ ਹਰ ਇੱਕ ਟੌਪਿੰਗ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ.
ਕਵਾਂਡੋ __next__ ਸਾਰੇ ਮਸਾਲੇ ਵਾਪਸ ਕਰ ਦਿੱਤੇ, StopIteration ਇਹ ਇੱਕ ਅਪਵਾਦ ਸੁੱਟਦਾ ਹੈ ਅਤੇ for ਲੂਪ ਹੁਣ ਜਾਣਦਾ ਹੈ ਕਿ ਇੱਥੇ ਕੋਈ ਹੋਰ ਟੌਪਿੰਗ ਨਹੀਂ ਹਨ ਅਤੇ ਇਸਲਈ ਦੁਹਰਾਓ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਰੱਦ ਕਰ ਦੇਵੇਗਾ।
Ercole Palmeri
ਐਪਲ ਵਿਜ਼ਨ ਪ੍ਰੋ ਕਮਰਸ਼ੀਅਲ ਵਿਊਅਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਓਫਥਲਮੋਪਲਾਸਟੀ ਓਪਰੇਸ਼ਨ ਕੈਟਾਨੀਆ ਪੌਲੀਕਲੀਨਿਕ ਵਿਖੇ ਕੀਤਾ ਗਿਆ ਸੀ...
ਰੰਗਾਂ ਰਾਹੀਂ ਵਧੀਆ ਮੋਟਰ ਹੁਨਰਾਂ ਦਾ ਵਿਕਾਸ ਕਰਨਾ ਬੱਚਿਆਂ ਨੂੰ ਲਿਖਣ ਵਰਗੇ ਹੋਰ ਗੁੰਝਲਦਾਰ ਹੁਨਰਾਂ ਲਈ ਤਿਆਰ ਕਰਦਾ ਹੈ। ਰੰਗ ਕਰਨ ਲਈ…
ਜਲ ਸੈਨਾ ਖੇਤਰ ਇੱਕ ਸੱਚੀ ਗਲੋਬਲ ਆਰਥਿਕ ਸ਼ਕਤੀ ਹੈ, ਜਿਸ ਨੇ 150 ਬਿਲੀਅਨ ਮਾਰਕੀਟ ਵੱਲ ਨੈਵੀਗੇਟ ਕੀਤਾ ਹੈ...
ਪਿਛਲੇ ਸੋਮਵਾਰ, ਫਾਈਨੈਂਸ਼ੀਅਲ ਟਾਈਮਜ਼ ਨੇ ਓਪਨਏਆਈ ਨਾਲ ਇੱਕ ਸੌਦੇ ਦਾ ਐਲਾਨ ਕੀਤਾ। FT ਆਪਣੀ ਵਿਸ਼ਵ ਪੱਧਰੀ ਪੱਤਰਕਾਰੀ ਨੂੰ ਲਾਇਸੰਸ ਦਿੰਦਾ ਹੈ...