Lösungen

Lösungen

Aufgabe: Ausdrücke und Zuweisungen

In Python gibt es unterschiedliche Arten von Werten, die man sich in der interaktiven Python-Umgebung anzeigen lassen kann.

>>> "Hallo"
'Hallo'
>>> "Hallo" + " " + "Python" + "!"
'Hallo Python!'
>>> 6*(3+4)
42
>>> 42 / 6
7.0
>>> 45 / 6
7.5
>>> 45 % 6
3
>>> 6 * 7 == 42
True
>>> 1 > 2
False
>>> True and not False
True
>>> 6 * 7 == 42 or 1 > 2
True
>>> str(42)
'42'
>>> str(6 * 7) == 42
False
>>> int(42)
42
>>> int("6 * 7")
6

Der Divisions-Operator (/) liefert als Ergebnis eine Fließkommazahl. Der Divisions-Operator (//) beschreibt eine ganzzahlige Division und liefert als Ergebnis eine Ganzzahl. Der Rest einer ganzzahlige Division wird mit dem Modulo-Operator (%) ermittelt

>>> 5//3
1
>>> 5%3
2
>>> 1/4
0.25
>>> 1.0/4
0.25
>>> 1/4.0
0.25
>>> 1.0/4.0
0.25

Die im Folgenden verwendeten arithmetischen Ausdrücke werden bei fehlender Klammerung linksassoziativ ausgewertet:

>>> 1-2-3
-4
>>> 1-(2-3)
2
>>> (1-2)-3
-4
>>>45/6/2
3.75
>>>45/(6/2)
15.0
>>> (45/6)/2
3.75

Potenzierung bindet stärker als Multiplikation und Division:

>>> 2*3**4
162
>>> 2*(3**4)
162
>>> (2*3)**4
1296
>>> 128/2**3
16.0
>>> 128/(2**3)
16.0
>>> (128/2)**3
262144.0

Durch Zuweisungen lassen sich Werte in Variablen speichern. Es gibt auch vordefinierte Werte.

import math
>>> text = "Hallo"
>>> text + text + text
"HalloHalloHallo"
>>> math.pi
3.141592653589793
>>> radius = 3
>>> umfang = 2 * math.pi * radius
>>> umfang
18.84955592153876

Aufgabe: Programme ergänzen

Hier sind ergänzte Varianten der gezeigten Programme:

a)

zahl = 41

zahl = zahl + 1    # diese Zeile ergänzen oder korrigieren

print(zahl)

b)

wort = "40"

zahl = 2    # hier eine Zeile einfügen

print(int(wort) + zahl)

c)

wort = "2"

zahl = 4    # hier eine Zeile einfügen

print(str(zahl) + wort)

d)

zahl = 41

zahl = zahl + 1    # diese Zeile ergänzen oder korrigieren

print(zahl)

e)

x = 6

result = x * 7    # diese Zeile ergänzen oder korrigieren

print(result)

f)

x = 6
s = str(5 * x)

ergebnis = int(s) + 2*x    # diese Zeile ergänzen oder korrigieren

print(ergebnis)

g)

zwei = 2
vierzig = 40

und = 0    # hier eine Zeile einfügen

print(zwei + und + vierzig)

h)

zwei = "2"
vier = "4"

zigund = ""    # hier eine Zeile einfügen

print(vier + zigund + zwei)

i)

a = 0
b = 1
c = a
d = a + b

e = 0    # hier eine Zeile einfügen

f = d - e

print(a * 2**0 + b * 2**1 + c * 2**2 + d * 2**3 + e * 2**4 + f * 2**5)

j)

a = 1 + 3 + 5
b = a + 7 + 9 + 11

value = a + b - 3    # diese Zeile ergänzen oder korrigieren

print(value)

Hausaufgabe: Programme mit Bedingten Anweisungen

Das Programm max3.py zur Berechnung des Maximums dreier Zahlen verwendet geschachtelte Bedingte Anweisungen.

x = 3
y = 4
z = 1

if x > y:
  if x > z:
    m = x
  else:      # y < x <= z
    m = z
else:        # x <= y
  if y > z:
    m = y
  else:
    m = z    # x <= y <= z

print("max(" + str(x) + "," + str(y) + "," + str(z) + ") = " + str(m))

Hier sind einige Beispielausgaben.

  max(1,2,3) = 3
  max(1,1,1) = 1
  max(2,2,1) = 2
  max(3,2,1) = 3
  max(3,4,1) = 4

Die geschachtelten Bedingte Verzweigungen könnten alternativ durch die folgenden Anweisungen ersetzt werden, ohne die Ausgabe des Programms zu verändern:

m = x

if m < y:
  m = y

if m < z:
  m = z

Die Programme not.py, and.py und or.py lassen sich jeweils mit einer einzigen bedingten Anweisung definieren. Hier ist die Definition von not.py mit Ausgaben für alle möglichen Eingaben.

x = False

if x:
  z = False
else:
  z = True

print("not " + str(x) + " = " + str(z))

# not False = True
# not True = False

Hier ist die Definition von and.py mit Ausgaben für alle möglichen Eingaben.

x = True
y = True

if x:
  z = y
else:
  z = False

print(str(x) + " and " + str(y) + " = " + str(z))

# False and False = False
# False and True = False
# True and False = False
# True and True = True

Hier ist die Definition von or.py mit Ausgaben für alle möglichen Eingaben.

x = True
y = True

if x:
  z = True
else:
  z = y

print(str(x) + " or " + str(y) + " = " + str(z))

# False or False = False
# False or True = True
# True or False = True
# True or True = True

