Hur man anropar en funktion i Python: The Ultimate Guide

Funktioner är ett väsentligt koncept i programmering som gör att du kan hantera och återanvända kodblock. Att veta hur man anropar en funktion i Python är en nyckelfärdighet att lära sig.

I den här handledningen kommer du att lära dig grunderna i anropsfunktioner, tillsammans med några tips för att skriva effektiv kod som är lättare att förstå.

Att behärska funktioner hjälper dig inte bara att skapa mer mångsidig kod utan också effektivisera din programmeringsprocess och förbättra din totala effektivitet som utvecklare.

Funktioner har samma underliggande principer, och när du väl behärskar funktioner i Python kommer du att kunna utöka din förståelse av funktioner jämfört med andra programmeringsspråk som Java, R, JavaScript, PHP, etc.

Innehållsförteckning

• Vad är en funktion?
• Definiera en funktion i Python
  • Funktionssyntax
  • Parametrar och argument
    • Kwargsargumentet
• Anropa en funktion
  • Grundläggande funktionsanrop
  • Positionella argument
  • Nyckelordsargument
• Returvärden
  • Enkelt returvärde
  • Flera returvärden
• Skickar Python-funktioner som argument
• Kapslade funktioner
• Lambda funktioner
• Rekursion
• Vanliga fel och felsökning
• Slutsats

Vad är en funktion?

En funktion i Python låter dig skapa återanvändbara kodbitar som kan anropas genom hela ditt program, vilket förenklar din kod och förbättrar läsbarheten. Den utför en specifik uppgift eller uppsättning uppgifter och kan anropas flera gånger inom ett program. 

Definiera en funktion i Python

Det finns två huvudkategorier av funktioner i Python:

• Användardefinierade funktioner: Funktioner som en programmerare definierar för att undvika upprepning av kod
• Inbyggda funktioner : Funktioner som definieras av någon annan och kan användas i din kod efter att du har installerat de nödvändiga paketen

Det här avsnittet fokuserar på användardefinierade funktioner. Du lär dig:

• Hur man definierar en funktion i Python
• Funktionens syntax
• Hur man använder parametrar och argument

Funktionssyntax

Nyckelordet def , följt av funktionsnamnet och parenteser, låter dig definiera en funktion i Python. Funktionskroppen är indragen och innehåller koden som ska exekveras när funktionen anropas. Ett exempel på en grundläggande funktion i Python ges nedan:

def greet(): print("Hej världen!") greet()

Nyckelordet def definierar en ny funktion med namnet greet. Den tredje raden med kod anropar funktionen, som exekverar koden inuti funktionen.

Raden printi koden ovan är också en funktion. Men om du arbetar i en Python 2-miljö definieras det som ett uttalande. Senare, i Python 3, ändrades det från uttalande till en funktion.

Parametrar och argument

Parametrar är platshållare i funktionsdefinitionen, medan argument är de värden som skickas när funktionen anropas.

För att specificera parametrar, inkludera dem inom parentesen av funktionsdefinitionen, separerade med kommatecken om det finns flera parametrar. När du anropar en funktion tillhandahåller du ingångsvärdena som kallas argument. Följande exempel visar hur man definierar en funktion som tar två parametrar:

def add_numbers(a, b): returnera a+b

Satsen return i funktionens kropp returnerar tillägget av de två argument som skickats in i den. Du kan tänka dig det som en miniräknare, där du matar in värden och får önskat resultat i gengäld.

Efter att ha definierat funktionen kan vi kalla den med valfria argument.

add_numbers(3, 5)

Kwargsargumentet

kwargs är en förkortning för "sökordsargument" i Python. Det låter dig utöka en funktions flexibilitet genom att tillåta den som ringer att ange valfritt antal nyckelordsargument när funktionen anropas. Nyckelordsargumenten skickas som en ordbok till funktionen.

I en funktionsdefinition kan du använda **syntaxen med dubbel asterisk före parameternamnet för att acceptera nyckelordsargument.

def my_function(**kwargs): för nyckel, värde i kwargs.items(): print(f"{key} = {value}") my_function(a=1, b=2, c=3)

I det här exemplet kwargs kommer en ordbok som innehåller nyckelordsargumenten som skickas till funktionen. Utgången visas i bilden nedan:

Anropa en funktion

Att anropa en funktion innebär att exekvera koden inuti funktionens kropp. Det finns fyra typer av funktionsanrop i Python:

• Grundläggande funktionsanrop
• Ringer med positionsargument
• Ringer med sökordsargument

Grundläggande funktionsanrop

