lambda-Parameter in Python 

Programmieren heißt Funktionen schreiben.

Einleitendes Beispiel

Im Ausdruck, der hinter dem Doppelpunkt eines lambda-Ausdrucks steht, dürfen auch Namen ohne Wert  verwendet werden, wenn diese Namen vor dem Doppelpunkt angemeldet werden.

lambda-Ausdruck

lambda x: 2 * x

Der Ausdruck »2 * x« enthält den Platzhalter »x« – einen Name ohne Wert.

Solch ein Platzhalter wird Parameter  genannt.

Beim Aufruf einer Funktion wird der Wert des Parameters dann nachträglich durch den Argumentwert  festgelegt.

Eine Funktion, die das Doppelte ihres Argumentwertes (»x«) ergibt kann man als »lambda x: 2 * x« schreiben.

Auswertung

( lambda z: 2 * z )( 5 + 2 )

14

Oben ist »z« der Parameter  und «7» der Argumentwert. Die Inkarnation ist dann »2 * 7« mit dem Wert «14».

Syntax

Ein lambda-Ausdruck (λ-Ausdruck) besteht aus dem Wort »lambda«.

Vor dem Doppelpunkt kann ein Parametername durch Angabe eines gewöhnlichen Bezeichners festgelegt werden.

Ein „gewöhnlicher Bezeichner“ ist – vereinfacht gesagt – so etwas wie ein Wort, beispielsweise »x« oder »width«.

Neue, erweiterte Syntax (vereinfacht)

lambda-Ausdruck
                 .-----------------------------------.
                 |                                   |
     .------.    |   .--------------------------.    V     .-.     .----------.
--->( lambda )---'---| gewoehnlicher Bezeichner |----'--->( : )--->| Ausdruck |--->
     '------'        '--------------------------'          '-'     '----------'

Semantik

In einem lambda-Ausdruck, der vor dem Doppelpunkt »:« einen Parameternamen enthält, darf der Parameternamen in dem Ausdruck hinter dem Doppelpunkt »:« als Ausdruck verwendet werden.

Beim Aufruf einer Funktion wird eine Kopie der Funktion angelegt, die sogenannte Inkarnation  der Funktion.

In der Inkarnation einer lambda-Funktion ergibt eine Auswertung des Parameternamens den Wert des Arguments des Aufrufes.

Veranschaulichung einer Inkarnation der Funktion »( lambda x: 2 * x )« mit dem Argumentwert »[7]«

2 * 7

Einfacher, aber etwas weniger genau, kann man sagen: Der Parametername steht für den Argumentwert.

Der Argumentwert wird praktisch an die Stellen des Parameters eingesetzt. »2 * x« → »2 * 7« („β-Reduktion“).

Protokoll

2 * 7

14

Durch »lambda x« wird angegeben, daß es sich um eine Funktion handelt und welches der Name des Parameters ist (nämlich »x«).

Änderung des Parameternamens

Der Parametername kann frei gewählt werden („α-Konversion“, ein Refaktor).

Protokoll

( lambda x: 2 * x )( 7 )

14

Protokoll

( lambda y: 2 * y )( 7 )

14

Protokoll

( lambda number: 2 * number )( 7 )

14

Dabei ist aber zu beachten, daß nur gewöhnlicher Bezeichner als Parameternamen erlaubt sind und der gewählte Parameternamen an der Stelle der Verwendung nicht schon eine (andere) Bedeutung haben sollte.

Anforderungen an Aufrufe

Ein lambda-Ausdruck, der einen Parameter hat, muß auch mit einem Argument aufgerufen werden.

Protokoll (frei übersetzt und gekürzt)

( lambda x: x )()

Typfehler: Ein Argument für den Parameter 'x' fehlt.

Ein lambda-Ausdruck, der keinen  Parameter hat, darf auch nicht mit einem Argument aufgerufen werden.

Protokoll (frei übersetzt und gekürzt)

( lambda: 0 )( 2 )

Typfehler: Argument fuer parameterlosen lambda-Ausdruck angegeben.

