ప్యాథన్ ఇటెరేటర్

ప్యాథన్ ఇటెరేటర్

ఇటెరేటర్ అనేది విలువలను అక్కడక్కడ ఇటెరేట్ చేయగల ఒక ఆబ్జెక్ట్ అని అర్థం వస్తుంది.

ఇటెరేటర్ అనేది ఇటెరేబుల్ ఆబ్జెక్ట్ అని అర్థం వస్తుంది, అనగా మీరు అన్ని విలువలను ఇటెరేట్ చేయవచ్చు.

సాంకేతికంగా, ప్యాథన్లో, ఇటెరేటర్ ప్రొటోకాల్ను అమలు చేసే ఆబ్జెక్ట్లు ఇటెరేటర్లు. వాటిని ప్రతి విలువను ఇటెరేట్ చేయవచ్చు. __iter__() మరియు __next__()

ఉంది.

ఇటెరేటర్ ఉంటే ఇటెరేబుల్ ఆబ్జెక్ట్

జాబితా, ట్యూపల్, డిక్షనరీ మరియు సెట్లు అన్ని ఇటెరేబుల్ ఆబ్జెక్ట్లు. వాటిని నుండి ఇటెరేటర్లను పొందవచ్చు (ఇటెరేటర్). ఈ అన్ని ఆబ్జెక్ట్లు ఇటెరేటర్లను పొందడానికి ఉపయోగించే iter()

ఇన్స్టాన్స్

మాదిరి మంథ్రం

mytuple = ("apple", "banana", "cherry")
ట్యూపల్ నుండి ఒక ఇటెరేటర్ను తిరిగి ఇవ్వడం, మరియు ప్రతి విలువను ముద్రించడం
print(next(myit))
print(next(myit))
print(next(myit))

ఇన్స్టాన్స్ చలాచలం

myit = iter(mytuple)

ఇన్స్టాన్స్

స్ట్రింగ్లు కూడా ఇటెరేబుల్ ఆబ్జెక్ట్లు ఉన్నాయి, మరియు ఇటెరేటర్ను తిరిగి ఇవ్వవచ్చు

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:
  ప్రింట్(x)

ఇన్స్టాన్స్ చలాచలం

ఇన్స్టాన్స్

స్ట్రింగ్లో అక్షరాలను ఇటెరేట్ చేయడం

mystr = "banana"
for x in mystr:
  ప్రింట్(x)

ఇన్స్టాన్స్ చలాచలం

హిందూస్థాన్ పరామర్శfor సైకిల్ లో వాస్తవానికి ఒక ఇటెరేటర్ ఆబ్జెక్ట్ను సృష్టిస్తుంది మరియు ప్రతి సైకిల్ అమలుకు కొన్ని చర్యలను చేపట్టుతుంది మీరు తగినంత సమయం ఉన్నట్లయితే మాదిరి మంథ్రం ఉన్నాయి.

ఇటెరేటర్ సృష్టించడం

ఆబ్జెక్ట్/క్లాస్ను ఇటెరేటర్గా సృష్టించడానికి, ఆబ్జెక్ట్కు ఇటెరేటర్ అమలు చేయాలి __iter__() మరియు __next__() మాదిరి మంథ్రం ఉన్నాయి.

ప్యాథన్ క్లాస్/ఆబ్జెక్ట్ అధ్యాయంలో మీరు నేర్చుకున్నట్లుగా, అన్ని క్లాస్లు పేరు కలిగిన __init__() ఫంక్షన్ ఉంది, దీనిద్వారా మీరు ఆబ్జెక్ట్ను సృష్టించటంలో కొన్ని ప్రారంభంచర్యలను చేపట్టవచ్చు.

__iter__() 方法的作用相似，您可以执行操作（初始化等），但必须始终返回迭代器对象本身。

__next__() 方法也允许您执行操作，并且必须返回序列中的下一个项目。

ఇన్స్టాన్స్

创建一个返回数字的迭代器，从 1 开始，每个序列将增加 1（返回 1、2、3、4、5 等）：

క్లాస్ మైన్నంబర్స్:
  డెఫ్ __iter__(సెల్ఫ్):
    సెల్ఫ్.ఎ = 1
    రిటర్న్ సెల్ఫ్
  డెఫ్ __next__(సెల్ఫ్):
    x = సెల్ఫ్.ఎ
    సెల్ఫ్.ఎ = ఎ + 1
    రిటర్న్ క్స్
మైక్లాస్ = మైన్నంబర్స్()
మైఇటర్ = ఇటర్(మైక్లాస్)
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

ఇన్స్టాన్స్ చలాచలం

స్టాప్ ఐటరేషన్

ప్రింట్(నెక్స్ట్(మైఇటర్)) మీరు తగినంత సమయం ఉన్నట్లయితే నెక్స్ట్()

నిరంతరం అనుసరించే సంభావ్యతను నివారించడానికి, మనం స్టేట్మెంట్ ఉపయోగించవచ్చు లేదా for చక్రంలో ఉపయోగించవచ్చు, అప్పుడు పై ఉదాహరణ నిరంతరం అనుసరిస్తుంది. స్టాప్ ఐటరేషన్ స్టేట్మెంట్.

లో __next__() పద్ధతిలో, అనుసరించిన సంఖ్యలు పూర్తి అయినప్పుడు మేము ఒక తిరస్కరణ పరిస్థితిని ప్రారంభించవచ్చు:

ఇన్స్టాన్స్

20 సమితి తర్వాత ఆగిపోవడం కోసం:

క్లాస్ మైన్నంబర్స్:
  డెఫ్ __iter__(సెల్ఫ్):
    సెల్ఫ్.ఎ = 1
    రిటర్న్ సెల్ఫ్
  డెఫ్ __next__(సెల్ఫ్):
    ఇఫ్ సెల్ఫ్.ఎ లెస్ థాన్ 20:
      x = సెల్ఫ్.ఎ
      సెల్ఫ్.ఎ = ఎ + 1
      రిటర్న్ క్స్
    ఇల్స్:
      రేజ్ స్టాప్ ఐటరేషన్
మైక్లాస్ = మైన్నంబర్స్()
మైఇటర్ = ఇటర్(మైక్లాస్)
ఫర్ x ఇన్ మైఇటర్:
  ప్రింట్(x)

ఇన్స్టాన్స్ చలాచలం