Zur Parametrisierung in Python

Paraphrasierung

main.py

def quadrat( x ): return x * x

auf deutsch

Um eine Zahl zu quadrieren, multipliziere sie mit sich selbst.

Falsche Anzahl an Argumenten

Wenn eine Funktion mit einem Parameter definiert wurde, muß sie dann auch mit einem Argument aufgerufen werden.

main.js

def gruesse( name ):
    print( 'Hallo ' + name + '!' )
gruesse()

Protokoll (frei übersetzt und gekürzt)

Typfehler: Es fehlt ein Ausdruck fuer den Parameter 'name'

Umgekehrt kann eine Funktion, die ohne Parameter definiert wurde, nicht mit einem Argument aufgerufen werden.

Protokoll (frei übersetzt und gekürzt)

def test():
  pass

test( 1 )

Typfehler: test() akzeptiert kein Argument

Verwendung von Etiketten

Bei allen in Python geschriebenen Funktionen, können immer Etikette für Argumente verwendet werden (wie »x=« unten).

main.py

def p( x ):
    print( x )
p( 2 )
p( x=2 )

Protokoll

2
2

Funktionen als Argumentwerte ⃗

Die im folgenden definierte Funktion »print_at_0« akzeptiert eine Funktion als Argumentwert und gibt deren Wert an der Stelle «0» aus.

Protokoll

def print_at_0( f ):
  print( f( 0 ))

from math import sin
from math import cos

Auswertung

print_at_0( sin )

0.0

Auswertung

print_at_0( cos )

1.0

Auswertung

print_at_0( lambda x: 2 * x )

Auswertung

print_at_0( lambda x: 2 + x )

Während eine lambda-Bindung mit »= lambda« als schlechter Stil gilt, gilt die Verwendung eines lambda-Ausdrucks in anderen Fällen, insbesondere als Argumentausdruck (wie oben), nicht als schlechter Stil.

lambda-Bindung Bindung einer lambda-Funktion an einen Namen

lambda-Funktion Wert eines lambda-Ausdrucks

lambda-Ausdruck ein mit »lambda« beginnender Ausdruck

Parametrische Polymorphie ⃗

(Fundamental Concepts in Programming Languages - Christopher Strachey (1967))

Eine Funktion kann Argumente verschiedener Typen akzeptieren.

Protokoll

def f( x ):
    print( x )

f( 2 )

f( 'abc' )

abc

Die Behandlung der Argumente kann von deren Typ abhängen.

Protokoll

def treble( x ):
    print( x * 3 )

treble( 2 )

treble( 'abc' )

abcabcabc

Beispiel ⃗

Im folgenden Programm sind alle Variablen lokal zu Funktionen (gut!).

Man kann jede Funktion einzeln verstehen.

Das große Programm wurde so effektiv in drei kleinere Unterprogramme und ein kleines Hauptprogramm zerlegt. Diese kleineren Programme sind jeweils einfacher zu verstehen als das vorige große Programm.

main.py

from winsound import Beep
from random import random
def sound( ist_quinte ):
    quintverhaeltnis = 3/2
    terzverhaeltnis = 5/4
    frequenzverhaeltnis = ist_quinte * quintverhaeltnis +( 1-ist_quinte )* terzverhaeltnis
    erste_frequenz_in_Hz = int( random() * 1000 + 110 )
    zweite_frequenz_in_Hz = int( erste_frequenz_in_Hz * frequenzverhaeltnis )
    dauer_in_millisekunden = 400
    Beep( erste_frequenz_in_Hz, dauer_in_millisekunden )
    Beep( zweite_frequenz_in_Hz, dauer_in_millisekunden )
def dialog( ist_quinte ):
    isteingabe = input( "War dies eine Quinte (q) oder eine grosse Terz (t)? " )
    print( 'Es war eine', ist_quinte * 'Quinte.' +( 1 - ist_quinte )* 'Terz.' )
    solleingabe = ist_quinte * 'q' +( 1 - ist_quinte )* 't'
    ist_richtig = isteingabe == solleingabe
    print( 'Ihre Antwort war', ist_richtig * 'richtig.' +( 1 - ist_richtig )* 'falsch' )
def runde():
    ist_quinte = int( random() * 2 ) # 1 = Quinte, 0 = keine Quinte (also eine Terz)
    sound( ist_quinte )
    dialog( ist_quinte )
runde()