»dir«

Wenn »dir« ohne Argumente aufgerufen wird, so ergibt es die Namen der Bindungstabelle der „Umgebung“, in der es sich befindet. Bei der Umgebung (dem Gültigkeitsbereich) kann es sich um ein Modul oder auch um einen lambda-Ausdruck handeln.

Innerhalb eines lambda-Ausdrucks ergibt »dir« die Parameternamen.

Protokoll

( lambda x: dir() )( 0 )

['x']

Übungsfragen

?   Übungsfragen

Können Sie die Werte der folgenden Ausdrücke vorhersagen?

Ausdruck

( lambda x: 4 )( 3 )

Ausdruck 1

( lambda x: x )( 9 )

Ausdruck 2

( lambda o: o )( 9 )

Ausdruck 3

( lambda x: 2 + x )( 3 )

Ausdruck 4

( lambda x: x + x )( 10 + 2 )

Ausdruck 5

( lambda x: x * 'abc' +( 1 - x )* 'def' )( 1 )

Ausdruck 6

( lambda x: x * 'abc' +( 1 - x )* 'def' )( 0 )

Ausdruck 7 *

( lambda x: lambda: x )( 2 )()

Ausdruck 8 *

( lambda x: lambda y: x - y )( 5 )( 8 )

Ausdruck 9 *

( lambda f: f( 2 ))( lambda x: x * x )

Ausdruck 10 *

( lambda f: lambda x: f( x ))( lambda x: x * x )( 3 )

Übungsfragen

?   Übungsfrage

Welche Werte haben die Aufrufe »g()« bei den folgenden Eingaben?

Eingaben

g = lambda: 2 + f( 3 )
f = lambda x: 10 * x
g()
f = lambda x: 100 * x
g()

Hinweis für den Dozenten  ► Bei Kursen mit dem traditionellen Ende (def und while), sollte die Übungszeit hier etwas begrenzt werden.

Übungsaufgaben

Mit lambda-Ausdrücken lassen sich Anforderungen an eine Berechnung klarer ausdrücken, weil es möglich ist, mit Hilfe des Parameters eine bestimmte Information darzustellen, ohne dieser schon einen konkreten Wert zu geben.

Bei den folgenden Übungsaufgaben geht es daher nicht nur darum, zu lernen, wie man den lambda-Operator verwendet. Es geht auch darum, die Verwendung verschiedener Sprachelementen aus früheren Lektionen zu üben, die man mit Hilfe von lambda-Ausdrücken besser üben kann als bisher. Insofern werden hier einige Übungen zu früheren Lektionen nachgeholt.

Bei allen Übungsaufgaben in diesem Kurs ist es auch erlaubt, eine Lösung aus mehreren  Zeilen abzugeben, die auch mehrere  Namen (Bindungen) anlegen, solange in einer bestimmten Aufgabe nichts Gegenteiliges gesagt wird.

/   Übungsaufgabe

Schreiben Sie eine Funktion namens »f«, deren Ergebnis stets «4» ist.

Wenn die Funktion richtig definiert wurde, sollten danach folgende Auswertungen beobachtbar sein.

Auswertung

f( 2 )

4

Auswertung

f( 2 )+ f( 3 )

8

Die Lösung sollte aussehen wie »f = lambda x: …«, wobei dann an Stelle der Ellipse noch etwas einzusetzen ist.

Test

t = lambda: f( 1 )== 4 and f( 'a' )== 4 and f( None )== 4
t()
True

/   Übungsaufgabe

Schreiben Sie eine Funktion namens »f«, deren Ergebnis der Wert ihres Arguments ist.

Wenn die Funktion richtig definiert wurde, sollten danach folgende Auswertungen beobachtbar sein.

Auswertung

f( 2 )

2

Auswertung

f( 2 )+ f( 3 )

5

Die Lösung sollte aussehen wie »f = lambda x: …«, wobei dann an Stelle der Ellipse noch etwas einzusetzen ist.

Test

