Der #Linux.de.workshop wurde diesmal in #python.de von Gnarf abgehalten
User Beispiele:
def foobar(varx):
for i in range(Varx)
print "looping %d " % i
return "end"
if __name__ == '__main__':
print foobar(20)Log:
20:33 -!- revenger__ [~mare@195.4.71.249] has joined #python.de
20:33 -!- Irssi: #python.de: Total of 4 nicks [0 ops, 0 halfops, 0 voices, 4 normal]
20:33 -!- Irssi: Join to #python.de was synced in 1 secs
20:33 < revenger__> is ja keiner da
20:33 < gnarf> doch
20:33 -!- andoo [andoo@p50857992.dip.t-dialin.net] has joined #python.de
20:33 < SpyrooU> da
20:33 < revenger__> hehe
20:34 -!- gnarf changed the topic of #python.de to: python workshop
20:34 -!- johnyb [~jb@p213.54.234.130.tisdip.tiscali.de] has joined #python.de
20:34 < gnarf> alle da?
20:34 < revenger__> ich ja :)
20:34 < gnarf> nein
20:34 < SpyrooU> ich auch
20:35 -!- simson [~simon@195.37.51.132] has joined #python.de
20:35 < simson> so
20:35 < gnarf> ah :)
20:35 < gnarf> jetzt zum eigentlichen thema
20:35 < gnarf> alle haben so eine "python" shell vorsich (einfach in ner shell python ohne argumente)
20:35 < gnarf> Python 2.3.4 (#2, May 29 2004, 03:31:27)
20:35 < gnarf> da sollte so ne zeile auftauchen
20:36 < gnarf> mindestens bis Python 2.3 sollte die gleich sein
20:36 < andoo> warum nimmst du nicht pycrust?
20:36 -!- Nebukadneza [~daddel9@dsl-213-023-052-086.arcor-ip.net] has joined #python.de
20:36 < SpyrooU> shell start >> checked
20:36 < Nebukadneza> gnarf: musst du immer ne extrawurschd machen? *g
20:36 < gnarf> andoo: ich wollte gerne bei einem vanilla python bleiben
20:36 < gnarf> Nebukadneza: weil ich den channel hiermit begründen möchte ;)
20:36 < Nebukadneza> *g
20:36 -!- ThomasWaldmann [~twaldmann@thinkmo.de] has joined #python.de
20:37 < revenger__> ok fang mal an :)
20:37 < gnarf> manche haben vll schon das erste tutorial gelesen, doch ich möchte einen gänzlich anderen stil vorziehen
20:37 < gnarf> 1) allgemeines
20:37 < gnarf> 2) datentypen
20:37 < gnarf> 3) operatoren
20:38 < gnarf> 4) keywords und damit verbunden die struktur eines echten programms.
20:38 < gnarf> bis schritt 4 wird python ein taschenrechner bleiben
20:38 < gnarf> bis schritt 4 wird python ein taschenrechner bleiben
20:38 < gnarf> eigentlich ist python ein ganz guter taschenrechner
20:38 < gnarf> kommentare fangen bei '#' an und gehen bis zum ende der zeile (perl, shell, awk, andere)
20:39 < revenger__> oder ''''
20:39 < gnarf> in der ersten zeile verwendet man (unter *nix) oft #!/usr/bin/env python2.3, da python an unterschiedlichen orten liegen kann
20:39 < gnarf> revenger__: was meinst du? doc strings?
20:39 < revenger__> ja
20:39 < revenger__> is ja auch ne form von kommentaren
20:39 < revenger__> aber weiter :)
20:39 < andoo> ich habe die leute gehasst die in meinen vortrag reingequatscht haben ;)
20:39 < gnarf> das ist eine andere form der kommentare zu der wir später noch kommen
20:40 < gnarf> ich kann ja +m setzen, wenns zu oft passiert ;)
20:40 < gnarf> wichtig damit man nicht gleich verwirrt ist: bei python spielt indenting eine rolle! bis ich etwas anderes sage haben statements am anfang einer zeile zu beginnen
20:40 < gnarf> gibt es noch allgemeine fragen, bevor ich zu 2 gehe?
20:41 < gnarf> oder anmerkungen?
20:41 * SpyrooU nicht
20:41 < revenger__> wieso eigentlich env python2.3?
20:41 < revenger__> geht ja /usr/bin/python2.3 genauso
20:41 < gnarf> revenger__: env sucht python2.3 in $PATH
20:41 < revenger__> ok
20:41 < gnarf> revenger__: python befindet sich auch oft in /usr/local/bin
20:41 -!- genera [~mememe@pD9522385.dip.t-dialin.net] has joined #python.de
20:41 < gnarf> hat jemand eigentlich ein log erstellt?
20:41 < revenger__> ich ja :)
20:42 < gnarf> revenger__: gib das mal genera
20:42 < ThomasWaldmann> eine anmerkung noch
20:42 < genera> hi
20:42 < ThomasWaldmann> fuer wichtige dinge (doku) sollte man nicht # ... verwenden, sondern docstrings
20:42 < gnarf> jo. (auch wenn auch # kommentare in pydoc erscheinen)
20:43 < gnarf> 2 - Datentypen
20:43 < gnarf> ich will hier nur einige wichtige nennen, auch wenn es weit mehr gibt.
20:43 < gnarf> int: Zahlen, z.B. 0, 1, -5
20:43 < gnarf> str: Zeiche(ketten), z.B. "a" 'foobar" """viel"""
20:43 < gnarf> long: lange Zahlen, z.B. 1245782397123642139784627136L
20:43 < gnarf> float: Fließkommazahlen, z.B. 3.14159265358
20:43 < gnarf> list: Listen, z.B. [], [1], [2,"foo"]
20:43 < gnarf> dict: Worterbücher, z.B. {}, {"foo":3, "lala":4}
20:43 < gnarf> wörterbücher mein ich ;)
20:44 < gnarf> int, str, long, float sollte jedem klar sein.
20:44 < gnarf> ups.
20:44 < gnarf> tuple: konstante Listen, z.B. (), (1,), ("foo,2)
20:45 < gnarf> konstante listen können im gegensatz zu den normalen listen nicht verlängert oder verkürzt werden
20:45 < gnarf> jegliche zuweisungen an ein einzelnes element eines tuples scheitern.
20:46 < gnarf> bei listen ist das anders. veränderungen sind nach belieben möglich
20:46 < gnarf> dafür sind listen langsamer
20:46 < gnarf> dict entspricht einem perl hash
20:46 < gnarf> die schlüssel müssen in python "hashable" (später mehr dazu) sein
20:47 < gnarf> man kann z.B. ein englisch -> deutschwörterbuch machen: {"dog":"Hund", "cat":"Katze"}
20:47 < gnarf> man kann aber auch längen von zeickenketten speichern: {"foo":3, "bar":3}
20:47 < gnarf> daran sieht man, dass die schlüssel eindeutig sein müssen, die werte jedoch nicht
20:48 < gnarf> hab ich was vergessen?
20:48 < gnarf> mom (telefon)
20:49 < ThomasWaldmann> anmerkung: zugriff auf dicts ist sehr schnell, auch bei großen dicts
20:49 < andoo> .oO( ich hätte mal mitten in einem vortrag ans handy gehen sollen :) )
20:49 < ThomasWaldmann> long int koennen beliebig lang sein
20:49 < revenger__> was bringt das eigentlich den typ explizit anzugeben?
20:49 < revenger__> nix oder?
20:50 < revenger__> >>> d=int
20:50 < revenger__> >>> d=3.23423423423
20:50 < revenger__> >>> print d
20:50 < revenger__> 3.23423423423
20:50 < ThomasWaldmann> braucht man nicht, ausser zur konvertierung
20:50 < gnarf> so.
20:50 < revenger__> das ganze is etwas sinnbefreit..
20:51 < gnarf> andoo: ich hab kein handy ;)
20:51 < gnarf> revenger__: bissl ander ist es
20:51 < gnarf> d=int weist den typ selbst an d zu
20:51 < revenger__> man muss sich doch im grossen und ganzen eh keine gedanken über die datentypen machen oder?
20:51 < gnarf> ich vergaß vorhin "strict typing" und "reverence based access"
20:51 < revenger__> also int,float,long,..
20:52 < gnarf> revenger__: doch
20:52 < revenger__> wo?
20:52 < gnarf> viele funktionen sind zwar untereinander kompatibel, jedoch gibt eine addition von int und list einen fehler
20:52 < gnarf> 1+[]
20:52 < revenger__> hmm naja listen ist etwas anderes
20:53 < revenger__> listen enthalten ja keys und eigene variablen
20:53 < gnarf> typen sind wie klassen zu verwenden d.h. man kann sie mit typname() instanzieren
20:53 < revenger__> dicts halt
20:53 < gnarf> d=int(1) wäre explizite typenangabe
20:53 < revenger__> ja
20:53 < revenger__> ok :)
20:53 < gnarf> d=int("1") tut auch das gleiche (konvertiert die 1 aus einem string)
20:53 < revenger__> keine weiteren fragen diesbezüglich :)
20:53 < gnarf> noch fragen zu diesen typen?
20:54 < gnarf> oder hab ich irgendwelche extrem wichtigen typen vergessen?
20:54 < simson> boolean, sind die disjoint?
20:54 < gnarf> oh. bool ;)
20:54 * andoo ist ein ziemlich wichtiger typ ;)
20:54 < gnarf> bool: kann nur True und False annehmen (case sensitive)
20:54 < simson> sind die disjoint?
20:55 < gnarf> simson: disjoint?
20:55 < simson> in lisp ist nil gleichzeitig boolean und leere liste.
20:55 < gnarf> dann gibt es noch einen typ, der nur einen einzigen wert: None hat.
20:55 < gnarf> simson: nein
20:55 < gnarf> simson: aber in wahrheits auswertungen ist eine leere liste false
20:55 < simson> gnarf: also gehören sie noch zu anderen typen?
20:55 < gnarf> simson: ja
20:55 < simson> also doch nicht disjoint ;)
20:56 < simson> (deutsches wort fehlt mir)
20:56 < gnarf> 3 - Operatoren
20:56 < gnarf> 3.1 - Unäre Operatoren
20:56 < gnarf> zunächst alle operatoren sind später in klassen überladbar.
20:57 < gnarf> +a, -a, ~a, not a, len(a), `a`, abs(a), hex(a), hash(a)
20:57 < gnarf> das sind alle unäre die mir so direkt eingefallen sind
20:57 < gnarf> wichtig: auch len, abs, hex und hash zählen zu den operatoren
20:58 < gnarf> + und - sind für zahlen klar
20:58 < gnarf> ~ ist binäre negation (int)
20:58 < gnarf> not a ist logische negation (bool, alle anderen typen werden vorher nach bool konvertiert)
20:58 < gnarf> ne. fast. wenn nicht überladen
20:59 < gnarf> len(a) gibt die länge zu rück. bei listen und tuplen die anzahl der elemente
20:59 < gnarf> string ist auch eine form des tupels
20:59 < gnarf> bei dicts auch die anzahl der einträge
21:00 < gnarf> abs(a) ist für zahlen klar.
21:00 < gnarf> hex(a) stellt eine zahl hexadezimal da (hab ich noch nie gebraucht)
21:00 < gnarf> hash(a) berechnet den hash wert einer variablen
21:00 < gnarf> wenn dieser operator definiert ist (muss nicht sein) spricht man von "hashable"
21:01 < gnarf> alle "hashable" typen sind als schlüssel in dicts möglich
21:01 < gnarf> deshalb sollte hash(a) bei verschiedenen werten auch verschiedene hash werte liefern
21:01 < gnarf> listen sind nicht hashable
21:01 < gnarf> dicts auch nicht
21:01 < gnarf> dazu fragen?
21:01 < gnarf> anmerkungen?
21:02 < revenger__> nope
21:02 < gnarf> wars wirklich so verstehbar?
21:02 < andoo> ja
21:02 < gnarf> mist ;)
21:02 < revenger__> oder for i in len(d) (wenn d ein dict ist wird jedes element durchlaufen und man kann mittels I darauf zugreifen
21:02 < gnarf> 3.2 Binäre Operatoren
21:02 < andoo> bis auf den sinn von hash(bla)
21:02 < revenger__> ok frage ist i eine referenz?
21:03 < gnarf> revenger__: 1. frage nein.
21:03 < gnarf> revenger__: kommt später ;)
21:03 < revenger__> kopieren von dictionaries .. dict2=dict1 .. das dict wird nicht kopiert sondern nur referenziert ..
21:03 < revenger__> oder?
21:03 < gnarf> ja a=b kopiert nur die referenz
21:03 < gnarf> auch bei integern
21:03 < revenger__> gibts da ne funktion das dict zu kopieren?
21:03 < gnarf> andoo: hash() liefert einen hashwert. sowas wie ne md5sum bei dateien
21:03 < gnarf> revenger__: ja. mom
21:04 < gnarf> revenger__: dict2=dict1.copy()
21:04 < revenger__> ah! danke
21:04 < simson> gnarf: das heißt der hash basiert nicht auf objekt identität?
21:04 < gnarf> simson: richtig
21:04 < gnarf> simson: hash(1) sollte gleich hash(1) sein
21:04 < gnarf> simson: auch wenn die unterschiedliche referenzen haben
21:04 < gnarf> noch fragen?
21:05 < andoo> was verstehst du unter referenzen?
21:05 < revenger__> pointer
21:05 < andoo> wenn ich a=b mache
21:05 < gnarf> andoo: für c++ler: pointer
21:05 < gnarf> andoo: die pointer werden kopiert
21:05 < andoo> aber ann sollte doch a=12; b=a; a=23;print b; auch 23 ausgeben
21:05 < andoo> tut es aber nicht
21:05 < gnarf> andoo: nein.
21:06 < revenger__> andoo: nur bei dicts und listen werden pointer übergeben
21:06 < gnarf> andoo: bei a=23 bekomt a einen neuen pointer
21:06 < revenger__> a, b sind direkte zuweisungen
21:06 < gnarf> andoo: b behält den alten von a
21:06 < andoo> achso :)
21:06 -!- Nebukadneza [~daddel9@dsl-213-023-052-086.arcor-ip.net] has quit ["Client exiting"]
21:06 < revenger__> das war ihm zuviel :)
21:06 < gnarf> gut.
21:06 < gnarf> 21:03 < gnarf> 3.2 Binäre Operatoren
21:06 < andoo> revenger__: nein, er muss weg. und tla fällt aus
21:07 < revenger__> ok
21:07 < gnarf> 3.2.1 Mathematische Binäre Operatoren
21:07 < gnarf> ruhe ;)
21:07 < gnarf> a+b, a-b, a*b, a/b, a%b, a**b, a // b
21:07 < gnarf> die sind mir eingefallen
21:07 < gnarf> a % b ist modulo (nur integer)
21:07 < gnarf> a % b kann auch bei strings verwendet werden
21:07 < gnarf> wer kennt die funktion "sprintf" aus c/c++/perl/awk nicht?
21:08 < simson> ich
21:08 < gnarf> oder "printf" aus der shell
21:08 < simson> ich
21:08 * simson
21:08 < gnarf> ok man kann strings formatieren
21:08 < andoo> ** ist potenzieren? // ist radizieren?
21:08 < gnarf> andoo: warte
21:08 < gnarf> simson: lies bitte man 3 sprintf ;)
21:09 < gnarf> simson: ab section Format of the format string
21:09 < gnarf> so ähnlich ist das in python auch
21:09 < gnarf> die wichtigsten formate sind %s für strings %d für integer
21:09 < gnarf> %f für floats
21:09 < revenger__> %.2f float mit 2 nachkommastellen
21:09 < gnarf> damit kann man mit "Hallo %s." % nick formatieren
21:10 < gnarf> wenn nick revenger__ ist kommt da "Hallo revenger__." raus
21:10 < gnarf> revenger__: ja
21:10 < gnarf> will man mehr als ein argument, nimmt man tupel
21:11 < gnarf> "%s ist %d Jahre alt." % (name, alter)
21:11 < gnarf> a**b ist potenzieren
21:11 < gnarf> funktioniert hauptsächlich mit zahlen
21:11 < gnarf> kleine anmerkung für mathematiker: complex(-1)**complex(0.5)
21:12 < gnarf> ich denke den typ kann sich jeder selbst erarbeiten ;)
21:12 < gnarf> a // b ist ganzzahldivision
21:12 < gnarf> andoo: nicht radizieren
21:12 < gnarf> das ergebnis wird auf die nächstkleinere ganzzahl abgerundet
21:13 < gnarf> fragen? anmerkungen?
21:13 < revenger__> is gut so :)
21:13 < ThomasWaldmann> beim strings formatieren ist es auch moegl dicts zu verwenden
21:14 < andoo> beispiel?
21:14 < ThomasWaldmann> print "%(name)s ist %(alter)d jahre alt" % dict
21:14 < gnarf> %(name)"%(foo)s" % {"foo":"bar"}
21:14 < gnarf> genau
21:14 < ThomasWaldmann> in dict muessen dann natuerlich name und alter nachschlagbar sein
21:14 < revenger__> interessant :)
21:15 < gnarf> s/%(name)//
21:15 < gnarf> wenn nicht gibt das ne exception
21:15 < ThomasWaldmann> v.a. wenn man was mehrfach braucht oder sehr lange bildschirminhalte damit generiert sehr praktisch
21:16 < gnarf> da dann jetzt alle klarheitenbeseitigt sind gehen wir zu:
21:16 < gnarf> 3.2.2 Bitweise binäre Operatoren
21:16 < gnarf> a&b, a|b, a^b
21:16 < gnarf> c benutzer kennen diese wahrscheinlich ziemlich gut
21:17 < gnarf> es ist einfach bitweise und, oder und exklusiv oder
21:17 < revenger__> mhm
21:17 < gnarf> 3.2.3 Logische binäre Operatoren
21:17 < gnarf> a and b, a or b
21:17 < gnarf> verhalten sich wie && und || in c und in der shell
21:18 < gnarf> das bedeuteted auch, wenn bei a and b a False ist, wird b _nicht_ ausgewertet
21:18 < gnarf> fragen oder anmerkungen dazu?
21:19 < gnarf> gut.
21:19 < gnarf> 3.2.4 - Vergleiche
21:19 < gnarf> a >> b, a << b, a > b, a >= b, a == b, a != b, a <= b, a < b, a in b, a is b
21:19 < gnarf> ach und bitschifts ;)
21:19 < revenger__> dacht ich mir :)
21:19 < gnarf> >> und << sind bitshifts. braucht man nie. vergessen
21:19 < andoo> ohne "c" bitte :)
21:19 < gnarf> ups ;)
21:20 < gnarf> wer mehr bitshifts wissen will, bitte nachlsesn oder nachher fragen
21:20 < gnarf> a > b, a >= b, a == b, a != b, a <= b, a < b sollten alle klar sein
21:20 < revenger__> gibts unter python auch <> ?
21:20 < gnarf> a != b ist a /= b in haskell
21:20 < gnarf> revenger__: <> aus pascal ist !=
21:20 < revenger__> ja das gibts bei postgres auch ..
21:21 < revenger__> schaut komisch aus :)
21:21 < gnarf> k. auch was gelernt
21:21 < gnarf> a in b prüft ob a in einem "iteratable" b ist
21:21 < gnarf> iteratable sind listen, tupel, strings, dicts
21:21 < SpyrooU> frage: wer loggt den chan? muss weg, wuerde mich freuen wenn mir jemand das komplette log schcken koennte =) Mattias.Giese@web.de
21:21 < gnarf> revenger__: übernimmst du?
21:22 -!- SpyrooU [~Mattias_G@pD9537A74.dip.t-dialin.net] has quit ["leaving"]
21:22 < gnarf> a is b liefert identitäten
21:22 < gnarf> simson: da sind deine identitäten
21:22 < gnarf> a is b ist nur True wenn die referenz gleich ist
21:23 < gnarf> unter umständen kann also a == b and not a is b also auch True sein
21:23 < gnarf> verstanden? fragen? anmerkungen?
21:23 < ThomasWaldmann> eins vielleicht noch zu vorhin
21:24 < ThomasWaldmann> es gibt in py auch ein objekt namens "None" - wird gerne verwendet, wenn man wirklich "nichts" haben will
21:24 < gnarf> hatte ich nur sehr am rande erwähnt. tschuldigung.
21:24 < andoo> vergleichbar mit void?
21:25 < gnarf> andoo: ähnlich. aber es hat einen einzigen wert
21:25 < gnarf> andoo: also foo=None funktioniert, wogegen du in c ein void nicht instanzieren kannst
21:26 < gnarf> ich würd dann jetzt gerne allen teilnehmern 5 (oder 10) min zeit geben sich mit dem python taschenrechner vertraut zu machen
21:26 < ThomasWaldmann> abtesten dann mit foo is None
21:26 < gnarf> da es vom None typ nur ein einziges element gibt, gibt es auch nur ein einziges None objekt (speed)
21:26 < gnarf> und is ist schneller als ==
21:26 < gnarf> is kann nicht überladen werden
21:27 < gnarf> bitte also jetzt ausgibig testen und sofort fragen
21:27 < gnarf> ich hab bestimmt viel vergessen
21:27 < gnarf> aber keywords und programmstruktur kommen erst gleich
21:27 < andoo> ich hab nebenbei getestet und mir viel nur auf das man die schlüssel(!) in dicts nicht mit "bla" sondern mit 'bla' definieren muss
21:28 < gnarf> andoo: nein
21:28 < gnarf> andoo: probier nochmal
21:28 < ThomasWaldmann> sollte egal sein
21:28 < andoo> ok, muss ein anderer fehler gewesen sein :)
21:29 * andoo geht jetzt auf mottenjagd
21:29 < gnarf> vll sollte ich nochmal die 1-tueplsyntax nennen. (element,) ich glaub das ist vorhin untergegangen
21:30 < gnarf> probiert noch jemand rum, oder langweilen sich grad alle?
21:31 < ThomasWaldmann> was lustiges am rande: print "hallo "*3
21:31 < gnarf> hehe :)
21:31 < andoo> andoo vs. motte = 0:1
21:31 < gnarf> str * int verhält sich wie ein x in perl
21:32 < gnarf> örks. ich hab was total wichtiges vergessen %)
21:32 < gnarf> `x`
21:32 < gnarf> unär
21:32 < gnarf> das ist der "representation" operator
21:32 < gnarf> jedes objekt sollte in eine menschlich lesbare gestallt in form eines strings konvertierbar sein
21:33 < andoo> andoo vs. motte = 2:1 und abpfiff :)
21:33 < ThomasWaldmann> besser ist es, da repr() zu verwenden
21:33 < gnarf> bei den genannten basistypen, kann man die ausgabe wieder in einen python interpreter füttern
21:33 < gnarf> man sollte später nach möglichkeit für _jede_ klasse doc strings (später) und diesen repr operator definieren
21:34 < ThomasWaldmann> und es ist auch sehr praktisch, wenn man nur ne ascii console hat, trotzdem aber unicode oder umlaute ausgeben will zu debugzwecken
21:34 < gnarf> probiert noch irgendjemand rum?
21:34 < andoo> nö
21:35 < gnarf> gut. weiter gehts
21:35 < gnarf> 4 Schlüsselwörter und Programmstruktur (der wohl größte teil)
21:35 < gnarf> erstmal haben schon viele print erwähnt
21:35 < gnarf> print gibt seine argumente aus
21:35 < gnarf> für nicht strings wird dazu repr vorher angewandt
21:36 < gnarf> man kann also in der python shell auch überall print vorschreiben
21:36 < gnarf> allerdings wird dann auch None ausgegeben
21:36 < gnarf> indenting...
21:36 < gnarf> blöcke werden nicht wie in c, perl etc mit {} begrenz sondern eingrückt
21:37 < gnarf> alles was den gleichen einrückungsgrad hat ist ein block
21:37 < gnarf> mom *beispiel such*
21:37 < andoo> gnarf: auch wenn ein leerzeile dazwischen ist?
21:37 < ThomasWaldmann> andoo: ja
21:38 < andoo> ThomasWaldmann: heißt du gnarf ;)
21:38 < andoo> aber trotzdem danke für die antwort :)
21:38 < gnarf> http://gatle.homelinux.org/superpos.python
21:38 < gnarf> nicht verstehen, nur die struktur anschauen
21:39 < gnarf> damit kommen wir gleich zu if
21:39 < gnarf> if bedingung: # doppelpunkt nicht vergessen
21:39 < gnarf> statements # einrücken
21:39 < gnarf> mehr_statements # einrücken
21:39 < gnarf> elif bedingung: # doppelpunkt und elif ohne s
21:40 < gnarf> statements # einrücken
21:40 < gnarf> else: # doppelpunkt
21:40 < gnarf> statements
21:40 < gnarf> elif oder else oder beide können weggelassen werden
21:40 < gnarf> alles was nicht bool ist, wird in bool umgewandelt
21:41 < gnarf> wenn len(a) 0 ist, ist meist auch der bool von a null
21:41 < gnarf> False mein ich ;)
21:41 < gnarf> fragen?
21:41 < gnarf> pass <- kein passwort, sondern ein statement
21:42 < gnarf> das leere statement
21:42 < gnarf> else wegzulassen wäre equivalent zu:
21:42 < gnarf> if b:
21:42 < gnarf> s
21:42 < gnarf> else:
21:42 < gnarf> pass
21:42 < gnarf> überall wo ein leerer block stehen müsste schreibt man pass hin
21:42 < gnarf> btw. eine gute konvention ist es 4 spaces zu nehmen
21:43 < gnarf> while <- schleifen
21:43 < gnarf> while bedingung:
21:43 < gnarf> statements
21:43 < gnarf> auch hier den doppelpunkt nicht vergessen
21:44 < gnarf> die statements werden solange ausgeführt bis die bedingung False liefert
21:44 < gnarf> das kann auch 0 mal bedeuten
21:44 < gnarf> außerdem kann man continue einfügen
21:44 < andoo> auch break?
21:44 < genera> kein end?
21:44 < gnarf> dabei wird der rest des schleifenkörpers weggelassen und bei der abbruchbedingung weitergemacht
21:44 < gnarf> mit break kann man die schleife sofort verlassen
21:45 < gnarf> eins noch, dann gehts ans schreiben:
21:45 < gnarf> for variable in iteratable:
21:45 < gnarf> statements
21:46 < gnarf> hierbei wird für jedes element aus iteratable statements aufgerufen wobei variable das jeweilieg element ist
21:46 < gnarf> beispiel:
21:46 < gnarf> for x in [1,2,3]:
21:46 < gnarf> print x
21:46 < gnarf> gibt 3 zahlen aus
21:46 < gnarf> verstanden (wichtig)? fragen? anmerkungen?
21:47 < ThomasWaldmann> zu den 4spaces
21:47 < ThomasWaldmann> es ist v.a. wichtig, nie spaces und tabs zu mischen
21:47 < gnarf> ansonsten zählen tabs wie 8 spaces
21:47 < ThomasWaldmann> und am besten ist es wirklich, auf tabs zu verzichten
21:48 < gnarf> mein beispiel enthält auch keine tabs
21:48 < gnarf> so. nun zu der praxis
21:48 < andoo> wenn ich als iteratable ein dict nehme {"eins":"one", "zwei":"two", "drei":"three"} wie komm ich dann an one, two, three?
21:49 < gnarf> jeder sollte ein kleines eigenes programm, dass all diese schlüsselwörter beinhaltet, schreiben
21:49 < gnarf> andoo: for x,y in somedict:
21:49 < andoo> aha
21:49 < gnarf> andoo: oder for x in somedict: und x als 2-tupel verwenden
21:49 < gnarf> wer keine ahnung hat, was sie/er schreiben möchte: 99 bottles of beer
21:50 < gnarf> ich möchte das nicht überprüfen, wer mir oder tw seinen source zur korrektur geben möchte kann das tun (z.B. auf http://nopaste.gatle.homelinux.org/)
21:50 < gnarf> jedoch fänd ich es gut, wenn jeder die möglichkeit nutzen würde und jetzt ein kleines beispiel schreibt
21:51 < ThomasWaldmann> gnarf: das mit x,y geht so nicht
21:51 < gnarf> ups
21:51 < gnarf> (x,y)
21:51 < gnarf> oder ne. das waren nur die keys
21:52 < gnarf> mein fehler
21:52 < andoo> wie mach ich das wenn ich nur x nehme?
21:52 < gnarf> mit x,y geht das nur bei dict.items()
21:52 < simson> wie bau ich mir eine liste bistimmter länge?
21:52 < gnarf> simson: l.append()
21:52 < gnarf> ach ne.
21:52 < simson> huh?
21:52 < gnarf> simson: l = [element]*n
21:52 < simson> ich möchte eine liste bestimmter länge, die nur false enthält
21:53 < gnarf> l=[False]*n
21:53 < simson> jo, sagtest du ja ;)
21:53 < gnarf> ich glaub ich hab grad noch was zu listen vergessen
21:53 < gnarf> liste[n] gibt das nte element der liste (oder des tupels)
21:54 < gnarf> man beginnt mit dem zählen bei _0_
21:54 < gnarf> liste[-n] gibt das nte element von hinten also bei -1 das letzte
21:54 < gnarf> liste[a:b] gibt eine liste mit den elementen ab dem aten bis exklusive dem bten
21:55 < gnarf> wenn b<a ist []
21:55 < gnarf> außer wenn b negativ ist ;)
21:55 < gnarf> bissl rumprobieren halt ;)
21:57 < ThomasWaldmann> dict['key'] greift dementsprechend via 'key' auf den wert im dict zu
21:58 < ThomasWaldmann> was man vielleicht noch erwaehnen sollte, ist dass man in py viel weniger "laufindices" i braucht
21:59 < simson> ich brauch grad zwo ;)
21:59 < gnarf> simson: versuch es anders
21:59 < ThomasWaldmann> weil man ja mit "for elem in list" auch direkt die elemente kriegt
21:59 < simson> aber eben nicht die stelle
21:59 < simson> oder?
21:59 < gnarf> es gibt eine range() funktion. range(von, bis, schrittgröße)
22:00 < gnarf> ah. das ist eine gute gelegenheit pydoc einzuführen
22:00 < simson> gnarf: du kannst meinen code ja gleich beurteilen, sobald er läuft ;)
22:00 < gnarf> es gibt in der shell ein prog pydoc
22:00 < gnarf> pydoc -k (so öhnlich wie apropos)
22:01 < gnarf> pydoc (so ähnlich wie man oder perldoc)
22:01 < gnarf> pydoc range (informationen zu range)
22:01 < gnarf> schrittgröße und von sind bei range optional (aber das liest ja hoffentlich grad jeder)
22:02 < simson> wurzel?
22:02 < gnarf> sqrt
22:03 < gnarf> simson: oder **0.5 (steht oben auch)
22:03 < andoo> no Python documentation found for 'sqrt'
22:03 < gnarf> weil sqrt ist in math
22:03 < andoo> ah
22:03 < gnarf> also import math
22:03 < gnarf> math.sqrt
22:03 < andoo> gnarf: danke :) war schon klar
22:03 < gnarf> das sollte ich auch mal erläutern ;)
22:04 < gnarf> import <modul> importiert ein modul. math ist ein beispiel. dann kann man auf alle elemente mit modul.element zugreifen
22:04 < andoo> oder "import * from math" :)
22:04 < gnarf> from <modul> import a,b,c importiert nur teile auf diese kann man dann direkt zugreifen
22:04 < andoo> ist mir sympathischer
22:04 < gnarf> andoo: fast
22:04 < andoo> hehe
22:05 < gnarf> from <modul> import * importtiert alles direkt
22:05 < gnarf> am rande: für dynamischen code siehe __import__
22:05 < ThomasWaldmann> letzteres sollte man sehr sparsam wenn ueberhaupt verwenden
22:06 < gnarf> beispiele wären noch gut. in kleineren programmen ist folgendes ok:
22:06 < gnarf> from math import sqrt
22:06 < gnarf> man kann sich auch informationen zu ganzen modulen anzeigen lassen
22:06 < gnarf> pydoc <modul>
22:06 < gnarf> module:
22:06 < andoo> gnarf: kann ich eine liste aller verfügbaren module bekommen?
22:06 < gnarf> math kennen wir
22:07 < gnarf> pydoc -k "" ?
22:07 < ThomasWaldmann> http://python.org/doc/lib/
22:07 < andoo> etwas übersichtlicher bitte :)
22:07 < gnarf> os sind betribesystem spezifische funktionen
22:07 < gnarf> sys sind allgemeine betriebssystem funktionen
22:08 < simson> ok
22:08 < simson> bin fertig ;)
22:08 < simson> gnarf: guckst du dir meinen code an?
22:08 < gnarf> opeartor ist für die funktionaleren typen (simson)
22:08 < gnarf> simson: wo?
22:08 < gnarf> simson: am besten auf irgendeinem webserver
22:08 < simson> wo denn?
22:08 < simson> jo
22:08 < gnarf> hmm mein "1 stunde vll" war ziemlich schlecht geschätzt ;)
22:09 < andoo> ich hab hier z.b. noch wxPython, twisted, pyosd und pygtk und hätte gerne eine liste mit allen verfügbaren modulen
22:09 < andoo> so das ich im script entweder wxPython oder pygtk nutzen kann
22:09 < simson> gnarf: http://www.gaussschule-bs.de/~simon/lern-python.py
22:10 < gnarf> simson: if not prim:
22:11 < simson> hab ich schon bemerkt ;)
22:11 < gnarf> simson: oder noch beser if prim: und dann den else part ;)
22:11 < ThomasWaldmann> simson: 4 spaces
22:12 < simson> ich benutz lieber tab..
22:12 < gnarf> ups. nochwas vergessen ;)
22:12 < gnarf> für die meisten operatoren geht: a = a <op> b <=> a <op>= b (wie in c, c++, perl)
22:12 < ThomasWaldmann> simson: vermutlich wirst das noch irgendwann bereuen ;)
22:13 < gnarf> simson: und sicher, dass es j=j+j hießen soll?
22:13 < andoo> naja, dauernd auf space rumhämmern ist schon nervig :)
22:13 < simson> gnarf: ja.
22:13 < gnarf> simson: nicht j+=i ?
22:13 < simson> gnarf: oh
22:13 < gnarf> simson: weil j+=j <=> j*=2
22:14 < simson> gnarf: du hast recht ;)
22:14 < revenger__> soda auch wieder da :)
22:14 < gnarf> und wenn du in i steps gehts, nimm for j in range(2*i, n, i)
22:14 < gnarf> wb seit wann fehlst du?
22:15 < gnarf> andoo: was macht dein beispiel?
22:15 < revenger__> ner halben stunde :) aber ich kenn python ja eh so halbwegs :)
22:15 < andoo> ich bekomm ja keine antwort :) dann mach ich auch kein beispiel ;)
22:15 < gnarf> andoo: frage nochmal? (sorry)
22:16 < andoo> <andoo> ich hab hier z.b. noch wxPython, twisted, pyosd und pygtk und hätte gerne eine liste mit allen verfügbaren modulen
22:16 < andoo> <andoo> so das ich im script entweder wxPython oder pygtk nutzen kann
22:16 < revenger__> hab mirs backlog durchgelesen .. bin jetz wieder auf eurem level :)
22:16 < gnarf> axo. hm keine ahnung.
22:16 < gnarf> andoo: mach einfach was ohne das ganze zeug
22:16 < gnarf> andoo: vielleicht finden wir ja noch was.
22:16 < ThomasWaldmann> andoo: try: import ... except: ...
22:16 < gnarf> except ImportError:
22:16 < gnarf> aber dazu wollte ich eigentlich gegen ende kommen
22:17 < ThomasWaldmann> jo
22:17 < andoo> ah gut :)
22:17 < gnarf> andoo: mach einfach mal keine extrawürstchen ;)
22:17 < gnarf> genera: machst du noch mit?
22:17 < gnarf> revenger__: machst du auch ein beispiel?
22:17 < andoo> gnarf: ich kann ja python. mich interessieren nur noch die extra-würstchen ;)
22:17 < gnarf> johnyb: machst du noch mit?
22:18 < gnarf> andoo: hm. k. keiner zwingt dich.
22:18 < gnarf> braucht noch irgendjemand mehr zeit?
22:18 < gnarf> ok. weiter gehts.
22:18 < gnarf> wir schreieb nun unsere erste funktion
22:19 < gnarf> def addone(x):
22:19 < revenger__> gnarf: was fürn beispiel?
22:19 < gnarf> """Diese Funktion inkementiert ihr argument."""
22:19 < gnarf> return 1+x
22:19 < gnarf> revenger__: ein einfaches beispiel mit if und while mit den bekannten dingen schreiben
22:19 < gnarf> ein paar dinge sind hierbei wichtig:
22:20 < gnarf> def definiert eine funktion oder methode
22:20 < gnarf> in klammer kommen die argumente durch , getrennt oder auch 0 argumente
22:20 < gnarf> danach nicht den : vergessen
22:20 < gnarf> doc strings sind wie man sieht in drei """ oder ''' eingeklammert
22:20 < gnarf> eigentlich sind das auch normale strings
22:21 < gnarf> auch "foo" kann ein doc string sein
22:21 < gnarf> in doc strings wird nur oft """ verwendet damit der string über mehrere zeilen gehen kann
22:21 < gnarf> und damit man innerhalb des strings ein einzelnes " oder ' nicht escapen muss
22:22 < gnarf> return beendet die funktion sofort und liefert den dahinterstehenden term als ergebnis
22:22 < gnarf> ist kein return vorhanden ist der rückgabewert None
22:22 < gnarf> a=addone(5) setzt a auf 6
22:23 < gnarf> fragen dazu?
22:23 < gnarf> def return_none():
22:23 < gnarf> """Diese Funktion gibt None zurück."""
22:23 < gnarf> pass
22:23 < gnarf> noch ein beispiel
22:24 < gnarf> jeder darf mal fakultät schreiben (rekursiv und nichtrekursiv)
22:24 < ThomasWaldmann> nur ne anmerkung: man kann auch listen, tuple, dicts etc. zurückgeben, ist also nicht auf 1 wert beschränkt wir in anderen sprachen
22:24 < gnarf> naja ne liste ist auch nur eine variable
22:24 < simson> jo
22:24 < gnarf> bzw. ein "container"
22:24 < andoo> es wird also immer eine referenz als rückgabewert übergeben?
22:25 < gnarf> andoo: alles wird als referenz behandelt ;)
22:25 < revenger__> gnarf: http://www.linuxwiki.de/linux_2ede_2eworkshop_2fpython sowas? :)
22:25 < andoo> gnarf: ich wollt nur schlau tun ;)
22:25 < revenger__> ok eigentlich print foobar :)
22:25 < gnarf> revenger__: :)
22:25 < gnarf> revenger__: klammern sind bei if und while nicht notwendig
22:26 < gnarf> revenger__: zählschleifen lieber mit for in range
22:26 < revenger__> weiss ich kommt aber von den andren programmiersprachen
22:26 < gnarf> revenger__: gewöhn dich um. py ist halt _anders_
22:26 < gnarf> ModelNine: nimmst du am workshop eigentlich auch teil?
22:27 < gnarf> weiter gehts
22:27 < simson> gnarf: wie kann ich in ein dict einfügen?
22:27 < gnarf> simson: eindict[schlüssel] = wert
22:27 < gnarf> lambda (darauf hat simson schon lange gewartet)
22:28 < gnarf> lambda tut das gleiche wie def nur, dass die funktionen keinen namen haben und dass man mit lambda mehrere funktionen (z.B. in einer schleife) erzeugen kann
22:28 < gnarf> addone = lambda a: 1+a
22:28 < gnarf> wer von haskell kommt und currying mag:
22:28 < simson> gnarf: was passiert wenn ich ein schlüssel nachfrage, dem im dict kein wert zugewiesen ist?
22:28 < gnarf> add = lambda a: lambda b: a+b
22:29 < gnarf> simson: KeyError iirc eindict.has_key(schlüssel) -> Bool oder False
22:29 < gnarf> simson: man kann auch "defaultwerte" vergeben eindict.get(schlüssel, default)
22:30 < gnarf> fragen zu lambda?
22:30 < gnarf> wir sind schon fast am ende ;)
22:30 < gnarf> jetzt kommt del
22:30 < gnarf> del löscht variablen
22:30 < gnarf> del foo und foo existiert nicht mehr
22:31 < gnarf> del eindict[wert] lösch ein einzelnes schlüssel wert paar
22:31 < revenger__> lambda wart mal kannst wo n beispiel geben wo mans einsetzen könnte/würde?
22:31 < gnarf> del liste[nummer] löscht ein element aus einer liste
22:31 < gnarf> revenger__: verwende es wie eine funktion
22:31 < simson> gnarf: geht das? :
22:31 < simson> def cache (fun)
22:31 < simson> csh = {}
22:31 < simson> lambda a:
22:31 < simson> if csh.has_key(a):
22:31 < simson> return csh[a]
22:31 < simson> else:
22:32 < simson> result = fun(a)
22:32 < revenger__> gnarf: soviel ich vom hörensagen weiss kann mans ja wie ein switch verwenden
22:32 < simson> csh[a] = result
22:32 < simson> return result
22:32 < revenger__> python hat kein switch
22:32 < simson> blah
22:32 < gnarf> revenger__: was?
22:32 < revenger__> switch(x) wie bei c/c++
22:32 < gnarf> revenger__: was kann man wie switch verwenden?
22:32 < revenger__> lambda? .. weiss nicht habs nur irgendwo irgendwann mal aufgeschnappt
22:32 < gnarf> simson: probier mal, aber ich denke auf lambda darf kein if folgen
22:33 < gnarf> simson: und keine blöcke und nichts
22:33 < simson> huh?
22:33 < simson> menno
22:33 < gnarf> revenger__: ja in kombination mit einem dictionary
22:33 < simson> gnarf: ich wollte eine funktion bauen, die als argument eine funktion übernimt, und eine funktion wiedergibt, die mit einem dict gecached ist ;)
22:33 < revenger__> ok :)
22:34 < simson> gnarf: geht aber nicht :(
22:34 < simson> gnarf: python's lambda ist kaputt.
22:34 < gnarf> simson: verstehe ich noch nicht ganz..
22:34 < gnarf> ich würd jetzt gern noch 2 punkte ab akkern und das dann auflösen
22:34 < gnarf> 3 punkte ;)
22:34 < gnarf> klassen, exceptions und yield
22:35 < gnarf> class name:
22:35 < gnarf> def methode(self):
22:35 < gnarf> pass
22:35 < simson> cache nimmt funktion, definier einen cache, bauet eine lambda funktion, die wenn zu dem argument schon was im dict steht das wiedergibt, und ansonsten den wert berechnet..
22:35 < gnarf> definiert eine einfache klasse mit einer methode ohne argument (!) die nichts tut
22:35 < gnarf> bei klassen haben methoden implizit das objekt als erstes argument
22:36 < gnarf> eine methode könnte auch attribute modifizieren
22:36 < gnarf> def setzeattr(self, wert):
22:36 < gnarf> self.mein_attribut = wert
22:37 < gnarf> dann gibt es eine menge von speziellen methoden der form __<name>__
22:37 < gnarf> dazu am besten mal in http://gatle.homelinux.org/superpos.python schauen
22:37 < revenger__> die man sich mit dir(obj) anzeigen lassn kann :)
22:37 < gnarf> oder eine refrenz zu rate ziehen
22:37 < gnarf> revenger__: der ist mir neu. danke
22:38 < gnarf> auf die spezialmethoden möchte ich ungern jetzt eingehen
22:39 < gnarf> fragen also bitte aufschieben
22:39 < gnarf> try:
22:39 < gnarf> try_block
22:39 < gnarf> raise EineAunahme
22:39 < gnarf> # sorry. falsches indenting
22:39 < gnarf> except EineAusnahme:
22:39 < gnarf> wird_ausgeführt_wenn_ausnahme_geworfen_wird
22:40 < gnarf> eine ausnahme lässt solange alle funktionen returnen, bis sie gefangen wird
22:40 < gnarf> ausnahmen konzept ist hoffentlich aus c++/ruby/delpi/perl oder was auch immer bekannt
22:41 < gnarf> dann gibts noch so n finally block (hinter dem except block, optional)
22:41 < gnarf> ThomasWaldmann: finally?
22:41 < ThomasWaldmann> quasi "letzte worte" ;)
22:42 < revenger__> kann man exeptions eigentlich irgendwie disablen?
22:42 < ThomasWaldmann> also wenn man z.b. noch dateien zumachen will, wenn es geknallt hat
22:42 < andoo> so, bin wieder da
22:42 < revenger__> also wenn eine funktion nicht aufrufbar oder nicht funktioniert automatisch nur die zeile nicht beachtet wird?
22:42 < ThomasWaldmann> revenger__: noe, nur auffangen
22:42 < gnarf> revenger__: man kann alle auffangen
22:42 < revenger__> ja. das weiss ich soweit..
22:42 < gnarf> revenger__: macht nur meist wenig sinn
22:43 < revenger__> bsp datenbank connections..
22:43 < gnarf> ThomasWaldmann: finally wird also nur im falle einer belibigen ausnahme aufgreufen?
22:43 < revenger__> datenbankverbindung ist abgebrochen und beim versuch ein query auszuführen gibts ne exception
22:43 < revenger__> exception
22:43 < revenger__> ergh
22:43 < gnarf> ach ja. unter einem try block können belibig viele except blöcke kommen
22:43 < ThomasWaldmann> gnarf: glaub ja
22:44 < gnarf> und yield wäre da noch (ein imho sehr schönes sprachliches mittel)
22:44 < gnarf> eine funktion kann ja wie wir wissen eine liste zurückgeben
22:44 < revenger__> yield?
22:44 < gnarf> aber wenn man sehr große listen zurückgibt, braucht das viel speicher
22:44 < gnarf> revenger__: erkläre ich grad ;)
22:44 < gnarf> darum kann man sie auch "in teilen" zurückgeben
22:44 < gnarf> beispiel:
22:45 < gnarf> def mein_range(anfang, ende):
22:45 < gnarf> c=anfang
22:45 < gnarf> while c < ende:
22:45 < gnarf> yield c
22:45 < gnarf> ups
22:45 < gnarf> yield c # meinte ich
22:45 < revenger__> indention :)
22:45 < gnarf> c+=1
22:46 < gnarf> das ist ein etwas minimalistisches range
22:46 < gnarf> sowas sollte man immer beim "iterieren" also in for x in hier: verwenden
22:47 < gnarf> so damit wäre ich eigentlich am ende.
22:47 < gnarf> ich möcht somit allen teilnehmern für ihr gehör danken und ein besondere dankwort an ThomasWaldmann für seine tolle unterstützung richten
22:47 < ThomasWaldmann> danke fuers vortragen ,)
22:47 < genera> *Applaus*
22:47 < revenger__> jop danke :)
22:48 < simson> gnarf: jo ;)
22:48 < gnarf> fragen dürfen natürlich weiterhin gestellt werden
22:48 < simson> gnarf: kannst du mir nochmal mit cache helfen?
22:48 < revenger__> *aufntischklopf*
22:48 < gnarf> :)
22:48 < gnarf> simson: ja
22:48 < simson> ok
22:48 < simson> ich lada mal auf iserv.
22:48 < gnarf> btw. ihr dürft jetzt auch langfristig hier bleiben
22:49 -!- gnarf changed the topic of #python.de to: Deutscher Python Kanal
22:49 < revenger__> eigentlich sollte's ja #linux.de.workshop sein :P
22:49 < simson> ok
22:49 < simson> gnarf: schau dir cache mal an
22:49 < gnarf> revenger__: naja. aber ich wollte gleichzeitig n ordentlichen deutschen python channel gründen ;)
22:49 < gnarf> simson: url?
22:49 < simson> wie vorhin..
22:49 < simson> http://www.gaussschule-bs.de/~simon/lern-python.py
22:50 < ThomasWaldmann> es gibt übrigens auch pythonwiki.de
22:50 < revenger__> gnarf: du programmierst ja auch C oder?
22:50 < gnarf> revenger__: ja
22:50 < gnarf> simson: warte mal. das kann man anders machen :)
22:50 < revenger__> schon mal python module geschrieben?
22:50 < gnarf> revenger__: eins
22:50 < gnarf> ein beispiel:
22:50 < simson> gnarf: wie?
22:51 < gnarf> def einefunktion(argumente):
22:51 < gnarf> if bedingung:
22:51 < gnarf> return wahr_wert
22:51 < gnarf> else:
22:51 < gnarf> return falsch_wert
22:51 < gnarf> kann man auch umschreiben
22:51 < gnarf> einefunktion = lambda argumente: (bedingung and [wahr_wert] or [falsch_wert])[0]
22:52 < gnarf> dazu einige erläuterungen
22:52 < simson> aber im else ist nicht nur return!
22:52 < simson> sondern auch die zuweisung.
-- LOG END --