Es ist nun leicht erkennbar, daß die lokalen Namen »quintverhaeltnis«, »terzverhaeltnis«, »frequenzverhaeltnis«, »erste_frequenz_in_Hz«, »zweite_frequenz_in_Hz« und »dauer_in_millisekunden« nur in der Funktion »sound« benötigt werden, wodurch das Programm etwas übersichtlicher ist. Genauso werden die Variablen »isteingabe«, »solleingabe« und »ist_richtig« nur in der Funktion »dialog« benötigt.

Bei Verwendung von Funktionen mit lokalen Namen ist es nicht nötig, diese lokalen Namen mit »del« zu entbinden, wenn sie nicht mehr benötigt werden, denn beim Ende des Ablaufs einer Funktion, werden alle lokalen Namen automatisch wieder entbunden.

Schließlich haben wir noch eine Modulvariable »ist_quinte«. Dies ist die einzige Information, welche von beiden Funktionen geteilt werden muß. Dies wird deutlich erkennbar, wenn die Modulvariable als Argumentwert an die beiden Funktionen übergeben wird, auch wenn sie sonst auch auf sie zugreifen könnten.

Namen, die lokal zu einer Funktion sind, sollten gegenüber anderen Arten von Namen bevorzugt verwendet werden.

Eine Funktion sollte Informationen bevorzugt über Parameter und Rückgaben (»return«) mit ihrer Umgebung austauschen und nicht durch direkten Zugriff auf Namen, die außerhalb jener Funktion angelegt wurden.

Fachsprache

Im folgenden nennen wir in den Aufgaben verwendete Fachverben und dann typischerweise damit verbundene Sprachelemente.

Tabelle

einlesen (eingeben) input

ausgeben print

zurueckgeben, ergeben, berechnen return

akzeptieren, uebergeben Parameter

Das heißt:

Wenn eine Funktion etwas einlesen soll: in der Funktion »input« verwenden.
Wenn der Bediener etwas eingeben können soll: »input« verwenden.
Wenn eine Funktion etwas ausgeben soll: in der Funktion »print« verwenden.
Wenn eine Funktion etwas zurückgeben soll: am Ende der Funktion »return« verwenden.
Wenn eine Funktion etwas ergeben soll: am Ende der Funktion »return« verwenden.
Wenn eine Funktion etwas berechnen soll: am Ende der Funktion »return« verwenden, um das Ergebnis der Berechnung zurückzugeben.
Wenn eine Funktion etwas als Argument akzeptieren soll: Parameter verwenden, um den Wert des Arguments entgegenzunehmen.
Wenn an eine Funktion etwas als Argument übergeben werden können soll: Parameter verwenden, um den übergebenen Wert des Arguments entgegenzunehmen.

Beispiele

Von der Funktion wird eine Zahl eingelesen.

def f():
    return int( input() )

Der Bediener kann eine Zahl eingeben.

zahl = int( input( "Zahl? " ))

Die Funktion gibt das Zeichen »5« aus.

def f():
    print( 5 )

Die Funktion gibt die Zahl «5» zurück.

def f():
    return 5

Die Funktion ergibt «5».

def f():
    return 5

Die Funktion berechnet die Summe von «2» und «3».

def f():
    return 2 + 3

Die Funktion akzeptiert eine Zahl als Argument

def f( zahl ):
    return 2 + zahl

Der Funktion kann eine Zahl als Argument übergeben werden

def f( zahl ):
    return 2 + zahl

Übungsfragen

? Übungsfrage 0

Welche Ausgabe würde die Ausführung des folgenden Quelltextes als Skript erzeugen?

(Der Quelltext soll zunächst nicht maschinell ausgeführt werden. Vielmehr soll – wie immer bei solche Übungsfragen – nur durch Lesen des Quelltextes vorhergesagt werden, welche Ausgabe erzeugt werden würde, wenn der Quelltext maschinell ausgeführt werden würde.)

Quelltext

def p( i ):
    print( i + 1 )

p( 4 ); p( 5 )

? Übungsfrage 1

Das folgende Protokoll wurde erstellt.

Protokoll

def f( name ):
    print( 'Hallo ' + name + '!' )

f( 'Mia' )

Hallo Mia!

Welche Ausgabe würde die Auswertung des Ausdrucks »f( 'Ben' )« ergeben?

? Übungsfrage 2

Welche Ausgabe erzeugt das folgende Skript?

Protokoll

def f( x ):
    print( 'f' )

def g():
    print( 'g' )
f( g() )

? Übungsfrage 3

Welchen Wert hat der Parameter »i« bei der Ausführung der Funktion »function« des folgenden Quelltext

Quelltext

def function( i ):
    pass