Ett grundläggande funktionsanrop anropar funktionen utan att skicka några argument till funktionen. Efter att ha definierat en funktion kan du anropa den genom att använda dess namn följt av parentes.

Om funktionen inte tar några argument kommer parenteserna att vara tomma. Koden nedan är ett exempel på en grundläggande funktion.

def welcome_message(): print("Välkommen till LuckyTemplates!") welcome_message()

Att köra koden ovan ger följande utdata:

Positionella argument

Positionsargument är den vanligaste typen av argument och de skickas till funktionen i samma ordning som de anges. Följande är ett exempel på ett funktionsanrop med positionsargument:

def welcome_message(name): print(f"Välkommen till LuckyTemplates, {name}!") welcome_message("John")

I exemplet ovan welcome_message()tar funktionen ett argument, name. När du anropar den här funktionen med argumentet Johnkommer den att skriva ut meddelandet bredvid namnet.

Koden ovan ger följande utdata:

Nyckelordsargument

Ett annat sätt att skicka argument till en funktion är att använda nyckelordsargument. Nyckelordsargument låter dig ange namnet på parametern tillsammans med dess värde, vilket gör koden mer läsbar och minskar chansen att skicka argument i fel ordning. 

Exemplet nedan använder nyckelordsargument för att anropa welcome_messagefunktionen:

def welcome_message(name, message='Välkommen till LuckyTemplates!'): print(meddelande, namn) welcome_message(name='Alice', message='God morgon')

I det här exemplet har vi definierat en funktion welcome_message()som har två parametrar, , nameoch message. Meddelandeparametern har ett standardargument på Welcome to LuckyTemplates!När vi anropar funktionen använder vi nyckelordsargument för att skicka värdet , Johnvilket resulterar i utdataWelcome to LuckyTemplates! John.

Returvärden

När du arbetar med funktioner vill du ofta returnera resultatet av operationer i din funktions kropp. Returvärden tillåter en funktion att skicka ett resultat tillbaka till den som ringer. Genom att förstå hur man arbetar med enstaka och flera returvärden kan du förbättra funktionaliteten hos dina Python-program.

Enkelt returvärde

En enkel returvärdesfunktion returnerar ett värde från operationerna i en funktion.

Ett exempel på en enkel returvärdesfunktion ges nedan:

def get_greeting(name): returnera "Hej, " + namn + "!" hälsning = get_greeting("Alice") print(hälsning)

I exemplet ovan get_greetingtar funktionen ett namn eftersom dess funktionsargument kompilerar det och returnerar en personlig hälsning. Returvärdet lagras sedan i variabelhälsningen och skrivs ut till konsolen.

Flera returvärden

Ibland kommer du att behöva returnera mer än ett värde från en funktion i Python. För att uppnå detta kan du använda en tupel eller en lista för att linda returvärdena.

Följande är ett exempel på funktion för flera returvärden i programmeringsspråket Python.

def get_name_and_age(): return ("John", 30) namn, ålder = get_name_and_age() print(name) print(age)

I det här exemplet get_name_and_ageär en funktion som returnerar en tupel med två värden: a name och en age.

Du kan också returnera en . Funktionen nedan visar ett listreturvärde från en funktion.

def calculate_areas(height, width): returnera [height * width, (height * width) / 2] area, triangle_area = calculate_areas(10, 5) print(area) print(triangle_area)

I det här fallet tar funktionen calculate_areastvå argument, height, och width, och returnerar en lista som innehåller arean av en rektangel och arean av en triangel.

Skickar Python-funktioner som argument

Python låter dig skicka funktioner som argument till andra funktioner. När en funktion accepterar en annan funktion som ett argument, kallas det en högre ordningsfunktion.

Koden nedan är ett exempel på att skicka en funktion till en annan funktion i Python:

def square(x): return x * x def double(x): return x * 2 def apply_func(func, x): return func(x) result = apply_func(square, 5)

Kapslade funktioner

Kapslade funktioner är funktioner definierade inom en annan funktion, även känd som inre funktioner. Dessa kan vara användbara när du skapar stängningar och modulär kod. 

För att skapa en kapslad funktion, definiera helt enkelt en funktion i en annan funktion:

def yttre_funktion(x, y): def inre_funktion(z): returnera x + y + z resultat = inre_funktion(3) returnera resultat # Anropa den yttre funktionen print(outer_function(1, 2))

I exemplet ovan definieras den inre_funktionen inom den yttre_funktionen. Den inre funktionen har tillgång till variablerna för den yttre funktionen, vilket gör att den kan utföra operationer på dem.

Lambda funktioner

