Hi all,
I made a french translation of tutorial. I need your help to read and
approve it.
Sometimes i need precisions (Note traducteur : A préciser).
Thanks.
# -----------------------
Starting
[fr]
Intoduction.
[/fr]
# -----------------------
# -----------------------
So you know Python and want to make a website. web.py provides the
code to make that easy.
[fr]
Vous connaissez Python et vous désirez construire un site web. Webpy
vous permettra de le faire facilement.
[/fr]
# -----------------------
# -----------------------
If you want to do the whole tutorial, you'll need to have installed
Python, web.py, flup, psycopg2, and Postgres (or equivalent database
and Python driver). For details, see webpy.org.
[fr]
Si vous décidez de suivre l'ensemble de ce tutorial, vous aurez besoin
d'installer Python, web.py, flup, psycopg2 et Postgres (ou une base de
donnée equivalente et les pilotes python). Pour plus de détails,
veuillez consulter webpy.org.
[/fr]
# -----------------------
# -----------------------
If you have an existing web.py project, take a look at the upgrade
page for info on migrating.
[fr]
Si vous possédez déjà un projet web.py existant, jetez un oeil à la
page de mise à jour pour plus d'informations sur la migration.
[/fr]
# -----------------------
# -----------------------
Let's get started.
[fr]
Commençons.
[/fr]
# -----------------------
# -----------------------
URL Handling
[fr]
Manipuler les URLs
[/fr]
# -----------------------
# -----------------------
The most important part of any website is its URL structure. Your URLs
aren't just the thing that your visitors see and email to their
friends, they also provide a mental model of how your website works.
On popular sites like del.icio.us, the URLs are even part of the user
interface. web.py makes it easy to make great URLs.
[fr]
La partie la plus importante de n'importe quel site web est la
structure des URLs. Les URLs ne sont pas que des liens que vos
visiteurs voient et envoient par mails à leurs amis, elles fournissent
aussi un modèle mental sur la façon avec laquel un site web
fonctionne. Sur des sites populaires tels que del.icio.us, les URLs
font partie même de l'interface utilisateur. Web.py rend la création
d'URLs facile.
[/fr]
# -----------------------
# -----------------------
To get started with your web.py application, open up a new text file
(let's call it code.py) and type:
import web
This imports the web.py module.
[fr]
Pour commencer avec votre application web.py, ouvrez un nouveau
fichier texte (que nous appelerons "code.py") et tapez:
import web
Cela importera le module web.py.
[/fr]
# -----------------------
# -----------------------
Now we need to tell web.py our URL structure. Let's start out with
something simple:
urls = (
'/', 'index'
)
The first part is a regular expressions that matches a URL, like /, /
help/faq, /item/(\d+), etc. (i.e. \d+ would match a sequence of
digits). The parentheses say to capture that piece of the matched data
for use later on. The second part is the name of a class to send the
request to, like index, view, welcomes.hello (which gets the hello
class of the welcomes module), or get_\1. \1 is replaced by the first
capture of your regular expression; any remaining captures get passed
to your function.
[fr]
Maintenant, Nous devons donner à web.py notre structure URL.
Commençons avec quelque chose de simple:
urls = (
'/', 'index'
)
La première partie est une expression régulière que l'on applique à
une chaîne de caractère (l'URL), telle que /, /help/faq, /item/(\d+),
etc.. (Note: \d+ n'admettra qu'une séquence de chiffre). Les
parenthèses signifient qu'il faut capturer la séquence pour s'en
servir plus tard. La seconde partie est le nom d'une Classe vers
laquelle la requête sera envoyée, comme 'index', 'view',
'welcome.hello' (qui recherchera la Classe hello du module welcome.),
ou get_\1.
/1 est remplacé par la première capture de l'expression régulière;
toutes les captures restantes seront passées à votre fonction. (Note
traducteur : A préciser)
[/fr]
# -----------------------
# -----------------------
This line says we want the URL / (i.e. the front page) to be handled
by the class named index.
[fr]
Cette ligne signifie que nous souhaitons l'URL / (Note: la page
d'accueil) qui doit être traitée par la classe nommée 'index'.
[/fr]
# -----------------------
# -----------------------
Now we need to create an application specifying the urls.
app = web.application(urls, globals())
This tells web.py to create an application with the URLs we listed
above, looking up the classes in the global namespace of this file.
[fr]
Maintenant, nous avons besoin de créer une application spécifiant les
URLs.
app = web.application(urls, globals())
Cela explique à web.py qu'il faut créer une application avec les URLs
qui sont listées ci-dessus, en appelant les Classes dans l'espace de
noms global de ce fichier.
[/fr]
# -----------------------
# -----------------------
Now we need to write the index class. While most people don't notice
it just browsing around, your browser uses a language known as HTTP
for communicating with the World Wide Web. The details aren't
important, but the basic idea is that Web visitors ask web servers to
perform certain functions (like GET or POST) on URLs (like / or /foo?
f=1).
[fr]
Maintenant, il est nécessaire d'écrire la Classe 'index'. Alors que la
plupart des gens ne le remarquent pas en naviguant simplement, votre
navigateur utilise un language connu appelé HTTP pour communiquer avec
le World Wide Web. Les détails ne sont pas importants, mais l'idée de
base est que les visiteurs de sites web demandent aux serveurs de
sites web de remplir certaines fonctions (telles que GET ou POST) sur
les URLs (comme / ou /foo?f=1).
[/fr]
# -----------------------
# -----------------------
GET is the one we're all familiar with, the one used to request the
text of a web page. When you type harvard.edu into your web browser,
it literally asks the Harvard web server to GET /. The second-most
famous, POST, is often used when submitting certain kinds of forms,
like a request to purchase something. You use POST whenever the act of
submitting a request does something (like charge your credit card and
process an order). This is key, because GET URLs can be passed around
and indexed by search engines, which you definitely want for most of
your pages but definitely don't want for things like processing orders
(imagine if Google tried to buy everything on your site!).
[fr]
GET est celle que nous connaissons tous, celle qui sert à demander le
texte d'une page web. Lorsque vous tapez 'harvard.edu' dans votre
navigateur, cela demande littéralement au serveur web de Harvard de
fournir /. La seconde fonction très célèbre, POST, est souvent
utilisée lorsque vous utilisez certains types de formulaires, comme
une demande d'achat d'un produit. Vous utilisez POST chaque fois que
vous soumettez une demande (comme le débit de votre carte de crédit et
le traitement d'une commande). Cela est essentiel, parce que GET URLs
peut être transmis et indexé par les moteurs de recherche, que vous
voulez certainement pour la plupart de vos pages, mais ne désirez
certainement pas pour des choses comme le traitement des ordres
(imaginez si Google essaye de tout acheter sur votre site!)
[/fr]
# -----------------------
# -----------------------
In our web.py code, we make the distinction between the two clear:
class index:
def GET(self):
return "Hello, world!"
This GET function will now get called by web.py anytime some makes a
GET request for /.
[fr]
Dans notre code web.py, nous faisons la distinction entre les deux
clairement:
class index:
def GET(self):
return "Hello, world!"
Cette fonction GET sera maintenant appelée par web.py chaque fois
qu'il y aura une requête GET pour /.
[/fr]
# -----------------------
# -----------------------
Alright, now we just need to finish up with a final line telling
web.py to start serving web pages:
if __name__ == "__main__": app.run()
This tells web.py to serve the application we created above.
[fr]
Très bien, maintenant nous avons juste besoin d'en finir avec une
ligne finale disant à web.py de commencer à fournir des pages web:
if __name__ == "__main__": app.run()
Cela explique à web.py qu'il faut lancer l'application que nous avons
créé ci-dessus.
[/fr]
# -----------------------
# -----------------------
Now notice that although I've been talking a lot here, we only really
have five or so lines of code. That's all you need to make a complete
web.py application. If you go to your command line and type:
$ python code.py
http://0.0.0.0:8080/
[fr]
Maintenant notez que, bien que j'ai beaucoup parlé ici, nous avons
seulement cinq ou six lignes de code tout au plus. C'est tout ce dont
nous avons besoin pour créer une application web.py complète. Si vous
allez dans votre terminal et que vous tapez les lignes de commande
suivantes :
$ python code.py
http://0.0.0.0:8080/
[/fr]
# -----------------------
# -----------------------
You now have your web.py application running a real web server on your
computer. Visit that URL and you should see "Hello, world!" (You can
add an IP address/port after the "code.py" bit to control where web.py
launches the server. You can also tell it to run a fastcgi or scgi
server.)
[fr]
Vous avez maintenant votre application web.py qui tourne comme un vrai
serveur web sur votre ordinateur. En visitant cette URL, vous devriez
voir "Hello, world!" dans votre navigateur. (Vous pouvez ajouter une
adresse IP/Port après la partie "code.py" pour contrôler où web.py
lancera le serveur. Vous pouvez aussi lui dire de faire fonctionner un
serveur fastcgi ou scgi.)
[Note traducteur : A PRECISER]
[/fr]
# -----------------------
# -----------------------
Note: You can specify the port number to use on the command line like
this if you can't or don't want to use the default:
$ python code.py 1234
[fr]
Note: Vous pouvez spécifier le numéro de port à utiliser dans la ligne
de commande, si vous ne souhaitez pas utiliser le port par défaut :
$ python code.py 1234
[/fr]
# -----------------------
# -----------------------
Templating
Writing HTML from inside Python can get cumbersome; it's much more fun
to write Python from inside HTML. Luckily, web.py makes that pretty
easy.
Note: Old versions of web.py used Cheetah templates. You are, of
course, welcome to use that or any other software with web.py, but it
is no longer officially supported.
[fr]
Modèles, gabarits
Ecrire du HTML à l'intérieur de python peut être lourd et pesant.
C'est bien plus amusant d'écrire du Python à l'intérieur du HTML. Par
bonheur, web.py le fait très facilement.
Note: Les anciennes versions de web.py utilisent le système de gabarit
de Cheetah. Vous êtes, evidemment, libres d'utiliser celui-ci ou
n'importe quel autre logiciel de template avec web.py, mais il n'est
plus officiellement supporté.
[/fr]
# -----------------------
# -----------------------
Let's make a new directory for our templates (we'll call it
templates). Inside, make a new file whose name ends with HTML (we'll
call it index.html). Now, inside, you can just write normal HTML:
<em>Hello</em>, world!
Or you can use web.py's templating language to add code to your HTML:
$def with (name)
$if name:
I just wanted to say <em>hello</em> to $name.
$else:
<em>Hello</em>, world!
[fr]
Créons un nouveau répertoire pour nos gabarits (nous l'appellerons
templates). A l'intérieur, créons un nouveau fichier dont l'extension
sera HTML (appelons-le index.html). Dans ce fichier, vous pouvez juste
écrire du HTML classique:
<em>Hello</em>, world!
Ou utiliser le langage de template de web.py pour ajouter du code dans
votre HTML:
$def with (name)
$if name:
I just wanted to say <em>hello</em> to $name.
$else:
<em>Hello</em>, world!
[/fr]
# -----------------------
# -----------------------
As you can see, the templates look a lot like Python files except for
the def with statement at the top (saying what the template gets
called with) and the $s placed in front of any code. Currently,
template.py requires the $def statement to be the first line of the
file. Also, note that web.py automatically escapes any variables used
here, so that if for some reason name is set to a value containing
some HTML, it will get properly escaped and appear as plain text. If
you want to turn this off, write $:name instead of $name.
[fr]
Comme vous pouvez le voir, les gabarits ressemblent beaucoup à des
fichiers Python, excepté la déclaration 'def' tout en haut (qui
explique avec quoi le modèle est appelé) ainsi que les $s placés
devant chaque code. Actuellement, template.py exige que la déclaration
$def soit la première ligne du gabarit. Notez également que web.py
encode automatiquement les variables utilisées ici, de sorte que si,
pour une raison un nom est défini dans une valeur contenant du HTML,
il sera proprement encodé et apparaitra comme un texte plein. Si vous
souhaitez désactiver cette fonction, écrivez $:name à la place de
$name.
[/fr]
# -----------------------
# -----------------------
Now go back to code.py. Under the first line, add:
render = web.template.render('templates/')
This tells web.py to look for templates in your templates directory.
Then change index.GET to:
name = 'Bob'
return render.index(name)
('index' is the name of the template and 'name' is the argument passed
to it)
Visit your site and it should say hello to Bob.
[fr]
Maintenant, retournons à notre "code.py". Sous la première ligne
ajoutez:
render = web.template.render('templates/')
Cela indique à web.py qu'il faut rechercher le gabarit dans le
repertoire 'templates'. Maintenant modifiez le contenu de la fonction
GET dans index en:
name = 'Bob'
return render.index(name)
(Ici, 'index' est le nom du gabarit et 'name' est un argument qui lui
est transmis)
Visitez votre site, il devrait vous afficher "I just wanted to say
hello to Bob."
[/fr]
# -----------------------
# -----------------------
But let's say we want to let people enter their own name in. Replace
the two lines we added above with:
i = web.input(name=None)
return render.index(i.name)
Visit / and it should say hello to the world. Visit /?name=Joe and it
should say hello to Joe.
Of course, having that ? in the URL is kind of ugly. Instead, change
your URL line at the top to:
'/(.*)', 'index'
and change the definition of index.GET to:
def GET(self, name):
return render.index(name)
and delete the line setting name. Now visit /Joe and it should say
hello to Joe.
If you wish to learn more about web.py templates, vist the templetor
page.
[fr]
Mais imaginons que nous souhaitions que les gens entrent leur propre
nom. Dans ce cas, remplacez les deux lignes que nous avons ajouté par:
i = web.input(name=None)
return render.index(i.name)
En visitant / il devrait vous afficher "Hello, world!". Mais en
visitant /?name=Joe il vous affichera "I just wanted to say hello to
Joe."
Naturellement, en voyant ceci, on constate que l'URL n'est pas très
claire. Pour l'améliorer, modifiez votre ligne URL en haut en:
'/(.*)', 'index'
Et modifiez la définition de la fonction GET de la classe index en:
def GET(self, name):
return render.index(name)
puis effaçez la ligne qui définit le nom. Maintenant, visitez /joe et
il devrait vous afficher hello to Joe.
Si vous désirez en apprendre davantage sur les gabarits de web.py,
visitez la page 'templator'
[/fr]
# -----------------------
# -----------------------
Databasing
Note: Before you can start using a database, make sure you have the
appropriate database library installed. For MySQL databases, use
MySQLdb and for Postgres use psycopg2.
First you need to create a database object.
db = web.database(dbn='postgres', user='username', pw='password',
db='dbname')
(Adjust these -- especially username, password, and dbname -- for your
setup. MySQL users will also want to change dbn definition to mysql.)
That's all you need to do -- web.py will automatically handle
connecting and disconnecting from the database.
[fr]
Base de données
Note: Avant de pouvoir utiliser une base de données, soyez certains
d'avoir la librairie de la base de données appropriée déjà installée.
Pour la base de donnée MySQL, utilisez MySQLdb et pour Postgres,
utilisez psycopg2.
Premièrement, vous devez créer un objet database.
db = web.database(dbn='postgres', user='username', pw='password',
db='dbname')
(Adaptez ici -- particulièrement pour username, password, and dbname
-- vos paramètres de connection. les utilisateurs de MySQL devront
modifier la définition dbn en 'mysql'.)
C'est tout ce dont vous avez besoin -- web.py gèrera automatiquement
la connection et la déconnection à la base de données.
[/fr]
# -----------------------
# -----------------------
Using your database engine's admin interface, create a simple table in
your database:
CREATE TABLE todo (
id serial primary key,
title text,
created timestamp default now(),
done boolean default 'f' );
And an initial row:
INSERT INTO todo (title) VALUES ('Learn web.py');
[fr]
Utilisez votre interface d'administration de la base de données, et
créez une simple table dans la base de données:
CREATE TABLE todo (
id serial primary key,
title text,
created timestamp default now(),
done boolean default 'f' );
Ainsi qu'une ligne initiale:
INSERT INTO todo (title) VALUES ('Learn web.py');
[/fr]
# -----------------------
# -----------------------
Return to editing code.py and change index.GET to the following,
replacing the entire function:
def GET(self):
todos = db.select('todo')
return render.index(todos)
and change back the URL handler to take just / as in:
'/', 'index',
Edit and replace the entire contents of index.html so that it reads:
$def with (todos)
<ul>
$for todo in todos:
<li id="t$todo.id">$todo.title</li>
</ul>
[fr]
Revenez à "code.py" et modifiez la fonction GET de la Classe index de
la façon suivante en remplaçant la fonction entièrement:
def GET(self):
todos = db.select('todo')
return render.index(todos)
puis remodifiez le gestionnaire d'URLs pour qu'il ne prenne en compte
que /:
'/', 'index'
Editez et remplaçez le contenu entier du gabarit index.html de cette
façon:
$def with (todos)
<ul>
$for todo in todos:
<li id="t$todo.id">$todo.title</li>
</ul>
[/fr]
# -----------------------
# -----------------------
Visit your site again and you should see your one todo item: "Learn
web.py". Congratulations! You've made a full application that reads
from the database. Now let's let it write to the database as well.
At the end of index.html, add:
<form method="post" action="add">
<p><input type="text" name="title" /> <input type="submit"
value="Add" /></p>
</form>
And change your URLs list to read:
'/', 'index',
'/add', 'add'
(You've got to be very careful about those commas. If you omit them,
Python adds the strings together and sees '/index/addadd' instead of
your list of URLs!)
[fr]
En visitant à nouveau votre site, vous devriez voir: "Learn web.py".
Félicitations ! Vous venez de créer une application complète qui lit
une base de données. Maintenant, nous allons écrire dans la base de
données.
A la fin du gabarit index.html, ajoutez:
<form method="post" action="add">
<p><input type="text" name="title" /> <input type="submit"
value="Add" /></p>
</form>
puis modifiez la liste de vos URLs pour qu'elle ressemble à:
'/', 'index',
'/add', 'add'
(Vous devez être très prudents avec les virgules. Si vous en oubliez,
Python joint les chaînes ensembles, et verra '/index/addadd' à la
place de votre liste d'URLs!)
[/fr]
# -----------------------
# -----------------------
Now add another class:
class add:
def POST(self):
i = web.input()
n = db.insert('todo', title=i.title)
raise web.seeother('/')
(Notice how we're using POST for this?)
web.input gives you access to any variables the user submitted through
a form.
[fr]
Maintenant, ajoutons une nouvelle Classe:
class add:
def POST(self):
i = web.input()
n = db.insert('todo', title=i.title)
raise web.seeother('/')
(Avez-vous noté que nous utilisons la fonction POST pour celle-ci?)
web.input vous donne accès à toutes les variables de l'utilisateur
soumises via un formulaire.
[/fr]
# -----------------------
# -----------------------
Note: In order to access data from multiple identically-named items,
in a list format (e.g.: a series of check-boxes all with the attribute
name="name") use:
post_data=web.input(name=[])
db.insert inserts values into the database table todo and gives you
back the ID of the new row. seeother redirects users to that URL.
[fr]
Note: Afin d'accéder aux données à partir de plusieurs éléments
identiquement nommé, dans un format de liste (Une série de cases à
cocher qui ont toutes l'attribut name="name"), utilisez:
post_data=web.input(name=[])
db.insert insère les valeurs dans la table todo de la base de données
et renvoi l'ID des nouvelles entrées. seeother redirige les
utilisateurs vers cette URL.
[/fr]
# -----------------------
# -----------------------
Some quick additional notes: db.update works just like db.insert
except instead of returning the ID it takes it (or a string WHERE
clause) after the table name.
web.input, db.query, and other functions in web.py return "Storage
objects", which are just like dictionaries except you can do d.foo in
addition to d['foo']. This really cleans up some code.
You can find the full details on these and all the web.py functions in
the documentation.
[fr]
Quelques notes additionnelles: db.update fonctionne comme db.insert
excepté qu'au lieu de renvoyer l'ID, il la prend après le nom de la
table.(ou une chaine si clause WHERE) [note TRADUCTEUR: A PRECISER]
web.input, db.query, et d'autres fonctions dans web.py renvoient des
Objets de Stockage (Storage objects), qui sont comme des dictionnaires
mis à part que vous pouvez écrire d.foo en plus de d['foo']. Cela rend
le code plus clair.
Vous pourrez trouver pleins de détails de tout ceci ainsi que de
toutes les fonctions web.py dans la documentation.
[/fr]
# -----------------------
# -----------------------
Developing
web.py also has a few tools to help us with debugging. When running
with the built-in webserver, it starts the application in debug mode.
In debug mode any changes to code and templates are automatically
reloaded and error messages will have more helpful information.
The debug is not enabled when the application is run in a real
webserver. If you want to disable the debug mode, you can do so by
adding the following line before creating your application/templates.
web.config.debug = False
This ends the tutorial for now. Take a look at the documentation for
lots more cool stuff you can do with web.py.
[fr]
Developper
web.py possède aussi des outils de debugging pour nous aider. Quand
nous le faisons tourner avec le server web intégré, il commence
l'application en mode debuggage. Dans ce mode, toutes les
modifications du code et des gabarits sont automatiquement rechargées
et les messages d'erreur contiennent de précieuses informations.
Le debuggage n'est pas actif lorsque l'application tourne comme un
vrai serveur. Si vous souhaitez désactiver ce mode, vous pouvez le
faire en ajoutant la ligne suivante avant de créer votre application/
gabarit.
web.config.debug = False
C'est la fin du tutorial maintenant. Jetez un oeil à la documentation
pour voir ce que vous pouvez utiliser avec web.py.
[/fr]
# -----------------------
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"web.py" group.
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to [email protected]
For more options, visit this group at http://groups.google.com/group/webpy?hl=en
-~----------~----~----~----~------~----~------~--~---