function( 2 + 3 )

? Übungsfrage 4

Welche Ausgabe erzeugt die Ausführung des folgenden Quelltextes?

Quelltext

def f( i ):
    return i + 2

print( f( 2 + 3 ))
print( f( 2 )+ f( 3 ))

? Übungsfrage 5

Welche Ausgabe erzeugt die Ausführung des folgenden Quelltextes?

Quelltext

def f( i ):
    print( i )
    return 2 * i

print( f( 2 + 4 ))

? Übungsfrage 6

Welche Ausgabe erzeugt die Ausführung des folgenden Quelltextes?

Quelltext

def f( i ):
    print( i + 5 )
    return i - 2

print( f( 3 + 4 ))

? Parameter und Argumente

Ein Parametername wird oft kurz als „Parameter“ bezeichnet. Ein Argumentausdruck wird oft kurz als „Argument“ bezeichnet.

Ist »i« in dem folgenden Quelltext ein Parameter oder ein Argument?

Ist »n + 1« in dem folgenden Quelltext ein Parameter oder ein Argument?

Quelltext

def inc( i ):
    i = i + 1

n = 2; inc( n + 1 ); print( n )

? Ausgabe einer Funktion

Was gibt die Funktion »f« aus?

(Genauer gefragt: Was würde die Auswertung eines Aufrufs der von der folgenden Funktionsdefinition definierten Funktion ausgeben?)

Funktionsdefinition

def f():
    print( 4 )
    return 9

Beispiel eines Aufrufs

x = f()

? Rückgabe einer Funktion

Was gibt die Funktion »f« zurück?

(Genauer gefragt: Welchen Wert würde die Auswertung eines Aufrufs der von der folgenden Funktionsdefinition definierten Funktion ergeben?)

Funktionsdefinition

def f():
    print( 7 )
    return 3

? Übungsfrage 7

Welche Ausgabe erzeugt die Ausführung des folgenden Quelltextes?

Quelltext

def f( i ):
    return i + 2 


print( f( 5 )); print( f( f( 5 )))

? Übungsfrage 8 ⃖

Der Aufruf der im folgenden definierten Funktion »doppelt« soll das Doppelte des Argumentwertes ergeben. Was muß dazu an der Stelle der Lücke »__________« stehen?

Quelltext mit Lücke

def doppelt( x ):
    __________

? Übungsfrage 9 ⃖

Welche der beiden am Ende des Quelltextes stehenden Zeilen ist zulässig?

Quelltext

def f0():
    return 12

def f1( i ):
    print( i )

f0( f1() )
f1( f0() )

? Übungsfrage 10

Was ist die Ausgabe des folgenden Quelltexts?

Quelltext

def f( i ):
    print( i )

a = 3; f( a )

? Übungsfrage 11

Was ist die Ausgabe des folgenden Quelltexts?

Quelltext

def f1( i ):
    print( i )

def f2():
    return 12

f1( f2() )

? Übungsfrage 12

Was ist die Ausgabe des folgenden Quelltexts?

Quelltext

def f1( i ):
    print( f2( i ))

def f2( i ):
    return i - 3

f1( 15 )

? Übungsfrage 13

Was ist die Ausgabe des folgenden Quelltexts?

Quelltext

def f( i ):
    print( i )

i = 2; j = 3; f( j )

? Übungsfrage 14

Was ist die Ausgabe des folgenden Quelltexts?

Quelltext

def f1( i ):
    print( 3 )
def f2():
    print( 4 )
    return 12
f1( f2() )

? Übungsfrage 15

Was ist die Ausgabe des folgenden Quelltexts?

Quelltext

def k( x ):
    return '(' + str( x )+ ')'
def p( x ):
    print( 'x = ' + k( x ))


p( 2 )

? Übungsfrage 16

Was ist die Ausgabe des folgenden Quelltexts?

Quelltext

def f( x ):
    print( x )
    return x
print( f( 4 )/ f( 1 )/ f( 2 ))

? Übungsfrage 17 *

Was ist voraussichtlich die Ausgabe des folgenden Programmes?

Quelltext

def f( x ):
    print( x )
    return x
print( f( 4 )** f( 1 )** f( 2 ))

Übungsaufgaben