Lambdafunktioner, även kända som anonyma funktioner, är ett sätt att skapa små engångsfunktioner i Python. I datavetenskapsprojekt kommer du ofta att arbeta med Lambda-funktioner för att skapa effektiva datastrukturer och pipelines.

För att skapa en lambdafunktion kan du använda nyckelordet lambda följt av en lista med argument, ett kolon och sedan ett uttryck. Uttrycket är vad lambdafunktionen kommer att returnera när den anropas. Följande är ett exempel på lambda-funktion i Python:

add = lambda a, b: a + b resultat = add(3, 4) print(result) # Output: 7

I exemplet ovan skapade vi en lambdafunktion som tar två argument ( a och b) och returnerar deras summa. Vi tilldelade denna lambda-funktion till en variabel som heter add.

Lambda kan vara användbart i följande scenarier:

• Som argument för funktioner av högre ordning som map(), filter() och sortered().
• Som nyckelfunktioner vid sortering av listor eller ordböcker.

Följande exempel visar användning av högre ordningsfunktion filter() med lambda:

siffror = [1, 2, 3, 4, 5, 6, 7, 8, 9] jämna_tal = lista(filter(lambda x: x % 2 == 0, siffror)) print(jämna_tal) # Utdata: [2, 4, 6, 8]

I det här exemplet använde vi en lambda-funktion för att definiera filtreringskriterierna för filter()-funktionen. Lambdafunktionen kontrollerar om ett tal är jämnt, och filter()-funktionen returnerar en ny lista som endast innehåller de jämna talen.

För att se ett exempel på hur funktioner kan vara användbara i olika datavetenskapliga scenarier, kolla videon nedan:

Rekursion

Rekursion är en teknik inom programmering där en funktion anropar sig själv. Detta kan vara ett användbart sätt att lösa komplexa problem genom att dela upp dem i mindre, identiska delproblem.

När du skapar en rekursiv funktion måste du ha två saker i åtanke: basfallet och det rekursiva fallet. 

• Basfallet är det tillstånd som stoppar rekursionen
• Det rekursiva fallet är där funktionen anropar sig själv. Det rekursiva fallet fungerar som en iterator för funktionen

Följande exempel visar rekursiva funktioner i Python:

def factorial(n): om n == 1: return 1 return n * factorial(n - 1) factorial(5)

I det här exemplet är basfallet när n == 1, och funktionen returnerar 1. Det rekursiva fallet uppstår när n inte är lika med 1, och funktionen anropar sig själv med n - 1.

Vanliga fel och felsökning

Om du är en nybörjarprogrammerare kommer du ofta att stöta på fel när du implementerar funktioner som rekursiva och lambda-funktioner. Följande avsnitt belyser några vanliga fel och felsökningstips som hjälper dig att lösa dem effektivt.

1. TypeError: saknar ett obligatoriskt argument : Det här felet uppstår när du inte anger det korrekta antalet argument som funktionen förväntar sig.

def my_function(fname, lname): print(fname, lname) # Correct call my_function("John", "Doe") # Kommer att visa ett fel my_function("John")

För att åtgärda detta fel, se till att du skickar rätt antal argument till din funktion.

2. TypeError: operandtyp som inte stöds . Det här felet kan uppstå när du försöker använda en operatör med inkompatibla typer.

def add_number(a, b): returnera a + b # Korrekt anropsresultat = add_number(5, 3) print(result) # Ger ett fel på grund av felaktigt args resultat = add_number("5", 3) print(result)

För att åtgärda detta fel, kontrollera att dina funktioner hanterar rätt datatyper och överväg att använda typcasting om det behövs

3. NameError: namnet 'funktionsnamn' är inte definierat : Detta fel antyder att funktionen inte har definierats innan den anropades. 

# Korrekt ordning def greet(): print("Hej, där!") greet() # Felaktig ordning goodbye() def goodbye(): print("Goodbye!")

För att åtgärda detta fel, se till att din funktion är korrekt definierad och att du anropar den efter dess definition.

Slutsats

För att sammanfatta och hjälpa dig att befästa din förståelse, sammanfattar följande punkter de viktigaste aspekterna av att anropa funktioner i Python:

• För att anropa en funktion, använd funktionsnamnet följt av parenteser (t.ex. ) function_name().
• Om funktionen tar argument, inkludera dem inom parentes (t.ex. ) function_name(arg1, arg2).
• Du kan skapa dina egna funktioner med nyckelordet def, som definierar funktionens omfattning och eventuella nödvändiga argument.
• När du anropar en funktion som returnerar ett värde kan du tilldela resultatet till en variabel för senare användning (t.ex. ) result = function_name(args).