Python als Werkzeug im Informatikunterricht
von
Jeanine Umlang und Clemens Wagner
Gliederung/Inhalt
1. Die Sprache
1.1 Geschichte, Sprachkonzept
Python wurde Anfang der 90er Jahre von Guido van Rossum als
Testumgebung für ein neues Betriebssystem entwickelt.
Entwicklung der Programmiersprachen
Python ist eine portable, objektorientierte Skriptsprache. Die
Syntax ist kurz und ausdrucksstark. Durch die Einbindung von Modulen
ist Python leicht erweiterbar.
1.2 Verfügbarkeit
Python wird zur Zeit von der nicht-kommerziellen
Python Software Foundation
entwickelt. Das Sprachpaket selbst und viele
Erweiterungsmöglichkeiten, Entwicklungsumgebungen und GUI-Builder
sind frei verfügbar. Siehe dazu die Linkliste.
2. Einführung in die Syntax
| Datentypen
Der Typ einer Variablen wird durch Zuweisung
festgelegt. |
Skalare: |
| integer |
i = 1
|
| long integer |
li =
9999999999L |
| float |
f = 3.14
|
| complex |
c = 3+4j
|
| string |
s = ' Hallo '
|
| Sequenzen: |
| Listen |
L = [1, 3] |
| Tupel |
T = (1, 3) |
| Dictionarie: |
D = {'b':
'Python', 'a': 5} |
| Operatoren |
()
[] {} `` [:] . + - ~ ** * / % << >> & ^ | is in < <= > >= == <>
!= not and lambda or |
| Anweisungsfolgen |
Anweisungen der selben logischen
Gruppe stehen gleichmäßig eingerückt |
if a >
0:
b = 1
c = 2
|
| Anweisungstrennung in einer Zeile
mit ' ; ' |
if a >
0:
b = 1; c = 2
|
| Fortsetzung einer
Anweisung in die nächste Zeile mit ' \ ' oder wenn noch Klammern
"offen sind". |
| Bedingte Anweisungen |
if,
elif und
else |
if a >
b:
print 'a ist groesser als
b.'
elif a < b:
print 'a ist kleiner als b.'
else:
print 'a ist gleich b.'
|
| Schleifen
Vorzeitiges Verlassen der Schleife:
break
Direkter Sprung zum Anfang der Schleife:
continue |
while |
liste = []
i = 0
while i < 100:
liste.append(i)
i = i + 1
|
| for |
liste = []
for i in range(100):
liste.append(i)
|
| Funktionen
|
def
Es kann ein Rückgabewert in der
return-Anweisung angegeben
werden, wenn nicht, ist der Rückgabewert der besondere Wert
None. |
def
fac(x):
if x==1:
return 1
return x*fac(x-1)
|
|
Module |
- Module sind Programmteile, die in eigene
Dateien geschrieben werden, um sie in mehreren Programmen
verwenden zu können.
- Es gibt keine besondere Anweisung, um ein
Modul als solches zu kennzeichnen. Ein Modul unterscheidet
sich von einem Programm nur durch die Verwendung, nicht durch
speziellen Code.
|
#
EinModul.py
# Definiere das Modul EinModul
var1 = 1
var2 = [2, 3]
def quadrat(x):
return x * x
|
- In andere Dateien wird das Modul durch eine
import -Anweisung geladen.
|
import EinModul
test = EinModul.var1 # test = 1
test = EinModul.quadrat(7) # test = 49 |
- Namen eines Moduls können importiert
werden, indem import zusammen
mit from benutzt wird. Sonst
wird nur der Name des Moduls importiert.
|
from EinModul import var1
# importiere nur var1;
# test = var1 ist damit möglich
from EinModul
import var1, var2
# importiere var1 und var2
from EinModul
import *
# importiert alle Namen, die nicht mit
_ beginnen. |
| Objekte |
- Objekte bieten Variablen und Funktionen
(Methoden), die auf diese Daten wirken.
- Es kann mehrere Objekte der selben Art
(Instanzen) geben (in unserem Beispiel mehrere öfen), die
unabhängig voneinander sind.
|
# ofen.py
class Ofen:
def __init__( self ):
self.temperatur = 20 #
Raumtemperatur
self.klappe_auf = 0 # Klappe
zu
self.material = None # Ofen
ist leer
def klappe_oeffnen( self ):
if self.temperatur > 20:
print "Bitte vor dem
Oeffnen der Klappe den Ofen abkuehlen!"
return
self.klappe_auf = 1
def klappe_schliessen( self
):
self.klappe_auf = 0
def fuellen_mit( self,
material ):
if not self.klappe_auf:
print "Bitte vor dem
Fuellen die Klappe oeffnen!"
return
self.material =
material
def aufheizen( self,
temperatur ):
if self.klappe_auf:
print "Bitte vor dem
Aufheizen die Klappe schliessen!"
return
self.temperatur =
temperatur
def abkuehlen( self ):
self.temperatur = 20
|
| Klassen |
|
| Vererbung |
Die Ableitung neuer
Klassen von bereits bestehenden nennt man Vererbung.
|
Aus der bestehenden
Klasse Ofen kann man eine neue Klasse Umluftherd erzeugen, bei
der zusätzlich die Umluft ein- und ausgeschaltet werden kann.
#umluftherd.py
import ofen
class Umluftherd( ofen.Ofen ):
def __init__( self ):
ofen.Ofen.__init__( self )
self.umluft = 0
def umluft_an( self ):
self.umluft = 1
def umluft_aus( self ):
self.umluft = 0
|
|
3. Vorstellen der verfügbaren
Entwicklungsumgebungen und GUI-Builder
3.1 Python-Oberflächen
IDLE
Pythonwin
3.2
Entwicklungsumgebungen mit GUI-Builder
Die Wahl der IDE hängt von der Wahl
der
GUI-Bibliothek ab. Zur
Verfügung stehen zum Beispiel:
Tkinter
für Tk (das GUI Toolkit zur Scriptsprache Tcl, ist Teil des
Python-Pakets)
Easygui
Quick and Dirty -
GUI-Funktionen
Für den Schuleinsatz nicht geeignet, da die Objektorientierung
verschleiert wird!
wxWindows/wxPython
Plattformübergreifendes
GUI-Toolkit
Boa Constructor
++ sehr umfangreich (IDE
integriert alle nötigen Funktionen)
+ übersichtliche Gliederung der Oberfläche
+ guter Objektinspektor
- Entwickeln von Programmen ohne GUI ist zu aufwendig, bzw. wird
unnötiger Code generiert
Arbeit mit Templates wäre sinnvoll
VisualWx
+ umfangreich
+ übersichtlich gegliedert
+- etwas sperriger Objektinspektor
Vergleichbar mit dem "Boa Constructor", Arbeit mit Templates wäre
sinnvoll
Python Card
- Das gestaltete GUI wird nicht in Python-Code, sondern in einer
Resource-Datei gespeichert. Dadurch geht der Bezug zu GUI-Elementen als
Objekten verloren.- Zwei verschiedene Oberflächen für Code-Erstellung
("Code Editor") und GUI-Erstellung ("Resource Editor")
SpecTix
- unübersichtlich
- stark eingeschränkter Funktionsumfang
Dazu jeweils:
wxWindows Reference (Help)
für Anfänger unerlässlich und gut
handhabbar
4. Python im Informatikunterricht?!
4.1 Pro
-Die Syntax zwingt dazu, gut lesbare Programme zu schreiben und sie
ist sehr einfach zu lernen
-Python ist wegen der Klarheit der Syntax und des konsequenten
Sprachkonzepts gut geeignet um
Programmierkonzepte zu lernen!
-"named parameter" ermöglichen die Verwendung von Klassen mit
Default-Parametern
-Einfache grafische Oberflächen können dank der mitgelieferten
Tk-Bibliothek auch "zu Fuß" programmiert werden
-Es gibt brauchbare Entwicklungsumgebungen mit GUI-Buildern
4.2 Contra
-Zugriffskontrolle bei Klassenelementen ist nur als Hilfkonstrukt
verfügbar (dafür: übersichtliche Syntax)
-Angabe von "self" bei der Methodendeklaration ist überflüssig
(verdeutlicht aber die Programmstruktur!)
-Lokale und globale Variablen können leicht verwechselt werden
-Die Mischung von objektorientiertem und funktionalem Sprachkonzept
erschwert das Verständnis der beiden aus ganz verschiedenen Richtungen
kommenden Ansätze
4.3 Diskussionspunkte
Zugriffskontrolle (weniger Laufzeitfehler)
<-----> einfache Syntax
(verantwortungsvolle Programmierung)
A.
Literatur- und Linkliste
B. Abkürzungen
| API = |
Application Programming Interface |
GUI =
|
Graphical User Interface
|
| IDE = |
Integrated Development Environment |
RAD =
|
Rapid Application Development
|
C. Lösung der Aufgabe 6 (loes6.htm)
|
