పైథాన్‌లో జనరేటర్లు అంటే ఏమిటి మరియు వాటిని ఎలా ఉపయోగించాలి?

ప్రయోజనాలతో పాటు పైథాన్‌లో జనరేటర్లు ఏమిటో తెలుసుకోండి. వివిధ వినియోగ కేసులతో పాటు వాటిని ఎలా సృష్టించాలో మరియు ఎలా ఉపయోగించాలో కూడా తెలుసుకోండి.

పునరావృత్తులు లేదా వాటిపై అడుగు పెట్టడానికి అనుమతించే వస్తువులను ఉత్పత్తి చేయడం భారమైన పనిగా పరిగణించబడుతుంది. కానీ, లో , ఈ బాధాకరమైన పని అమలు నిజంగా సున్నితంగా ఉంటుంది. కాబట్టి పైథాన్లోని జనరేటర్లను దగ్గరగా చూద్దాం.

ఈ వ్యాసంలో ఉన్న అన్ని అంశాల జాబితా ఇక్కడ ఉంది:





కాబట్టి ప్రారంభిద్దాం. :)

పైథాన్‌లో జనరేటర్లు ఏమిటి?

జనరేటర్లు ప్రాథమికంగా ప్రయాణించదగిన వస్తువులు లేదా వస్తువులను తిరిగి ఇచ్చే విధులు. ఈ ఫంక్షన్లు అన్ని వస్తువులను ఒకేసారి ఉత్పత్తి చేయవు, బదులుగా అవి వాటిని ఒకేసారి ఉత్పత్తి చేస్తాయి మరియు అవసరమైనప్పుడు మాత్రమే. ఎప్పుడు అంశాల సమితిపై మళ్ళించడానికి చేర్చబడింది, జెనరేటర్ ఫంక్షన్ అమలు అవుతుంది. జనరేటర్లకు అనేక ప్రయోజనాలు ఉన్నాయి.



జనరేటర్లను ఉపయోగించడం వల్ల కలిగే ప్రయోజనాలు

  • పైథాన్‌లో జనరేటర్లు లేకుండా, ఇటరబుల్స్ ఉత్పత్తి చేయడం చాలా కష్టం మరియు సుదీర్ఘమైనది.

  • జనరేటర్లు స్వయంచాలకంగా __iter __ (), __ తదుపరి __ () మరియు స్టాప్ఇట్రేషన్‌ను అమలు చేస్తున్నందున అమలు చేయడం సులభం, లేకపోతే, స్పష్టంగా పేర్కొనాలి.



  • అంశాలు మామూలు మాదిరిగా కాకుండా అవసరమైనప్పుడు ఉత్పత్తి చేయబడినందున మెమరీ సేవ్ అవుతుంది . మీరు భారీ సంఖ్యలో ఇటరేటర్లను సృష్టించాల్సిన అవసరం వచ్చినప్పుడు ఈ వాస్తవం చాలా ముఖ్యమైనది. ఇది జనరేటర్ల యొక్క అతిపెద్ద ప్రయోజనంగా కూడా పరిగణించబడుతుంది.

  • అనంతమైన వస్తువులను ఉత్పత్తి చేయడానికి ఉపయోగించవచ్చు.

  • అనేక కార్యకలాపాలను పైప్‌లైన్ చేయడానికి కూడా వీటిని ఉపయోగించవచ్చు

సాధారణ విధులు vs జనరేటర్ విధులు:

పట్టికలో డేటాను ఎలా కలపాలి

పైథాన్‌లోని జనరేటర్లు మీరు ఎలా సృష్టించారో అదే విధంగా సృష్టించబడతాయి ‘డెఫ్’ కీవర్డ్ ఉపయోగించి. కానీ, జనరేటర్ ఫంక్షన్లు తిరిగి వచ్చే బదులు దిగుబడి కీవర్డ్‌ని ఉపయోగించుకుంటాయి. ఇది ఇటరేటర్ అని వ్యాఖ్యాతకు తెలియజేయడానికి ఇది జరుగుతుంది. ఇది మాత్రమే కాదు, జనరేటర్ ఫంక్షన్లు తరువాతి () ఫంక్షన్ అని పిలువబడినప్పుడు నడుస్తాయి మరియు సాధారణ ఫంక్షన్ల విషయంలో వారి పేరుతో కాదు. దీన్ని బాగా అర్థం చేసుకోవడానికి క్రింది ఉదాహరణను పరిశీలించండి:

ఉదాహరణ:

def func (a): a = [1,2,3] b = func (a) next (b)

అవుట్పుట్: [1, 2, 3]

మీరు చూడగలిగినట్లుగా, పై అవుట్‌పుట్‌లో, ఫంక్ () దిగుబడి కీవర్డ్‌ని మరియు దాని అమలు కోసం తదుపరి ఫంక్షన్‌ను ఉపయోగిస్తోంది. కానీ, సాధారణ ఫంక్షన్ కోసం మీకు ఈ క్రింది కోడ్ అవసరం:

ఉదాహరణ:

def func (a): a = [1,2,3] func (a) ను తిరిగి ఇవ్వండి

అవుట్పుట్: [1, 2, 3]

మీరు పై ఉదాహరణను పరిశీలిస్తే, సాధారణ ఫంక్షన్ కూడా అదే అవుట్‌పుట్‌ను తిరిగి ఇస్తున్నప్పుడు జెనరేటర్ ఫంక్షన్‌ను ఎందుకు ఉపయోగించాలో మీరు ఆలోచిస్తూ ఉండవచ్చు. కాబట్టి పైథాన్‌లో జనరేటర్లను ఎలా ఉపయోగించాలో చూద్దాం.

జనరేటర్ విధులను ఉపయోగించడం:

ముందే చెప్పినట్లుగా, పైథాన్‌లోని జనరేటర్లు ఒకేసారి పునరుత్పాదక శక్తిని ఉత్పత్తి చేస్తాయి. కింది ఉదాహరణను చూడండి:

ఉదాహరణ:

def myfunc (a): a> = 3: a = a + 1 b = myfunc (a) print (b) next (b)

మీరు ఈ క్రింది ఫంక్షన్‌ను అమలు చేసినప్పుడు, మీరు ఈ క్రింది అవుట్‌పుట్‌ను చూస్తారు:

అవుట్పుట్: 4

ఇక్కడ, ఒక స్థితిని సంతృప్తిపరిచే ఒక వస్తువు తిరిగి ఇవ్వబడింది. అమలు చేసిన తరువాత, నియంత్రణ కాలర్‌కు బదిలీ చేయబడుతుంది. ఒకవేళ మరిన్ని అంశాలు అవసరమైతే, తరువాతి () ఫంక్షన్‌కు కాల్ చేయడం ద్వారా అదే ఫంక్షన్‌ను మళ్లీ అమలు చేయాలి.

తదుపరి (బి)

అవుట్పుట్: 5

తదుపరి అమలులో, ఫంక్షన్ 6,7, మొదలైనవి ఇస్తుంది. పైథాన్‌లోని జనరేటర్ ఫంక్షన్లు __iter __ () మరియు __ తదుపరి __ () పద్ధతులను స్వయంచాలకంగా అమలు చేస్తాయి. అందువల్ల, మీరు తదుపరి () పద్ధతిని ఉపయోగించడం ద్వారా వస్తువులపై మళ్ళించవచ్చు. అంశం ఉత్పత్తి ఆగిపోయినప్పుడు, జనరేటర్ విధులు అమలు చేస్తాయి స్టాప్ఇట్రేషన్ కాలర్‌ను చింతించకుండా అంతర్గతంగా. దీనికి మరొక ఉదాహరణ ఇక్కడ ఉంది:

ఉదాహరణ:

a = 2 def myfunc (a): a> = 0: a - = 1 b = myfunc (a) print (b) next (b)

అవుట్పుట్:

నిస్సార కాపీ vs డీప్ కాపీ జావా