Aufgabe: Fakultäts-Berechnung mit Schleifen

Das folgende Programm berechnet die Fakultät einmal mit einer for-Schleife und einmal mit einer while-Schleife.

n = 10

f = 1
for i in range(1,n+1):
  f = f * i

print(f)

f = 1
i = 0
while i < n:
  i = i + 1
  f = f * i

print(f)

Die Version mit der for-Schleife ist kürzer, wegen der automatischen Berechnung der Zählvariable weniger fehleranfällig und sicher terminierend. Das Programm mit der while-Schleife würde ein falsches Ergebnis berechnen, wenn wir die Zählvariable am Ende des Schleifenrumpfes hochzählen würden. Es würde nicht terminieren, wenn wir das Hochzählen vergessen hätten.

Hausaufgabe: Fachsprache zur Beschreibung von Programmen

Das Programm enthält drei Variablen: text, zahl und i. Die Variable i ist die Zählvariable der Zählschleife. Die ersten beiden Zeilen enthalten Zuweisungen an die Variablen text und zahl. Die zugewiesenen Werte sind "Ho" und 3. Beides sind primitive Ausdrücke, die also nicht weiter ausgerechnet werden müssen. "Ho" ist eine Zeichenkette und 3 ist eine Zahl. Eine weitere Zuweisung steht im then-Zweig der optionalen Anweisung im Rumpf der Zählschleife. Hier wird der Variablen text der Wert des Ausdrucks text + text zugewiesen. Letzterer ist ein komplexer Ausdruck, in dem zweimal die Variable text als Teilausdruck vorkommt. Die Bedingung der optionalen Anweisung i % 2 == 1 ist ebenfalls ein komplexer Ausdruck und zwar ein logischer. Sie enthält die Teilausdrücke i % 2, i, 2 und 1. Die erste Zeile der Zählschleife enthält die arithmetischen Ausdrücke 1 und zahl zur Definition der Grenzen des Bereiches, den die Zählvariable durchläuft. Die letzte Programmzeile enthält eine Ausgabe-Anweisung, die den Wert der Variablen text ausgibt.

Der Rumpf der Zählschleife wird dreimal durchlaufen. Die Bedingung der optionalen Anweisung ist genau dann True, wenn i = 1 oder i = 3 gilt. Die Zuweisung text = text + text wird also zweimal ausgeführt. Nach dem ersten Mal erhält die Variable text den Wert "HoHo", nach dem zweiten Mal den Wert "HoHoHoHo". Die Ausgabe des Programms ist also HoHoHoHo.

Bonusaufgabe: Zählschleifen untersuchen

Es ist in Python nicht möglich, mit einer for-Schleife eine Endlosschleife zu programmieren. Selbst wenn der Schleifenrumpf Zuweisungen an die Zählvariable enthält, wirkt diese sich nur bis zum Ende des Schleifenrumpfes aus. Im nächsten Durchlauf hat die Zählvariable unabhängig von Zuweisungen den nächsten Wert im Zahlenbereich. Auch Zuweisungen an eine zur Definition des Zahlenbereiches verwendete Variable im Schleifenrumpf ändern den durchlaufenen Bereich nicht. Das folgende Programm veranschaulicht dieses Verhalten.

n = 3
for i in range(1,n+1):
  print("Wert von i vor der Zuweisung: " + str(i))
  i = i - 1
  print("Wert von i nach der Zuweisung: " + str(i))
  n = n + 1

Ausgabe dieses Programms:

Wert von i vor der Zuweisung: 1
Wert von i nach der Zuweisung: 0
Wert von i vor der Zuweisung: 2
Wert von i nach der Zuweisung: 1
Wert von i vor der Zuweisung: 3
Wert von i nach der Zuweisung: 2

Bonusaufgabe: Python-Programm, das sich selbst ausgibt

Das folgende Python-Programm erzeugt sich selbst als Ausgabe.

q = '"'
r = "'"
s = "print('q = '+r+q+r); print('r = '+q+r+q); print('s = '+q+s+q); print(s)"
print('q = '+r+q+r); print('r = '+q+r+q); print('s = '+q+s+q); print(s)

Die letzte Programmzeile enthält vier Ausgabe-Anweisungen. Jede dieser Anweisungen gibt eine Zeile des Programms aus.

Der Wert, der in der dritten Programmzeile der Variablen s zugewiesen wird, entspricht der vierten Programmzeile. Die Variable s wird deshalb sowohl für die dritte als auch für die vierte Ausgabe-Anweisung verwendet. Die Zuweisungen an die Variablen q und r helfen dabei, die richtigen Hochkommata in der Ausgabe zu erzeugen.

Ein Programm, das sich selbst als Ausgabe erzeugt, heißt “Quine” - in Anlehnung an Quine’s Paradox:

“Yields Falsehood when preceded by its quotation” yields Falsehood when preceded by its quotation.

Aufgabe: Schleifenbedingungen mit Fließkommazahlen

In Python terminiert das gegebene Programm nicht, da aufgrund von Rundungsfehlern, stets x != 1.0 gilt. Wir korrigieren es, indem wir die Schleifenbedingung wie folgt anpassen.

x = 0.0         #1

while x < 1.0:  #2
  print(x)      #3
  x = x + 0.1   #4

Auch dieses Programm liefert allerdings noch nicht die gewünschte Ausgabe.

0.0
0.1
0.2
0.30000000000000004
0.4
0.5
0.6
0.7
0.7999999999999999
0.8999999999999999
0.9999999999999999

Das folgende Programm behebt dieses Problem.

for i in range(0,10):
  print(i/10)