Bei allen Übungsaufgabe, bei denen Eingaben mit Hilfe von „input()“ oder Übergaben (Argumentwerte) mit Hilfe von Parametern von einem Programmstück akzeptiert werden, reicht es wenn die erwarteten Eingaben oder Übergaben richtig verarbeitet werden. Das Programmstück braucht sich nicht in einer bestimmten Weise zu verhalten, wenn unerwartete oder sinnlose Werte eingegeben oder übergeben werden. Beispielsweise kann ein Programmstück, das zwei Zahlen summieren soll, davon ausgehen, daß es auch zwei Zahlen erhält (und keine Texte oder andere Arten von Werten).

Für alle Funktionsdefinitionen in diesem Kapitel soll »def« verwendet werden und nicht »= lambda«.

/ Umbenennung eines Parameters (Refaktor)

Benennen Sie den Parameter der Funktion »f« in dem folgenden Programm von »i« in »k« um. (Wir bezeichnen eine Eingabe hier auch als ein „Programm“.)

Es soll sich um einen Refaktor handeln, das heißt, die Ausgabe soll nicht verändert werden.

Hier soll eine Funktionsdefinition geschrieben werden, die eine Funktion definiert, die wie »f« unten verwendet werden kann, aber deren Parameter »k« heißt.

Quelltext

def f( i ):
    print( i )

a = 3; f( 3 )

Protokoll

/ Übungsaufgabe 0 ⃖

Quelltext

def gruesse( name ):
    print( 'Hallo ' + name + '!' )

gruesse( 'Mia' )

Protokoll

Hallo Mia!

Überarbeiten Sie das obenstehenden Hauptprogramm (den Teil am Ende des Programms, der kein Teil einer Funktionsdefinition ist) so, daß die folgende Ausgabe mit Hilfe der Funktion »gruesse« erzeugt wird.

Bei dieser Aufgabe darf nur das Hauptprogramm verändert werden. Das Hauptprogramm der Lösung darf nur Aufrufe enthalten, welche die Funktion »gruesse« aufrufen. Es darf keine Aufrufe der Funktion ›print‹ enthalten.

Das Hauptprogramm besteht aus allen Anweisungen, die keine Funktionsdefinitionen sind und nicht selber in einer Funktionsdefinition enthalten sind. Oben besteht das Hauptprogramm aus der letzten Zeile des Quelltextes »gruesse( 'Mia' )«.

erwartete Ausgabe

Hallo Mia!
Hallo Mia!
Hallo Mia!

/ Übungsaufgabe 1 ⃖

Quelltext

def gruesse( name ):
    print( 'Hallo ' + name + '!' )

gruesse( 'Mia' )

Protokoll

Hallo Mia!

erwartete Ausgabe

Hallo Mia!
Hallo Ben!
Hallo Lea!

/ Übungsaufgabe 2 ⃖

Überarbeiten Sie die Lösung der vorherigen Übungsaufgabe, indem Sie die Definition der Funktion »gruesse« so verändern, daß die folgende Ausgabe erzeugt wird. (Hierbei darf das Hauptprogramm nicht verändert werden.)

erwartete Ausgabe

Guten Tag, Mia!
Guten Tag, Ben!
Guten Tag, Lea!

/ Übungsaufgabe 3 ⃖

Überarbeiten Sie die Lösung der vorherigen Übungsaufgabe, indem Sie im Hauptprogramm den Wert jedes Aufrufs von ›gruesse‹ mit Hilfe von ›print‹ ausgeben.

erwartete Ausgabe (zur Kontrolle)

Guten Tag, Mia!
None
Guten Tag, Ben!
None
Guten Tag, Lea!
None

/ Übungsaufgabe 4 ⃖

Überarbeiten Sie die Lösung der vorherigen Übungsaufgabe, indem Sie in der Definition der Funktion »gruesse« zusätzlich noch den Wert «5» zurückgeben.

erwartete Ausgabe (zur Kontrolle)

Guten Tag, Mia!
5
Guten Tag, Ben!
5
Guten Tag, Lea!
5

/ Übungsaufgabe 5 (2 ′)

Überarbeiten Sie die Lösung der vorherigen Übungsaufgabe, indem Sie nicht mehr den Wert «5», sondern den Wert des Parameters zurückgeben. (Im Vergleich zur vorigen Übungsaufgabe soll das Hauptprogramm hier nicht verändert werden.)

erwartete Ausgabe (zur Kontrolle)

Guten Tag, Mia!
Mia
Guten Tag, Ben!
Ben
Guten Tag, Lea!
Lea

/ Übungsaufgabe 6

Überarbeiten Sie die Lösung der vorherigen Übungsaufgabe folgendermaßen:

Im Hauptprogramm sollen die Argumentausdrücke der drei Aufrufe nun »0«, »1« beziehungsweise »2« lauten.

