Python – 07 Funktionen und Methoden

Einführung

Funktionen kennst du aus der Mathematik. Man kann sagen: Es handelt sich dabei um Anweisungen, die für bestimmte Eingabewerte entsprechende Rückgabewerte haben¹.

f(x) = x² beispielsweise gibt für jeden Eingabewert x das Quadrat von x als Rückgabewert zurück, also x².

1
2
3

# Beispiel
def addiere(a, b):  # nehme Zahlen a und b an
    return a + b  # gib Summe von a und b zurück

Good to know: Je nach Kontext nennt man Funktionen in der Programmierung auch Methoden. Meinem Empfinden nach geschieht das selten konsistent. Den Begriff Methoden nutzt man eher in der Objektorientierten Programmierung, beim prozeduralen Stil – den wir gerade verfolgen – spricht man von Funktionen. Daher bleiben wir also erst einmal bei dem Begriff “Funktion”.

Zurück zum eigentlichen Thema: Was passiert oben in dem Code? Überlege, recherchiere vorher oder rate:

Funktionen machen das Leben leichter!

Das tolle an Funktionen ist, dass man sie nur einmal anlegen muss und dann immer wieder nutzen kann. Das Beispiel oben ist einfach, vielleicht zu einfach, um eine Funktion dafür zu anlegen? Selbst das ist in mancher Hinsicht sinnvoll, bspw. bei Objektorientierter Programmierung, wenn du Methoden einer Klasse formulierst. Doch so weit müssen wir nicht gehen, das folgende Beispiel sollte ganz schnell deutlich machen, warum es sinnvoll ist:

1
2
3
4
5
6
7

#Fakultät als rekursive Funktion
def fak(n):
    if n>0:
        return n*fak(n-1)
    else:
        return 1
print(fak(5))

Diese Funktion berechnet die Fakultät einer Zahl, Beispiel: 5! = 5·4·3·2·1 = 120 Du hast sicher keine Lust, so etwas jedes Mal neu einzugeben. Ist die Funktion einmal sauber implementiert, kannst du sie immer wieder verwenden. Du musst einfach nur die Funktion mit einem passenden Parameter aufrufen.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#Berechnet die Summe aller Zahlen von 1 bis n
def sum(n):
    if n>0:
        return n+sum(n-1)
    else:
        return 0

#Berechnet die Summe aller Zahlen von 1 bis n mithilfe des "Kleinen Gauß"
def kl_gauss(n):
    return int((n*(n+1))/2)

#Probiere beide Varianten mal aus
print(sum(13))
print(sum(20))
print(kl_gauss(13))

Was oben nach mathematischer Spielerei aussieht, ist ein sehr mächtiges Konzept. Eine Funktion ist besonders dann hilfreich, wenn sie mithilfe von Parametern auf verschiedene Bedingungen reagieren können muss. Noch ein Beispiel:

1
2

def gruss(name):
    print("Hallo "+name+", schön dich zu sehen!")

Fällt dir etwas an dieser Funktion auf? Es fehlt der return-Befehl! Das bedeutet, dass diese Funktion keinen Wert zurückgibt, sondern nur einen print-Befehl ausgibt. In einfachen Fällen ist das kein Problem, doch in der Regel sollte eine Funktion immer einen Wert zurückgeben. Denn dann kannst du damit weiterarbeiten. Beispiel:

1
2
3
4
5
6
7
8

def gruss(name):
    return "Hallo "+name+", schön dich zu sehen!"

a = gruss("Soraya") #Der Variable wird der Wert, den gruss("Soraya") zurückgegeben hat, zugewiesen.

print("Der Computer hat sie mit '"+a+"' gegrüßt. Dabei hat er",len(a),"Zeichen genutzt.") #a wird genutzt

print("Der Computer hat sie mit '"+gruss("Soraya")+"' gegrüßt.") #der direkte Abruf ist auch möglich

Parameter und Argumente

Der Eingabewert für Funktionen heißt Parameter, bei Methoden nennt man sie auch Argumente. Die Begriffe werden aber oft synonym verwendet, also Funktionen = Methoden und Parameter = Argumente. Wir machen uns da erst mal keine Gedanken. Wichtig ist jedoch das Folgende.

Sei func() eine Funktion in Python, dann gilt:

• func(param) hat den festen Parameter param, dieser muss eingegeben werden.
• func(*opt) hat den optionalen Parameter opt, dieser kann eingegeben werden.
• func(standard=“Mustermensch”) hat den Standardparameter standard. Die Funktion übernimmt den Standardwert, wenn nichts eingetragen wird.
• func(**kwargs) benutzt man, wenn man nicht weiß, wie viele Argumente mitgegeben werden. Der Fall ist etwas komplizierter.

Aufgaben

1
2
3
4
5
6
7
8

def steckbrief(name, alter, groesse, haarfarbe):
    return name+" ist "+str(alter)+" Jahre alt und "+str(groesse)+" cm groß. Seine Haarfarbe ist "+haarfarbe+"."

eren = steckbrief("Eren",15,165,"schwarz")
armin = steckbrief("Armin",14,150,"blond")

print(eren)
print(armin)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import turtle

s = turtle.getscreen()
t = turtle.Turtle()

t.right(90)
t.forward(100)
t.left(90)
t.backward(100)
t.goto(70, 70)

t.home()

turtle.done()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import turtle

s = turtle.getscreen()
t = turtle.Turtle()

t.pen(pencolor="purple", fillcolor="orange", pensize=10, speed=9)
t.begin_fill()
t.circle(90)
t.end_fill()

turtle.done()

1
2
3
4
5
6
7
8

import turtle
r = 90
s = turtle.getscreen()
t = turtle.Turtle()
while r > 10:
    t.circle(r)
    r -= 10
turtle.done()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

def schleifen(radius, runden):
    r = radius
    # s = turtle.getscreen()
    k = runden
    t = turtle.Turtle()
    if runden <= 0:
        exit()
    while k > 0:
        t.circle(r)
        r -= 10
        k -= 1
    turtle.done()

schleifen(80, 5)

Flask-Anwendung (Bonus)

Flask-Routen sind Funktionen!

Hast du schon mit Flask gearbeitet? Dann ist dir vielleicht aufgefallen: Flask-Routen sind Funktionen!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

from flask import Flask

app = Flask(__name__)

@app.route("/")  # Decorator: Verbindet URL "/" mit der Funktion
def home():      # Das ist eine Funktion!
    return "Hallo Welt!"

@app.route("/info")
def info():      # Noch eine Funktion!
    return "Das ist die Info-Seite"

1
2
3

@app.route("/gruss/<name>")
def gruss(name):  # Parameter wird aus URL übernommen
    return f"Hallo {name}!"

Lösung zeigen

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

from flask import Flask app = Flask(__name__) # Hilfsfunktion für Addition def addiere(a, b): return a + b @app.route("/rechner/<int:a>/<int:b>") def rechner(a, b): ergebnis = addiere(a, b) return f"{a} + {b} = {ergebnis}" if __name__ == "__main__": app.run(debug=True)

Erweiterung: Füge weitere Funktionen hinzu: subtrahiere(), multipliziere(), dividiere()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

from turtle import * # * steht für alles, so können wir die Funktionen direkt nutzen

t1 = Turtle()

def mandala(color1='blue', color2='red', speed='fastest'):
    t1.speed(speed)
    for i in range(18):  # 360/30 = 12
        t1.color(color1)
        t1.forward(50)
        t1.left(20)
        t1.circle(50)
        t1.color(color2)
        t1.circle(80)

mandala()

done()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import random

def nameAbfrage():
    return input("Wie heißt du?")

def zahlenRaten(start,ende):
    name = nameAbfrage()
    print("Hallo",name+"!","Lass uns spielen!")
    n = random.randint(start,ende)
    print("Ich habe mir eine Zahl zwischen",start,"und",ende,"ausgedacht!\n")
    eingabe = int(input("Rate mal!"))
    versuche = 1
    while eingabe != n:
        if eingabe < n:
            eingabe = int(input("Meine Zahl ist größer!\n Rate noch mal ..."))
        elif eingabe > n:
            eingabe = int(input("Meine Zahl ist kleiner!\n Rate noch mal ..."))
        versuche += 1
    else:
        if versuche == 1:
            print("Wow! Direkt erraten, kannst du zaubern?")
        else:
            print(n, " ist richtig! Du hast",versuche,"Versuche benötigt.")


zahlenRaten(4,56)

Zahlenraten als Web-App

