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 Aufgabenstellungen finden

1. Vorschlag

(Christian 09.11.04)

Ich hätte hier einpaar "Klassiker" anzubieten, leider haben sie aber absolut keine philosophische Relevanz:

z.B. könnte man ein Programm schreiben, das eine Zahl einliest und feststellt, ob sie eine Primzahl ist.

man könnte ein Programm schreiben, das 2 Zahlen einliest und feststellt, was ihr größter gemeinsamer Teiler, kleinstes gemeinsames Vielfaches ist

ein Programm könnte einen String oder eine Textdatei sortieren - Sonderzeichen als erstes, dann Zahlen, dann Wörter

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 ?

leichte aufgabe

i = 0
while i < 4:
    print 'wer'
    i = i + 1

i = 54
while i >= 52:
    print i
    i = i - 1

i = 3
while i <= 9:
    print i
    i = i + 2

i = 0
while i < 3:
    print 'zt'
    i = i + 1

eine halbwegs leichte aufgabe zu verschachtelten schleifen

k = 5
while k >= 4:
    i = 1
    while i <= 3:
        #print str(k) + ' - ' + str(i)
        print k, '-', i
        i = i + 1
    k = k - 1

nur die hauptwoerter austauschen

(daniel, 20.10.04)

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

Anfangsbuchstaben aufsagen

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

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

(H.A.L. 11:59, 16. Dez 2004 (CET))

Akrostichon

satz = [ 'Integrated', 'Deve', 'Lopment', 'Environment' ]
i = 0
while i < len(satz):
    wort = satz[i]
    print wort[0], ' wie ', wort
    i = i + 1

oder

satz = [ 'Integrated', 'Deve', 'Lopment', 'Environment' ]
i = 0
while i < len(satz):
    print satz[i][0], ' wie ', satz[i]
    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)

(daniel, 06.11.04)

einfachere version mit dem vorteil, dass bei zwei gleichen wörtern in der liste "satz" keine endlosschleife entsteht. wie auch schon im programm oben, werden alle elemente aus der liste "satz" ausgegeben.

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

x = 0
y = len(satz)
while x < y:
    wort = random.choice(satz)
    print wort,
    satz.remove(wort)
    x = x + 1

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'

haiku mit sinnlosen silben

(christian, 09.11.04)

ich hab jetzt mal ein haiku-programm für sinnlose silben geschrieben:

import random

import string

def HaikuZeileErstellen(Zahl, silbensammlung):
    i=0
    k=0
    ch=chr(1)
    Haiku=''
    change= ''
    wort = ''
    silbe1 = ''    
    while i<Zahl+k:        
        silbe = random.choice(silbensammlung)
        while silbe==' ' and silbe == silbe1:
            silbe = random.choice(silbensammlung)          
        if i == 0:
            while silbe == ' ':
                silbe = random.choice(silbensammlung)
            j=0
            while j < len(silbe):
                j=j+1
                ch = silbe [j-1]
                if j == 1:
                   ch = string.upper(ch)
                Haiku = Haiku + ch
            i = i+1                   
        else:
            Haiku=Haiku + silbe
            silbe1 = silbe
            i = i+1  
        if silbe == ' ':
            k = k+1              
    return Haiku        

silbenpool = ['dreh', 'geh', 'hin', 'ter', 'blau', 'cher', 'ver', 'der', 'ei', 'grau', 'zu', 'for', 'hin', 'au', 'auf', 'ga', 'be',' ', ' ',' ', ' ', ' ', ' ', ' ']

i = 0

while i<5:
    print HaikuZeileErstellen(5, silbenpool)
    print HaikuZeileErstellen(7, silbenpool)
    print HaikuZeileErstellen(5, silbenpool)
    print '\n'
    i=i+1

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.2004

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

probier script vom 14.12.2005

def abc( n):
    i = 0
    while i < n:
        print 'a'
        print 'b'
        print 'c'
        i = i + 1
    return

def x( c, n): # beisp.: x( 'i', 30)
    if (n > 500):
        return 'das ist mir zuviel'
    s = ''
    i = 0
    while i < n:
        s = s + c
        i = i + 1
    return s

print 'sd'
print 'hgfs3rse'
print 'hiugkjztgk'

abc( 5)

print 'sdfds'
print 'zgzg'