Der Typ der Argumente soll nun also »int« sein.

Dazu muß die Definition der Funktion »gruesse« so angepaßt werden, daß sie auch int-Werte „begrüßen“ kann!

erwartete Ausgabe (zur Kontrolle)

Guten Tag, 0!
0
Guten Tag, 1!
1
Guten Tag, 2!
2

/ Übungsaufgabe 7 (Refaktor „Parameter umbenennen“) (2 ′)

Ändern Sie den Namen des Parameters »name« nun in »zahl«, so daß das Programm sich hinterher wieder genau so verhält wie vorher.

/ Übungsaufgabe 8

Überarbeiten Sie die Lösung der vorherigen Übungsaufgabe folgendermaßen:

Die Funktion »gruesse« soll »Guten Tag, «, das Doppelte des Argumentwertes und ein Ausrufezeichen »!« ausgeben (anstatt – wie bisher – »Guten Tag, «, den Argumentwert und ein Ausrufezeichen »!«), aber sich ansonsten weiterhin so verhalten wie bei der vorigen Übungaufgaben.

Wenn wir sagen, daß eine Funktion etwas machen soll, so bedeutet dies eigentlich, daß dies bei der Auswertung eines Aufrufs der Funktion geschehen soll.

erwartete Ausgabe (zur Kontrolle)

Guten Tag, 0!
0
Guten Tag, 2!
1
Guten Tag, 4!
2

/ Übungsaufgabe 9

Überarbeiten Sie die Lösung der vorherigen Übungsaufgabe folgendermaßen:

Die Funktion »gruesse« soll das Dreifache ihres Argumentwertes zurückgeben (anstatt wie bisher ihren Argumentwert), aber sich ansonsten weiterhin so verhalten wie bei der vorigen Übungaufgaben.

erwartete Ausgabe (zur Kontrolle)

Guten Tag, 0!
0
Guten Tag, 2!
3
Guten Tag, 4!
6

/ Übungsaufgabe 10

Überarbeiten Sie die Lösung der vorherigen Übungsaufgabe so, daß eine Auswertung eines Aufrufs der Funktion nichts mehr ausgibt und das Dreifache des Argumentwertes ergibt.

erwartete Ausgabe (zur Kontrolle)

0
3
6

/ Refaktor ⃖

An Stelle der beiden unterschiedlichen Funktionsdefinitionen soll eine Definition einer einzigen Funktion stehen, in der das, in dem sich die beiden Funktionen unterscheiden, durch einen Parameter ausgedrückt wird. Die beiden Aufrufe von »f« beziehungsweise »g« sollen alsdann durch zwei Aufrufe der neuen Funktion mit Argumentwerten so ersetzt werden, daß das neue Skript sich wie das untenstehende Skript verhält.

main.py

def f():
    print( 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + 'abcdefghijklmnopqrstuvwxyz' )
def g():
    print( 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + '0123456789' )
f()
g()

/ Übungsaufgabe 11

Schreiben Sie eine def-Definition einer Funktion »schreibX«, die ein Argument akzeptiert. Die Auswertung eines Aufrufs dieser Funktion soll die Zeichenfolge »x = «, den Argumentwert ihres Aufrufs und ein Zeilenende ausgeben (in dieser Reihenfolge). Diese Funktion soll keinen Wert zurückgeben (das heißt: sie soll ›None‹ zurückgeben).

erwartete Ausgabe (zur Kontrolle)

schreibX( 2 )

x = 2

schreibX( 2.3 )

x = 2.3

/ Übungsaufgabe 12

Schreiben Sie eine def-Definition einer Funktion »value«, so daß der Wert eines Aufrufs der Wert des Argumentausdrucks ist.

Mit „der Wert eines Aufrufs“ ist der Wert eines Auswertung eines Aufrufausdrucks gemeint.

erwartete Ausgabe (zur Kontrolle)

x = value( 2 )
print( x )

x = value( 2.3 )
print( x )

2.3

x = value( 'abc' )
print( x )

'abc'

/ Übungsaufgabe 13

Schreiben Sie eine def-Definition einer Funktion »println«, so daß die von einer einer Auswertung eines Aufrufs hervorgerufene Änderung die Ausgabe des Argumentwertes ist.

erwartete Ausgabe (zur Kontrolle)

_ = println( 2 )

_ = println( 2.3 )

2.3

_ = println( 'abc' )

abc

/ Übungsaufgabe 14

Schreiben Sie eine def-Definition einer Funktion »ignore«, die ein Argument akzeptiert, aber weder einen Wert hat noch eine Änderung bewirkt hat.

