Python brugerdefinerede funktioner | Et overblik

I denne tutorial vil vi diskutere, hvordan man bruger Python brugerdefinerede funktioner , og hvordan man opretter dem. Brugerdefinerede funktioner kan hjælpe dig med at opdele store programmer i små dele for at gøre dem nemmere at fejlfinde, vedligeholde og forstå.

Brugerdefinerede funktioner er også gode til at gemme gentagne koder i et program. Vi kan udføre den kode ved at kalde funktionen, når det er nødvendigt. 

Lad os begynde at udforske, bygge og øve os i, hvordan man laver brugerdefinerede funktioner ved at oprette en ny notesbog. For at gøre det skal du klikke på menuen Filer og derefter holde musen på og vælge Python 3 .

Efter at have oprettet en ny notesbog, vil vi starte med at trykke ESC + B et par gange for at tilføje flere kodeceller . 

Lad os tilføje en dokumentstreng for at give en kort note om, hvad vi laver. For at gøre dette er det vigtigt at bruge tegnet " # " i begyndelsen. Skriv derefter noten lige efter " # " tegnet. 

Indholdsfortegnelse

• Struktur af brugerdefinerede funktioner i Python
• Tilføjelse af argumenter i Python brugerdefinerede funktioner
• Ændring af funktioner i Python
• Betingede erklæringer i Python
• Kaldende funktioner i variabler
• Konklusion

Struktur af brugerdefinerede funktioner i Python

For at oprette brugerdefinerede funktioner i Python, bør vi følge dens standardstruktur. Først skal vi tilføje def for at definere funktionen. Derefter tilføjer vi funktionsnavnet . Til sidst tilføjer du åbne og lukke parenteser for at lukke funktionen.

Bemærk, at vi også kan tilføje argumenter inden for parentesen, men indtil videre vil vi bare lade det stå tomt. Efter at have lukket funktionen, kan vi tilføje et kolon til sidst.

Dette er for at sikre, at de instruktioner, vi vil erklære, er tilføjet i den funktion, vi opretter.

Efter at have oprettet funktionen, lad os tilføje en instruktion, som vil blive udført senere, når vi kalder denne funktion. For dette eksempel, lad os udskrive ordet " hej ".

Når du tilføjer instruktionen, skal du klikke på Enter for at gå til næste linje. Du vil bemærke, at kodelinjen stadig er indrykket efter at have trykket på Enter. Det betyder, at vi stadig er inde i funktionen. For at komme ud af funktionen skal du blot trykke på Backspace én gang.

Derefter kan vi nu udføre den funktion ved at kalde den ved hjælp af funktionsnavnet . Før vi gør det, lad os tilføje en anden dokumentstreng .

Lad os kalde funktionen ved at skrive funktionsnavnet og tilføje åbne og lukkede parenteser. Klik derefter på Shift + Enter .

Som et resultat vil vi se, at denne funktion viser en tekst, der siger " hej ."

Dernæst tilføjer vi endnu en instruktion, der viser " Bob ."

Tryk derefter Shift + Enter en gang mere for at køre koden igen.

Det er sådan, vi opretter og kalder funktioner i Python .

Tilføjelse af argumenter i Python brugerdefinerede funktioner

Lad os nu prøve at tilføje argumenter til vores funktion. Lad os tilføje en ligesom eksemplet nedenfor.

Lad os derefter definere vores nye funktion med et argument .

Indtil videre vil vi kun tilføje 1 argument ved at bruge variablen " x ." I dette eksempel vil " x " være en hilsen, som du ønsker skal vises, når funktionen kaldes eller udføres. Lad os tilføje en instruktion, der viser det argument, vi tilføjede.

Så vil vi kalde vores " hilsen " funktion og sende en værdi til " x " argumentet . Efter dette vil du se teksten " Hej Bob " udskrevet som et resultat.

Ændring af funktioner i Python

Lad os ændre denne funktion. Vi kopierer den sidste funktion, vi oprettede, og indsætter den i den næste kodecelle .

I stedet for at bruge print() , bruger vi return() som giver dig mulighed for at returnere den værdi, som vi har angivet ved at kalde funktionen . 

Derudover giver brug af return() -sætningen dig mulighed for at returnere værdien flere gange.

