Funktioner i Python

Denne artikel forklarer funktioner i Python.

YouTube Video

Funktioner i Python

Funktioner i Python er en essentiel funktion til at definere genanvendelige kodeblokke, der giver dig mulighed for at organisere og forenkle dit program ved at kalde dem efter behov. Brug af funktioner kan forbedre kodens læsbarhed og overholde DRY-princippet (Don't Repeat Yourself, undgå at skrive den samme kode flere gange).

Definere funktioner

Funktioner defineres ved at bruge nøgleordet def. Den grundlæggende syntaks er som følger:.

1def function_name(arg1, arg2, ..., argN):
2    """docstring (A brief description of the function)"""
3    processing
4    return return_value

For eksempel, for at definere en funktion der lægger to tal sammen, kan du skrive:.

1def add(x, y):
2    """A function that adds two numbers and returns the result"""
3    return x + y

Kalder funktioner

En defineret funktion kan kaldes og bruges som følger:.

1result = add(3, 4)
2print(result)  # Output: 7

Komponenter i en funktion

1. Funktionsnavn: Navnet på funktionen, der bruges til at kalde den.

2. Argumenter (Parametre): Variabelnavne, der modtager data, der sendes under kaldet. Du kan definere nul eller flere argumenter.

3. Dokumentationsstræk (Docstring): En tekststreng brugt til at beskrive formålet og anvendelsen af en funktion. Valgfri.

4. Funktionskrop: En indrykket blok, hvor instruktioner, som funktionen udfører, skrives.

5. Returværdi: Værdien returneres til den kaldende ved hjælp af return-udsagnet. Hvis return udelades, returneres None som standard.

Typer af argumenter

I Python er der flere typer argumenter.

1. Positionelle argumenter: Den standardmåde, hvorpå argumenter sendes til funktioner.
2. Standardargumenter: Argumenter med standardværdier, der kan udelades under kaldet.

1def greet(name, message="Hello"):
2    print(f"{message}, {name}")
3
4greet("Alice")  # "Hello, Alice"
5greet("Bob", "Good morning")  # "Good morning, Bob"

3. Variabel-længde Argumenter: *args til at modtage flere positionelle argumenter som en tuple, og **kwargs til at modtage dem som en ordbog.

1def func(*args, **kwargs):
2    print("args:", args)
3    print("kwargs:", kwargs)
4
5func(1, 2, 3, a=4, b=5)
6# Output:
7# args: (1, 2, 3)
8# kwargs: {'a': 4, 'b': 5}

Ved at bruge funktioner korrekt kan du skrive Python-programmer mere effektivt og produktivt.

Lambda-funktioner i Python

I Python bruges lambda-funktioner til at definere anonyme, korte funktioner. I modsætning til funktioner defineret med det normale def-nøgleord tillader lambda dig at oprette korte, enkeltlinjefunktioner. Her vil vi forklare lambda-funktioner i Python i detaljer.

Grundlæggende om lambda-funktioner

lambda-funktioner, også kaldet anonyme funktioner, bruges til at definere midlertidige funktioner, der ikke har noget navn, som navnet antyder. Den grundlæggende syntaks er som følger:.

1lambda arguments: expression

• argumenter: Angiv funktionens argumenter. Flere argumenter kan specificeres, adskilt af kommaer.
• udtryk: Dette er et udtryk, der evalueres baseret på argumenterne. Resultatet af udtrykket bliver funktionens returværdi.

For eksempel definerer og udfører følgende kode en lambda-funktion, der lægger to tal sammen.

1add = lambda x, y: x + y
2print(add(5, 3))  # Output: 8

I dette eksempel er lambda x, y: x + y en lambda-funktion, der tager to argumenter, x og y, og returnerer deres sum.

Anvendelsesmuligheder for lambda-funktioner

lambda-funktioner er nyttige i situationer, hvor du har brug for at definere en simpel funktion på stedet. De er særligt almindelige i følgende tilfælde:.

1. Når de gives som argumenter til funktioner

   • Det er nyttigt i højere-ordens funktioner (funktioner, der tager andre funktioner som argumenter), når man overfører korte, midlertidige funktioner.

2. Når nøgler specificeres for at sortere lister

   • De er praktiske til at specificere sorteringskriterier (nøgler) i funktioner som sort() eller sorted().

Eksempel på brug i højere-ordens funktioner

Typiske eksempler på højere-ordens funktioner inkluderer map(), filter() og reduce(). Disse funktioner tager andre funktioner som argumenter og anvender dem på sekvenser som lister.

1numbers = [1, 2, 3, 4, 5]
2squared = list(map(lambda x: x ** 2, numbers))
3print(squared)  # Output: [1, 4, 9, 16, 25]

I dette eksempel gives en lambda-funktion til map()-funktionen for at kvadrere hvert tal i en liste.

Eksempler på brug af listesortering

lambda-funktionen kan nogle gange bruges til at angive en brugerdefineret nøgle ved sortering af en liste. For eksempel sorterer følgende kode en liste med tuples baseret på det andet element.

1pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
2pairs.sort(key=lambda pair: pair[1])
3print(pairs)
4# Output: [(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

I dette eksempel bruges en lambda-funktion til at sortere tuples baseret på deres andet element (en streng).

filter() og lambda

filter()-funktionen bruges til at filtrere elementer i en liste (eller en anden iterabel) baseret på en given betingelse.

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

I dette eksempel bliver lige tal i en liste filtreret for at skabe en ny liste.

lambda og reduce()

reduce()-funktionen bruges til at reducere en liste til en enkelt værdi. Det kan nemt implementeres ved hjælp af en lambda-funktion.

1from functools import reduce
2
3numbers = [1, 2, 3, 4, 5]
4product = reduce(lambda x, y: x * y, numbers)
5print(product)  # Output: 120

I dette eksempel multipliceres alle elementer i listen sammen for at give et resultat.

Undgå at bruge komplekse lambda-funktioner

Fordelen ved lambda-funktioner er deres kortfattethed, men de bliver sværere at læse, når de bruges til at implementere kompleks logik. Derfor er det passende at bruge dem til simple operationer, der kan udtrykkes på en enkelt linje. Til komplekse operationer er det mere læsbart og vedligeholdbart at definere en funktion med def.

For eksempel bør du undgå at bruge komplekse lambda-funktioner som den nedenfor.

1# Complex and hard-to-read lambda function
2complex_func = lambda x, y: (x * 2 + y) if x > y else (x + y * 2)

I dette tilfælde er det bedre at bruge en funktion defineret med def, som vist nedenfor.

1def complex_func(x, y):
2    if x > y:
3        return x * 2 + y
4    else:
5        return x + y * 2

Konklusion

Python's lambda-funktioner er et praktisk værktøj til at definere midlertidige, korte funktioner. De bruges ofte i højere-ordens funktioner eller listeoperationer til kortfattet at definere specifikke betingelser. Dog bø.

Du kan følge med i ovenstående artikel ved hjælp af Visual Studio Code på vores YouTube-kanal. Husk også at tjekke YouTube-kanalen.

YouTube Video