Wichtiges zur Projektarbeit der Klassen 2aLM und 2dNP

Ich habe versucht, einige wichtige Informationen zusammenzustellen. Bei Fragen oder Bemerkungen bitte direkt an mich wenden.

• 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.

• 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 Tigerjython oder von Wikipedia (starte etwa bei 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.

• 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.

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.

• 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.)

Hier ist mein Projekt, für das ich mir eine 6 geben würde - eine ähnliche Simulation findet sich auf Wikipedia: Percolation.

# 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()        

Zur Kursseite