abc( 1)


print 's8z9999999999999999999999999999999999iziuz'

print 's8z' + x( '9', 20) + 'iziuz'

print 'iuziuiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiixxx'

print 'iuziu' + x( 'i', 30) + 'xxx'

s = 'iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii'
print 'iuziu' + s + 'xxx'

print x( 'i', 3000)

shell protokoll zum 14.12.2004

>>> import RandomNounFunc
>>> s = [ '#hut', 'ist', '#hut', ',',
                          '#schal', 'ist', '#schal']
>>> s
['#hut', 'ist', '#hut', ',', '#schal', 'ist', '#schal']
>>> RandomNounFunc.RandomNounUppercase(s)
'#hut ist #hut , #schal ist #schal '
>>> RandomNounFunc.RandomNounMarkup(s)
'hut ist hut , schal ist schal '
>>> s1 = 'sgfsrdgf  dgfd'
>>> s1
'sgfsrdgf  dgfd'
>>> s1 = RandomNounFunc.RandomNounMarkup(s)
>>> s1
'schal ist schal , hut ist hut '
>>> s = ['Marmelade','ist','Kompott']
>>> s1 = s1 + RandomNounFunc.RandomNounMarkup(s)
>>> s1
'schal ist schal , hut ist hut Marmelade ist Kompott '
>>> print s1
schal ist schal , hut ist hut Marmelade ist Kompott 
>>> RandomNounFunc.RandomNounMarkup( ['#tor','#stiege','#turm'])
'turm turm tor '
>>> RandomNounFunc.RandomNounMarkup(1)

Traceback (most recent call last):
  File "<pyshell#30>", line 1, in -toplevel-
    RandomNounFunc.RandomNounMarkup(1)
  File "C:/#dat/philo/prg\RandomNounFunc.py", line 12, in RandomNounMarkup
    while i < len(satz):
TypeError: len() of unsized object
>>> 

>>> import RandomNounBaseClass
>>> TextNounUppercase( ['Hut','ist','Kragen']).RandomNouns()
'Hut ist Hut '
>>> for i in range (10):
	TextNounUppercase( ['Hut','ist','Kragen']).RandomNouns()

	
'Hut ist Kragen '
'Kragen ist Kragen '
'Kragen ist Kragen '
'Kragen ist Hut '
'Kragen ist Kragen '
'Kragen ist Hut '
'Hut ist Kragen '
'Kragen ist Kragen '
'Hut ist Kragen '
'Hut ist Hut '

shell protokoll vom 17.1.2005

IDLE 1.0.3      
>>> 
class X:
    pass

>>> 
[DEBUG ON]
>>> 
[DEBUG OFF]
>>> X
<class __main__.X at 0x00A68F30>
>>> willi = X()
>>> willi.name = 'schubert'
>>> willi.groesse = '170'
>>> willi.schuhgroesse = 42
>>> willi.groesse = 170
>>> 
>>> willi
<__main__.X instance at 0x00A5A558>
>>> print willi
<__main__.X instance at 0x00A5A558>
>>> willi.name
'schubert'
>>> 
>>> max = X()
>>> max.name = 'moritz'
>>> max.groesse = 160
>>> max.schuhgroesse = 45
>>> 
>>> def print_person:
	
SyntaxError: invalid syntax
>>> def print_person( p):
	print 'name:', p.name, 'groesse:', p.groesse

	
>>> print_person( willi)
name: schubert groesse: 170
>>> ##erwin = X()
>>> class person:
	name = '',
	groesse = 0,
	schuhgroesse = 0,

	
>>> erwin = person()
>>> erwin.name
('',)
>>> lise = X()
>>> lise.name

Traceback (most recent call last):
  File "<pyshell#34>", line 1, in -toplevel-
    lise.name
AttributeError: X instance has no attribute 'name'
>>> i = 5
>>> erwin.groesse = 180
>>> 
>>> class PersonP:
	def __init__(self, n):
		name = n

		
>>> andrea = PersonP( 'andrea')
>>> andrea.name

Traceback (most recent call last):
  File "<pyshell#43>", line 1, in -toplevel-
    andrea.name
AttributeError: PersonP instance has no attribute 'name'
>>> class PersonP:
	def __init__(self, n):
		name = self.n

		
