Python användardefinierade funktioner | En översikt

I den här handledningen kommer vi att diskutera hur man använder Python användardefinierade funktioner och hur man skapar dem. Användardefinierade funktioner kan hjälpa dig att dela upp stora program i små delar för att göra dem lättare att felsöka, underhålla och förstå.

Användardefinierade funktioner är också bra för att lagra upprepade koder i ett program. Vi kan exekvera den koden genom att anropa funktionen vid behov. 

Låt oss börja utforska, bygga och öva på hur man skapar användardefinierade funktioner genom att skapa en ny anteckningsbok. För att göra det klickar du på Arkiv- menyn och håller sedan muspekaren på och väljer Python 3 .

Efter att ha skapat en ny anteckningsbok kommer vi att börja med att trycka på ESC + B några gånger för att lägga till flera kodceller . 

Låt oss lägga till en dokumentsträng för att ge en kort notering om vad vi gör. För att göra detta är det viktigt att använda " # "-tecknet i början. Skriv sedan anteckningen direkt efter " # "-tecknet. 

Innehållsförteckning

• Struktur av användardefinierade funktioner i Python
• Lägga till argument i Python användardefinierade funktioner
• Ändra funktioner i Python
• Villkorliga uttalanden i Python
• Anropa funktioner i variabler
• Slutsats

Struktur av användardefinierade funktioner i Python

För att skapa användardefinierade funktioner i Python bör vi följa dess standardstruktur. Först måste vi lägga till def för att definiera funktionen. Sedan lägger vi till funktionsnamnet. Lägg slutligen till öppen och stäng parentes för att stänga funktionen.

Observera att vi också kan lägga till argument inom parentesen, men för tillfället lämnar vi det tomt. Efter att ha stängt funktionen kan vi sedan lägga till ett kolon i slutet.

Detta för att säkerställa att instruktionerna vi ska deklarera läggs till i funktionen vi skapar.

Efter att ha skapat funktionen, låt oss lägga till en instruktion som kommer att exekveras senare när vi anropar den här funktionen. För det här exemplet, låt oss skriva ut ordet " hej ".

När du har lagt till instruktionen, klicka på Enter för att gå till nästa rad. Du kommer att märka att kodraden fortfarande är indragen efter att du tryckt på Enter. Det betyder att vi fortfarande är inne i funktionen. För att komma ur funktionen, tryck bara på Backsteg en gång.

Efter det kan vi nu köra den funktionen genom att anropa den med funktionen namn . Innan vi gör det, låt oss lägga till en annan dokumentsträng .

Låt oss anropa funktionen genom att skriva funktionsnamnet och lägga till öppna och stängda parenteser. Klicka sedan på Shift + Enter .

Som ett resultat kommer vi att se att den här funktionen visar en text som säger " hej ."

Därefter lägger vi till en annan instruktion som visar " Bob ."

Tryck sedan på Shift + Enter en gång till för att köra koden igen.

Det är så vi skapar och anropar funktioner i Python .

Lägga till argument i Python användardefinierade funktioner

Låt oss nu försöka lägga till argument till vår funktion. Låt oss lägga till en precis som exemplet nedan.

Efter det, låt oss definiera vår nya funktion med ett argument .

För närvarande kommer vi bara att lägga till 1 argument med variabeln " x ." I det här exemplet kommer " x " att vara en hälsning som du vill ska visas när funktionen anropas eller exekveras. Låt oss lägga till en instruktion som visar argumentet vi lade till.

Sedan kommer vi att anropa vår " hälsnings " - funktion och skicka ett värde till " x " - argumentet . Efter detta kommer du att se texten " Hej Bob " utskriven som ett resultat.

Ändra funktioner i Python

Låt oss ändra denna funktion. Vi kopierar den senaste funktionen som vi skapade och klistrar in den i nästa kodcell .

Istället för att använda print() kommer vi att använda return() som gör att du kan returnera värdet som vi har angett när vi anropade funktionen . 

Genom att använda return() -satsen kan du dessutom returnera värdet flera gånger.

