Skip to content
This repository
Browse code

fixed grammar and typos ... at least some of them

  • Loading branch information...
commit 329c019d55b1ec6fd8dc9dd9ef0dcb99e7bb913d 1 parent 3f1c887
authored February 13, 2008 anandology committed January 05, 2011

Showing 1 changed file with 205 additions and 205 deletions. Show diff stats Hide diff stats

  1. 410  tutorial2.de.md
410  tutorial2.de.md
Source Rendered
@@ -5,208 +5,208 @@ title: web.py 0.2 tutorial
5 5
 
6 6
 # web.py 0.2 tutorial
7 7
 
8  
-## Starting
9  
-
10  
-Du kennst also Python und willst eine Webseite erstellen. web.py gibt dir die Möglichkeit, das leicht zu bewerkstelligen.
11  
-
12  
-Wenn du das ganze Tutorial durcharbeiten willst, wirst du python, web.py, flup, psycopg2 und postgres brauchen. Weitere Details dazu auf [webpy.org](http://webpy.org/).
13  
-
14  
-Wenn du bereits ein web.py Projekt hast, schau am besten auf die [upgrade](http://webpy.infogami.com/upgrade_to_point2) Seite (in Englisch) für Informationen zur Migration. 
15  
-
16  
-Legen wir mal los...
17  
-
18  
-## URL Handling
19  
-
20  
-Der wichtigste Bestandteil einer Website ist die URL Struktur. Die URLs sind nicht nur das, was deine Besucher sehen und an ihre Freunde mailen, sie dienen auch als mentales Model, das zeigt, wie die Webseite funktioniert. Bei bekannten Webseiten wie etwa [del.icio.us](http://del.icio.us) sind die URLs sogar ein Teil des Benutzerinterfaces. web.py macht es leicht, gute URLs zu erstellen.
21  
-
22  
-Um mit deinem web.py-Programm anzufangen, öffne eine neue Textdatei (nenn sie `code.py`) und tippe:
23  
-
24  
-    import web
25  
-
26  
-Dadurch wird das web.py-Modul importiert.
27  
-
28  
-Nun müssen wir web.py unsere URL Struktur bekanntmachen, wir beginnen mit etwas Einfachem:
29  
-
30  
-    urls = (
31  
-      '/', 'index'    )
32  
-
33  
-Der erste Teil ist ein [regulärer Ausdruck](http://osteele.com/tools/rework/) dem die URL entsprechen muss, beispielsweise ``/``, ``/help/faq``, ``/item/(\d+)``, etc. (Das ``\d+`` entspricht einer Ziffernfolge. Die runden Klammern bewirken, dass das "gefundene" für später aufgehoben wird. )
34  
-
35  
-Der zweite Teil ist der Name der Klasse an welche die Anfrage geschickt wird, beispielsweise `index`, `view`, `welcomes.hello` (gibt die Anfrage an die Klasse `hello` des Moduls `welcomes`), oder `get_\1`. `\1` wird durch den ersten Treffer (geklammerten Teil) des regulären Ausdrucks ersetzt, alle verbleibenden Funde werden an die Funktion weitergeleitet.
36  
-
37  
-Diese Zeile sagt das wir die URL `/` (die Startseite) mit der Klasse namens `index` bearbeiten wollen.
38  
-
39  
-Nun müssen wir die `index`-Klasse schreiben. Die meisten Leute bemerken es beim Surfen nicht, aber der Browser verwendet eine Sprache, die als HTTP bekannt ist, zur Kommunikation mit dem WWW. Die Details dazu sind nicht wichtig, aber die eigentliche Idee ist, das die Besucher den Webserver auffordern, bestimmte Funktionen (wie eta `GET` oder `POST`) an URLs (wie `/` oder `/foo?f=1`) auszuführen.
40  
-
41  
-`GET` ist die bekannteste Funktion. Sie wird verwendet, um den Text oder Inhalt einer Webseite anzufordern. Wenn du in deinem Browser `harvard.edu` eintippst dann forderst du im wahrsten Sinne des Wortes den Harvard Webserver auf "to `GET /`". Am zweit bekanntesten ist `POST`. POST wird oft verwendet, wenn man ein Formular abschickt, wie zum Beispiel eine Anfrage etwas zu kaufen. Du benutzt `POST` immer dann, wenn das Abschicken der Anfrage etwas bewirkt (wenn du die Kreditkarte belastest oder eine Bestellung aufgibst). Das ist sehr wichtig, denn `GET` URLs können herum gereicht werden und von Suchmaschinen indexiert werden. Das ist zwar etwas, was du für einen Großteil deiner Seite willst, aber bestimmt _nicht_ für Dinge wie Bestellungen aufgeben. (Stell dir vor, Google würde versuchen alles auf deiner Seite zu kaufen).
42  
-
43  
-
44  
-In unserem web.py-Quellcode können wir die zwei Funktionen unterscheiden:
45  
-
46  
-    class index:
47  
-        def GET(self):
48  
-            print "Hello, world!"
49  
-
50  
-Diese `GET`-Funktion wird nun aufgeruft wenn jemand eine `GET` Anfrage an `/` schickt.
51  
-
52  
-Gut, nun müssen wir nur noch eine Zeile hinzufügen, um web.py zu sagen das es Webseiten zur Verfügung stellen soll.
53  
-
54  
-    if __name__ == "__main__": web.run(urls, globals())
55  
-
56  
-Das sagt web.py, dass es die URLs die wir oben definiert haben bereitstellen soll, indem es die Klassen aufruft, die wir in der Datei global definiert haben.
57  
-
58  
-Nun, obwohl du bereits viel gelesen hast, haben wir eigentlich nur etwa fünf Zeilen geschrieben. Das ist eigentlich auch alles, was du für eine komplette web.py-Applikation brauchst.
59  
-
60  
-Wenn du nun in deine Kommandozeile gehst und folgendes tippst:
61  
-
62  
-    $ python code.py
63  
-    Launching server: http://0.0.0.0:8080/
64  
-
65  
-Dann wird deine web.py-Applikation einen Webserver auf deinem Computer laufen lassen. Besuche nun die URL und du solltest ein "Hello, world!" sehen. (Du kannst eine IP Addresse/Port nach dem "code.py" hinzufügen um zu kontrollieren, wo genau web.py den Server startet. Du kannst ihm ebenso sagen ob er ein `fastcgi` oder `scgi` server starten soll.)
66  
-
67  
-**Hinweis:** Du kannst den Port beim Aufruf von 'code.py' angeben, wenn du den Standardwert 8080 nicht benutzen willst oder kannst:
68  
-
69  
-    $ python code.py 1234
70  
-
71  
-
72  
-## Developing
73  
-
74  
-Web.py hat ebenso ein paar Tools die uns beim Debugging helfen. Füge in der letzten Zeile vor `if __name__` folgendes hinzu:
75  
-
76  
-    web.webapi.internalerror = web.debugerror
77  
-
78  
-Das wird dir hilfreiche Fehlermeldungen liefern. Außerdem musst du in der letzten Zeile `web.reloader` hinzufügen, damit es wie folgt aussieht: 
79  
-
80  
-    if __name__ == "__main__": web.run(urls, globals(), web.reloader)
81  
-
82  
-Das sagt web.py, dass es web.reloader verwenden soll. web.reloader ist eine "middleware" (eine Funktion, die bestimmte Funktionalitäten zu dem Webserver hinzufügt). Diese lädt die Dateien jedesmal neu, nachdem du diese verändert hast. Dadurch sieht du die Änderungen sofort im Browser, ohne den Server neu zu starten. (Bei größeren Änderungen kann es trotzdem sein, dass du den Server neustarten musst). Wahrscheinlich wirst du das wieder herausnehmen wollen wenn du deine Seite Online stellst, aber zum Entwickeln ist es großartig. Außerdem gibt es noch `web.profiler`, das zeigt dir am Ende jeder Webseite Informationen darüber, wie lange jede Funktion gebraucht hat, sodass du dein Programm schneller machen kannst. 
83  
-    
84  
-## Templating
85  
-
86  
-HTML von Python aus zu schreiben kann sehr lästig werden; es macht viel mehr spaß, Python innerhalb von HTML zu schreiben. Glücklicherweise macht web.py das ziemlich einfach.
87  
-
88  
-**Hinweis:** Ältere Versionen von web.py haben [Cheetah templates](http://www.cheetahtemplate.org/) verwendet. Du kannst das natürlich immer noch verwenden. Ebenso kann jede andere Software zusammen mit web.py verwendet werden. Aber Cheetah wird nicht mehr offiziell unterstützt.
89  
-
90  
-Nun, lasst uns ein neues Verzeichnis für unsere templates erstellen (wir nennen es `templates`). Darin erstellen wir eine neue Datei die auf HTML endet (wir nennen sie `index.html`). Darin kannst du nun normales HTML schreiben:
91  
-
92  
-    <em>Hello</em>, world!
93  
-
94  
-Oder du kannst web.py's _templating_-Sprache verwenden und Code zu HTML hinzufügen:
95  
-
96  
-    $def with (name)
97  
-    
98  
-    $if name:
99  
-        I just wanted to say <em>hello</em> to $name.
100  
-    $else:
101  
-        <em>Hello</em>, world!
102  
-
103  
-**Achtung: Zur Zeit sind vier Leerzeichen erforderlich für die Einrückung.**
104  
-
105  
-Wie du sehen kannst, sieht das Python-Dateien ähnlich, abgesehen von der `def with`-Anweisung am Anfang (das sagt dem Template womit es aufgerufen wird) und den `$`, die vor Codestücken platziert werden. Zur Zeit ist es erforderlich, dass das `$def`-Statement in der ersten Zeile der Datei steht. Sollte `name` z.B. `<b>test</b>` enthalten so wird auch `<b>test</b>` angezeigt, wenn man will das der HTML Code wirklich interpretiert wird, so muss man `$:name` anstatt `$name` schreiben.
106  
-
107  
-Nun, zurück zur `code.py`. Unter der ersten Zeile fügen wir hinzu:
108  
-
109  
-    render = web.template.render('templates/')
110  
-
111  
-Damit sucht web.py nach Templates in deinem Template-Verzeichnis. Nun ändere `index.GET` zu:
112  
-
113  
-    name = 'Bob'    
114  
-    print render.index(name)
115  
-
116  
-(`index` ist der Name des Templates und `name` ist das Argument welches an dieses weitergeleitet wird). 
117  
-
118  
-Besuche deine Seite. Sie sollte nun "hello to Bob" ausgeben.
119  
-
120  
-**Entwicklungstipp:** Füge `cache=False` an das Ende deines `render`-Aufrufs. Damit wird web.py jedesmal das Template neu laden wenn du die Seite aufrufst.
121  
-
122  
-Nun ändere die URL-Zeile zu:
123  
-
124  
-    '/(.*)', 'index'
125  
-
126  
-und ändere die Definition von `index.GET` zu:
127  
-
128  
-    def GET(self, name):
129  
-
130  
-und lösche die Zeile mit `name = 'Bob'`. Besuche `/` und es sollte "hello to the world" zu sehen sein. Besuche `/Joe` und es sollte "hello to Joe" erscheinen.
131  
-
132  
-Wenn du mehr über web.py templates wissen willst, besuche die [templetor page](/templetor).
133  
-
134  
-## Databasing
135  
-
136  
-**Hinweis:** Bevor du eine Datenbank benutzen kannst, vergewissere dich das du die entsprechenden Datenbank Bibliotheken installiert hast. Für MySql Datenbanken kannst du [MySQLdb](http://sourceforge.net/project/shofiles.php?group_id=22307) verwenden und für Postgres verwende [psycopg2](http://initd.org/pub/software/psycopg/).
137  
-
138  
-Über der `web.run` Zeile füge folgendes hinzu:
139  
-
140  
-    web.config.db_parameters = dict(dbn='postgres', user='username', pw='password', db='dbname')
141  
-
142  
-(Passe die Parameter entsprechend an, vor allem `username`, `password`, und `dbname`. MySQL User sollten `dbn` zu `mysql` ändern.)
143  
-Die Zeile könnte für Sqlite Benutzer in etwa wie folgt aussehen:
144  
-
145  
-	web.config.db_parameters = dict(dbn='sqlite', db='data.db')
146  
-
147  
-Erstelle eine einfache Tabellen in deiner Datenbank:
148  
-
149  
-    CREATE TABLE todo (
150  
-      id serial primary key,
151  
-      title text,
152  
-      created timestamp default now(),
153  
-      done boolean default 'f'    );
154  
-
155  
-Und füge eine Zeile ein:
156  
-
157  
-    INSERT INTO todo (title) VALUES ('Learn web.py');
158  
-
159  
-In `code.py` ändere `index.GET` zu:
160  
-
161  
-    def GET(self):
162  
-        todos = web.select('todo')
163  
-        print render.index(todos)
164  
-
165  
-und ändere den URL-Handler wieder zurück zu `/`.
166  
-
167  
-Ändere `index.html` damit es wie folgt aussieht: 
168  
-
169  
-    $def with (todos)
170  
-    <ul>
171  
-    $for todo in todos:
172  
-        <li id="t$todo.id">$todo.title</li>
173  
-    </ul>
174  
-
175  
-Besuche deine Seite erneut und du wirst dein erstes Todo-Item sehen: "Learn web.py". Gratuliere, du hast ein voll funktionsfähiges Programm, das aus einer Datenbank liest. Nun wollen wir es auch noch in die Datenbank schreiben lassen.
176  
-
177  
-Füge folgendes am Ende von `index.html` hinzu:
178  
-
179  
-    <form method="post" action="add">
180  
-    <p><input type="text" name="title" /> <input type="submit" value="Add" /></p>
181  
-    </form>
182  
-
183  
-Und ändere deine URLs, damit es so aussieht:
184  
-
185  
-    '/', 'index',
186  
-    '/add', 'add'
187  
-
188  
-(Passe mit den Kommas auf. Wenn du sie vergisst, fügt Python die Strings zusammen und sieht `'/index/addadd'`, was nicht das ist, das du haben willst!)
189  
-
190  
-Füge in `code.py` folgende Klasse hinzu: 
191  
-
192  
-    class add:
193  
-        def POST(self):
194  
-            i = web.input()
195  
-            n = web.insert('todo', title=i.title)
196  
-    	    web.seeother('/')
197  
-
198  
-(Bemerkt? Wir benutzen hier `POST`)
199  
-
200  
-`web.input` gibt dir Zugriff auf jede Variable die der User durch ein Formular abgeschickt hat. Wenn du Daten von Items mit dem selben Namen verarbeiten willst (wie in etwa bei einer Serie von Checkboxen mit name="name" benutze:
201  
-
202  
-    post_data=web.input(name=[])
203  
-
204  
-`web.insert` fügt eine Zeile zur Datenbanktabelle `todo` hinzu und gibt die ID der neuen Zeile zurück. `seeother` leitet den User weiter zu dieser URL.
205  
-
206  
-Kurz: `web.transact()` startet eine Transaktion. `web.commit()` übergibt diese. `web.rollback()` macht die Transaktion nichtig. `web.update` funktioniert in etwa so wie `web.insert` außer dass es anstatt eine ID zurückzugeben eine nach dem Tabellennamen benötigt (oder eine `WHERE` Klausel). 
207  
-
208  
-`web.input`, `web.query` und einige andere Funktionen in web.py liefern "Storage objects" zurück, sie funktionieren genau wie Dictionaries, außer das du `d.foo` zusätzlich zu `d['foo']` verwenden kannst. Das macht vieles einfach lesbar.
209  
-
210  
-Du kannst die ganzen Details dazu und allen anderen web.py-Funktionen in der [Dokumentation](http://new.webpy.org/docs) nachlesen.
211  
-
212  
-Das Tutorial endet hier, schau dir die Dokumentation an, um zu sehen was man noch so cooles mit web.py machen kann.
  8
+## Starting
  9
+
  10
+Du kennst also Python und willst eine Webseite erstellen. web.py gibt dir die Möglichkeit, das leicht zu bewerkstelligen.
  11
+
  12
+Wenn du das ganze Tutorial durcharbeiten willst, wirst du python, web.py, flup, psycopg2 und postgres brauchen. Weitere Details dazu auf [webpy.org](http://webpy.org/).
  13
+
  14
+Wenn du bereits ein web.py Projekt hast, schau am besten auf die [upgrade](http://webpy.infogami.com/upgrade_to_point2) Seite (in Englisch) für Informationen zur Migration. 
  15
+
  16
+Legen wir mal los...
  17
+
  18
+## URL Handling
  19
+
  20
+Der wichtigste Bestandteil einer Website ist die URL Struktur. Die URLs sind nicht nur das, was deine Besucher sehen und an ihre Freunde mailen, sie dienen auch als mentales Model, das zeigt, wie die Webseite funktioniert. Bei bekannten Webseiten wie etwa [del.icio.us](http://del.icio.us) sind die URLs sogar ein Teil des Benutzerinterfaces. web.py macht es leicht, gute URLs zu erstellen.
  21
+
  22
+Um mit deinem web.py-Programm anzufangen, öffne eine neue Textdatei (nenn sie `code.py`) und tippe:
  23
+
  24
+    import web
  25
+
  26
+Dadurch wird das web.py-Modul importiert.
  27
+
  28
+Nun müssen wir web.py unsere URL Struktur bekanntmachen, wir beginnen mit etwas Einfachem:
  29
+
  30
+    urls = (
  31
+      '/', 'index'    )
  32
+
  33
+Der erste Teil ist ein [regulärer Ausdruck](http://osteele.com/tools/rework/) dem die URL entsprechen muss, beispielsweise ``/``, ``/help/faq``, ``/item/(\d+)``, etc. (Das ``\d+`` entspricht einer Ziffernfolge. Die runden Klammern bewirken, dass das "gefundene" für später aufgehoben wird. )
  34
+
  35
+Der zweite Teil ist der Name der Klasse an welche die Anfrage geschickt wird, beispielsweise `index`, `view`, `welcomes.hello` (gibt die Anfrage an die Klasse `hello` des Moduls `welcomes`), oder `get_\1`. `\1` wird durch den ersten Treffer (geklammerten Teil) des regulären Ausdrucks ersetzt, alle verbleibenden Funde werden an die Funktion weitergeleitet.
  36
+
  37
+Diese Zeile sagt das wir die URL `/` (die Startseite) mit der Klasse namens `index` bearbeiten wollen.
  38
+
  39
+Nun müssen wir die `index`-Klasse schreiben. Die meisten Leute bemerken es beim Surfen nicht, aber der Browser verwendet eine Sprache, die als HTTP bekannt ist, zur Kommunikation mit dem WWW. Die Details dazu sind nicht wichtig, aber die eigentliche Idee ist, dass die Besucher den Webserver auffordern, bestimmte Funktionen (wie eta `GET` oder `POST`) an URLs (wie `/` oder `/foo?f=1`) auszuführen.
  40
+
  41
+`GET` ist die bekannteste Funktion. Sie wird verwendet, um den Text oder Inhalt einer Webseite anzufordern. Wenn du in deinem Browser `harvard.edu` eintippst, dann forderst du im wahrsten Sinne des Wortes den Harvard Webserver auf "to `GET /`". Am zweit bekanntesten ist `POST`. POST wird oft verwendet, wenn man ein Formular abschickt, wie zum Beispiel eine Anfrage etwas zu kaufen. Du benutzt `POST` immer dann, wenn das Abschicken der Anfrage etwas bewirkt (wenn du die Kreditkarte belastest oder eine Bestellung aufgibst). Das ist sehr wichtig, denn `GET` URLs können herum gereicht werden und von Suchmaschinen indexiert werden. Das ist zwar etwas, was du für einen Großteil deiner Seite willst, aber bestimmt _nicht_ für Dinge wie Bestellungen aufgeben. (Stell dir vor, Google würde versuchen alles auf deiner Seite zu kaufen).
  42
+
  43
+
  44
+In unserem web.py-Quellcode können wir diese zwei Funktionen unterscheiden:
  45
+
  46
+    class index:
  47
+        def GET(self):
  48
+            print "Hello, world!"
  49
+
  50
+Die `GET`-Funktion wird nun aufgerufen, wenn jemand eine `GET` Anfrage an `/` schickt.
  51
+
  52
+Gut, nun müssen wir nur noch eine Zeile hinzufügen, um web.py zu sagen, dass es Webseiten zur Verfügung stellen soll.
  53
+
  54
+    if __name__ == "__main__": web.run(urls, globals())
  55
+
  56
+Das sagt web.py, dass es die URLs, die wir oben definiert haben bereitstellen soll, indem es die Klassen aufruft, die wir in der Datei global definiert haben.
  57
+
  58
+Nun, obwohl du bereits viel gelesen hast, haben wir eigentlich nur etwa fünf Zeilen geschrieben. Das ist eigentlich auch alles, was du für eine komplette web.py-Applikation brauchst.
  59
+
  60
+Wenn du nun in deine Kommandozeile gehst und folgendes tippst:
  61
+
  62
+    $ python code.py
  63
+    Launching server: http://0.0.0.0:8080/
  64
+
  65
+Dann wird deine web.py-Applikation einen Webserver auf deinem Computer laufen lassen. Besuche nun die URL und du solltest ein "Hello, world!" sehen. (Du kannst eine IP Addresse/Port nach dem "code.py" hinzufügen um zu kontrollieren, wo genau web.py den Server startet. Du kannst ihm ebenso sagen ob er ein `fastcgi` oder `scgi` server starten soll.)
  66
+
  67
+**Hinweis:** Du kannst den Port beim Aufruf von 'code.py' angeben, wenn du den Standardwert 8080 nicht benutzen willst oder kannst:
  68
+
  69
+    $ python code.py 1234
  70
+
  71
+
  72
+## Developing
  73
+
  74
+Web.py hat ebenso ein paar Tools, die uns beim Debugging helfen. Füge in der letzten Zeile vor `if __name__` folgendes hinzu:
  75
+
  76
+    web.webapi.internalerror = web.debugerror
  77
+
  78
+Das wird dir hilfreiche Fehlermeldungen liefern. Außerdem musst du in der letzten Zeile `web.reloader` hinzufügen, damit es wie folgt aussieht: 
  79
+
  80
+    if __name__ == "__main__": web.run(urls, globals(), web.reloader)
  81
+
  82
+Das sagt web.py, dass es web.reloader verwenden soll. web.reloader ist eine "middleware" (eine Funktion, die bestimmte Funktionalitäten zu dem Webserver hinzufügt). Diese lädt die Dateien jedesmal neu, nachdem du diese verändert hast. Dadurch sieht du die Änderungen sofort im Browser, ohne den Server neu zu starten. (Bei größeren Änderungen kann es trotzdem sein, dass du den Server neustarten musst). Wahrscheinlich wirst du das wieder herausnehmen wollen wenn du deine Seite Online stellst, aber zum Entwickeln ist es großartig. Außerdem gibt es noch den `web.profiler`, der zeigt dir am Ende jeder Webseite Informationen darüber, wie lange jede Funktion gebraucht hat, sodass du dein Programm schneller machen kannst. 
  83
+    
  84
+## Templating
  85
+
  86
+HTML von Python aus zu schreiben kann sehr lästig werden; es macht viel mehr spaß, Python innerhalb von HTML zu schreiben. Glücklicherweise macht web.py das ziemlich einfach.
  87
+
  88
+**Hinweis:** Ältere Versionen von web.py haben [Cheetah templates](http://www.cheetahtemplate.org/) verwendet. Du kannst das natürlich immer noch verwenden. Ebenso kann jede andere Software zusammen mit web.py verwendet werden. Aber Cheetah wird nicht mehr offiziell unterstützt.
  89
+
  90
+Nun, lasst uns ein neues Verzeichnis für unsere templates erstellen (wir nennen es `templates`). Darin erstellen wir eine neue Datei die auf HTML endet (wir nennen sie `index.html`). Darin kannst du nun normales HTML schreiben:
  91
+
  92
+    <em>Hello</em>, world!
  93
+
  94
+Oder du kannst web.py's _templating_-Sprache verwenden und Code zu HTML hinzufügen:
  95
+
  96
+    $def with (name)
  97
+    
  98
+    $if name:
  99
+        I just wanted to say <em>hello</em> to $name.
  100
+    $else:
  101
+        <em>Hello</em>, world!
  102
+
  103
+**Achtung: Zur Zeit sind vier Leerzeichen erforderlich für die Einrückung.**
  104
+
  105
+Wie du sehen kannst, sieht das Python-Dateien ähnlich, abgesehen von der `def with`-Anweisung am Anfang (das sagt dem Template womit es aufgerufen wird) und den `$`, die vor Codestücken platziert werden. Zur Zeit ist es erforderlich, dass das `$def`-Statement in der ersten Zeile der Datei steht. Sollte `name` z.B. `<b>test</b>` enthalten so wird auch `<b>test</b>` angezeigt, wenn man will das der HTML Code wirklich interpretiert wird, so muss man `$:name` anstatt `$name` schreiben.
  106
+
  107
+Nun, zurück zur `code.py`. Unter der ersten Zeile fügen wir hinzu:
  108
+
  109
+    render = web.template.render('templates/')
  110
+
  111
+Damit sucht web.py nach Templates in deinem Template-Verzeichnis. Nun ändere `index.GET` zu:
  112
+
  113
+    name = 'Bob'    
  114
+    print render.index(name)
  115
+
  116
+(`index` ist der Name des Templates und `name` ist das Argument welches an dieses weitergeleitet wird). 
  117
+
  118
+Besuche deine Seite. Sie sollte nun "hello to Bob" ausgeben.
  119
+
  120
+**Entwicklungstipp:** Füge `cache=False` an das Ende deines `render`-Aufrufs. Damit wird web.py jedesmal das Template neu laden wenn du die Seite aufrufst.
  121
+
  122
+Nun ändere die URL-Zeile zu:
  123
+
  124
+    '/(.*)', 'index'
  125
+
  126
+und ändere die Definition von `index.GET` zu:
  127
+
  128
+    def GET(self, name):
  129
+
  130
+und lösche die Zeile mit `name = 'Bob'`. Besuche `/` und es sollte "hello to the world" zu sehen sein. Besuche `/Joe` und es sollte "hello to Joe" erscheinen.
  131
+
  132
+Wenn du mehr über web.py templates wissen willst, besuche die [templetor page](/templetor).
  133
+
  134
+## Databasing
  135
+
  136
+**Hinweis:** Bevor du eine Datenbank benutzen kannst, vergewissere dich das du die entsprechenden Datenbank Bibliotheken installiert hast. Für MySql Datenbanken kannst du [MySQLdb](http://sourceforge.net/project/shofiles.php?group_id=22307) verwenden und für Postgres verwende [psycopg2](http://initd.org/pub/software/psycopg/).
  137
+
  138
+Über der `web.run` Zeile füge folgendes hinzu:
  139
+
  140
+    web.config.db_parameters = dict(dbn='postgres', user='username', pw='password', db='dbname')
  141
+
  142
+(Passe die Parameter entsprechend an, vor allem `username`, `password`, und `dbname`. MySQL User sollten `dbn` zu `mysql` ändern.)
  143
+Die Zeile könnte für Sqlite Benutzer in etwa wie folgt aussehen:
  144
+
  145
+	web.config.db_parameters = dict(dbn='sqlite', db='data.db')
  146
+
  147
+Erstelle eine einfache Tabellen in deiner Datenbank:
  148
+
  149
+    CREATE TABLE todo (
  150
+      id serial primary key,
  151
+      title text,
  152
+      created timestamp default now(),
  153
+      done boolean default 'f'    );
  154
+
  155
+Und füge eine Zeile ein:
  156
+
  157
+    INSERT INTO todo (title) VALUES ('Learn web.py');
  158
+
  159
+In `code.py` ändere `index.GET` zu:
  160
+
  161
+    def GET(self):
  162
+        todos = web.select('todo')
  163
+        print render.index(todos)
  164
+
  165
+und ändere den URL-Handler wieder zurück zu `/`.
  166
+
  167
+Ändere `index.html` damit es wie folgt aussieht: 
  168
+
  169
+    $def with (todos)
  170
+    <ul>
  171
+    $for todo in todos:
  172
+        <li id="t$todo.id">$todo.title</li>
  173
+    </ul>
  174
+
  175
+Besuche deine Seite erneut und du wirst dein erstes Todo-Item sehen: "Learn web.py". Gratuliere, du hast ein voll funktionsfähiges Programm, das aus einer Datenbank liest. Nun wollen wir es auch noch in die Datenbank schreiben lassen.
  176
+
  177
+Füge folgendes am Ende von `index.html` hinzu:
  178
+
  179
+    <form method="post" action="add">
  180
+    <p><input type="text" name="title" /> <input type="submit" value="Add" /></p>
  181
+    </form>
  182
+
  183
+Und ändere deine URLs, damit es so aussieht:
  184
+
  185
+    '/', 'index',
  186
+    '/add', 'add'
  187
+
  188
+(Passe mit den Kommas auf. Wenn du sie vergisst, fügt Python die Strings zusammen und sieht `'/index/addadd'`, was nicht das ist, das du haben willst!)
  189
+
  190
+Füge in `code.py` folgende Klasse hinzu: 
  191
+
  192
+    class add:
  193
+        def POST(self):
  194
+            i = web.input()
  195
+            n = web.insert('todo', title=i.title)
  196
+    	    web.seeother('/')
  197
+
  198
+(Bemerkt? Wir benutzen hier `POST`)
  199
+
  200
+`web.input` gibt dir Zugriff auf jede Variable die der User durch ein Formular abgeschickt hat. Wenn du Daten von Items mit dem selben Namen verarbeiten willst (wie in etwa bei einer Serie von Checkboxen mit name="name" benutze:
  201
+
  202
+    post_data=web.input(name=[])
  203
+
  204
+`web.insert` fügt eine Zeile zur Datenbanktabelle `todo` hinzu und gibt die ID der neuen Zeile zurück. `seeother` leitet den User weiter zu dieser URL.
  205
+
  206
+Kurz: `web.transact()` startet eine Transaktion. `web.commit()` übergibt diese. `web.rollback()` macht die Transaktion nichtig. `web.update` funktioniert in etwa so wie `web.insert` außer dass es anstatt eine ID zurückzugeben eine nach dem Tabellennamen benötigt (oder eine `WHERE` Klausel). 
  207
+
  208
+`web.input`, `web.query` und einige andere Funktionen in web.py liefern "Storage objects" zurück, sie funktionieren genau wie Dictionaries, außer das du `d.foo` zusätzlich zu `d['foo']` verwenden kannst. Das macht vieles einfach lesbar.
  209
+
  210
+Du kannst die ganzen Details dazu und allen anderen web.py-Funktionen in der [Dokumentation](http://new.webpy.org/docs) nachlesen.
  211
+
  212
+Das Tutorial endet hier, schau dir die Dokumentation an, um zu sehen was man noch so cooles mit web.py machen kann.

0 notes on commit 329c019

Please sign in to comment.
Something went wrong with that request. Please try again.