>>> andrea = PersonP( 'andrea')

Traceback (most recent call last):
  File "<pyshell#46>", line 1, in -toplevel-
    andrea = PersonP( 'andrea')
  File "<pyshell#45>", line 3, in __init__
    name = self.n
AttributeError: PersonP instance has no attribute 'n'
>>> class PersonP:
	def __init__(self, n):
		self.name = n

		
>>> andrea = PersonP( 'andrea')
>>> andrea.name
'andrea'
>>> print_person( max)
name: moritz groesse: 160
>>> print_person( andrea)
name: andrea groesse:

Traceback (most recent call last):
  File "<pyshell#52>", line 1, in -toplevel-
    print_person( andrea)
  File "<pyshell#22>", line 2, in print_person
    print 'name:', p.name, 'groesse:', p.groesse
AttributeError: PersonP instance has no attribute 'groesse'
>>> andrea.groesse = 180
>>> print_person( andrea)
name: andrea groesse: 180
>>> print_person( 5)
name:

Traceback (most recent call last):
  File "<pyshell#55>", line 1, in -toplevel-
    print_person( 5)
  File "<pyshell#22>", line 2, in print_person
    print 'name:', p.name, 'groesse:', p.groesse
AttributeError: 'int' object has no attribute 'name'
>>> class PersonKlasse:
	name = 'noname'
	groesse = 170
	def print_person( self):
		print 'name:', name, 'groesse:', groesse

		
>>> daniela = PersonKlasse()
>>> daniela.print_person()
name:

Traceback (most recent call last):
  File "<pyshell#63>", line 1, in -toplevel-
    daniela.print_person()
  File "<pyshell#61>", line 5, in print_person
    print 'name:', name, 'groesse:', groesse
NameError: global name 'name' is not defined
>>> class PersonKlasse:
	name = 'noname'
	groesse = 170
	def print_person( self):
		print 'name:', self.name, 'groesse:', self.groesse

>>> 
>>> daniela = PersonKlasse()
>>> daniela.print_person()
name: noname groesse: 170
>>> 5.print_person()
SyntaxError: invalid syntax
>>> willi.print_person = print_person
>>> willi.print_person()

Traceback (most recent call last):
  File "<pyshell#70>", line 1, in -toplevel-
    willi.print_person()
TypeError: print_person() takes exactly 1 argument (0 given)
>>> willi.print_person( willi)
name: schubert groesse: 170
>>> print_person
<function print_person at 0x00A3C370>
>>> f = print_person
>>> f( willi)
name: schubert groesse: 170
>>> print_person( willi)
name: schubert groesse: 170
>>> def print_person( p):
	print 'eoeh'

	
>>> print_person( willi)
eoeh
>>> willi.print_person( willi)
name: schubert groesse: 170
>>> print_person
<function print_person at 0x00A40070>
>>> 
KeyboardInterrupt
>>> willi.print_person
<function print_person at 0x00A3C370>
>>> willi.print_person( max)
name: moritz groesse: 160
>>> class person:
	name = '',
	groesse = 0,
	schuhgroesse = 0,
        f = willi.print_person

        
>>> moni = person()
>>> moni.print_person()

Traceback (most recent call last):
  File "<pyshell#87>", line 1, in -toplevel-
    moni.print_person()
AttributeError: person instance has no attribute 'print_person'
>>> class person:
	name = ''
	groesse = 0
	schuhgroesse = 0
        print_person = willi.print_person

>>> moni.print_person( moni)

Traceback (most recent call last):
  File "<pyshell#89>", line 1, in -toplevel-
    moni.print_person( moni)
AttributeError: person instance has no attribute 'print_person'
>>> moni = person()
>>> moni.print_person( moni)

Traceback (most recent call last):
  File "<pyshell#91>", line 1, in -toplevel-
    moni.print_person( moni)
TypeError: print_person() takes exactly 1 argument (2 given)
>>> moni.print_person( )
name:  groesse: 0
>>> 
>>> 

noch ein probierscript zu: "Textproduktion - Codeorganisation. von Funktionen zu Objekten aus Klassen"

def f( i):
    print 'i: ', i

def g( i):
    print 'i*2: ', i*2

fr = f
fr(1)
fr = g
fr(1)

def call_five_times( fr, n):
    for i in range(5):
        fr(n)

