Programmieren im Unterricht mit Python

Programmieren im Unterricht mit PythonPython in Beispielen: Eine Einführung für Programmierer

J. Arnold, M. Guggisberg, T. Kohn, A. Plüss

Copyright c© 2015, TigerJython Teamhttp://www.tigerjython.ch/

http://jython.tobiaskohn.ch/

Version vom 5./6. September 2015.

Programmieren im Unterricht mit Python 3

1 Listen und Summen

Einführung Die Primzahlen eignen sich hervorragend als Beispiel-Liste, weil die Zahlen nicht regelmässig verteilt sind. In diesem Ab-schnitt stellen wir verschiedene Techniken vor, um die Summe einerListe von Primzahlen (oder anderem) zu berechnen.

For-Schleife For-Schleifen in Python arbeiten immer mit Listen: DieLaufvariable geht der Reihe nach alle Elemente einer Liste durch. Damitist diese Technik prädestiniert, um die Summe zu bilden.

1 primes = [2, 3, 5, 7, 11, 13, 17, 19]

2 summe = 0

3 for p in primes:

4 summe += p

5 print summe

Funktionen In Python wird eine Funktion mit def definiert undgibt mit return ein Resultat zurück. Indem wir den Code oben in eineFunktion verpacken, haben wir flexibleren, wiederverwendbaren Code.

1 def summe(liste):

2 result = 0

3 for zahl in liste:

4 result += zahl

5 return result

6

7 primes = [2, 3, 5, 7, 11, 13, 17, 19]

8 print summe(primes)

Eine Funktion für alles Weil Variablen in Python keinen festen Typhaben, können wir die Summenfunktion auch so umschreiben, dass sieStrings (Zeichenketten) zusammenhängt.

1 def summe(liste):

2 if liste != []:

3 result = head(liste)

4 for item in tail(liste):

5 result += item

6 return result

7 else:8 return None9

10 primes = [2, 3, 5, 7, 11, 13, 17, 19]


12 print summe(["Tic", "Tac", "Toe"])

c© 2015, J. Arnold, M. Guggisberg, T. Kohn, A. Plüss

4 Programmieren im Unterricht mit Python

Rekursion Für die Rekursion haben sich die Funktionen head undtail als nützlich herausgestellt. Dabei gibt head(liste) das erste Ele-ment zurück, tail(liste) den Rest – wiederum als Liste. Mit head und tail können

wir das erste Element einerListe abspalten.head([2,3,5]) = 2tail([2,3,5]) = [3,5]

1 def summe(liste):

2 if liste == []:

3 return 0

4 else:5 return head(liste) + summe(tail(liste))

6

7 primes = [2, 3, 5, 7, 11, 13, 17, 19]


Für Profis: Falten* Wir gehen noch einen Schritt weiter und ma-chen sogar die «Addition» austauschbar. Wir können dann nicht nurSummen, sondern auch Produkte mit der gleichen Funktion berech-nen. Dazu nutzen wir aus, dass Funktionen in Python 1.-Klass-Objektesind. Das heisst, wir können eine Funktion als Parameter an eine andereFunktion übergeben!

1 def fold(liste, op):

2 result = head(liste)

3 for item in tail(liste):

4 result = op(result, item)

5 return result

6

7 def add(x, y):

8 return x + y

9

10 def mul(x, y)

11 return x * y

12

13 primes = [2, 3, 5, 7, 11, 13, 17, 19]

14 print fold(primes, add)

15 print fold(primes, mul)

Noch etwas schöner wird es, wenn wir Lambda-Ausdrücke verwenden,um kurze Funktionen direkt in den Code einzubetten. Die Operations-funktionen add und mul oben können wir im Prinzip auch so schreiben:

add = lambda x, y: x + y

mul = lambda x, y: x * y

Die Namen add und mul sind aber ebenfalls überflüssig und wir rufenfold direkt so auf:

1 primes = [2, 3, 5, 7, 11, 13, 17, 19]

2 print fold(primes, lambda x, y: x + y)

3 print fold(primes, lambda x, y: x * y)


Listen und Summen 5

AUFGABEN

1. Schreibe eine Funktion fakult(n), die die Fakultät n! = 1 ·2 ·3 · · ·neiner Zahl n berechnet.

Natürlich geht das auf völlig verschiedene Arten und die interessanteAufgabe wäre, möglichst viele verschiedene Wege für die Berechnungzu finden.

