పైథాన్లో రికర్షన్ గురించి మీరు తెలుసుకోవలసిన ప్రతిదీ

సరళమైన మాటలలో, పునరావృతం అనేది ఒక ఫంక్షన్ కాల్ ద్వారా సమస్యను పరిష్కరించే ఒక మార్గం, పదం “ పునరావృత ”లాటిన్ క్రియ నుండి ఉద్భవించింది“ పునరావృతం ”, అంటే ఏదో పునరావృతం చేయడం. పునరావృత ఫంక్షన్ ఇదే చేస్తుంది, ఇది అదే విషయాన్ని మళ్లీ మళ్లీ చేస్తుంది, అనగా అది తనను తాను గుర్తుచేసుకుంటుంది. ఈ వ్యాసంలో, పైథాన్‌లో పునరావృతం గురించి నేర్చుకుంటాము. ఈ బ్లాగులో పొందుపరచబడిన విషయాలు క్రిందివి:

• పైథాన్‌లో పునరావృతం అంటే ఏమిటి?
• ముగింపు పరిస్థితి
• పైథాన్ యొక్క పునరావృత పరిమితి
• పునరావృతంతో చదునైన జాబితాలు
• పునరావృత ప్రయోజనాలు
• పునరావృత యొక్క ప్రతికూలతలు

పైథాన్‌లో పునరావృతం అంటే ఏమిటి?

పునరావృతం అంటే తనను తాను పరంగా నిర్ణయించే ప్రక్రియ. పైథాన్లో, ఏదైనా ఫంక్షన్ ఏ ఇతర ఫంక్షన్‌ను అయినా పిలుస్తుందని మనకు తెలుసు, ఒక ఫంక్షన్ కూడా తనను తాను పిలుస్తుంది. నిర్దిష్ట షరతు నెరవేరే వరకు తనను తాను పిలిచే ఈ రకమైన ఫంక్షన్లను పునరావృత ఫంక్షన్లుగా పిలుస్తారు.

అది ఎలా పనిచేస్తుందో చూడటానికి కొన్ని ఉదాహరణలు తీసుకుందాం, మీకు సానుకూల పూర్ణాంకం ఇస్తే కారకమైనది.

• n! = n * (n-1) * (n-2) మరియు మొదలైనవి.
• 2! = 2 * (2-1)
• ఒకటి! = 1
• 0! = 0
• 4! = 4 * 3!
• 3! = 3 * 2!
• 2! = 2 * 1!

పై విలువలను భర్తీ చేయడం క్రింది వ్యక్తీకరణకు దారి తీస్తుంది

• 4! = 4 * 3 * 2 * 1

సానుకూల పూర్ణాంకం లేదా 0 ను దాని పరామితిగా తీసుకొని, n వ కారకాన్ని తిరిగి ఇచ్చే వాస్తవం (n) అని చెప్పడానికి ఒక ఫంక్షన్‌ను మనం నిర్వచించాలి, పునరావృత ఉపయోగించి దాన్ని ఎలా చేయగలం?

పునరావృతం ఉపయోగించి అలా చేద్దాం, మనం ఈ క్రింది సమీకరణాన్ని పరిశీలించాలి

• n! = n. (n-1). (n-2) & hellip3.2.1

• n! = n. (n-1)! # మేము ఈ పంక్తిలో ఉన్నట్లుగా పై స్టేట్‌మెంట్‌ను తిరిగి వ్రాయగలము

• ఇప్పుడు ఇక్కడ మనం 2 ను పారామితిగా పాస్ చేస్తే మనకు లభిస్తుంది:

  • 2! = 2.1! = 2

    జావాలో ఫైల్ను ఎలా ఉపయోగించాలి

• అదేవిధంగా, మేము 1 ఉత్తీర్ణత సాధిస్తే:

  • ఒకటి! = 1.0! = 1

• కానీ మనం 0 దాటితే అది విరిగిపోతుంది

  • 0! = 0. (- 1)! మరియు ఇక్కడ -1 కొరకు కారకమైనది నిర్వచించబడలేదు కాబట్టి ఇది విలువలు> 0 కోసం మాత్రమే పనిచేస్తుంది

• కాబట్టి మనం రెండు కేసులు రాయాలి

  • 1. n! = n. (n-1)! n> = 1 అయితే

  • 2. 1 ఉంటే n = 0

అన్ని సానుకూల పూర్ణాంకాలకు మరియు 0 కి ఇది పూర్తి పరిష్కారం.

ముగింపు పరిస్థితి

పునరావృత ఫంక్షన్ ముగించడానికి ఒక ముఖ్యమైన పరిస్థితిని నెరవేర్చాలి. తదుపరి పునరావృతం లేకుండా సమస్యను పరిష్కరించగల పరిస్థితి వైపు కదులుతున్నప్పుడు, పునరావృత ఫంక్షన్ ముగుస్తుంది, సమస్యను చిన్న ఉప-దశల్లోకి తగ్గిస్తుంది. కాల్స్‌లో రద్దు చేసే పరిస్థితి నెరవేరకపోతే పునరావృతం అనంతమైన లూప్‌లో ముగుస్తుంది.

కారకమైన పరిస్థితులు:

• n 1 కంటే ఎక్కువ ఉన్నంతవరకు n = n * (n-1) యొక్క కారకం.
• 1 ఉంటే n = 0