call_five_times( f, 5)
call_five_times( g, 7)

class a:
    i = 0
    s = 'leer'
    def f( self):
        print self.i, self.s


def f( self):
    print 'ext', self.i, self.s

x = a()


x.f()
x.i = 5
x.f()

x.k = 5
print x.k+1

x.fp = f
# geht nicht: x.fp(). das ist der unterschie zwischen funktionen und methoden
x.fp(x)

class aa(a):
    def f( self):
        print self.i, self.s
        print self.i, self.s

x = aa()
x.f()

import testmodule
testmodule.testfunc(7)

from testmodule import testfunc
testfunc(3)    

script und shell protokoll vom 12.4.2005

(Anmerkungen --anna 13:04, 19. Apr 2005 (CEST)) (anmerkungen zu den anmerkungen -- ml 19.4.2005)

def f( a, b = 'xxxx'):
    print a
    print b


satz=[['iuziuz',3],['asdad',7]]

for e in satz:
    # f( e)
    # f( b = '123', a = 'edc')
    f( a = 'sadf')

f( '1', '2')

g = f

g( 'qweqweqw', 'qweqweqwe')

#eof

IDLE 1.1      
>>> ================================ RESTART ================================
>>> 
sadf
xxxx
sadf
xxxx
1
2
qweqweqw
qweqweqwe
>>> class X:


	pass

>>> X a               # "X" ist eine Klasse, falscher Versuch einer Instantiierung
SyntaxError: invalid syntax
>>> a = X             # Objekt a wird als Instanz von Klasse X erzeugt
# nein, das war auch ein fehlversuch. kommt, wie der vorige fehlversuch
# aus der c++ welt, dort würde 'X a;' gehen, und 'X* a = new X' wäre das selbe
# wie 'X* a = new X()'.
# was hier passiert: a wird zur referenz auf die klasse X, nicht zur instanz.
>>> a
<class __main__.X at 0x00B40990>
>>> a.i = 1           # Zuweisungen eines Wertes zu den Attributen i, s der Instanz a
# nein, siehe oben. man sieht es wenn man das ergebnis von '>>>a' ansieht:
# es müsste instance statt class sein.
>>> a.s = 'asd'       # 
>>> 
>>> a
<class __main__.X at 0x00B40990>
>>> a.i               # Aufruf der Attributwerte der Instanz a
1
>>> a.s
'asd'
>>> b = X             # neue Instanz b der Klasse X
>>> b.i               # Aufruf des Klassenattributs i (??)
1
# hier wird der fehler klar: a und b können keine instanzen sein weil wir das attribut i
# nur a aber nicht b zugewiesen haben. das b trotzdem über ein i verfügt lässt sich
# dadurch erklären, dass a und b referenzen auf die klasse X sind, daher sind sie im selben namespace.
# im folgenden die erste erfolgreiche instanzierung von X. die klammern habens ausgemacht.
# man sieht unten auch das '>>> a' die adresse einer instanz bringt.
>>> a = X()
>>> a
<__main__.X instance at 0x00B41D50>
>>> 
>>> X
<class __main__.X at 0x00B40990>
>>> a.i
1
>>> X.k = 5           # Definition des Klassenattributes k, Belegung mit "5"
>>> a = X()
>>> a.k               # Instanzen a und b haben dieses Klassenattribut
5
>>> b.k
5
>>> X.m = 9
>>> a.m
9
>>> a.n = 1           # Definition und Belegung des Instanzenattributes n der Instanz a 
>>> X.m
9
>>> X.n               # versuchter Aufruf eines Klassenattributes n der Klasse X (a.n = 1 setzt Instanzattribut)

Traceback (most recent call last):
  File "<pyshell#29>", line 1, in -toplevel-
    X.n
AttributeError: class X has no attribute 'n'
>>> b = X()           
>>> b.n               # weder die Klasse X, noch die Instanz b haben ein Attribut n

Traceback (most recent call last):
  File "<pyshell#31>", line 1, in -toplevel-
    b.n
