Python Funktionen & Module

6 Kernkonzepte

Die wichtigsten Konzepte für Funktionen und Module in Python: def · Parameter / *args / **kwargs · return · lambda · global / nonlocal · import / from / as / __name__ Funktionen strukturieren Code, machen ihn wiederverwendbar und testbar. Module erlauben die Organisation von Code in separaten Dateien und die Nutzung von Bibliotheken.

def – Funktionen definieren

def name(parameter): ...

def greet(name): print(f"Hallo, {name}!")

def definiert eine Funktion. Der Codeblock wird eingerückt und erst bei Aufruf ausgeführt. Funktionen können Parameter entgegennehmen und Werte zurückgeben.

Funktions-Definition

Bestandteil	Beschreibung
def	Schlüsselwort für Funktionsdefinition
name	Funktionsname (Bezeichner)
(...)	Parameterliste (optional)
:	Doppelpunkt nach der Signatur
Einrückung	4 Leerzeichen (PEP 8)

Beispiele

# Einfache Funktion:

def quadrat(x):

return x ** 2

# Funktion mit mehreren Parametern:

def summe(a, b, c):

return a + b + c

# Funktion mit Default-Werten:

def power(base, exp=2):

return base ** exp

# Aufruf:

print(quadrat(5)) # 25

print(power(3)) # 9

print(power(3, 3)) # 27

Tipp: Funktionen sollten nach PEP 8 mit Kleinbuchstaben und Unterstrichen benannt werden (z.B. meine_funktion). Docstrings mit """...""" dokumentieren die Funktion.

Parameter – *args, **kwargs & mehr

*args · **kwargs · Keyword-Only

def func(a, b, *args, c=0, **kwargs): # a, b: positional, *args: variable, c: keyword-only, **kwargs: variable keyword

Parameter-Arten: Positional, Keyword, Variable (*args) und beliebige Schlüsselwort-Argumente (**kwargs). Seit Python 3.8 gibt es auch Keyword-Only-Parameter.

Parameter-Arten

Syntax	Beschreibung
def f(a, b):	Positionale Parameter (Reihenfolge wichtig)
def f(a, b=0):	Default-Werte (optional)
def f(a, b, *args):	`*args` sammelt restliche positionale Argumente
def f(a, b, *, c):	Keyword-Only (c muss als Keyword übergeben werden)
def f(**kwargs):	`**kwargs` sammelt beliebige Keyword-Argumente

Beispiele

# *args: variable Anzahl von Argumenten:

def summe_aller(*args):

return sum(args)

# **kwargs: beliebige Keyword-Argumente:

def print_kwargs(**kwargs):

for key, value in kwargs.items():

print(f"{key}: {value}")

# Keyword-Only (ab Python 3.8):

def config(host, *, port, debug=False):

print(f"Host: {host}, Port: {port}, Debug: {debug}")

# Aufruf:

config("localhost", port=8080, debug=True)

print(summe_aller(1, 2, 3, 4)) # 10

Tipp: *args und **kwargs sind Konventionen – Sie können andere Namen verwenden, aber diese sind weit verbreitet und leicht verständlich.

return – Werte zurückgeben

return wert · return · return wert1, wert2

def add(a, b): return a + b # Ohne return wird None zurückgegeben

return beendet die Funktion und gibt einen Wert zurück. Ohne return oder mit return ohne Wert wird None zurückgegeben. Mehrere Werte werden als Tupel zurückgegeben.

Beispiele

# Einzelner Rückgabewert:

def quadrat(x):

return x ** 2

# Mehrere Rückgabewerte (Tupel):

def get_coordinates():

return 10, 20

# Frühzeitiges Beenden (Guard Clause):

def divide(a, b):

if b == 0:

return None

return a / b

# Kein return → None:

def do_nothing():

pass

# Aufruf:

x, y = get_coordinates()

print(do_nothing()) # None

Tipp: Eine Funktion sollte idealerweise einen einzigen Zweck haben und einen konsistenten Rückgabetyp liefern – das erleichtert Tests und Fehlersuche.

lambda – Anonyme Funktionen

lambda parameter: ausdruck

quadrat = lambda x: x ** 2 # Verwendung: quadrat(5) → 25

lambda erstellt eine anonyme Funktion in einer Zeile. Sie können nur einen Ausdruck enthalten (keine Statements) und werden oft für kurze Callbacks oder Schlüsselfunktionen verwendet.

Beispiele

# Einfache lambda:

add = lambda a, b: a + b

# Mit sorted() und key:

names = ["Anna", "Ben", "Clara"]

sorted_names = sorted(names, key=lambda x: len(x))

# Mit filter():

zahlen = [1, 2, 3, 4, 5, 6]

gerade = list(filter(lambda x: x % 2 == 0, zahlen))

# Mit map():

quadrate = list(map(lambda x: x**2, zahlen))

# Lambda in Dictionary:

ops = {

"add": lambda a, b: a + b,

"sub": lambda a, b: a - b

}

print(ops["add"](5, 3)) # 8

Tipp: Lambdas sind praktisch für einfache Operationen. Für komplexere Logik sollten Sie eine reguläre Funktion mit def definieren – das ist lesbarer und leichter zu testen.

global / nonlocal – Variablen-Scope

global x · nonlocal x

x = 10 # globale Variable def change(): global x x = 20

global erlaubt das Ändern einer globalen Variable innerhalb einer Funktion. nonlocal (für verschachtelte Funktionen) erlaubt das Ändern einer Variable im umschließenden Scope.

Beispiele

# global:

counter = 0

def increment():

global counter

counter += 1

# nonlocal (verschachtelte Funktion):

def outer():

x = "outer"

def inner():

nonlocal x

x = "inner"

inner()

print(x) # "inner"

# Lesen globaler Variablen (ohne global):

name = "Python"

def show():

print(name) # Funktioniert (lesen)

⚠️ Achtung: Vermeiden Sie global nach Möglichkeit – es macht Code schwerer verständlich und fehleranfällig. Nutzen Sie stattdessen Parameter und Rückgabewerte.

Module – import, from, as, name

import · from ... import · as · __name__

import math from datetime import datetime import json as j if __name__ == "__main__": ...

Module sind Python-Dateien, die Funktionen, Klassen und Variablen enthalten. Mit import werden sie in andere Skripte eingebunden. __name__ gibt den Modulnamen an.

Import-Varianten

Syntax	Beschreibung
import modul	Komplettes Modul importieren
import modul as alias	Mit Alias (kürzerer Name)
from modul import name	Nur bestimmte Namen importieren
from modul import *	Alle Namen importieren (vermeiden!)
import modul.submodul	Untermodul importieren

Beispiele

# Modul importieren und nutzen:

import math

print(math.pi)

print(math.sqrt(16))

# Mit Alias:

import numpy as np

# Bestimmte Namen importieren:

from datetime import datetime, timedelta

# __name__-Prüfung für ausführbare Skripte:

if __name__ == "__main__":

print("Skript wird direkt ausgeführt")

# Eigene Module:

# In utils.py: def greet(name): return f"Hallo {name}"

from utils import greet

Tipp: Die if __name__ == "__main__":-Guard erlaubt es, Code nur auszuführen, wenn das Skript direkt gestartet wird – nicht beim Import als Modul.