Funktioner
Hittills har vi skrivit all vår kod i app.py, men när våra program växer behöver vi ett bättre sätt att organisera vår kod. Vi måste dela upp vår kod i mindre, mer hanterbara och mer underhållbara bitar som vi kallar funktioner. Funktionen är en behållare för några rader kod som utför en specifik uppgift.
Du har till exempel redan lärt dig om några inbyggda funktioner i Python print()
och input()
. Varje funktion har ett syfte och vet hur man utför en specifik uppgift. Så när vi bygger stora komplexa program bör vi dela upp vår kod i mindre återanvändbara bitar, dvs funktioner.
Låt oss förstå detta koncept genom att bygga ett program för att skriva ut ett hälsningsmeddelande.
print('Hi there!')
print('Welcome aboard!')
Här har vi ett enkelt program med bara två rader kod. Nu, låt oss säga, vi kommer att behöva dem i andra program för att sätta dem i en funktion som vi kan återanvända.
Låt mig introducera ett reserverat nyckelord def
i Python, som är en förkortning för define och används för att definiera en funktion.
def greet_user():
print('Hi there!')
print('Welcome aboard!')
Nu kommer detta kodblock att definiera en funktion "greet_user
” med kodraderna efter det. Närhelst denna funktion anropas kommer dessa två rader att exekveras. Låt oss använda detta:
print('start')
greet_user()
print('finish')
Programmet exekveras sekventiellt, vilket innebär att du måste definiera en funktion innan du anropar den i programmet.
parametrar
De definierade funktionerna fungerar lite annorlunda än de inbyggda funktionerna i Python. Till exempel när det gäller print()
en funktion tar det viss information som vi vill skriva ut, men vår hälsningsfunktion tar ingen information. Vore det inte trevligare om du kunde skicka namnet på användaren här och sedan, istället för att säga "hej då", kunde du skriva ut användarens namn?
Du kan göra detta genom att lägga till parametrarna inom parentesen för den definierade funktionen. Låt mig visa dig:
def greet_user(name):
print('Hi there!')
print('Welcome aboard!')
Nu den "name
” inuti parentesen kommer att fungera som en lokal variabel och vi kan skicka användarens namn när vi anropar den.
greet_user('Shahbaz')
Nu är namnparametern inställd på "Shahbaz
”. Låt oss ändra programmet för att använda det.
def greet_user(name):
print(f'Hi {name}')
print('Welcome aboard!')
print('start')
greet_user('Shahbaz')
print('finish')
En viktig sak att notera är att "namnet" i den första raden kallas en parameter medan namnet som anges, dvs Shahbaz kallas ett argument.
Låt oss köra det här programmet.
Så med dessa parametrar kan vi ta emot information i våra funktioner.
Nu ska vi göra något intressant. Låt oss säga att du vill lägga till ett annat namn till hälsningsmeddelandet. Det är enkelt.
def greet_user(name):
print(f'Hi {name}')
print('Welcome aboard!')
print('start')
greet_user('Shahbaz')
greet_user('Aayush')
print('finish')
Observera nu att när en funktion har en parameter är vi skyldiga att skicka ett värde för den parametern. Om du tar bort namnet från funktionen och kör programmet får vi ett felmeddelande. Du kan också använda flera parametrar i en enda funktion, separerade med kommatecken.
Till exempel, greet_user(first_name, last_name):
. Argument kommer också att formateras på liknande sätt.
Nyckelordsargument
Hittills har vi lärt oss att när vi definierar parametrar för våra funktioner ska vi alltid ange värden annars får vi ett fel. I det förra programmet, argumenten 'Shahbaz'
och 'Bhatti'
kallas positionsargument, vilket betyder att deras position eller ordning spelar roll i programmet.
I Python har vi en annan sorts argument som kallas nyckelordsargument, för vilka positionen inte spelar någon roll. Låt mig visa dig hur de fungerar.
Titta på det senaste programmet. Vi kan ändra det så här:
def greet_user(first_name, last_name):
print(f'Hi {first_name} {last_name}')
print('Welcome aboard!')
print('start')
greet_user(first_name='Shahbaz', last_name='Bhatti')
print('finish')
Nu den first_name
och last_name
är nyckelordsparametrarna. Du kan byta plats och resultatet blir detsamma.
Nu betyder det inte att vi alltid ska använda sökordsargument. För det mesta använder vi positionsargument, men i vissa situationer hjälper dessa nyckelordsargument oss att förbättra läsbarheten för vår kod.
Det finns ytterligare en sak du behöver veta om sökordsargument. Nyckelordsargument ska alltid komma efter positionsargument.
Returuttalande
Hittills har vi lärt oss hur man skapar funktioner och skickar information till dem med hjälp av deras parametrar. Låt oss nu lära oss hur man skapar funktioner som returnerar värden. Detta är särskilt användbart om du gör någon form av beräkningar och du vill returnera resultatet till den som använder din funktion. Låt mig visa dig.
Låt oss definiera en funktion som beräknar kvadraten på ett tal.
def square(number):
return number*number
Vi har använt retursatsen för att returnera detta nummer utanför funktionen. Nu, om vi anropar den här funktionen, returnerar den ett värde precis som input()
fungera. Låt oss skriva ut det på terminalen.
Du kan argumentera för att samma resultat kan erhållas utan att använda returuppdraget. Låt oss kolla upp det.
Vi ser två saker, siffran 9 och ingen. Vad är det som händer här?
När Python-tolken exekverar den här koden kommer den först att anropa kvadratfunktionen och kontrollen flyttas till funktionen. Här beräknar vi kvadraten på detta givna tal och skriver ut det på terminalen.
Nu, som standard, returnerar alla funktioner värdet none. Så om vi inte har en retursats här, returnerar Python som standard ingen. Inget är ett objekt som representerar frånvaron av ett värde. Det är som ingenting eller null i C, C++, Java och Javascript.
Sammanfatta!
Jag hoppas att du har förstått vikten av funktioner.
De är en viktig aspekt av Python-inlärning om du planerar att skriva stora och komplexa program under din kodningskarriär.
Kommentera uppropet