From 0262e7670d638e98db2e0aee34592612522da980 Mon Sep 17 00:00:00 2001 From: Sinma Date: Sat, 6 Jul 2013 22:37:39 +0200 Subject: [PATCH 01/24] =?UTF-8?q?R=C3=A9organisation=20de=20=C2=ABPrincipe?= =?UTF-8?q?s=20de=20fonctionnement=C2=BB=20et=20simplification=20de=20la?= =?UTF-8?q?=20pr=C3=A9sentation=20des=20commandes?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Dans la partie «Principes de fonctionnement», j’ai placé le texte explicatif avant la description pour les deux derniers points de la liste. J’ai aussi supprimé ce qu’il y avait avant le $ pour les lignes de commandes, ça risque moins de provoquer la confusion (moi-même je n’ai pas compris tout de suite) --- README.md | 27 +++++++++++++-------------- 1 file changed, 13 insertions(+), 14 deletions(-) diff --git a/README.md b/README.md index 3c0992a3..1a22440f 100644 --- a/README.md +++ b/README.md @@ -33,13 +33,14 @@ Les principes sont assez simples : Dans les deux cas, cela revient au même : vous disposez localement d'un dépôt sur lequel vous allez pouvoir travailler. * Travailler sur votre dépôt. - * Versionner vos modifications -> Créer un commit. Une fois satisfait de votre modification ou de votre ajout, vous pouvez versionner vos modifications. En langage Git, on parle de commit. Ce commit crée une nouvelle version du fichier. S'il s'agit d'un nouveau fichier, ce sera la première version. - * Publier vos modifications. - + * Versionner vos modifications → Créer un commit. + Vos commits sont dans votre dépôt local. Vous avez alors la possibilité de les publier vers le dépôt initial ou même vers un autre dépôt. En langage Git, on parle de push. Si vous ne disposez pas des droit de publication sur dépôt distant, vous pouvez aussi proposer vos modifications au responsable du dépôt. En langage Git on parle de pull request. + + * Publier vos modifications. En résumé, vous créez un dépôt local, vous travaillez, vous committez et vous publiez. Facile, non ? @@ -48,7 +49,7 @@ En résumé, vous créez un dépôt local, vous travaillez, vous committez et vo Concrètement, voici ce que ça donne pour ce projet. Commençons pas cloner joyeusement le projet. Dans votre dossier personnel, placez vous à l'endroit où vous souhaitez créer votre dépôt local puis exécutez la commande de clonage ```bash -git clone https://github.com/framasoft/plongez-dans-python3.git +$git clone https://github.com/framasoft/plongez-dans-python3.git ``` Vous devriez obtenir le résultat suivant. Vous remarquerez que cette opération crée automatiquement un dossier dans lequel figurera votre dépôt : @@ -65,7 +66,7 @@ Resolving deltas: 100% (1587/1587), done. Faites une modification. Vous pouvez obtenir à tout moment le statut de votre dépôt : ```bash -Blake:plongez-dans-python3 gcoulais$ git status +$ git status # On branch master # Untracked files: # (use "git add ..." to include in what will be committed) @@ -89,8 +90,8 @@ Ici un fichier README.md a été ajouté mais n'a pas encore été committé. Gi Ajoutons maintenant le fichier au suivi de version et committons. L'opération se déroule donc en deux fois : add puis commit. Un commit est toujours accompagné d'un message expliquant ce que vous avez fait. ```bash -Blake:plongez-dans-python3 gcoulais$ git add README.md -Blake:plongez-dans-python3 gcoulais$ git commit -m "Ajout du README.md" +$ git add README.md +$ git commit -m "Ajout du README.md" [master 2c53431] Ajout du README.md 1 file changed, 80 insertions(+) create mode 100644 README.md @@ -99,7 +100,7 @@ Blake:plongez-dans-python3 gcoulais$ git commit -m "Ajout du README.md" Il ne reste plus qu'à publier la modification sur le dépôt distant : ```bash -Blake:plongez-dans-python3 gcoulais$ git push origin master +$ git push origin master Counting objects: 4, done. Delta compression using up to 4 threads. Compressing objects: 100% (3/3), done. @@ -114,7 +115,7 @@ To https://github.com/framasoft/plongez-dans-python3.git Effectivement, d'autres que vous travaillent sur cette traduction. Il faut donc que vous puissiez récupérer leurs modifications. Encore une fois, c'est un jeu d'enfant. Placez vous simplement dans votre dépôt et magie : ```bash -Blake:plongez-dans-python3 gcoulais$ git pull origin master +$ git pull origin master From https://github.com/framasoft/plongez-dans-python3 * branch master -> FETCH_HEAD Already up-to-date. @@ -123,7 +124,7 @@ Already up-to-date. Ici ce n'est pas très parlant : le dépôt local était déjà à jour. Mais c'est bien là que vous verrez apparaître toutes les modifications de vos petits camarades. Attention, si vous avez des modifications en cours, Git refusera de faire l'opération de pull. Il suffit de mettre de côté vos modifications, de récupérer la dernière version du dépôt distant puis d'y appliquer vos modifications en cours. En langage git, ça donne ça : ```bash -Blake:plongez-dans-python3 gcoulais$ git stash +$ git stash Saved working directory and index state WIP on master: 7583460 README : coloration syntaxique pour les blocs de code HEAD is now at 7583460 README : coloration syntaxique pour les blocs de code ``` @@ -131,13 +132,13 @@ HEAD is now at 7583460 README : coloration syntaxique pour les blocs de code puis ```bash -Blake:plongez-dans-python3 gcoulais$ git pull origin master +$ git pull origin master ``` et enfin ```bash -Blake:plongez-dans-python3 gcoulais$ git stash apply +$ git stash apply # On branch master # Changes not staged for commit: # (use "git add ..." to update what will be committed) @@ -154,5 +155,3 @@ no changes added to commit (use "git add" and/or "git commit -a") TODO: expliquer brièvement les branches. TODO: expliquer brièvement les remote. Pourquoi origin master - - From 35c2a4c061a953e0ced1f69b0ecaabc1dbb224cd Mon Sep 17 00:00:00 2001 From: Sinma Date: Sat, 6 Jul 2013 23:08:02 +0200 Subject: [PATCH 02/24] =?UTF-8?q?Correction=20d=E2=80=99espace=20ins=C3=A9?= =?UTF-8?q?cable=20(mode=20typo=20nazi)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- 00-index.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/00-index.html b/00-index.html index e7bf7b40..96c183ae 100644 --- a/00-index.html +++ b/00-index.html @@ -21,7 +21,7 @@
 
-

Vous êtes ici :  • +

Vous êtes ici : •

Plongez dans Python 3

