Jassif Team Institution

Python Iterators

ஒரு மீள் செயல்படுத்தி என்பது எண்ணக்கூடிய எண்ணிக்கையிலான மதிப்புகளைக் கொண்ட ஒரு பொருள்.

ஒரு மீள் செயல்படுத்தி என்பது மீள் செயல்படுத்தக்கூடிய ஒரு பொருள், அதாவது நீங்கள் அனைத்து மதிப்புகளிலும் பயணிக்க முடியும்.

தொழில்நுட்ப ரீதியாக, பைத்தானில், ஒரு மீள் செயல்படுத்தி என்பது மீள் செயல்படுத்தி நெறிமுறையைச் செயல்படுத்தும் ஒரு பொருள், இது __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)

மேலும் எடுத்துக்காட்டுகள்

எடுத்துக்காட்டு

சதுர எண்களைத் திரும்பப் பெறும் மீள் செயல்படுத்தி:

class Squares:
  def __iter__(self):
    self.n = 1
    return self

  def __next__(self):
    if self.n <= 10:
      result = self.n ** 2
      self.n += 1
      return result
    else:
      raise StopIteration

squares = Squares()
for num in squares:
  print(num)

எடுத்துக்காட்டு

தனிப்பயன் மீள் செயல்படுத்தி எழுத்துக்களின் வரிசையுடன்:

class Alphabet:
  def __iter__(self):
    self.letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    self.index = 0
    return self

  def __next__(self):
    if self.index < len(self.letters):
      letter = self.letters[self.index]
      self.index += 1
      return letter
    else:
      raise StopIteration

alphabet = Alphabet()
for letter in alphabet:
  print(letter)

பயிற்சி