2. Ein altes Rätsel von Sam Loyd (1841–1911):

Neulich sah ich mir zusammen mit einem Freund die Attraktionen auf Coney Is-land an, und dabei lernten wir kennen, was uns jemand als das ehrlichste Spielam ganzen Strand anpries. Da waren zehn kleine Figuren, die man mit einem Ballumwerfen musste. Der Mann sagte: «Für 1 Cent haben Sie einen Wurf, und Siekönnen werfen, so oft Sie wollen, und so dicht ’rangehen, wie Sie wollen. ZählenSie die Zahlen auf den Figuren, die Sie umwerfen zusammen, und wenn Sie genau50 haben, nicht mehr und nicht weniger, erhalten Sie eine prächtige Maggie-Cline-Zigarre mit einem Goldband drum herum.»

Unser Geld war alle, noch bevor wir heraus hatten, wie man eigentlich gewin-nen konnte. Ausserdem fiel uns auf, dass eine ganze Menge Leute genauso wenigMaggie-Cline-Zigarren rauchten wie wir. Wissen Sie, wie man genau 50 Punktemacht?

Die Aufgabe besteht also darin, aus den gegebenen Zahlen jene heraus-zusuchen, die zusammen die Summe 50 ergeben:

25, 27, 3, 12, 6, 15, 9, 30, 21, 19

Schreibe ein Programm, das diese Aufgabe für dich übernimmt!



2 Fibonacci-Zahlen berechnen

Einführung Die Fibonacci-Zahlen sind das klassische Beispiel füreine rekursiv definierte Zahlenfolge:

an = an−2 + an−1, a0 = a1 = 1 1, 1, 2, 3, 5, 8, 13, 21, . . .

In diesem Abschnitt untersuchen wir verschiedene rekursive und itera-tive Möglichkeiten, um die Fibonacci-Zahlen zu berechnen.

Der naive Ansatz Wir beginnen mit dem naiven Ansatz und de-finieren eine Funktion fib(n) aus der rekursiven Formel oben. Abervorsicht: Dieser Ansatz hat eine exponentielle Laufzeit!

1 def fib(n):

2 if n < 2:

3 return 1

4 else:5 return fib(n-2) + fib(n-1)

6

7 print fib(30)

Iterativer Ansatz mit Liste Ein iterativer Ansatz (d. h. mit einerSchleife) arbeitet viel schneller und ist ebenfalls einfach zu program-mieren. Python erleichtert uns die Arbeit sehr, indem wir mit liste[-1]bzw. liste[-2] auf das letzte und zweitletzte Element einer Liste zu-greifen können.

1 def fib(n):

2 F = [1, 1]

3 repeat n-1:

4 x = F[-2] + F[-1]

5 F.append(x)

6 return F[-1]

7

8 print fib(30)

Iterativer Ansatz ohne Liste In diesem zweiten iterativen Ansatzverzichen wir auf die Liste. Eigentlich genügt es ja, wenn wir von derListe jeweils die beiden letzten Elemente speichern. Python erlaubt uns,hier mit Tupeln zu arbeiten und die Abbildung (a, b) 7→ (b, a+ b) direktumzusetzen.

1 def fib(n):

2 (a, b) = (1, 1)

3 repeat n-1:

4 (a, b) = (b, a+b)


Fibonacci-Zahlen berechnen 7

5 return b

6

7 print fib(30)

Memoization: Rekursion mit Liste Als letzten Ansatz stellen wirnoch «Memoization» vor. Um den rekursiven Ansatz schneller zu ma-chen speichern wir hier die Werte, die bereits berechnet wurden. Dazuverwenden wir ein Dictionary (Hash-Table, s. unten).

1 memo_table = {}

2 def fib(n):

3 if n < 2:

4 return 1

5 elif n in memo_table:

6 return memo_table[n]

7 else:8 result = fib(n-2) + fib(n-1)

9 memo_table[n] = result

10 return result

11

12 print fib(30)

Alternativ wäre hier noch eine kürzere Variante des selben:

1 memo_table = {0: 1, 1: 1}

2 def fib(n):

3 if n not in memo_table:

4 memo_table[n] = fib(n-2) + fib(n-1)

5 return memo_table[n]

6

7 print fib(30)

Dictionaries Neben Listen sind auch Dictionaries in Python fest ein-gebaute Datenstrukturen. Die Schlüssel ("Name", (3,4) etc.) dürfenbeliebige (unveränderbare) Datentypen haben.

