Funksies
Tot dusver het ons al ons kode in die app.py geskryf, maar soos ons programme groei, het ons 'n beter manier nodig om ons kode te organiseer. Ons moet ons kode opbreek in kleiner, meer hanteerbare en meer onderhoubare stukke wat ons funksies noem. Die funksie is 'n houer vir 'n paar reëls kode wat 'n spesifieke taak verrig.
Byvoorbeeld, jy het reeds van 'n paar ingeboude funksies in Python geleer print()
en input()
. Elke funksie het 'n doel en weet hoe om 'n spesifieke taak uit te voer. Dus, wanneer ons groot komplekse programme bou, moet ons ons kode opbreek in kleiner herbruikbare stukke, dws funksies.
Kom ons verstaan hierdie konsep deur 'n program te bou vir die druk van 'n groeteboodskap.
print('Hi there!')
print('Welcome aboard!')
Hier het ons 'n eenvoudige program met slegs twee reëls kode. Nou, kom ons sê, ons gaan hulle in ander programme nodig hê om hulle in 'n funksie te plaas wat ons kan hergebruik.
Laat ek 'n gereserveerde sleutelwoord voorstel def
in Python, wat kort is vir definieer en word gebruik om 'n funksie te definieer.
def greet_user():
print('Hi there!')
print('Welcome aboard!')
Nou sal hierdie blok kode 'n funksie definieer "greet_user
” met die reëls kodes daarna. Wanneer hierdie funksie geroep word, sal hierdie twee reëls uitgevoer word. Kom ons gebruik dit:
print('start')
greet_user()
print('finish')
Die program word opeenvolgend uitgevoer, wat beteken dat u 'n funksie moet definieer voordat u dit in die program oproep.
Grense
Die gedefinieerde funksies werk 'n bietjie anders as die ingeboude funksies van Python. Byvoorbeeld, in die geval van print()
'n funksie, dit neem inligting wat ons wil druk, maar ons groet-funksie neem geen inligting nie. Sal dit nie lekkerder wees as jy die naam van die gebruiker hier en dan kan deurgee nie, in plaas van om "hi daar" te sê, kan jy die naam van die gebruiker druk?
Jy kan dit doen deur die parameters binne die hakies van die gedefinieerde funksie by te voeg. Laat ek jou wys:
def greet_user(name):
print('Hi there!')
print('Welcome aboard!')
Nou die "name
” binne die hakies sal optree soos 'n plaaslike veranderlike en ons kan die gebruiker se naam deurgee wanneer ons dit roep.
greet_user('Shahbaz')
Nou is die naam parameter gestel op "Shahbaz
”. Kom ons verander die program om daarvan gebruik te maak.
def greet_user(name):
print(f'Hi {name}')
print('Welcome aboard!')
print('start')
greet_user('Shahbaz')
print('finish')
'n Belangrike ding om daarop te let is dat die "naam" in die eerste reël 'n Parameter genoem word, terwyl die naam wat verskaf word, dws Shahbaz, 'n argument genoem word.
Kom ons gaan voort en hardloop hierdie program.
So met hierdie parameters kan ons inligting in ons funksies ontvang.
Nou, kom ons doen iets interessants. Kom ons sê jy wil nog 'n naam by die groeteboodskap voeg. Dit is eenvoudig.
def greet_user(name):
print(f'Hi {name}')
print('Welcome aboard!')
print('start')
greet_user('Shahbaz')
greet_user('Aayush')
print('finish')
Let nou op dat wanneer 'n funksie 'n parameter het, ons verplig is om 'n waarde vir daardie parameter deur te gee. As jy die naam van die funksie verwyder en die program laat loop, sal ons 'n fout kry. Jy kan ook veelvuldige parameters in 'n enkele funksie gebruik, geskei deur 'n komma.
Byvoorbeeld, greet_user(first_name, last_name):
. Argumente sal ook soortgelyk geformateer word.
Sleutelwoordargumente
Tot dusver het ons geleer dat wanneer ons parameters vir ons funksies definieer, ons altyd waardes moet verskaf, anders sal ons 'n fout kry. In die laaste program, die argumente 'Shahbaz'
en 'Bhatti'
word posisionele argumente genoem, wat beteken dat hul posisie of volgorde in die program belangrik is.
In Python het ons 'n ander soort argument genaamd sleutelwoordargumente, waarvoor die posisie nie saak maak nie. Kom ek wys jou hoe hulle werk.
Kyk na die laaste program. Ons kan dit soos volg verander:
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')
Nou die first_name
en last_name
is die sleutelwoordparameters. Jy kan hul plekke verander en die resultaat sal dieselfde wees.
Dit beteken nou nie dat ons altyd sleutelwoordargumente moet gebruik nie. Meeste van die tyd gebruik ons posisionele argumente, maar in sekere situasies help hierdie sleutelwoordargumente ons om die leesbaarheid van ons kode te verbeter.
Daar is nog een ding wat jy moet weet oor sleutelwoordargumente. Die sleutelwoordargumente moet altyd na posisionele argumente kom.
Terugsendingverklaring
Tot dusver het ons geleer hoe om funksies te skep en inligting aan hulle te stuur deur hul parameters te gebruik. Kom ons leer nou hoe om funksies te skep wat waardes gee. Dit is veral nuttig as jy 'n soort berekeninge doen en jy die resultaat wil teruggee aan wie ook al jou funksie gebruik. Laat ek jou wys.
Kom ons definieer 'n funksie wat die kwadraat van 'n getal sal bereken.
def square(number):
return number*number
Ons het die terugkeerstelling gebruik om hierdie nommer buite die funksie terug te gee. Nou, as ons hierdie funksie noem, gee dit 'n waarde net soos die input()
funksie. Kom ons druk dit op die terminale.
Jy kan argumenteer dat dieselfde resultaat verkry kan word sonder om die opgawestaat te gebruik. Kom ons kyk daarna.
Ons sien twee dinge, die getal 9, en geen. Wat gebeur hier?
Wanneer die Python-interpreter hierdie kode uitvoer, sal dit eers die vierkantfunksie oproep en die beheer skuif na die funksie. Hier bereken ons die kwadraat van hierdie gegewe getal en druk dit dan op die terminaal.
Nou, by verstek, gee alle funksies die waarde geen. As ons dus nie 'n opgawestelling hier het nie, gee Python by verstek niks terug. Geen is 'n voorwerp wat die afwesigheid van 'n waarde verteenwoordig nie. Dit is soos niks of nul in C, C++, Java en Javascript.
Afsluit!
Ek hoop jy het die belangrikheid van funksies verstaan.
Dit is 'n belangrike aspek van Python-leer as jy van plan is om groot en komplekse programme te skryf tydens jou koderingsloopbaan.
Lewer Kommentaar