lehrkraefte:snr:informatik:glf22:python:funktionen-erster-versuch

Funktionen

Funktionen oder: Wie man grössere Programm übersichtlich gestaltet: teile und herrsche (divide et impera), modularer Entwurf, Baukastenprinzip.

Schau dir das folgende Video zu Funktionen an und löse die darin enthaltenen kleinen Aufgaben!

Video "Funktionen (Erklärungen mit Turtle-Grafik)"

Sprachliche Ungenauigkeit im Video: Beim Aufruf einer Funktion spricht man von Argumenten, nicht von Parametern. Wir erklären dies anhand der Funktion vieleck aus dem Video:

  • In der Definition dieser Funktion (die mit der Kopfzeile def vieleck100(n): beginnt) ist n ein Parameter.
  • Im Funktionsaufruf vieleck100(5) ist 5 das Argument.

Programme aus dem Video:

Zwischenzustand, Funktion dreieck100 ohne Parameter

Zwischenzustand, Funktion dreieck100 ohne Parameter

funktion-dreieck100-ohne-parameter
from turtle import *
 
def dreieck100():
    for i in range(3):
        forward(100)    
        left(120)
 
dreieck100()
forward(150)
dreieck100()
 
exitonclick()

Zwischenzustand, Funktionen dreieck100 und fuenfeck100 ohne Parameter

Zwischenzustand, Funktionen dreieck100 und fuenfeck100 ohne Parameter

funktionen-dreieck100-und-fuenfeck100-ohne-parameter
from turtle import *
 
def dreieck100():
    for i in range(3):
        forward(100)    
        left(120)
 
def fuenfeck100():
    for i in range(5):
        forward(100)    
        left(360/5)
 
dreieck100()
forward(150)
dreieck100()
forward(150)
fuenfeck100()
 
exitonclick()

Zwischenzustand, Funktion vieleck100 mit einem Parameter

Zwischenzustand, Funktion vieleck100 mit einem Parameter

funktion-vieleck100-mit-einem-parameter
from turtle import *
 
def vieleck100(n):
    for i in range(n):
        forward(100)    
        left(360/n)
 
vieleck100(3)
forward(150)
vieleck100(4)
forward(150)
vieleck100(5)
 
exitonclick()

Endzustand, Funktion vieleck mit zwei Parametern

Endzustand, Funktion vieleck mit zwei Parametern

funktion-vieleck-mit-zwei-parametern
from turtle import *
 
def vieleck(a, n):
    for i in range(n):
        forward(a)    
        left(360/n)
 
vieleck(75, 3)
forward(150)
vieleck(50, 4)
forward(150)
vieleck(100, 5)
 
exitonclick()

Schreibe ein neues Python-Programm, in dem eine Funktion mit einem Parameter quadrat(s) definiert wird. Diese Funktion soll ein Quadrat der Seitenlänge s zeichnen (und die Turtle soll nach dem Zeichnen denselben Zustand (= Position und Richtung) haben wie davor).

Verwende deine Funktion, um das folgende Bild zu erstellen! (Das kleinste Quadrat hat Seitenlänge 100, diese wächst von Quadrat zu Quadrat um 20, es gibt insgesamt n = 10 Quadrate.)

Teste und verstehe die folgenden Python-Programme:

(1) Funktion ohne Parameter:

def begruesse():
    print("Hallo!")
    print("Ich bin so ziemlich die einfachste Funktion, die man sich vorstellen kann:")
    print("Ich bekomme keinen Parameter (und liefere keinen Rückgabewert).")
 
begruesse()

(2) Funktion mit einem Parameter:

def begruesse(name):
    print("Hallo " + name + "!")
    print("Schön bist du hier, " + name + "!")
    print()
 
begruesse("Pinocchio")
begruesse("Papagena")
begruesse("Faust")

(3) Funktion ohne Parameter aber mit Rückgabewert.

Das folgende Beispiel einer Funktion mit einem Rückgabewert ist neu und sehr wichtig!

def begruesseUndErfrageNamen():
    print("Hallo!")
    name = input("Wie heisst du? ")
    return name
 
begruesseUndErfrageNamen()

Die Funktion gibt den Wert des Ausdrucks zurück, der hinter dem Wort return steht.

Die Ausführung der Funktion wird abgebrochen, sobald solch ein “return-Befehl” ausgeführt wird. Deswegen stehen solche Befehle (fast) immer ganz am Ende von Funktionsdefinitionen.

(4) Funktion mit einem Parameter und einem Rückgabewert.

