Demystifying Python Recursion

De mest komplekse oppgavene i Python kan brytes ned i enklere deltak. Rekursjon bidrar til å oppnå dette, og dermed gjør koden ren og pen. Denne opplæringen vil introdusere rekursjon, fordelene med rekursjon, og hvordan du bruker den i Python programmering.

Hva er rekursjon?

Rekursjon er en metode for å løse et problem med løsningene på mindre forekomster av det samme problemet. Denne tilnærmingen kan brukes på mange typer utfordringer i programmeringen.

Fordelene ved å bruke rekursjon

Noen av fordelene med å bruke rekursjon er:

• Rekursjon legger til enkelhet når du skriver kode, noe som gjør det enklere å feilsøke.
• Rekursjon reduserer hvor lang tid en algoritme tar for å løpe som en funksjon av lengden på inngangen.
• Rekursjon er også foretrukket når man løser svært komplekse problemer, spesielt problemer på trebaserte strukturer, fordi det fungerer bedre.

Introduksjon til Python rekursiv funksjon

Selv om rekursjon virker som en komplisert prosedyre, er det ikke så komplisert. På lekmannens vilkår, anta at du har to rektangler A og B. Hvis du legger dem sammen, danner de et rektangel C. Dette er i seg selv en rekursiv prosedyre. Vi har brukt mindre forekomster av et rektangel for å definere seg selv, og hvis vi skulle skrive en Python-funksjon, ville det være som følger:

def rektangel (a, b): return a + b 

Siden en rekursiv funksjon kaller seg, må det være en regel eller et bruddpunkt hvor prosessen eller sløyfen vil avslutte. En slik tilstand er kjent som en grunntilstand. En grunntilstand er et krav i hvert rekursivt program, ellers vil prosedyren føre til en uendelig sløyfe.

Det andre kravet er rekursiv sak når funksjonen kaller seg.

La oss se på et eksempel:

I dette eksemplet vil du skrive en faktorialfunksjon som tar et heltall (positivt) som en inngang. Faktoren til et tall er oppnådd ved å multiplisere tallet med alle positive heltall under det. For eksempel, faktorial (3) = 3 x 2 x 1, faktorial (2) = 2 x 1, og faktorial (0) = 1.

Det første du må gjøre er å definere vårt grunnleggende tilfelle, som vil være faktorial (0) = 1.

Som du kan se over, er det et forhold mellom hvert sammenhengende faktorscenario. Du bør legge merke til at factorial (4) = 4 x faktorial (3). Tilsvarende, faktorial (5) = 5 x faktorial (4).

Den andre delen vil skrive en funksjon som kaller seg.

Nå som vi har forenklet det, vil den resulterende funksjonen være:

def factorial (n): if (n == 0): #Define vårt grunnleggende tilfelle? returner 1 annet: returner n * faktorial (n-1) utskrift (faktorial (5)) #result # 120

Løsningen hvis n == 0 er:

def factorial (n): if (n == 0): #Define vårt grunnleggende tilfelle? returnere 1 annet: returner n * faktorial (n-1) utskrift (faktorial (0)) #result # 0

Nå som du vet hvordan du skriver rekursive funksjoner, la oss se på flere casestudier som vil styrke din forståelse av rekursjon.

Case Study 1: Fibonacci

I en Fibonacci-sekvens er hvert tall summen av de to foregående tallene, for eksempel: 1 + 1 = 2; 1 + 2 = 3; 2 + 3 = 5; 3 + 5 = 8. Fibonacci-sekvensen har blitt anvendt på mange områder, og det vanligste er å forutse prisaktjon på aksjemarkedet av forexhandlere.

Fibonacci-sekvensen starter med 0 og 1. Det første tallet i en Fibonacci-sekvens er 0, det andre tallet er 1, og det tredje uttrykket i sekvensen er 0 + 1 = 1. Den fjerde er 1 + 1 = 2 og så videre.

For å komme opp med en rekursiv funksjon, må du ha to basissaker, det vil si 0 og 1. Du kan da oversette tilleggsmønsteret i det andre tilfellet.

Den resulterende funksjonen vil være:

def fibonacci (n): if (n == 1): #define Basissak 1 retur 0 + 1 elif (n == 2): #define Basissak 1 retur 1 + 2 annet: returfibre (n) + fibonacci n-1) print (fibonacci (5)) #result # 

Case Study 2: Reversere en streng

I dette eksemplet vil du skrive en funksjon som tar en streng som input og deretter returnerer baksiden av strengen.

Det første du må gjøre er å definere vårt grunnleggende tilfelle, som vil kontrollere om strengen er lik 0, og i så fall returnerer strengen seg selv.

Det andre trinnet er å rekursivt kalle omvendt-funksjonen for å kutte delen av strengen utenom det første tegnet og deretter sammenkoble det første tegnet til slutten av den snittede strengen.

Den resulterende funksjonen er som vist nedenfor:

def omvendt (a): hvis len (a) == 0: returnere et annet: gå tilbake omvendt (a [1:]) + a [0] print (omvendt ("Python er et veldig enkelt språk å lære")) Resultat #nrael eller egaugnal ysae yrev a si nohtyP 

Case studie 3: Sum av elementer

I dette eksemplet skriver du en funksjon som tar en matrise som input og returnerer summen av elementene i listen.

Det første du må gjøre er å definere vårt grunnleggende tilfelle, som vil kontrollere om størrelsen på listen er null, og return 0 hvis True.

Det andre trinnet returnerer elementet og et anrop til funksjonssummen () minus ett element i listen.

Løsningen er som vist nedenfor:

def sum_of_numbers (l): hvis len (l) == 1: return 0 annet: retur l [0] + sum (l [1:]) a = [5,7,3,8,10] print a)) # resultat # 33

Løsningen for en tom liste er som vist nedenfor:

def sum_of_numbers (l): hvis len (l) == 1: return 0 annet: retur l [0] + sum (l [1:]) b = [] print (sum (b)) # resultat # 0

Konklusjon

Denne opplæringen har dekket det som er nødvendig for å bruke rekursjon for å løse komplekse programmer i Python. Det er også viktig å merke seg at rekursjon har sine egne begrensninger:

• Rekursjon tar mye stakkplass, noe som gjør det litt tregt å opprettholde programmet.
• Rekursjonsfunksjoner krever mer plass og tid til å utføre.

Husk, ikke nøl med å se hva vi har tilgjengelig for salg og for studier i Envato Market, og vær så snill å stille spørsmål og gi din verdifulle tilbakemelding ved å bruke feedet under.