lehrkraefte:snr:informatik:python:wichtiges-zur-projektarbeit [https://fginfo.ksbg.ch Fachgruppe Informatik der KSBG]

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== 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]]