Funksjoner i Python

Denne artikkelen forklarer funksjoner i Python.

YouTube Video

Funksjoner i Python

Funksjoner i Python er en viktig funksjon for å definere gjenbrukbare kodeblokker, som lar deg organisere og forenkle programmet ditt ved å kalle dem når det trengs. Å bruke funksjoner kan forbedre kodelesbarhet og følge DRY-prinsippet (Don't Repeat Yourself, unngå å skrive samme kode flere ganger).

Definere funksjoner

Funksjoner defineres ved å bruke nøkkelordet def. Den grunnleggende syntaksen 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 å definere en funksjon som legger sammen to tall, skriver du:.

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

Bruke funksjoner

En definert funksjon kan kalles og brukes som følger:.

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

Komponenter i en funksjon

1. Funksjonsnavn: Navnet på funksjonen, brukes for å kalle den.

2. Argumenter (Parametere): Variabelnavn som mottar data som sendes inn under kall. Du kan definere null eller flere argumenter.

3. Dokumentasjonsstreng (Docstring): En streng brukt til å beskrive formålet og bruken av en funksjon. Valgfritt.

4. Funksjonskropp: En innrykket blokk hvor instruksjonene funksjonen utfører er skrevet.

5. Return-verdi: Verdien som returneres til kalleren ved bruk av return-setningen. Hvis return utelates, returneres None som standard.

Typer av argumenter

I Python finnes det flere typer argumenter.

1. Posisjonsargumenter: Den vanlige måten å sende argumenter til funksjoner på.
2. Standardargumenter: Argumenter med standardverdier som kan utelates under kall.

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

3. Variabel-lengde Argumenter: *args for å motta flere posisjonelle argumenter som en tuple, og **kwargs for å motta dem som en 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}

Ved å bruke funksjoner riktig kan du skrive Python-programmer mer effektivt og produktivt.

Lambda-funksjoner i Python

I Python brukes lambda-funksjoner til å definere anonyme, konsise funksjoner. I motsetning til funksjoner definert med det vanlige def-nøkkelordet, lar lambda deg lage korte, enlinje-funksjoner. Her skal vi forklare lambda-funksjoner i Python i detalj.

Grunnleggende om lambda-funksjoner

lambda-funksjoner, også kalt anonyme funksjoner, brukes til å definere midlertidige funksjoner som ikke har noe navn, som navnet antyder. Den grunnleggende syntaksen er som følger:.

1lambda arguments: expression

• arguments: Spesifiser funksjonens argumenter. Flere argumenter kan spesifiseres, adskilt med komma.
• expression: Dette er et uttrykk som evalueres basert på argumentene. Resultatet av uttrykket blir funksjonens returverdi.

For eksempel definerer og kjører følgende kode en lambda-funksjon som legger sammen to tall.

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

I dette eksempelet er lambda x, y: x + y en lambda-funksjon som tar to argumenter, x og y, og returnerer summen av dem.

Brukstilfeller for lambda-funksjoner

lambda-funksjoner er nyttige i situasjoner der du trenger å definere en enkel funksjon på stedet. De er spesielt vanlige i følgende tilfeller:.

1. Når de sendes som argumenter til funksjoner

   • Det er nyttig i høyere-ordens funksjoner (funksjoner som tar andre funksjoner som argumenter) når man sender korte, midlertidige funksjoner.

2. Når du spesifiserer nøkler for sortering av lister

   • De er nyttige for å spesifisere sorteringskriterier (nøkler) i funksjoner som sort() eller sorted().

Eksempel på bruk i høyere-ordens-funksjoner

Typiske eksempler på høyere-ordens-funksjoner inkluderer map(), filter() og reduce(). Disse funksjonene tar andre funksjoner 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 eksempelet sendes en lambda-funksjon til map()-funksjonen for å kvadrere hvert tall i en liste.

Eksempler på bruk av listesortering

lambda-funksjonen kan noen ganger brukes til å spesifisere en tilpasset nøkkel når man sorterer en liste. For eksempel sorterer følgende kode en liste med tupler basert på det andre 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 dette eksemplet brukes en lambda-funksjon til å sortere tuplene basert på deres andre element (en streng).

filter() og lambda

filter()-funksjonen brukes til å filtrere elementer i en liste (eller annen itererbar) basert på en gitt 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 eksemplet blir partall i en liste filtrert ut for å lage en ny liste.

lambda og reduce()

reduce()-funksjonen brukes til å redusere en liste til en enkelt verdi. Det kan enkelt implementeres ved bruk av en lambda-funksjon.

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 eksemplet multipliseres alle elementene i listen for å produsere et resultat.

Unngå å bruke komplekse lambda-funksjoner

Fordelen med lambda-funksjoner er deres kortfattethet, men de blir vanskeligere å lese når de brukes til å implementere kompleks logikk. Derfor er det passende å bruke dem for enkle operasjoner som kan uttrykkes på én linje. For komplekse operasjoner er det mer lesbart og vedlikeholdbart å definere en funksjon med def.

For eksempel bør du unngå å bruke komplekse lambda-funksjoner 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 tilfellet er det bedre å bruke en funksjon definert 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

Konklusjon

Pythons lambda-funksjoner er et praktisk verktøy for å definere midlertidige, korte funksjoner. De brukes ofte i høyere-ordens funksjoner eller listeoperasjoner for å konsist definere spesifikke betingelser. Imidlertid bør lambda-funksjoner begrenses til enkle oppgaver, mens def-funksjoner foretrekkes for kompleks logikk.

Du kan følge med på artikkelen ovenfor ved å bruke Visual Studio Code på vår YouTube-kanal. Vennligst sjekk ut YouTube-kanalen.

YouTube Video