Hvordan kalle en funksjon i Python: The Ultimate Guide

Funksjoner er et viktig konsept i programmering som lar deg administrere og gjenbruke kodeblokker. Å vite hvordan man kaller en funksjon i Python er en nøkkelferdighet å lære.

I denne opplæringen lærer du det grunnleggende om ringefunksjoner, sammen med noen tips for å skrive effektiv kode som er lettere å forstå.

Mestringsfunksjoner vil ikke bare hjelpe deg med å lage mer allsidig kode, men også strømlinjeforme programmeringsprosessen og forbedre din generelle effektivitet som utvikler.

Funksjoner har de samme underliggende prinsippene, og når du mestrer funksjoner i Python, vil du kunne utvide forståelsen av funksjoner sammenlignet med andre programmeringsspråk som Java, R, JavaScript, PHP, etc.

Innholdsfortegnelse

• Hva er en funksjon?
• Definere en funksjon i Python
  • Funksjonssyntaks
  • Parametre og argumenter
    • Kwargs-argumentet
• Kalle opp en funksjon
  • Grunnleggende funksjonsanrop
  • Posisjonsargumenter
  • Søkeordargumenter
• Returverdier
  • Enkel returverdi
  • Flere returverdier
• Sender Python-funksjoner som argumenter
• Nestede funksjoner
• Lambda funksjoner
• Rekursjon
• Vanlige feil og feilsøking
• Konklusjon

Hva er en funksjon?

En funksjon i Python lar deg lage gjenbrukbare kodebiter som kan kalles gjennom hele programmet, forenkle koden og forbedre lesbarheten. Den utfører en bestemt oppgave eller et sett med oppgaver og kan kalles flere ganger i et program. 

Definere en funksjon i Python

Det er to hovedkategorier av funksjoner i Python:

• Brukerdefinerte funksjoner: Funksjoner som en programmerer definerer for å unngå repetisjon av kode
• Innebygde funksjoner : Funksjoner som er definert av noen andre og kan brukes i koden din etter å ha installert de nødvendige pakkene

Denne delen av delen fokuserer på brukerdefinerte funksjoner. Du lærer:

• Hvordan definere en funksjon i Python
• Funksjonens syntaks
• Hvordan bruke parametere og argumenter

Funksjonssyntaks

Nøkkelordet def , etterfulgt av funksjonsnavnet og parenteser, lar deg definere en funksjon i Python. Funksjonskroppen er rykket inn og inneholder koden som skal utføres når funksjonen kalles. Et eksempel på en grunnleggende funksjon i Python er gitt nedenfor:

def greet(): print("Hello, World!") greet()

Nøkkelordet def definerer en ny funksjon med navnet hilse. Den tredje linjen med kode påkaller funksjonen, som utfører koden inne i funksjonen.

Linjen printi koden ovenfor er også en funksjon. Men hvis du jobber i et Python 2-miljø, er det definert som en uttalelse. Senere, i Python 3, ble det endret fra uttalelse til en funksjon.

Parametre og argumenter

Parametre er plassholdere i funksjonsdefinisjonen, mens argumenter er verdiene som sendes når funksjonen kalles.

For å spesifisere parametere, inkluderer du dem innenfor parentesene til funksjonsdefinisjonen, atskilt med kommaer hvis det er flere parametere. Når du kaller en funksjon, gir du inngangsverdiene kalt argumenter. Følgende eksempel demonstrerer å definere en funksjon som tar to parametere:

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

Utsagnet return i funksjonens kropp returnerer tillegget av de to argumentene som er sendt inn i den. Du kan tenke på det som en kalkulator, hvor du legger inn verdier og får ønsket resultat tilbake.

Etter å ha definert funksjonen, kan vi kalle den med argumenter etter eget valg.

add_numbers(3, 5)

Kwargs-argumentet

kwargs er en forkortelse for "søkeordargumenter" i Python. Den lar deg utvide en funksjons fleksibilitet ved å la innringeren spesifisere et hvilket som helst antall nøkkelordargumenter når funksjonen kalles opp. Nøkkelordargumentene sendes som en ordbok til funksjonen.

I en funksjonsdefinisjon kan du bruke den doble stjernesyntaksen **før parameternavnet for å godta nøkkelordargumenter.

def my_function(**kwargs): for nøkkel, verdi i kwargs.items(): print(f"{key} = {value}") my_function(a=1, b=2, c=3)

I dette eksemplet kwargs vil det være en ordbok som inneholder nøkkelordargumentene som sendes til funksjonen. Utgangen er vist på bildet nedenfor:

Kalle opp en funksjon

Å kalle en funksjon betyr å utføre koden inne i funksjonens kropp. Det er fire typer funksjonskall i Python:

