Diskussion:Programmieren für Philosophinnen und Philosophen

programme

lösungen wo ?

im moment (20.10.04 in der früh, ml) sind lösungen bzw lösungsvorschläge auf inhalts- und diskussionseite verteilt. da könnten wir uns überlegen wie wir das handhaben wollen. ein argument dafür lösungen und lösungsvorschläge auf der diskussionsseite unterzubringen wäre, dass für leute die aufgabenstellungen suchen die sie selbst lösen wollen die lösung nicht sofort ersichtlich ist. daher habe ich die lösungen von daniel vorerst auf die diskussionsseite verlagert.

(AnAd 20.10.04) bin dafür, die lösungen auf der diskusionsseite zu lassen. aus 2 gründen. 1. möcht ich nicht schon die lösung lesen müssen bevor ich anfange. (wie du ja auch schon geschrieben hast). 2. fürchte ich, wenn alles auf der ersten seite steht, informationen zu überlesen.

neue aufgaben?

(AnAd 20.10.04)kannst du bitte in zukunft die für anfänger und anfängerinnen geeigneten aufgaben kennzeichnen?

(m.l. 24.10.04) reichen die hineise wie "nicht so einfach" und "einfach wären" etc nicht ?

nur die hauptwoerter austauschen

problem mit hauptwörter: eine automatische erkennung von hauptwörter ist zu kompliziert.

siehe: http://www.deutsch-digital.de/daten/grammatik/105.html

