Funktioner
Indtil videre har vi skrevet al vores kode i app.py, men efterhånden som vores programmer vokser, har vi brug for en bedre måde at organisere vores kode på. Vi er nødt til at dele vores kode op i mindre, mere håndterbare og mere vedligeholdelige bidder, som vi kalder funktioner. Funktionen er en beholder til et par linjer kode, der udfører en bestemt opgave.
For eksempel har du allerede lært om nogle få indbyggede funktioner i Python print()
, input()
. Hver funktion har et formål og ved, hvordan man udfører en bestemt opgave. Så når vi bygger store komplekse programmer, bør vi dele vores kode op i mindre genanvendelige bidder, dvs. funktioner.
Lad os forstå dette koncept ved at bygge et program til udskrivning af en hilsen.
print('Hi there!')
print('Welcome aboard!')
Her har vi et simpelt program med kun to linjer kode. Lad os nu sige, at vi får brug for dem i andre programmer for at sætte dem i en funktion, som vi kan genbruge.
Lad mig introducere et reserveret søgeord def
i Python, som er en forkortelse for definere og bruges til at definere en funktion.
def greet_user():
print('Hi there!')
print('Welcome aboard!')
Nu vil denne kodeblok definere en funktion "greet_user
” med kodelinjerne efter det. Når denne funktion kaldes, vil disse to linjer blive udført. Lad os bruge dette:
print('start')
greet_user()
print('finish')
Programmet udføres sekventielt, hvilket betyder, at du skal definere en funktion, før du kalder den i programmet.
parametre
De definerede funktioner fungerer en lille smule anderledes end de indbyggede funktioner i Python. For eksempel i tilfælde af print()
en funktion, kræver det nogle oplysninger, som vi vil udskrive, men vores velkomstfunktion tager ikke nogen information. Ville det ikke være rart, hvis du kunne give brugerens navn her og så, i stedet for at sige "hej der", kunne du printe navnet på brugeren?
Du kan gøre dette ved at tilføje parametrene inden for parentesen af den definerede funktion. Lad mig vise dig:
def greet_user(name):
print('Hi there!')
print('Welcome aboard!')
Nu er "name
” inde i parentesen vil fungere som en lokal variabel, og vi kan videregive brugerens navn, når vi kalder det.
greet_user('Shahbaz')
Nu er navneparameteren sat til "Shahbaz
”. Lad os ændre programmet for at gøre brug af det.
def greet_user(name):
print(f'Hi {name}')
print('Welcome aboard!')
print('start')
greet_user('Shahbaz')
print('finish')
En vigtig ting at bemærke er, at "navnet" i den første linje kaldes en parameter, mens det angivne navn, dvs. Shahbaz, kaldes et argument.
Lad os gå videre og køre dette program.
Så med disse parametre kan vi modtage information i vores funktioner.
Lad os nu gøre noget interessant. Lad os sige, at du vil tilføje et andet navn til hilsenen. Det er simpelt.
def greet_user(name):
print(f'Hi {name}')
print('Welcome aboard!')
print('start')
greet_user('Shahbaz')
greet_user('Aayush')
print('finish')
Bemærk nu, at når en funktion har en parameter, er vi forpligtet til at sende en værdi for den parameter. Hvis du fjerner navnet fra funktionen og kører programmet, får vi en fejl. Du kan også bruge flere parametre i en enkelt funktion, adskilt af et komma.
For eksempel: greet_user(first_name, last_name):
. Argumenter vil også blive formateret på samme måde.
Søgeordsargumenter
Indtil videre har vi lært, at når vi definerer parametre for vores funktioner, skal vi altid angive værdier, ellers får vi en fejl. I det sidste program, argumenterne 'Shahbaz'
, 'Bhatti'
kaldes positionelle argumenter, hvilket betyder, at deres position eller rækkefølge har betydning i programmet.
I Python har vi en anden slags argument kaldet søgeordsargumenter, hvor positionen er ligegyldig. Lad mig vise dig, hvordan de virker.
Se det sidste program. Vi kan ændre det sådan:
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 first_name
, last_name
er søgeordsparametrene. Du kan skifte deres plads, og resultatet bliver det samme.
Det betyder nu ikke, at vi altid skal bruge søgeordsargumenter. Det meste af tiden bruger vi positionelle argumenter, men i visse situationer hjælper disse søgeordsargumenter os med at forbedre læsbarheden af vores kode.
Der er endnu en ting, du skal vide om søgeordsargumenter. Søgeordsargumenterne skal altid komme efter positionsargumenter.
Returerklæring
Indtil videre har vi lært, hvordan man opretter funktioner og sender information til dem ved hjælp af deres parametre. Lad os nu lære, hvordan du opretter funktioner, der returnerer værdier. Dette er især nyttigt, hvis du laver en form for beregninger, og du vil returnere resultatet til den, der bruger din funktion. Lad mig vise dig.
Lad os definere en funktion, som beregner kvadratet af et tal.
def square(number):
return number*number
Vi har brugt return-sætningen til at returnere dette nummer uden for funktionen. Nu, hvis vi kalder denne funktion, returnerer den en værdi ligesom input()
fungere. Lad os udskrive det på terminalen.
Du kan argumentere for, at det samme resultat kan opnås uden at bruge returopgørelsen. Lad os tjekke det ud.
Vi ser to ting, tallet 9 og ingen. Hvad sker der her?
Når Python-fortolkeren udfører denne kode, kalder den først kvadratfunktionen, og kontrollen flytter til funktionen. Her beregner vi kvadratet af dette givne tal og udskriver det derefter på terminalen.
Nu returnerer alle funktioner som standard værdien ingen. Så hvis vi ikke har en returerklæring her, returnerer Python som standard ingen. Ingen er et objekt, der repræsenterer fraværet af en værdi. Det er som ingenting eller null i C, C++, Java og Javascript.
Afslut!
Jeg håber du har forstået vigtigheden af funktioner.
De er et væsentligt aspekt af Python-læring, hvis du planlægger at skrive store og komplekse programmer i løbet af din kodekarriere.
Giv en kommentar