Seminararbeit Fachdidaktik Informatik

1. Einordnung der Unterrichtsstunde [zurück]

Diese Stunde ist Bestandteil der 2. Phase unserer Halbjahresplanung. Sie umfasst die Behandlung von Struktogrammen nach Nassi-Shneiderman.
Notwendige Voraussetzungen aus den vorhergehenden Stunden sind ein sicherer und geübter Umgang mit der Programmieroberfläche, mit der Grafikbibliothek und mit den bisher erlernten Sprachelementen, speziell denen der objektorientierten Betrachtung. Ich gehe davon aus, dass zuvor der Begriff Algorithmus und umgangssprachliche Kontrollstrukturen anhand von Alltagsalgorithmen definiert und thematisiert wurden. Außerdem sollten die Schüler mit Hilfe der Grafikbibliothek und Pythons Kontrollstrukturen in selbständiger Arbeit einen einfachen Algorithmus entwickelt haben, der eine Bedingung oder/und eine Wiederholung enthält, um somit die Effektivität von Kontrollstrukturen zu verinnerlichen und deren Bedeutung in Algorithmen zu erkennen.
In der zu behandelnden Unterrichtsstunde soll nun die Handhabung von Struktogrammen eingeführt und geübt werden. Dabei soll bereits auf die Syntax von Python geachtet werden, damit die Struktogramme sofort in ihren jeweiligen Programmcode übersetzt werden können. Die Algorithmen beinhalten erstmal nur das Positionieren von mehreren Objekten, z.B. eine Schleife zur Anordnung in jede Ecke des Spielfeldes.
Die nächste Stunde dient dann zur Entwicklung von Algorithmen für bewegte Objekte, im Hinblick auf die Umsetzung des Squash-Spiels, und zur Leistungsüberprüfung des Teilgebietes "Kontrollstrukturen".
Im Folgenden geht es dann weiter mit der Behandlung von Klassenbeziehungen und der Festigung des Gelernten durch die Erstellung des Quellcodes für das Squash-Spiel.

Ein Algorithmus ist der Entwurf einer Lösungsidee. Er besteht aus klar und deutlich formulierten Schritten, die mit endlichem Aufwand in endlicher Zeit ausführbar sind. Ein Programm ist somit ein Algorithmus, jedoch gebunden an eine Programmiersprache.

Als Kontrollstrukturen werden im Allgemeinen Sprachmittel zum Steuern einer Ausführungsreihenfolge von Anweisungen bezeichnet. Kontrollstrukturen in einem Programm ermöglichen es, bestimmte Anweisungsblöcke nur unter bestimmten Bedingungen oder mehrfach zu durchlaufen. Sie kontrollieren also den Programmablauf.
Bei Programmen die keine Kontrollstrukturen aufweisen werden die Anweisungen in der Reihenfolge abgearbeitet in der sie im Quelltext vorkommen.

Kontrollstrukturen der Programmiersprache Python

Unter einem Struktogramm (Nassi-Shneiderman-Diagramm) versteht man die graphische Darstellung eines Programmablaufs mit entsprechenden Operationen. Es stellt ein Modell dar, mit dessen Hilfe Programme unabhängig von der Programmiersprache entwickelt werden können. Der Lesefluss eines Struktogramms erfolgt von oben nach unten, genauso wie die Abarbeitung erfolgen soll. Umfangreiche und komplexe Programme sind so leicht lesbar. Jedes Struktogramm besteht aus einzelnen Elementstrukturblöcken, die jeweils einen Programmschritt symbolisieren und anschließend kantendeckend aneinander gefügt und gegebenenfalls ineinander verschachtelt werden. Jeder Strukturblock zeichnet sich dadurch aus, dass er nur einen Eingang und nur einen Ausgang besitzt.

Ich hatte zuerst überlegt den Aufbau eines Struktogramms über den klassischen Frontalunterricht einzuführen. Da ich jedoch die Sachanalyse selbst über das Internet durchgeführt habe und dort auch einiges nachlesen konnte, habe ich diesen Zugang zu den Struktogrammen gewählt. Somit sind die Schüler gezwungen sich eigene Gedanken zum Thema zu machen und sind auch eher bereit das Ganze kritisch zu betrachten. Ich habe leider in meinen bisher unterrichteten Stunden festgestellt, dass die Schüler meistens den Vortrag des Lehrers akzeptieren und sich wenig eigene Gedanken machen. So kann ich dem entgegenwirken. Außerdem lernen die Schüler, das Internet auch zum Wissenserwerb zu nutzen und somit sich selbst zu helfen.

