Sådan kalder du en funktion i Python: The Ultimate Guide

Funktioner er et væsentligt koncept i programmering, der gør det muligt for dig at administrere og genbruge kodeblokke. At vide, hvordan man kalder en funktion i Python er en nøglefærdighed at lære.

I denne øvelse lærer du det grundlæggende i opkaldsfunktioner sammen med nogle tips til at skrive effektiv kode, der er lettere at forstå.

Mastering-funktioner vil ikke kun hjælpe dig med at skabe mere alsidig kode, men også strømline din programmeringsproces og forbedre din overordnede effektivitet som udvikler.

Funktioner har de samme underliggende principper, og når du mestrer funktioner i Python, vil du være i stand til at udvide din forståelse af funktioner sammenlignet med andre programmeringssprog som Java, R, JavaScript, PHP osv.

Indholdsfortegnelse

• Hvad er en funktion?
• Definering af en funktion i Python
  • Funktions syntaks
  • Parametre og argumenter
    • Kwargs-argumentet
• Kaldning af en funktion
  • Grundlæggende funktion Kald
  • Positionelle argumenter
  • Søgeordsargumenter
• Returværdier
  • Enkelt returværdi
  • Flere returværdier
• Sender Python-funktioner som argumenter
• Indlejrede funktioner
• Lambda funktioner
• Rekursion
• Almindelige fejl og fejlfinding
• Konklusion

Hvad er en funktion?

En funktion i Python giver dig mulighed for at oprette genanvendelige kodestykker, der kan kaldes i hele dit program, hvilket forenkler din kode og forbedrer læsbarheden. Den udfører en bestemt opgave eller et sæt opgaver og kan kaldes flere gange i et program. 

Definering af en funktion i Python

Der er to hovedkategorier af funktioner i Python:

• Brugerdefinerede funktioner: Funktioner, som en programmør definerer for at undgå gentagelse af kode
• Indbyggede funktioner : Funktioner, der er defineret af en anden og kan bruges i din kode efter installation af de nødvendige pakker

Dette afsnit fokuserer på brugerdefinerede funktioner. Du lærer:

• Sådan defineres en funktion i Python
• Funktionens syntaks
• Sådan bruges parametre og argumenter

Funktions syntaks

Nøgleordet def , efterfulgt af funktionsnavnet og parenteser, giver dig mulighed for at definere en funktion i Python. Funktionens krop er indrykket og indeholder den kode, der skal udføres, når funktionen kaldes. Et eksempel på en grundlæggende funktion i Python er givet nedenfor:

def greet(): print("Hej, verden!") greet()

Nøgleordet def definerer en ny funktion med navnet greet. Den tredje kodelinje kalder på funktionen, som udfører koden inde i funktionen.

Linjen printi koden ovenfor er også en funktion. Men hvis du arbejder i et Python 2-miljø, er det defineret som et statement. Senere, i Python 3, blev det ændret fra sætning til en funktion.

Parametre og argumenter

Parametre er pladsholdere i funktionsdefinitionen, mens argumenter er de værdier, der sendes, når funktionen kaldes.

For at angive parametre skal du inkludere dem i parentesen af ​​funktionsdefinitionen, adskilt af kommaer, hvis der er flere parametre. Når du kalder en funktion, angiver du inputværdierne kaldet argumenter. Følgende eksempel viser, hvordan man definerer en funktion, der tager to parametre:

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

Udsagnet return i funktionens krop returnerer tilføjelsen af ​​de to argumenter, der er overført til den. Du kan tænke på det som en lommeregner, hvor du indtaster værdier og får det ønskede resultat til gengæld.

Efter at have defineret funktionen, kan vi kalde den med argumenter efter eget valg.

tilføje_numre(3, 5)

Kwargs-argumentet

kwargs er en forkortelse for "søgeordsargumenter" i Python. Det giver dig mulighed for at udvide en funktions fleksibilitet ved at tillade den, der ringer, at angive et hvilket som helst antal nøgleordsargumenter, når funktionen kaldes. Nøgleordsargumenterne sendes som en ordbog til funktionen.

I en funktionsdefinition kan du bruge den dobbelte stjernesyntaks **før parameternavnet til at acceptere nøgleordsargumenter.

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

I dette eksempel kwargs vil der være en ordbog, der indeholder nøgleordsargumenterne, der sendes til funktionen. Outputtet er vist på billedet nedenfor:

Kaldning af en funktion

At kalde en funktion betyder at udføre koden inde i funktionens krop. Der er fire typer funktionskald i Python:

• Grundlæggende funktion Kald
• Opkald med positionelle argumenter
• Opkald med søgeordsargumenter

Grundlæggende funktion Kald

Et grundlæggende funktionskald påkalder funktionen uden at sende nogen argumenter ind i funktionen. Efter at have defineret en funktion, kan du kalde den ved at bruge dens navn efterfulgt af parentes.

Hvis funktionen ikke tager nogen argumenter, vil parenteserne være tomme. Koden nedenfor er et eksempel på en grundlæggende funktion.

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

At køre koden ovenfor giver følgende output:

Positionelle argumenter

Positionelle argumenter er den mest almindelige type argument, og de sendes til funktionen i samme rækkefølge, som de er angivet. Følgende er et eksempel på et funktionskald med positionelle argumenter:

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

I eksemplet ovenfor welcome_message()tager funktionen et argument, name. Når du kalder denne funktion med argumentet John, vil den udskrive beskeden ved siden af ​​navnet.

Ovenstående kode giver følgende output:

Søgeordsargumenter

En anden måde at sende argumenter til en funktion på er ved at bruge nøgleordsargumenter. Nøgleordsargumenter giver dig mulighed for at angive navnet på parameteren sammen med dens værdi, hvilket gør koden mere læsbar og reducerer chancen for at sende argumenter i den forkerte rækkefølge. 

Eksemplet nedenfor bruger søgeordsargumenter til at kalde welcome_messagefunktionen:

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

I dette eksempel har vi defineret en funktion, welcome_message()der har to parametre, name, og message. Meddelelsesparameteren har et standardargument på Welcome to LuckyTemplates!Når vi kalder funktionen, bruger vi nøgleordsargumenter til at videregive værdien John, hvilket resulterer i outputtetWelcome to LuckyTemplates! John.

Returværdier

Når du arbejder med funktioner, vil du ofte gerne returnere resultatet af operationer inde i din funktions krop. Returværdier gør det muligt for en funktion at sende et resultat tilbage til den, der ringer. Ved at forstå, hvordan man arbejder med enkelte og flere returværdier, kan du forbedre funktionaliteten af ​​dine Python-programmer.

Enkelt returværdi

En enkelt returværdifunktion returnerer én værdi fra operationerne i en funktion.

Et eksempel på en enkelt returværdifunktion er givet nedenfor:

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

I eksemplet ovenfor tager funktionen get_greetinget navn, da dens funktionsargument kompilerer det og returnerer en personlig hilsen. Returværdien gemmes derefter i den variable hilsen og udskrives til konsollen.

Flere returværdier

Til tider vil du blive bedt om at returnere mere end én værdi fra en funktion i Python. For at opnå dette kan du bruge en tupel eller en liste til at ombryde returværdierne.

Følgende er et eksempel på funktion med flere returværdier i programmeringssproget Python.

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

I dette eksempel get_name_and_ageer en funktion, der returnerer en tupel med to værdier: a name og en age.

Du kan også returnere en . Funktionen nedenfor viser en listereturværdi fra en funktion.

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

I dette tilfælde tager funktionen calculate_areasto argumenter, height, og width, og returnerer en liste, der indeholder arealet af et rektangel og arealet af en trekant.

Sender Python-funktioner som argumenter

Python giver dig mulighed for at videregive funktioner som argumenter til andre funktioner. Når en funktion accepterer en anden funktion som et argument, omtales den som en højere-ordens funktion.

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

Indlejrede funktioner

Indlejrede funktioner er funktioner defineret i en anden funktion, også kendt som indre funktioner. Disse kan være nyttige, når du opretter lukninger og modulær kode. 

For at oprette en indlejret funktion skal du blot definere en funktion i en anden funktion:

def ydre_funktion(x, y): def indre_funktion(z): returner x + y + z resultat = indre_funktion(3) returnerer resultat # Kald den ydre funktion print(ydre_funktion(1, 2))

I eksemplet ovenfor er den indre_funktion defineret i den ydre_funktion. Den indre funktion har adgang til variablerne for den ydre funktion, så den kan udføre operationer på dem.

Lambda funktioner

Lambda-funktioner, også kendt som anonyme funktioner, er en måde at skabe små engangsfunktioner i Python. I datavidenskabsprojekter vil du ofte arbejde med Lambda-funktioner til at skabe effektive datastrukturer og pipelines.

