ਪਾਇਥਨ ਇੱਟਰੇਟਰ

ਪਾਇਥਨ ਇੱਟਰੇਟਰ

ਇੱਕ ਇੱਟਰੇਟਰ ਇੱਕ ਆਬਜ਼ਦਾਰੀ ਹੈ, ਜਿਸ ਵਿੱਚ ਮੁੱਲਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਸੂਚਨਾ ਹੈ

ਇੱਕ ਇੱਟਰੇਟਰ ਇੱਕ ਇੱਟਰੇਬਲ ਆਬਜ਼ਦਾਰੀ ਹੈ, ਮਤਲਬ ਤੁਸੀਂ ਸਾਰੇ ਮੁੱਲਾਂ ਦੀ ਸ਼ਰੂਆਤ ਕਰ ਸਕਦੇ ਹੋ

ਤਕਨੀਕੀ ਰੂਪ ਵਿੱਚ, ਪਾਇਥਨ ਵਿੱਚ ਇੱਕ ਇੱਟਰੇਟਰ ਇੱਕ ਇੱਟਰੇਟਰ ਪ੍ਰੋਟੋਕੋਲ ਦਾ ਸਮਰਥਨ ਕਰਨ ਵਾਲਾ ਆਬਜ਼ਦਾਰੀ ਹੈ, ਜਿਸ ਵਿੱਚ ਮੱਥਦਾ ਹੈ __iter__() ਅਤੇ __next__()。

ਇੱਟਰੇਟਰ VS ਇੱਟਰੇਬਲ ਆਬਜ਼ਦਾਰੀ

ਸੂਚੀ, ਟੁਪੀ, ਅਤੇ ਦਸਤਾਵੇਜ਼ ਅਤੇ ਸਟਾਰ ਵੀ ਇੱਕ ਇੱਟਰੇਬਲ ਆਬਜ਼ਦਾਰੀ ਹਨ। ਇਹ ਇੱਟਰੇਬਲ ਕੰਟੇਨਰ ਹਨ, ਅਤੇ ਤੁਸੀਂ ਇਸ ਤੋਂ ਇੱਕ ਇੱਟਰੇਟਰ ਲੈ ਸਕਦੇ ਹੋ

ਸਾਰੇ ਇਹ ਆਬਜ਼ਦਾਰੀ ਇੱਕ ਇੱਟਰੇਟਰ ਲੈਣ ਲਈ ਇੱਕ ਮੱਥਦਾ ਹੈ iter() ਮੱਥਦਾ ਹੈ:

ਉਦਾਹਰਣ

ਇੱਕ ਟੁਪੀ ਦੇ ਮੁੱਲਾਂ ਦੀ ਸ਼ਰੂਆਤ ਕਰੋ ਅਤੇ ਹਰੇਕ ਮੁੱਲ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰੋ:

mytuple = ("apple", "banana", "cherry")
myit = iter(mytuple)
print(next(myit))
print(next(myit))
print(next(myit))

ਉਦਾਹਰਣ ਚਲਾਓ

ਸਟਰਿੰਗ ਵੀ ਇੱਕ ਇੱਟਰੇਬਲ ਆਬਜ਼ਦਾਰੀ ਹੈ, ਅਤੇ ਇੱਕ ਇੱਟਰੇਟਰ ਦੀ ਸ਼ਰੂਆਤ ਕਰ ਸਕਦੇ ਹਾਂ:

ਉਦਾਹਰਣ

ਸਟਰਿੰਗ ਵੀ ਇੱਕ ਇੱਟਰੇਬਲ ਆਬਜ਼ਦਾਰੀ ਹੈ, ਅਤੇ ਇੱਕ ਇੱਟਰੇਟਰ ਦੀ ਸ਼ਰੂਆਤ ਕਰ ਸਕਦੇ ਹਾਂ:

mystr = "banana"
myit = iter(mystr)
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))

ਉਦਾਹਰਣ ਚਲਾਓ

ਇੱਕ ਇੱਟਰੇਟਰ ਦੀ ਸ਼ਰੂਆਤ ਕਰੋ

ਅਸੀਂ ਇੱਕ for ਸਰਕੂਲ ਦੀ ਮਦਦ ਨਾਲ ਵੀ ਇੱਕ ਇੱਟਰੇਬਲ ਆਬਜ਼ਦਾਰੀ ਦੀ ਸ਼ਰੂਆਤ ਕਰ ਸਕਦੇ ਹਾਂ:

ਉਦਾਹਰਣ

ਇੱਕ ਟੁਪੀ ਵਿੱਚ ਮੁੱਲਾਂ ਦੀ ਸ਼ਰੂਆਤ ਕਰੋ:

mytuple = ("apple", "banana", "cherry")
for x in mytuple:
  print(x)

ਉਦਾਹਰਣ ਚਲਾਓ

ਉਦਾਹਰਣ

ਇੱਕ ਸਟਰਿੰਗ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਸ਼ਰੂਆਤ ਕਰੋ:

mystr = "banana"
for x in mystr:
  print(x)

ਉਦਾਹਰਣ ਚਲਾਓ

ਸੁਝਾਅ:for ਸਰਕੂਲ ਇੱਕ ਇੱਟਰੇਟਰ ਆਬਜ਼ਦਾਰੀ ਬਣਾਉਂਦਾ ਹੈ, ਅਤੇ ਹਰੇਕ ਸਰਕੂਲ ਚੱਕਰ ਵਿੱਚ ਇੱਕ ਮੁੱਢਲਾ ਫੰਕਸ਼ਨ ਚਲਾਉਂਦਾ ਹੈ next() ਮੱਥਦਾ ਹੈ。