BDFL = {"Name": "van Rossum", "Vorname": "Guido",

"Geb-Jahr": 1956, "BDFL": True}

PT = {(3, 4): 5, (5, 12): 13, (20, 21): 29}

print "Name", BDFL["Name"]

print PT[(5, 12)]

Was ist Memoization? Bei Memoization gehen wir davon aus, dasses aufwendig oder teuer ist, den Funktionswert f(x) für einen Wertx zu berechnen. Deshalb verwenden wir eine Liste oder Tabelle undspeichern alle Funktionswerte von f(x) nach deren ersten Berechnung.Memoization ist eine speziel-

le Form des «Caching» vonFunktionswerten.

Für einen bestimmten Wert x1 kann also der erste Aufruf von f(x1)

noch teuer sein. Ab dem zweiten Aufruf liegt das Resultat aber bereitsvor und wird direkt der Liste/Tabelle entnommen.



3 Listen: Chaos und Ordnung

Zufallszahlen Für viele Zwecke ist es nützlich, eine Liste mit Zu-fallszahlen erstellen zu können, um dann mit einer solchen zufälligenListe weiterzuarbeiten. Dazu laden wir die Funktin randint aus demrandom-Modul und erzeugen dann mit randint(0, 20) eine Zufalls-zahl zwischen 0 und 20.

1 from random import randint

2 liste = []

3 repeat 30:

4 liste.append(randint(0, 20))

Mit List-Comprehensions geht das natürlich auch kürzer:

from random import randint

liste = [randint(0, 20) for x in range(30)]

Zahlen binär zerlegen Jede ganze Zahl lässt sich auch binär schrei-ben. So hat 69 etwa die Binärdarstellung 0100 0101. Diese Binärdarstel-lung soll uns Python liefern. Dabei sind // die Ganzzahl-Division und %

der Rest dieser Ganzzahl-Division. Pythons Divisionsoperatoren:61 / 8 = 7.62561 // 8 = 761 % 8 = 5

1 binary = []

2 zahl = 69

3 repeat 8:

4 binary.insert(0, zahl % 2)

5 zahl = zahl // 2

6 print binary

Mit join werden die einzelnen Ziffern zu einem String ohne Kommataverbunden, so dass eine eigentliche Binärzahl entsteht:

print join(binary)

Sortieren (I) Nachdem wir eine Liste erzeugt haben wollen wir sieauch sortieren. Hier ist ein einfacher Algorithmus, der demonstriert,wie man Elemente aus einer ersten Liste entfernen und an eine andereListe anhängen kann.

1 def my_sort(liste):

2 result = []

3 while liste != []:

4 x = min(liste)

5 liste.remove(x) # x aus alter Liste entfernen

6 result.append(x) # x an neue Liste anhängen

7 return result

8

9 print my_sort([14, 3, 4, 5, 17, 7, 18, 11, 19])

10 print my_sort(["Kuh", "Biene", "Zebra", "Emu", "Affe"])


Listen: Chaos und Ordnung 9

Sortieren (II) Diese Variante des Sortierens erstellt eine neue Liste,in der jedes Element an der richtigen Stelle eingefügt wird, so dass dieListe jederzeit korrekt sortiert ist. Elemente, die grösser sind als allebisherigen können nicht eingefügt werden, sondern werden am Endeangehängt.

1 def my_sort(liste):

2 result = []

3 for item in liste:

4 inserted = False

5 for i in indices(result):

6 if result[i] > item:

7 result.insert(i, item)

8 inserted = True

9 break10 if not inserted:

11 result.append(item)

12 return result

13

14 print my_sort([14, 3, 4, 5, 17, 7, 18, 11, 19])

Sortieren (III): Merge-Sort Die dritte Variante eines Sortieralgorith-mus ist «Merge-Sort». Wir arbeiten hier mit Rekursion und nutzen aus,dass wir eine Liste in Python sehr einfach auftrennen können:

liste = [4, 9, 1, 7, 5, 3]

liste[2:4] -> [1, 7]

liste[:3] -> [4, 9, 1]

liste[3:] -> [7, 5, 3]

1 def merge_sort(liste):

2 if len(liste) <= 1:

3 return liste

4 # Liste aufteilen und Teile sortieren:

5 idx = len(liste) // 2

6 partA = merge_sort(liste[:idx])

7 partB = merge_sort(liste[idx:])