eine möglichkeit ist die kennzeichnung von hauptwörter, durch ein zeichen (zb: #), großschreibung, ...

nur die hauptwoerter zufaellig auswaehlen

(daniel, 20.10.04)

unterscheidung durch ein zeichen:

import random
satz = [ 'der', '#panther', 'hat', 'an', 'der', '#uhr', 'gedreht', ',',
         'ist', 'es', 'wirklich', 'schon', 'so', 'spaet', '?' ]

hauptwort = []

i = x = 0
while i < len(satz):
    wort = satz[i]
    if wort[0] == '#':
        hauptwort.append(wort)
    i = i + 1

while x < len(satz):
    wort = satz[x]
    if wort[0] == '#':
        wort = random.choice(hauptwort)
        wort = wort[1:]
    print wort,
    x = x + 1

unterscheidung durch groß- und kleinschreibung:

import random
satz = [ 'der', 'Panther', 'hat', 'an', 'der', 'Uhr', 'gedreht', ',',
         'ist', 'es', 'wirklich', 'schon', 'so', 'spaet', '?' ]

hauptwort = []

i = x = 0
while i < len(satz):
    wort = satz[i]
    if wort.istitle():
        hauptwort.append(wort)
    i = i + 1

while x < len(satz):
    wort = satz[x]
    if wort.istitle():
        wort = random.choice(hauptwort)
    print wort,
    x = x + 1

hauptwoerter automatisch erkennen

(daniel, 06.11.04)

import string

print '\n' + '-' * 49
print '  Bitte geben sie ein Wort oder einen Satz ein!'
print '-' * 49

# eingabe eines strings

satz = raw_input('  Eingabe: ')
print

# den string zerlegen und in eine (wort)liste schreiben

satzzeichen = [ '.', ',', ';', ':', '?', '!' ]
x = y = z = 0
while x < len(satzzeichen):
    satz=string.replace(satz, satzzeichen[x], '')
    x = x + 1
wortliste = string.splitfields(satz, ' ')

# antworten

antwort = [ 'ist ein Hauptwort', 
            'ist so meine ich ein Hauptwort', 
            'ist meiner Meinung nach kein Hauptwort', 
            'ist kein Hauptwort' ]

# endungen von hauptwoertern

endung = [ 'heit', 'keit', 'nis', 'schaft', 'tum', 'ung', 'ling', 'sal' ]

# woerter die keine hauptworter sind

woerter = [ 'und', 'weil', 'wenn', 'oder', 'als', 'die', 'der', 'das', 'dem', 'den' ]

# (wort)liste auf hauptwoerter ueberpruefen

while y < len(wortliste):
    wort = wortliste[y]
    print '  ' + wort + ':',
    z = a = 0
    while z < len(endung):
        if wort[-3:] == endung[z]:
            print antwort[0]
            a = 1
        if wort[-4:] == endung[z]:
            print antwort[0]
            a = 1
        if wort[-5:] == endung[z]:
            print antwort[0]
            a = 1
        z = z + 1
    z = 0
    if a == 0:
        while z < len(woerter):
            if wort == woerter[z]:
                print antwort[3]
                a = 1
            z = z + 1
    if a == 0:
        if wort.istitle():
            print antwort[1]
        else:
            print antwort[2]
    y = y + 1

print '-' * 49 + '\n'

"stabreime": nur woerter mit dem selbem anfangsbuchstaben verwenden

(daniel, 19.10.04)

import random
satz = [ 'wer', 'hat', 'an', 'der', 'uhr', 'gedreht', ',',
         'ist', 'es', 'wirklich', 'schon', 'so', 'spaet', '?' ]

tmp = random.choice(satz)
print tmp,
i = 1
while i < len(satz):
    wort = random.choice(satz)
    if tmp[0] == wort[0]:
        print wort,
        i = i + 1

ausgangstext in woerter zerlegen, variante mit splitfields

(daniel, 19.10.04)

import string
import random
ein_satz = 'wer hat an der uhr gedreht , ist es wirklich schon so spaet ?'
satz = string.splitfields(ein_satz, ' ')

i = 0
while i < len(satz):
    print random.choice(satz),
    i = i + 1

den ergebnis text in einen string schreiben

(daniel, 19.10.04)

import random
ein_satz = [ 'wer', 'hat', 'an', 'der', 'uhr', 'gedreht', ',',
             'ist', 'es', 'wirklich', 'schon', 'so', 'spaet', '?' ]
i = 1
satz = random.choice(ein_satz)
while i < len(ein_satz):
    satz = satz + ' ' + random.choice(ein_satz)
    i = i + 1

print satz,

ausgewaehlte woerter nicht noch einmal auswaehlen

(daniel, 19.10.04)

import random
satz = [ 'wer', 'hat', 'an', 'der', 'uhr', 'gedreht', ',',
         'ist', 'es', 'wirklich', 'schon', 'so', 'spaet', '?' ]

tmp = [ random.choice(satz) ]
print tmp[0],

while len(tmp) < len(satz):
    wort = random.choice(satz)
    x = y = 0
    while x < len(tmp):
        if tmp[x] == wort:
            x = len(tmp)
            y = 1
        x = x + 1
    if y == 0:
        print wort,
        tmp.append(wort)

haiku

was ist ein haiku:

 http://www.onlinekunst.de/ernstferstl/haiku.html
 http://www.visionsplanet.com/poesie/wasisteinhaiku.htm

haiku, 1. versuch

ad haikus: das müsste mit klammer in der klammer funktionieren; bin schon am herumbasteln, hab aber keinen grund zu der annahme, bis heute 17 uhr eine fertige haikus-maschine gebaut zu haben. ...aber im grunde glaub´ich schon, dass es pipi-fax-einfach ist; AnAd(19.10.04)

so weit bin ich schon mal:

import random
wort1 = ['Herb', 'stes']
wort2 = ['Ab', 'end']
wort3 = ['an', 'mach','en']
wort4 = ['frag', 'te']
wort5 = ['Des']
wort6 = ['Soll']
wort7 = ['ich']
wort8 = ['Licht']
wort9 = ['Kam']
wort10 = ['sie']
wort11 = ['und']
wort12 = ['schon']
satz = [ wort1 , wort2 , wort3, wort4, wort5 , wort6 , wort7, wort8, wort9 , wort10, wort11, wort12 ]

i = 0
j = 0
k = 0
while i < 5:
    i = i + 1
    print random.choice( satz),
    while j < 7:
        j = j + 1
        print random.choice( satz),
        while k < 5:
            k = k + 1
            print random.choice( satz),

zwei sachen können noch verbessert werden: 1. zur zeit werden wahllos wörter reingeworfen, so kommen manvhe gar nicht vor, andere wiederum mehrmals; 2. es schaut nicht nach haiku aus, weil noch keine zeilenumbrüche vorkommen; -> noch ein problem: python hat silben mit wörtern verwechselt; ist also doch noch keine haiku-maschine; aber fast!

die schleifen sache werde ich nochmal überdenken; hab auch schon eine idee; stell ich dann in den nächsten tagen rein;

ok.; die neue version: (AnAd 20.10.04)

 
import random
wort1 = ['Herb', 'stes']
wort2 = ['Ab', 'end']
wort3 = ['an', 'mach','en']
wort4 = ['frag', 'te']
wort5 = ['Des']
wort6 = ['Soll']
wort7 = ['ich']
wort8 = ['Licht']
wort9 = ['Kam']
wort10 = ['sie']
wort11 = ['und']
wort12 = ['schon']
satz = [ wort1 , wort2 , wort3, wort4, wort5 , wort6 , wort7, wort8, wort9 , wort10, wort11, wort12 ]
i = 0
while i < 5:
    print random.choice( satz),
    i = i + 1 
print  
j = 0
while j < 7:
    print random.choice( satz),
    j = j + 1
print  
k = 0
while k < 5:
    print random.choice( satz),
    k = k + 1 
print

der vollständigkeit halber das original:

Des Herbstes Abend ::: Soll ich schon Licht anmachen? ::: Kam sie und fragte. (Etsujin)

(ml, 19.10.04:) mutig. und eine meisterleistung. auch nach über 20 jahren programmiererfahrung war mir nicht auf den ersten blick klar was dieses programm eigentlich macht. klar war nur das es sicher keine haikus erzeugt. ein fall für den debugger. das gilt für die verschachtelten schleifen unten. daran knüpft sich eine zusatzaufgabe: warum werden 17 wörter ausgegeben und nicht 5*7*5=175 wörter wie die verschachtelten schleifen auf den ersten blick erwarten lassen.

das datenformat jedoch ist ein interessanter und brauchbarer ansatz. der text ist eine liste von wörtern. wörter sind eine liste von silben. folgendes codefragment knüpft an die variablenbelegung oben an (wort1-12, satz) und zeigt wie man für eine auswahl sowohl das wort wie auch die silbenanzahl bekommt. die funktion len() gibt für listen die anzahl der elemente an. (für strings die anzahl der zeichen, aber in diesem fall handelt es sich um eine liste.)

w = random.choice( satz)
print w
print len(w)

haiku: eine moeglichkeit

(daniel, 22.10.04)

import string
import random
haiku = 'Des Herb-stes Ab-end ::: Soll ich schon Licht an-mach-en? ::: Kam sie und frag-te. (Etsujin)'
autor = 'Terry Jones, Graham Chapman, John Cleese, Eric Idle, Terry Gilliam, Michael Palin'

# den string zerlegen und in eine (wort)liste schreiben

haiku_ohne_autor = haiku[:string.find(haiku, ' (')]
zeile = string.splitfields(haiku_ohne_autor, ' ::: ')
wortliste = []
x = 0
while x < len(zeile):
    wortliste = wortliste + string.splitfields(zeile[x], ' ')
    x = x + 1

# aus der (wort)liste ein haiku verfassen und in einen string schreiben

x = y = silben = 0
haikuzeile = 5
haiku_programm = ''
while x < 17:
    wort = random.choice(wortliste)
    y = string.count(wort, '-')
    if y > 0:
        silben = silben + y
    silben = silben + 1
    if silben < haikuzeile:
        haiku_programm = haiku_programm + ' ' + wort
    elif silben == haikuzeile:
        haiku_programm = haiku_programm + ' ' + wort
        x = x + silben
        if x < 17:
            haiku_programm = haiku_programm + ' :::'
        silben = 0
        if haikuzeile == 7:
            haikuzeile = 5
        else:
            haikuzeile = 7
    else:
        silben = silben - y - 1

# haiku ohne silbentrennung ausgeben

print '\n' + string.replace(haiku, '-', '') + '\n'
print string.replace(haiku_programm[1:], '-', ''),
# auch spass muss sein!
print '(' + random.choice(string.splitfields(autor, ', ')) + ')' + '\n'

ohne satzzeichen in der (wort)liste:

import string
import random
haiku = 'Des Herb-stes Ab-end ::: Soll ich schon Licht an-mach-en? ::: Kam sie und frag-te. (Etsujin)'
autor = 'Terry Jones, Graham Chapman, John Cleese, Eric Idle, Terry Gilliam, Michael Palin'

# den string zerlegen und in eine (wort)liste schreiben

haiku_ohne_autor = haiku[:string.find(haiku, ' (')]
satzzeichen = [ '.', ' :::', ',', ';', '?', '!' ':' ]
x = 0
while x < len(satzzeichen):
    haiku_ohne_autor = string.replace(haiku_ohne_autor, satzzeichen[x], '')
    x = x + 1
wortliste = string.splitfields(haiku_ohne_autor, ' ')

# aus der (wort)liste ein haiku verfassen und in einen string schreiben

x = y = silben = 0
haikuzeile = 5
haiku_programm = ''
while x < 17:
    wort = random.choice(wortliste)
    y = string.count(wort, '-')
    if y > 0:
        silben = silben + y
    silben = silben + 1
    if silben < haikuzeile:
        haiku_programm = haiku_programm + ' ' + wort
    elif silben == haikuzeile:
        haiku_programm = haiku_programm + ' ' + wort
        x = x + silben
        if x < 17:
            haiku_programm = haiku_programm + ' :::'
        silben = 0
        if haikuzeile == 7:
            haikuzeile = 5
        else:
            haikuzeile = 7
    else:
        silben = silben - y - 1

# haiku ohne silbentrennung ausgeben

print '\n' + string.replace(haiku, '-', '') + '\n'
print string.replace(haiku_programm[1:], '-', '') + '.',
# auch spass muss sein!
print '(' + random.choice(string.splitfields(autor, ', ')) + ')' + '\n'

vorarbeit zu: satz zerlegen zu woertern

hier ein weiteres stückchen code, vorerst mal undokumentiert.

i=0
s = 'wer hat an der uhr gedreht, ist es wirklich schon so spaet ?'
tmp=''
aus=''
while i < len(s):
    if s[i] == ' ':
        aus=aus+' '+tmp
        tmp=''
    else:  
        tmp = tmp + s[i]
    i = i + 1

aus=aus+' '+tmp
print aus

(ml, 19.10.04:) in diesem codefragment werden die wörter jeweils in der variable "tmp" "gesammelt". genutzt wird das feature, dass mit s[i] auf ein einzelnes zeichen eines strings zugegriffen werden kann. testweise werden die in "tmp" befindlichen wörter zum string "aus" summiert. aber um worte zufällig daraus erzeugen zu können würden wir eine liste von wörtern benötigen. dazu folgende codeauschnitte:

# statt: aus=''
wortliste = []
...

        #statt: aus=aus+' '+tmp
        wortliste.append( tmp)

(ml, 20.10.04:) eine zusatzfrage: lässt sich die schleife auch so gestalten, dass das statement "aus=aus+' '+tmp" (bzw wortliste.append) nur einmal vorkommt ?

shell protokoll vom 19.10

IDLE 1.0.3      
>>> gtrtz

Traceback (most recent call last):
  File "<pyshell#0>", line 1, in -toplevel-
    gtrtz
NameError: name 'gtrtz' is not defined
>>> 1+1
2
>>> +1
1
>>> i = 1+1
>>> i
2
>>> i = 3+3
>>> i
6
>>> i = i + 1
>>> i
7
>>> i == i + 1
False
>>> i +1 + 1 = i + 2
SyntaxError: can't assign to operator
>>> i + 1 + 1 = i + 2
SyntaxError: can't assign to operator
>>> i +1 + 1 == i + 2
True
>>> s = 'aber'
>>> s
'aber'
>>> s = aber

Traceback (most recent call last):
  File "<pyshell#15>", line 1, in -toplevel-
    s = aber
NameError: name 'aber' is not defined
>>> aber = 'aber'
>>> s = aber
>>> aber = 'aber nicht'
>>> aber
'aber nicht'
>>> aber = aber + '. aber doch'
>>> aber
'aber nicht. aber doch'
>>> aber = aber - 'doch'

Traceback (most recent call last):
  File "<pyshell#22>", line 1, in -toplevel-
    aber = aber - 'doch'
TypeError: unsupported operand type(s) for -: 'str' and 'str'
>>> w234234 = 1
>>> 42432a = 1
SyntaxError: invalid syntax
>>> _wkjhlkhj = 1
>>> w-ere = 1
SyntaxError: can't assign to operator
>>> I

Traceback (most recent call last):
  File "<pyshell#27>", line 1, in -toplevel-
    I
NameError: name 'I' is not defined
>>> i
7
>>> s=['wer','hat','der']
>>> s
['wer', 'hat', 'der']
>>> print s
['wer', 'hat', 'der']
>>> print s[1]
hat
>>> s[0]
'wer'
>>> 
>>> 
>>> w = true

Traceback (most recent call last):
  File "<pyshell#36>", line 1, in -toplevel-
    w = true
NameError: name 'true' is not defined
>>> w = 1 == 1
>>> w
True
>>> w = True
>>> w
True
>>> w = False
>>> w
False
>>> (1 == 1) == w
False
>>> w = True
>>> 1 == 1) == w
SyntaxError: invalid syntax
>>> (1 == 1) == w
True
>>> w = 'True'
>>> w
'True'
>>> print w
True
>>> (1 == 1) == w
False