Hur man ringer in en funktion Python (Exempel)

Hur man definierar och anropar en funktion Python

Funktion i Python definieras av "def" sats följt av funktionsnamn och parenteser (())

Exempelvis:

Låt oss definiera en funktion genom att använda kommandot ”def func1():” och anropa funktionen. Utgången av funktionen blir "Jag lär mig Python fungera".

Funktionen print func1() anropar vår def func1(): och skriv ut kommandot ” Jag lär mig Python funktion Ingen."

Det finns regler i Python att definiera en funktion.

• Eventuella argument eller indataparametrar ska placeras inom dessa parenteser
• Funktionen första sats kan vara en valfri sats-docstring eller dokumentationssträngen för funktionen
• Koden inom varje funktion börjar med ett kolon (:) och ska indragas (mellanslag)
• Uttrycket retur (uttryck) avslutar en funktion, och skickar eventuellt tillbaka ett värde till den som ringer. En retursats utan args är detsamma som return None.

Betydelsen av indrag (mellanslag) i Python

Innan vi blir bekanta med Python funktioner är det viktigt att vi förstår indragsregeln att deklarera Python funktioner och dessa regler är tillämpliga på andra delar av Python liksom att deklarera villkor, loopar eller variabel.

Python följer en viss stil av indrag för att definiera koden, eftersom Python funktioner har ingen explicit början eller slut som lockiga hängslen för att indikera start och stopp för funktionen, de måste förlita sig på denna indrag. Här tar vi ett enkelt exempel med kommandot "skriv ut". När vi skriver "print"-funktionen precis under def func 1 (): Det kommer att visa en "indragsfel: förväntade sig ett indraget block".

Nu, när du lägger till indraget (mellanslag) framför "print"-funktionen, ska det skrivas ut som förväntat.

Åtminstone räcker ett indrag för att få din kod att fungera framgångsrikt. Men som en bästa praxis är det tillrådligt att lämna cirka 3-4 indrag för att anropa din funktion.

Det är också nödvändigt att du måste göra det samtidigt som du deklarerar indrag bibehåll samma indrag för resten av din kod. Till exempel, i skärmdumpen nedan när vi kallar en annan sats "fortfarande i func1" och när den inte deklareras precis under den första utskriftssatsen kommer den att visa ett indragsfel "ta bort indrag matchar inte någon annan indragsnivå."

När vi nu tillämpar samma indrag för båda påståendena och justerar dem på samma rad, ger det den förväntade utmatningen.

Hur fungerar avkastningsvärdet?

Returnera kommandot in Python anger vilket värde som ska ge tillbaka till den som anropar funktionen. Låt oss förstå detta med följande exempel

Steg 1) Funktionen returnerar ingenting

Här – vi ser när funktion inte är "retur". Till exempel vill vi ha kvadraten på 4, och den ska ge svaret "16" när koden exekveras. Vilket det ger när vi helt enkelt använder "print x*x"-kod, men när du kallar funktionen "print square" ger det "None" som en utdata. Detta beror på att när du anropar funktionen sker inte rekursion och faller av i slutet av funktionen. Python returnerar "Ingen" för att misslyckas i slutet av funktionen.

Steg 2) Ersätt utskriftskommandot med tilldelningskommando

För att göra detta tydligare ersätter vi utskriftskommandot med tilldelningskommando. Låt oss kontrollera utgången.

När du kör kommandot "print square (4)" returnerar det faktiskt värdet på objektet eftersom vi inte har någon specifik funktion att köra över här returnerar det "None".

Steg 3) Använd 'retur'-funktionen och exekvera koden

Nu kommer vi att se hur man hämtar utdata med "return"-kommandot. När du använder "retur"-funktionen och exekverar koden, kommer den att ge utgången "16."

Steg 4) Kör kommandot "print square"

Fungerar i Python är i sig ett objekt, och ett objekt har ett visst värde. Vi får här se hur Python behandlar ett föremål. När du kör kommandot "print square" returnerar det objektets värde. Eftersom vi inte har skickat något argument, har vi ingen specifik funktion att köra över här det returnerar ett standardvärde (0x021B2D30) som är platsen för objektet. I praktiken Python programmet kommer du förmodligen aldrig att behöva göra detta.

