- Python-Kurs
- Lektion 1
- Grundlagen
- Arithmetik und Algebraische Funktionen:
- Aufgabe 1:
- Aufgabe 2:
- Aufgabe 3:
- Aufgabe 4:
- Aufgabe 5:
- Vorbedingungen und Exceptions:
- Aufgabe 6:
- Übungsblatt 1:
- Lektion 2
- Schleifen
- Aufgabe 1:
- Aufgabe 2:
- Aufgabe 3:
- Aufgabe 4:
- Aufgabe 5:
- Der string-Typ
- Aufgabe 6:
- Aufgabe 7:
- Übungsblatt 2:
- Lektion 3
- Der Array-Typ list:
- Aufgabe 1:
- Aufgabe 2:
- Wertsemantik und Referenzsemantik
- Aufgabe 3:
- Aufgabe 4:
- Aufgabe 5:
- Aufgabe 6:
- Übungsblatt 3:
- Lektion 4
- Der Typ dict ("Dictionary")
- Der Typ SET
- Aufgabe 1:
- Sortieren:
- Aufgabe 2:
- Iteratoren:
- Aufgabe 3:
- Aufgabe 4:
- Übungsblatt 4:
- Lektion 5
- Eigene Typen:
- Aufgabe 1:
- Aufgabe 2:
- Aufgabe 3:
- Aufgabe 4:
- Die Bild-Klasse Image:
- Aufgabe 5:
- Aufgabe 6:
- Aufgabe 7:
- Aufgabe 8:
- Übungsblatt 5:
- Lektion 6
- Aufgaben zur Bildbearbeitung
- Aufgabe 1:
- Aufgabe 2:
- Aufgabe 3:
- Aufgabe 4:
- Aufgabe 5:
- Übungsblatt 6:
- Lektion 7
- Klassen zum Zeichnen
- Aufgabe 1:
- Aufgabe 2:
- Aufgabe 3:
- Aufgabe 4:
- Aufgabe 5:
- Übungsblatt 7:
- Lektion 8
- Wissenschaftliches Rechnen in Python:
- Lektion 9
- Erstellen der Tests
- Ausführen der Tests:
- Test-Ausgabe:
- Setup und Teardown
- Noch mehr "asserts":
- Wiederholung
- Funktionale Programmierung
- Eigene Iteratoren
- Wiederholungsaufgaben:
Lektion 1
print("Hello World!")python hello.pyname = input("Wie heisst du? ")print("Hello", name)import sys # importiere das Modul 'sys'print(sys.platform)dir(sys)dir(__builtin__) import pip pip.get_installed_distributions() # welche Module # kann man importieren? type("Hello") # str type(1) # int type(1.0) # float type(True) # bool type(None) # NoneType "Hello", 'Hello' # String-Literal 1 # Integer-Literal 1.0, 1e-12 # float-Literale True, False # bool-Literaleint(1)float(1)int() # => 0str() # => "" a = 1 # Variable 'a' hat Typ 'int', Wert '1'a = 2*300b = a - 4a = -2.6type(a) # floatb = int(a)print(b) # -2: Typumwandlung rundet Richtung 0type(b) # intc = float(b) # type(c) => floata = 10b = 3...print(rest) # => 1assert rest == a % b # '==' fragt 'ist das gleich?' # ergibt 'True' oder 'False'a = int(input("Introduce value of a:"))b = int(input("Introduce value of b:"))rest = a - a//b * bprint(rest)assert rest == a % b10**10 # '10 hoch 10'10.0**102*3+5 # => 112*(3+5) # => 16import mathmath.sqrt(2.0) # Modulnamen vor Funktionsnamen # schreiben, mit Punkt getrenntfrom math import sqrt # Funktion sqrt ins aktuelle # Modul importierensqrt(2.0)dir(math) # => die üblichen Funktionen: exp, ...if a == 0: # der Doppelpunkt ist wichtig! b = 3 c = 4 print(a, b, c)elif a == 1: b = 5 c = 1else: b = 10 c = 0print(a, b, c)day = int(input('Tag: '))...day = int(input("Tag: "))month = int(input("Monat: "))year = int(input("Jahr: "))m = month - 2if m < 2: m += 12 year -= 1year1 = year % 100c = year // 100w = (day + (26*m - 2)//10 + year1 + year1//4 + c//4 - 2*c) % 7if w<0: w += 7if w == 0: w = "Sonntag"if w == 1: w = "Montag"if w == 2: w = "Dienstag"if w == 3: w = "Mittwoch"if w == 4: w = "Donnerstag"if w == 5: w = "Freitag"if w == 6: w = "Samstag"print("Der", day, month, year, " war ein", w)# der Doppelpunkt am Ende ist wichtig!def funktionsname(argument1, argument2, ...): '''Dokumentation Drei Anführungszeichen: mehrzeilige Strings ( dürfen Newlines enthalten) ''' code code return ... # Ergebnis zurückgebendef day_of_week(day, month, year): ... return weekday # als Stringdef day_of_week(day, month, year): m = month - 2 if m < 2: m += 12 year -= 1 year1 = year % 100 c = year // 100 w = (day + (26*m - 2)//10 + year1 + year1//4 + c//4 - 2*c) % 7 if w<0: w += 7 if w == 0: w = "Sonntag" if w == 1: w = "Montag" if w == 2: w = "Dienstag" if w == 3: w = "Mittwoch" if w == 4: w = "Donnerstag" if w == 5: w = "Freitag" if w == 6: w = "Samstag" return wday = int(input("Tag: "))month = int(input("Monat: "))year = int(input("Jahr: "))print("Der", day, month, year, " war ein", day_of_week(day, month, year))# Modul-Teildef funktion1(): ...def funktion2(arg): ...# Skript-Teil: die Bedingung ist nur True, wenn die# Datei als Skript aufgerufen wurdeif __name__ == '__main__': ... # Testcode print("All tests succeeded")python wochentag.py # Testenpython run_wochentag.py # enthält 'import wochentag': Wochentage ausrechnenassert <Bedingung, die True sein muss>, "optionale Fehlermeldung"assert wochentag(4, 4, 2016) == "Montag"def isValidDate(day, month, year): # => True/False if day < 1 or day > 31: return False ...def weekday(day, month, year): if not isValidDate(day, month, year): raise ValueError("weekday(): kein gültiges Datum.") ... # Funktion normal weiter ausführenLektion 2
k = 0while k < 10: print(k) k = k + 1 # wer das vergisst, bekommt eine # Endlosschleifek = 0while k < 10: print(k) k = k + 2 # ungerade Zahlen überspringenk = 0while k < 10: if k % 2 == 0: # keine Ausgabe für ungerade Zahl print(k) k = k + 1k = 0while k < 10: if k % 2 != 0: k += 1 continue # Schleifenkörper vorzeitig # abbrechen, zum while zurück print(k) k = k + 1def my_sqrt(x): y = x / 2 while y*y != x: y = (y + x/y) / 2 return yimport sys# Funktion mit default-Wert für Argument 'eps'def close_at_tolerance(a, b, eps=sys.float_info.epsilon): '''Tests if a and b are almost equal, with relative error eps. ''' diff = abs(a - b) # absoluter Fehler wäre # return diff <= eps # relativer Fehler return diff <= eps * max(abs(a), abs(b))def my_sqrt(x): if x < 0: # precondition check raise ValueError("my_sqrt(): negative argument") y = x / 2 # initial guess # while y*y != x: # dieser einfache Test funktioniert nicht für # 'krumme' Zahlen (endliche Genauigkeit # von 'float' - relativer Fehler 2e-16) while not close_at_tolerance(y*y, x, sys.float_info.epsilon): y = (y + x/y) / 2 return yif __name__ == "__main__": assert my_sqrt(9) == 3 assert my_sqrt(0) == 0 assert my_sqrt(4) == 2 # Exception abfangen und behandeln # => so testet man, dass Exceptions # wie gewünscht funktionieren try: # "probiere etwas, was eine # Exception auslösen könnte" my_sqrt(-1) # wenn die Exception wie gewünscht ausgelöst # wurde, ist die folgende Zeile unerreichbar assert False, "my_sqrt(-1) didn't raise ValueError" except ValueError as e: # Fange die Exception # 'ValueError' ab # 'as e' speichert die # Exception in der # Variablen e pass # nichts tun, alles in Ordnung # print(e) würde die Fehlermeldung ausgeben # andere Exceptions werden weitergereicht assert my_sqrt(1.21) == 1.1 assert close_at_tolerance(my_sqrt(0.5), 1.0 / my_sqrt(2.0)) print("All tests passed.")for k in <iterable>: ... # Schleifenkörperfor k in (0, 1, 2, 3): print(k)t = (0, 1, 2, 3)print(type(t)) # => tupleprint(t) # => (0, 1, 2, 3)print(t[1]) # => 1 - Zugriff auf einzelne Element # mit Index-Operator [index]# range(start, stop, step)# start und step sind optional# (wenn man step weglässt, gilt step = 1,# wenn man nur stop angibt, gilt start = 0for k in range(4): print(k) # gibt 4 Elemente aus: 0, 1, 2, 3for k in range(4, 0, -1): # (start, stop, step) print(k) # gibt 4, 3, 2, 1 ausdef factorialWhile(x): i = 1 res = 1 while i <= x: res *= i i += 1 return resdef factorialFor(x): res = 1 for i in range(1, x+1): res *= i return resprint(factorialWhile(6))print(factorialFor(6))assert factorialWhile(15) == factorialFor(15) # the two different implementations # should give the same result l = len(s) # Länge des Strings = Anzahl Zeichen for k in range(len(s)): zeichen = s[k] # k-tes Zeichen abfragen ... # mit 'zeichen' etwas tun for zeichen in s: # alle Zeichen nacheinander # an 'zeichen' zuweisen ... # mit 'zeichen' etwas tunmystring = input("Geben Sie Ihren String ein: ")def secondLetter(string): new_str = str() for k in range(len(string)): if k % 2 != 0: new_str += string[k] return new_strdef reverseString(string): new_str = str() for k in string: new_str = k + new_str return new_strprint("Jeder zweite Buchstabe vom String: ",secondLetter(mystring))print("Der String rueckwaerts: ",reverseString(mystring)) def easter(year): ... return day, month # erzeugt ein tuple # (day, month) und gibt # dieses zurück day, month = easter(2016) # entpackt das tuple, # das von easter() # zurückgegeben wird a, b = b, a # 'swap' a <=> bstring[k:] # gibt den String ab Index k ausstring[:k] # gibt den String bis Index k-1 ausstring.count('x') # gibt an, wie oft x im String vorkommtstring.find('x') # gibt den Index an, an dem sich x im # String befindet (von links gezählt)string.rfind('x') # Gegenstück zu '.find()' (von rechts # gezählt)string.isalpha() # prüft, ob der String nur aus Buchstaben # besteht (liefert boolean)string.isnumeric() # prüft, ob der String nur aus Zahlen # besteht (liefert boolean)string.lower() # wandelt den String in Kleinbuchstaben umstring.upper() # wandelt den String in Großbuchstaben umstring.split('x') # teilt den String bei allen 'x' und löscht x # Ergebnis: eine Liste der Teilstrings zwischen # den gelöschten 'x'string.splitlines() # teilt mehrzeilige Strings (split am Zeilenende)string.replace('x', 'y') # ändert alle 'x' in 'y' und gibt den # neuen String zurückstring.replace('x', 'y', 4) # ändert nur die ersten 4 # Vorkommen von 'x'string.replace('vorher', 'nachher')# ersetzt alle Vorkommen # des Teilstrings 'vorher'if s[4] in " .?!,;": ... # tue etwasif s[4] not in " .?!,;": .. # tue etwasdef normalize_string(string): normalised = str() for k in string: if k in (".?,;! "): continue else: normalised +=k.lower() return normaliseddef is_palindrom(string): palindrom = normalize_string(string) return palindrom == reverseString(palindrom)# Datei zum Lesen öffneninfile = open("filename")... # Daten einleseninfile.close() # Datei wieder schließen (nicht vergessen!)# statt 'infile = open("filename")' schreibewith open("filename") as infile: ... # Daten einlesen (hier ist Datei offen)pass # am Ende der Einrückung wird die Datei # automatisch geschlossen, hier ist sie also zu# füge 'w' zum open()-Befehl hinzuwith open("filename", 'w') as outfile: ... # Daten schreiben (hier ist Datei offen)with open("filename") as infile: contents = infile.read()with open("filename") as infile: # Zeilen in der Datei sind 'iterable', können # als Argument der for-Schleife verwendet werden for line in infile.readlines(): ... # bearbeite die aktuelle Zeilewith open("filename", 'w') as outfile: outfile.write(contents)with open("filename", 'w') as outfile: outfile.writelines(lines)Lektion 3
array = [1, 2.0, 3, '4'] # vier Elementeleer = []auch_leer = list()string_array = 'asdf asdjh asdkj'.split(' ')# ergibt ['asdf', 'asdjh', 'asdkj']a_tuple = (3, 4, 5, 6)array_from_tuple = list(a_tuple)# ergibt [3, 4, 5, 6]zahlen = list(range(3, 0, -1)) # aus 'iterable'# ergibt [3, 2, 1]nested = [leer, string_array, a_tuple, 1.0]nested[0] # => []nested[1] # => ['asdf', 'asdjh', 'asdkj']nested[2] # => (3, 4, 5, 6)nested[3] # => 1.0nested[2] = 'asdasd' # a_tuple wird dadurch aus # dem Array entferntprint(nested[2]) # => 'asdasd'gedreht = drehe(array)assert gedreht != arraydrehe_in_place(array)assert gedreht == arrayl = len(array)# zwei Arrays aneinanderhängenarray3 = array1 + array2 # neues kombiniertes Array erzeugenarray1 += array2 # array1 verlängern# ein neues Element anhängenarray.append(single_element)# äquivalent zuarray += [single_element]# Funktion 'reversed' dreht das Arraygedreht = list(reversed(array))def drehe_in_place(array): i = 0 # erstes Element j = len(array) - 1 # letztes Element while i < j: # swap i <=> j array[i], array[j] = array[j], array[i] i += 1 # von vorn zur Mitte j -= 1 # von hinten zur Mittearray.reverse()array.append(x) # hängt x am Ende des Arrays anarray.insert(idx, x) # fügt x beim Index idx einarray += other_array # hängt other_array am Ende anarray.pop(idx) # löscht am Index idx den Eintrag # aus dem Array und gibt den # gelöschten Eintrag zurück (ohne # Argument wird der letzte Eintrag # gelöscht)del array[idx] # löscht den Eintrag am Index idx, # ohne ihn zurückzugebenarray.remove(x) # löscht das erste Vorkommen des # Eintrages x aus dem Arrayarray.clear() # löscht alle Einträge aus dem Arrayarray.sort() # sortiert das Array aufsteigendarray.sort(reverse=True) # Sortierung absteigendarray.reverse() # dreht die Reihenfolge der Einträge umarray.copy() # erzeugt eine Kopie des Arraysarray.count(x) # gibt an, wie oft x im Array vorkommtif weekday == 0: return "Sonntag"if weekday == 1: return "Montag"...weekdays = ['Sonntag', 'Montag', ..., 'Samstag']... # weekday ausrechnen ...return weekdays[weekday] # und als Index benutzendef day_of_week(day, month, year): m = month - 2 if m < 2: m += 12 year -= 1 y = year % 100 c = year // 100 w = (day + (26*m - 2)//10 + y + y//4 + c//4 - 2*c) % 7 weekdays = ["Sonntag", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag"] return weekdays[w] value = array[2] # Lesen array[2] = new_value # Schreiben value = array[-1] # Lesen des letzten Elements array[-1] = new_value # Schreiben des letzten Elements # array[-idx] <=> array[len(array)-idx] subarray = array[2:5] # kopiert Array-Elemente von # Index 2 (inklusiv) bis Index 5 (exklusiv) in ein neues Array array[2:] # Endindex fehlt => kopiere bis zum Ende array[:5] # Anfangsindex fehlt => kopiere vom Anfang array[:] # kein Index => kopiere alles array[2:5:2] # nur jedes zweite Element kopieren array[::-1] # alle Elemente rückwärts kopieren path = "/usr/lib/libpython.a" slash = path.rfind('/') filename = path[slash+1:] # => "libpython.a"a = [1, 2, 3]b = ab[0] = 'changed' # Referenzsemantik: a wird auch # geändert, weil 'a' und 'b' auf # den gleichen Speicher verweisenassert a[0] == 'changed'a = 1b = ab = 2assert a == 1 # Wertsemantik: Ändern von 'b' # hat keinen Einfluss auf 'a'def do_something(array): ... array[2] = 5 ...a = [1,2,3,4]do_something(a) # Achtung: Referenzsemantikprint(a[2]) # ist das 3 oder 5 ? => 5a = [1,2,3]b = aassert a == b # Vergleich der Werteassert a is b # Vergleich der Speicherpositionassert id(a) == id(b) # Vergleich der Objekt-IDsc = [1,2,3]assert a == c # Vergleich der Werteassert not a is c # Vergleich der Speicherpositionassert id(a) != id(c) # Vergleich der Objekt-IDsb = a[:] # erzeugt eine Kopieb = a.copy() # erzeugt eine Kopieimport copya = [1,2,3,4]b = copy.deepcopy(a) # erzeugt eine Kopiea = [1,2,3,4]b = []for e istrn a: b.append(e**2)assert b == [1, 4, 9, 16]# definiere die Operation, die auf# die Elemente angewendet werden solldef square(x): return x**2b = list(map(square, a)) # führt obige Schleife aus# beachte: in Python 3 gibt 'map' einen Iterator# zurück (zu Iteratoren später), den man erst in# ein Array umwandeln mussb = list(map(lambda x: x**2, a))# 'lambda x:' bedeutet 'def unnamed(x):'# 'lambda x, y:' bedeutet 'def unnamed(x, y):'# beachte: bei 'lambda' gibt es kein 'return', es# wird einfach der letzte Wert zurückgegebenfrom math import expdef myexp(x): return exp(-x/2)a = [2,3,4]b = list(map(myexp, a))# normaler Konstruktora = [1,2,3,4]# list comprehensionb = [e**2 for e in a ]# ^ Element für b ^ Schleife für Originalelemente# ^ (beliebige Operation auf der Laufvariablen e)b = [e**2 for e in a if e % 2 == 0]# ^Operation ^Schleife ^Filterbedingungfemale_names = [name for name in names if is_female(name) ][1.2, 2.55] => [ '1.2', '2.55' ]a = [1.2, 2.55]b = [str(k) for k in a]def myformatting(x): string = "{:16,.2f}".form at(x) return string.replace(",","'")a = [15424.26546, 2458.55465]b = [myformatting(k) for k in a]result = (" " + s)[-16:]result = s.rjust(16) # mit Leerzeichen füllenresult = s.rjust(16, '0') # mit Nullen füllen"Der {}. {}. {} ist Mittwoch".format(6,"Apr",2016)=> "Der 6. Apr. 2016 ist Mittwoch""Der {2}/{1}/{0} ist Mittwoch".format(6,"Apr",2016)=> "Der 2016/Apr/6 ist Mittwoch""{:d} {:f} {:e}".format(14, 12.345, 23.123)"14 12.345000 2.312300e+01""{:8d}".format(10) # => " 10""{:08d}".format(10) # => "00000010""{:.2f}".format(1.2383) # => "1.24""{:.3f}".format(1.2383) # => "1.238""{:8.2f}".format(1.2383) # => " 1.24"Lektion 4
d = {} # geschweifte statt eckige Klammernd = dict() # Konstruktoraufrufd[1000] = 1d[-10] = 2d = {}d['erstes'] = 1d['zweites'] = 2a = {'eins': 1,'fünf': 5, 3: 3}text = ...text = text.lower()d = {}for word in text.split(' '): if word in d: # ist der Index 'word' vorhanden? d[word] += 1 # ja => Hochzählen else: d[word] = 1 # nein => Initialisierenlist(d.keys()) # gibt eine Liste mit den # Schlüsseln auslist(d.values()) # gibt eine Liste mit den Werten # auslist(d.items()) # gibt eine Liste mit den Schlüsseln # und Werten aus# alle Schlüssel und Werte ausgeben:for key, value in d.items(): print('key: ', key, ' holds value ', value)d.fromkeys(d2, xval) # iteriert über d2 und gibt ein # neues Dictionary mit den # übereinstimmenden Schlüsseln # und dem dafür neu # festgelegten Wert xval # (muss nicht angegeben # werden, dann:None) ausd.pop(xkey) # löscht den Schlüssel xkey und den # zugehörigen Wert aus dem Dictionary und gibt # den Wert zurückd.popitem() # löscht irgendein item aus dem # Dictionary und gibt es ausd.update(d2) # überschreibt das Dictionary d mit den # Werten des Dictionarys d2, # Elemente, deren Schlüssel in d, # aber nicht in d2 vorkommen, # bleiben unveränderta = set() # erzeugt leeres Setb = {1,2,3}c= set([1, 2, 3, 4, 3, ])c.discard(1) # löscht das Element 1 aus dem Set, # tut nichts, wenn 1 nicht enthalten istc..discard(1) # löscht das Element 1 aus dem Set, # löst 'KeyError' aus, wenn 1 nicht enthalten istc.add(5) # fügt das Element 5 zum Set hinzuc.differencec.subsetc.intersectprint(len(set(mystring))) # a enthält Tupel der Länge 2 sorted(a, key=lambda x: x[0]) # sortiere nach Element 0 ^ der Tupel # abgekürzte Schreibweise für obiges import operator sorted(a, key=operator.itemgetter(0)) # noch mehr abgekürzt from operator import itemgetter sorted(a, key=itemgetter(0)) d = {1: 'eins', 2: 'zwei', 3: 'drei' } sorted(d.items(), key=itemgetter(0)) a = [2, -3, 5, -1, 6, 7, -5] a.sort(key=abs) # in-place b = ['asdasd', 'asd', '', '1234'] c = list(sorted(b, key=len)) # neues Array compare(a, b) # => -1 <=> a < b # => 0 <=> a == b # => 1 <=> a > b from functools import cmp_to_key sorted(array, key=cmp_to_key(compare)) def name_compare(s1, s2): v1, n1 = s1.split(' ') # Vor- und Nachname v2, n2 = s2.split(' ') if n1 == n2: l1, l2 = len(v1), len(v2) if l1 < l2: return -1 elif l1 == l2: return 0 else: return 1 elif n1 < n2: return -1 else: return 1 names = ["Hanno Müller", ...] sorted(names, key=cmp_to_key(name_compare)) def selection_sort(array): # sortiere in-place l = len(array) for i in range(0,l-1): # suche kleinstes Element des Rest-Arrays [i:l] smallest = i for k in range (i+1,l): # die if-Bedingung bestimmt das Sortier-Ergebnis # * default (wie jetzt): aufsteigende Sortierung # * array[smallest]<array[k]: absteigende Sortierung # * key(array[k])<key(array[smallest]): Sortierung nach key # * compare(array[k], array[smallest])<0: mit Compare-Funktion if array[k]<array[smallest]: smallest=k # bringe kleinstes Element des Rest-Arrays [i:l] an Position i array[i],array[smallest] = array[smallest],array[i]a = {'erstes': 1, 'zweites': 2, 42: 'zweiundvierzig' }# erzeuge Iterator für keysi = a.keys().__iter__()# die kanonische Schleife mit Iteratortry: while True: # Endlosschleife # wird durch Exception beendet element = next(i) # liefert nächstes Element # oder raise Stopiteration # wenn kein Element mehr # vorhanden print(element) # tue etwas mit elementexcept StopIteration: # fange die erwartete # Exception auf pass# Outputzweites42erstes# Kurzschreibweise, Python generiert obiges darausfor element in a.keys(): print(element)# Outputzweites42erstesfor i in zip(a,b): # erzeugt Paare aus den # Arrays a und b. Die Anzahl der # Iterationen entspricht dem # kürzesten Array print(i)for i in itertools.zip_longest(a,b): # wie zip, # aber die Anzahl der # Iterationen entspricht dem # längsten Array. # Fehlende Werte werden mit # 'None' aufgefüllt. Mit dem # Parameter 'fillvalue' kann # man einen anderen Füllwert # wählen print(i)for i in itertools.product(a,b): # erzeugt alle aus a # und b möglichen # Paare print(i)karten = list()for i in itertools.product(werte,farben): karten.append(i)summe = functools.reduce (lambda x, y: x + y, a, 0) # erster Parameter: function, zweiter # Parameter: sequence, # optionaler dritter Parameter: Startwertwerte = { 'sieben': 0, 'zehn': 10, ... }skat = { "Pik sieben": 0, "Kreuz Ass": 11, ...}import itertoolswerte = ['sieben', 'acht', 'neun', 'zehn', 'Bube', 'Dame', 'Koenig', 'Ass']farben = ['Karo', 'Pik', 'Kreuz', 'Herz']werteDict = { 'sieben': 0, 'acht': 0 , 'neun': 0, 'zehn': 10, 'Bube': 2, 'Dame': 3, 'Koenig': 4, 'Ass': 11}skat = {}for i in itertools.product(farben, werte): skat[i[0]+' ' +i[1]] = werteDict[i[1]]Lektion 5
class MyClass(Basisklasse1, Basisklasse2, ...): ... # Methoden (Funktionen) der Klasseclass MyClass(object): ...class MyClass(object): def __init__(self, arg1, arg2, ...): ... # Initialisierung von 'self'my_object = MyClass(arg1, arg2, ...)class Point(object): def __init__(self, x, y): self.x = x self.y = ypoint = Point(10, 20)class Point(object): def __init__(self, x=0, y=0): self.x = x self.y = ypoint = Point()assert point.get_x() == 0 and point.get_y() == 0point1 = Point(1) # => Point(1,0)class Point(object): def __init__(self, x, y): self.x = x self.y = y def get_x(self): return self.x def get_y(self): return self.ypoint = Point(10, 20)print(point.get_x(), point.get_y()) ... def set_x(self, x_new): self.x = x_new def set_y(self, y_new): self.y = y_newpoint = Point(10, 20)point.set_y(-10)# Python macht daraus intern den Aufruf# Point.set_y(point, y)# ^ self ... def __str__(self): return "({}, {})".format(self.x, self.y)class Point(object): ..... # all other methods of the class def __eq__(self, other): return self.x == other.x and self.y == other.y def __ne__(self, other): return self.x != other.x and self.y != other.yp1 = Point(100,100)p2 = Point(100,100)p3 = Point(12,100)# testsassert p1 == p2assert p1 != p3 ... def __lt__(self, other): if self.y == other.y: return self.x < other.x else: return self.y < other.yclass Point(object): .... def __lt__(self, other): if self.y == other.y: return self.x < other.x else: return self.y < other.y def __ge__(self,other): return not self < other def __gt__(self,other): return not self < other and not self == other def __le__(self,other): return not self > otherp1 = Point(100,100)p2 = Point(100,100)p3 = Point(12,100)assert p3 < p1assert p3 >= p3assert p1 > p3assert p1 <= p1assert p3 <= p1 # ... usw. ... def __len__(self): return 2 def __getitem__(self, index): if index == 0: return self.x elif index == 1: return self.y else: raise IndexError("Point[index]: index must be 0 or 1") def __setitem__(self, index, value): if index == 0: self.x = value elif index == 1: self.y = value else: raise IndexError("Point[index]: index must be 0 or 1")point = Point(10, 20)# automatische Schleifefor coord in point: print(coord)# Schleife mit expliziter Indexierungfor k in range(len(point)): coord = point[k] print(coord)# Schleife mit IndexError als Stop-Kriteriumtry: k = 0 while True: coord = point[k] print(coord) k += 1except IndexError: pass# Ausgabe in allen Fällen10 # x-Koordinate20 # y-Koordinateclass Image(object): def __init__(self, width=0, height=0): # vermeide Redundanz => Größe festlegen # und Speicher anlegen nur einmal # implementieren und hier wiederverwenden self.resize(width, height) def get_width(self): return self.width def get_height(self): return self.height def resize(self, new_width, new_height): self.width = new_width self.height = new_height # alle Pixel mit 0 initialisieren self.pixel = [0]*(new_width*new_height)image = Image(100, 200) # Konstruktorimage[10, 12] = 100 # Pixel (10, 12) setzenprint(image[0,0]) # Pixel (0, 0) lesen ... def __getitem__(self, coord): index = coord[0] + self.width*coord[1] return self.pixel[index] def __setitem__(self, coord, value): index = coord[0] + self.width*coord[1] self.pixel[index] = valueassert image[3,4] == image[Point(3,4)]x, y = 3, 4point = Point(x,y)assert image[x,y] == image[point]" 0 123 12\n 42 5 255\n 156 27 9" 0 255 0255 0 255 0 255 0def writePGM(image, filename): with open(filename, 'w') as file: file.write('P2\n') file.write('{} {}\n'.format(image.get_width(), image.get_height())) file.write('255\n') file.write(str(image))width, height = 200, 200feld = 20image = Image(width, height)for y in range(height): for x in range(width): if (x // feld + y // feld) % 2 == 0: image[x,y] = 255 else: image[x,y] = 0writePGM(image, 'schachbrett.pgm')Lektion 6
def smoothImage(image): result = Image(image.width, image.height) for y in range(1, image.height-1): for x in range(1, image.width-1): # ^ Rand skippen ^ sum = 0 for yy in range(y-1, y+2): for xx in range(x-1, x+2): sum += image[x,y] average = round(sum / 9) result[x, y] = averageassert image.get_reflected(1,2) == image[1,2]assert image.get_reflected(-1,-2) == image[1,2]class Image(): ... def get_reflected(self, x, y): if x < 0: x = -x elif x >= self.width: x = 2*self.width-2-x if y < 0: y = -y elif y >= self.height: y = 2*self.height-2-y # jetzt enthalten x und y gültige Indizes, # eventuell sind diese reflektiert return self[x,y]image = Image(3,3)# fülle mit aufsteigenden Zahlenimage.pixel = range(9)print(image)# Ausgabe# 0 1 2# 3 4 5# 6 7 8assert image.get_reflected(-1, 0) == 1assert image.get_reflected(-2, 0) == 2assert image.get_reflected(0, -1) == 3assert image.get_reflected(1, -2) == 7assert image.get_reflected(3, 0) == 1assert image.get_reflected(4, 0) == 0assert image.get_reflected(0, 3) == 3assert image.get_reflected(1, 4) == 1def drawLine(image, p0, p1, value): dx = p1[0] - p0[0] dy = p1[1] - p0[1] steps = max(abs(dx), abs(dy)) dx /= steps dy /= steps # range(step+1), weil sonst der Punkt p1 nicht # gezeichnet wird (Zählung ab 0) for k in range(steps+1): # Geradengleichung mit Parameter k x = p0[0] + round(k*dx) y = p0[1] + round(k*dy) # clipping condition if x >= 0 and x < image.width and \ y >= 0 and y < image.height: # erlaubt ist in Python auch: # if 0 <= x < image.width and ... image[x, y] = valuedef drawRectangle(image, p0, p1, value): p2 = Point(p0[0], p1[1]) p3 = Point(p1[0], p0[1]) # Äquivalent und vielleicht lesbarer wäre # p2 = Point(p0.x, p1.y) # p3 = Point(p1.x, p0.y) drawLine(image, p0, p2, value) drawLine(image, p2, p1, value) drawLine(image, p1, p3, value) drawLine(image, p3, p0, value)Lektion 7
class Line: def __init__(self, p0, p1, value): self.p0 = p0 self.p1 = p1 self.value = value def draw(self, image): drawLine(image, self.p0, self.p1, self.value)class Drawing: def __init__(self): self.items = [] def add(self, item): self.items.append(item) def draw(self, image): for item in self.items: item.draw(image)rect = Rectangle(Point(9,11), Point(21,19), 255)line = Line(Point(9,19), Point(21,11), 128)draw = Drawing()draw.add(rect)draw.add(line)outer = Drawing()outer.add(draw)outer.add(draw)image = Image(150,100)outer.draw(image)class Shifter: def __init__(self, item, offset): # 'item' ist das Zeichenobjekt, das # verschoben gezeichnet werden soll self.item = item self.offset = offset def draw(self, image): self.item.drawShifted(image, self.offset) def drawShifted(self, image, offset): total_offset = self.offset + offset self.item.drawShifted(image, total_offset)rect = Rectangle(Point(9,11), Point(21,19), 255)line = Line(Point(9,19), Point(21,11), 128)draw = Drawing()draw.add(rect)draw.add(line)outer = Drawing()outer.add(draw)# füge Kopie verschoben einouter.add(Shifter(draw, Point(10,10)))image = Image(150,100)outer.draw(image)class EmbeddedImage: def __init__(self, image): self.image = image def draw(self, target_image): # verwende hier 'drawShifted()' mit offset=(0,0) # um Codeduplizierung zu vermeiden self.drawShifted(target_image, Point()) def drawShifted(self, target_image, offset): ... # your code here# ändern Sie den folgenden Aufruf so, wie Ihre# Bildklasse aus einem File aufgebaut wirdimage = readPGM("filename")embed = EmbeddedImage(image)drawing = Drawing()drawing.add(embed)# füge eine verschobene Kopie von 'embed' eindrawing.add(Shifter(embed, Point(100,100)))target_image = Image(350,300)drawing.draw(target_image)def computeNeighbors(point, width, height): # Nachbarn ausrechnen und in Liste schreiben return neighbors# Hilfsfunktiondef isInside(point, width, height):def floodFill (image, point, value):class FloodFill: Lektion 8
Lektion 9
from unittest import TestCaseclass MyTest(TestCase): def test_something(self): # test something here two = self.helper_function() self.assertTrue(1 + two == 3) def helper_function(self): # do something helpful return 2class MyTest(TestCase): def setUp(self): # the name must be setUp, nothing else self.my_array = [1, 2, 3] def test_my_array(self): self.assertEqual(len(self.my_array), 3) def tearDown(self): # the name must be tearDown, nothing else print("Clean up something super important")class TestRaise(TestCase): def test_str_to_int(self): with self.assertRaises(ValueError): int("this is not a number") def test_sqrt_of_negative(self): with self.assertRaises(ValueError): math.sqrt(-1)Wiederholung
from math import sqrt# Betragsfunktion, die an der Spitze abgerundet ist# größeres 'epsilon' = mehr Abrundungdef soft_abs(value, epsilon=1e-7): return sqrt(value**2 + epsilon**2)array = ... # Array von Zahlen# soft_abs() anwenden mit Schleiferesult = []for elem in array: result.append(soft_abs(elem))def my_map(function, iterable): result = [] for elem in iterable: result.append(function(elem)) return result# verwende 'map' anstelle einer Schleiferesult = my_map(soft_abs, array)result = [soft_abs(elem) for elem in array]x_array = ... # Array von x-Koordinateny_array = ... # Array von y-Koordinatendef norm(x, y): # auch oft 'hypot' genannt return sqrt(x**2 + y**2)norms = map(norm, x_array, y_array)norms = [norm(coord[0], coord[1]) for coord in zip(x_array, y_array)]norms = []for k in range(len(x_array)): norms.append(norm(x_array[k], y_array[k]))uebungspunkte = ... # Punkte pro Aufgabe als Arrayzwischensumme = 0for aufgabe in uebungspunkte: zwischensumme += aufgabesumme = zwischensummefrom functools import reducesumme = reduce(lambda zwischensumme, aufgabe: zwischensumme + aufgabe, uebungspunkte)# das implementiertzwischensumme = uebungspunkte[0]for aufgabe in uebungspunkte[1:]: zwischensumme += aufgabesumme = zwischensummesumme = sum(uebungspunkte)summe = reduce(lambda zwischensumme, aufgabe: zwischensumme + aufgabe, uebungspunkte, 0) # '0' ist der Initialwertdef addiere(zwischensumme, aufgabe): return zwischensumme + aufgabeaddiere = lambda zwischensumme, aufgabe: zwischensumme + aufgabeuebungspunkte = ... # Punkte pro Aufgabe als Arrayrunning_total = [uebungspunkte[0]]for aufgabe in uebungspunkte[1:]: running_total.append(running_total[-1] + aufgabe)from itertools import accumulaterunning_total = accumulate(uebungspunkte, lambda zwischensumme, aufgabe: zwischensumme + aufgabe)# das 'lambda' kann man weglassen, weil Addition die# Default-Operation istrunning_total = accumulate(uebungspunkte)uebungspunkte = {'mueller': 200, 'schultze': 35, ...}total = 310klausurzulassung = []for student in uebungspunkte.keys(): if uebungspunkte[student] / total >= 0.5: klausurzulassung.append(student)klausurzulassung = [student for student, punkte in uebungspunkte.items() if punkte / total >= 0.5]klausurzulassung = filter( lambda student: uebungspunkte[student] / total >= 0.5, uebungspunkte.keys())class MyRange: def __init__(self, start, stop, step): # Endlosschleifen verhindern if step == 0: raise ValueError("MyRange(): step must be non-zero") self.current = start self.stop = stop self.step = step def __iter__(self): return self # MyRange ist schon ein Iterator def __next__(self): # Abbruchbedingungen testen if self.step > 0 and self.current >= self.stop: raise StopIteration() if self.step < 0 and self.current <= self.stop: raise StopIteration() # einen Schritt ausführen und den alten Wert zurückgeben result = self.current self.current += self.step return resultfor k in MyRange(0, 10, 2): print(k)# dieser Generator ist in 'itertools' bereits vorhandendef count(start=0): current = start while True: yield current current += 1jetzt_ist_aber_schluss = 999for k in count(): if k == jetzt_ist_aber_schluss: break # Schleife abbrechen ... # Code ausführen, wenn noch nicht Schluss istdef myformat(x): return "{:0>13,.3f}".format(x)a = [53453.56465,46548.54654,878.454,8984]print(list(map(myformat, a)))print([myformat(k) for k in a])print(list(map(lambda x: "{:0>13,.3f}".format(x), a)))from itertools import accumulateimport operatorfrom functools import reducedef factorial(x): return max(list(accumulate(range(1,x+1), operator.mul)))def myfactorial(x): return reduce(lambda x,y: x*y, range(1,x+1))assert factorial(45) == myfactorial(45)from math import sqrt, floordef perfectSquares(liste): return list(filter(lambda x: sqrt(x)==int(sqrt(x)), liste))print(perfectSquares(range(10)))print(len(set(mylist)))def ganz(): x = input("aa:") try: int(x) x[2] except ValueError as e: print(e) ganz()