పై కారకమైన పరిస్థితులను పైథాన్ కోడ్‌లో మారుస్తాము:

def fact (n): if n == 1: return n else: return n * fact (n-1)

ఒక ఉదాహరణ తీసుకుందాం, మేము 4 యొక్క కారకాన్ని కనుగొనాలనుకుంటున్నాము:

వాస్తవం (4) # ఇది 4 * వాస్తవం (3) మరియు n == 1 వరకు తిరిగి వస్తుంది.

 అవుట్పుట్: 24

సరళత మరియు స్పష్టత కారణంగా ఇది పునరావృతానికి ఉదాహరణగా చాలా తరచుగా ఉపయోగించబడుతుంది. ప్రతి దశలో సమస్య యొక్క చిన్న సందర్భాలను పరిష్కరించడం కంప్యూటర్ సైన్స్లో పునరావృతం అని పిలుస్తారు.

పైథాన్ యొక్క పునరావృత పరిమితి

కొన్ని భాషలలో, మీరు అనంతమైన పునరావృత లూప్‌ను సృష్టించవచ్చు కాని, పైథాన్‌లో, పునరావృత పరిమితి ఉంది. పరిమితిని తనిఖీ చేయడానికి sys మాడ్యూల్ నుండి కింది ఫంక్షన్‌ను అమలు చేయండి. ఇది పైథాన్ కోసం పునరావృత సెట్ యొక్క పరిమితిని ఇస్తుంది.

జావాకు ఉత్తమమైన ఆలోచన ఏమిటి

దిగుమతి sys sys.getrecursionlimit ()

 అవుట్పుట్: 1000

మీ అవసరానికి అనుగుణంగా మీరు సిస్ మాడ్యూల్ యొక్క ఫంక్షన్‌ట్రెకర్షన్లిమిట్ () ను ఉపయోగించి పరిమితిని కూడా మార్చవచ్చు, ఇప్పుడు పరిమితిని దాటి, ఏమి జరుగుతుందో తనిఖీ చేసే వరకు పునరావృతంగా పిలిచే ఒక ఫంక్షన్‌ను సృష్టించండి:

def పునరావృత (): __name__ == '__main__' ఉంటే పునరావృత (): పునరావృత ()

మీరు పై కోడ్‌ను అమలు చేస్తే, మీకు రన్‌టైమ్ మినహాయింపు లభిస్తుంది: రన్‌టైమ్ లోపం: గరిష్ట పునరావృత లోతు మించిపోయింది. పైథాన్ ఎప్పటికీ అంతం కాని పునరావృత లూప్‌లో ముగిసే ఫంక్షన్‌ను సృష్టించకుండా నిరోధిస్తుంది.

పునరావృతంతో చదునైన జాబితాలు

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

డెఫ్ ఫ్లాట్ (a_list, ఫ్లాట్_లిస్ట్ = ఏదీ లేదు): ఫ్లాట్_లిస్ట్ ఏదీ లేకపోతే: ఫ్లాట్_లిస్ట్ = [] a_list లోని ఐటెమ్ కోసం: ఐసిన్‌స్టాన్స్ (ఐటెమ్, లిస్ట్) ఉంటే: ఫ్లాట్ (ఐటమ్, ఫ్లాట్_లిస్ట్) వేరే: ఫ్లాట్_లిస్ట్.అపెండ్ (ఐటమ్) ఫ్లాట్_లిస్ట్‌ను తిరిగి ఇస్తే __ పేరు == '__ మెయిన్__': గూడు = [1,2,3, [4,5], 6] x = చదును (సమూహ) ముద్రణ (x)

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

పై కోడ్‌ను అమలు చేస్తే మనం ఇన్‌పుట్‌గా ఉపయోగించిన పూర్ణాంక జాబితాను కలిగి ఉన్న పూర్ణాంక జాబితాకు బదులుగా ఒకే జాబితా వస్తుంది. మీరు ఇతర మార్గాలను ఉపయోగించి కూడా ఇదే పని చేయవచ్చు, పైథాన్‌లో itertools.chain () అని పిలుస్తారు, మీరు ఒక ఫంక్షన్ గొలుసును సృష్టించడానికి ఉపయోగించే కోడ్‌ను తనిఖీ చేయవచ్చు () ఇది మేము చేసిన విధంగానే వేరే విధానం.

పునరావృత ప్రయోజనాలు

• పునరావృత ఫంక్షన్‌లో కోడ్ శుభ్రంగా మరియు సొగసైనది.

• మిశ్రమ పనిని పునరావృతం ఉపయోగించి సరళమైన ఉప సమస్యలుగా విభజించవచ్చు.

• కొన్ని సమూహ పునరుక్తిని ఉపయోగించడం కంటే పునరావృతంతో క్రమాన్ని రూపొందించడం సులభం.

పునరావృత యొక్క ప్రతికూలతలు

• పునరావృత ఫంక్షన్ వెనుక ఉన్న తర్కాన్ని అనుసరించడం కొన్నిసార్లు కష్టం.

• పునరావృత కాల్‌లు ఖరీదైనవి (అసమర్థమైనవి) ఎందుకంటే అవి చాలా మెమరీ మరియు సమయాన్ని తీసుకుంటాయి.

• పునరావృత ఫంక్షన్లు డీబగ్ చేయడం కష్టం.

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