Das Zahlenraten-Spiel aus Aufgabe 6 funktioniert in der Konsole. Mit Flask kannst du es in eine Web-App verwandeln!

Lösung zeigen

app.py:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81

from flask import Flask, render_template, request, session import random app = Flask(__name__) app.secret_key = "geheim123" # Für Sessions benötigt # Hilfsfunktion: Generiere Zufallszahl def neue_zahl(start: int, ende: int) -> int: """Generiert eine Zufallszahl zwischen start und ende.""" return random.randint(start, ende) # Hilfsfunktion: Prüfe Eingabe def pruefe_zahl(eingabe: int, zielzahl: int) -> str: """Vergleicht Eingabe mit Zielzahl. Gibt 'richtig', 'größer' oder 'kleiner' zurück.""" if eingabe == zielzahl: return "richtig" elif eingabe < zielzahl: return "größer" else: return "kleiner" @app.route("/") def home(): return render_template("home.html") @app.route("/ratespiel", methods=['GET', 'POST']) def ratespiel(): # Initialisiere Spiel (beim ersten Besuch) if 'zielzahl' not in session: session['zielzahl'] = neue_zahl(1, 100) session['versuche'] = 0 session['start'] = 1 session['ende'] = 100 if request.method == 'POST': aktion = request.form.get('aktion') # Neues Spiel starten if aktion == 'neu': session['zielzahl'] = neue_zahl(1, 100) session['versuche'] = 0 return render_template("ratespiel.html", nachricht="Neues Spiel gestartet! Rate eine Zahl zwischen 1 und 100.", versuche=0) # Zahl raten try: eingabe = int(request.form.get('zahl')) session['versuche'] += 1 ergebnis = pruefe_zahl(eingabe, session['zielzahl']) if ergebnis == "richtig": versuche = session['versuche'] # Spiel zurücksetzen session.pop('zielzahl', None) session.pop('versuche', None) return render_template("ratespiel_gewonnen.html", zahl=eingabe, versuche=versuche) elif ergebnis == "größer": nachricht = f"Die gesuchte Zahl ist GRÖẞER als {eingabe}! Versuch {session['versuche']}" else: # kleiner nachricht = f"Die gesuchte Zahl ist KLEINER als {eingabe}! Versuch {session['versuche']}" return render_template("ratespiel.html", nachricht=nachricht, versuche=session['versuche'], letzte_eingabe=eingabe) except ValueError: return render_template("ratespiel.html", nachricht="Bitte gib eine gültige Zahl ein!", versuche=session['versuche']) # GET-Request: Zeige Formular return render_template("ratespiel.html", versuche=session.get('versuche', 0)) if __name__ == "__main__": app.run(debug=True)

templates/ratespiel.html:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89