t = lambda: f( 1 )== 1 and f( 'a' )== 'a' and f( None )== None
t()
True

/   Übungsaufgabe

Schreiben Sie eine Funktion namens »f«, deren Ergebnis um «7» größer ist als der Wert ihres Arguments.

Wenn die Funktion richtig definiert wurde, sollten danach folgende Auswertungen beobachtbar sein.

Auswertung

f( 2 )

9

Auswertung

f( 2 )+ f( 3 )

19

Die Lösung sollte aussehen wie »f = lambda x: …«, wobei dann an Stelle der Ellipse noch etwas einzusetzen ist.

Test

t = lambda: f( 1 )== 8 and f( 2 )== 9 and f( -7 )== 0
t()
True

/   Anwendung

Das Normalgewicht einer Person in Kilogramm ist die Körpergröße (in Metern) mal 100 minus 100.

Schreiben Sie eine Funktion, die aus der Körpergröße (in Metern, Typ ›float‹) das Normalgewicht (in Kilogramm, Typ ›float‹) berechnet.

(Das Normalgewicht ist nur für mittlere Körpergrößen Erwachsener anwendbar.)

Test

t = lambda n: 72.999999 < n( 1.73 )< 73.000001 and 87.999999 < n( 1.88 )< 88.000001 and 55.999999 < n( 1.56 )< 56.000001
t( n )
True

/   Übungsaufgabe

Schreiben Sie eine Funktion, die einen Text entgegennimmt und ihn einklammert.

Auswertung

f( 'abc' )

'(abc)'

Test

t = lambda f: f( '' )== '()' and f( 'a' )== '(a)' and f( '(' )== '(()' and f( 'abc' )== '(abc)'
t( f )
True

Schreiben Sie dann ein Programm, das einen Text einliest und eingeklammert wieder ausgibt, wobei zum Einklammern, die gerade geschriebene Funktion verwendet werden soll.

/   Eine Wirkfunktion

Schreiben Sie eine parameterlose Funktion namens »a«, bei deren Aufruf die Zahl 5 ausgegeben wird.

Wenn die Funktion richtig definiert wurde, sollten danach folgende Ausführungen beobachtbar sind.

Ausführung

_ = a()

5

Die Lösung sollte aussehen wie »a = lambda: …«, wobei dann an Stelle der Ellipse noch etwas einzusetzen ist.

/   Übungsaufgabe

Schreiben Sie eine Funktion namens »c«, welche die als Argument übergebene Funktion aufruft.

Ausführung

a = lambda: 22
c( a )

22

a = lambda: 19
c( a )

19

Die Lösung sollte aussehen wie »c = lambda f: …«, wobei dann an Stelle der Ellipse noch etwas einzusetzen ist.

/   Übungsaufgabe

Schreiben Sie eine Funktion namens »q«, die das Quadrat einer Zahl berechnet.

Das Quadrat  einer Zahl erhält man, indem man die Zahl mit sich selbst multipliziert.

Auswertung

q( 2 )

4

Auswertung

q( 3 )

9

Test

t = lambda q: q( 0 )== 0 and q( 2 )== 4 and q( 3 )== 9 and q( 2.5 )==6.25
t( q )
True

/   Übungsaufgabe

Schreiben Sie eine Funktion ›is_neg‹, die ›True‹ ergibt, wenn sie mit einer negativen Zahl aufgerufen wird.

Beispiel

is_neg( 5 )

False

is_neg( 0 )

False

is_neg( -3 )

True

Test

t = lambda: is_neg( -3 ) and( not is_neg( 5 )) and( not is_neg( 0 ))
t()
True

/   Übungsaufgabe

Schreiben Sie eine Funktion ›ok‹, die ›True‹ ergibt, wenn sie mit einer ganzen Zahl zwischen 1 (einschließlich) und 6 (einschließlich) aufgerufen wird. Wenn sie mit einer anderen ganzen Zahl aufgerufen wird, soll sie ›False‹ ergeben.

Beispiel

ok( 5 )

True

ok( 0 )

False

