Articles
Introduktion till Python
Funktioner i Python

Funktioner i Python

Den här artikeln förklarar funktioner i Python.

YouTube Video

Funktioner i Python

Funktioner i Python är en viktig funktion för att definiera återanvändbara kodblock som gör att du kan organisera och förenkla ditt program genom att kalla dem vid behov. Att använda funktioner kan förbättra kodens läsbarhet och följa DRY-principen (Don't Repeat Yourself, undvik att skriva samma kod flera gånger).

Definiera Funktioner

Funktioner definieras med hjälp av nyckelordet def. Den grundläggande syntaxen är som följer:.

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

Till exempel, för att definiera en funktion som lägger till två tal, skulle du skriva:.

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

Anropa Funktioner

En definierad funktion kan anropas och användas enligt följande:.

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

Komponenter i en Funktion

  1. Funktionsnamn: Namnet på funktionen som används för att anropa den.

  2. Argument (Parametrar): Variabelnamn som tar emot data som skickas vid anropet. Du kan definiera noll eller flera argument.

  3. Dokumentationssträng (Docstring): En sträng som används för att beskriva syftet och användningen av en funktion. Valfritt.

  4. Funktionskropp: Ett indraget block där instruktionerna som funktionen utför skrivs.

  5. Returneringsvärde: Värdet som returneras till anroparen med hjälp av return-satsen. Om return utelämnas returneras None som standard.

Typer av Argument

I Python finns det flera typer av argument.

  1. Positionsargument: Det vanliga sättet att skicka argument till funktioner.
  2. Standardargument: Argument med standardvärden som kan utelämnas vid anrop.
1def greet(name, message="Hello"):
2    print(f"{message}, {name}")
3
4greet("Alice")  # "Hello, Alice"
5greet("Bob", "Good morning")  # "Good morning, Bob"
  1. Arguments med variabel längd: *args för att ta emot flera positionella argument som en tuple, och **kwargs för att ta emot dem som ett ordbok.
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}

Genom att använda funktioner korrekt kan du skriva Python-program mer effektivt och smidigt.

Lambda-funktioner i Python

I Python används lambda-funktioner för att definiera anonyma, kortfattade funktioner. Till skillnad från funktioner definierade med det vanliga nyckelordet def, tillåter lambda att skapa korta, enradiga funktioner. Här förklarar vi lambda-funktioner i Python i detalj.

Grunderna för lambda-funktioner

lambda-funktioner, även kallade anonyma funktioner, används för att definiera temporära funktioner som inte har något namn, precis som namnet antyder. Den grundläggande syntaxen är som följer:.

1lambda arguments: expression
  • arguments: Ange funktionens argument. Flera argument kan specificeras, separerade med kommatecken.
  • expression: Detta är ett uttryck som utvärderas baserat på argumenten. Resultatet av uttrycket blir funktionens returvärde.

Till exempel definierar och kör följande kod en lambda-funktion som lägger ihop två tal.

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

I det här exemplet är lambda x, y: x + y en lambda-funktion som tar två argument, x och y, och returnerar deras summa.

Användningsområden för lambda-funktioner

lambda-funktioner är användbara i situationer där du behöver definiera en enkel funktion direkt. De är särskilt vanliga i följande fall:.

  1. När de passeras som argument till funktioner

    • Den är användbar i högre ordningens funktioner (funktioner som tar andra funktioner som argument) när man skickar korta, temporära funktioner.

  2. När du anger nycklar för att sortera listor

    • De är praktiska för att ange sorteringskriterier (nycklar) i funktioner som sort() eller sorted().

Exempel på användning i högre ordningens funktioner

Typiska exempel på högre ordningens funktioner inkluderar map(), filter() och reduce(). Dessa funktioner tar andra funktioner som argument och tillämpar dem på sekvenser som listor.

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

I det här exemplet skickas en lambda-funktion till map()-funktionen för att kvadrera varje tal i en lista.

Exempel på listsortering

lambda-funktionen kan ibland användas för att specificera en anpassad nyckel när man sorterar en lista. Till exempel sorterar följande kod en lista av tupler baserat på det andra elementet.

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 detta exempel används en lambda-funktion för att sortera tuplerna baserat på deras andra element (en sträng).

filter() och lambda

filter()-funktionen används för att filtrera element i en lista (eller annan iterabel) baserat på ett visst villkor.

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 detta exempel filtreras jämna tal i en lista för att skapa en ny lista.

lambda och reduce()

reduce()-funktionen används för att reducera en lista till ett enda värde. Den kan enkelt implementeras med hjälp av 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 detta exempel multipliceras alla element i listan för att ge ett resultat.

Undvik att använda komplexa lambda-funktioner

Fördelen med lambda-funktioner är deras kortfattade syntax, men de blir svårare att läsa när de används för att implementera komplex logik. Därför är det lämpligt att använda dem för enkla operationer som kan uttryckas på en enda rad. För komplexa operationer är det mer läsbart och hanterbart att definiera en funktion med def.

Till exempel bör du undvika att använda komplexa lambda-funktioner som den nedan.

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

I detta fall är det bättre att använda en funktion definierad med def, som visas nedan.

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

Slutsats

Pythons lambda-funktioner är ett bekvämt verktyg för att definiera temporära, korta funktioner. De används ofta i högre ordningens funktioner eller listoperationer för att kortfattat definiera specifika villkor. Dock bör lambda-funktioner begränsas till enkla uppgifter, medan def-funktioner bör föredras för komplex logik.

Du kan följa med i artikeln ovan med hjälp av Visual Studio Code på vår YouTube-kanal. Vänligen kolla även in YouTube-kanalen.

YouTube Video

Bästa praxis för Pythons for-slinga