Argument i funktioner

Argumentet är ett värde som skickas till funktionen när den anropas.

Med andra ord på den anropande sidan är det ett argument och på funktionssidan är det en parameter.

Låt se hur Python Args fungerar –

Steg 1) Argument deklareras i funktionsdefinitionen. När du anropar funktionen kan du skicka värdena för dessa args som visas nedan

Steg 2) För att deklarera ett standardvärde för ett argument, tilldela det ett värde vid funktionsdefinition.

Exempelvis: x har inga standardvärden. Standardvärden för y=0. När vi bara anger ett argument när vi anropar multiplikationsfunktionen, Python tilldelar det angivna värdet till x samtidigt som värdet y=0 behålls. Därav multipliceringen av x*y=0

Steg 3) Den här gången kommer vi att ändra värdet till y=2 istället för standardvärdet y=0, och det kommer att returnera utdata som (4×2)=8.

Steg 4) Du kan också ändra i vilken ordning argumenten kan skickas in Python. Här har vi vänt om ordningen på värdet x och y till x=4 och y=2.

Steg 5) Flera argument kan också skickas som en array. Här i exemplet anropar vi multipla args (1,2,3,4,5) genom att anropa (*args)-funktionen.

Exempelvis: Vi deklarerade flera args som nummer (1,2,3,4,5) när vi anropar (*args)-funktionen; den skriver ut resultatet som (1,2,3,4,5)

tips:

• In Python 2.7. funktionsöverbelastning stöds inte i Python. Funktionsöverbelastning är möjligheten att skapa flera metoder med samma namn med en annan implementering. Funktion Överbelastning stöds fullt ut i Python 3
• Det råder ganska stor förvirring mellan metoder och funktioner. Metoder i Python är associerade med objektinstanser medan funktion inte är det. När Python anropar en metod, binder den den första parametern i det anropet till lämplig objektreferens. Med enkla ord, en fristående funktion i Python är en "funktion", medan en funktion som är ett attribut för en klass eller en instans är en "metod".

Här är den kompletta Python 3-kod

#define a function
def func1():
   print ("I am learning Python function")
   print ("still in func1")
   
func1()

def square(x):
  	return x*x
print(square(4))

def multiply(x,y=0):
	print("value of x=",x)
	print("value of y=",y)
    
	return x*y
  
print(multiply(y=2,x=4))

Här är den kompletta Python 2-kod

#define a function
def func1():
   print " I am learning Python function"
   print " still in func1"
   
func1()

def square(x):
  	return x*x
print square(4)

def multiply(x,y=0):
	print"value of x=",x
	print"value of y=",y
    
	return x*y
  
print multiply(y=2,x=4)

Sammanfattning

Funktion i Python är en återanvändbar kod som används för att utföra en enda, relaterad åtgärd. I den här artikeln kommer vi att se

• Funktion definierad av def meddelandet
• Kodblocket inom varje funktion börjar med ett kolon (:) och ska indragas (mellanslag)
• Eventuella argument eller indataparametrar bör placeras inom dessa parenteser, etc.
• Minst ett indrag ska lämnas före koden efter att funktionen deklarerats
• Samma indragsstil bör bibehållas genom hela koden inom def-funktionen
• För bästa praxis anses tre eller fyra strecksatser vara bäst före uttalandet
• Du kan använda kommandot "return" för att returnera värden till funktionsanropet.
• Python kommer att skriva ut ett slumpmässigt värde som (0x021B2D30) när argumentet inte levereras till den anropande funktionen. Exempel "utskriftsfunktion."
• På anropssidan är det ett argument och på funktionssidan är det en parameter
• Standardvärde i argument – ​​När vi bara anger ett argument när vi anropar multiplikationsfunktionen eller någon annan funktion, Python tilldelar det andra argumentet som standard
• Python gör att du också kan vända ordningen på argumentet

Denna kod är redigerbar. Klicka på Kör för att köra