Beachte: Die folgende Funktion wäre auch eine Funktion in der Mathematik.

def quadrat(x):
    return x*x
 
print(quadrat(12))
print(quadrat(13))
print(quadrat(14))

(5) Funktion mit zwei Parametern und einem Rückgabewert.

def addiere(x,y):
    return x + y
 
print(addiere(2, 5))
print(addiere(3, -0.8))

(6) Funktion mit einem Parametern und einem booleschen Rückgabewert (also True oder False).

def durch13teilbar(x):
    return x % 13 == 0
 
print(durch13teilbar(26))
print(durch13teilbar(15))
print(durch13teilbar(91))

(7) Die folgende Funktion prüft, ob eine Zahl dritte oder vierte Potenz einer einstelligen Zahl ist.

def dritteOderViertePotenz(x):
    istPotenz = False
    for i in range(10):
        if x == i**3 or x == i**4:
            istPotenz = True
    return istPotenz
 
print(dritteOderViertePotenz(343))
print(dritteOderViertePotenz(256))
print(dritteOderViertePotenz(81))
print(dritteOderViertePotenz(6561))

Mit dem Schlüsselwort def (für define) kann man Funktionen definieren. Wie man an den Beispielen unten sieht, ist die Syntax ähnlich wie bei Schleifen (for) und Bedingungen (if): Ein Doppelpunkt ist in der “Kopfzeile” nötig, der eigentliche Code der Funktion ist einzurücken.

Funktionen nehmen einen oder mehrere oder auch gar keinen Wert als Argument. Als Argumente sind integers, strings, Booleans etc. erlaubt. Funktionen können (müssen aber nicht) mit Hilfe des Schlüsselworts return einen Wert zurückgeben (so wie man das erwartet, wenn man an den Funktionsbegriff in der Mathematik denkt).

Funktionen haben einerseits den Zweck, sonst mehrfach auftauchenden Code zu bündeln; andererseits dienen sie der besseren Struktur/Lesbarkeit des Programms.

Öffne eine neues Python-Programm.

(1) Schreibe eine Funktion summeBis(n), die die Summe aller ganzen Zahlen von 1 bis $n$ als Rückgabewert zurückgibt. Teste sie, indem du summeBis(10) ausgibst (das Ergebnis sollte 55 sein; vgl. Gaußsche Summenformel).

(2) Schreibe eine Funktion summeQuadratzahlen(n), die die Summe aller Quadrate der ganzen Zahlen von 1 bis $n$ als Rückgabewert zurückgibt. Teste sie, indem du summeQuadratzahlen(10) ausgibst (das Ergebnis sollte 385 sein).

Öffne eine neues Python-Programm. (1) Schreibe eine Funktion istPrim(x), die entscheidet, ob der Parameterx eine Primzahl ist, und dementsprechend True oder False zurückgibt.

Hinweis

Hinweis

Variiere das Beispiel der Funktion istDritteOderViertePotenz(x) aus der vorigen Aufgabe. Wie ein Teilbarkeitstest geht, steht auch in dieser Aufgabe.

Subhinweis

Subhinweis

Definiere eine boolesche Variable istKandidat = True. Teste alle Zahlen von 2 bis x-1 (oder mindestens $\sqrt{x}$) darauf, ob sie ein Teiler von x sind. Sobald ein Teiler gefunden wurde, passe die Variable istKandidat entsprechend an.


(2) Nutze deine Funktion istPrim, um eine Liste aller Primzahlen bis n = 10000 auszugeben.

Hinweis: Damit nicht jede Primzahl in einer neuen Zeile steht: Der Befehl print(p, end = “, ”) gibt den Wert der Variablen p aus, danach ein Komma gefolgt von einem Leerschlag, und geht danach nicht in die nächste Zeile.

Ziel der Aufgabe ist, den kreisförmigen Mäander effizient zu zeichnen.

Da die rote Figur mehrfach vorkommt, ist es sinnvoll, diese Figur von einer Funktion zeichnen zu lassen.

  • (1) Definiere eine Funktion ornament() (ohne Parameter): Sie soll den roten Streckenzug zeichnen (links oben beginnend mit Blickrichtung der Turtle nach rechts; am Ende soll sie wieder nach rechts schauen). Hinweis: Die roten Teilstücke sind 60, 40 und 20 Pixel lang.
  • (2) Verwende deine Funktion und eine for-Schleife, um den folgenden Mäander zu zeichnen (alles soll einfarbig sein). Passe die Stiftdicke geeignet an.

  • (3) Ändere dein Programm so, dass der obige kreisförmige Mäander entsteht, der aus n = 23 Einzelmustern besteht (wieder alles einfarbig). Zum anfänglichen Positionieren der Turtle könnte die folgende Infobox nützlich sein.

