Programmieren für Philosophinnen und Philosophen
Inhaltsverzeichnis
- 1 Termine
- 2 Skripte unter python.philo.at
- 3 Entwicklungsumgebung
- 4 Programme
- 4.1 Textproduktion
- 4.1.1 aufgabenstellungen
- 4.1.2 haikus
- 4.1.3 haiku vorarbeiten
- 4.1.4 verschachtelte schleifen
- 4.1.5 leichte aufgabe
- 4.1.6 vermutlich noch leichte aufgabe
- 4.1.7 eine halbwegs leichte aufgabe zu verschachtelten schleifen
- 4.1.8 "stabreime"
- 4.1.9 Anfangsbuchstaben aufsagen
- 4.1.10 nur die hauptwörter austauschen.
- 4.1.11 ausgangstext in wörter zerlegen
- 4.1.12 ausgangstext in siben zerlegen
- 4.1.13 ausgangstext in wörter zerlegen, hauptwörter extra
- 4.1.14 den ergebnis text in einen string schreiben
- 4.1.15 zusatz zu ergebnis in string: kein leerzeichen vor satzzeichen
- 4.1.16 das programm komprimieren
- 4.1.17 ausgewählte wörter nicht noch einmal auswählen
- 4.1.18 andere quellen für wörter
- 4.1.19 neue aufgabenstellungen finden
- 4.2 Textproduktion - Codeorganisation. von Funktionen zu Objekten aus Klassen
- 4.3 Wiki Integration
- 4.1 Textproduktion
Termine
- 5.10.2004 17:00-20:00,
- 19.10.2004 17:00-20:00, Hörsaal 3A (NIG, 3. Stock)
- 9.11.2004 17:00-20:00, AG-Raum NIG
- 16.11.2004 17:00-20:00, AG-Raum NIG
- fällt aus: 30.11.2004
- 14.12.2004, Hörsaal 3A (NIG, 3. Stock)
Skripte unter python.philo.at
unter /var/www/python.philo.at/htdocs/ können die skripte abgelegt werden und sind so über http://python.philo.at erreichbar.
sie sind so im computerraum am institut oder über ssh (wenn von odin für den user erlaubt) bearbeitbar.
WICHTIG: die rechte (zb: -rw-r--r--) müssen so erteilt werden, dass alle berechtigt sind die datei zu lesen.
wer dies nutzen will, bitte ich um eine mail an webmaster@python.philo.at in der er mir seinen user-namen kund tut. daher ist eine voraussetzung, ein user (zugangsberechtigung) im computerraum am institut (philosophie).
zugangsberechtigung: http://io.philo.at/service.shtml
Entwicklungsumgebung
wir verwenden Python 2.3.4, zu finden unter http://www.python.org/download.
dokumentation der programmiersprache python und der zugehörigen standard libraries ist in der installation enthalten (idle menü "help" - "python docs").
falls der einstieg in die python entwicklungsumgebung idle probleme bereitet ist http://hkn.eecs.berkeley.edu/~dyoo/python/idle_intro/index_ger.html zu empfehlen.
hinweis: programme und shell anweisungen dürfen keine umlaute enhalten.
hinweis: beim "save as" dialog muss ".py" am ende des dateinamens angegeben werden.
hinweis: der debugger kann im shell window über das menü ("Debug" - "Debugger") gestartet werden. alle drei fenster (shell, source (= .py datei) und debugger sollten so am bildschirm plaziert werden, dass sie sich nicht überdecken. im debug window sollte die checkbox "source" eingeschalten werden. im source window kann dann das programm gestartet werden wie sonst auch. im debug window kann mit der schaltfläche "over" ein schritt nach dem anderen durchgeführt werden. unten sieht man die variablenwerte.
(fragen, anmerkungen etc auf der diskussions seite, link unten in der mitte)
Python on Apple Macintosh
"MacOs X.3" beinhaltet bereits die komplette "MacPython-engine". Das Einzige was Dir also noch fehlt ist eine passende Oberfläche in der Du arbeiten kannst. Es gibt sicher mehrere "skins", die Du dabei verwenden kannst. Für den Anfang dürften die "MacPython 2.3 for Panther addons" reichen, welche Du auf dieser Seite herunterladen kannst.
Klicke dann einfach auf den Link "MacPython 2.3 for Panther addons"
Das Einzige was Du bei der Installation beachten musst, ist, dass Du als Ziellaufwerk Deine "Hauptfestplatte" angibst.
Das Programm findest Du dann im Ordner: "Festplatte/Programme/MacPython-2.3"
Mit Doppelklick auf "PythonIDE" startest Du das Programm.
Die alte Version von "MacPython" ("MacPython-OSX 2.3.3") solltest Du, so steht es auf der Webseite des Herstellers, besser nicht verwenden wenn Du "OsX.3" verwendest, da es zu Komplikationen mit dem bereits vorinstallierten "MacPython 2.3" kommen kann. Diese Version solltest Du also nur dann verwenden, wenn Du noch immer "OsX.2" verwendest. Auf derselben Seite findest Du natürlich auch eine Version für "Classic" ("MacOs 9").
Welche Version von "MacOs" auf Deinem Computer installiert ist, kannst Du herausfinden indem du links oben auf das "Apfel-Symbol" klickst und dannach "Über diesen Mac" wählst.
Programme
(fragen, anmerkungen etc auf der diskussions seite, link unten in der mitte)
Textproduktion
# woerter zufaellig zusammenstellen
import random
satz = [ 'wer', 'hat', 'an', 'der', 'uhr', 'gedreht', ',',
'ist', 'es', 'wirklich', 'schon', 'so', 'spaet', '?' ]
i = 0
while i < 14:
print random.choice( satz),
i = i + 1
#eof
aufgabenstellungen
im folgenden aufgabenstellungen und hinweise für erweiterungen oder modifikationen des "woerter zufaellig zusammenstellen" programmes.
lösungen, lösungsvarianten oder lösungsvorschläge könnt ihr auf die diskussionsseite stellen (link unten in der mitte). auch anregeungen, wünsche, beschwerden etc. (zb forderungen nach mehr hinweisen für bestimmte aufgaben, einfachere oder schwierigere aufgaben.)
ihr könnt zuerst versuchen ein programm für eine aufgabenstellung zu schreiben und dann auf der diskussionsseite nachsehen ob es schon ein programm dazu gibt, und wenn nicht (oder nicht in dieser variante), eure lösung dort hinstellen. oder ihr könnt bevor ihr ein programm schreibt euch in vorhandenen lösungen hinweise holen. oder ihr könnt versuchen bestehende lösungen zu verbessern. oder ihr könnt einen lösungsvorschlag für eine aufgabenstellung von der diskussionsseite in eurer idle / python installation laufen lassen, und versuchen herauszufinden wie das programm funktioniert. bzw ob es überhaupt funktioniert. dazu kann das verwenden des debuggers hilfreich sein. (zum debugger siehe hinweise oben.)
haikus
als nächstes könnten wir ein programm schreiben das haikus generiert (das ist nicht ganz einfach). (zb. 1.zeile 5 silben, 2.zeile 7 silben, 3.zeile 5 silben). zuerst müssen wir uns überlegen wie wir die daten im programm halten. eine liste von strings wie im beispiel oben ist zuwenig - die anzahl der silben pro wort ist nicht enthalten. dann müssen wir überlegen nach welchem verfahren wir vorgehen.
(vorschläge, entwürfe, programmcode für diese und die folgenden fragstellungen sind willkommen.)
haiku vorarbeiten
das mit den haikus selbst ist nicht so einfach. aber einfach wären zwei prototypen, in denen zuerst auf silben verzichtet wird und zwei verschiedene arten von schleifen auspobiert werden. in beiden codefragmenten soll eine zeile mit 5 wörtern, eine zeile mit 7 wörtern und eine zeile mit 5 wörtern ausgegeben werden. (vermutlich kann man neue zeilen mit einem leerem "print" (ohne parameter) bewirken.)
in der ersten variante könnte man drei schleifen, für jede zeile eine, hintereinanderhängen. jede schleife beginnt links am fensterrand. auch die anweisungen für die neue zeile beginnen links am fensterrand.
die zweiten variante könnte mit verschachtelten schleifen realisiert sein. eine äussere wird drei mal durchgeführt, einmal für jede zeile. eine innere schleife, die bei jedem durchlauf der äusseren druchgeführt wird, und ensprechend eingerückt sein muss (ohne leerzeilen) (siehe "indent" in "First Steps Towards Programming" im tutorial in den python docs), produziert jeweils eine zeile. die anzahl der durchläufe (=worte) wird nicht mit einer konstante ("7") sondern einer variable ("k") angegeben. diese variable wird vor der inneren schleife, aber innerhalb der äusseren schleife, abhängig davon der wievielte durchlauf stattfindet, belegt. also zb "if i == 0:", dann eingerückt "k = 5". und das für "i == 1", und "i == 2" mit der selben einrückung analog.
verschachtelte schleifen
als hinweis noch ein beispiel für verschachtelte schleifen:
# kombinationen
formen = [ 'kreis', 'pfeil' ]
farben = [ 'roter', 'gelber', 'blauer']
i_formen = 0
while i_formen < len( formen):
i_farben = 0
while i_farben < len( farben):
print farben[ i_farben] + ' ' + formen[ i_formen]
i_farben = i_farben + 1
i_formen = i_formen + 1
leichte aufgabe
zum einstieg eine denke ich leichte aufgabe. schreibt ein programm mit folgender ausgabe (unter verwendung von 4 while schleifen):
wer wer wer wer 54 53 52 3 5 7 9 zt zt zt
vermutlich noch leichte aufgabe
zum einstieg geeignet, aber vielleicht ein bischen zum nachdenken. schreibt ein programm mit folgender ausgabe (unter verwendung von 1 while schleife):
54 3 53 5 52 7 9
eine halbwegs leichte aufgabe zu verschachtelten schleifen
schreibt ein programm mit folgender ausgabe (unter verwendung von 2 verschachtelten while schleifen):
5 - 1 5 - 2 5 - 3 4 - 1 4 - 2 4 - 3
"stabreime"
nur wörter mit dem selbem anfangsbuchstaben verwenden.
Ist mit dem Beispielsatz ein bisschen fad. Wie waers stattdessen mit
satz = [ 'programmieren', 'und', 'umprogrammieren', 'phuer', 'umtriebige',
'philosophen', 'und', 'pantherinnen', 'produziert', 'unvorhersehbares' ]
Anfangsbuchstaben aufsagen
habe ich als Zwischenstation zur Stabreim-Aufgabe geschrieben. Ein Programm mit einem Output wie z. B.
e wie es ? wie ? d wie der u wie uhr s wie schon s wie so g wie gedreht u wie uhr w wie wirklich i wie ist w wie wer , wie , s wie so , wie ,
(H.A.L. 11:56, 16. Dez 2004 (CET))
nur die hauptwörter austauschen.
(nicht ganz einfach)
zuerst müsste man sich überlegen wie man die daten hält. eine variante: eine liste von wörtern, (wie in "woerter zufaellig zusammenstellen"), aber statt den hauptwörtern nur ein "#". und einen 2. liste die nur hauptwörter enthält. analog zur haiku geschichte könnte man auch hier zuerst mit einem codefragment das nur die daten enthält beginnen, und sich das mit den schleifen in einem 2. schritt überlegen.
ausgangstext in wörter zerlegen
den ausgangstext nicht als liste von strings sondern den ganzen text als einen string an das programm übergeben. das programm muss dann die liste von wörtern die zufällig zusammengestellt werden sollen selbst erzeugen.
ausgangstext in siben zerlegen
zusatz zum zerlegen von sätzen (nicht ganz einfach): "fra-ge sie-ben ist rund". so einen text ins liste von listen format für die haikus bringen, siehe haiku 1. versuch. das kann vermutlich mit "string.splitfields" realisiert werden (in zwei schritten), oder auf basis von vorarbeit zu: satz zerlegen zu wörtern. beide varianten könnten hier entwickelt werden.
ausgangstext in wörter zerlegen, hauptwörter extra
zusatz zum zerlegen von sätzen (nicht ganz einfach): einen ausgangstext indem die hauptwörter mit "#" gekennzeichnet sind (zb 'wer hat an der #uhr gedreht') entsprechend dem vorschlag oben bei "nur die hauptwörter austauschen" zerlegen.
den ergebnis text in einen string schreiben
das könnte eine einfache aufgabe zum einsteigen sein. am anfang des programmes einen string leer initialisieren, zb aus = ''. statt print: aus = aus + ' ' + ... . und am ende ein mal, ohne einrückung print aus.
zusatz zu ergebnis in string: kein leerzeichen vor satzzeichen
zusatz (halbwegs einfach): bei satzzeichen kein leerzeichen. (hinweis: random.choice vorher einer variable zuweisen. die dann in einem if statement mit else zweig auswerten. siehe python docs, tutorial, "More Control Flow", "if Statements".)
das programm komprimieren
so, dass die selbe funktionalität (textproduktion) nur die halbe anzahl an programm statements benötigt.
ausgewählte wörter nicht noch einmal auswählen
andere quellen für wörter
in den bisherigen beispielen haben wir einen text oder eine liste von wörtern als ausgangsmaterial für neue texte verwendet. was wenn wir als ausgangsmaterial alle wörter einer sprache verwenden wollen ? dazu könnten wir im internet nach verfügbaren daten suchen. (zb bei open source wörterbüchern). (eventuell gibt es datenbanken die für wörter zusatzinformationen wie grammatikalische position oder anzahl der silben enthalten).
neue aufgabenstellungen finden
(das ist auch eine gute übung um einzuschätzen was machbar ist.)
Textproduktion - Codeorganisation. von Funktionen zu Objekten aus Klassen
Funktionen
# RandomNounFunc.py
# daniel, 20.10.04, basis scripts
# ml 13.11.04, funktionen
import random
def RandomNounMarkup( satz):
hauptwort = []
i = 0
while i < len(satz):
wort = satz[i]
if wort[0] == '#':
hauptwort.append(wort)
i = i + 1
res = ''
i = 0
while i < len(satz):
wort = satz[i]
if wort[0] == '#':
wort = random.choice(hauptwort)
wort = wort[1:]
res = res + wort + ' '
i = i + 1
return res
def RandomNounUppercase( satz):
hauptwort = []
i = 0
while i < len(satz):
wort = satz[i]
if wort.istitle():
hauptwort.append(wort)
i = i + 1
res = ''
i = 0
while i < len(satz):
wort = satz[i]
if wort.istitle():
wort = random.choice(hauptwort)
res = res + wort + ' '
i = i + 1
return res
# test code
def _test():
satz = [ 'der', '#panther', 'hat', 'an', 'der', '#uhr', 'gedreht', ',',
'ist', 'es', 'wirklich', 'schon', 'so', 'spaet', '?' ]
print RandomNounMarkup( satz)
print
satz = [ 'der', 'Panther', 'hat', 'an', 'der', 'Uhr', 'gedreht', ',',
'ist', 'es', 'wirklich', 'schon', 'so', 'spaet', '?' ]
print RandomNounUppercase( satz)
if __name__ == '__main__':
_test()
# eof
verwendung
unter der voraussetzung, dass sich dieses modul als datei 'RandomNounFunc.py' im selben verzeichnis oder sonst wo im phyton modul suchpfad befindet, können die funktionen aus einem programm oder der shell zb wie folgt verwendet werden:
import RandomNounFunc
print RandomNounFunc.RandomNounMarkup( [ '#hut', 'ist', '#hut', ',',
'#schal', 'ist', '#schal'])
print
print RandomNounFunc.RandomNounUppercase( [ 'Marmelade', 'ist', 'Marmelade', ',',
'Kompott', 'ist', 'Kompott'])
Funktionsvariablen
# RandomNounFuncVar.py
# daniel, 20.10.04, basis scripts
# ml 13.11.04, funktionen, klassen
import random
# independent data
class X:
pass
# Markup funcs
def InitNounMarkup( x, satz):
x.satz = satz
x.hauptwort = []
i = 0
while i < len( x.satz):
wort = x.satz[i]
if wort[0] == '#':
x.hauptwort.append(wort)
i = i + 1
def LenMarkup( x):
return len( x.satz)
def WordMarkup( x, i):
return x.satz[i]
def WordIsNounMarkup( x, i):
wort = x.satz[i]
if wort[0] == '#':
return 1
else:
return 0
def RandomNounMarkup( x):
wort = random.choice( x.hauptwort)
wort = wort[1:]
return wort
# Uppercase funcs
def InitNounUppercase( x, satz):
x.satz = satz
x.hauptwort = []
i = 0
while i < len( x.satz):
wort = x.satz[i]
if wort.istitle():
x.hauptwort.append(wort)
i = i + 1
def LenUppercase( x):
return len( x.satz)
def WordUppercase( x, i):
return x.satz[i]
def WordIsNounUppercase( x, i):
wort = x.satz[i]
if wort.istitle():
return 1
else:
return 0
def RandomNounUppercase( x):
wort = random.choice( x.hauptwort)
return wort
# independent func
def RandomNoun( satz, Len, Word, WordIsNoun, RandomNoun):
res = ''
i = 0
while i < Len( satz):
if WordIsNoun( satz, i):
wort = RandomNoun( satz)
else:
wort = Word( satz, i)
res = res + wort + ' '
i = i + 1
return res
# test code
def _test():
satz = [ 'der', '#panther', 'hat', 'an', 'der', '#uhr', 'gedreht', ',',
'ist', 'es', 'wirklich', 'schon', 'so', 'spaet', '?' ]
x = X()
InitNounMarkup( x, satz)
print RandomNoun( x, LenMarkup, WordMarkup, WordIsNounMarkup,
RandomNounMarkup)
print
satz = [ 'der', 'Panther', 'hat', 'an', 'der', 'Uhr', 'gedreht', ',',
'ist', 'es', 'wirklich', 'schon', 'so', 'spaet', '?' ]
x = X()
InitNounUppercase( x, satz)
print RandomNoun( x, LenUppercase, WordUppercase, WordIsNounUppercase,
RandomNounUppercase)
if __name__ == '__main__':
_test()
# eof
Klassen
# RandomNounClass.py
# daniel, 20.10.04, basis scripts
# ml 13.11.04, funktionen, klassen
import random
class TextNounMarkup:
def __init__( self, satz):
self.satz = satz
self.hauptwort = []
i = 0
while i < len( self.satz):
wort = self.satz[i]
if wort[0] == '#':
self.hauptwort.append(wort)
i = i + 1
def Len( self):
return len( self.satz)
def Word( self, i):
return self.satz[i]
def WordIsNoun( self, i):
wort = self.Word(i)
if wort[0] == '#':
return 1
else:
return 0
def RandomNoun( self):
wort = random.choice( self.hauptwort)
wort = wort[1:]
return wort
class TextNounUppercase:
def __init__( self, satz):
self.satz = satz
self.hauptwort = []
i = 0
while i < len( self.satz):
wort = self.satz[i]
if wort.istitle():
self.hauptwort.append(wort)
i = i + 1
def Len( self):
return len( self.satz)
def Word( self, i):
return self.satz[i]
def WordIsNoun( self, i):
wort = self.Word(i)
if wort.istitle():
return 1
else:
return 0
def RandomNoun( self):
wort = random.choice( self.hauptwort)
return wort
def RandomNoun( satz):
res = ''
i = 0
while i < satz.Len():
if satz.WordIsNoun(i):
wort = satz.RandomNoun()
else:
wort = satz.Word(i)
res = res + wort + ' '
i = i + 1
return res
# test code
def _test():
satz = [ 'der', '#panther', 'hat', 'an', 'der', '#uhr', 'gedreht', ',',
'ist', 'es', 'wirklich', 'schon', 'so', 'spaet', '?' ]
print RandomNoun( TextNounMarkup( satz))
print
satz = [ 'der', 'Panther', 'hat', 'an', 'der', 'Uhr', 'gedreht', ',',
'ist', 'es', 'wirklich', 'schon', 'so', 'spaet', '?' ]
print RandomNoun( TextNounUppercase( satz))
if __name__ == '__main__':
_test()
# eof
Basis Klasse
# RandomNounBaseClass.py
# daniel, 20.10.04, basis scripts
# ml 13.11.04, funktionen, klassen
import random
class Text:
def __init__( self):
print 'error: method not implemented'
def Len( self):
print 'error: method not implemented'
def Word( self, i):
print 'error: method not implemented'
def WordIsNoun( self, i):
print 'error: method not implemented'
def RandomNoun( self):
print 'error: method not implemented'
def RandomNouns( self):
res = ''
i = 0
while i < self.Len():
if self.WordIsNoun(i):
wort = self.RandomNoun()
else:
wort = self.Word(i)
res = res + wort + ' '
i = i + 1
return res
class TextNounMarkup( Text):
def __init__( self, satz):
self.satz = satz
self.hauptwort = []
i = 0
while i < len( self.satz):
wort = self.satz[i]
if wort[0] == '#':
self.hauptwort.append(wort)
i = i + 1
def Len( self):
return len( self.satz)
def Word( self, i):
return self.satz[i]
def WordIsNoun( self, i):
wort = self.Word(i)
if wort[0] == '#':
return 1
else:
return 0
def RandomNoun( self):
wort = random.choice( self.hauptwort)
wort = wort[1:]
return wort
class TextNounUppercase (Text):
def __init__( self, satz):
self.satz = satz
self.hauptwort = []
i = 0
while i < len( self.satz):
wort = self.satz[i]
if wort.istitle():
self.hauptwort.append(wort)
i = i + 1
def Len( self):
return len( self.satz)
def Word( self, i):
return self.satz[i]
def WordIsNoun( self, i):
wort = self.Word(i)
if wort.istitle():
return 1
else:
return 0
def RandomNoun( self):
wort = random.choice( self.hauptwort)
return wort
# test code
def _test():
satz = [ 'der', '#panther', 'hat', 'an', 'der', '#uhr', 'gedreht', ',',
'ist', 'es', 'wirklich', 'schon', 'so', 'spaet', '?' ]
print TextNounMarkup( satz).RandomNouns()
print
satz = [ 'der', 'Panther', 'hat', 'an', 'der', 'Uhr', 'gedreht', ',',
'ist', 'es', 'wirklich', 'schon', 'so', 'spaet', '?' ]
print TextNounUppercase( satz).RandomNouns()
if __name__ == '__main__':
_test()
# eof
verwendung zb:
import RandomNounBaseClass
satz = [ '#hut', 'ist', '#hut', ',', '#schal', 'ist', '#schal']
satzobjekt = RandomNounBaseClass.TextNounMarkup( satz)
print satzobjekt.RandomNouns()
print
print RandomNounBaseClass.TextNounUppercase( [ 'Marmelade', 'ist', 'Marmelade', ',',
'Kompott', 'ist', 'Kompott']).RandomNouns()
Wiki Integration
unsere textproduktionsfunktionen könnten wir im web der allgemeinheit zur verfügung stellen. eine einfache variante wäre es die funktionen in ein wiki zu integrieren. moin ist ein wiki das in python geschrieben ist. moin unterstützt parser plugins. im folgenden ein beispiel für einen sehr einfachen parser. dem können wir die schnittstelle entnehmen auf der wir aufsetzen könnten.
"""
MoinMoin - HTML Text Parser
Copyright (c) 2001 by Christian Bird <chris.bird@lineo.com>
All rights reserved, see COPYING for details.
"""
class Parser:
"""
Send HTML code raw
"""
def __init__(self, raw, request, **kw):
self.html = raw
def format(self, formatter):
""" Send the "parsed" text.
"""
#this is pretty easy since converting HTML to HTML is a no-brainer
print self.html