AttributeError: X instance has no attribute 'n'
>>> b.m               # die Instanz b hat für m den Wert des Klassenattributes X.m
9
>>> b.m = 0           # für die Instanz b wird das Instanzenattribut m auf 0 gesetzt
>>> b.m
0
>>> a.m
9
>>> X.m
9
>>> X.m = 99          # Neubelegung des Klassenattributs
>>> a.m               # das von der Klasse übernommene Klassenattribut für die Instanz a wird verändert
99
>>> b.m               # das Instanzenattribut für b bleibt unverändert
0
>>> a.m = 3           # Einführung eines Instanzenattributs m für a
>>> X.m = 100
>>> a.m
3
>>> X.m = 'asd'       # Unabhängigkeit der Belegung von Klassenattribut und Instanzenattribut m
>>> a.m
3
>>> c = X()           # die neue Instanz c übernimmt den Wert des Klassenattributs m
>>> c.m
'asd'
>>> class Y:
	i = 0
	def f( self, s):
		print s * i

		
>>> a = Y()
>>> a.i = 1
>>> a.f('qwe')

Traceback (most recent call last):              # nach Klassendefinition ist i nicht auf die Klasse spezifiziert
  File "<pyshell#54>", line 1, in -toplevel-    # und wird daher als globale Variable interpretiert
    a.f('qwe')
  File "<pyshell#51>", line 4, in f
    print s * i
NameError: global name 'i' is not defined
>>> class Y:
	i = 0
	def f( self, s):
		print s * self.i

>>> 
>>> a.f('asd')

Traceback (most recent call last):
  File "<pyshell#57>", line 1, in -toplevel-
    a.f('asd')
  File "<pyshell#51>", line 4, in f
    print s * i                                 # "a.f('asd')" wird noch mit der alten Klassendefinition bearbeitet 
NameError: global name 'i' is not defined
>>> a = Y()                # Instanz a der Klasse Y mit Funktion f, deren Wert "asd"
>>> a.f('asd')

>>> a.i = 2
>>> a.f('asd')
asdasd                     # gemäß Klassendefinition und Variablenbewertung: Stringverdoppelung
>>> a.f(2)
4                          # bzw. Multiplikation - Überladung von "*"
>>> print 3
3
>>> print 3+4*2
11
>>> a.i ='q'
>>> a.f('w')

Traceback (most recent call last):
  File "<pyshell#66>", line 1, in -toplevel-
    a.f('w')
  File "<pyshell#55>", line 4, in f
    print s * self.i
TypeError: can't multiply sequence by non-int
>>> a.f = g
>>> a.f( 'qw', '666')
qw
666
>>> Y.f = g
>>> b = Y()
>>> b.f( 'asd', 'asdasd')

Traceback (most recent call last):
  File "<pyshell#71>", line 1, in -toplevel-
    b.f( 'asd', 'asdasd')
TypeError: f() takes at most 2 arguments (3 given)
>>> b.f( 'adffdfsd')
<__main__.Y instance at 0x00B46850>
adffdfsd
>>> del a.f
>>> a.f( 'x')
<__main__.Y instance at 0x00B41B48>
x
>>> 

nachtrag zum shell protokoll vom 12.4.2005

>>> class X:
	i = 0

	
>>> a = X()
>>> i = 0
>>> i += 1
>>> i
1
>>> a.i += 1
>>> a.i
1
>>> X.i
0
>>> b = X()
>>> b.i
0
>>> X.i += 1
>>> X.i += 1
>>> X.i
2
>>> b.i
2
>>> a.i
1
>>> 

2. nachtrag zum shell protokoll vom 12.4.2005

class X:
    count = 0
    def __init__( self):
        X.count += 1
        self.id = X.count

"""    

test script protokoll:

>>> a = X()
>>> a.id
1
>>> b = X()
>>> b.id
2

"""


class XX( X):
    def __init__( self):
        self.k = 1


"""

test script protokoll:

>>> aa = XX()
>>> aa.count
0
>>> aa.id

Traceback (most recent call last):
  File "<pyshell#1>", line 1, in -toplevel-
    aa.id
AttributeError: XX instance has no attribute 'id'
>>> aa.k
1
>>> XX.k

Traceback (most recent call last):
  File "<pyshell#20>", line 1, in -toplevel-
    XX.k
AttributeError: class XX has no attribute 'k'

"""


class XY( X):
    def __init__( self):
        X.__init__( self)
        self.k = 1

"""

test script protokoll:
>>>
>>> bb = XY()
>>> bb.id
1

"""