For at oprette en lambda-funktion kan du bruge lambda-nøgleordet efterfulgt af en liste med argumenter, et kolon og derefter et udtryk. Udtrykket er, hvad lambda-funktionen vil returnere, når den kaldes. Følgende er et eksempel på lambda-funktion i Python:

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

I eksemplet ovenfor oprettede vi en lambda-funktion, der tager to argumenter ( a og b) og returnerer deres sum. Vi tildelte denne lambda-funktion til en variabel kaldet add.

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

• Som argumenter for funktioner af højere orden som map(), filter() og sorted().
• Som nøglefunktioner ved sortering af lister eller ordbøger.

Følgende eksempel viser brug af højere ordens funktion filter() med lambda:

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

I dette eksempel brugte vi en lambda-funktion til at definere filtreringskriterierne for filter()-funktionen. Lambda-funktionen kontrollerer, om et tal er lige, og filter()-funktionen returnerer en ny liste, der kun indeholder de lige tal.

For at se et eksempel på, hvordan funktioner kan være nyttige i forskellige datavidenskabelige scenarier, se videoen nedenfor:

Rekursion

Rekursion er en teknik i programmering, hvor en funktion kalder sig selv. Dette kan være en nyttig måde at løse komplekse problemer ved at opdele dem i mindre, identiske delproblemer.

Når du opretter en rekursiv funktion, skal du huske på to ting: basiscasen og den rekursive case. 

• Grundtilfældet er den tilstand, der stopper rekursionen
• Det rekursive tilfælde er, hvor funktionen kalder sig selv. Det rekursive kasus fungerer som en iterator for funktionen

Følgende eksempel viser rekursive funktioner i Python:

def factorial(n): hvis n == 1: returner 1 returner n * factorial(n - 1) factorial(5)

I dette eksempel er grundsagen når n == 1, og funktionen returnerer 1. Det rekursive tilfælde opstår, når n ikke er lig med 1, og funktionen kalder sig selv med n - 1.

Almindelige fejl og fejlfinding

Hvis du er nybegynder programmør, vil du ofte løbe ind i fejl, når du implementerer funktioner som rekursive og lambda-funktioner. De følgende afsnit fremhæver et par almindelige fejl og fejlfindingstip for at hjælpe dig med at løse dem effektivt.

1. TypeError: mangler et påkrævet argument : Denne fejl opstår, når du ikke angiver det korrekte antal argumenter, som funktionen forventer.

def my_function(fname, lname): print(fname, lname) # Korrekt kald min_funktion("John", "Doe") # Vil rejse en fejl min_funktion("John")

For at rette denne fejl skal du sørge for at sende det korrekte antal argumenter til din funktion.

2. TypeError: ikke-understøttet operandtype . Denne fejl kan opstå, når du forsøger at bruge en operator med inkompatible typer.

def add_number(a, b): returner a + b # Korrekt opkaldsresultat = add_number(5, 3) print(result) # Vil rejse en fejl på grund af forkert args resultat = add_number("5", 3) print(result)

For at rette denne fejl skal du kontrollere, at dine funktioner omhandler de rigtige datatyper, og overveje at bruge typecasting, hvis det er nødvendigt

3. NameError: navn 'funktionsnavn' er ikke defineret : Denne fejl antyder, at funktionen ikke er blevet defineret, før den blev kaldt. 

# Korrekt rækkefølge def greet(): print("Hej, der!") greet() # Forkert rækkefølge farvel() def farvel(): print("Farvel!")

For at rette denne fejl skal du sikre dig, at din funktion er defineret korrekt, og at du kalder den efter dens definition.

Konklusion

For at opsummere og hjælpe dig med at styrke din forståelse, opsummerer følgende punkter de vigtigste aspekter ved at kalde funktioner i Python:

• For at kalde en funktion skal du bruge funktionsnavnet efterfulgt af parenteser (f.eks. function_name()).
• Hvis funktionen tager argumenter, skal du inkludere dem i parentesen (f.eks. function_name(arg1, arg2)).
• Du kan oprette dine egne funktioner ved at bruge nøgleordet def, der definerer funktionens omfang og eventuelle påkrævede argumenter.
• Når du kalder en funktion, der returnerer en værdi, kan du tildele resultatet til en variabel til senere brug (f.eks. result = function_name(args)).