From dd60bc9fc192fbdc31cc99ca5cba95c2a9d49d94 Mon Sep 17 00:00:00 2001 From: Gilles Coulais Date: Sun, 7 Jul 2013 12:01:15 +0200 Subject: [PATCH 03/24] Ajouts : branches, remotes --- README.md | 94 ++++++++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 87 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index 1a22440f..56f72435 100644 --- a/README.md +++ b/README.md @@ -9,7 +9,9 @@ TODO: expliquer le projet, comment participer, qui contacter, à quelle on mange GIT : petit guide à l'usage du débutant --------------------------------------- -Git est un système de gestion de versions décentralisé [DVCS](https://en.wikipedia.org/wiki/Distributed_revision_control). Voilà pour les gros mots. Passons maintenant à quelque chose de compréhensible pour l'humain courant. +Git est un système de gestion de versions décentralisé [DVCS](https://en.wikipedia.org/wiki/Distributed_revision_control). Voilà pour les gros mots. + +Passons maintenant à quelque chose de compréhensible pour l'humain courant. Ce guide doit vous mettre le pied à l'étrier du projet de traduction de Dive Into Python 3. ### Git : kesako ? @@ -17,7 +19,7 @@ Git permet de gérer des versions de fichiers. Grâce à Git, on sait qui a fait ### Je n'y connais rien. Que fais je ? -Eh bien vous apprenez. Pas de panique : inutile d'avoir fait Polytechnique. La courbe d'apprentissage des commandes de base est très rapide. +Eh bien vous apprenez. Pas de panique : inutile d'avoir fait Polytechnique. La courbe d'apprentissage des commandes de base est très rapide. Vous allez apprendre comment fonctionne Git avec des explications pour être humain et comment utiliser les commandes de base de Git : clone, pull, push, log, commit, branch, status... #### Installation @@ -129,13 +131,13 @@ Saved working directory and index state WIP on master: 7583460 README : colorati HEAD is now at 7583460 README : coloration syntaxique pour les blocs de code ``` -puis +puis : ```bash $ git pull origin master ``` -et enfin +et enfin : ```bash $ git stash apply @@ -151,7 +153,85 @@ no changes added to commit (use "git add" and/or "git commit -a") #### Origin master : c'est quoi cette bouteille de lait ? -#### À propos des branches +Lors des opérations de récupératio (pull) et publication (push), vous avez utilisé des choses inconnues : origin master. Tout d'abord, c'est dangereux d'exécuter une commande sans savoir ce qu'elle fait :) . Bon, ici aucun chaton n'a été tué, l'honneur est sauf. Mais alors qu'est ce que c'est que ce 'origin master' ? + +Votre dépôt local est autonome. Vous pouvez n'utiliser que lui et ne jamais rien publier. Mais si vous souhaitez contribuer à un autre dépôt, il y a un moment où votre votre dépôt local doit connaitre un plusieurs dépôts externes vers lesquels il pourra publier ou desquels il pourra récupérer des mise à jour. En langage Git, cela s'appelle un remote. Un remote est un dépôt distant qui est associé au votre. + +Par ailleurs, votre dépôt local peut être associé à plusieurs remotes. Il faut donc un moyen de différencier ces remotes. Ils sont donc nommés. + +Enfin, un remote contient au moins une branche, il faut donc pouvoir identifier la branche distante avec laquelle vous souhaitez communiquer. Comment ça vous ne savez pas ce qu'est une branche ? Un peu de patience, ça vient. + +Pour en revenir à ce qui nous intéresse, origin est donc un dépôt distant et master une branche dans ce dépôt. La magie, c'est que vous n'avez rien fait pour créer ou nommer ce remote. En fait, Git l'a fait tout seul comme un grand lorsque vous avez cloné le dépôt. Vous pouvez voir les dépôts auxquels vous être abonnés avec une simple commande : + +```bash +$ git remote -v +origin git@github.com:framasoft/plongez-dans-python3.git (fetch) +origin git@github.com:framasoft/plongez-dans-python3.git (push) +no changes added to commit (use "git add" and/or "git commit -a") +``` + +Il y a beaucoup de choses que l'on peut faire avec les remotes. Il y a cependant de grandes chances que cette simple commande vous soit suffisante dans le cadre de ce projet. + +#### Jardinons un peu : les branches + +Pour en terminer avec ce petit voyage au pays de Git, soyons un peu bucoliques. Lorsque vous créez ou clonez un dépôt, Git crée une branche par défaut appelée master. Une branche est une sorte de copie du dépôt (en fait Git ne copie pas vraiment les données, mais nous n'irons pas aussi loin). Vous pouvez alors travailler sur cette copie sans impacter les autres branches : toute ce qui est committé dans cette nouvelle branche n'apparaîtra pas dans les autres. Si au final vous êtes satisfaits de votre travail, il ne vous reste plus qu'à commiter vos modifications dans cette branche puis à les rapatrier dans la branche master. En langage Git, on parle de merge. Mais vous pouvez aussi ne pas être content de ce que vous avez fait et ne pas vouloir conserver ces modifications. Il suffit de les committer puis de supprimer la nouvelle branche. + +Pour connaitre la liste des branches de votre dépôt local : + +```bash +$ git branch +* master +``` + +Pour créer une nouvelle branche : + +```bash +$ git branch maNouvelleBranche +$ git branch + maNouvelleBranche +* master +``` + +L'astérisque vous indique le dépôt sur lequel vous travaillez. Changeons de branche pour travailler sur maNouvelleBranche : + +```bash +$ git checkout maNouvelleBranche +M README.md +Switched to branch 'maNouvelleBranche' +gilles@Arctica:~/Developpement/Python/DiveIntoPython3$ git branch +* maNouvelleBranche + master +``` + +L'astérisque vous montre que vous êtes désormais sur la branche maNouvelleBranche. + +#### Faites le petit chef : lister les commits + +Dans votre activité professionnelle, vous avez sûrement un (petit) chef qui vient vous voir 20 fois par jour en vous disant "Alors, t'en es où ?". Oui, c'est énervant. + +Mais Git est un gars calme et posé qui répondra toujours à vos sollicitations. Alors n'hésitez pas à faire le chef : + +```bash +$ git log +commit 35c2a4c061a953e0ced1f69b0ecaabc1dbb224cd +Author: Sinma +Date: Sat Jul 6 23:08:02 2013 +0200 + + Correction d’espace insécable (mode typo nazi) + +commit 0262e7670d638e98db2e0aee34592612522da980 +Author: Sinma +Date: Sat Jul 6 22:37:39 2013 +0200 + + Réorganisation de «Principes de fonctionnement» et simplification de la présentation des commandes + + Dans la partie «Principes de fonctionnement», j’ai placé le texte explicatif avant la description pour les deux derniers points de la liste. + + J’ai aussi supprimé ce qu’il y avait avant le $ pour les lignes de commandes, ça risque moins de provoquer la confusion (moi-même je n’ai pas comp + +commit f38a3530decc51c6ec72163f9595387409e506af +[...] +``` +Vous pouvez naviguer dans l'historique des commits avec les flèches haut et bas de votre clavier. Quittez avec q. -TODO: expliquer brièvement les branches. -TODO: expliquer brièvement les remote. Pourquoi origin master +Vous avez désormais les armes pour démarrer. Il y a énormément d'autres choses que vous pouvez faire avec Git mais ce n'est pas l'objet de ce tutoriel. Pour savoir comment faire telle ou telle chose, vous pouvez consulter le [Git Book](http://git-scm.com/book/fr/) ou solliciter la [liste de discussion](http://www.framalistes.org/sympa/info/plongez-dans-python-3). From 8310f17516b2e692bdee0773370190cee1b758f7 Mon Sep 17 00:00:00 2001 From: Sinma Date: Thu, 11 Jul 2013 15:31:39 +0200 Subject: [PATCH 04/24] =?UTF-8?q?Ajout=20d=E2=80=99une=20espace=20dans=20l?= =?UTF-8?q?e=20README?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit La correction la plus nulle du monde --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 56f72435..d1da3ab7 100644 --- a/README.md +++ b/README.md @@ -51,7 +51,7 @@ En résumé, vous créez un dépôt local, vous travaillez, vous committez et vo Concrètement, voici ce que ça donne pour ce projet. Commençons pas cloner joyeusement le projet. Dans votre dossier personnel, placez vous à l'endroit où vous souhaitez créer votre dépôt local puis exécutez la commande de clonage ```bash -$git clone https://github.com/framasoft/plongez-dans-python3.git +$ git clone https://github.com/framasoft/plongez-dans-python3.git ``` Vous devriez obtenir le résultat suivant. Vous remarquerez que cette opération crée automatiquement un dossier dans lequel figurera votre dépôt : From 5a0e62d67152b3482a5defa6772b6774b3d2f2e6 Mon Sep 17 00:00:00 2001 From: audionuma Date: Sun, 14 Jul 2013 08:01:15 +0200 Subject: [PATCH 05/24] =?UTF-8?q?D=C3=A9but=20trad=20chapitre=20native=20d?= =?UTF-8?q?atatypes?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- 03-native-datatypes.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/03-native-datatypes.html b/03-native-datatypes.html index 82421bfc..4f113584 100755 --- a/03-native-datatypes.html +++ b/03-native-datatypes.html @@ -1,6 +1,6 @@ --- title: Les types prédéfinis -status: Non traduit +status: En cours permalink: native-datatypes.html --- From c72a032cc624bc81e272a7134d735d263e5ab79d Mon Sep 17 00:00:00 2001 From: Luc Didry Date: Sun, 14 Jul 2013 11:56:08 +0200 Subject: [PATCH 06/24] Update 01-installing-python.html MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Passage à en relecture --- 01-installing-python.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/01-installing-python.html b/01-installing-python.html index 3c6134a4..e2e41fc2 100755 --- a/01-installing-python.html +++ b/01-installing-python.html @@ -1,6 +1,6 @@ --- title: Installer Python -status: Non traduit +status: Relecture permalink: installing-python.html --- From cf5ceecd2ee0cd4fc04fd4a3d66f72dafc13bf2a Mon Sep 17 00:00:00 2001 From: Luc Didry Date: Sun, 14 Jul 2013 12:13:40 +0200 Subject: [PATCH 07/24] Ajout du wokflow dans le README --- README.md | 20 +++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index d1da3ab7..b5d6b71a 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,25 @@ Dive Into Python 3 Projet de traduction fr ----------------------- -TODO: expliquer le projet, comment participer, qui contacter, à quelle on mange, pourquoi les escargots n'ont pas de dents... +TODO: expliquer le projet, à quelle heure on mange, pourquoi les escargots n'ont pas de dents… + +Comment participer ? +-------------------- + +Pour discuter, on a une mailing-list : plongez-dans-python-3@framalistes.org. Inscrivez-vous sur [http://www.framalistes.org/sympa/subscribe/plongez-dans-python-3](http://www.framalistes.org/sympa/subscribe/plongez-dans-python-3). + +Ensuite, il faut nous envoyer un petit mail sur cette liste en nous donnant votre pseudo github, qu'on vous ajoute au groupe qui a les droits sur ce dépôt, histoire de pouvoir bosser. + +La façon de travailler est assez simple, mais il est primordial de s'y tenir, sinon ça va être le gros bazar. +1. Passer le statut à "En cours" dans l'en-tête du fichier que vous allez traduire, dans la branche master. +2. Pousser cette modification (ou la refaire) dans la branche gh-pages. +3. Créer, à partir de la branche master, une nouvelle branche portant le nom du fichier à traduire. +4. Traduire. +5. Passer le statut du fichier à "Relecture" dans la branche du fichier, la branche master et la branche gh-pages +6. Faire une pull-request pour pousser la branche du fichier dans la branche master +7. Relecture par les autres membres de l'équipe, quand ils sont ok pour pousser, ils mettent un :1 dans les commentaires de la pull-request +8. Quand on a 4 ou 5 :1 dans les commentaires, le coordinateur (ldidry) pousse dans master, update le statut à "Publié" dans les branches master et gh-pages. +9. goto 1 GIT : petit guide à l'usage du débutant --------------------------------------- From 5c0a2ebf096d44284da4abb3d7d2058bfcf1da91 Mon Sep 17 00:00:00 2001 From: Luc Didry Date: Sun, 14 Jul 2013 12:15:51 +0200 Subject: [PATCH 08/24] Update README.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Ça m'apprendra à pas faire d'aperçu avant de commiter --- README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index b5d6b71a..7c7a8404 100644 --- a/README.md +++ b/README.md @@ -14,13 +14,14 @@ Pour discuter, on a une mailing-list : plongez-dans-python-3@framalistes.org. In Ensuite, il faut nous envoyer un petit mail sur cette liste en nous donnant votre pseudo github, qu'on vous ajoute au groupe qui a les droits sur ce dépôt, histoire de pouvoir bosser. La façon de travailler est assez simple, mais il est primordial de s'y tenir, sinon ça va être le gros bazar. + 1. Passer le statut à "En cours" dans l'en-tête du fichier que vous allez traduire, dans la branche master. 2. Pousser cette modification (ou la refaire) dans la branche gh-pages. 3. Créer, à partir de la branche master, une nouvelle branche portant le nom du fichier à traduire. 4. Traduire. 5. Passer le statut du fichier à "Relecture" dans la branche du fichier, la branche master et la branche gh-pages 6. Faire une pull-request pour pousser la branche du fichier dans la branche master -7. Relecture par les autres membres de l'équipe, quand ils sont ok pour pousser, ils mettent un :1 dans les commentaires de la pull-request +7. Relecture par les autres membres de l'équipe, quand ils sont ok pour pousser, ils mettent un :1 (émoticône pouce vers le haut de github) dans les commentaires de la pull-request 8. Quand on a 4 ou 5 :1 dans les commentaires, le coordinateur (ldidry) pousse dans master, update le statut à "Publié" dans les branches master et gh-pages. 9. goto 1 From 2a210056b9d8b6684966aa573e4c437f1a8bfaf6 Mon Sep 17 00:00:00 2001 From: Valentin Lorentz Date: Sun, 14 Jul 2013 13:44:08 +0200 Subject: [PATCH 09/24] Marquage du chapitre 2 en 'En cours'. --- 02-your-first-python-program.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/02-your-first-python-program.html b/02-your-first-python-program.html index 1fbe5282..8e0e40a7 100755 --- a/02-your-first-python-program.html +++ b/02-your-first-python-program.html @@ -1,6 +1,6 @@ --- title: Votre premier programme en Python -status: Non traduit +status: En cours permalink: your-first-python-program.html --- From a5d011259f45edd4de4f182ebfc4775aed1d37bd Mon Sep 17 00:00:00 2001 From: Valentin Lorentz Date: Sun, 14 Jul 2013 17:00:45 +0200 Subject: [PATCH 10/24] Debut de la traduction du chapitre 2 (environ un quart). --- 02-your-first-python-program.html | 66 +++++++++++++++---------------- 1 file changed, 33 insertions(+), 33 deletions(-) diff --git a/02-your-first-python-program.html b/02-your-first-python-program.html index 8e0e40a7..d352f2ca 100755 --- a/02-your-first-python-program.html +++ b/02-your-first-python-program.html @@ -19,16 +19,16 @@
  
-

You are here: Home ‣ Dive Into Python 3 ‣ -

Difficulty level: ♦♢♢♢♢ -

Your First Python Program

+

Vous êtes ici : Index • Plongez dans Python 3 ‣ +

Niveau de difficulté : ♦♢♢♢♢ +

Votre premier programme Python

-

❝ Don’t bury your burden in saintly silence. You have a problem? Great. Rejoice, dive in, and investigate. ❞
— Ven. Henepola Gunaratana +

❝ N'enterre pas ton fardeau dans un silence saint. Tu as un problème ? Bien. Réjouis-toi, approfondis, et investigues. ❞
— Ven. Henepola Gunaratana

  -

Diving In

-

Convention dictates that I should bore you with the fundamental building blocks of programming, so we can slowly work up to building something useful. Let’s skip all that. Here is a complete, working Python program. It probably makes absolutely no sense to you. Don’t worry about that, because you’re going to dissect it line by line. But read through it first and see what, if anything, you can make of it. -

[download humansize.py] +

Approfondir

+

Les conventions dictent que je dois vous bassiner avec les briques fondamentales de la programmation, donc nous pouvons lentement travailler à construire quelque chose d'utile. Sautons tout ça. Ceci est un programme Python complet et fonctionnel. Il n'a probablement aucun sens pour vous. Ne vous en faites pas, car je vas le disséquer ligne par ligne. Mais commencez par le lire et voir si vous y comprenez quelque chose. +

[télécharger humansize.py] 

SUFFIXES = {1000: ['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'],
             1024: ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB']}
 
@@ -57,48 +57,48 @@ 
Diving In

 if __name__ == '__main__':
     print(approximate_size(1000000000000, False))
     print(approximate_size(1000000000000))
-

Now let’s run this program on the command line. On Windows, it will look something like this: +

Maintenant, lançons ce programme par la ligne de commandes. Sous Windows, ça ressemblera à quelque chose comme ça : 

 c:\home\diveintopython3\examples> c:\python31\python.exe humansize.py
 1.0 TB
 931.3 GiB
-

On Mac OS X or Linux, it would look something like this: +

Sur Mac OS X ou Linux, ça ressemblera plutôt à ça : 

-you@localhost:~/diveintopython3/examples$ python3 humansize.py
+vous@localhost:~/diveintopython3/examples$ python3 humansize.py
 1.0 TB
 931.3 GiB
-

What just happened? You executed your first Python program. You called the Python interpreter on the command line, and you passed the name of the script you wanted Python to execute. The script defines a single function, the approximate_size() function, which takes an exact file size in bytes and calculates a “pretty” (but approximate) size. (You’ve probably seen this in Windows Explorer, or the Mac OS X Finder, or Nautilus or Dolphin or Thunar on Linux. If you display a folder of documents as a multi-column list, it will display a table with the document icon, the document name, the size, type, last-modified date, and so on. If the folder contains a 1093-byte file named TODO, your file manager won’t display TODO 1093 bytes; it’ll say something like TODO 1 KB instead. That’s what the approximate_size() function does.) +

Qu'est-ce qui vient de se passer ? Vous venez d'exécuter votre premire programme Python. Vous appelez l'interprète Python par la ligne de commandes et vous lui donnez le nom du script Python que vous voulez exécuter. Le script définit une unique fonction, la fonction approximate_size() qui prend une taille de fichier exacte en octets et calcule une taille plus esthétique (mais approximative). (Vous avez probablement déjà vu ça dans l'Explorateur de Windows, le Finder de Mac OS X, ou Nautilus ou Dolphin ou Thunar sous Linux. Si vous avez un répertoire avec des documents dans liste multi-colonnes, il affichera un tableau avec l'icône du document, le nom du document, la taille, le type, la date de dernière modification, etc. Si le fichier contient un fichier de 1093 octets nommé TODO, votre gestionnaire de fichiers n'affichera pas TODO 1093 octets ; mais plutôt quelque chose du genre TODO 1 KO. C'est ce que fait la fonction approximate_size().) -

Look at the bottom of the script, and you’ll see two calls to print(approximate_size(arguments)). These are function calls — first calling the approximate_size() function and passing a number of arguments, then taking the return value and passing it straight on to the print() function. The print() function is built-in; you’ll never see an explicit declaration of it. You can just use it, anytime, anywhere. (There are lots of built-in functions, and lots more functions that are separated into modules. Patience, grasshopper.) +

Regardez à la fin du script et vous verrez deux appels à print(approximate_size(arguments)). Ce sont des appels de fonctions  — le ppremier appelle la fonction approximate_size() et lui passe des arguments (aussi appelés paramètres), puis prend la valeur de retour et la passe directement à la fonction print(). La fonction print() est fournie par Python ; vous ne verrez jamais de déclaration explicite de celle-ci. Vous pouvez l'utiliser n'importe où, n'importe quand. (Il y a beaucoup de fonctions fournies par Python, et beaucoup d'entre elles sont séparées dans des modules modules. Patience, jeune padawan.) -

So why does running the script on the command line give you the same output every time? We’ll get to that. First, let’s look at that approximate_size() function. +

Donc, pourquoi exécuter ce script dans la ligne de commande vous donne le même résultat à chaque fois ? Nous y arriverons. Jetons d'abord un coup d'œil à la fonction approximate_size().

⁂ -

Declaring Functions

-

Python has functions like most other languages, but it does not have separate header files like C++ or interface/implementation sections like Pascal. When you need a function, just declare it, like this: +

Déclarer des Fonctions

+

Python a des fonctions comme la plupart des autres langages, mais n'a pas de fichiers d'en-têtes séparés comme le C++ ou des sections interface/implémentation comme le Pascal. Lorsque vous avez besoin d'une fonction, déclarez-la simplement, comme ceci : 

def approximate_size(size, a_kilobyte_is_1024_bytes=True):
- -

The keyword def starts the function declaration, followed by the function name, followed by the arguments in parentheses. Multiple arguments are separated with commas. -

Also note that the function doesn’t define a return datatype. Python functions do not specify the datatype of their return value; they don’t even specify whether or not they return a value. (In fact, every Python function returns a value; if the function ever executes a return statement, it will return that value, otherwise it will return None, the Python null value.) +

+

Le mot-clef def commence une déclaration de fonction, suivi par le nom de la fonction, suivi par les paramètres entre parenthèses. Plusieurs paramètres peuvent être séparés par des virgules. +

Notez qu'une fonction ne définit pas de type de retour. Les fonctions Python ne spécifient pas le type de leur valeur de retour ; elles ne spécifient même si si elles retournent ou non une valeur. (En fait, toute fonction Python retourne une valeur ; si la fonction exécute une instruction return, elle retournera cette valeur, sinon elle retournera None, la valeure nulle de Python.)

-

☞In some languages, functions (that return a value) start with function, and subroutines (that do not return a value) start with sub. There are no subroutines in Python. Everything is a function, all functions return a value (even if it’s None), and all functions start with def. +

☞Dans certains langages, les fonctions (qui retournent une valeur) commencent par function, et les sous-routines (qui n'en retournent pas) commencent par sub. Il n'y a pas de sous-routine en Python. Tout est fonction, toutes les fonctions retournent des valeurs (même si c'est None), et toutes les fonctions commencent par def.

-

The approximate_size() function takes the two arguments — size and a_kilobyte_is_1024_bytes — but neither argument specifies a datatype. In Python, variables are never explicitly typed. Python figures out what type a variable is and keeps track of it internally. +

La fonction approximate_size() prend deux paramètres — size et a_kilobyte_is_1024_bytes — mais aucun des deux ne spécifie un type. En Python, les variables ne sont jamais spécifiquement typées. Python devine quel est le type d'une variable et le garde en mémoire en interne.

-

☞In Java and other statically-typed languages, you must specify the datatype of the function return value and each function argument. In Python, you never explicitly specify the datatype of anything. Based on what value you assign, Python keeps track of the datatype internally. +

☞en Java et dans les autres langages typés statiquement, vous devez spécifier le type de retour de la fonction, et le type de chacun des paramètres de la fonction. En Python vous n'avez jamais besoin de spécifier explicitement le type de quoi que ce soit. En fonction de la valeur que vous assignez, Python garde l'information sur le type de données en interne.

-

Optional and Named Arguments

+

Paramètres Optionels et Nommés

-

Python allows function arguments to have default values; if the function is called without the argument, the argument gets its default value. Furthermore, arguments can be specified in any order by using named arguments. +

Python autorise les paramètres de fonctions à avoir des valeurs par défaut ; si une fonction est appelée sans paramètre, l'paramètre prend sa valeur par défaut. De plus, les paramètres peuvent être spécifiés dans n'importe quel ordre en utilisant les paramètres nommés. -

Let’s take another look at that approximate_size() function declaration: +

Regardons à nouveau la déclaration de la fonction approximate_size() : 

def approximate_size(size, a_kilobyte_is_1024_bytes=True):
-

The second argument, a_kilobyte_is_1024_bytes, specifies a default value of True. This means the argument is optional; you can call the function without it, and Python will act as if you had called it with True as a second parameter. +

Le second paramètre, a_kilobyte_is_1024_bytes, spécifie une valeur par défaut qui est True. Cela signifie que le paramètre est optional ; vous pouvez appeler la fonction sans celui-ci, et PYthon fera comme si vous aviez appelé la fonction avec True comme second paramètre.

Now look at the bottom of the script: @@ -106,11 +106,11 @@

Optional and Named Arguments

print(approximate_size(1000000000000, False)) ① print(approximate_size(1000000000000)) ②
    -
  1. This calls the approximate_size() function with two arguments. Within the approximate_size() function, a_kilobyte_is_1024_bytes will be False, since you explicitly passed False as the second argument. -
  2. This calls the approximate_size() function with only one argument. But that’s OK, because the second argument is optional! Since the caller doesn’t specify, the second argument defaults to True, as defined by the function declaration. +
  3. Ceci appelle la fonction approximate_size() avec deux paramètres. Dans la fonction approximate_size(), a_kilobyte_is_1024_bytes sera False, puisque vous avez passé explicitement False comme second paramètre. +
  4. Ceci appelle la fonction approximate_size() avec un seul paramètre. Mais c'est correct, car le second paramètre est optionnel ! Puisque l'appel ne le spécifie pas, le second argument prend par défaut la valeur True, comme défini dans la déclaration de la fonction.
-

You can also pass values into a function by name. +

Vous pouvez également passer des valeurs à une fonction par leur nom. 

 >>> from humansize import approximate_size
@@ -127,11 +127,11 @@ 
Optional and Named Arguments

   File "<stdin>", line 1
 SyntaxError: non-keyword arg after keyword arg
    -
  1. This calls the approximate_size() function with 4000 for the first argument (size) and False for the argument named a_kilobyte_is_1024_bytes. (That happens to be the second argument, but doesn’t matter, as you’ll see in a minute.) -
  2. This calls the approximate_size() function with 4000 for the argument named size and False for the argument named a_kilobyte_is_1024_bytes. (These named arguments happen to be in the same order as the arguments are listed in the function declaration, but that doesn’t matter either.) -
  3. This calls the approximate_size() function with False for the argument named a_kilobyte_is_1024_bytes and 4000 for the argument named size. (See? I told you the order didn’t matter.) -
  4. This call fails, because you have a named argument followed by an unnamed (positional) argument, and that never works. Reading the argument list from left to right, once you have a single named argument, the rest of the arguments must also be named. -
  5. This call fails too, for the same reason as the previous call. Is that surprising? After all, you passed 4000 for the argument named size, then “obviously” that False value was meant for the a_kilobyte_is_1024_bytes argument. But Python doesn’t work that way. As soon as you have a named argument, all arguments to the right of that need to be named arguments, too. +
  6. Ceci appelle la fonction la fonction approximate_size() avec 4000 comme premier paramètre (size) et False pour le paramètre nommé a_kilobyte_is_1024_bytes. (Il s'avère qu'il s'agit du second paramètre, mais ça n'a pas d'importance, comme vous allez le voir dans une minute.) +
  7. Ceci appelle la fonction approximate_size() avec 4000 pour le paramètre nommé size et False pour l'argument nommé a_kilobyte_is_1024_bytes. (Il s'avère que ces arguments sont dans le même ordre que ceux listés dans la déclaration de la fonction, mais ça n'a pas d'importance non plus.) +
  8. Ceci appelle la fonction approximate_size() avec False pour le paramètre nommé a_kilobyte_is_1024_bytes et 4000 pour l'argument nommé size. (Vous voyez ? Je vous avez dit que l'ordre n'avait pas d'importance.) +
  9. Si cet appel échoue c'est parce que vous avez un paramètre nommé suivi d'un paramètre non nommé (positionel), et ça ne marche jamais. Lisez la liste d'argument de gauche à droite, une fois que vous avez un paramètre nommé, tous ceux qui suivent doivent aussi être nommés. +
  10. Cet appel échoue également, pour la même raison que le précédent. Est-ce surprenant ? Après tout, nous avons passé 4000 à l'argument nommé size, donc évidemment, False était destiné au paramètre a_kilobyte_is_1024_bytes. Mais Python ne fonctionne pas de cette façon. Dès que vous avez un paramètre nommé, tous les paramètres à la droite de celui-ci doivent aussi être nommés.

⁂ From 34eb4f301edd0ce99d8f5d20141f5791268b040a Mon Sep 17 00:00:00 2001 From: Valentin Lorentz Date: Sun, 14 Jul 2013 23:03:12 +0200 Subject: [PATCH 11/24] =?UTF-8?q?Poursuite=20de=20la=20traduction=20du=20c?= =?UTF-8?q?hapitre=202=20(environ=20la=20moiti=C3=A9).?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- 02-your-first-python-program.html | 56 +++++++++++++++---------------- 1 file changed, 28 insertions(+), 28 deletions(-) diff --git a/02-your-first-python-program.html b/02-your-first-python-program.html index d352f2ca..0a2861ff 100755 --- a/02-your-first-python-program.html +++ b/02-your-first-python-program.html @@ -33,14 +33,14 @@

Approfondir

1024: ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB']} def approximate_size(size, a_kilobyte_is_1024_bytes=True): - '''Convert a file size to human-readable form. + '''Convertit une taille de fichier en une forme lisible par un humain. - Keyword arguments: - size -- file size in bytes - a_kilobyte_is_1024_bytes -- if True (default), use multiples of 1024 - if False, use multiples of 1000 + Paramètres par mot-clef : + size -- taille de fichiers en octets + a_kilobyte_is_1024_bytes -- si True (par défaut), utilise des multiples de 1024 + si False, utilise des multiples de 1000 - Returns: string + Retourne : une chaine de caractères ''' if size < 0: @@ -136,34 +136,34 @@

Paramètres Optionels et Nommés

⁂ -

Writing Readable Code

-

I won’t bore you with a long finger-wagging speech about the importance of documenting your code. Just know that code is written once but read many times, and the most important audience for your code is yourself, six months after writing it (i.e. after you’ve forgotten everything but need to fix something). Python makes it easy to write readable code, so take advantage of it. You’ll thank me in six months. -

Documentation Strings

-

You can document a Python function by giving it a documentation string (docstring for short). In this program, the approximate_size() function has a docstring: +

Écrire du Code Lisible

+

Je ne vais pas vous ennuyer avec un long discours menaçant à propos de documenter son code. Sachez simplement que du code est écrit une fois, mais lu souvent, et l'audience la plus importante de votre code est vous-même, six mois après l'avoir écrit (c'est-à-dire après que vous ayiez tout oublié mais que devez corriger quelque chose). Python rend facile l'écriture de code lisible, tirez-en donc avantage. Vous me remercierez dans six mois. +

Chaînes de Documentation

+

Vous pouvez documenter une fonction Python en lui donnant une chaine de documentation (« documentation string » en anglais, abrégé en docstring). Dans ce programme, la fonction approximate_size() a docstring une : 

def approximate_size(size, a_kilobyte_is_1024_bytes=True):
-    '''Convert a file size to human-readable form.
+    '''Convertit une taille de fichier en une forme lisible par un humain.
 
-    Keyword arguments:
-    size -- file size in bytes
-    a_kilobyte_is_1024_bytes -- if True (default), use multiples of 1024
-                                if False, use multiples of 1000
+    Paramètres par mot-clef :
+    size -- taille de fichiers en octets
+    a_kilobyte_is_1024_bytes -- si True (par défaut), utilise des multiples de 1024
+                                si False, utilise des multiples de 1000
 
-    Returns: string
+    Retourne : une chaine de caractères
 
     '''
- -

Triple quotes signify a multi-line string. Everything between the start and end quotes is part of a single string, including carriage returns, leading white space, and other quote characters. You can use them anywhere, but you’ll see them most often used when defining a docstring. +

+

Les triple apostrophes signifient qu'il s'agit d'une chaine multiligne. Tout ce qui est entre les apostrophes de début et de fin fait partie de la même chaine, y compris les retour chariot, les espaces de début de ligne, et les autres caractères de citation. Vous pouvez les utiliser n'importe où, mais vous les verrez le plus fréquemment lors de la définition d'une docstring.

-

☞Triple quotes are also an easy way to define a string with both single and double quotes, like qq/.../ in Perl 5. +

☞Les triples apostrophes sont aussi une façon simple de définir une chaine contenant à la fois des apostrophes et des guillemets, comme qq/.../ dans Perl 5.

-

Everything between the triple quotes is the function’s docstring, which documents what the function does. A docstring, if it exists, must be the first thing defined in a function (that is, on the next line after the function declaration). You don’t technically need to give your function a docstring, but you always should. I know you’ve heard this in every programming class you’ve ever taken, but Python gives you an added incentive: the docstring is available at runtime as an attribute of the function. +

Tout ce qui est entre les triples apostrophes est la docstring de la fonction, qui documente ce que fait la fonction. Une docstring, si elle existe, doit être la première chose définie dans la fonction (c'est-à-dire la ligne suivant immédiatement la déclaration de la fonction). Vous n'avez pas techniquement besoin de donner une docstring votre fonction, mais vous devriez toujours. Je sais que vous avez déjà entendu cela dans tous les cours de programmation que vous avez eu, mais Python vous y incite encore plus : la docstring est disponible à tout moment de l'exécution en tant qu'attribut de la fonction.

-

☞Many Python IDEs use the docstring to provide context-sensitive documentation, so that when you type a function name, its docstring appears as a tooltip. This can be incredibly helpful, but it’s only as good as the docstrings you write. +

☞Beaucoup d'IDEs Python utilisent la docstring pour fournir de la documentation contextuelle, de telle façon que lorsque vous tapez le nom d'une fonction, sa docstring apparait dans une infobulle. Ça peut être incroyablement utile, mais sa qualité dépend de la qualité des docstrings que vous écrivez.

⁂ -

The import Search Path

-

Before this goes any further, I want to briefly mention the library search path. Python looks in several places when you try to import a module. Specifically, it looks in all the directories defined in sys.path. This is just a list, and you can easily view it or modify it with standard list methods. (You’ll learn more about lists in Native Datatypes.) +

Le Chemin de Recherche de import

+

Avant d'aller plus loin, je voudrais mentionner brièvement le chemin de recherche de bibliothèques. Python cherche à plusieurs endroits lorsque vous essayez d'importer un module. Plus spécifiquement, il regarde dans tous les dossiers définis dans sys.path. Il s'agit uniquement d'une liste, et vous pouvez facilement la voir ou la modifier avec les méthodes de liste standards (Vous en sourez plus sur les listes dans Les Types Prédéfinis.) 

 >>> import sys                                                 ①
 >>> sys.path                                                   ②
@@ -187,11 +187,11 @@ 
The import Search Path

  '/usr/lib/python3.1/dist-packages', 
  '/usr/local/lib/python3.1/dist-packages']
    -
  1. Importing the sys module makes all of its functions and attributes available. -
  2. sys.path is a list of directory names that constitute the current search path. (Yours will look different, depending on your operating system, what version of Python you’re running, and where it was originally installed.) Python will look through these directories (in this order) for a .py file whose name matches what you’re trying to import. -
  3. Actually, I lied; the truth is more complicated than that, because not all modules are stored as .py files. Some are built-in modules; they are actually baked right into Python itself. Built-in modules behave just like regular modules, but their Python source code is not available, because they are not written in Python! (Like Python itself, these built-in modules are written in C.) -
  4. You can add a new directory to Python’s search path at runtime by adding the directory name to sys.path, and then Python will look in that directory as well, whenever you try to import a module. The effect lasts as long as Python is running. -
  5. By using sys.path.insert(0, new_path), you inserted a new directory as the first item of the sys.path list, and therefore at the beginning of Python’s search path. This is almost always what you want. In case of naming conflicts (for example, if Python ships with version 2 of a particular library but you want to use version 3), this ensures that your modules will be found and used instead of the modules that came with Python. +
  6. Importer le module sys rend disponible toutes ses fonctions et attributs. +
  7. sys.path est une liste de noms de dossiers qui constitue le chemin de recherche actuel. (Le votre ressemblera à autre chose, en fonction de votre système d'exploitation, la version de Python que vous utilisez, et où il a été installé à l'origine.). Python recherchera dans ces dossiers (et dans cet ordre) un fichier .py dont le nom correspond à celui que vous essayez d'importer. +
  8. En fait, j'ai menti ; la vérité est bien plus compliquée que cela, car tous les modules ne sont pas stockés dans des fichiers .py. Certains sont des Actually, I lied; the truth is more complicated than that, because not all modules are stored as .py files. Certains sont des modules natifs ; ils font en effet partie de Python lui-même. Les modules natifs se comportent comme des modules classiques, mais leur code Python n'est pas disponible, car ils ne sont pas écrits en Python ! (Comme Python lui-même, ces modules natifs sont écrits en C.) +
  9. Vous pouvez ajouter un nouveau dossier au chemin de recherche de Python en ajoutant le nom de celui-ci à sys.path, et alors Python regardera aussi dans ce dossier quand vous essayez d'importer un module. Et ce tant que Python est en cours d'exécution. +
  10. En utilisant sys.path.insert(0, new_path), vous ajoutez un nouveau dossier comme premier élément de la liste sys.path, et donc au début du chemin de recherche de Python. C'est presque toujours ce que vous voulez. Dans le cas de conflits de noms (par exemple si Python est distribué avec la version 2 d'une bibliothèque donnée mais que vous voulez utiliser la version 3), cela permet de s'assurer que vous modules seront trouvés et utilisés à la place de ceux qui sont distribués avec Python.

⁂ From a5efcd8637928faa129980c32fa022a3d6f38c4e Mon Sep 17 00:00:00 2001 From: Gatien Bovyn Date: Mon, 15 Jul 2013 11:23:08 +0200 Subject: [PATCH 12/24] Corrections orthographiques --- 02-your-first-python-program.html | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/02-your-first-python-program.html b/02-your-first-python-program.html index 0a2861ff..c2acbf23 100755 --- a/02-your-first-python-program.html +++ b/02-your-first-python-program.html @@ -19,15 +19,15 @@

  
-

Vous êtes ici : Index • Plongez dans Python 3 ‣ -

Niveau de difficulté : ♦♢♢♢♢ +

Vous êtes ici : Index • Plongez dans Python 3 ‣ +

Niveau de difficulté : ♦♢♢♢♢

Votre premier programme Python

-

❝ N'enterre pas ton fardeau dans un silence saint. Tu as un problème ? Bien. Réjouis-toi, approfondis, et investigues. ❞
— Ven. Henepola Gunaratana +

❝ N’enterre pas ton fardeau dans un silence saint. Tu as un problème ? Bien. Réjouis-toi, approfondis, et investigue. ❞
— Ven. Henepola Gunaratana

 

Approfondir

-

Les conventions dictent que je dois vous bassiner avec les briques fondamentales de la programmation, donc nous pouvons lentement travailler à construire quelque chose d'utile. Sautons tout ça. Ceci est un programme Python complet et fonctionnel. Il n'a probablement aucun sens pour vous. Ne vous en faites pas, car je vas le disséquer ligne par ligne. Mais commencez par le lire et voir si vous y comprenez quelque chose. +

Les conventions dictent que je dois vous bassiner avec les briques fondamentales de la programmation, donc nous pouvons lentement travailler à construire quelque chose d’utile. Sautons tout ça. Ceci est un programme Python complet et fonctionnel. Il n’a probablement aucun sens pour vous. Ne vous en faites pas, car je vais le disséquer ligne par ligne. Mais commencez par le lire et voir si vous y comprenez quelque chose.

[télécharger humansize.py] 

SUFFIXES = {1000: ['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'],
             1024: ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB']}
@@ -40,7 +40,7 @@ 
Approfondir

     a_kilobyte_is_1024_bytes -- si True (par défaut), utilise des multiples de 1024
                                 si False, utilise des multiples de 1000
 
-    Retourne : une chaine de caractères
+    Retourne : une chaîne de caractères
 
     '''
     if size < 0:
@@ -57,7 +57,7 @@ 
Approfondir

 if __name__ == '__main__':
     print(approximate_size(1000000000000, False))
     print(approximate_size(1000000000000))
-

Maintenant, lançons ce programme par la ligne de commandes. Sous Windows, ça ressemblera à quelque chose comme ça : +

Maintenant, lançons ce programme par la ligne de commande. Sous Windows, ça ressemblera à quelque chose comme ça : 

 c:\home\diveintopython3\examples> c:\python31\python.exe humansize.py
 1.0 TB
@@ -68,7 +68,7 @@ 
Approfondir

 1.0 TB
 931.3 GiB
-

Qu'est-ce qui vient de se passer ? Vous venez d'exécuter votre premire programme Python. Vous appelez l'interprète Python par la ligne de commandes et vous lui donnez le nom du script Python que vous voulez exécuter. Le script définit une unique fonction, la fonction approximate_size() qui prend une taille de fichier exacte en octets et calcule une taille plus esthétique (mais approximative). (Vous avez probablement déjà vu ça dans l'Explorateur de Windows, le Finder de Mac OS X, ou Nautilus ou Dolphin ou Thunar sous Linux. Si vous avez un répertoire avec des documents dans liste multi-colonnes, il affichera un tableau avec l'icône du document, le nom du document, la taille, le type, la date de dernière modification, etc. Si le fichier contient un fichier de 1093 octets nommé TODO, votre gestionnaire de fichiers n'affichera pas TODO 1093 octets ; mais plutôt quelque chose du genre TODO 1 KO. C'est ce que fait la fonction approximate_size().) +

Qu'est-ce qui vient de se passer ? Vous venez d'exécuter votre premier programme Python. Vous appelez l'interpréteur Python par la ligne de commandes et vous lui donnez le nom du script Python que vous voulez exécuter. Le script définit une unique fonction, la fonction approximate_size() qui prend une taille de fichier exacte en octets et calcule une taille plus esthétique (mais approximative). (Vous avez probablement déjà vu ça dans l'Explorateur de Windows, le Finder de Mac OS X, ou Nautilus ou Dolphin ou Thunar sous Linux. Si vous avez un répertoire avec des documents dans liste multi-colonnes, il affichera un tableau avec l'icône du document, le nom du document, la taille, le type, la date de dernière modification, etc. Si le fichier contient un fichier de 1093 octets nommé TODO, votre gestionnaire de fichiers n'affichera pas TODO 1093 octets ; mais plutôt quelque chose du genre TODO 1 KO. C'est ce que fait la fonction approximate_size().)

Regardez à la fin du script et vous verrez deux appels à print(approximate_size(arguments)). Ce sont des appels de fonctions  — le ppremier appelle la fonction approximate_size() et lui passe des arguments (aussi appelés paramètres), puis prend la valeur de retour et la passe directement à la fonction print(). La fonction print() est fournie par Python ; vous ne verrez jamais de déclaration explicite de celle-ci. Vous pouvez l'utiliser n'importe où, n'importe quand. (Il y a beaucoup de fonctions fournies par Python, et beaucoup d'entre elles sont séparées dans des modules modules. Patience, jeune padawan.) From 5369065a0005b983beeb159e55473b2b17883e6d Mon Sep 17 00:00:00 2001 From: Gatien Bovyn Date: Mon, 15 Jul 2013 11:33:32 +0200 Subject: [PATCH 13/24] Corrections orthographiques --- 02-your-first-python-program.html | 38 +++++++++++++++---------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/02-your-first-python-program.html b/02-your-first-python-program.html index c2acbf23..f99c7359 100755 --- a/02-your-first-python-program.html +++ b/02-your-first-python-program.html @@ -62,52 +62,52 @@

Approfondir

c:\home\diveintopython3\examples> c:\python31\python.exe humansize.py 1.0 TB 931.3 GiB -

Sur Mac OS X ou Linux, ça ressemblera plutôt à ça : +

Sur Mac OS X ou Linux, ça ressemblera plutôt à ça : 

 vous@localhost:~/diveintopython3/examples$ python3 humansize.py
 1.0 TB
 931.3 GiB
-

Qu'est-ce qui vient de se passer ? Vous venez d'exécuter votre premier programme Python. Vous appelez l'interpréteur Python par la ligne de commandes et vous lui donnez le nom du script Python que vous voulez exécuter. Le script définit une unique fonction, la fonction approximate_size() qui prend une taille de fichier exacte en octets et calcule une taille plus esthétique (mais approximative). (Vous avez probablement déjà vu ça dans l'Explorateur de Windows, le Finder de Mac OS X, ou Nautilus ou Dolphin ou Thunar sous Linux. Si vous avez un répertoire avec des documents dans liste multi-colonnes, il affichera un tableau avec l'icône du document, le nom du document, la taille, le type, la date de dernière modification, etc. Si le fichier contient un fichier de 1093 octets nommé TODO, votre gestionnaire de fichiers n'affichera pas TODO 1093 octets ; mais plutôt quelque chose du genre TODO 1 KO. C'est ce que fait la fonction approximate_size().) +

Qu’est-ce qui vient de se passer ? Vous venez d’exécuter votre premier programme Python. Vous appelez l'interpréteur Python par la ligne de commande et vous lui donnez le nom du script Python que vous voulez exécuter. Le script définit une unique fonction, la fonction approximate_size() qui prend une taille de fichier exacte en octets et calcule une taille plus esthétique (mais approximative). Vous avez probablement déjà vu ça dans l’Explorateur de Windows, le Finder de Mac OS X, ou Nautilus ou Dolphin ou Thunar sous Linux. Si vous avez un répertoire avec des documents dans une liste multi-colonnes, il affichera un tableau avec l'icône du document, le nom du document, la taille, le type, la date de dernière modification, etc. Si le fichier contient un fichier de 1093 octets nommé TODO, votre gestionnaire de fichiers n’affichera pas TODO 1093 octets, mais plutôt quelque chose du genre TODO 1 KO. C’est ce que fait la fonction approximate_size(). -

Regardez à la fin du script et vous verrez deux appels à print(approximate_size(arguments)). Ce sont des appels de fonctions  — le ppremier appelle la fonction approximate_size() et lui passe des arguments (aussi appelés paramètres), puis prend la valeur de retour et la passe directement à la fonction print(). La fonction print() est fournie par Python ; vous ne verrez jamais de déclaration explicite de celle-ci. Vous pouvez l'utiliser n'importe où, n'importe quand. (Il y a beaucoup de fonctions fournies par Python, et beaucoup d'entre elles sont séparées dans des modules modules. Patience, jeune padawan.) +

Regardez à la fin du script et vous verrez deux appels à print(approximate_size(arguments)). Ce sont des appels de fonctions  — le premier appelle la fonction approximate_size() et lui passe des arguments (aussi appelés paramètres), puis prend la valeur de retour et la passe directement à la fonction print(). La fonction print() est fournie par Python : vous ne verrez jamais de déclaration explicite de celle-ci. Vous pouvez l’utiliser n’importe où, n’importe quand. (Il y a beaucoup de fonctions fournies par Python, et beaucoup d’entre elles sont séparées dans des modules modules. Patience, jeune padawan.) -

Donc, pourquoi exécuter ce script dans la ligne de commande vous donne le même résultat à chaque fois ? Nous y arriverons. Jetons d'abord un coup d'œil à la fonction approximate_size(). +

Donc, pourquoi exécuter ce script dans la ligne de commande vous donne le même résultat à chaque fois ? Nous y arriverons. Jetons d’abord un coup d’œil à la fonction approximate_size().

⁂

Déclarer des Fonctions

-

Python a des fonctions comme la plupart des autres langages, mais n'a pas de fichiers d'en-têtes séparés comme le C++ ou des sections interface/implémentation comme le Pascal. Lorsque vous avez besoin d'une fonction, déclarez-la simplement, comme ceci : +

Python a des fonctions comme la plupart des autres langages, mais n’a pas de fichiers d’en-têtes séparés comme le C++ ou des sections interface/implémentation comme le Pascal. Lorsque vous avez besoin d’une fonction, déclarez-la simplement, comme ceci : 

def approximate_size(size, a_kilobyte_is_1024_bytes=True):
- +

Le mot-clef def commence une déclaration de fonction, suivi par le nom de la fonction, suivi par les paramètres entre parenthèses. Plusieurs paramètres peuvent être séparés par des virgules. -

Notez qu'une fonction ne définit pas de type de retour. Les fonctions Python ne spécifient pas le type de leur valeur de retour ; elles ne spécifient même si si elles retournent ou non une valeur. (En fait, toute fonction Python retourne une valeur ; si la fonction exécute une instruction return, elle retournera cette valeur, sinon elle retournera None, la valeure nulle de Python.) +

Notez qu’une fonction ne définit pas de type de retour. Les fonctions Python ne spécifient pas le type de leur valeur de retour : elles ne spécifient même pas si elles retournent ou non une valeur. (En fait, toute fonction Python retourne une valeur : si la fonction exécute une instruction return, elle retournera cette valeur, sinon elle retournera None, la valeure nulle de Python.)

-

☞Dans certains langages, les fonctions (qui retournent une valeur) commencent par function, et les sous-routines (qui n'en retournent pas) commencent par sub. Il n'y a pas de sous-routine en Python. Tout est fonction, toutes les fonctions retournent des valeurs (même si c'est None), et toutes les fonctions commencent par def. +

☞Dans certains langages, les fonctions (qui retournent une valeur) commencent par function, et les sous-routines (qui n’en retournent pas) commencent par sub. Il n’y a pas de sous-routine en Python. Tout est fonction, toutes les fonctions retournent des valeurs (même si c’est None), et toutes les fonctions commencent par def.

-

La fonction approximate_size() prend deux paramètres — size et a_kilobyte_is_1024_bytes — mais aucun des deux ne spécifie un type. En Python, les variables ne sont jamais spécifiquement typées. Python devine quel est le type d'une variable et le garde en mémoire en interne. +

La fonction approximate_size() prend deux paramètres — size et a_kilobyte_is_1024_bytes — mais aucun des deux ne spécifie un type. En Python, les variables ne sont jamais spécifiquement typées. Python devine quel est le type d’une variable et le garde en mémoire en interne.

-

☞en Java et dans les autres langages typés statiquement, vous devez spécifier le type de retour de la fonction, et le type de chacun des paramètres de la fonction. En Python vous n'avez jamais besoin de spécifier explicitement le type de quoi que ce soit. En fonction de la valeur que vous assignez, Python garde l'information sur le type de données en interne. +

☞en Java et dans les autres langages typés statiquement, vous devez spécifier le type de retour de la fonction, et le type de chacun des paramètres de la fonction. En Python vous n’avez jamais besoin de spécifier explicitement le type de quoi que ce soit. En fonction de la valeur que vous assignez, Python garde l’information sur le type de données en interne.

-

Paramètres Optionels et Nommés

+

Paramètres Optionnels et Nommés

-

Python autorise les paramètres de fonctions à avoir des valeurs par défaut ; si une fonction est appelée sans paramètre, l'paramètre prend sa valeur par défaut. De plus, les paramètres peuvent être spécifiés dans n'importe quel ordre en utilisant les paramètres nommés. +

Python autorise les paramètres de fonctions à avoir des valeurs par défaut : si une fonction est appelée sans paramètre, le paramètre prend sa valeur par défaut. De plus, les paramètres peuvent être spécifiés dans n’importe quel ordre en utilisant les paramètres nommés. -

Regardons à nouveau la déclaration de la fonction approximate_size() : +

Regardons à nouveau la déclaration de la fonction approximate_size() : 

def approximate_size(size, a_kilobyte_is_1024_bytes=True):
-

Le second paramètre, a_kilobyte_is_1024_bytes, spécifie une valeur par défaut qui est True. Cela signifie que le paramètre est optional ; vous pouvez appeler la fonction sans celui-ci, et PYthon fera comme si vous aviez appelé la fonction avec True comme second paramètre. +

Le second paramètre, a_kilobyte_is_1024_bytes, spécifie une valeur par défaut qui est True. Cela signifie que le paramètre est optional : vous pouvez appeler la fonction sans celui-ci, et Python fera comme si vous aviez appelé la fonction avec True comme second paramètre. -

Now look at the bottom of the script: +

Maintenant regardez la fin du script : 

if __name__ == '__main__':
     print(approximate_size(1000000000000, False))  ①
     print(approximate_size(1000000000000))         ②
  1. Ceci appelle la fonction approximate_size() avec deux paramètres. Dans la fonction approximate_size(), a_kilobyte_is_1024_bytes sera False, puisque vous avez passé explicitement False comme second paramètre. -
  2. Ceci appelle la fonction approximate_size() avec un seul paramètre. Mais c'est correct, car le second paramètre est optionnel ! Puisque l'appel ne le spécifie pas, le second argument prend par défaut la valeur True, comme défini dans la déclaration de la fonction. +
  3. Ceci appelle la fonction approximate_size() avec un seul paramètre. Mais c’est correct, car le second paramètre est optionnel ! Puisque l’appel ne le spécifie pas, le second argument prend par défaut la valeur True, comme défini dans la déclaration de la fonction.

Vous pouvez également passer des valeurs à une fonction par leur nom. @@ -127,9 +127,9 @@

Paramètres Optionels et Nommés

File "<stdin>", line 1 SyntaxError: non-keyword arg after keyword arg
    -
  1. Ceci appelle la fonction la fonction approximate_size() avec 4000 comme premier paramètre (size) et False pour le paramètre nommé a_kilobyte_is_1024_bytes. (Il s'avère qu'il s'agit du second paramètre, mais ça n'a pas d'importance, comme vous allez le voir dans une minute.) -
  2. Ceci appelle la fonction approximate_size() avec 4000 pour le paramètre nommé size et False pour l'argument nommé a_kilobyte_is_1024_bytes. (Il s'avère que ces arguments sont dans le même ordre que ceux listés dans la déclaration de la fonction, mais ça n'a pas d'importance non plus.) -
  3. Ceci appelle la fonction approximate_size() avec False pour le paramètre nommé a_kilobyte_is_1024_bytes et 4000 pour l'argument nommé size. (Vous voyez ? Je vous avez dit que l'ordre n'avait pas d'importance.) +
  4. Ceci appelle la fonction la fonction approximate_size() avec 4000 comme premier paramètre (size) et False pour le paramètre nommé a_kilobyte_is_1024_bytes. (Il s’avère qu’il s’agit du second paramètre, mais ça n’a pas d’importance, comme vous allez le voir dans une minute.) +
  5. Ceci appelle la fonction approximate_size() avec 4000 pour le paramètre nommé size et False pour l’argument nommé a_kilobyte_is_1024_bytes. (Il s’avère que ces arguments sont dans le même ordre que ceux listés dans la déclaration de la fonction, mais ça n’a pas d’importance non plus.) +
  6. Ceci appelle la fonction approximate_size() avec False pour le paramètre nommé a_kilobyte_is_1024_bytes et 4000 pour l’argument nommé size. (Vous voyez ? Je vous avez dit que l’ordre n’avait pas d’importance.)
  7. Si cet appel échoue c'est parce que vous avez un paramètre nommé suivi d'un paramètre non nommé (positionel), et ça ne marche jamais. Lisez la liste d'argument de gauche à droite, une fois que vous avez un paramètre nommé, tous ceux qui suivent doivent aussi être nommés.
  8. Cet appel échoue également, pour la même raison que le précédent. Est-ce surprenant ? Après tout, nous avons passé 4000 à l'argument nommé size, donc évidemment, False était destiné au paramètre a_kilobyte_is_1024_bytes. Mais Python ne fonctionne pas de cette façon. Dès que vous avez un paramètre nommé, tous les paramètres à la droite de celui-ci doivent aussi être nommés.
From f7f17077bec67da567bc908d9b77334c416e17e5 Mon Sep 17 00:00:00 2001 From: Gatien Bovyn Date: Mon, 15 Jul 2013 11:46:53 +0200 Subject: [PATCH 14/24] Corrections orthographiques --- 02-your-first-python-program.html | 32 +++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/02-your-first-python-program.html b/02-your-first-python-program.html index f99c7359..76be745f 100755 --- a/02-your-first-python-program.html +++ b/02-your-first-python-program.html @@ -129,41 +129,41 @@

Paramètres Optionnels et Nommés

  1. Ceci appelle la fonction la fonction approximate_size() avec 4000 comme premier paramètre (size) et False pour le paramètre nommé a_kilobyte_is_1024_bytes. (Il s’avère qu’il s’agit du second paramètre, mais ça n’a pas d’importance, comme vous allez le voir dans une minute.)
  2. Ceci appelle la fonction approximate_size() avec 4000 pour le paramètre nommé size et False pour l’argument nommé a_kilobyte_is_1024_bytes. (Il s’avère que ces arguments sont dans le même ordre que ceux listés dans la déclaration de la fonction, mais ça n’a pas d’importance non plus.) -
  3. Ceci appelle la fonction approximate_size() avec False pour le paramètre nommé a_kilobyte_is_1024_bytes et 4000 pour l’argument nommé size. (Vous voyez ? Je vous avez dit que l’ordre n’avait pas d’importance.) -
  4. Si cet appel échoue c'est parce que vous avez un paramètre nommé suivi d'un paramètre non nommé (positionel), et ça ne marche jamais. Lisez la liste d'argument de gauche à droite, une fois que vous avez un paramètre nommé, tous ceux qui suivent doivent aussi être nommés. -
  5. Cet appel échoue également, pour la même raison que le précédent. Est-ce surprenant ? Après tout, nous avons passé 4000 à l'argument nommé size, donc évidemment, False était destiné au paramètre a_kilobyte_is_1024_bytes. Mais Python ne fonctionne pas de cette façon. Dès que vous avez un paramètre nommé, tous les paramètres à la droite de celui-ci doivent aussi être nommés. +
  6. Ceci appelle la fonction approximate_size() avec False pour le paramètre nommé a_kilobyte_is_1024_bytes et 4000 pour l’argument nommé size. (Vous voyez ? Je vous avais dit que l’ordre n’avait pas d’importance.) +
  7. Si cet appel échoue c’est parce que vous avez un paramètre nommé suivi d’un paramètre non nommé (positionel), et ça ne marche jamais. Lisez la liste d’argument de gauche à droite, une fois que vous avez un paramètre nommé, tous ceux qui suivent doivent aussi être nommés. +
  8. Cet appel échoue également, pour la même raison que le précédent. Est-ce surprenant ? Après tout, nous avons passé 4000 à l’argument nommé size, donc évidemment, False était destiné au paramètre a_kilobyte_is_1024_bytes. Mais Python ne fonctionne pas de cette façon. Dès que vous avez un paramètre nommé, tous les paramètres à la droite de celui-ci doivent aussi être nommés.

⁂

Écrire du Code Lisible

-

Je ne vais pas vous ennuyer avec un long discours menaçant à propos de documenter son code. Sachez simplement que du code est écrit une fois, mais lu souvent, et l'audience la plus importante de votre code est vous-même, six mois après l'avoir écrit (c'est-à-dire après que vous ayiez tout oublié mais que devez corriger quelque chose). Python rend facile l'écriture de code lisible, tirez-en donc avantage. Vous me remercierez dans six mois. +

Je ne vais pas vous ennuyer avec un long discours menaçant à propos de documenter son code. Sachez simplement que du code est écrit une fois, mais lu souvent, et l’audience la plus importante de votre code est vous-même, six mois après l’avoir écrit (c’est-à-dire après que vous ayiez tout oublié mais que devez corriger quelque chose). Python rend facile l’écriture de code lisible, tirez-en donc avantage. Vous me remercierez dans six mois.

Chaînes de Documentation

-

Vous pouvez documenter une fonction Python en lui donnant une chaine de documentation (« documentation string » en anglais, abrégé en docstring). Dans ce programme, la fonction approximate_size() a docstring une : +

Vous pouvez documenter une fonction Python en lui donnant une chaîne de documentation (« documentation string » en anglais, abrégé en docstring). Dans ce programme, la fonction approximate_size() a une docstring : 

def approximate_size(size, a_kilobyte_is_1024_bytes=True):
-    '''Convertit une taille de fichier en une forme lisible par un humain.
+    '''Convertit une taille de fichier en un format lisible par un humain.
 
     Paramètres par mot-clef :
     size -- taille de fichiers en octets
     a_kilobyte_is_1024_bytes -- si True (par défaut), utilise des multiples de 1024
                                 si False, utilise des multiples de 1000
 
-    Retourne : une chaine de caractères
+    Retourne : une chaîne de caractères
 
     '''
-

Les triple apostrophes signifient qu'il s'agit d'une chaine multiligne. Tout ce qui est entre les apostrophes de début et de fin fait partie de la même chaine, y compris les retour chariot, les espaces de début de ligne, et les autres caractères de citation. Vous pouvez les utiliser n'importe où, mais vous les verrez le plus fréquemment lors de la définition d'une docstring. +

Les triple apostrophes signifient qu’il s’agit d’une chaîne multiligne. Tout ce qui est entre les apostrophes de début et de fin fait partie de la même chaîne, y compris les retour chariot, les espaces de début de ligne, et les autres caractères de citation. Vous pouvez les utiliser n’importe où, mais vous les verrez le plus fréquemment lors de la définition d’une docstring.

-

☞Les triples apostrophes sont aussi une façon simple de définir une chaine contenant à la fois des apostrophes et des guillemets, comme qq/.../ dans Perl 5. +

☞Les triples apostrophes sont aussi une façon simple de définir une chaîne contenant à la fois des apostrophes et des guillemets, comme qq/.../ dans Perl 5.

-

Tout ce qui est entre les triples apostrophes est la docstring de la fonction, qui documente ce que fait la fonction. Une docstring, si elle existe, doit être la première chose définie dans la fonction (c'est-à-dire la ligne suivant immédiatement la déclaration de la fonction). Vous n'avez pas techniquement besoin de donner une docstring votre fonction, mais vous devriez toujours. Je sais que vous avez déjà entendu cela dans tous les cours de programmation que vous avez eu, mais Python vous y incite encore plus : la docstring est disponible à tout moment de l'exécution en tant qu'attribut de la fonction. +

Tout ce qui est entre les triples apostrophes est la docstring de la fonction, qui documente ce que fait la fonction. Une docstring, si elle existe, doit être la première chose définie dans la fonction (c’est-à-dire la ligne suivant immédiatement la déclaration de la fonction). Vous n’avez pas techniquement besoin de donner une docstring à votre fonction, mais vous devriez toujours. Je sais que vous avez déjà entendu cela dans tous les cours de programmation que vous avez eu, mais Python vous y incite encore plus : la docstring est disponible à tout moment de l’exécution en tant qu’attribut de la fonction.

-

☞Beaucoup d'IDEs Python utilisent la docstring pour fournir de la documentation contextuelle, de telle façon que lorsque vous tapez le nom d'une fonction, sa docstring apparait dans une infobulle. Ça peut être incroyablement utile, mais sa qualité dépend de la qualité des docstrings que vous écrivez. +

☞Beaucoup d’EDIs Python utilisent la docstring pour fournir de la documentation contextuelle, de telle façon que lorsque vous tapez le nom d’une fonction, sa docstring apparait dans une infobulle. Ça peut être incroyablement utile, mais sa qualité dépend de la qualité des docstrings que vous écrivez.

⁂

Le Chemin de Recherche de import

-

Avant d'aller plus loin, je voudrais mentionner brièvement le chemin de recherche de bibliothèques. Python cherche à plusieurs endroits lorsque vous essayez d'importer un module. Plus spécifiquement, il regarde dans tous les dossiers définis dans sys.path. Il s'agit uniquement d'une liste, et vous pouvez facilement la voir ou la modifier avec les méthodes de liste standards (Vous en sourez plus sur les listes dans Les Types Prédéfinis.) +

Avant d’aller plus loin, je voudrais mentionner brièvement le chemin de recherche de bibliothèques. Python cherche à plusieurs endroits lorsque vous essayez d’importer un module. Plus spécifiquement, il regarde dans tous les dossiers définis dans sys.path. Il s’agit uniquement d’une liste, et vous pouvez facilement la voir ou la modifier avec les méthodes de liste standards (Vous en saurez plus sur les listes dans Les Types Prédéfinis.) 

 >>> import sys                                                 ①
 >>> sys.path                                                   ②
@@ -188,10 +188,10 @@ 
Le Chemin de Recherche de import

  '/usr/local/lib/python3.1/dist-packages']
  1. Importer le module sys rend disponible toutes ses fonctions et attributs. -
  2. sys.path est une liste de noms de dossiers qui constitue le chemin de recherche actuel. (Le votre ressemblera à autre chose, en fonction de votre système d'exploitation, la version de Python que vous utilisez, et où il a été installé à l'origine.). Python recherchera dans ces dossiers (et dans cet ordre) un fichier .py dont le nom correspond à celui que vous essayez d'importer. -
  3. En fait, j'ai menti ; la vérité est bien plus compliquée que cela, car tous les modules ne sont pas stockés dans des fichiers .py. Certains sont des Actually, I lied; the truth is more complicated than that, because not all modules are stored as .py files. Certains sont des modules natifs ; ils font en effet partie de Python lui-même. Les modules natifs se comportent comme des modules classiques, mais leur code Python n'est pas disponible, car ils ne sont pas écrits en Python ! (Comme Python lui-même, ces modules natifs sont écrits en C.) -
  4. Vous pouvez ajouter un nouveau dossier au chemin de recherche de Python en ajoutant le nom de celui-ci à sys.path, et alors Python regardera aussi dans ce dossier quand vous essayez d'importer un module. Et ce tant que Python est en cours d'exécution. -
  5. En utilisant sys.path.insert(0, new_path), vous ajoutez un nouveau dossier comme premier élément de la liste sys.path, et donc au début du chemin de recherche de Python. C'est presque toujours ce que vous voulez. Dans le cas de conflits de noms (par exemple si Python est distribué avec la version 2 d'une bibliothèque donnée mais que vous voulez utiliser la version 3), cela permet de s'assurer que vous modules seront trouvés et utilisés à la place de ceux qui sont distribués avec Python. +
  6. sys.path est une liste de noms de dossiers qui constitue le chemin de recherche actuel. (Le vôtre ressemblera à autre chose, en fonction de votre système d’exploitation, la version de Python que vous utilisez, et où il a été installé à l’origine.). Python recherchera dans ces dossiers (et dans cet ordre) un fichier .py dont le nom correspond à celui que vous essayez d’importer. +
  7. En fait, j’ai menti ; la vérité est bien plus compliquée que cela, car tous les modules ne sont pas stockés dans des fichiers .py. Certains sont des modules natifs : ils font en effet partie de Python lui-même. Les modules natifs se comportent comme des modules classiques, mais leur code Python n’est pas disponible, car ils ne sont pas écrits en Python :! (Comme Python lui-même, ces modules natifs sont écrits en C.) +
  8. Vous pouvez ajouter un nouveau dossier au chemin de recherche de Python en ajoutant le nom de celui-ci à sys.path, et alors Python regardera aussi dans ce dossier quand vous essayez d’importer un module. Et ce tant que Python est en cours d’exécution. +
  9. En utilisant sys.path.insert(0, new_path), vous ajoutez un nouveau dossier comme premier élément de la liste sys.path, et donc au début du chemin de recherche de Python. C’est presque toujours ce que vous voulez. Dans le cas de conflits de noms (par exemple si Python est distribué avec la version 2 d’une bibliothèque donnée mais que vous voulez utiliser la version 3), cela permet de s’assurer que vos modules seront trouvés et utilisés à la place de ceux qui sont distribués avec Python.

⁂ From 660a22a11ff8037852525acba3f1d792bdf09050 Mon Sep 17 00:00:00 2001 From: Gatien Bovyn Date: Mon, 15 Jul 2013 11:49:44 +0200 Subject: [PATCH 15/24] Corrections orthographiques --- 02-your-first-python-program.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/02-your-first-python-program.html b/02-your-first-python-program.html index 76be745f..2d0c7aae 100755 --- a/02-your-first-python-program.html +++ b/02-your-first-python-program.html @@ -189,7 +189,7 @@

Le Chemin de Recherche de import

  1. Importer le module sys rend disponible toutes ses fonctions et attributs.
  2. sys.path est une liste de noms de dossiers qui constitue le chemin de recherche actuel. (Le vôtre ressemblera à autre chose, en fonction de votre système d’exploitation, la version de Python que vous utilisez, et où il a été installé à l’origine.). Python recherchera dans ces dossiers (et dans cet ordre) un fichier .py dont le nom correspond à celui que vous essayez d’importer. -
  3. En fait, j’ai menti ; la vérité est bien plus compliquée que cela, car tous les modules ne sont pas stockés dans des fichiers .py. Certains sont des modules natifs : ils font en effet partie de Python lui-même. Les modules natifs se comportent comme des modules classiques, mais leur code Python n’est pas disponible, car ils ne sont pas écrits en Python :! (Comme Python lui-même, ces modules natifs sont écrits en C.) +
  4. En fait, j’ai menti  la vérité est bien plus compliquée que cela, car tous les modules ne sont pas stockés dans des fichiers .py. Certains sont des modules natifs : ils font en effet partie de Python lui-même. Les modules natifs se comportent comme des modules classiques, mais leur code Python n’est pas disponible, car ils ne sont pas écrits en Python :! (Comme Python lui-même, ces modules natifs sont écrits en C.)
  5. Vous pouvez ajouter un nouveau dossier au chemin de recherche de Python en ajoutant le nom de celui-ci à sys.path, et alors Python regardera aussi dans ce dossier quand vous essayez d’importer un module. Et ce tant que Python est en cours d’exécution.
  6. En utilisant sys.path.insert(0, new_path), vous ajoutez un nouveau dossier comme premier élément de la liste sys.path, et donc au début du chemin de recherche de Python. C’est presque toujours ce que vous voulez. Dans le cas de conflits de noms (par exemple si Python est distribué avec la version 2 d’une bibliothèque donnée mais que vous voulez utiliser la version 3), cela permet de s’assurer que vos modules seront trouvés et utilisés à la place de ceux qui sont distribués avec Python.
From 8e0f56fac7d3adb8dac89d60d7423ec07d126ebd Mon Sep 17 00:00:00 2001 From: Valentin Lorentz Date: Mon, 15 Jul 2013 23:03:52 +0200 Subject: [PATCH 16/24] Poursuite de la traduction du chapitre 2 (environ les trois quarts). --- 02-your-first-python-program.html | 72 +++++++++++++++---------------- 1 file changed, 36 insertions(+), 36 deletions(-) diff --git a/02-your-first-python-program.html b/02-your-first-python-program.html index 2d0c7aae..7a1160a1 100755 --- a/02-your-first-python-program.html +++ b/02-your-first-python-program.html @@ -68,7 +68,7 @@

Approfondir

1.0 TB 931.3 GiB -

Qu’est-ce qui vient de se passer ? Vous venez d’exécuter votre premier programme Python. Vous appelez l'interpréteur Python par la ligne de commande et vous lui donnez le nom du script Python que vous voulez exécuter. Le script définit une unique fonction, la fonction approximate_size() qui prend une taille de fichier exacte en octets et calcule une taille plus esthétique (mais approximative). Vous avez probablement déjà vu ça dans l’Explorateur de Windows, le Finder de Mac OS X, ou Nautilus ou Dolphin ou Thunar sous Linux. Si vous avez un répertoire avec des documents dans une liste multi-colonnes, il affichera un tableau avec l'icône du document, le nom du document, la taille, le type, la date de dernière modification, etc. Si le fichier contient un fichier de 1093 octets nommé TODO, votre gestionnaire de fichiers n’affichera pas TODO 1093 octets, mais plutôt quelque chose du genre TODO 1 KO. C’est ce que fait la fonction approximate_size(). +

Qu’est-ce qui vient de se passer ? Vous venez d’exécuter votre premier programme Python. Vous appelez l’interpréteur Python par la ligne de commande et vous lui donnez le nom du script Python que vous voulez exécuter. Le script définit une unique fonction, la fonction approximate_size() qui prend une taille de fichier exacte en octets et calcule une taille plus esthétique (mais approximative). Vous avez probablement déjà vu ça dans l’Explorateur de Windows, le Finder de Mac OS X, ou Nautilus ou Dolphin ou Thunar sous Linux. Si vous avez un répertoire avec des documents dans une liste multi-colonnes, il affichera un tableau avec l’icône du document, le nom du document, la taille, le type, la date de dernière modification, etc. Si le fichier contient un fichier de 1093 octets nommé TODO, votre gestionnaire de fichiers n’affichera pas TODO 1093 octets, mais plutôt quelque chose du genre TODO 1 KO. C’est ce que fait la fonction approximate_size().

Regardez à la fin du script et vous verrez deux appels à print(approximate_size(arguments)). Ce sont des appels de fonctions  — le premier appelle la fonction approximate_size() et lui passe des arguments (aussi appelés paramètres), puis prend la valeur de retour et la passe directement à la fonction print(). La fonction print() est fournie par Python : vous ne verrez jamais de déclaration explicite de celle-ci. Vous pouvez l’utiliser n’importe où, n’importe quand. (Il y a beaucoup de fonctions fournies par Python, et beaucoup d’entre elles sont séparées dans des modules modules. Patience, jeune padawan.) @@ -197,40 +197,40 @@

Le Chemin de Recherche de import

⁂

Everything Is An Object

-

In case you missed it, I just said that Python functions have attributes, and that those attributes are available at runtime. A function, like everything else in Python, is an object. -

Run the interactive Python shell and follow along: +

Au cas où vous ne l'auriez pas remarqué, les fonctions Python ont des attributs, et ces attributs sont accessibles à l’exécution. Python, tout est objet, y compris les fonctions. +

Lancez un shell interactif Python et exécutez le code suivant : 

 >>> import humansize                               ①
 >>> print(humansize.approximate_size(4096, True))  ②
 4.0 KiB
 >>> print(humansize.approximate_size.__doc__)      ③
-Convert a file size to human-readable form.
+Convertit une taille de fichier en un format lisible par un humain.
 
-    Keyword arguments:
-    size -- file size in bytes
-    a_kilobyte_is_1024_bytes -- if True (default), use multiples of 1024
-                                if False, use multiples of 1000
+    Paramètres par mot-clef :
+    size -- taille de fichiers en octets
+    a_kilobyte_is_1024_bytes -- si True (par défaut), utilise des multiples de 1024
+                                si False, utilise des multiples de 1000
 
-    Returns: string
+    Retourne : une chaîne de caractères
    -
  1. The first line imports the humansize program as a module — a chunk of code that you can use interactively, or from a larger Python program. Once you import a module, you can reference any of its public functions, classes, or attributes. Modules can do this to access functionality in other modules, and you can do it in the Python interactive shell too. This is an important concept, and you’ll see a lot more of it throughout this book. -
  2. When you want to use functions defined in imported modules, you need to include the module name. So you can’t just say approximate_size; it must be humansize.approximate_size. If you’ve used classes in Java, this should feel vaguely familiar. -
  3. Instead of calling the function as you would expect to, you asked for one of the function’s attributes, __doc__. +
  4. La première ligne importe le programme humansize en tant que module — un bout de code que vous pouvez utiliser de façon interactive, ou dans un programme Python plus gros. Une fois que vous avez importé un module, vous pouvez faire référence à n’importe laquelle de ses fonctions, classes, et attributs publics. Les modules peuvent faire de même pour accéder aux fonctionnalités d’autres modules, et vous pouvez le faire aussi dans le shell interactif de Python. C’est un concept important, et vous en verrez bien plus au cours de ce livre. +
  5. Quand vous voulez utiliser les fonctions définies dans des modules importés, vous devez inclure le nom du module. Vous ne pouvez seulement dire approximate_size ; ce doit être humansize.approximate_size. Si vous avez utilisé des classes en Java, ce concept devrait vous être vaguement familier. +
  6. Plutôt que d’appeler la fonction comme vous auriez pu vous y attendre, nous avons utilisé un des attributs de la fonction, __doc__.
-

☞import in Python is like require in Perl. Once you import a Python module, you access its functions with module.function; once you require a Perl module, you access its functions with module::function. +

☞import est comme require en Perl. Une fois que vous importez un module Python, vous avez accès à toutes ses fonctions par module.fonction ; une fois que vous avez utilisé require sur un module Perl, vous avez accès à toutes ses fonctions avec module::function.

-

What’s An Object?

-

Everything in Python is an object, and everything can have attributes and methods. All functions have a built-in attribute __doc__, which returns the docstring defined in the function’s source code. The sys module is an object which has (among other things) an attribute called path. And so forth. -

Still, this doesn’t answer the more fundamental question: what is an object? Different programming languages define “object” in different ways. In some, it means that all objects must have attributes and methods; in others, it means that all objects are subclassable. In Python, the definition is looser. Some objects have neither attributes nor methods, but they could. Not all objects are subclassable. But everything is an object in the sense that it can be assigned to a variable or passed as an argument to a function. -

You may have heard the term “first-class object” in other programming contexts. In Python, functions are first-class objects. You can pass a function as an argument to another function. Modules are first-class objects. You can pass an entire module as an argument to a function. Classes are first-class objects, and individual instances of a class are also first-class objects. -

This is important, so I’m going to repeat it in case you missed it the first few times: everything in Python is an object. Strings are objects. Lists are objects. Functions are objects. Classes are objects. Class instances are objects. Even modules are objects. +

Qu’est-ce qu’un objet ?

+

Tout, en Python, est un objet, et tout peut avoir des attributs et des méthodes. Toutes les fonctions ont un attribut créé automatiquement, __doc__, qui contient la docstring définie dans le code source de la fonction. Le module sys est un objet qui a (entre autres) un attribut appelé path, etc. +

Cependant, cela ne répond pas à la question plus fondamentale : qu’est-ce qu’un objet ? Des langages de programmation différents définissent « objet » de différentes façons. Pour certains, cela signifique que que tous les objets doivent avoir des attributs et des méthodes ;dans d’autre, cela signifie que tous les objets peuvent être dérivés. En Python, la définition est plus libre. Certains objets n’ont ni attribut ni méthode, mais ils pourraient. Tous les objets ne sont pas dérivables. Mais tout est objet dans le sens où tout peut-être assigné à une variable ou passé en paramètre à une fonction. +

Vous pouvez entendu parler du terme « objet de première classe » dans d’autres contextes de programmation. En Python, les fonctions sont des objets de première classe. Vous pouvez passer une fonction en paramètre à une autre fonction. Les modules sont des objets de première classe. Vous pouvez passer tout un module en paramètre à une fonction. Les classes sont des objets de première-classe, et les instances d’une classe sont aussi des objets de première classe. +

Ceci est important, donc je vais le répéter si vous l’avez manqué les premières fois : tout en Python est objet. Les strings sont des objets. Les listes sont des objets. Les fonctions sont des objets. Les classes sont des objets. Même les modules sont des objets.

⁂ -

Indenting Code

-

Python functions have no explicit begin or end, and no curly braces to mark where the function code starts and stops. The only delimiter is a colon (:) and the indentation of the code itself. +

Indenter le Code

+

Les fonctions Python n’ont pas de begin ni de end explicite ni d’accolades pour marquer où une fonction commence et se termine. Le seul délimiteur est le double point (:) et l’indentation du code elle-même. 

def approximate_size(size, a_kilobyte_is_1024_bytes=True):  ①
     if size < 0:                                            ②
         raise ValueError('number must be non-negative')     ③
@@ -243,45 +243,45 @@ 
Indenting Code

 
     raise ValueError('number too large')
    -
  1. Code blocks are defined by their indentation. By “code block,” I mean functions, if statements, for loops, while loops, and so forth. Indenting starts a block and unindenting ends it. There are no explicit braces, brackets, or keywords. This means that whitespace is significant, and must be consistent. In this example, the function code is indented four spaces. It doesn’t need to be four spaces, it just needs to be consistent. The first line that is not indented marks the end of the function. -
  2. In Python, an if statement is followed by a code block. If the if expression evaluates to true, the indented block is executed, otherwise it falls to the else block (if any). Note the lack of parentheses around the expression. -
  3. This line is inside the if code block. This raise statement will raise an exception (of type ValueError), but only if size < 0. -
  4. This is not the end of the function. Completely blank lines don’t count. They can make the code more readable, but they don’t count as code block delimiters. The function continues on the next line. -
  5. The for loop also marks the start of a code block. Code blocks can contain multiple lines, as long as they are all indented the same amount. This for loop has three lines of code in it. There is no other special syntax for multi-line code blocks. Just indent and get on with your life. +
  6. Les blocs de code sont définis par leur indentation. Par « bloc de code », je parle des fonctions, blocs if, boucles for, boucles while, etc. Indenter débuter un bloc et désindenter le termine. Il n’y a pas d’accolade, crochet, ou mot-clé explicite. Cela signifie que les espaces blancs sont significatifs et doivent être cohérents. Dans cet exemple, le code de la fonction est indenté avec quatre espaces. Il n’est pas obligatoire d’utiliser quatre espaces, il faut seulement être cohérent. La première ligne à ne pas être identée marque la fin de la fonction. +
  7. En Python, une instruction if est suivie par un bloc de code. Si l’expression du if est évaluée à True (c’est-à-dire « vrai »), le bloc indenté est exécuté, xinon c’est le bloc else qui l’est (s’il y en a un). Notez l’absence de parenthèse autour de l’expression. +
  8. Cette ligne est à l’intérieur du bloc if. L’instruction raise lèvera une exception (du type ValueError), mais seulement si size < 0. +
  9. Ce n’est pas la fin de la fonction. Les lignes complètement blances ne comptent pas. Elles peuvent être le code plus lisible, mais ne comptent pas comme des délimiteurs de blocs. La fonction continue à la ligne suivante. +
  10. La boucle for marque aussi le début d’un bloc de code. Les blocs de code peuvent contenir plusieurs lignes, à condition que toutes soient indentées au même niveau. Cette boucle for contient trois lignes de code. Il n’y a pas de syntaxe particulière pour les blocs de code multilignes. Indentez simplement et passez votre chemin.
-

After some initial protests and several snide analogies to Fortran, you will make peace with this and start seeing its benefits. One major benefit is that all Python programs look similar, since indentation is a language requirement and not a matter of style. This makes it easier to read and understand other people’s Python code. +

Après quelques protestations initiales et des analogies narquoises à Fortran, vous ferez la paix avec ceci et commencerez à en voir les bénéfices. Un avantage majeur est que tous les programmes Python se ressemblent, puisque l’indentation est une attente du langage et pas seulement une question de style. Cela rend plus simple la lecture et la compréhension de votre code Python par d’autres personnes.

-

☞Python uses carriage returns to separate statements and a colon and indentation to separate code blocks. C++ and Java use semicolons to separate statements and curly braces to separate code blocks. +

☞Python utilise les retours chariot pour séparer les instructions et un double-point et une indentation pour séparer les blocs de code. C++ et Java utilisent des point-virgules pour séparer les instructions et des accolades pour séparer les blocs de code.

⁂

Exceptions

-

Exceptions are everywhere in Python. Virtually every module in the standard Python library uses them, and Python itself will raise them in a lot of different circumstances. You’ll see them repeatedly throughout this book. +

Les exceptions sont partout en Python. Presque tous les modules de la bibliothèque standard de Python les utilise, et Python lui-même en lève dans beaucoup de situations différentes. Vous verrez que nous en utilisons fréquemment au cours de ce livre. -

What is an exception? Usually it’s an error, an indication that something went wrong. (Not all exceptions are errors, but never mind that for now.) Some programming languages encourage the use of error return codes, which you check. Python encourages the use of exceptions, which you handle. +

Qu’est-ce qu’une exception ? En général c’est une erreur indiquant que quelque chose s’est mal passé. (Toutes les exceptions ne sont pas des erreurs, mais nous passerons là-dessus pour le moment.) Certains langages de programmation encouragent l’utilisation de code de retour d’erreur, que vous pouvez vérifier. Python encourage l’utilisation d’exceptions que vous pouvez gérer. -

When an error occurs in the Python Shell, it prints out some details about the exception and how it happened, and that’s that. This is called an unhandled exception. When the exception was raised, there was no code to explicitly notice it and deal with it, so it bubbled its way back up to the top level of the Python Shell, which spits out some debugging information and calls it a day. In the shell, that's no big deal, but if that happened while your actual Python program was running, the entire program would come to a screeching halt if nothing handles the exception. Maybe that’s what you want, maybe it isn’t. +

Quand une erreur survient dans le Shell Python, elle est affichée avec quelques détails à propos de l’exceptions et de comment elle est survenue, et c’est tout. Ceci est appelé une exception non gérée. Lorsque l’exception a été levée, il n’y avait pas de code pour explicitement la remarquer et la gérer, donc elle est remontée jusqu’au niveau supérieur : le Shell Python, qui affiche quelques informations de débogage et met un point final à cette histoire. Dans le shell, ce n’est pas bien grave. Mais si ça arrive alors que votre programme Python réel est en cours d’exécution, tout le programme va s’arrêter en hurlant et rien ne gèrera l’exception. Ça peut être ce que vous désirez, mais peut-être pas.

-

☞Unlike Java, Python functions don’t declare which exceptions they might raise. It’s up to you to determine what possible exceptions you need to catch. +

☞Contrairement à Java, les fonctions Python ne déclarent pas quelles exceptions elles peuvent lever. C’est à vous de déterminer quelles exceptions vous avez à gérer.

-

An exception doesn’t need to result in a complete program crash, though. Exceptions can be handled. Sometimes an exception is really because you have a bug in your code (like accessing a variable that doesn’t exist), but sometimes an exception is something you can anticipate. If you’re opening a file, it might not exist. If you’re importing a module, it might not be installed. If you’re connecting to a database, it might be unavailable, or you might not have the correct security credentials to access it. If you know a line of code may raise an exception, you should handle the exception using a try...except block. +

Une exception ne résulte pas nécessairement en un plantage du programme, cependant. Les exceptions peuvent très bien être gérées. Parfois, une exception est vraiment parce que vous avez un bogue dans votre code (comme accéder à une variable qui n’existe pas), mais parfois, une exception est quelque chose que vous pouvez anticiper. Si vous ouvrez un fichier, il peut ne pas exister. Si vous importez un module, il peut ne pas être installé. Si vous vous connectez à une base de données, elle peut être indisponible, ou vous pouvez ne pas y avoir les droits d’accès. Si vous savez qu’une ligne de votre code peut lever une exception, vous pouvez gérer l’exception en utilisant un bloc try...except.

-

☞Python uses try...except blocks to handle exceptions, and the raise statement to generate them. Java and C++ use try...catch blocks to handle exceptions, and the throw statement to generate them. +

☞Python utiliser des blocs try...except pour gérer les exceptions, et l’instruction raise pour les engendrer. Java et C++ utilisent try...catch pour gérer les exceptions et l’instruction throw pour les engendrer.

-

The approximate_size() function raises exceptions in two different cases: if the given size is larger than the function is designed to handle, or if it’s less than zero. +

La fonction approximate_size() lève des exceptions dans deux cas : si la taille donnée est plus grande que ce que la fonction peut gérer, ou si elle est plus petite que zéro. 

if size < 0:
     raise ValueError('number must be non-negative')
-

The syntax for raising an exception is simple enough. Use the raise statement, followed by the exception name, and an optional human-readable string for debugging purposes. The syntax is reminiscent of calling a function. (In reality, exceptions are implemented as classes, and this raise statement is actually creating an instance of the ValueError class and passing the string 'number must be non-negative' to its initialization method. But we’re getting ahead of ourselves!) +

La syntaxe pour lever une exception est assez simple. Utilisez l’instruction raise, suivie du nom de l’exception, et une chaine lisible humainement pour du débogage éventuel. La syntaxe est nous rappelle un appel de fonction. (En réalité, les exceptions sont implémentées comme étant des classes, et l’instruction raise sert en fait à créer une instance de la classe ValueError en lui passant la chaine 'number must be non-negative' à sa méthode d’initialisation. Mais nous sommes en train de prendre trop d’avance !)

-

☞You don’t need to handle an exception in the function that raises it. If one function doesn’t handle it, the exception is passed to the calling function, then that function’s calling function, and so on “up the stack.” If the exception is never handled, your program will crash, Python will print a “traceback” to standard error, and that’s the end of that. Again, maybe that’s what you want; it depends on what your program does. +

☞Vous n’avez pas besoin de gérer une exception que vous levez. Si une fonction ne la gère pas, elle est passée à la fonction appelante, puis à la fonction qui a appelé la fonction appelante, et ainsi de suite jusqu’en haut de la pile. Si l’exception n’est jamais gérer, votre programme plantera, Python affichera un « traceback » dans stderr et ce sera tout. Encore une fois, ce peut être quelque chose que vous voulez ; ça dépend de ce que fait votre programme.

Catching Import Errors

From 72c8ca38114869437328e76231ab35c0efe32d0d Mon Sep 17 00:00:00 2001 From: Astalaseven Date: Mon, 15 Jul 2013 23:15:43 +0200 Subject: [PATCH 17/24] Corrections --- 02-your-first-python-program.html | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/02-your-first-python-program.html b/02-your-first-python-program.html index 7a1160a1..4c158a97 100755 --- a/02-your-first-python-program.html +++ b/02-your-first-python-program.html @@ -5,7 +5,7 @@ --- -Your first Python program - Dive Into Python 3 +Votre premier programme Python - Plongez dans Python 3