En anden god ting med return() er, at du kan returnere værdien så meget, du vil. Lad os f.eks. returnere " Hej Bob " 2000 gange.

Lad os gå videre til et andet eksempel. Denne gang laver vi en formel. I det foregående eksempel brugte vi kun et argument, men i dette eksempel skal vi nu bruge to.

I dette eksempel navngav vi vores funktion som "" med argumenter som " x " og " y ." Vi har også angivet en formel i vores returudsagn , og derefter har vi givet værdier for " x " og " y " ved at kalde funktionen. For at opsummere denne formel er 2*2+1+1 lig med 6 .

Det er sådan, vi opretter og bruger argumenter i Python .

Husk, at argumenter er de værdier , der sendes til funktionen , når den kaldes.

Betingede erklæringer i Python

Vi bruger betingede sætninger i Python til at køre et program baseret på den angivne betingelse. Python analyserer, om disse betingede udsagn opfylder de angivne betingelser eller ej. Så kan resultaterne behandles som sande eller falske .

Lad os begynde at skabe vores betingede funktion ved at skabe.

Når du har oprettet disse variable, skal du trykke på Shift + Enter for at indlæse dem. Dernæst begynder vi at definere vores funktion, og vi vil navngive den " er_godkendt " med argumenter som navn , løn , side og udgifter . 

Inde i funktionen ønsker vi at få den årlige_total , som er lig med “ løn*12+side*12-udgifter*12 ”.

Derefter returnerer vi navnet og yearly_total .

Når vi kalder funktionen, videregiver vi værdierne fra de variabler, vi oprettede tidligere. I dette tilfælde er det navn1 , løn1 , side1 og udgifter1 . Vi bør have et output svarende til eksemplet nedenfor.

Som du kan se i vores resultat, har vi John sammen med hans årlige_total på 32400 . 

Lad os derefter tilføje vores betingede erklæringer. Denne gang sletter vi " return name, yearly_total ", fordi vi ikke vil bruge det i dette eksempel.

Denne betingede erklæring betyder blot, at hvis den årlige_total for en person er større end 30000 , vil den vise navnet sammen med beskeden " , du er godkendt. ”

På den anden side vil else-sætningen vise return()- sætningen indeholdende navnet og beskeden " , du er ikke godkendt. ” hvis den årlige_total er mindre end 30000 .

Hvis vi forsøger at kalde funktionen med vores betingede udsagn, vil dette være resultatet. 

Når man ser på resultatet, bliver John godkendt, fordi han har mere end 30000 for sit årlige_total .

Kaldende funktioner i variabler

Lad os derefter prøve at sætte vores sætning til at kalde funktionen i variabler. Vi gør dette for at gemme output for hver person, vi har oprettet.

Efter dette, lad os gå tilbage til de variabler, vi har oprettet, og opdatere den variabel, der blev brugt til Jill og John .

Efter opdatering af variablerne skal du sørge for at køre programmet igen for at gemme ændringerne. 

Lad os vise resultaterne ved at bruge print()-sætningen og resultatvariablerne .

Når vi viser resultaterne, kan vi se, at alle er godkendt, fordi Bob , Jill og John har mere end 30000 i deres årlige_total . Så lad os ændre vores tærskel fra 30000 til 35000 og køre programmet igen.

Hvis du stadig kan huske, har John kun omkring 32000 i sit årlige_total . Men vi ændrede tærsklen til 35.000 . Som følge heraf er John nu ikke godkendt.

Konklusion

Sammenfattende har vi lært den korrekte syntaks for Python brugerdefinerede funktioner såvel som vigtigheden af ​​at have en dokumentstreng i starten af ​​en ny funktion, som vi skal oprette.

Vi har også diskuteret de argumenter, som er nyttige i forskellige situationer. I denne blog brugte vi den til at vise hilsner og oprette en formel. Husk, at argumenter er de værdier, der sendes til funktionen, når den kaldes.

Derudover lærte vi ombruges i brugerdefinerede funktioner , nemlig " hvis " og " andet "-betingelser. Du kan bruge disse til at erklære betingelser i en funktion og bestemme, om den skal udføre bestemte sætninger eller ej.

Alt det bedste,

Gaellim