erwartete Ausgabe (zur Kontrolle)

ignore( 2 )
ignore( 2.3 )
ignore( 'abc' )

/ Übungsaufgabe 15

Schreiben Sie eine def-Definition einer Funktion »twice«, die das Doppelte ihres numerischen Argumentwertes zurückgibt.

erwartete Ausgabe (zur Kontrolle)

twice( 2 )

twice( 2.3 )

4.6

/ Übungsaufgabe 16

Schreiben Sie eine def-Definition einer Funktion »half«, die die Hälfte ihres numerischen Argumentwertes zurückgibt.

erwartete Ausgabe (zur Kontrolle)

half( 2 )

half( 2.3 )

1.15

/ Übungsaufgabe 17 ⃖

Schreiben Sie eine def-Definition einer Funktion »nachfolger_ausgeben«, die für ein ganzahliges Argument den Nachfolger (die nächstgrößere ganze Zahl) ausgibt.

Zur Kontrolle kann die folgende Anweisung ausgeführt werden.

Anweisung

_ = nachfolger_ausgeben( 2 )

Die Ausführung der Anweisung sollte die folgende Ausgabe bewirken

/ Übungsaufgabe 18 ⃖

Schreiben Sie eine def-Definition einer Funktion »nachfolger«, die für ein ganzahliges Argument den Nachfolger (die nächstgrößere ganze Zahl) zurückgibt.

(Diese Funktion soll keine Änderung bewirken und insbesondere nichts ausgeben.)

Die Auswertung des Ausdrucks »print( 'Ergebnis =', nachfolger( nachfolger( 5 )))« im Hauptprogramm sollte dann »Ergebnis = 7« ausgeben.

Ausdruck

print( 'Ergebnis =', nachfolger( nachfolger( 5 )))

Erwartete Ausgabe

Ergebnis = 7

/ Logarithmus Dualis ergeben

Schreiben Sie eine def-Definition einer Funktion »lb«, die einem Parameter »x« hat und bei Aufruf mit einer Zahl, den Logarithmus jener Zahl zur Basis 2 liefert. Verwenden Sie hierzu innerhalb der Suite die Funktion »log« aus dem Modul »math«. Prüfen Sie dann beispielsweise, daß »lb( 265 )« den Wert «8.0» ergibt.

(Diese Funktion soll keine Änderung bewirken und insbesondere nichts ausgeben.)

/ Logarithmus Dualis ausgeben

Schreiben Sie eine def-Definition einer Funktion »plb«, die einem Parameter »x« hat und bei Aufruf mit einer Zahl, den Logarithmus jener Zahl zur Basis 2 ausgibt. Verwenden Sie hierzu innerhalb der Suite die zuvor geschrieben Funktion »lb«.

(Ein Aufruf dieser Funktion soll den Wert »None« haben.)

/ Schreiben einer Funktionsdefinition mit einem Parameter (3)

Schreiben Sie eine def-Definition einer Funktion »f« (mit »def«), die wie die Funktion »f« nach der folgenden Bindung eines lambda-Wertes verwendet werden kann (sie soll also für gleiche Argumentwerte das gleiche Ergebnis liefern).

Bindung

f = lambda x: 12 * x

Anders gesagt: die Bindungsanweisung soll in eine entsprechende Funktionsdefinition „übersetzt“ werden.

/ Schreiben einer Bindung eines `lambda`-Wertes mit einem Parameter (4)

Schreiben Sie eine Bindungsanweisung, die einen lambda-Werte an den Namen »f« (ohne »def«) bindet, so daß »f« wie die Funktion »f« nach der folgenden Funktionsdefinition verwendet werden kann (beide »f« sollen also für gleiche Argumentwerte das gleiche Ergebnis liefern).

Funktionsdefinition

def f( z ):
  return z / 4

Anders gesagt: die Funktionsdefinition soll in eine entsprechende Bindung eines lambda-Wertes „übersetzt“ werden.

/ Übungsaufgabe 19

Schreiben Sie eine def-Definition einer Funktion »unterstreichen«, die einen Text unterstrichen ausgibt.

Gewünschte Ausgabe

_ = unterstreichen( 'abc' )

abc
---

_ = unterstreichen( 'alpha' )

alpha
-----

/ Übungsaufgabe 20

Schreiben Sie eine def-Definition einer Funktion »einrahmen«, die einen Text eingerahmt ausgibt.

Gewünschte Ausgabe

_ = einrahmen( 'abc' )

