பைத்தானில் மறுநிகழ்வு பற்றி நீங்கள் தெரிந்து கொள்ள வேண்டிய அனைத்தும்

எளிமையான சொற்களில், மறுநிகழ்வு என்பது ஒரு செயல்பாட்டைத் தானே அழைப்பதன் மூலம் சிக்கலைத் தீர்ப்பதற்கான ஒரு வழியாகும், “ சுழல்நிலை ”லத்தீன் வினைச்சொல்லிலிருந்து உருவானது“ மீண்டும் ”, எதையாவது மீண்டும் செய்வதாகும். இதுதான் சுழல்நிலை செயல்பாடு செய்கிறது, இது மீண்டும் மீண்டும் அதே விஷயத்தை மீண்டும் செய்கிறது, அதாவது அது தன்னை நினைவுபடுத்துகிறது. இந்த கட்டுரையில், பைத்தானில் மறுநிகழ்வு பற்றி அறிந்து கொள்வோம். இந்த வலைப்பதிவில் உள்ளடக்கப்பட்ட தலைப்புகள் பின்வருமாறு:

• பைத்தானில் மறுநிகழ்வு என்றால் என்ன?
• முடித்தல் நிலை
• பைத்தானின் மறுநிகழ்வு வரம்பு
• மறுநிகழ்வுடன் தட்டையான பட்டியல்கள்
• மறுநிகழ்வின் நன்மைகள்
• மறுநிகழ்வின் தீமைகள்

பைத்தானில் மறுநிகழ்வு என்றால் என்ன?

மறுநிகழ்வு என்பது தன்னைத்தானே தீர்மானிக்கும் செயல்முறையாகும். பைத்தானில், எந்தவொரு செயல்பாடும் வேறு எந்த செயல்பாட்டையும் அழைக்க முடியும் என்பதை நாம் அறிவோம், ஒரு செயல்பாடு தன்னை அழைக்கலாம். குறிப்பிட்ட நிபந்தனை பூர்த்தி செய்யப்படாத வரை தன்னை அழைக்கும் இந்த வகையான செயல்பாடுகள் சுழல்நிலை செயல்பாடுகள் என அழைக்கப்படுகின்றன.

அது எவ்வாறு இயங்குகிறது என்பதைப் பார்க்க சில எடுத்துக்காட்டுகளை எடுத்துக்கொள்வோம், உங்களுக்கு ஒரு நேர்மறையான முழு எண் வழங்கப்பட்டால், காரணியாலானது.

• 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-1)! n> = 1 என்றால்

  • 2. 1 என்றால் n = 0

இது அனைத்து நேர்மறை முழு எண் மற்றும் 0 க்கான முழுமையான தீர்வாகும்.

முடித்தல் நிலை

ஒரு சுழல்நிலை செயல்பாடு நிறுத்த ஒரு முக்கியமான நிபந்தனையை பூர்த்தி செய்ய வேண்டும். மேலும் மறுநிகழ்வு இல்லாமல் சிக்கலைத் தீர்க்கக்கூடிய ஒரு நிலையை நோக்கி நகரும்போது, ​​ஒரு சுழல்நிலை செயல்பாடு நிறுத்தப்படும், இது சிக்கலை சிறிய துணை-படிகளாகக் குறைக்கும். அழைப்புகளில் முடிவின் நிலை பூர்த்தி செய்யப்படாவிட்டால், மறுநிகழ்வு எல்லையற்ற சுழற்சியில் முடிவடையும்.

காரணி நிலைமைகள்:

• n 1 ஐ விட அதிகமாக இருக்கும் வரை n = n * (n-1) இன் காரணியாலானது.
• 1 என்றால் n = 0

மேலே உள்ள காரணியாலான நிலைமைகளை பைதான் குறியீட்டில் மாற்றுவோம்:

def உண்மை (n): என்றால் n == 1: திரும்ப n வேறு: திரும்ப n * உண்மை (n-1)

ஒரு எடுத்துக்காட்டை எடுத்துக்கொள்வோம், 4 இன் காரணிகளைக் கண்டுபிடிக்க விரும்புகிறோம் என்று கூறுங்கள்:

உண்மை (4) # இது 4 * உண்மை (3) மற்றும் n == 1 வரை திரும்பும்.

 வெளியீடு: 24

எளிமை மற்றும் தெளிவு காரணமாக இது மறுநிகழ்வுக்கான உதாரணமாக அடிக்கடி பயன்படுத்தப்படுகிறது. ஒவ்வொரு கட்டத்திலும் ஒரு சிக்கலின் சிறிய நிகழ்வுகளைத் தீர்ப்பது கணினி அறிவியலில் மறுநிகழ்வு என்று அழைக்கப்படுகிறது.

பைத்தானின் மறுநிகழ்வு வரம்பு

சில மொழிகளில், நீங்கள் எல்லையற்ற சுழல்நிலை சுழற்சியை உருவாக்கலாம், ஆனால், பைத்தானில், மறுநிகழ்வு வரம்பு உள்ளது. வரம்பை சரிபார்க்க பின்வரும் செயல்பாட்டை sys தொகுதியிலிருந்து இயக்கவும். இது மலைப்பாம்பிற்கான மறுநிகழ்வு தொகுப்பின் வரம்பைக் கொடுக்கும்.

ஒரு jframe செய்வது எப்படி

இறக்குமதி sys sys.getrecursionlimit ()

 வெளியீடு: 1000