ok( -3 )

False

Test

t = lambda:( not ok( -3 ))and( not ok( 0 ))and ok( 1 )and ok( 3 )and ok( 6 )and( not ok( 7 ))and( not ok( 12 ))
t()
True

/   Teilbarkeitstest

Schreiben Sie eine Funktion namens »t«, deren Ergebnis angibt, ob der Argumentwert durch «7» teilbar ist.

Wenn die Funktion richtig definiert wurde, sollten danach folgende Auswertungen beobachtbar sein.

Auswertung

t( 6 )

False

Auswertung

t( 7 )

True

Die Lösung sollte aussehen wie »t = lambda n: …«, wobei dann an Stelle der Ellipse noch etwas einzusetzen ist.

Test

tt = lambda:( not t( 6 ))and( not t( 8 ))and( not t( 5 ))and( not t( 15 ))and t( 7 )and t( 14 )
tt()
True

/   Schaltjahrestest

Schreiben Sie eine Funktion namens »s«, deren Ergebnis angibt, ob der Argumentwert ein Schaltjahr ist.

Wenn die Funktion richtig definiert wurde, sollten danach folgende Auswertungen beobachtbar sein.

Auswertung

s( 1899 )

False

Auswertung

s( 1900 )

False

Auswertung

s( 1904 )

True

Auswertung

s( 1999 )

False

Auswertung

s( 2000 )

True

Auswertung

s( 2001 )

False

Auswertung

s( 2004 )

True

Die Lösung sollte aussehen wie »s = lambda j: …«, wobei dann an Stelle der Ellipse noch etwas einzusetzen ist.

Test

Schreiben Sie am besten zunächst einen Test (etwa nach dem Vorbild des Tests der vorigen Aufgabe).

/   Übungsaufgabe

Schreiben Sie eine Funktion namens »r12n«, die zu einer Zahl deren R12 -Verschlüsselung ergibt.

Bei der R12-Verschlüsselung wird 12 Zahlen vorwärts gegangen, wobei die Zahlen nach dem «23» wieder mit «0» beginnen.

So ist die R12-Verschlüsselung von «14» beispielsweise «2».

R12

              .-----------.
              |           v
0000000000111111111122220000000000111111111122220000000000111111111122220000000000111111111122220...
0123456789012345678901230123456789012345678901230123456789012345678901230123456789012345678901230...

Wenn die Funktion richtig definiert wurde, sollten danach folgende Auswertungen beobachtbar sein.

Auswertung

r12b( "a" )

'm'

Auswertung

r12b( "b" )

n

Auswertung

r12b( "n" )

b

Die Lösung sollte aussehen wie »r12b = lambda c: …«, wobei dann an Stelle der Ellipse noch etwas einzusetzen ist.

/   Alphabetische Position

Schreiben Sie eine Funktion namens »pos«, die zu einem kleinen Buchstaben dessen alphabetische Position bei der Numerierung a=0, b=1, c=2 und so weiter ergibt.

Wenn die Funktion richtig definiert wurde, sollten danach folgende Auswertungen beobachtbar sein.

Auswertung

pos( "a" )

0

Auswertung

pos( "b" )

1

Auswertung

pos( "c" )

2

Die Lösung sollte aussehen wie »pos = lambda s: …«, wobei dann an Stelle der Ellipse noch etwas einzusetzen ist.

/   Zeichen

Schreiben Sie eine Funktion namens »let«, die zu einer alphabetischen Position das Schriftzeichen ergibt.

Wenn die Funktion richtig definiert wurde, sollten danach folgende Auswertungen beobachtbar sein.

Auswertung

let( 0 )

'a'

Auswertung

let( 1 )

'b'

Auswertung

let( 2 )

'c'

Die Lösung sollte aussehen wie »let = lambda p: …«, wobei dann an Stelle der Ellipse noch etwas einzusetzen ist.

/   Übungsaufgabe

Schreiben Sie eine Funktion namens »r12b«, die zu einem kleinen Buchstaben dessen R12 -Verschlüsselung ergibt.