<!DOCTYPE html> <html lang="de"> <head> <meta charset="UTF-8"> <title>Zahlenraten</title> <style> body { font-family: Arial, sans-serif; max-width: 600px; margin: 50px auto; padding: 20px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); text-align: center; } .container { background: white; padding: 40px; border-radius: 15px; box-shadow: 0 10px 30px rgba(0,0,0,0.3); } h1 { color: #667eea; margin-bottom: 10px; } .nachricht { background: #fff3cd; color: #856404; padding: 15px; border-radius: 5px; margin: 20px 0; font-weight: bold; } .versuche { color: #666; font-size: 14px; margin-bottom: 20px; } input[type="number"] { width: 200px; padding: 15px; font-size: 24px; text-align: center; border: 3px solid #667eea; border-radius: 10px; margin: 20px 0; } button { padding: 15px 30px; margin: 10px; border: none; border-radius: 10px; font-size: 18px; cursor: pointer; font-weight: bold; } .btn-raten { background: #667eea; color: white; } .btn-neu { background: #95a5a6; color: white; } button:hover { opacity: 0.9; } </style> </head> <body> <div class="container"> <h1>Zahlenraten</h1> <p>Ich habe mir eine Zahl zwischen 1 und 100 ausgedacht!</p> <p class="versuche">Versuche: {{ versuche }}</p> {% if nachricht %} <div class="nachricht">{{ nachricht }}</div> {% endif %} <form method="POST"> <input type="number" name="zahl" min="1" max="100" placeholder="?" autofocus required value="{{ letzte_eingabe if letzte_eingabe else '' }}"> <br> <button type="submit" name="aktion" value="raten" class="btn-raten">Raten!</button> <button type="submit" name="aktion" value="neu" class="btn-neu">Neues Spiel</button> </form> </div> </body> </html>

templates/ratespiel_gewonnen.html:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71

<!DOCTYPE html> <html lang="de"> <head> <meta charset="UTF-8"> <title>Gewonnen!</title> <style> body { font-family: Arial, sans-serif; max-width: 600px; margin: 50px auto; padding: 20px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); text-align: center; } .container { background: white; padding: 40px; border-radius: 15px; box-shadow: 0 10px 30px rgba(0,0,0,0.3); } h1 { color: #4caf50; font-size: 48px; } .erfolg { background: #e8f5e9; color: #2e7d32; padding: 20px; border-radius: 10px; margin: 20px 0; font-size: 20px; } .emoji { font-size: 80px; } a { display: inline-block; margin-top: 20px; padding: 15px 30px; background: #667eea; color: white; text-decoration: none; border-radius: 10px; font-weight: bold; } a:hover { background: #5568d3; } </style> </head> <body> <div class="container"> <div class="emoji">OK</div> <h1>Gewonnen!</h1> <div class="erfolg"> <p><strong>Die Zahl war {{ zahl }}!</strong></p> <p>Du hast {{ versuche }} {% if versuche == 1 %}Versuch{% else %}Versuche{% endif %} benötigt.</p> {% if versuche == 1 %} <p>WOW! Beim ersten Versuch! Kannst du zaubern?</p> {% elif versuche <= 5 %} <p>Ausgezeichnet! Du bist sehr gut!</p> {% elif versuche <= 10 %} <p>Gut gemacht!</p> {% else %} <p>Geschafft! Übung macht den Meister.</p> {% endif %} </div> <a href="/ratespiel">Noch mal spielen!</a> </div> </body> </html>

Wichtige Konzepte:

• Hilfsfunktionen: neue_zahl() und pruefe_zahl() machen den Code übersichtlicher
• Sessions: Speichern Daten zwischen Anfragen (Zielzahl, Versuche)
• Funktionen aufrufen: Die Route-Funktion ratespiel() ruft die Hilfsfunktionen auf

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

## Wähle zufällig EINEN Namen aus einer Liste aus
namen = ["Olga","Tom","Tim","Anna","Ali","Beyza","Arya"] #Liste mit Namen

#Funktion: Zieht zufällig einen Namen aus einer Liste
def zieheName():
    i = random.randint(0,len(namen)-1) #wähle Index zwischen 0 und Länge des Arrays minus 1 aus
    return namen[i] #gib Namen mit Index i zurück

n1 = zieheName() # Übergebe Rückgabewert der Funktion an Variable n1
print(n1) #gib n1 in Konsole aus

Zufallsgenerator-App (Umfassend)

Jetzt kombinierst du alles, was du über Funktionen gelernt hast, in einer Flask-App!

Lösung zeigen

app.py:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101

from flask import Flask, render_template, request import random app = Flask(__name__) # ========== HILFSFUNKTIONEN ========== def generiere_zahlen(start: int, ende: int, anzahl: int) -> list[int]: """Generiert eine Liste mit Zufallszahlen.""" zahlen = [] for _ in range(anzahl): zahlen.append(random.randint(start, ende)) return zahlen def waehle_name(namen_liste: list[str]) -> str: """Wählt einen zufälligen Namen aus einer Liste.""" index = random.randint(0, len(namen_liste) - 1) return namen_liste[index] def erstelle_steckbrief(name: str, alter: int, groesse: int, haarfarbe: str) -> dict: """Erstellt einen Steckbrief als Dictionary.""" return { 'name': name, 'alter': alter, 'groesse': groesse, 'haarfarbe': haarfarbe, 'beschreibung': f"{name} ist {alter} Jahre alt, {groesse} cm groß und hat {haarfarbe}e Haare." } def wuerfeln(anzahl_wuerfel: int = 1) -> list[int]: """Würfelt mit einer bestimmten Anzahl an Würfeln.""" return [random.randint(1, 6) for _ in range(anzahl_wuerfel)] def generiere_zufalls_steckbrief() -> dict: """Generiert einen komplett zufälligen Steckbrief (nutzt andere Funktionen!)""" namen = ["Anna", "Ben", "Clara", "David", "Emma", "Felix", "Greta", "Hassan"] haarfarben = ["blond", "braun", "schwarz", "rot", "grau"] zufalls_name = waehle_name(namen) zufalls_alter = random.randint(10, 80) zufalls_groesse = random.randint(140, 200) zufalls_haarfarbe = waehle_name(haarfarben) return erstelle_steckbrief(zufalls_name, zufalls_alter, zufalls_groesse, zufalls_haarfarbe) # ========== ROUTEN ========== @app.route("/") def home(): return render_template("zufallsgenerator_home.html") @app.route("/zahlen", methods=['GET', 'POST']) def zahlen_generator(): zahlen = None summe = None durchschnitt = None if request.method == 'POST': start = int(request.form.get('start', 1)) ende = int(request.form.get('ende', 100)) anzahl = int(request.form.get('anzahl', 10)) zahlen = generiere_zahlen(start, ende, anzahl) summe = sum(zahlen) durchschnitt = round(summe / len(zahlen), 2) return render_template("zahlen_generator.html", zahlen=zahlen, summe=summe, durchschnitt=durchschnitt) @app.route("/name") def namen_generator(): namen = ["Alice", "Bob", "Charlie", "Diana", "Eve", "Frank", "Grace", "Henry"] gewaehlter_name = waehle_name(namen) return render_template("namen_generator.html", alle_namen=namen, gewaehlter_name=gewaehlter_name) @app.route("/steckbrief") def steckbrief_generator(): steckbrief = generiere_zufalls_steckbrief() return render_template("steckbrief_generator.html", steckbrief=steckbrief) @app.route("/wuerfel", methods=['GET', 'POST']) def wuerfel_generator(): ergebnisse = None gesamt = None if request.method == 'POST': anzahl = int(request.form.get('anzahl', 2)) ergebnisse = wuerfeln(anzahl) gesamt = sum(ergebnisse) return render_template("wuerfel_generator.html", ergebnisse=ergebnisse, gesamt=gesamt) if __name__ == "__main__": app.run(debug=True)

templates/zufallsgenerator_home.html:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92

<!DOCTYPE html> <html lang="de"> <head> <meta charset="UTF-8"> <title>Zufallsgenerator</title> <style> body { font-family: Arial, sans-serif; max-width: 800px; margin: 50px auto; padding: 20px; background: #f5f5f5; } h1 { color: #333; text-align: center; } .generators { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 20px; margin-top: 30px; } .generator-card { background: white; padding: 30px; border-radius: 10px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); text-align: center; transition: transform 0.2s; } .generator-card:hover { transform: translateY(-5px); box-shadow: 0 5px 20px rgba(0,0,0,0.2); } .generator-card a { text-decoration: none; color: inherit; } .icon { font-size: 48px; margin-bottom: 10px; } h3 { color: #667eea; margin: 10px 0; } p { color: #666; font-size: 14px; } </style> </head> <body> <h1>Zufallsgenerator</h1> <p style="text-align: center; color: #666;">Wähle einen Generator aus:</p> <div class="generators"> <div class="generator-card"> <a href="/zahlen"> <div class="icon">123</div> <h3>Zufallszahlen</h3> <p>Generiere Listen mit Zufallszahlen</p> </a> </div> <div class="generator-card"> <a href="/name"> <div class="icon">N</div> <h3>Namens-Wähler</h3> <p>Wähle einen zufälligen Namen</p> </a> </div> <div class="generator-card"> <a href="/steckbrief"> <div class="icon">S</div> <h3>Steckbrief</h3> <p>Generiere zufälligen Steckbrief</p> </a> </div> <div class="generator-card"> <a href="/wuerfel"> <div class="icon">W</div> <h3>Würfel</h3> <p>Würfle mit mehreren Würfeln</p> </a> </div> </div> </body> </html>

Weitere Templates (zahlen_generator.html, namen_generator.html, etc.) kannst du selbst gestalten!

Wichtige Konzepte in dieser App:

1. Viele Hilfsfunktionen: Jede Funktion hat eine klare Aufgabe
2. Funktionen rufen Funktionen auf: generiere_zufalls_steckbrief() nutzt waehle_name() und erstelle_steckbrief()
3. Code-Wiederverwendung: Die gleichen Funktionen werden in verschiedenen Routes genutzt
4. Strukturierter Code: Hilfsfunktionen oben, Routes unten