--- Log opened Tue Oct 23 20:07:45 2007
20:07 < sherkin> Le programme de ce soir ?
20:08 < Waraba> le sujet est ecris non
20:08 < gpocentek> on continue ce qu'on a commencé la semaine dernière
20:08 < gpocentek> logs en live : http://gauvain.pocentek.net/python-2007-10-23
20:08 < gpocentek> skateinmars: ^
20:09 < gpocentek> ok, let's go
20:09 < gpocentek> vu la population ce soir, je vais me passer du mode +m
20:10 < sherkin> optimiste !
20:10 < gpocentek> donc, python - episode 2
20:10 < gpocentek> vous avez l'adresse du dernier cours dans le topic si besoin
20:10 < gpocentek> hésitez pas à poser des questions si besoin !
20:10 -!- shiva [n=shiva@guy78-5-82-247-56-86.fbx.proxad.net] has joined #ubuntu-fr-classroom
20:11 < gpocentek> Pour commencer je voudrais aborder comment trouver de la documentation
20:11 < gpocentek> Python a une documentation interne, que l'on peut appeler avec la variable spéciale __doc__ pour quasiment chaque fonction, méthode ou objet interne à python ('builtin').
20:11 < gpocentek> Pour y accéder dans l'interpréteur :
20:11 < gpocentek>   print str.__doc__
20:12 < gpocentek> je vous laisse lancer le shell et tester :)
20:12 < gpocentek> ok pour tout le monde ?
20:12 < sherkin> ok
20:12 < shiva> ok
20:12 < VMarCV> ok
20:12 < sherkin> Retourne une jolie chaine ...
20:12 < gpocentek> C'est intéressant si l'on connait le nom de l'objet qui nous intéresse bien sûr !
20:12 < Waraba> pas ok
20:12 < Sp4rKy> print apero.ricard().__doc__
20:13 < Sp4rKy> ( bonsoir )
20:13 < gpocentek> Waraba: ?
20:13 < gpocentek> (je vais passer au +m finalement, pour la clarté des logs)
20:13 < gpocentek> Waraba: un souci avec ça ?
20:13 < Waraba> gpocentek: non
20:13 -!- mode/#ubuntu-fr-classroom [+o gpocentek] by ChanServ
20:13 <@gpocentek> ok
20:13 -!- mode/#ubuntu-fr-classroom [+v skateinmars] by gpocentek
20:14 -!- mode/#ubuntu-fr-classroom [+v Sp4rKy] by gpocentek
20:14 <@gpocentek> donc je continue
20:14 -!- mode/#ubuntu-fr-classroom [+m] by gpocentek
20:14 <@gpocentek> (je reprends en fait)
20:14 <@gpocentek> C'est intéressant si l'on connait le nom de l'objet qui nous intéresse bien sûr !
20:14 <@gpocentek> Pour connaître toutes les variables et méthodes associées à un objet, on utilise la fonction dir():
20:14 <@gpocentek>   dir(str)
20:14 <@gpocentek>   dir(list)
20:15 <@gpocentek> ça vous affiche une séquence avec toutes les variables accessibles (y compris les méthodes)
20:15 <@gpocentek> s/variables/attributs/
20:15 -!- mode/#ubuntu-fr-classroom [-m] by gpocentek
20:15 <@gpocentek> ok pour ça ?
20:15 < Waraba> ok
20:15 < VMarCV> oui
20:15 < sherkin> yaisse
20:15 -!- mode/#ubuntu-fr-classroom [+m] by gpocentek
20:15 <@gpocentek> Et pour connaître la liste des éléments au coeur de python :
20:15 <@gpocentek>   dir(__builtins__)
20:16 <@gpocentek> ce sont les éléments qui forment le coeur du langage python
20:16 <@gpocentek> à partir de cette liste et avec la documentation pour chaque fonction, vous avez sous la main tout ce que python peut faire par défaut
20:16 <@gpocentek> Autre moyen de trouver de la doc : Installez le paquet 'python-doc' et vous aurez également accès à une documentation complète (/usr/share/doc/python-doc/html/index.html).
20:17 <@gpocentek> En particulier, /usr/share/doc/python-doc/html/lib/lib.html contient tous les détails nécessaires sur les éléménts par défaut de python.
20:17 -!- mode/#ubuntu-fr-classroom [-m] by gpocentek
20:17 <@gpocentek> je vous laisse installer le paquet et jeter un oeil à ça
20:17 <@gpocentek> ouvrez les fichiers dans firefox (ou autre navigateur), c'est plus pratique pour lire de l'html
20:18 <@gpocentek> installer ce paquet vous donne la doc qui correspond à la version de python que vous utilisez
20:18 < sherkin> c'est la même chose que http://www.python.org/doc/ ?
20:18 < sherkin> (je manque d'espace disque ...)
20:18 -!- moft [n=moft@shound.org] has joined #ubuntu-fr-classroom
20:18 <@gpocentek> sherkin: oui
20:18 < sebastienb> http://quentel.pierre.free.fr/python-trad/lib.html ya une petite traduction ici (enfin il en reste en anglais)
20:18 <@gpocentek> merci sebastienb
20:19 <@gpocentek> savoir où trouver de la doc est vraiment important je pense
20:19 < sebastienb> ouais
20:19 <@gpocentek> et bien sûr google reste votre plus fidèle ami
20:19 < sebastienb> et wikibooks aussi pour pygame et soya3D
20:19 <@gpocentek> il y a des tonnes de ressources sur le net, n'hésitez pas à en profiter
20:19 < sebastienb> et le blog de ded pour panda
20:20 <@gpocentek> ok pour tout le monde ?
20:20 < ploc> ok
20:20 < Waraba> ok
20:20 < sebastienb> ok
20:20 -!- mode/#ubuntu-fr-classroom [+m] by gpocentek
20:20 <@gpocentek> Le but de la session d'aujourd'hui est de découvrir des éléments qui nous permettrons vous permettre d'écrire une petite application de répertoire téléphonique.
20:20 <@gpocentek> On voudrait avoir un menu qui propose de faire plusieurs choses :
20:21 <@gpocentek> - ajouter un contact
20:21 <@gpocentek> - en supprimer un
20:21 <@gpocentek> - en modifier un
20:21 <@gpocentek> - lister tous les contacts (par ordre alphabétique)
20:21 <@gpocentek> - lister les contacts commençant pour une lettre en particuler
20:21 <@gpocentek> - quitter
20:21 <@gpocentek> on n'écrira pas ce programme en entier ce soir, ce sera à vous de le faire
20:21 <@gpocentek> mais je vais vous donner toutes les pistes pour le faire
20:21 <@gpocentek> Ce dont on va avoir besoin :
20:21 <@gpocentek> - une boucle pour le menu et la capacité d'en sortir
20:21 <@gpocentek> - un moyen d'enregistrer une paire nom/n° de tel
20:21 <@gpocentek> - un moyen de parcourir la liste des paires
20:21 <@gpocentek> - un moyen de sauver/lire sur le disque
20:22 -!- mode/#ubuntu-fr-classroom [-m] by gpocentek
20:22 <@gpocentek> ça va à tout le monde ce petit exo ?
20:22 < VMarCV> oui
20:22 < yvan_> ok
20:22 < Waraba> oui
20:22 < sherkin> ok
20:22 < sebastienb> ca a l'air facile
20:22 <@gpocentek> je trouve ça plus intéressant que de balancer une liste d'instructions ;)
20:22 < ploc> non
20:22 <@gpocentek> ploc: ?
20:22 < ploc> je blague... ;-) allons-y
20:22 <@gpocentek> sebastienb: pas forcément quand on débute
20:23 <@gpocentek> ploc: ok :)
20:23 -!- mode/#ubuntu-fr-classroom [+m] by gpocentek
20:23 <@gpocentek> 1ère étape : un menu
20:23 <@gpocentek> Le menu devra apparaître indéfiniment.
20:23 <@gpocentek> ce n'est pas possible avec les éléments de controle qu'on a déjà vu (if, for).
20:23 <@gpocentek> On va donc utiliser une boucle while.
20:23 -!- mode/#ubuntu-fr-classroom [-m] by gpocentek
20:23 < sebastienb> faut bien connaitre les classes et ca c'est plus dur (le temps que j'ai mis avant de comprendre O_O)
20:23 <@gpocentek> avant d'aller plus loin, des questopns sur if et for ?
20:24 <@gpocentek> sebastienb: on fera pas d'orienté objet ce soir
20:24 < VMarCV> non
20:24 < sebastienb> arf ok
20:24 <@gpocentek> sebastienb: à la prochaine session
20:24 < sebastienb> ok
20:24 < yvan_> go
20:24 <@gpocentek> ok, continuons
20:24 -!- mode/#ubuntu-fr-classroom [+m] by gpocentek
20:24 <@gpocentek> while ('tant que') s'utilise comme ceci :
20:24 <@gpocentek>   while (condition est vraie):
20:24 <@gpocentek>       #faire des actions
20:24 <@gpocentek>       #et d'autres
20:24 <@gpocentek> par exemple :
20:25 <@gpocentek>   i = 0
20:25 <@gpocentek>   while (i < 10):
20:25 <@gpocentek>         print i
20:25 -!- mode/#ubuntu-fr-classroom [-m] by gpocentek
20:25 <@gpocentek> vous pouvez tester ça dans l'interpréteur
20:25 < sebastienb> (pour faire une boucle infinie simple, faites while 1:     )
20:25 <@gpocentek> oops
20:25 <@gpocentek> j'ai oublié un truc
20:25 < sebastienb> l'incrémentation ?
20:26 <@gpocentek>   i = 0
20:26 <@gpocentek>   while (i < 10):
20:26 <@gpocentek>         i = i+1
20:26 <@gpocentek>         print i
20:26 <@gpocentek> ça ça va mieux marcher, désolé
20:26 < ploc> en effet !
20:27 <@gpocentek> le premier exemple est justement ce qu'on veut éviter (la plupart du temps)
20:27 <@gpocentek> la conditionest *toujours* vérifiée, donc la boucle ne s'arrête jamais
20:27 <@gpocentek> c'est un des meilleurs moyen de saturer une machine :)
20:28 <@gpocentek> moyens*
20:28 <@gpocentek> ok pour while ?
20:28 < sherkin> ok
20:28 < yvan_> comment definit on la fin de boucle ?
20:28 <@gpocentek> yvan_: par l'indentation
20:29 < sebastienb> ya pas de END comme en pascal ou de }
20:29 < sherkin> on a des marques de commentaires  par blocs ?
20:29 < yvan_> ok
20:29 < sherkin> genre /* .. */
20:29 <@gpocentek> sherkin: c'est à dire ?
20:29 <@gpocentek> non
20:29 <@gpocentek> # blabla
20:29 < sherkin> ok
20:29 < sebastienb> tiens, je m'etais posé la question un jour
20:29 < VMarCV> pour plusieurs ligne c """ """
20:29 <@gpocentek> ok, je continue
20:29 -!- mode/#ubuntu-fr-classroom [+m] by gpocentek
20:30 <@gpocentek> Mais justement, pour notre application on va vouloir une telle boucle (infinie), qui demande sans cesse à l'utilisateur ce qu'il veut faire, jusqu'à ce qu'il demande d'en sortir (i.e. quitter).
20:30 <@gpocentek> C'est l'instruction break qui va nous permettre de quitter la boucle :
20:30 <@gpocentek>   i = 1
20:30 <@gpocentek>   while (i > 0):
20:30 <@gpocentek>         i = i + 1
20:30 <@gpocentek>         if i > 10:
20:30 <@gpocentek>                 break
20:30 <@gpocentek>         else:
20:30 <@gpocentek>                 print "Toujours dans la boucle"
20:30 <@gpocentek>   print "Adieu la boucle"
20:31 <@gpocentek> dès que i sera supérieur à 10, on sortira de la boucle
20:31 -!- mode/#ubuntu-fr-classroom [-m] by gpocentek
20:31 <@gpocentek> ok pour ça ?
20:31 < VMarCV> oui
20:31 < yvan_> ok
20:32 <@gpocentek> ok, petite question : Pour forcer une boucle infinie, que pourrait-on utiliser qui ne fasse pas intervenir de variable ?
20:32 < VMarCV> while 1
20:32 -!- GottferDamnt [n=teva@AMontsouris-151-1-7-58.w82-123.abo.wanadoo.fr] has joined #ubuntu-fr-classroom
20:32 < GottferDamnt> o/
20:32 <@gpocentek> VMarCV: voilà
20:32 < sebastienb> while 1: - while True:
20:33 <@gpocentek> ou toute variable non nulle ou non fausse
20:33 < ploc> genre True
20:33 <@gpocentek> donc comment est-ce que vous gèreriez votre menu avec ça ?
20:33 <@gpocentek> (en gros, pas de détails)
20:34 < ploc> si var = 0
20:34 < ploc> break
20:34 < ploc> si var = 1
20:34 < ploc> menu 1
20:34 < ploc> sinon reboucle sur le menu
20:34 <@gpocentek> ouep, et var vient d'où ?
20:34 < ploc> l'entrée utilisateur
20:34 < VMarCV> raw_input
20:35 <@gpocentek> ok, donc c'est clair pour tout le monde :)
20:35 < sherkin> while 1
20:35 < sherkin>   print "ajouter un contact\n"
20:35 < sherkin>   ...
20:35 < sherkin> print "aciao"
20:35 <@gpocentek> ok
20:35 <@gpocentek> deuxième étape alors, gérer les "duos" nom/numéro de tel
20:35 -!- mode/#ubuntu-fr-classroom [+m] by gpocentek
20:36 <@gpocentek> Il y a sans doute plusieurs façons de gérer les couples nom/n° de tel, voyons une solution qui me paraît pratique, et qui permet de découvrir un nouveau type : les dictionnaires.
20:36 <@gpocentek> Les dictionnaires sont des listes de clé/valeur, que l'ont définit comme ceci :
20:36 <@gpocentek>   dico = {1: "tada", 2: "hello", "cle": 4, "cle2": "valeur"}
20:36 <@gpocentek> notez qu'on peut mélanger les types (ici des entiers et des chaines de caractères)
20:36 <@gpocentek> Contrairement aux listes, il n'y a pas de notion d'ordre, puisque l'idée d'un dictionnaire est de proposer une correspondance clé/valeur.
20:37 <@gpocentek> On accède à une valeur par:
20:37 <@gpocentek>   dico[cle]
20:37 <@gpocentek> où cle est évidemment une des clés du dictionnaire.
20:37 -!- mode/#ubuntu-fr-classroom [-m] by gpocentek
20:37 <@gpocentek> questions ?
20:37 < VMarCV> non
20:38 < yvan_> ok
20:38 <@gpocentek> ok
20:38 < ploc> si
20:38  * gpocentek écoute ploc 
20:38 < ploc> le type des clés, c'est ce que tu veux ?
20:38 <@gpocentek> ploc: oui
20:38 < ploc> je veux dire, il peut y avoir plusisuers types dans un même dico ?
20:38 < sebastienb> ouais
20:38 < sebastienb> des ints des str
20:38 <@gpocentek> oui, c'est le cas dans mon exemple
20:38 < ploc> si oui, comment accéder au bon enregistrement ?
20:39 <@gpocentek> ploc: par la clé
20:39 < sebastienb> dico[tacle]
20:39 < ploc> dico[cle2] fonctionnera ?
20:39 < sebastienb> non
20:39 <@gpocentek> ploc: non
20:39 < sebastienb> dico["cle2"]
20:39 <@gpocentek> mais dict["cle2"] oui
20:39 <@gpocentek> dico*
20:39 < ploc> sebastienb: c'est qui le prof ?
20:39 < sebastienb> désolé
20:39 < ploc> alors il faut connaitre le type de la clé avant de pouvoir accéder à la valeur ?
20:40 <@gpocentek> ploc: il faut connaître la clé oui
20:40 < ploc> le TYPE de la clé
20:40 <@gpocentek> si tu connais la clé tu connais son type
20:40 < ploc> ok
20:40 <@gpocentek> ne confonds pas "cle2" et cle2
20:40 <@gpocentek> "cle2" c'est une chaine de caractères
20:41 < sebastienb> sauf si cle2 = "cle2"
20:41 <@gpocentek> cle2 c'est une variable, qui peut contenir ce que tu veux
20:41 <@gpocentek> sebastienb: non
20:41 -!- GottferDamnt [n=teva@AMontsouris-151-1-7-58.w82-123.abo.wanadoo.fr] has left #ubuntu-fr-classroom ["Konversation terminated!"]
20:41 <@gpocentek> "cle2" est invariable, pas cle2
20:41 <+skateinmars> sebastienb: c'est quand même pas pareil
20:41 < sebastienb> bah si c'est dans la variable ca marche
20:41 <@gpocentek> ploc: ça va la distinction valeur/variable ?
20:41 < sherkin> il retourne 'valeur' pour une clé chaine inexistante ? !!
20:41 < sebastienb> c'est ce que je voulais dire
20:41 <+skateinmars> ca marche != pareil
20:41 < sherkin> >>> dico["cle2"]
20:41 < sherkin> 'valeur'
20:42 <@gpocentek> sherkin: regarde la definition du dico
20:42 <+skateinmars> sherkin: regarde la definition du dico on lui a attribue une valeur
20:42 <@gpocentek> "cle2" est définie
20:42 < ploc> oui
20:42 < sherkin> donc on doit pouvoir tester si la clé existe ...
20:42 <@gpocentek> sherkin: exactement
20:43 <@gpocentek> je mets volontairement les tests de coté pour l'instant
20:43 <@gpocentek> ok, donc
20:43 <@gpocentek> Exercice : quelles méthodes existent pour un dictionnaire ('dict' dans le langage python) ?
20:43 <@gpocentek> (cf le début du cours)
20:44 <@gpocentek> (c'est pour voir si vous suivez :p)
20:44 <@gpocentek> ayé, je les ai perdu...
20:45 < ploc> >>> print str.__dict__
20:45 < ploc> {'upper': <method 'upper' of 'str' objects>, '__getslice__': <slot wrapper '__getslice__' of 'str' objects>, 'startswith': <method 'startswith' of 'str' objects>, 'lstrip': <method 'lstrip' of 'str' objects>, 'capitalize': <method 'capitalize' of 'str' objects>, '__str__': <slot wrapper '__str__' of 'str' objects>, '__getattribute__': <slot wrapper '__getattribute__' of 'str' objects>, 'rpartition': <method 'rpartition' of 'st
20:45 <@gpocentek> ou plus simplement dir(dict)
20:46 < ploc> tu peux rappeler la différence ?
20:46 < iladrin> j'avais suivi.  mais je reste discret   :D
20:46 <@gpocentek> ploc: l'appel à 'print' sous entend une mise en forme du résultat
20:47 < ploc> dakodak
20:47 <@gpocentek> tu as plus de détails que si tu fais simplement dir(truc)
20:47 <@gpocentek> ok
20:47 -!- mode/#ubuntu-fr-classroom [+m] by gpocentek
20:47 <@gpocentek> parmi les méthodes de dict, il y en a une intéressante : keys()
20:47 <+skateinmars> < ploc> >>> print str.__dict__ << on demandait les dict ;)
20:47 <@gpocentek> ah oui tiens
20:48 -!- vieuxmike [n=michael@ero34-1-88-161-77-35.fbx.proxad.net] has joined #ubuntu-fr-classroom
20:48 <@gpocentek> c'est donc bien dir(dict)
20:48 <@gpocentek> pour en revenir à keys()
20:48 <@gpocentek> cette méthode permet d'obtenir une liste de toutes les clés du dictionnaire :
20:48 <@gpocentek>   dico.keys()
20:49 -!- mode/#ubuntu-fr-classroom [-m] by gpocentek
20:49 <@gpocentek> ok ça ?
20:49 < sebastienb> pratique
20:49 -!- eolhyt1 [n=eolhyte@41.251.64.29] has joined #ubuntu-fr-classroom
20:49 < moft> dico.keys() ça retourne quoi comme type de variable ?
20:49 <@gpocentek> >>> dico.keys()
20:49 <@gpocentek> ['cle2', 1, 2, 'cle']
20:49 < sherkin> dico.has_key("rien")
20:49 < eolhyt1> Hello
20:50 <@gpocentek> moft: ça retourne une liste
20:50 <@gpocentek> >> foo = dico.keys()
20:50 <@gpocentek> >>> foo
20:50 <@gpocentek> ['cle2', 1, 2, 'cle']
20:50 < moft> gpocentek: ok
20:50 <@gpocentek> comme on a une liste, on va pouvoir la parcourir
20:50 <@gpocentek> pour lister tous les couples on peut utiliser :
20:51 <@gpocentek>   for key in dico.keys():
20:51 <@gpocentek>         print key, dico[key]
20:51 <@gpocentek> (cf cours de la semaine dernière, parcourir tous les éléments d'une liste)
20:51 <@gpocentek> ok ça ?
20:52 <@gpocentek> ou est-ce qu'il faut que je revienne sur 'for' ?
20:52 <+skateinmars> ok ici :)
20:52 <@gpocentek> vous voyez que la syntaxe est proche de la langue parlée en fait
20:52 <@gpocentek> le choix des noms
20:53 <@gpocentek> on pourrait traduire "pour chaque clé dans le liste des clés de dico: afficher clé, et valeur de clé"
20:53 -!- Julia1 [n=julian@user-85-201-64-130.tvcablenet.be] has joined #ubuntu-fr-classroom
20:53 <@gpocentek> ça aide souvent de penser en "pseudo code", nottamment pour des algorythmes complexes
20:54 <@gpocentek> dites moi si ça va ou pas, je me sens seul là 
20:54 <@gpocentek> (skateinmars triche il connait déjà ;) )
20:54 < yvan_> ok
20:54 < ploc> ca va ca va, on écoute religieusement ;-)
20:54 <+skateinmars> """"même pas vrai :p"""
20:55 <@gpocentek> hehe
20:55 < sherkin> ok
20:55 <@gpocentek> ok
20:55 -!- mode/#ubuntu-fr-classroom [+m] by gpocentek
20:55 <@gpocentek> pour accéder à une clé, il faut qu'elle existe
20:55 <@gpocentek> essayez par exemple
20:55 <@gpocentek>   dico["scoubidou"] # ou autre ;)
20:56 <@gpocentek> et python vous ralera dessus
20:56 <@gpocentek> avat d'essayer d'accéder à une clé, il faut donc vérifier qu'elle existe :
20:56 -!- kagou [n=kagou@92.127.119-80.rev.gaoland.net] has joined #ubuntu-fr-classroom
20:56 <@gpocentek>   if dico.has_key("truc"):
20:56 <@gpocentek>     print dico["truc"]
20:56 <@gpocentek>   else:
20:56 <@gpocentek>     print "perdu"
20:57 -!- hype_ [n=hype_@gar31-3-82-234-50-53.fbx.proxad.net] has joined #ubuntu-fr-classroom
20:57 -!- mode/#ubuntu-fr-classroom [-m] by gpocentek
20:57 <@gpocentek> ok pour ça ?
20:57 < ploc> petite question hs : comment faire un affichage avec retour à la ligne, dans raw_input ?
20:57 <+skateinmars> "truc" in dico # et ca :]
20:57 <@gpocentek> ploc: en utilisant '\n' pour remplacer le saut de ligne
20:58 <@gpocentek> skateinmars vous propose une autre technique de test
20:58 <@gpocentek> de manière générale, il ne faut pas s'aventurer à assumer que quelque chose existe
20:58 <@gpocentek> mais tester l'existance pour pouvoir réagir ensuite
20:59 <@gpocentek> ok ?
20:59 < VMarCV> ok
20:59 <@gpocentek> passons à une étape suivante alors
20:59 <@gpocentek> encore une fois, je vous donne des pistes pour le futur programme, à vous de l'écrire comme vous voulez
21:00 <@gpocentek> (il n'y a pas qu'une solution)
21:00 -!- mode/#ubuntu-fr-classroom [+m] by gpocentek
21:00 <@gpocentek> Une étape important : organiser le code
21:00 <@gpocentek> en utilisant des fonctions !
21:00 <@gpocentek> on en a parlé la dernière fois mais je voudrais apporter quelques précisions
21:01 <@gpocentek> Un mot sur la portée des variables d'abord.
21:01 <@gpocentek> Chaque variable déclarée a une portée, c'est à dire qu'elle n'est valable que dans le bloc courant (et les sous blocs). Par exmple :
21:01 -!- marseillai [n=mars@ubuntu/member/marseillai] has quit [Remote closed the connection]
21:01 <@gpocentek>   def foo():
21:01 <@gpocentek>         a = 5
21:01 <@gpocentek>   a = 4
21:01 <@gpocentek>   foo()   # à priori on change la valeur
21:01 <@gpocentek>   print a # mais non !
21:01 -!- mode/#ubuntu-fr-classroom [-m] by gpocentek
21:02 <@gpocentek> essayer ce bout de code dans un script
21:02 <@gpocentek> le résultat attendu du "print a" est à priori 5, puisque modifié dans l'appel à foo(), mais...
21:03 <@gpocentek> dans la fonction, la variable 'a' n'est pas la même que dans le corps du programme
21:03 <@gpocentek> donc les deux valeurs ne s'écrasent pas l'une l'autre
21:03 <@gpocentek> est-ce que c'est clair pour tout le monde ça ?
21:04 < VMarCV> oui
21:04 < ploc> c'est 2 variables différentes quoi !
21:04 < sherkin> limpide :)
21:04 <@gpocentek> ok
21:05 <@gpocentek> c'est pas forcément facile à comprendre, mais vous êtes très forts donc c'est bon :)
21:05 <@gpocentek> maintenant, on peut vouloir utiliser une variable définie dans le corps du programme dans une fonction
21:05 <@gpocentek> dans ce cas là on utilise l'intruction 'global' :
21:05 <@gpocentek>   def foo():
21:05 <@gpocentek>       globla a
21:05 <@gpocentek>       a = 5
21:05 <@gpocentek>   a = 4
21:05 <@gpocentek>   foo()   #
21:05 <@gpocentek>   print a # on a vraiment changé la valeur cette fois ci
21:05 < sherkin> :(
21:06 < sherkin> pas glop globals
21:06 <+skateinmars>  <@gpocentek>       globla a << gafe
21:06 <+skateinmars> *gaffe
21:06 < vieuxmike> on peut definir des variables locales u globales?
21:06 <@gpocentek> dans foo, on prévient avec "global a" qu'on veut récupérer le 'a' qu'on a utilisé ailleurs
21:06 < vieuxmike> soit c'est local : dans une fonction...
21:06 <@gpocentek> "global" , pas "globla", désolé (encore)
21:06 < vieuxmike> soit c'est global : dans le programme
21:07 < vieuxmike> c'est ca?
21:07 < ploc> et gloubi bouloga ?
21:07 <@gpocentek> vieuxmike: c'est global dans le programme, et dans une fonction on peut choisir d'avoir le même nom
21:07 <@gpocentek> mais soit global, soit local
21:07 <@gpocentek> (c'est pas clair du tout cette phrase)
21:07 < vieuxmike> en gros une variable globale sera reutilisee dans toute les fonction
21:08 <@gpocentek> vieuxmike: oui, mais il faut le préciser
21:08 < vieuxmike> si on definit un 'a' global et qu'on utilise une variable 'a' dans une fonction
21:08 < vieuxmike> ce 'a' de la fonction sera le 'a' global
21:08 < ploc> >python exemple4.py
21:08 < ploc>   File "exemple4.py", line 13
21:08 < ploc>     global dico
21:08 < ploc>          ^
21:08 < ploc> SyntaxError: invalid syntax
21:08 <+skateinmars> vieuxmike: le global se definit dans une fonction, pas en dehors
21:09 -!- ptitgui [n=ptitgui@bro29-2-88-164-249-78.fbx.proxad.net] has joined #ubuntu-fr-classroom
21:09 < vieuxmike> ah
21:09 < sherkin> a definie globale dans une fonction, et devient globale dans toutes les autres fonctions ??
21:09 < vieuxmike> e reverrai le cours de la semaine derniere :-)
21:09 < vieuxmike> :-p
21:09 <+skateinmars> sherkin: non non "global" s'utilise dans une fonction et prend effet sur cette fonction la pas sur les autres
21:09 < ploc> gpocentek: j'ai merdé (cf l'extrait de ma console)
21:09 < sherkin> ouf :)
21:09 <@gpocentek> sherkin: non, dans cette fonction là seulement
21:09 <+skateinmars> ploc: tu as mis ca en dehors dune fonction ?
21:09 <@gpocentek> ploc: ok :)
21:09 < ptitgui> est ce que quelqu'un connais un liveusb pour faire des clones disque ?
21:10 < sherkin> j'avais mal compris
21:10  * gpocentek a eu un moment de doute 
21:10 < ploc> non, dans une fonction rechercher
21:10 <@gpocentek> ok pour local/global ?
21:10 < ploc> ptitgui: c'est un cours de python, tu te trompes de canal
21:10 <@gpocentek> ok, je continue
21:10 -!- mode/#ubuntu-fr-classroom [+m] by gpocentek
21:11 <@gpocentek> Pour notre programme, on peut choisir de définir le dictionnaire qui contiendra nos valeurs comme variable globale, qui sera accessible dans toutes les fonctions du programme.
21:11 <@gpocentek> Bien évidemment il est plus que conseillé de définir des fonctions qui exécuteront telle ou telle action du programme, par exemple:
21:11 <@gpocentek>   def del_item(nom):
21:11 <@gpocentek>     # blabla
21:11 <@gpocentek>   def add_item(nom, no_tel, confirm=True):
21:11 <@gpocentek>     # bla bla
21:11 <@gpocentek> Notez que la fonction add_item prend 3 arguments dont 2 obligatoires (les 2 premiers).
21:12 <@gpocentek> Si le 3ème argument n'est pas donné, python utilisera une valeur par défaut pour la variable ('True' dans notre cas). 
21:12 <@gpocentek> Lors des appels à la fonction, les arguments doivent être donnés dans l'ordre trouvé dans la déclaration.
21:12 <@gpocentek> par exemple
21:12 <@gpocentek>   add_item("gustave", "0123456", False)
21:12 -!- mode/#ubuntu-fr-classroom [-m] by gpocentek
21:12 <@gpocentek> ok pour les arguments optionels ?
21:13 <@gpocentek> on peut en définir plusieurs bien sûr
21:13 -!- SunWukongFR [n=stephan@pra13-2-82-235-212-185.fbx.proxad.net] has quit ["I'm leaving now because I've to."]
21:13 < ploc> pourquoi j'ai une erreurok
21:13 < ploc> ok
21:13 -!- cedric_b [n=cedric@ANantes-251-1-34-248.w81-250.abo.wanadoo.fr] has joined #ubuntu-fr-classroom
21:13 <@gpocentek> ok
21:13 -!- mode/#ubuntu-fr-classroom [+m] by gpocentek
21:14 <@gpocentek> Pour documenter vos fonctions, vous pouvez définir une "docstring", c'est à dire le texte qui sera accessible par l'appel à 'fonction.__doc__' :
21:14 -!- Dr`Maison [n=fred@chy02-1-88-176-124-69.fbx.proxad.net] has quit [Client Quit]
21:14 <@gpocentek>   def une_fonction():
21:14 <@gpocentek>     """une_fonction ne fait rien
21:14 <@gpocentek>     Cette fonction ne fait rien, et ne prend pas d'argument
21:14 <@gpocentek>     """
21:14 <@gpocentek>     pass
21:14 <@gpocentek> utiliser 3 " permet d'avoir du texte sur plusieurs lignes
21:15 <@gpocentek> c'est valable aussi pour toutes les chaines de caractères
21:15 <@gpocentek> Le mot clé 'pass' permet de ne rien faire (python oblige à avoir une commande dans un bloc).
21:15 -!- mode/#ubuntu-fr-classroom [-m] by gpocentek
21:15 <@gpocentek> est-ce clair ?
21:15 < sherkin> oui
21:15 <+skateinmars> gpocentek: il y a des parseurs ala phpdoc ? pour mettre genre @return dans la doc ?
21:15 <@gpocentek> vous pourrez accéder au docstring de votre fonction par une_fonction.__doc__
21:15 -!- eolhyt1 [n=eolhyte@41.251.64.29] has left #ubuntu-fr-classroom []
21:16 <@gpocentek> skateinmars: ça existe, mais j'avoue que je ne m'en suis jamais servi
21:16 <@gpocentek> donc je pourrai pas m'étendre là dessus...
21:16 <+skateinmars> ok
21:16 <@gpocentek> Une bonne idée pour construire votre script est de définir les divers opérations qu'il sera amené à faire, et de définir les fonctions en conséquences (leur nom, leurs arguments, leur valeur de retour).
21:17 <@gpocentek> j'en ai pas parlé mais essayez toujours d'utiliser des variables au nom explicite
21:17 <@gpocentek> idem pour les fonctions
21:17 <@gpocentek> si vous reprenez un bout de code 6 mois après l'avoir écrit, il faut être capable de comprendre ce qu'il fait assez vite
21:18 <@gpocentek> def f3(a, b, c=1): # a proscrire !
21:18 < sebastienb> idem si vous voulez faire lire votre code
21:18 <@gpocentek> voilà
21:18 <@gpocentek> ok pour ces petites précisions sur les fonctions ?
21:18 < ploc> oui mais
21:19 <@gpocentek> mais ?
21:19 < ploc> j'ai toujours une erreur dans mon script : if dico.has_key("searchValue"): (erreur de syntaxe)
21:19 <@gpocentek> ploc: tu peux pastebiner ton script ?
21:19 -!- Waraba [n=wara@217.64.98.242] has quit [Connection timed out]
21:20 <@gpocentek> s'il y a des questions sur d'autres choses profitez en (avant qu'on voit la lecture/ecriture des fichiers)
21:20 < ploc> http://pastebin.ca/747092
21:20 <+skateinmars> (http://paste.dunnewind.net)
21:20 -!- Julia1 [n=julian@user-85-201-64-130.tvcablenet.be] has left #ubuntu-fr-classroom []
21:20 <+Sp4rKy> skateinmars: han ce faux hl :)
21:20 <@gpocentek> ploc: il te manque un parenthèse ligne 2
21:21 <@gpocentek> je vais en profiter pour commenter un peu ta fonction
21:21 <+skateinmars> if dico.has_key("searchValue"): << ploc attention la tu ne fais pas reference a searchValue
21:21 < ploc> si vous avez une erreur ligne x, cherchez l'erreur ligne x-1 ! ;-) merci
21:21 <+skateinmars> (enfin je me tais et laisse faire gpocentek :) )
21:22 <@gpocentek> ploc: voilà, skateinmars te montre un problème
21:22 <@gpocentek> tu as confondu une valeur "searchValue", et une variable serchValue
21:22 <@gpocentek> searchValue entre "" devient une chaine de caractères, et perd son sens de variable
21:22 < sebastienb> [21:16:48] <gpocentek> j'en ai pas parlé mais essayez toujours d'utiliser des variables au nom explicite >> tu pourrais rappeller les conventions ?je pense que ca serait pratique
21:22 < ploc> ok, et je convertis en int, ce qui est inutile (copier coller de la semaine dernière
21:23 <@gpocentek> ploc: pourquoi convertir en int ?
21:23 <@gpocentek> le nom ce sera pas un entier à priori
21:24 <@gpocentek> ploc: est-ce que tu vois la différence entre variable et valeur ?
21:24 <+skateinmars> gpocentek: c'est ce qu'il vient de dire :) (il a du c/c un truc sur les listes)
21:24 -!- yvan_ [n=yvan@77-56-134-122.dclient.hispeed.ch] has quit ["Ex-Chat"]
21:24 <@gpocentek> oops
21:24 <@gpocentek> dsl j'ai mal lu
21:25 <@gpocentek> donc c'est bon :)
21:25 <@gpocentek> une autre remarque que je voulais faire c'est la pertinence d'avoir le raw_input à l'intérieur de la fonction
21:25 < ploc> gpocentek: oui oui
21:25 <@gpocentek> bien sûr tout dépend de ce que vous voulez faire, mais...
21:26 <@gpocentek> dans ce cas autant passer la valeur du résultat de raw_input en argument
21:26 <@gpocentek> ça permettra d'utiliser cette fonction dans un autre contexte
21:26 <@gpocentek> ok ?
21:26 < ploc> oui c'est vrai
21:27 <@gpocentek> ok, alors dernière étape pour ce soir, les fichiers
21:27 -!- mode/#ubuntu-fr-classroom [+m] by gpocentek
21:27 <@gpocentek> Pour sauvegarder vos données, on peut simplement écrire le dictionnaire que vous aurez créé dans un fichier.
21:27 <@gpocentek> Il existe des méthodes pour écrire le dictionnaire en soit dans des fichiers, mais voyons une méthode plus primaire.
21:28 <@gpocentek> Lire et écrire des fichiers est de toute manière quelque chose que vous aurez à faire presque constamment.
21:28 <@gpocentek> Un fichier s'ouvre avec l'instruction 'open', qui prend en argument le chemin/nom du fichier, et le méthode d'ouverture (lecture, écriture, ajout).
21:28 <@gpocentek> Cette instruction retourne un objet, descripteur de fichier :
21:28 <@gpocentek>   f = open("/home/gauvain/python.txt", "w")
21:28 <@gpocentek> le chemin peut être absolu ou relatif
21:28 -!- sanguinarius [n=sanguina@AMontsouris-152-1-51-52.w83-202.abo.wanadoo.fr] has joined #ubuntu-fr-classroom
21:29 <@gpocentek> f est le descripteur du fichier, ouvert en écriture.
21:29 <@gpocentek>  On aurait utilisé "r" pour une simple lecture, "a" pour de l'ajout. "w" écrase complètement le fichier.
21:29 -!- mode/#ubuntu-fr-classroom [-m] by gpocentek
21:29 <@gpocentek> ok jusque là ?
21:29 < VMarCV> oui
21:29 -!- shiva [n=shiva@guy78-5-82-247-56-86.fbx.proxad.net] has quit ["Quitte"]
21:30 <@gpocentek> faites bien attention au "w", ça vide totalement le fichier...
21:30 -!- mode/#ubuntu-fr-classroom [+m] by gpocentek
21:30 <@gpocentek> Pour ajouter du texte dans ce fichier, il suffit simplement d'utiliser la méthode write : f.write("J'écris une ligne dans le fichier\n")
21:30 <@gpocentek>   f.write("J'écris une ligne dans le fichier\n")
21:31 <@gpocentek> Le '\n' final correspond à un saut de ligne (sous unix)
21:31 <@gpocentek> Une fois le fichier rempli avec ce que vous voulez, il faut le fermer :
21:31 <@gpocentek>   f.close()
21:31 -!- mode/#ubuntu-fr-classroom [-m] by gpocentek
21:31 <@gpocentek> en fait on écrit dans un fichier comme on écrit à l'écran (avec write au lieu de print)
21:32 <@gpocentek> ok pour ça ?
21:32 < sherkin> on peut "sérialiser" notre dico ?
21:32 <@gpocentek> sherkin: j'y viens après
21:33 < sherkin> ok
21:33 <@gpocentek> de suite même
21:33 -!- mode/#ubuntu-fr-classroom [+m] by gpocentek
21:33 <@gpocentek> Pour sauver notre dictionnaire, on peut tout à fait imaginer une boucle qui lit toutes les entrées du dictionnaire, et qui à chaque fois écrit une ligne du type :
21:33 <@gpocentek>   nom prénom:014546474849
21:33 -!- mode/#ubuntu-fr-classroom [-m] by gpocentek
21:33 <@gpocentek> sherkin: c'est ça que tu appelles sérialiser ?
21:34 < sherkin> je pensais à éviter de réinventer la roue ;)
21:34 <@gpocentek> tu pensais à quoi ?
21:34 <@gpocentek> je vois pas trop en fait
21:35 < sherkin> sauvegarde sous un format "binaire" ou rechargeable par une seule fonction
21:35 < sherkin> comme en perl
21:35 <@gpocentek> Tie::File ? :)
21:35 < ploc> avec write, on peut utilise %s et le séparateur virgule, comme avec print
21:35 <@gpocentek> ploc: tout à fait
21:35 -!- jnjb [n=nico@dyn-88-122-227-231.ppp.tiscali.fr] has joined #ubuntu-fr-classroom
21:35 <@gpocentek> enfin pas la ',' comme pour print
21:36 < sherkin> zut j'ai oublié le nom exact ... je cherche
21:36 <@gpocentek> mais le %s oui
21:36 < ploc> f.write("|", key, ">", dico[key], "|\n")
21:36 < ploc> TypeError: function takes exactly 1 argument (5 given)
21:36 < ploc> en effet
21:36 <@gpocentek> sherkin: il y a des modules pour ça, mais justement je préférais voir la méthode "brute"
21:36 <@gpocentek> ploc: + à la place des virgules
21:36 < sherkin> ok
21:36 <@gpocentek> je continue
21:37 -!- mode/#ubuntu-fr-classroom [+m] by gpocentek
21:37 <@gpocentek> donc
21:37 <@gpocentek> Les : nous permettrons de distinguer le nom du numéro de téléphone lors de la lecture de ce fichier.
21:37 <@gpocentek> C'est la méthode readlines que nous allons utiliser pour lire ce fichier.
21:37 <@gpocentek> readlines (à ne pas confondre avec readline, sans s) permet de lire l'entièreté du fichier, ligne par ligne, et de stocker chaque ligne dans une liste :
21:37 <@gpocentek>   lignes = f.readlines()
21:38 <@gpocentek> (la méthode readline lit le fichier ligne par ligne, mais retourne uniquement 1 ligne)
21:38 <@gpocentek> Chaque ligne peut alors être utilisée en parcourant la liste :
21:38 <@gpocentek>   for ligne in lignes:
21:38 <@gpocentek>         print ligne
21:38 <@gpocentek> ou
21:38 <@gpocentek>   for ligne in f.readlines():
21:38 <@gpocentek> directement
21:38 -!- mode/#ubuntu-fr-classroom [-m] by gpocentek
21:39 <@gpocentek> ok pour la lecture ligne par ligne ?
21:39 < VMarCV> ok
21:39 -!- saucisson_ [n=viking@ANice-151-1-9-50.w83-113.abo.wanadoo.fr] has joined #ubuntu-fr-classroom
21:39 <@gpocentek> on peut évidemment lire caractère par caractère, ou par bloc de caractères
21:39 < sherkin> ok
21:39 <@gpocentek> (avec la méthode read)
21:39 < termitor> ah , j'ai encore manque un cours python, bien le bonjour tous le monde
21:39 <@gpocentek> mais peu importe pour nous
21:39 -!- mode/#ubuntu-fr-classroom [+m] by gpocentek
21:40 <@gpocentek> Pour notre exemple, il nous reste à diviser notre ligne en deux, d'un côté des : le nom, de l'autre le numéro de téléphone.
21:40 <@gpocentek> Une méthode du type str (chaîne de caractères) permet ça, 'split' :
21:40 <@gpocentek>   tab = line.split(":")
21:40 <@gpocentek> (s/line/ligne/)
21:40 <@gpocentek> La valeur de retour est une séquence, qui contient chacun des éléments de l'explosion de la chaîne de caractère suivant les ':'.
21:41 <@gpocentek> Donc si ligne = "tagada:012345678", on aura tab = ["tagada", "012345678"].
21:41 -!- mode/#ubuntu-fr-classroom [-m] by gpocentek
21:41 <@gpocentek> ok pour ça ?
21:41 < jnjb> salut
21:41 <@gpocentek> ensuite vous pouvez remplir votre dictionnaire :
21:41 <@gpocentek>   dico[tab[0]] = tab[1]
21:42 <@gpocentek> et vous récupèrerez toutes vos données contenues dans le fichier
21:42 <@gpocentek> (arf j'en dis trop, ça va être trop facile de faire le programme)
21:42 -!- davro [n=cyril@217.128.111.160] has joined #ubuntu-fr-classroom
21:42 <@gpocentek> ok pour tout le monde ?
21:42  * sherkin c/c
21:43 < VMarCV> oui
21:43 <@gpocentek> ok
21:43 -!- davromaniak [n=cyril@ubuntu/member/davromaniak] has quit [Nick collision from services.]
21:43 -!- davro is now known as davromaniak
21:43 <@gpocentek> alors je vous propose d'en rester là pour le cours de ce soir
21:43 <@gpocentek> et de vous amuser à coder ce petit programme :)
21:44 < ploc> gpocentek: pas si facile d'écrire le programme, tu laisses des coquilles ;-)
21:44 -!- hype_ [n=hype_@gar31-3-82-234-50-53.fbx.proxad.net] has quit ["Don't follow me"]
21:44 <@gpocentek> ploc: justement, c'est marrant
21:44 <@gpocentek> ;)
21:44 < sherkin> tu veux des copies à corriger pour la semaine prochaine ?
21:44 < vieuxmike> quand est ce que le cours sera mis en ligne pour ceux qui sont arrives apres la sonnerie?
21:44 <@gpocentek> sherkin: je "veux" pas, mais si vous voulez que je regarde, c'est avec plaisir
21:44 <@gpocentek> vieuxmike: je vais essayer de faire ça d'ici la fin de semaine
21:45 < vieuxmike> meric ;-)
21:45 <+skateinmars> vieuxmike: les logs bruts sont deja dispos
21:45 < sherkin> trop sympa :-)
21:45 < vieuxmike> "les logs brut" ??O_O??
21:45 < ploc> brutes ?
21:45 <@gpocentek> si vous avez des questions en cours de route, passez par le chan, y'a quelques pythoneux
21:45 <@gpocentek> vieuxmike: http://gauvain.pocentek.net/python-2007-10-23
21:45 <+skateinmars> vieuxmike: bah c'est le nom hein ;)
21:45 < vieuxmike> merci
21:46 < ploc> NameError: global name 'dico' is not defined
21:46 < ploc> comment faire pour que dico soit global ?
21:46 <@gpocentek> le définir ?
21:46 <+skateinmars> en dehors d'une fonction
21:46 <+skateinmars> -"? "
21:46 < ploc> mais il est vide tant que je le remplis pas à partir du fichier...
21:46 <@gpocentek> niveau calendrier le prochain cours est pas encore planifié
21:47 <+skateinmars> ploc: dico = {} et tu as un dico
21:47 < VMarCV> ça sera sur quoi
21:47 < sherkin> on poste où nos oeuvres ?
21:47 <@gpocentek> skateinmars nous fera l'honneur d'un cours sur les serveurs web "alternatifs" courant de la semaine prochaine
21:47 <+skateinmars> uniquement si Sp4rKy se bouge :]
21:47 -!- davromaniak [n=cyril@ubuntu/member/davromaniak] has quit [Read error: 104 (Connection reset by peer)]
21:47 <@gpocentek> sherkin: passe par ici, ou envoie par mail
21:47 < ploc> skateinmars: genre ?
21:47 -!- davromaniak [n=cyril@ubuntu/member/davromaniak] has joined #ubuntu-fr-classroom
21:47 <+skateinmars> ploc: ?
21:47 <@gpocentek> VMarCV: programmation orientée objet la prochaine fois
21:48 < ploc> quels serveurs ?
21:48 < VMarCV> ok
21:48 <+skateinmars> ploc: apache un pe uavancé, nginx, et lighttpd avec Sp4rKy
21:48 <@gpocentek> ce sera pas avant 2 ou 3 semaines
21:49 < VMarCV> ok
21:49 <@gpocentek> ce sera annoncé sur le planet de toute façon :)
21:49 < VMarCV> comme d'hab
21:49 <@gpocentek> ouep
--- Log closed Tue Oct 23 21:49:55 2007