Differences

This shows you the differences between two versions of the page.

--- lehrkraefte:snr:informatik:python:wichtiges-zur-projektarbeit [2021/11/09 15:22] – [Beispiel] Olaf Schnürer
+++ lehrkraefte:snr:informatik:python:wichtiges-zur-projektarbeit [2022/05/23 10:40] (current) – [Allgemeines und Zeitplan] Olaf Schnürer
@@ Line 1: / Line 1: @@
+====== Wichtiges zur Projektarbeit der Klassen 2aLM und 2dNP ======
+Ich habe versucht, einige wichtige Informationen zusammenzustellen. Bei Fragen oder Bemerkungen bitte direkt an mich wenden.
+===== Allgemeines und Zeitplan =====
+  * Es sind Zweier- und Einsergruppen erlaubt, im folgenden Gruppe genannt.
+  * Jede Gruppe schreibt ein Python-Programm im Rahmen eines selbstgewählten Projektes.
+  * Jede Gruppe beschreibt mir ihr Projekt möglichst bis zum 17. November, damit ich einschätzen kann, ob es realistisch ist, und damit ich eventuell rechtzeitig Änderungen vorschlagen kann.
+  * Arbeit an den Projekten in 4 Doppellektionen (oder auch ab sofort): 17. und 24. November, 1. und 8. Dezember 2021
+  * Abgabe der lauffähigen Python-Programme: idealerweise nach der Doppellektion am 8. Dezember, spätestens am 14. Dezember um 23:59 Uhr (vermutlich per Email an mich)
+  * 15. Dezember (letzte Doppellektion vor Weihnachten): Kurzpräsentation der Projekte durch alle Gruppenmitglieder, danach jeweils kurze Fragerunde (ca. 5 Minuten pro Gruppe, je nach Anzahl der Gruppen). Bei Abwesenheit eines Gruppenmitglieds wird die Präsentation nachgeholt.
+  * Wer will, dass sein Python-Programm im Rahmen der Kurs-Seiten (mit dem dortigen Copyright) veröffentlicht wird, gibt mir Bescheid (am besten mit der Abgabe).
+  * Alle Mitglieder einer Gruppe bekommen dieselbe Note.
+  * Jede Gruppe darf selbst eine Note vorschlagen, am Ende entscheide aber ich.
+===== Themenwahl =====
+  * Jede Gruppe sucht ein Thema, das in der verfügbaren Zeit sinnvoll bearbeitet werden kann. Das Thema sollte weder zu schwierig noch zu einfach sein.
+  * Wer auf der Suche nach einem geeigneten Thema ist, möge etwa an Simulationen (z. B. Virusausbreitung), (kleine) Spiele, Apps, Analyse von Daten, Mathematisches, Physikalisches, ... denken.
+  * Inspiration darf man sich gerne im Internet holen, etwa von [[https://www.tigerjython.ch/|Tigerjython]] oder von Wikipedia (starte etwa bei [[https://de.wikipedia.org/wiki/Sierpinski-Dreieck|Sierpinski-Dreieck]] und folge je nach Interesse den Links; nutze auch Versionen der Seiten in anderen Sprachen - oft enthält die englische Seite deutlich mehr Informationen).
+  * Wer Probleme bei der Themenwahl hat, wende sich an mich: Ich habe eine Liste mit Vorschlägen, will aber eure Kreativität nicht einschränken und bin gespannt auf eure Ideen.
+===== Zeitmanagement =====
+  * Versucht, möglichst schnell ein Programm zu schreiben, das ihr "im Notfall" abgeben könnt.
+  * Kümmert euch erst dann um Optimierungen, Verbesserungen, graphische Verschönerungen.
+  * Wenn ihr aus wichtigen Gründen nicht genügend Zeit habt (etwa nicht bei allen vier Doppellektionen anwesend sein könnt), teilt mir dies bitte mit, damit ich meine Bewertung entsprechend anpassen kann.
+===== Ehrlichkeit  =====
+alias "Abschreiben verboten" alias (an der Uni) "wissenschaftlich korrektes Arbeiten"
+  * Jede Gruppe bearbeitet ihr Projekt eigenständig. Ausdrücklich erlaubt ist es, Hilfe von Lehrpersonen, Klassenkameraden, Verwandten, Freunden etc. einzuholen, solange diese "beratend" ist.
+  * Inspiration darf man sich überall holen. Wesentliche Inspirationsquellen müssen aber offen benannt werden, etwa durch einen Kommentar im Programm. (Etwa: "Die Idee für diesen Programmteil kommt von der folgenden Web-Seite." oder "Dieser Programmteil ist wesentlich beeinflusst von ...")
+  * Verboten ist es beispielsweise, einfach Code-Fragmente ohne Angabe der Quelle aus dem Internet zu kopieren (Plagiat). Statt stupidem Kopieren empfehle ich zumindest "mitdenkendes Abschreiben mit kleinen Veränderungen" samt Angabe der Quelle.
+  * "Lehrbuchwissen" (also bei uns das, was in Programmierkursen erklärt wird) darf ohne Angabe der Quelle verwendet werden.
+===== Einige Punkte, auf die ich bei der Bewertung achte =====
+  * Das Python-Programm ist lauffähig.
+  * Am Anfang des Programms ist kurz als Kommentar erklärt, was das Programm tut.
+  * Das Python-Programm ist übersichtlich geschrieben. (Sinnvolle, erklärende Kommentare im Programmcode sind erlaubt.)
+  * Bei Interaktion mit dem Benutzer soll klar sein, was dieser tun soll oder darf.
+  * Wichtige Konzepte des Programmierkurses werden sinnvoll verwendet (etwa if-Selektion, for- oder while-Schleifen, Listen, Funktionen, eventuell Grafik).
+  * Kompliziertheit des Programms: Wie schwierig war es, die Projektidee in ein Programm umzusetzen?
+  * Das Programm ist "kompakt" und zweckmässig. (Alle Programmteile sind relevant - beispielsweise tauchen keine Variablen auf, die nirgends verwendet werden. Es ist schwierig, ein kürzeres Programm mit derselben Funktionalität zu schreiben.)
+===== Beispiel =====
+Hier ist mein Projekt, für das ich mir eine 6 geben würde 8-) - eine ähnliche Simulation findet sich auf [[https://en.wikipedia.org/wiki/Percolation|Wikipedia: Percolation]].
+<code python>
+# Autor: Olaf Schnürer
+#
+# Simulation eines Versickerungsprozesses (Perkolation).
+#
+# Zuerst erzeugen wir ein "poröses Gestein": In einem rechteckigen Raster
+# von Pixeln (= Bildpunkten, hier eigentlich kleinen Quadraten) werden Pixel
+# mit einer fixierten Wahrscheinlichkeit p dunkel gefärbt. Dunkle Pixel stehen
+# für wasserundurchlässigen Fels. Die restlichen Pixel stehen für Luft.
+#
+# Wir stellen uns vor, dass oberhalb des Gesteins beliebig viel Wasser vorhanden
+# ist und simulieren, wie dieses in das Gestein eindringt (Luft kann dabei beliebig entweichen).
+#
+# Mögliche Anschlussfrage: Ab welcher Wahrscheinlichkeit erreicht
+# das Wasser "meist" den Boden? Dazu könnte man (in einem neuen Programm)
+# etwa für alle p zwischen 0.4 und 0.5 in Schritten von 0.01 jeweils 100 Simulationen
+# laufen lassen (ohne grafische Ausgabe, damit es schneller geht) und
+# dann in einem "Balkendiagramm darstellen, wie oft der Boden bei welcher
+# Wahrscheinlichkeit erreicht wird. (Monte-Carlo-Methode)
+from gpanel import *
+from random import randint, random
+# Abmessungen des Gesteins:
+Xmax = 400
+Ymax = 200
+# Seitenlänge eines Quadrats in Bildschirm-Pixel
+skalierung = 4
+# Wahrscheinlichkeit für Fels
+p = 0.41
+def zeichne_quadrat(x, y, farbe):
+    setColor(farbe)
+    fillRectangle(x * skalierung, y * skalierung, (x + 1) * skalierung, (y + 1) * skalierung)
+    setColor("black")
+    rectangle(x * skalierung, y * skalierung, (x + 1) * skalierung, (y + 1) * skalierung)
+# Öffne Fenster und vereinbare Koordinaten.
+makeGPanel(Size(Xmax * skalierung, Ymax * skalierung + 30))
+window(0, Xmax * skalierung, -30, Ymax * skalierung)
+# poröses Gestein wird zufällig erzeugt
+# Der folgende Code verwendet, dass man beim Erzeugen von Listen
+# zusätzlich eine "if-(then-)else"-Abrage machen kann.
+feld = [["gray" if random() < p else "white" for j in range(-1, Ymax + 1)] for i in range(-1, Xmax + 1)]
+# Die folgenden beiden for-Schleifen erzeugen eine "bounding box"
+# aus Fels. (Das erspart später das Abfragen, ob man gerade einen Punkt am Rand betrachtet.)
+for i in range(-1, Xmax + 1):
+    feld[i][-1] = "gray"
+    feld[i][Ymax] = "gray"
+for j in range(-1, Ymax + 1):
+    feld[-1][j] = "gray"
+    feld[Xmax][j] = "gray"
+# Zeichne das poröse Gestein.
+for i in range(0, Xmax):
+    for j in range(0, Ymax):
+        zeichne_quadrat(i, j, feld[i][j])
+# getKeyCodeWait()
+# Erstelle Start-Liste blauer Felder alias Wasser:
+# Alle "Luftfelder" in der obersten Zeile werden aufgenommen.
+# Für jedes Wasserfeld werden seine Koordinaten gespeichert.
+blaue_felder = []
+for i in range(0, Xmax):
+    if feld[i][Ymax - 1] == "white":
+        feld[i][Ymax - 1] = "blue"
+        blaue_felder.append([i, Ymax - 1])
+#        zeichne_quadrat(i, Ymax - 1, "blue")
+# print(blaue_felder)
+# Solange die Liste blauer Felder nicht leer ist,
+# wird jeweils das erste blaue Feld betrachtet, eingefärbt und eventuelle Luftnachbarn
+# werden hinten an die Liste drangehängt.
+while len(blaue_felder) > 0:
+    aktuell = blaue_felder.pop(0)
+    x = aktuell[0]
+    y = aktuell[1]
+#    print(blaue_felder)
+#    print(x, y)
+    zeichne_quadrat(x, y, "blue")
+    if (x > 0) and (feld[x-1][y] == "white"):
+        feld[x-1][y] = "blue"
+        blaue_felder.append([x-1, y])
+    if (x < Xmax - 1) and (feld[x+1][y] == "white"):
+        feld[x+1][y] = "blue"
+        blaue_felder.append([x+1, y])
+    if (y > 0) and (feld[x][y-1] == "white"):
+        feld[x][y-1] = "blue"
+        blaue_felder.append([x, y-1])
+    if (y < Ymax - 1) and (feld[x][y+1] == "white"):
+        feld[x][y+1] = "blue"
+        blaue_felder.append([x, y+1])
+# Folgende Zeile auskommentieren, wenn sich das Wasser schneller ausbreiten soll.
+    delay(1)
+#    getKeyCodeWait()
+# Textausgabe
+text(Xmax * skalierung/3, -20, "Zum Schliessen irgendeine Taste drücken.", Font("Courier", Font.PLAIN, 20), "white", "red")
+# Warten, bis der Benutzer eine Taste drückt.
+getKeyCodeWait()
+# Fenster schliessen.
+dispose()
+</code>
+===== Link zur Kursseite =====
+[[lehrkraefte:snr:informatik:glf21|Zur Kursseite]]