.-----.
| abc |
'-----'

_ = einrahmen( 'alpha' )

.-------.
| alpha |
'-------'

/ Übungsaufgabe 21 ⃖

Grundaufgabe

Schreiben Sie eine def-Definition einer Funktion »get«, die eine Zahl vom Bediener einliest und als int-Wert zurückgibt.

Hierfür darf angenommen werden, daß der Bediener immer ein ganzzahliges Numerale eingibt, das ohne Fehler in einen int-Wert umgewandelt werden kann. Es ist also egal, was passiert, wenn die Zeichenfolge nicht in eine ganze Zahl umgewandelt werden kann.

✕ Es gibt kein Testbeispiel (Aufrufbeispiel) zu dieser Aufgabe, da die Aufgabenstellung alleine bereits ausreichend verständlich ist und das Verständnis der in der Aufgabenstellung verwendeten Fachsprache geübt werden soll.

Zusatzanforderungen

Falls Sie die Grundaufgabe schon gelöst und noch Zeit haben, können Sie auch noch einige der folgenden Zusatzanforderungen bearbeiten:

Diese Funktion soll einen Text als Argument akzeptieren, der beim Start der Funktion als Abfragetext (Eingabeaufforderung) ausgegeben werden soll.
Die Funktion soll zunächst kurz piepen, bevor sie dann auf eine Eingabe wartet.
Schreiben Sie dann eine weitere Funktion, die eine ganze Zahl einliest und das Doppelte jener Zahl ausgibt.

/ Übungsaufgabe 22 ⃖

Grundaufgabe

Schreiben Sie eine def-Definition einer Funktion »read«, die eine Zahl vom Bediener einliest und als float-Wert zurückgibt.

Hierfür darf angenommen werden, daß der Bediener immer ein Numerale eingibt, das ohne Fehler in einen float-Wert umgewandelt werden kann. Es ist also egal, was passiert, wenn die Zeichenfolge nicht in eine Gleitkommazahl umgewandelt werden kann. Diese Funktion soll einen Text als Argument akzeptieren, der beim Start der Funktion als Abfragetext (Eingabeaufforderung) ausgegeben werden soll.

Zusatzanforderungen

Falls Sie die Grundaufgabe schon gelöst und noch Zeit haben, können Sie auch noch einige der folgenden Zusatzanforderungen bearbeiten:

Diese Funktion soll einen Text als Argument akzeptieren, der beim Start der Funktion als Abfragetext (Eingabeaufforderung) ausgegeben werden soll.
Die Funktion soll zunächst kurz piepen, bevor sie dann auf eine Eingabe wartet.
Schreiben Sie dann eine weitere Funktion, die eine Gleitkommazahl einliest und das Doppelte jener Zahl ausgibt.

/ Übungsaufgabe 23

Wir setzen die folgende Anweisung als Vorbereitung voraus.

Vorbereitungen

from turtle import *

Die im folgenden definierte Funktion »Dreieck« zeichnet ein gleichseitiges Dreieck.

Vorbereitungen

def Dreieck():
    forward( 99 ); left( 360/3 )
    forward( 99 ); left( 360/3 )
    forward( 99 ); left( 360/3 )

Schreiben Sie die Funktion so um, daß die Seitenlänge nicht mehr auf »99« festgelegt ist, sondern als Argumentwert übergeben werden kann.

Zeichnen Sie dann durch Aufruf dieser umgeschriebenen Funktion Dreiecke verschiedener Größe.

/ Übungsaufgabe 24

Schreiben Sie eine def-Definition einer Funktion, die ein gleichseitiges kleines Dreieck an eine bestimmte Position zeichnet (die Position soll durch zwei Zahlen, welche die Koordinaten des Punktes darstellen, als Argument übergeben werden können).

Zeichnen Sie dann durch Aufruf dieser Funktion Dreiecke an verschiedenen Positionen.

/ Übungsaufgabe 25

Schreiben Sie eine def-Definition einer Funktion, die ein gleichseitiges Dreieck einer bestimmten Größe an eine bestimmte Position zeichnet (die Position soll durch zwei Zahlen, welche die Koordinaten des Punktes darstellen, als Argument übergeben werden können, außerdem soll die Größe durch eine Zahl ausgedrückt werden, die ebenfalls als Argument übergeben wird).

Zeichnen Sie dann durch Aufruf dieser Funktion Dreiecke verschiedener Größen an verschiedene Positionen.

Lambdas zur genauen Kontrolle des Zeitpunktes der Auswertung *