8 # Teillisten miteinander verschmelzen:

9 result = []

10 while partA != [] and partB != []:

11 if head(partA) < head(partB):

12 result.append(head(partA))

13 partA = tail(partA)

14 else:15 result.append(head(partB))

16 partB = tail(partB)

17 # Entweder partA oder partB ist hier leer:

18 return result + partA + partB

19

20 print merge_sort([4, 9, 1, 7, 5, 3])



Filtern Diese einfache Variante einer Filter-Funktion zeigt, wie duin Python mit in direkt prüfen kannst, ob ein Element in einer Listevorkommt.

1 def filter(liste, allowed):

2 result = []

3 for item in liste:

4 if item in allowed:

5 result.append(item)

6 return result

7

8 print filter([4, -3, 0, 2, -5], [0, 2, 4, 6, 8])

Hier noch die Kurzversion mit List Comprehensions:

def filter(liste, allowed):

return [x for x in liste if x in allowed]

AUFGABEN

3. Schreibe eine Funktion, die aus einer gegebenen Liste alle doppeltvorkommenden Elemente entfernt.

4. Schreibe eine Funktion, die zwei Listen vergleicht und die Anzahlder Elemente zurückgibt, die in beiden Listen vorkommen.

5. Schreibe eine Funktion, die zu einer gegebenen Liste eine zufälligePermutation erzeugt und zurückgibt.

6. Schreibe eine Lotto-Simulation. Wähle zuerst 6 Zahlen aus 42 ausund führe dann 10 000 Ziehungen mit 7 Zufallszahlen durch. Das Pro-gramm gibt dann jedes Mal die 7 Zahlen aus, wenn 4, 5 oder 6 «rich-tige» dabei sind und zählt zusammen, wie oft du mit deinen 6 Glücks-zahlen gewonnen hast.

7. Gegeben ist eine Liste, die nur die Zahlen 0 und 1 enthält. Fin-de darin die längste Abfolge von Nullen oder Einsen. Für die Eingabe[0, 1, 1, 0, 0, 1, 1, 1, 0] wäre die längste Folge [1, 1, 1].

Das Programm soll drei Informationen dazu ausgeben: Die Länge derFolge, ob es Nullen oder Einsen sind und an welcher Stelle in der Listedie Folge auftritt.


Listen: Punkte und Polygone 11

4 Listen: Punkte und Polygone

Einführung Punkte lassen sich in Python direkt mit Tupeln abbilden.Ein Tupel ist eine «unveränderbare» Liste. Einmal erzeugt, ändern sichdie Elemente eines Tupels also nicht mehr. Für ein Polygon verwendenwir dann eine Liste von Tupeln. Hier ist ein gleichseitiges Dreieck:Tupel werden im Gegensatz

zu Listen mit runden Klam-mern geschrieben:Liste: [1, 2, 3]Tupel: (1, 2, 3)

[(-34.6, -20), (0, 40), (34.6, -20)]

In diesem Abschnitt arbeiten wir mit solchen Polygonen.

Das Polygon zeichnen Als Einstieg lassen wir uns das Polygon zu-nächst einmal zeichnen. Dazu verwenden wir die Turtle-Grafik, die fürunsere Zwecke mehr als ausreicht.

1 from gturtle import * # Turtle-Bibliothek laden

2 makeTurtle() # Turtle-Fenster öffnen

3 speed(-1) # Turtle möglichst schnell

4 setPenColor("black") # Linien-Farbe: Schwarz

5

6 coords = [(-34.6, -20), (0, 40), (34.6, -20)]

7 (x, y) = coords[-1] # Startpunkt

8 setPos(x, y)

9 for (x, y) in coords:

10 moveTo(x, y)

Distanzen Die Distanz eines Punkts zum Ursprung müssen wir sel-ber berechnen. Dazu laden wir die Wurzel-Funktion sqrt aus demMathematik-Modul math und definieren eine neue Funktion. Anschlies-Anstelle von sqrt könnten

wir auch x**0.5 (x0.5) ver-wenden.

send suchen wir den Punkt, der am nächsten beim Ursprung liegt.

1 from math import sqrt

2

3 def dist((x0, y0), (x1, y1)):

4 d = (x1 - x0)**2 + (y1 - y0)**2

5 return sqrt(d)

6

7 coords = [(1, 9), (2, 8), (3, 7), (4, 6), (5, 5), (6, 4)]