Bei der R12-Verschlüsselung wird 12 Buchstaben vorwärts gegangen, wobei das Alphabet nach dem »x« wieder mit »a« beginnt.

So ist die R12-Verschlüsselung von »o« beispielsweise »c«.

R12

              .-----------.
              |           v
abcdefghijklmnopqrstuvwxabcdefghijklmnopqrstuvwxabcdefghijklmnopqrstuvwxabcdefghijklmnopqrstuvwxa...
0000000000111111111122220000000000111111111122220000000000111111111122220000000000111111111122220...
0123456789012345678901230123456789012345678901230123456789012345678901230123456789012345678901230...

Wenn die Funktion richtig definiert wurde, sollten danach folgende Auswertungen beobachtbar sein.

Auswertung

r12b( "a" )

'm'

Auswertung

r12b( "b" )

n

Auswertung

r12b( "n" )

b

Die Lösung sollte aussehen wie »r12b = lambda c: …«, wobei dann an Stelle der Ellipse noch etwas einzusetzen ist.

/   Übungsaufgabe

Schreiben Sie eine parameterlose Funktion »number« zum Einlesen einer ganzen Zahl. Bei der Auswertung eines Aufrufs dieser Funktion soll die Implementation also auf eine Eingabe warten, und der Wert des Aufrufs soll dann die eingegebene Zahl mit dem Typ ›int‹ werden.

Konsolenprotokoll

number() + number()

2
3

5

Übersetzungshinweise

number  (hier) Zahl

Die Lösung sollte aussehen wie »number = lambda: …«, wobei dann an Stelle der Ellipse noch etwas einzusetzen ist.

Eine Funktion kann eine Abkürzung für ein bestimmtes wiederkehrendes Muster, wie die Kombination von ›int‹ und ›input‹ sein.

/   Übungsaufgabe

Binden Sie eine Funktion zur Berechnung einer Würfelzahl (Zufallszahl aus dem Bereich von 1 bis 6) an den Namen »w«. Bei jedem Aufruf von ›w‹ sollte dann eine unvorhersehbare ganze Zahl aus dem Bereich von 1 (einschließlich) bis 6 (einschließlich) erscheinen.

Beispiele

w()

4

w()

4

w()

2

/   Tick

Schreiben Sie eine Funktion namens »t«, deren Ergebnis die ihr übergebene Zahl als Zeichenfolge ist. Falls die Zahl durch 3 teilbar ist, soll das Ergebnis aber statt dessen das Wort „Tick“ sein.

Auswertung

t( 5 )

'5'

Auswertung

t( 6 )

'Tick'

/   TickTack

Schreiben Sie eine Funktion namens »tt«, deren Ergebnis die ihr übergebene Zahl als Zeichenfolge ist.

Falls die Zahl durch 3 teilbar ist, soll das Ergebnis aber statt dessen das Wort „Tick“ sein.

Falls die Zahl durch 5 teilbar ist, soll das Ergebnis das Wort „Tack“ sein.

Falls die Zahl aber durch 3 und durch 5 teilbar ist, soll das Ergebnis „TickTack“ lauten.

Auswertung

tt( 10 )

'Tack'

Auswertung

tt( 11 )

'11'

Auswertung

tt( 12 )

'Tick'

Auswertung

tt( 13 )

'13'

Auswertung

tt( 14 )

'14'

Auswertung

tt( 15 )

'TickTack'

/   Übungsaufgabe °

Schreiben Sie eine parameterlose Funktion »value()« zum Einlesen einer Zahl. Bei der Auswertung eines Aufrufs dieser Funktion soll die Implementation also auf eine Eingabe warten, und der Wert des Aufrufs soll dann die eingegebene Zahl mit dem Typ ›float‹ werden.

Konsolenprotokoll

value() + value()

2.2
3.0

5.2

Übersetzungshinweise

value  (hier) Wert, Zahl

/   Übungsaufgabe °