En annan bra sak med return() är att du kan returnera värdet så mycket du vill. Låt oss till exempel återvända " Hej Bob " 2000 gånger.

Låt oss gå vidare till ett annat exempel. Den här gången skapar vi en formel. I det föregående exemplet använde vi bara ett argument men i det här exemplet ska vi nu använda två.

I det här exemplet namngav vi vår funktion som "" med argument som " x " och " y ." Vi har också angett en formel i vår retursats , sedan angav vi värden för " x " och " y " när vi anropade funktionen. För att sammanfatta denna formel är 2*2+1+1 lika med 6 .

Det är så vi skapar och använder argument i Python .

Kom ihåg att argument är de värden som skickas till funktionen när den anropas.

Villkorliga uttalanden i Python

Vi använder villkorliga satser i Python för att köra ett program baserat på det angivna villkoret. Python analyserar om dessa villkorliga uttalanden uppfyller de villkor som anges eller inte. Då kan resultaten bearbetas som sant eller falskt .

Låt oss börja skapa vår villkorliga funktion genom att skapa.

När du har skapat dessa variabler trycker du på Skift + Enter för att ladda dem. Därefter börjar vi definiera vår funktion och vi kommer att döpa den till " är_godkänd " med argument som namn , lön , sida och kostnader . 

Inuti funktionen vill vi få den årliga_total som är lika med " lön*12+sida*12-kostnader*12 ".

Sedan returnerar vi namnet och yearly_total .

När vi anropar funktionen skickar vi värdena från variablerna som vi skapade tidigare. I det här fallet är det namn1 , lön1 , sida1 och kostnader1 . Vi bör ha en utdata som liknar exemplet nedan.

Som du kan se i vårt resultat har vi John tillsammans med hans årliga_total på 32400 . 

Låt oss sedan lägga till våra villkorliga uttalanden. Den här gången tar vi bort " return name, yearly_total " eftersom vi inte kommer att använda det i det här exemplet.

Detta villkorliga uttalande betyder helt enkelt att om den årliga_total för en person är större än 30000 , kommer den att visa namnet tillsammans med meddelandet " , du är godkänd. ”

Å andra sidan kommer else-satsen att visa return() -satsen som innehåller namnet och meddelandet " , du är inte godkänd. ” om den årliga_total är mindre än 30 000 .

Om vi ​​försöker anropa funktionen med våra villkorliga uttalanden blir detta resultatet. 

När man tittar på resultatet blir John godkänd eftersom han har mer än 30 000 för sitt årliga_total .

Anropa funktioner i variabler

Låt oss sedan försöka sätta vårt uttalande för att anropa funktionen i variabler. Vi gör detta för att spara utdata för varje person vi har skapat.

Efter detta, låt oss gå tillbaka till variablerna vi har skapat och uppdatera variabeln som används för Jill och John .

Efter att ha uppdaterat variablerna, se till att köra programmet igen för att spara ändringarna. 

Låt oss visa resultaten med hjälp av print()-satsen och resultatvariablerna .

När vi visar resultaten kan vi se att alla är godkända eftersom Bob , Jill och John har mer än 30 000 i sitt årliga_total . Så låt oss ändra vårt tröskelvärde från 30 000 till 35 000 och kör programmet igen.

Om du fortfarande kan komma ihåg har John bara cirka 32 000 i sin årliga_total . Men vi ändrade tröskeln till 35 000 . Som ett resultat är John nu inte godkänd.

Slutsats

Sammanfattningsvis har vi lärt oss rätt syntax för Python användardefinierade funktioner samt vikten av att ha en dokumentsträng i början av en ny funktion som vi ska skapa.

Vi har också diskuterat de argument som är användbara i olika situationer. I den här bloggen använde vi den för att visa hälsningar och skapa en formel. Tänk på att argument är de värden som skickas till funktionen när den anropas.

Dessutom lärde vi oss omanvänds i användardefinierade funktioner , nämligen villkoren " if " och " else ". Du kan använda dessa för att deklarera villkor i en funktion och bestämma om den ska köra vissa satser eller inte.

Med vänliga hälsningar,

Gaellim