• Grunnleggende funksjonsanrop
• Ringer med posisjonsargumenter
• Ringer med søkeordargumenter

Grunnleggende funksjonsanrop

Et grunnleggende funksjonskall påkaller funksjonen uten å sende noen argumenter inn i funksjonen. Etter å ha definert en funksjon, kan du kalle den ved å bruke navnet etterfulgt av parenteser.

Hvis funksjonen ikke tar noen argumenter, vil parentesene være tomme. Koden nedenfor er et eksempel på en grunnleggende funksjon.

def welcome_message(): print("Velkommen til LuckyTemplates!") welcome_message()

Å kjøre koden ovenfor gir følgende utgang:

Posisjonsargumenter

Posisjonsargumenter er den vanligste typen argument, og de sendes til funksjonen i samme rekkefølge som de er spesifisert. Følgende er et eksempel på et funksjonskall med posisjonsargumenter:

def welcome_message(name): print(f"Velkommen til LuckyTemplates, {name}!") welcome_message("John")

I eksemplet ovenfor welcome_message()tar funksjonen ett argument, name. Når du kaller denne funksjonen med argumentet John, vil den skrive ut meldingen ved siden av navnet.

Koden ovenfor gir følgende utgang:

Søkeordargumenter

En annen måte å sende argumenter til en funksjon på er å bruke nøkkelordargumenter. Nøkkelordargumenter lar deg spesifisere navnet på parameteren sammen med verdien, noe som gjør koden mer lesbar og reduserer sjansen for å sende argumenter i feil rekkefølge. 

Eksemplet nedenfor bruker nøkkelordargumenter for å kalle welcome_messagefunksjonen:

def welcome_message(name, message='Velkommen til LuckyTemplates!'): print(message, name) welcome_message(name='Alice', message='God morgen')

I dette eksemplet har vi definert en funksjon welcome_message()som har to parametere, nameog message. Meldingsparameteren har et standardargument på Welcome to LuckyTemplates!Når vi kaller funksjonen, bruker vi nøkkelordargumenter for å sende verdien John, noe som resulterer i utdataWelcome to LuckyTemplates! John.

Returverdier

Når du arbeider med funksjoner, vil du ofte returnere resultatet av operasjoner inne i funksjonens kropp. Returverdier lar en funksjon sende et resultat tilbake til den som ringer. Ved å forstå hvordan du arbeider med enkle og flere returverdier, kan du forbedre funksjonaliteten til Python-programmene dine.

Enkel returverdi

En enkelt returverdifunksjon returnerer én verdi fra operasjonene i en funksjon.

Et eksempel på en enkelt returverdifunksjon er gitt nedenfor:

def get_greeting(navn): returner "Hei, " + navn + "!" hilsen = get_greeting("Alice") print(hilsen)

I eksemplet ovenfor tar funksjonen get_greetinget navn ettersom funksjonsargumentet kompilerer det og returnerer en personlig hilsen. Returverdien lagres deretter i variabelhilsenen og skrives ut til konsollen.

Flere returverdier

Noen ganger vil du bli bedt om å returnere mer enn én verdi fra en funksjon i Python. For å oppnå dette kan du bruke en tuppel eller en liste for å pakke returverdiene.

Følgende er et eksempel på funksjoner med flere returverdier i programmeringsspråket Python.

def get_name_and_age(): return ("John", 30) navn, alder = get_name_and_age() print(name) print(age)

I dette eksemplet get_name_and_ageer en funksjon som returnerer en tuppel med to verdier: a name og en age.

Du kan også returnere en . Funksjonen nedenfor viser en listereturverdi fra en funksjon.

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

I dette tilfellet tar funksjonen calculate_areasto argumenter, height, og width, og returnerer en liste som inneholder arealet av et rektangel og arealet av en trekant.

Sender Python-funksjoner som argumenter

Python lar deg sende funksjoner som argumenter til andre funksjoner. Når en funksjon aksepterer en annen funksjon som et argument, blir den referert til som en høyere-ordens funksjon.

Koden nedenfor er et eksempel på å overføre en funksjon til en annen funksjon 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)

Nestede funksjoner

Nestede funksjoner er funksjoner definert innenfor en annen funksjon, også kjent som indre funksjoner. Disse kan være nyttige når du lager nedleggelser og modulær kode. 

For å lage en nestet funksjon, definer ganske enkelt en funksjon i en annen funksjon:

def ytre_funksjon(x, y): def indre_funksjon(z): returner x + y + z resultat = indre_funksjon(3) returner resultat # Kalle den ytre funksjonen print(ytre_funksjon(1, 2))

I eksemplet ovenfor er indre_funksjonen definert innenfor ytre_funksjonen. Den indre funksjonen har tilgang til variablene til den ytre funksjonen, slik at den kan utføre operasjoner på dem.