Schreiben Sie eine Funktion namens »exp2«, deren Ergebnis der Wert der Potenz mit zwei als Basis und dem Argumentwert als Exponent ist. Hier zu soll die Funktion »pow« oder der Operator »**« verwendet werden.

Wenn die Funktion richtig definiert wurde, sollten danach folgende Auswertungen beobachtbar sein.

Auswertung

exp2( 0 )

1

Auswertung

exp2( 1 )

2

Auswertung

exp2( 2 )

4

Auswertung

exp2( 4 )

16

/   lambda-Funktionen, die Änderungen hervorrufen °

Schreiben Sie eine lambda-Bindung (also eine Bindung einer lambda-Funktion an einen gewöhnlichen Bezeichner), so daß man danach eine Funktion namens »typ« verwenden kann, die den Typ ihres Argumentes ausgibt. Die folgenden vier Auswertungen sollen also in der Konsole die darunter angezeigten Ausgaben erzeugen.

Konsolenprotokoll

x = typ( 1 )

<class 'int'>

type( x )

<class 'NoneType'>

x = typ( 1.0 )

<class 'float'>

x = typ( '1' )

<class 'str'>

/   Übungsaufgabe °

Schreiben Sie einen lambda-Ausdruck in die Konsole, so daß danach die unten gezeigten Auswertungen mit »print« die unten gezeigten Ausgaben erzeugen.

Konsolenprotokoll (Auszug)

lambda …

<function <lambda> at 0x000000000…>

print( _( 2 ))

4

print( _( 3 ))

9

print( _( _( 2 )))

16

print( _( _( 3 )))

81

/   Übungsaufgabe °

Der Kehrwert einer Zahl ‹ x › ist definiert als ‹ 1/x ›.

Schreiben Sie eine Zeile, welche den gewöhnlichen Bezeicher »k« an eine Funktion zur Berechnung des Kehrwerts bindet, so daß «k» sich dann wie in den folgenden Beispielen verhält. (Hierzu kann »lambda« verwendet werden.)

Beispiele

k( 1 )

1.0

k( 2 )

0.5

k( 3 )

0.3333333333333333

Die Lösung sollte aussehen wie »f = lambda x: …«, wobei dann an Stelle der Ellipse noch etwas einzusetzen ist.

Test

t = lambda: k( 1 )== 1 and k( 2 )== 0.5 and k( 4 )== 0.25 and 0.333333 < k( 3 )< 0.3333334
t()
True

/   Übungsaufgabe

Schreiben Sie eine Funktion, die einen Text entgegennimmt und ihn verdreifacht.

Auswertung

f( 'abc' )

'abcabcabc'

Test

t = lambda f: f( '' )== '' and f( 'd' )== 'ddd' and f( 'abc' )== 'abcabcabc'
t( f )
True

/   Übungsaufgabe

Schreiben Sie eine Funktion, die einen Text entgegennimmt und ihn verdreifacht und einklammert.

Auswertung

f( 'abc' )

'(abcabcabc)'

Test

t = lambda f: f( '' )== '()' and f( 'd' )== '(ddd)' and f( 'abc' )== '(abcabcabc)'
t( f )
True

/   Übungsaufgabe

Schreiben Sie eine Funktion, die einen Text entgegennimmt, ihn einklammert, und das Ergebnis verdreifacht.

Auswertung

f( 'abc' )

'(abc)(abc)(abc)'

Test

t = lambda f: f( '' )== '()()()' and f( 'd' )== '(d)(d)(d)' and f( 'abc' )== '(abc)(abc)(abc)'
t( f )
True

/   Übungsaufgabe °

Binden Sie den Namen »r« an ein Objekt, so daß eine Auswertung eines Aufrufs von »r« eine Zufallszahl ergibt (bei jedem Aufruf von »r« soll sich eine andere Zufallszahl ergeben).

Der Aufruf soll hierbei ohne Argumentausdrücke erfolgen.

/   Übungsaufgabe °

Binden Sie den Namen »r« an ein Objekt, so daß eine Auswertung eines Aufrufs von »r« eine Zufallszahl ergibt (bei jedem Aufruf von »r« soll sich eine andere Zufallszahl ergeben).

