Programmieren für Philosophinnen und Philosophen

Hinweise

Python Bookmarks

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

Akrostichon

Und weil wir grad dabei sind: Vom Ausgangspunkt

satz = [ 'Integrated', 'Deve', 'Lopment', 'Environment' ]

zur Ausgabe

I wie Integrated
D wie Deve
L wie Lopment
E wie Environment

zu kommen geht ganz ähnlich.

Interessanter wirds z.B., wenn man dam Skript ein Wort als Argument übergibt und es aus dem Wort und einer Liste von Wörtern nach Anfangsbuchstaben geordnet ein Akrostichon basteln soll... Aber um an so etwas komfortabel herumprobieren zu können, bräuchten wir die entsprechenden Listen --H.A.L. 12:07, 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.

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

dynamische webseiten mit pyhton

im folgenden der sourcecode für test.cgi

#!/usr/bin/env python

import cgi
import cgitb; cgitb.enable()

print "Content-Type: text/html"     # HTML is following
print                               # blank line, end of headers

print "<html>"
print "<head><TITLE>dynamische webseite mit pyhton</TITLE></head>"
print "<body>"

print "<form action=""test.cgi"" method=get|post>"
print "<br><br>"
print "text eingeben, button '2x' betätigen"
print "<br><br>"
print "text: "
print "<input type=""text"" name=""text"">"
print "<br><br>"
print "<input type=""submit"" name=""submit"" value=""2x"">"
print "</form>"

form = cgi.FieldStorage()
if form.has_key("text"):
    print form.getvalue("text") * 2

print "</body>"
print "</html>"