Lambda funksjoner

Lambda-funksjoner, også kjent som anonyme funksjoner, er en måte å lage små engangsfunksjoner i Python. I datavitenskapsprosjekter vil du ofte jobbe med Lambda-funksjoner for å lage effektive datastrukturer og pipelines.

For å lage en lambda-funksjon kan du bruke lambda-nøkkelordet etterfulgt av en liste med argumenter, et kolon og deretter et uttrykk. Uttrykket er hva lambda-funksjonen vil returnere når den kalles. Følgende er et eksempel på lambda-funksjon i Python:

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

I eksemplet ovenfor opprettet vi en lambda-funksjon som tar to argumenter ( a og b) og returnerer summen deres. Vi tilordnet denne lambda-funksjonen til en variabel kalt add.

Lambda kan være nyttig i følgende scenarier:

• Som argumenter for funksjoner av høyere orden som map(), filter() og sorted().
• Som nøkkelfunksjoner ved sortering av lister eller ordbøker.

Følgende eksempel viser bruk av høyere ordens funksjon filter() med lambda:

tall = [1, 2, 3, 4, 5, 6, 7, 8, 9] partall = liste(filter(lambda x: x % 2 == 0, tall)) print(partall) # Utdata: [2, 4, 6, 8]

I dette eksemplet brukte vi en lambda-funksjon for å definere filtreringskriteriene for filter()-funksjonen. Lambda-funksjonen sjekker om et tall er partall, og filter()-funksjonen returnerer en ny liste som kun inneholder partallene.

For å se et eksempel på hvordan funksjoner kan være nyttige i forskjellige datavitenskapelige scenarier, sjekk videoen nedenfor:

Rekursjon

Rekursjon er en teknikk i programmering hvor en funksjon kaller seg selv. Dette kan være en nyttig måte å løse komplekse problemer ved å dele dem opp i mindre, identiske delproblemer.

Når du oppretter en rekursiv funksjon, må du huske på to ting: grunntilfellet og det rekursive tilfellet. 

• Grunnfallet er tilstanden som stopper rekursjonen
• Det rekursive tilfellet er der funksjonen kaller seg selv. Det rekursive kasuset fungerer som en iterator for funksjonen

Følgende eksempel viser rekursive funksjoner i Python:

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

I dette eksemplet er grunntilfellet når n == 1, og funksjonen returnerer 1. Det rekursive tilfellet oppstår når n ikke er lik 1, og funksjonen kaller seg selv med n - 1.

Vanlige feil og feilsøking

Hvis du er en nybegynnerprogrammerer, vil du ofte støte på feil når du implementerer funksjoner som rekursive og lambda-funksjoner. De følgende delene fremhever noen vanlige feil og feilsøkingstips for å hjelpe deg med å løse dem effektivt.

1. TypeError: mangler et nødvendig argument : Denne feilen oppstår når du ikke oppgir riktig antall argumenter som funksjonen forventer.

def my_function(fname, lname): print(fname, lname) # Riktig kall min_funksjon("John", "Doe") # Vil gi en feilmelding min_funksjon("John")

For å fikse denne feilen, sørg for at du sender riktig antall argumenter til funksjonen din.

2. TypeError: operandtype som ikke støttes . Denne feilen kan oppstå når du prøver å bruke en operatør med inkompatible typer.

def add_number(a, b): returner a + b # Riktig anropsresultat = add_number(5, 3) print(result) # Vil gi en feil på grunn av feil args resultat = add_number("5", 3) print(result)

For å fikse denne feilen, sjekk at funksjonene dine omhandler de riktige datatypene, og vurder å bruke typecasting om nødvendig

3. NameError: navn 'funksjonsnavn' er ikke definert : Denne feilen antyder at funksjonen ikke har blitt definert før den ble kalt. 

# Riktig rekkefølge def greet(): print("Hei, der!") greet() # Feil rekkefølge goodbye() def goodbye(): print("Farvel!")

For å fikse denne feilen, sørg for at funksjonen din er riktig definert og at du kaller den etter definisjonen.

Konklusjon

For å oppsummere og hjelpe deg med å styrke forståelsen din, oppsummerer følgende punkter nøkkelaspektene ved å kalle funksjoner i Python:

• For å kalle en funksjon, bruk funksjonsnavnet etterfulgt av parenteser (f.eks. function_name()).
• Hvis funksjonen tar argumenter, inkluderer du dem innenfor parentesen (f.eks. function_name(arg1, arg2)).
• Du kan lage dine egne funksjoner ved å bruke nøkkelordet def, som definerer funksjonens omfang og eventuelle nødvendige argumenter.
• Når du kaller en funksjon som returnerer en verdi, kan du tilordne resultatet til en variabel for senere bruk (f.eks. result = function_name(args)).