உங்கள் தேவைக்கேற்ப சிஸ் தொகுதியின் செயல்பாடுகளைப் பயன்படுத்தி வரம்பை மாற்றலாம், இப்போது வரம்பை மீறி என்ன நடக்கிறது என்பதைச் சரிபார்க்கும் வரை மீண்டும் மீண்டும் தன்னை அழைக்கும் ஒரு செயல்பாட்டை உருவாக்குவோம்:

def recursive (): __name__ == '__main__' என்றால் சுழல்நிலை (): சுழல்நிலை ()

மேலே உள்ள குறியீட்டை நீங்கள் இயக்கினால், நீங்கள் இயக்க நேர விதிவிலக்கு பெறுவீர்கள்: இயக்கநேர பிழை: அதிகபட்ச மறுநிகழ்வு ஆழம் மீறியது. ஒருபோதும் முடிவடையாத சுழல்நிலை சுழற்சியில் முடிவடையும் ஒரு செயல்பாட்டை உருவாக்குவதிலிருந்து பைதான் உங்களைத் தடுக்கிறது.

மறுநிகழ்வுடன் தட்டையான பட்டியல்கள்

காரணிகளைத் தவிர்த்து மறுநிகழ்வைப் பயன்படுத்தி நீங்கள் செய்யக்கூடிய பிற விஷயங்கள், உள்ளமைக்கப்பட்ட பட்டியலிலிருந்து ஒற்றை ஒன்றை உருவாக்க விரும்புகிறீர்கள் என்று சொல்லலாம், கீழேயுள்ள குறியீட்டைப் பயன்படுத்தி இதைச் செய்யலாம்:

def flatten (a_list, flat_list = none): flat_list எதுவும் இல்லை என்றால்: a_list இல் உள்ள உருப்படிக்கு flat_list = []: isinstance என்றால் (உருப்படி, பட்டியல்): தட்டையானது (உருப்படி, தட்டையான_ பட்டியல்) வேறு: flat_list.append (உருப்படி) தட்டையான_ பட்டியலை __name__ == '__main__': உள்ளமை = [1,2,3, [4,5], 6] x = தட்டையானது (உள்ளமை) அச்சு (x)

 வெளியீடு: [1,2,3,4,5,6]

மேலே உள்ள குறியீட்டை இயக்குவதால், நாம் உள்ளீடாகப் பயன்படுத்திய முழு எண் பட்டியலைக் கொண்ட முழு பட்டியலுக்குப் பதிலாக ஒற்றை பட்டியலில் விளைகிறது. மற்ற வழிகளையும் பயன்படுத்தி நீங்கள் இதைச் செய்யலாம், பைத்தானுக்கு itertools.chain () என்று ஒன்று உள்ளது, நீங்கள் ஒரு செயல்பாட்டுச் சங்கிலியை உருவாக்கப் பயன்படும் குறியீட்டைச் சரிபார்க்கலாம் () நாங்கள் செய்ததைப் போலவே இதைச் செய்வது வேறுபட்ட அணுகுமுறையாகும்.

மறுநிகழ்வின் நன்மைகள்

• குறியீடு ஒரு சுழல்நிலை செயல்பாட்டில் சுத்தமாகவும் நேர்த்தியாகவும் இருக்கும்.

• ஒரு கூட்டு பணியை மறுநிகழ்வைப் பயன்படுத்தி எளிமையான துணை சிக்கல்களாக உடைக்கலாம்.

• சில உள்ளமைக்கப்பட்ட மறு செய்கையைப் பயன்படுத்துவதை விட மறுநிகழ்வுடன் வரிசையை உருவாக்குவது எளிதானது.

மறுநிகழ்வின் தீமைகள்

• சுழல்நிலை செயல்பாட்டின் பின்னால் உள்ள தர்க்கத்தைப் பின்பற்றுவது சில நேரங்களில் கடினமாக இருக்கலாம்.

• சுழல்நிலை அழைப்புகள் விலை உயர்ந்தவை (திறமையற்றவை) ஏனெனில் அவை நிறைய நினைவகத்தையும் நேரத்தையும் எடுத்துக்கொள்கின்றன.

• சுழல்நிலை செயல்பாடுகள் பிழைத்திருத்தம் செய்வது கடினம்.

இந்த கட்டுரையில் மறுநிகழ்வு என்றால் என்ன, சிக்கல் அறிக்கையிலிருந்து சுழல்நிலை செயல்பாடுகளை எவ்வாறு உருவாக்கலாம், கணித ரீதியாக ஒரு சிக்கல் அறிக்கையை எவ்வாறு வரையறுக்க முடியும் என்பதைக் கண்டோம். காரணியாலின் சிக்கலை நாங்கள் தீர்த்துக் கொண்டோம், மேலும் காரணிகளைக் கண்டுபிடிப்பதற்குத் தேவையான நிபந்தனைகளைக் கண்டறிந்தோம், அந்த நிலைமைகளை பைதான் குறியீடாக மாற்ற முடிந்தது, மறுநிகழ்வு எவ்வாறு செயல்படுகிறது என்பதைப் புரிந்துகொள்கிறது. டெவலப்பர்கள் மோசமாக கட்டமைக்கப்பட்ட சுழல்நிலை செயல்பாடுகளை உருவாக்குவதைத் தடுக்க பைத்தானுக்கு மறுநிகழ்வுக்கான உள்ளமைக்கப்பட்ட வரம்பு உள்ளது என்பது சுத்தமாக இருக்கிறது என்று நினைக்கிறேன். கவனிக்க வேண்டிய ஒரு முக்கியமான விஷயம் என்னவென்றால், செயல்பாடு தன்னை அழைத்துக் கொண்டே இருப்பதால் மறுநிகழ்வு பிழைத்திருத்தம் செய்வது கடினம்.