ਇੱਕ ਇੱਟਰੇਟਰ ਬਣਾਉਣ

ਜੇਕਰ ਤੁਸੀਂ ਆਬਜ਼ਦਾਰੀ/ਵਰਗ ਨੂੰ ਇੱਕ ਇੱਟਰੇਟਰ ਦੇ ਰੂਪ ਵਿੱਚ ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਆਬਜ਼ਦਾਰੀ ਨੂੰ ਇੱਕ ਇੱਟਰੇਟਰ ਬਣਾਉਣ ਲਈ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ __iter__() ਅਤੇ __next__() ਮੱਥਦਾ ਹੈ。

ਜਿਵੇਂ ਤੁਸੀਂ ਪਾਇਥਨ ਵਰਗ/ਆਬਜ਼ਦਾਰੀ ਅਧਿਆਇ ਵਿੱਚ ਸਿੱਖੇ ਹੋਣ, ਸਾਰੇ ਵਰਗ ਨੂੰ ਇੱਕ ਨਾਮ ਹੈ __init__() ਫੰਕਸ਼ਨ, ਜੋ ਤੁਹਾਨੂੰ ਆਬਜ਼ਦਾਰੀ ਬਣਾਉਣ ਸਮੇਂ ਕੁਝ ਪ੍ਰਾਰੰਭਿਕ ਸੰਰਚਨਾ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ。

__iter__() ਮੰਥਨ ਵਿੱਚ ਵੀ ਤੁਸੀਂ ਕਾਰਜ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਤੁਹਾਨੂੰ ਸਿਰਜਣਾ ਵਿੱਚ ਅਗਲਾ ਪ੍ਰੋਜੈਕਟ ਵਾਪਸ ਦੇਣਾ ਹੋਵੇਗਾ, ਪਰ ਤੁਹਾਨੂੰ ਹਮੇਸ਼ਾ ਇਕਾਈ ਵਾਪਸ ਦੇਣ ਵਾਲਾ ਇਕਾਈ ਵਾਪਸ ਦੇਣਾ ਹੋਵੇਗਾ。

__next__() ਮੰਥਨ ਵਿੱਚ ਵੀ ਤੁਸੀਂ ਕਾਰਜ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਤੁਹਾਨੂੰ ਸਿਰਜਣਾ ਵਿੱਚ ਅਗਲਾ ਪ੍ਰੋਜੈਕਟ ਵਾਪਸ ਦੇਣਾ ਹੋਵੇਗਾ。

ਉਦਾਹਰਣ

ਇੱਕ ਸਿਰਜਣਾ ਕਰੋ ਜੋ ਨੰਬਰਾਂ ਨੂੰ ਵਾਪਸ ਦੇਣ ਵਾਲਾ ਇਕਾਈ ਹੋਵੇ, ਜੋ 1 ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ ਅਤੇ ਹਰੇਕ ਲਾਈਨ ਵਿੱਚ ਇਕਾਈ ਵਧਦੀ ਹੈ (ਵਾਪਸ 1, 2, 3, 4, 5 ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਹੀ ਹੁੰਦੇ ਹਨ):

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
  def __next__(self):
    x = self.a
    self.a += 1
    return x
myclass = MyNumbers()
myiter = iter(myclass)
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

ਉਦਾਹਰਣ ਚਲਾਓ

StopIteration

ਜੇਕਰ ਤੁਸੀਂ ਕਾਫੀ next() ਸਟੇਟਮੈਂਟ ਵਰਤ ਸਕਦੇ ਹਾਂ, ਜਾਂ for ਸਰਕਟ ਵਿੱਚ ਵਰਤ ਸਕਦੇ ਹਾਂ, ਤਾਕਿ ਉੱਪਰੋਕਤ ਉਦਾਹਰਣ ਹਮੇਸ਼ਾ ਚਲਦੇ ਰਹਿ ਸਕਣ।

ਇਕਾਈਆਂ ਨੂੰ ਹਮੇਸ਼ਾ ਚਲਾਉਣ ਵਾਲੇ ਇਕਾਈਆਂ ਤੋਂ ਬਚਣ ਲਈ ਅਸੀਂ StopIteration ਸਟੇਟਮੈਂਟ.

ਵਿੱਚ __next__() ਮੰਥਨ ਵਿੱਚ, ਜੇਕਰ ਇਕਾਈਆਂ ਦੀ ਸੰਖਿਆ ਨਿਰਧਾਰਿਤ ਕੀਤੀ ਗਈ ਹੈ ਤਾਂ ਅਸੀਂ ਇੱਕ ਸਤਰਹਣ ਕਰਨ ਦੀ ਸ਼ਰਤ ਜੋੜ ਸਕਦੇ ਹਾਂ ਅਤੇ ਗਲਤੀ ਉਤਪੰਨ ਕਰ ਸਕਦੇ ਹਾਂ:

ਉਦਾਹਰਣ

20 ਇਕਾਈਆਂ ਬਾਅਦ ਸਤਰਹਣਾ ਕਰੋ:

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration
myclass = MyNumbers()
myiter = iter(myclass)
for x in myiter:
  print(x)

ਉਦਾਹਰਣ ਚਲਾਓ