Im Unterschied zur vorigen Übungsaufgabe soll der Aufruf diesmal mit einem Argumentausdruck erfolgen müssen, dessen Wert bei der Auswertung des Aufrufs allerdings ignoriert  werden soll.

/   Übungsaufgabe °

Binden Sie den Namen »r« an ein Objekt, so daß eine Auswertung eines Aufrufs von »r« eine Zufallszahl ergibt (bei jedem Aufruf von »r« soll sich eine andere Zufallszahl ergeben).

Der Aufruf soll mit einem Argumentausdruck erfolgen müssen, der eine Obergrenze für die zu erzeugende Zufallszahl angibt.

/   Übungsaufgabe °

Binden Sie den Namen »r« an ein Objekt, so daß eine Auswertung eines Aufrufs von »r« eine Zufallszahl ausgibt (bei jedem Aufruf von »r« soll eine andere Zufallszahl ausgegeben werden).

Der Aufruf soll hierbei ohne Argumentausdrücke erfolgen. Jeder Aufruf soll ›None‹ als Wert haben.

/   lambda-Funktionen zur Umrechnung ⃗

Bei einem System A wird die Helligkeit einer dunklen Lampe mit dem Wert 0 beschrieben, wenn die Lampe auf ihr Maximum gestellt wurde, hat ihre Helligkeit den Wert 1.

Bei dem System B wird die Helligkeit einer dunklen Lampe mit dem Wert 0 beschrieben, dem Maximum wird aber der Wert 255 zugeordnet (es handelt sich um dieselbe Lampe).

Daher entspricht der Helligkeit 1 im System A die Helligkeit 255 im System B, der Helligkeit 0,5 im System A die Helligkeit 127,5 im System B, und so weiter.

Schreiben Sie eine lambda-Funktion namens »b«, welche zu einem Argumentwert, der eine Helligkeit im System A angibt, die Helligkeit im System B ergibt.

/   Übungsaufgabe ⃗

Für die Angabe der Helligkeit eines Bildpunktes verwendet man manchmal ein System, bei dem «0.0» das Minimum und «1.0» das Maximum bedeutet. Oft wird aber auch ein System verwendet, bei dem «0x00» das Minimum und «0xFF» das Maximum bedeutet.

Schreiben Sie eine Funktion, die eine Angabe aus dem zweiten System in eine Angabe aus dem ersten System umwandelt.

Auswertung

i( 0x80 )

0.5019607843137255

Auswertung

i( 0x00 )

0.0

Auswertung

i( 0xFF )

1.0

/   Übungsaufgabe *

Schreiben Sie eine Funktion ›f‹, die eine Funktion ergibt, welche ihren Argumentwert um den Wert des Arguments der Funktion ›f‹ erhöht.

Auswertung

f( 2 )( 3 )

5

/   Hintereinanderausführung von Aufrufbarem *

Schreiben Sie eine Funktion »bind«, welche die Hintereinanderausführung ihrer beiden Argumentaufrufbaren ergibt, die dazu jeweils ein Argument akzeptieren sollten.

Beispiele

mem = bind( len, lambda x: x + 1 )
mem( "abc" )

4

Teilnehmerfrage: Warum wurde der Buchstabe „λ“ gewählt? ⃗

Der λ-Kalkül entstand in den 30er Jahren (des 20. Jahrhunderts). Damals wurde »lambda x: 2 * x« zunächst als ‹ 2x̂ › oder ‹ x̂: 2x › geschrieben. Aus dem Zirkumflex-Akzent ‹ ^ › entwickelte sich dann ein vorangestelltes ‹ λ › – vielleicht wegen Problemen beim Schriftsatz des ‹ x̂ ›. Nach einer anderen Quelle könnte es auch sein, daß Church das Symbol ‹ λ › mehr oder weniger willkürlich wählte, ohne einen speziellen Grund für die Wahl gerade dieses Symbols zu haben.