8 min_point = head(coords)

9 min_dist = dist(min_point, (0, 0))

10 for point in coords:

11 d = dist(point, (0, 0))

12 if d < min_dist:

13 min_dist = d

14 min_point = point

15 print min_point



Graphen Wenn wir Polygone darstellen können, dann ist es ein klei-ner Schritt zu Funktionsgraphen. In diesem Beispiel erzeigen wir eineListe mit Punkten auf der Parabel y = 1

5x2.

coords = []

for x in range(-10, 11):

coords.append((5*x, x**2))

In Python lässt sich das auch kürzer schreiben als:

coords = [(5*x, x**2) for x in range(-10, 11)]

AUFGABEN

8. Schreibe ein Programm, das für eine beliebige Funktion den Gra-phen und die Koordinatenachsen zeichnet. Das Turtle-Fenster hat inder Regel eine Grösse von 600× 400 Pixeln mit dem Punkt (0, 0) in derMitte.

Hinweis: Verwende für die folgenden Aufgaben das Polygon:

[(34, 24), (31, 53), (70, 99), (80, 96), (104, 64), (55, 21), (44, 19), (46, 48)]

9. Schreibe eine Funktion center, die den Schwerpunkt eines Polyg-ons berechnet.

xS =x1 + x2 + x3 + · · ·+ xn

nyS =

y1 + y2 + y3 + · · ·+ ynn

10. Schreibe eine Funktion circumference, die den Umfang des Poly-gons ermittelt.

11. Ermittelte den Durchmesser eines Polygons, also die längste Di-stanz zwischen zwei Punkten.

12. Finde in einer Liste von Koordinaten drei Punkte, die sich zu einemrechtwinkligen Dreieck verbinden lassen. Idealerweise findet dein Pro-gramm natürlich alle solchen Tripel, ohne eines doppelt auszugeben.

13. Finde in einer Liste von Koordinaten vier Punkte A, B, C, D, sodass die Strecken AB und CD senkrecht zueinander stehen.


Strings: Text analysieren 13

5 Strings: Text analysieren

Einführung Python kann relativ gut mit Strings (Zeichenketten)umgehen und bietet eine Vielzahl von Funktionen. Dabei unterscheidetPython nicht, ob ein String in einfache oder doppelte Anfährungszei-chen eingeschlossen wird:

"Python ist toll!" == ’Python ist toll!’

Die Länge des Strings lässt sich mit len("...") bestimmen.

Buchstaben zählen In vielerlei Hinsicht unterscheiden sich Stringsin Python kaum von Listen. So können wir auch mit einer for-Schleifedie einzelnen Buchstaben/Zeichen eines Strings durchgehen und so dievorkommenden «E» zählen.

1 def count_e(text):

2 count = 0

3 for letter in text:

4 if letter in ["e", "E"]:

5 count += 1

6 return count

7

8 print count_e("Python lernen macht Spass!")

Frequenzanalyse Bei einfachen Text-Verschlüsselungen lohnt es sich,eine Frequenzanalyse des Textes vorzunehmen und die Häufigkeitender Buchstaben zu zählen. Hier lassen wir das Python erledigen undverwenden dazu ein «Dictionary».

1 def freq_analysis(text):

2 # Tabelle enthält zur Zeit nur Eintrag für ’a’ und ’e’.

3 letters = {"a": 0, "e": 0}

4 for ch in text:

5 ch = ch.lower() # Alles in Kleinbuchstaben

6 if ch in letters:

7 # Vorhandenen Wert erhöhen:

8 letters[ch] += 1

9 else:10 # Neuer Eintrag wird automatisch erstellt:

11 letters[ch] = 1

12 return letters

13

14 print freq_analysis("Python lernen ist cool!")



Wörter zählen Python kann einen gegebenen String mit split di-rekt zerlegen und liefert dann eine Liste mit den einzelnen Teilstücken.Das nutzen wir, um die Wörter in einem String zu zählen.

1 def count_words(text):

2 words = text.split(" ")

3 return len(words)

4

5 print count_words("Python ist auch eine Schlange.")

Parsen einer Zahl Dieses Programm liest aus einem gegebenen Stringeine hexadezimale Zahl heraus. Aus "3F" wird damit 63. In Python sel-ber lassen sich hexadezimale Zahlen als 0x3F direkt eingeben.

