.. include:: markup.rst **************** Hausaufgaben **************** Hausaufgabe 1 =============== **Hausaufgabe 1.1 (1 Punkt)** Gegeben ist folgende Berechnungsvorschrift für ``x``: .. math:: x := a \cdot \sqrt{1 - \left(\frac{y}{b}\right)^2} 1) Erzeugen Sie ein Python Skript mit beliebigem Namen mittels Spyder. 2) Schreiben Sie Ihren Namen in ein Kommentar 3) Definieren Sie drei Variablen ``a``, ``b``, ``y`` mit den Werten ``5``, ``2.5`` und ``1``. 4) Berechnen Sie den Wert von ``x``. 5) Geben Sie das Ergebnis aus 4) in der folgenden Form aus: ``x = ..., y = ...``. Setzen Sie dabei für die Punkte Ihr Ergebnis aus 4) und den Wert für ``y`` ein. 6) Wiederholen Sie die Punkte 4) und 5) aber verwenden Sie anstelle des Divisionsoperators ``/`` den Ganzzahldivisionsoperator ``//`` in der Berechnungsvorschrift. 7) Probieren Sie selbstständig weitere Werte für die Variablen ``a`` und ``b`` aus. Hausaufgabe 2 =============== **Hausaufgabe 2.1 (1 Punkt)** Gegeben ist eine Liste ``Obstkorb`` mit den Einträgen ``"Apfel","Banane","Kiwi", "Apfel", "Banane"``. Schreiben Sie Code, der die folgenden Punkte löst und lassen Sie sich zu jedem Punkt eine kurze Ausgabe mit erklärendem Text ausgeben. 1) Definieren Sie die Liste ``Obstkorb``. 2) Finden Sie heraus ob sich die Zeichenkette ``"Banane"`` in dieser Liste befindet. 3) Ermitteln Sie, wie oft ``"Banane"`` in der Liste vorkommt. 4) Bestimmen Sie alle Indizes von ``"Banane"`` in der Liste ``Obstkorb``. Kontrollieren Sie, dass Sie die richtigen Stellen gefunden haben, indem Sie die Indizes sowie die zugehörigen Werte ausgeben. 5) Löschen Sie das vorletzte Element aus ``"Obstkorb"`` und speichern Sie dieses in einer beliebigen Variablen ab. 6) Geben Sie die Länge der Liste aus. 7) Fügen Sie die Zahl ``5`` ans Ende der Liste an. 8) Multiplizieren Sie die Liste mit ``2`` und speichern Sie die neue Liste in der Variablen ``Obstkorb2``. 9) Erstellen Sie eine neue Liste ``Werte`` mit beliebigen Einträgen. Addieren Sie die Listen ``Obstkorb`` und ``Werte`` und geben Sie das Ergebnis aus. 10) Erstellen Sie eine neue Liste ``doppel_Liste``, die die Liste ``Obstkorb`` als 0. Element und die Liste ``Werte`` als 1. Element enthält. D.h. ``doppel_Liste`` ist eine Liste, die Listen enthält. 11) Erstellen Sie eine explizite Kopie der Liste ``Obstkorb`` und nennen Sie diese ``Obstkorb_Kopie`` 12) Überprüfen Sie auf mindestens eine Art, dass eine Veränderung an der Kopie die ursprüngliche Liste tatsächlich nicht verändert. .. hint :: Überprüfen Sie nach jedem Punkt durch Ausgabe in der Konsole, dass Ihr Code richtig funktioniert. **Hausaufgabe 2.2 (1 Punkt)** Drei Freunde nehmen bei einen 5km-Staffellauf teil. Die Liste ``Laufzeiten`` mit den Einträgen ``"Tobias : 27min ", "Alexander : 24.3 min", "Maria: 32 min "`` beschreibt ihre Ergebnisse. 1) Definieren Sie die gegebene Liste ``Laufzeiten``. 2) Extrahieren Sie die Zahlenwerte aus den Strings der Liste und speichern Sie sie in den Variablen ``Tobias``, ``Alexander`` und ``Maria`` als Gleitkommazahlen ab. Achten Sie darauf, dass die Strings beliebige Zahlen mit beliebig vielen Leerzeichen beinhalten können. Ein Ausgabe sollte dann wie folgt aussehen: :: In[1]:print(Tobias) 27.0 3) Berechnen Sie die Summe der Laufzeiten und geben Sie das Ergebnis per ``print`` Befehl aus. 4) Erstellen Sie ein Dictionary ``Laufzeiten_Dict``, das die Variablen ``Tobias``, ``Alexander`` und ``Maria`` mit ihren jeweiligen Zahlenwerten enthält. Dabei soll der jeweilige Variablenname als String der Schlüssel sein. Für den Wert wird der jeweilige Zahlenwert als Gleitkommazahl zugeordnet. Das Dictionary sollte folgendermaßen aussehen: :: In[2]:print(Laufzeiten_Dict) {'Tobias': 27.0, 'Alexander': 24.3, 'Maria': 32.0} 5) Errechnen Sie erneut die Summe der Laufzeiten. Verwenden Sie diesmal jedoch das Dictionary ``Laufzeiten_Dict`` für die Berechnung. Geben Sie das Ergebnis erneut per ``print`` Befehl aus. 6) Angenommen es hätte noch ein vierter Läufer an der Staffel teilgenommen, der auch den Namen ``Tobias`` trägt, jedoch eine Laufzeit von 22 Minuten erreicht hat. Fügen Sie den entsprechenden Eintrag im Dictionary hinzu (Schlüssel:``"Tobias"``, Wert:``22``) und lassen Sie sich das neue Dictionary ausgeben. Beantworten Sie folgende Frage im Kommentar: Was passiert mit dem zugehörigen Wert, wenn in ein Dictionary ein bereits vorhandener Schlüssel hinzugefügt wird? .. hint :: Um die Summe der Laufzeiten zu berechnen, erstellen Sie am besten zuerst eine Liste aller Werte des Dictionaries. Dann können Sie die Listenfunktion ``sum`` verwenden um die Summe zu berechnen. .. hint :: Stellen Sie sicher, dass Ihr Programm auch für beliebige Listen mit 3 Einträgen der gleichen Art funktioniert (andere Namen/Zeiten/Anzahl an Leerzeichen innerhalb der Strings). Hausaufgabe 3 =============== **Hausaufgabe 3.1 (1 Punkt)** Gegeben ist ein Dictionary ``Pakete`` mit z.B. folgendem Inhalt: ``'163' : 4.2, '175' : 0.5, '214' : 12, '159' : 0.3``. Die Schlüssel sind Strings und geben den Identifikationscode eines Pakets an. Der entsprechende Wert ist das Gewicht des Pakets in Kilogramm. Ab einem Gewicht von ``2 kg`` wird ein höherer Betrag für die Zustellung verlangt. Für Pakete, die leichter sind als ``2 kg`` ist die Zustellung billig. Eine Ausnahme bildet das Paket mit Identifikationsnummer ``'175'``. Für Pakete mit dieser Identifikationsnummer ist die Zustellung immer teuer. Erstellen Sie zwei Listen, ``billig`` und ``teuer``, die jeweils die Identifikationsnummern der Briefe enthalten, bei denen die Zustellung billig bzw. teuer ist. Gehen Sie wie folgt vor: 1) Legen Sie zwei leere Listen ``billig`` und ``teuer`` an. 2) Lesen Sie mit Hilfe einer Schleife die Identifikationsnummer und das Gewicht des Pakets aus. Definieren Sie dafür innerhalb der Schleife die Variablen ``ID`` und ``Gewicht``. 3) Wenn das Paket genau 2kg oder mehr wiegt oder die Identifikationsnummer ``'175'`` entspricht, fügen Sie die Identifikationsnummer zur Liste ``teuer`` hinzu. Andernfalls fügen Sie die Identifikationsnummer des Pakets zur Liste ``billig`` hinzu. 4) Geben Sie beide Listen per ``print`` Befehl aus. Die Ausgabe sollte folgendermaßen aussehen: :: In[1]:print(billig, teuer) ['159'] ['163','175','214'] .. hint :: Stellen Sie sicher, dass Ihr Programm für beliebige Dictionaries (unterschiedliche Länge, unterschiedliche Einträge) funktioniert. **Hausaufgabe 3.2 (1 Punkt)** Gegeben ist eine Liste ``Zahlungen``, die als Einträge eine Liste mit Vornamen (str) und von der Person getätigte Zahlungen in Euro (int) enthält: :: Zahlungen = [["Anna",60], ["Sarah",37], ["Marco",88], ["Stefan",100], ["Sebastian",22], ["Marco",70], ["Anna",120]] Erstellen Sie ein Dictionary ``Zahlungen_Dict`` welches als Schlüssel den Vornamen der Person enthält und als Wert die Summe der jeweiligen Zahlungen. Gehen Sie dafür wie folgt vor: 1) Erstellen Sie dazu zuerst ein leeres Dictionary ``Zahlungen_Dict``. 2) Durchlaufen Sie die Liste ``Zahlungen`` und lesen Sie in jedem Schritt den Vornamen der Person sowie die jeweilige Höhe der Zahlungen aus der Liste aus. 3) Überprüfen Sie, ob der Vorname bereits im Dictionary vorhanden ist: * Wenn der Vorname noch nicht vorhanden ist, fügen Sie im Dictionary einen neuen Eintrag hinzu, wobei der Vorname der Person der Schlüssel und die Höhe der Zahlung der Wert sein soll. * Wenn der Vorname bereits im Dictionary vorhanden ist, soll nur der Wert des bestehenden Eintrags verändert werden. Die ausgelesene Zahlung soll dabei zu der Zahlung, das bereits als Wert im Dictionary gespeichert wurde, addiert werden. 4) Geben Sie das Dictionary mit Hilfe von ``print`` aus. Am Ende sollte das Dictionary folgendermaßen aussehen: :: In [1]: print(Zahlungen_Dict) {'Anna': 180, 'Sarah': 37, 'Marco': 158, 'Stefan': 100, 'Sebastian': 22} 5) Verwenden Sie das Dictionary um das Maximum der Zahlungen zu bestimmen. Speichern Sie die Zahl unter der Variable ``Max_Zahlungen`` ab. Geben Sie die maximale Zahlung mittels print-Befehl aus. Verwenden Sie dabei für die Formatierung die f-String Methode und geben Sie die Zahl mit zwei Kommastellen aus. .. hint :: Um das Maximum der Zahlungen zu berechnen, erstellen Sie am besten zuerst eine Liste aller Werte des Dictionaries. Dann können Sie die Listenfunktion ``max`` verwenden um das Maximum herauszufinden. .. hint :: Stellen Sie sicher, dass Ihr Programm für beliebige Listen (unterschiedliche Länge, unterschiedliche Einträge) funktioniert. Hausaufgabe 4 =============== **Hausaufgabe 4.1 (1 Punkt)** Definieren Sie eine Funktion ``Pruefung``, welche eine Liste ``Pruefungsantritte`` und ein optionales Argument ``Bestehensgrenze`` (Typ:int) übergeben bekommt. Die Liste ``Pruefungsantritte`` enthält als Einträge jeweils eine Liste pro Person mit den Daten Vorname und erreichte Prüfungspunkte: :: Pruefungsantritte = [["Anton",60], ["Natalia",37], ["Manuel",88], ["Heinrich",100], ["Christoph",22], ["Mario",70]] Die Prüfung gilt als bestanden wenn zumindest 60 Punkte erreicht wurden. Das optionale Argument ``Bestehensgrenze`` soll deswegen als default Wert auf die Zahl ``60`` gesetzt werden. In der Funktion sollen nun aus der Liste ``Pruefungsantritte`` die Namen aller Personen, die die Prüfung bestanden haben, gesucht werden und in eine neu erstellte Liste geschrieben werden. Die Funktion soll dann die neu erstellte Liste und die Anzahl der Personen in dieser Liste zurückgeben. Wenden Sie nun die Funktion ``Pruefung`` im Hauptteil ihres Skripts auf die Liste ``Pruefungsantritte`` an. Rufen Sie dafür zuerst Ihre Funktion ohne Angabe des optionalen Arguments auf und lassen Sie sich die Liste und die Anzahl der Personen per print-Befehl ausgeben. Der Output sollte dann z.B. wie folgt aussehen: :: In[1]: Liste1 = Pruefung(Pruefungsantritte) In[2]: print(Liste1[0],Liste1[1]) ['Anton', 'Manuel', 'Heinrich', 'Mario'] 4 Rufen Sie danach im Hauptteil Ihres Skripts Ihre Funktion mit Angabe des optionalen Arguments auf. Setzen Sie das optionale Argument ``Bestehensgrenze`` auf eine beliebige Zahl wie zum Beispiel ``90`` und lassen Sie sich die Liste und die Anzahl der Personen erneut per print-Befehl ausgeben. In diesem Fall sollte der Output dann z.B. wie folgt aussehen: :: In[3]: Liste2 = Pruefung(Pruefungsantritte,90) In[4]: print(Liste2[0],Liste2[1]) ['Heinrich'] 1 .. hint :: Stellen Sie sicher, dass Ihr Programm für beliebige Listen (unterschiedliche Länge, unterschiedliche Einträge) funktioniert. Hausaufgabe 5 =============== **Hausaufgabe 5.1 (1 Punkt)** Ziel dieser Aufgabe ist es 3 Funktionen zu schreiben, mit denen eine Textdatei eingelesen, verarbeitet, und das Ergebnis abgespeichert werden kann. Die Funktionen sollen im Hauptteil des Programms auf eine Beispieldatei angewendet werden. In diesem Beispiel gehen wir von mehreren Messreihen aus, die in einer Textdatei dokumentiert wurden. Sie finden dafür die Beispieldatei "messreihen.txt" auf TUWEL. Jede Zeile enthält die Bezeichnung der Messreihe (z.B. "Messreihe 1"), gefolgt vom Datum (z.B. "21.8.2022") und genau 3 Messwerten. Die einzelnen Einträge sind durch einen Strichpunkt (``;``) voneinander getrennt. Eine Zeile der Datei sieht z.B. wie folgt aus: :: Messreihe 1; 21.8.2022; 20.1; 20.3; 21.0 1) Erstellen Sie eine Funktion ``Datei_einlesen(filename)``, die die Messwerte aus einer Textdatei mit Namen ``filename`` einliest und die Daten als Dictionary zurückgibt. Als Key des Dictionaries verwenden Sie die Bezeichnung der Messreihe. Der Value ist eine Liste mit den Messwerten (Liste von float Variablen). Das Datum kann ingorniert werden. Gehen Sie davon aus, dass die Textdatei im selben Verzeichnis wie Ihr Python-Skript liegt. 2) Erstellen Sie eine Funktion ``Berechne_mittelwerte(daten)``, die ein Dictionary ``daten`` übergeben bekommt. In dieser Funktion sollen 2 Listen erstellt werden: * ``bezeichnungen`` enthält die Bezeichnung aller Messreihen als string * ``mittelwerte`` enthält die Mittelwerte der jeweiligen Messreihen als float (Berechnung durch: Summe der Messwerte/Anzahl Messwerte) Die Funktion soll die beiden Listen abschließend zurückgeben. 3) Erstellen Sie eine Funktion ``Datei_schreiben(bezeichnungen,mittelwerte,filename)``. Die Funktion liest die beiden Listen ``bezeichnungen`` und ``mittelwerte`` ein und speichert die Informationen in einer Textdatei mit Namen ``filename``. Die Bezeichnung der Messreihe und deren Mittelwert sollen durch einen Doppelpunkt (``:``) getrennt sein. 4) Verwenden Sie nun Ihre 3 Funktionen, um die Beispieldatei ``messreihen.txt`` einzulesen (Funktion ``Datei_einlesen``), die Mittelwerte aller Messreihen zu bestimmen (Funktion ``Berechne_mittelwerte``), und das Ergebnis als Datei ``mittelwerte.txt`` abzuspeichern (Funktion ``Datei_schreiben``). Eine Zeile der Datei ``mittelwerte.txt`` sollte dann z.B. wie folgt aussehen: :: Messreihe 1: 20.47 .. hint :: Das Programm muss mit beliebigen Textdateien des oben genannten Formats funktionieren. Wenn Ihre Abgabe nur mit der Textdatei aus TUWEL funktioniert erhalten Sie keine Punkte. Hausaufgabe 6 =============== **Hausaufgabe 6.1 (1 Punkt)** 1) Erstellen Sie eine Klasse ``Mitarbeiter``, die die die Attribute ``name``, ``arbeitszeit`` (Jahresarbeitszeit in Stunden), und ``gehalt`` (Jahresgehalt in Euro) übergeben bekommt. ``gehalt`` soll als privates Attribut gespeichert werden. Das Erstellen eines Objekts könnte z.B. so aussehen: :: In [1]: Mitarbeiter1 = Mitarbeiter("Magdalena Muster", 1680, 58800.0) In [2]: print(Mitarbeiter1.name,Mitarbeiter1.arbeitszeit) Magdalena Muster 1680.0 2) Schreiben Sie eine Methode ``get_gehalt``, die das private Attribut ``gehalt`` zurückgibt. :: In [3]: print(Mitarbeiter1.get_gehalt()) 58800.0 3) Schreiben Sie eine Methode ``get_stundenlohn``, die den Stundenlohn (gehalt/arbeitszeit) berechnet und zurückgibt. z.B.: :: In [4]: print(Mitarbeiter1.get_stundenlohn()) 35.0 4) Überladen Sie den print Operator (``__str__``), sodass der Name und Stundenlohn ausgegeben wird, wenn die Funktion ``print`` auf ein Objekt vom Typ Mitarbeiter angewandt wird: :: In [5]: print(Mitarbeiter1) Magdalena Muster, Stundenlohn 35.00 Euro/h 5) Schreiben Sie eine Methode ``gehalt_anpassung``, die eine Gehaltsanpassung in Prozent (float) übergeben bekommt. Die Methode soll das Gehalt um diesen Prozentsatz erhöhen. z.B.: :: In [6]: Mitarbeiter1.gehalt_anpassung(10.0) In [7]: print(Mitarbeiter1.get_gehalt()) 64680.0 In [8]: print(Mitarbeiter1) Magdalena Muster, Stundenlohn 38.50 Euro/h **Hausaufgabe 6.2 (1 Punkt)** 1) Erstellen Sie eine von ``Mitarbeiter`` abgeleitete Klasse ``Programmierer``, die zusätzlich zu den Attributen von ``Mitarbeiter`` eine Liste ``programmiersprachen`` (liste von strings) übergeben bekommt. Außerdem soll die Anzahl der Programmiersprachen als Attribut ``anzahl`` gespeichert werden. Um die restlichen Attribute von ``Programmierer``, zu initialisieren, verwenden Sie den Konstruktor der Klasse ``Mitarbeiter``. Das Erstellen einer Instanz der Klasse ``Programmierer`` könnte z.B. so aussehen: :: In [1]: Programmierer1 = Programmierer("Gustav Generisch", 1680, 84000.0,["C++","Python"]) In [2]: print(Programmierer1.programmiersprachen) ['C++', 'Python'] In [3]: print(Programmierer1.anzahl) 2 2) Überladen Sie den print-Operator (``__str__``) der Klasse ``Programmierer``, sodass der Name, Stundenlohn und die Anzahl der Programmiersprachen ausgegeben wird, z.B.: :: In [4]: print(Programmierer1) Gustav Generisch, Stundenlohn 50.00 Euro/h, beherrscht 2 Programmiersprachen 3) Überladen Sie den Vergleichsoperator (``__lt__``), sodass zwei Objekte der Klasse Programmierer anhand der Anzahl von Programmiersprachen verglichen werden: :: In [5]: Programmierer2 = Programmierer("Peter Muster", 1680, 84000.0,["C++"]) In [6]: print(Programmierer1>Programmierer2) True In [7]: print(Programmierer1