Die Schüler werden in drei Gruppen aufgeteilt. Dabei sind die Schüler nicht gezwungen zusammenzuarbeiten. Die Gruppeneinteilung dient eher der Themenunterscheidung. Eine Gruppe soll sich mit der Definitionen von Struktogrammen und dem grundsätzlichen Aufbau beschäftigen, die andere mit der Darstellung einer Schleife und eine weitere mit dem Aufbau der Bedingung, wobei jede Gruppe auch nach Beispielen Ausschau halten soll. Über diese soll dann nach dem Zusammentragen der Ergebnisse diskutiert werden, damit die Schüler auch lernen die Meinung ihrer Mitschüler kritisch zu betrachten. Die Ergebnisse werden von einem Schüler der jeweiligen Gruppe vorgetragen und zu einem Tafelbild zusammengefügt.

So erhalten die Schüler einen bleibenden Überblick über den Aufbau eines Struktogramms und werden in den Methoden-, Sach- und Selbstkompetenzen geschult.

In einer ersten Anwendung sollen die Schüler dann das zusammengetragene Wissen verinnerlichen. Dazu sollen sie den vorgegebenen Pythoncode der Methode eins() in ein Struktogramm umwandeln und herausfinden, was diese Methode ausführt. Die Methode enthält Wiederholungen und Bedingungen.

In der zweiten Anwendung sollen die Schüler sich dann anhand eines Problems einen Algorithmus in Form eines Struktogramms überlegen. Gegenüber der ersten Anwendung müssen die Schüler jetzt ohne Hilfe handeln. Sie sollen mehrere Bälle diagonal anordnen bis sie an eine Wand stoßen, dann sollen die Bälle in die entgegengesetzte Richtung diagonal angeordnet werden. Unter der Sicht des Gesamtkonzeptes "Squash-Spiel" ist dies bereits ein Teilproblem bzw. Teilalgorithmus. Die Schüler können diese Überlegungen in der Erarbeitung des Quelltextes des Squash-Spiels wieder aufgreifen.

from grafik import *
import math

class HSpielfeld(TZeichenblatt):
    def __init__(self):
        TZeichenblatt.__init__(self)


class HBall(TKreis):
    #Erzeugung einer Klasse mit den Parametern Spielfeld, x- und y-Koordinate des Mittelpunktes
    #und Füllfarbe 
    def __init__(self,SF,x,y,f):
        TKreis.__init__(self,SF)
        self.Spielfeld=SF                                         #Zuordnung zum Spielfeld
        self.setzeRadius(20)                                      #Festlegen des Radius
        self.setzeMPos(x-self.holeRadius(),y-self.holeRadius())   #Startpunkt festlegen
        self.Farbe.setzeFarbname("gruen")                         #Festlegen der Randfarbe 
        self.Fuellfarbe.setzeFarbname(f)                          #Festlegen der Füllfarbe
        
    #Methode, die ein Objekt bewegt
    def bewegen(self,x,y):
        self.posVersetzenUm(x,y)    #Versetzt das Objekt um x(y) entlang der x(y)-Achse
        self.zeigen()               #zeigt das Objekt an der neuen Position

        
def eins():
    #Erzeugen eines Balls
    ball=HBall(spielfeld,0,0,"weiss")
    j=1                 #Startwert j
    #Anzeigen von Bällen  entlang der y-Achse im Abstand 500
    while (j*50 < (spielfeld.holeHoehe()-ball.holeRadius())):
        i=1             #Startwert i
        #Anzeigen von Bällen entlang der x-Achse im Abstand 50 
        while (i*50 <(spielfeld.holeBreite()-ball.holeRadius())):
            #Auswahl von Spalten in denen die Bälle gruen sein sollen 
            if i in (1,3,5,7,9,11,13,15,17,19):
                ball=HBall(spielfeld,i*50,j*50,"gruen")
                ball.zeigen()
            #sonst sind die Bälle rot 
            else:
                ball=HBall(spielfeld,i*50,j*50,"rot")
                ball.zeigen()
            i=i+1
        j=j+1

            
#diagonale Anordnung von Bällen mit Reflexion an der Wand 
def vier():
    ball=HBall(spielfeld,0,0,"weiss")
    i=1
    j=1
    while (j*20 <(spielfeld.holeHoehe()-ball.holeRadius())) \
                 and (i*20 <(spielfeld.holeBreite()-ball.holeRadius())):
        ball=HBall(spielfeld,i*20,j*20,"rot")
        ball.zeigen()
        i=i+1
        j=j+1
        print j
    j=j-2
    print j
    while (j*20 <(spielfeld.holeHoehe()-ball.holeRadius())) \
                 and (i*20 <(spielfeld.holeBreite()-ball.holeRadius())):
        print j
        ball=HBall(spielfeld,i*20,j*20,"rot")
        ball.zeigen()
        j=j-1
        i=i+1
    
    
#--------------------------Main------------------------------

fenster=Tkinter.Tk()
spielfeld=HSpielfeld()
ball=HBall(spielfeld,50,50,"rot")
spielfeld.pack()
vier()
fenster.mainloop()

Inhalt