Mit ord(’A’) ermitteln wir den Ascii-Code eines einzelnen Zeichens.Die Umkehrung dazu wäre chr(65), die aus dem Ascii-Code wiederumeinen String erzeugt.

1 eingabe = inputString()

2 zahl = 0

3 for ch in eingabe.upper():

4 zahl *= 0x10

5 if ’0’ <= ch <= ’9’:

6 zahl += (ord(ch) - ord(’0’))

7 elif ’A’ <= ch <= ’F’:

8 zahl += (ord(ch) - ord(’A’) + 10)

9 else:10 print "Fehler: Ungültiges Zeichen", ch

11 break12 print zahl

AUFGABEN

14. Schreibe die Funktion count_words so um, dass sie Wörter wie«Python-Kurs» als zwei eigene Wörter zählt.

15. Schreibe ein Programm, das einen Text mit der Caesar-Chiffre ver-schlüsselt.

16. Schreibe ein Programm, das eine Längen-Eingabe wie «14 cm» oder«5 in» entgegennimmt und die Länge in Meter ausgibt.

Hinweis: 1 in = 2.54 cm, 1 ft = 30.48 cm, bzw. in Python:

factors = {"in": 0.0254, "ft": 0.3048}


Klassen und eigene Datentypen* 15

6 Klassen und eigene Datentypen*

Einführung Python ist zwar objektorientiert, unterscheidet sich abermassiv von OOP-Sprachen wie Java. Es gibt weder Interfaces noch In-formation Hiding. Bei einem Aufruf wie myObject.foo() kümmertsich Python nicht um den Typ von myObject, sondern sucht in der ent-sprechenden Klasse lediglich nach der Methode foo.

Beim Definieren einer Klasse ist wichtig, dass self immer mitangege-ben werden muss: Sowohl als erster Parameter jeder Methode als auchfür den Zugriff auf Felder.

Objekte erzeugen In Python können wir zu einem Objekt jeder-zeit neue Felder hinzufügen, indem wir ihnen einen Wert zuweisen.myObject.field=123 erzeugt direkt ein neues Feld im Objekt myObject,falls es nicht schon vorhanden ist.

Dieses Verhalten nutzen wir in TigerJython aus und bieten die FunktionmakeObject an, um ein zunächst leeres Objekt zu erstellen. Dieses lässtsich danach je nach Bedarf mit Feldern ergänzen.

1 ball = makeObject()

2 ball.pos = (1, 2, 3)

3 ball.radius = 4

4 ball.color = makeColor("red")

5 print ball

Die Felder können aber auch direkt in makeObject angegeben werden:

1 ball = makeObject(pos=(1, 2, 3), radius=4)

2 ball.color = makeColor("red")

3 print ball

Eine Klasse für Vektoren Eine neue Klasse lässt sich relativ schnellund einfach definieren. Die grösste Schwierigkeit besteht darin, dasself nicht zu vergessen. Eine neue Instanz wird danach direkt mitVector() erzeugt.

In diesem Beispiel überladen wir mit den Methoden __add__ und __mul__

eigentlich die Plus- bzw. Stern-Operatoren +, * und __repr__ entsprichtin Java der Methode toString().

1 class Vector:

2

3 # Konstruktor:

4 def __init__(self, x, y, z=0):

5 self.x = x

6 self.y = y



7 self.z = z

8

9 # Gibt ein *neues* Objekt mit der Summe zurück:

10 def __add__(self, that):

11 return Vector(self.x + that.x,

12 self.y + that.y,

13 self.z + that.z)

14

15 # Entspricht Self * That:

16 def __mul__(self, that):

17 if type(that) is int:

18 return Vector(self.x * that,

19 self.y * that,

20 self.z * that)

21

22 # Entspricht That * Self:

23 def __rmul__(self, that):

24 return self.__mul__(that)

25

26 # Wird von ’print’ aufgerufen:

27 def __repr__(self):

28 x, y, z = self.x, self.y, self.z

29 return "({0}, {1}, {2})".format(x, y, z)

30

31 v1 = Vector(1, 2, 3)

32 v2 = Vector(2, -3)

33 print v1 + v2 * 2

AUFGABEN

17. Ergänze die Vektor-Klasse um die Methode __sub__ und eine Me-thode dotP für das Skalarprodukt.

18. Schreibe eine Klasse Fraction, die einen Bruch darstellt und im-plementiere die vier Grundrechenarten +, -, * und / (über die Methode__truediv__).


Documents

Programmieren im Unterricht mit Python