Wir definieren zwei einfache Funktionen.

Protokoll

def f( x ):
  print( 'f'+ str( x ))
  return x

def g( x ):
  print( 'g'+ str( x ))
  return x

Im folgenden Beispiel werden beide Funktionen schon bei der Bindung an »v« aufgerufen.

Protokoll

v = f( g( 2 ))

g2
f2

Im folgenden Beispiel werden beide Funktionen erst beim Aufruf von »v« aufgerufen.

Protokoll

v = lambda: f( g( 2 ))
v()

g2

f2

2

v()

g2

f2

2

Durch einen geschickten Einsatz von lambda-Ausdrücken können wir es erreichen, daß »g« schon bei der Bindung an »v« aufgerufen wird, aber »f« erst bei einem Aufruf von »v«.

Protokoll

w = lambda x: lambda: f( x )
v = w( g( 2 ))

g2

# v ist nun lambda: f( 2 )
v()

f2

2

v()

f2

2

Hier eine direktere Variante, bei der »g« schon bei der Bindung an »v« aufgerufen wird, aber »f« erst bei einem Aufruf von »v«.

Protokoll

v =( lambda x: lambda: f( x ))( g( 2 ))

g2

# v ist nun lambda: f( 2 )
v()

f2

2

v()

f2

2

Verändern der Argumentvariablen? ⃗

Durch eine Bindung an einen Parameter wird eine etwaige Argumentvariable nicht berührt.

Protokoll

def clear( i ):
  i = 0


n = 2
clear( n )
print( n )

Hochzählen der Argumentvariablen? ⃗

Es ist nicht möglich, eine Funktion zu schreiben, welche die Argumentvariable erhöht.

Protokoll

def inc( i ):
  i = i + 1

n = 2
inc( n )
print( n )

Zur Parametrisierung in Python

Paraphrasierung

Falsche Anzahl an Argumenten

Verwendung von Etiketten

Funktionen als Argumentwerte ⃗

Parametrische Polymorphie ⃗

Beispiel ⃗

Fachsprache

Beispiele

Übungsfragen

? Übungsfrage 0

? Übungsfrage 1

? Übungsfrage 2

? Übungsfrage 3

? Übungsfrage 4

? Übungsfrage 5

? Übungsfrage 6

? Parameter und Argumente

? Ausgabe einer Funktion

? Rückgabe einer Funktion

? Übungsfrage 7

? Übungsfrage 8 ⃖

? Übungsfrage 9 ⃖

? Übungsfrage 10

? Übungsfrage 11

? Übungsfrage 12

? Übungsfrage 13

? Übungsfrage 14

? Übungsfrage 15

? Übungsfrage 16

? Übungsfrage 17 *

Übungsaufgaben

/ Umbenennung eines Parameters (Refaktor)

/ Übungsaufgabe 0 ⃖

/ Übungsaufgabe 1 ⃖

/ Übungsaufgabe 2 ⃖

/ Übungsaufgabe 3 ⃖

/ Übungsaufgabe 4 ⃖

/ Übungsaufgabe 5 (2 ′)

/ Übungsaufgabe 6

/ Übungsaufgabe 7 (Refaktor „Parameter umbenennen“) (2 ′)

/ Übungsaufgabe 8

/ Übungsaufgabe 9

/ Übungsaufgabe 10

/ Refaktor ⃖

/ Übungsaufgabe 11

/ Übungsaufgabe 12

/ Übungsaufgabe 13

/ Übungsaufgabe 14

/ Übungsaufgabe 15

/ Übungsaufgabe 16

/ Übungsaufgabe 17 ⃖

/ Übungsaufgabe 18 ⃖

/ Logarithmus Dualis ergeben

/ Logarithmus Dualis ausgeben

/ Schreiben einer Funktionsdefinition mit einem Parameter (3)

/ Schreiben einer Bindung eines lambda-Wertes mit einem Parameter (4)

/ Übungsaufgabe 19

/ Übungsaufgabe 20

/ Übungsaufgabe 21 ⃖

Grundaufgabe

Zusatzanforderungen

/ Übungsaufgabe 22 ⃖

Grundaufgabe

Zusatzanforderungen

/ Übungsaufgabe 23

/ Übungsaufgabe 24

/ Übungsaufgabe 25

Lambdas zur genauen Kontrolle des Zeitpunktes der Auswertung *

Verändern der Argumentvariablen? ⃗

Hochzählen der Argumentvariablen? ⃗

/ Schreiben einer Bindung eines `lambda`-Wertes mit einem Parameter (4)