పైథాన్-ఎడురేకాలో స్టాప్ఇటరేషన్-జనరేటర్లుపై చిత్రం మా ప్రోగ్రామ్ యొక్క ఎన్నిసార్లు అమలు చేయాలో చూపిస్తుంది. మీరు తదుపరి ఫంక్షన్‌ను మళ్లీ కాల్ చేయడానికి ప్రయత్నిస్తే, అది వర్ణించే సందేశాన్ని అందిస్తుంది స్టాప్ఇట్రేషన్ అమలు చేయబడింది. మీరు దీన్ని సాధారణ ఫంక్షన్లతో చేయడానికి ప్రయత్నిస్తే, తిరిగి వచ్చిన విలువలు మారవు లేదా మళ్ళించవు. దిగువ ఉదాహరణను చూడండి:

ఉదాహరణ:

def z (): n = 1 దిగుబడి n n = n + 3 దిగుబడి n p = z () తదుపరి (p)

అవుట్పుట్:

ఉచ్చులు కలిగిన జనరేటర్లు:

మీరు ఒకే ఫంక్షన్‌ను ఒకేసారి అమలు చేయాలనుకుంటే, మీరు ‘ఫర్’ లూప్‌ను ఉపయోగించుకోవచ్చు. ఈ లూప్ వస్తువులపై మళ్ళించటానికి సహాయపడుతుంది మరియు అన్ని అమలుల తరువాత అది స్టాప్ఇట్రేషన్‌ను అమలు చేస్తుంది.

ఉదాహరణ:

def z (): n = 1 దిగుబడి n (n + 3 దిగుబడి n లో x కోసం z (): ప్రింట్ (x)

అవుట్పుట్:

ఒకటి
4

పునరుత్పాదక వస్తువులను ఉత్పత్తి చేయడానికి మీరు వ్యక్తీకరణలను కూడా పేర్కొనవచ్చు.

జనరేటర్ వ్యక్తీకరణలు:

ఇరేటర్లను ఉత్పత్తి చేయడానికి మీరు ఫర్ లూప్‌తో పాటు వ్యక్తీకరణలను కూడా ఉపయోగించవచ్చు. ఇది సాధారణంగా తరం పునరావృతాలను చాలా సులభం చేస్తుంది. జనరేటర్ వ్యక్తీకరణ జాబితా గ్రహణాలను పోలి ఉంటుంది లాంబ్డా విధులు , జనరేటర్ వ్యక్తీకరణలు అనామక జనరేటర్ ఫంక్షన్లను సృష్టిస్తాయి.

దిగువ ఉదాహరణను చూడండి:

ఉదాహరణ:

a = పరిధి (6) ముద్రణ ('జాబితా కాంప్రహెన్షన్', ముగింపు = ':') b = [x కోసం x కోసం x] ప్రింట్ (బి) ముద్రణ ('జనరేటర్ వ్యక్తీకరణ', ముగింపు = ': n') సి = (a లో x కోసం x + 2) c లో y కోసం ప్రింట్ (సి): ప్రింట్ (y)

అవుట్పుట్:

జాబితా కాంప్రహెన్షన్: [2, 3, 4, 5, 6, 7]

జనరేటర్ వ్యక్తీకరణ:

2
3
4
5
6

మీరు చూడగలిగినట్లుగా, పై అవుట్‌పుట్‌లో, మొదటి వ్యక్తీకరణ జాబితా గ్రహణశక్తి, ఇది [] బ్రాకెట్లలో పేర్కొనబడింది. జాబితా కాంప్రహెన్షన్ ఒకేసారి అంశాల పూర్తి జాబితాను ఉత్పత్తి చేస్తుంది. తరువాతి జనరేటర్ వ్యక్తీకరణ, ఇది ఒకే వస్తువులను తిరిగి ఇస్తుంది, కానీ ఒక సమయంలో ఒకటి. ఇది () బ్రాకెట్లను ఉపయోగించి పేర్కొనబడింది.


జనరేటర్ఫంక్షన్లను ఇతర ఫంక్షన్లలో కూడా ఉపయోగించవచ్చు.ఉదాహరణకి:

ఉదాహరణ:

a = పరిధి (6) ముద్రణ ('జనరేటర్ వ్యక్తీకరణ', ముగింపు = ': n') c = (a లో x కోసం x + 2) ముద్రణ (సి) ముద్రణ (నిమి (సి))

అవుట్పుట్:

జనరేటర్ వ్యక్తీకరణ
2

పై ప్రోగ్రామ్ a యొక్క విలువలకు వర్తించినప్పుడు పై ప్రోగ్రామ్ min విలువను ప్రింట్ చేస్తుంది.

కేసులు వాడండి:

లో జనరేటర్లను ఉపయోగిద్దాం నుండి:

  • ఫైబొనాక్సీ సిరీస్‌ను రూపొందించండి
  • సంఖ్యలను ఉత్పత్తి చేస్తోంది

ఫైబొనాక్సీ సిరీస్‌ను ఉత్పత్తి చేస్తోంది:

ఫైబొనాక్సీ సిరీస్ మనందరికీ తెలిసిన సంఖ్యల శ్రేణి, ఇందులో ప్రతి సంఖ్య రెండు సంఖ్యల ముందు మొత్తం. మొదటి రెండు సంఖ్యలు 0 మరియు 1. ఫైబొనాక్సీ సిరీస్‌ను రూపొందించడానికి జెనరేటర్ ప్రోగ్రామ్ ఇక్కడ ఉంది:

ఉదాహరణ:

def fibo (): మొదటిది, రెండవది = 0,1 అయితే నిజం: మొదటిది మొదటిది, రెండవది = రెండవది, మొదటి + రెండవది x లో ఫైబో (): ఉంటే x> 50: బ్రేక్ ప్రింట్ (x, ముగింపు = '')

అవుట్పుట్:

0 1 1 2 3 5 8 13 21 34

పై అవుట్పుట్ 50 కంటే తక్కువ విలువలతో ఫైబొనాక్సీ సిరీస్‌ను చూపుతుంది. ఇప్పుడు సంఖ్యల జాబితాను ఎలా ఉత్పత్తి చేయాలో చూద్దాం.

సంఖ్యలను ఉత్పత్తి చేయడం:

మీరు పేర్కొన్న జాబితా సంఖ్యలను ఉత్పత్తి చేయాలనుకుంటే, మీరు జనరేటర్ ఫంక్షన్లను ఉపయోగించి చేయవచ్చు. కింది ఉదాహరణను చూడండి:

ఉదాహరణ:

a = పరిధి (10) బి = (ఎలో x కోసం x) ప్రింట్ (బి) y లో బి: ప్రింట్ (వై)

అవుట్పుట్:

0
ఒకటి
2
3
4
5
6
7
8
9

జావా క్లాస్‌పాత్‌ను ఎలా సెట్ చేయాలి

ఉదాహరణ:

a = పరిధి (2,10,2) బి = (ఎలో x కోసం x) ప్రింట్ (బి) y లో బి: ప్రింట్ (వై)

అవుట్పుట్:


2
4
6
8

పై ప్రోగ్రామ్ 2 నుండి 10 వరకు సంఖ్యలను కూడా తిరిగి ఇచ్చింది. ఇది పైథాన్లోని జనరేటర్లపై ఈ వ్యాసం చివరకి తీసుకువస్తుంది. మీరు అన్ని విషయాలను అర్థం చేసుకున్నారని నేను ఆశిస్తున్నాను.

మీరు వీలైనంత వరకు ప్రాక్టీస్ చేశారని నిర్ధారించుకోండి మరియు మీ అనుభవాన్ని తిరిగి పొందండి.

మాకు ప్రశ్న ఉందా? దయచేసి ఈ “పైథాన్‌లో జనరేటర్లు” బ్లాగులోని వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.

పైథాన్‌తో పాటు దాని వివిధ అనువర్తనాలతో లోతైన జ్ఞానం పొందడానికి, మీరు ప్రత్యక్ష ప్రసారం కోసం నమోదు చేసుకోవచ్చు 24/7 మద్దతు మరియు జీవితకాల ప్రాప్యతతో.