Bonusaufgaben (bitte ausklappen)

Bonusaufgaben (bitte ausklappen)

Zeichne den folgenden rechteckigen Mänder mit Hilfe einer zusätzlichen Funktion eckbewegung(), die den orangen Teil des Musters zeichnet und viermal aufgerufen wird.

Zeichne ähnliche Muster! Zur Inspiration:

Die wichtigsten Zustandsparameter der Turtle sind ihre Position und ihre Blickrichtung (weniger wichtig sind Farbe und Stiftdicke etc.).

  • Ihre Position wird durch $x$- und $y$-Koordinate angegeben.
  • Ihre Blickrichtung wird durch einen Winkel in Grad angegeben: $0^\circ$: nach rechts; $90^\circ$: nach oben, $180^\circ$: nach links etc.

Das zugrunde liegende Koordinatensystem liegt zentriert im Standard-Turtle-Fenster: Sichtbar sind alle Punkte mit

  • x-Koordinaten zwischen -473 und +473 und
  • y-Koordinaten zwischen -398 und +398 (jedenfalls auf meinem Laptop).

Man kann die Turtle direkt in einen gewissen Zustand versetzen:

  • setposition(-100, 50) bewegt die Turtle auf den Punkt $(-100, 50)$. (Kürzer hat setpos(-100, 50) denselben Effekt.)
  • setheading(45) dreht man die Turtle so, dass ihre Blickrichtung zur positiven $x$-Achse einen Winkel von $45^\circ$ bildet bildet (in mathematisch positivem Drehsinn, also dem Gegenuhrzeigersinn), die Turtle schaut also nach rechts oben. (Kürzer hat seth(45) denselben Effekt.)

Alles vor dem roten Kasten sollte bekannt sein: https://www.w3schools.com/python/python_functions.asp

Exercises dazu (die ersten vier Fragen solltest du beantworten können): https://www.w3schools.com/python/exercise.asp?filename=exercise_functions1

Das Aufteilen einer grösseren Vorhabens in Teilvorhaben, die sogenannten Module, nennt man Modularisierung, auch modularen Entwurf oder Baukastenprinzip.

In der Informatik wird dies oft durch Funktionen bewerkstelligt. “Funktionen sind die Spezialisten beim Programmieren.”

Wir haben schon viele Funktionen kennengelernt und verwendet, z. B. print, input, forward, right, penup, setcolor, random.random.

Funktionen werden aufgerufen (Funktionsaufruf), indem man den jeweiligen Funktionsnamen angibt und danach in runden Klammern geeignete Argumente (= Übergabewerte) angibt.

Die runden Klammern sind beim Funktionsaufreu stets hinzuschreiben, auch wenn keine Argumente übergeben werden.

Beispiele:

  • pencolor(“red”) ist ein Aufruf der Funktion pencolor mit “red” als Argument.
  • penup() ist ein Aufruf der Funktion penup; diese Funktion nimmt keine Argumente entgegen.

Zum besseren Verständnis ist es sinnvoll, Funktionen in vier Arten einzuteilen, je nachdem, ob sie

  • Argumente benötigen oder nicht;
  • einen Rückgabewert zurückgeben oder nicht.

In der folgenden Tabelle ist für jeder dieser vier Arten ein Beispiel angegeben und darunter ein Aufruf der Funktion.

Funktionen ohne Parameter mit Parameter(n)
ohne Rückgabewert penup pensize
penup() pensize(10)
mit Rückgabewert random.random input
random.random() input(“Wie heisst du?”)

Grob gesagt kann man Aufrufe und Definitionen von Funktionen daran erkennen, dass nach ihnen ein Paar runder Klammern (mit oder ohne Argumente/Parameter dazwischen) auftaucht!

Beachte: Sogenannte Schlüsselworte wie for, if, else, while etc. sind keine Funktionen. Sie werden verwendet, um den Ablauf von Python-Programmen zu steuern.

Die Zusatzinformation, die sie entgegennehmen (etwa die Bedingung x == 2 in if x == 2:) wird bei gutem Programmierstil NICHT in runde Klammern eingeschlossen.

Also bitte nicht if(x==2): schreiben (auch wenn es keine Fehlermeldung gibt).

  • lehrkraefte/snr/informatik/glf22/python/funktionen-erster-versuch.txt
  • Last modified: 2022/11/15 08:42
  • by Olaf Schnürer