Skip to content
Newer
Older
100644 213 lines (120 sloc) 11.5 KB
40016f3 edit
jordi authored
1 ---
2 layout: default
ad45969 edit
ngaa authored
3 title: web.py 0.2 tutorial
40016f3 edit
jordi authored
4 ---
5
ad45969 edit
ngaa authored
6 # web.py 0.2 tutorial
7
329c019 fixed grammar and typos ... at least some of them
cao authored
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.
Something went wrong with that request. Please try again.