[ gpocentek] encore 2 minutes pour voir si ça bouge sur #u-fr et c'est parti :)
[ Dohko_] ok :)
[ yannick_lm] bienvnue
[ paulska] Bonsoir
[ gpocentek] hello paulska
[ Dohko_] salut
[ gpocentek] hop allons y
[ yannick_lm] c'est parti
[ gpocentek] comme y'a pas grand monde hésitez pas pour les questions, je pourrai faire des petits rappels
[ gpocentek] Ok
[ gpocentek] donc ce soir je voulais aborder la programmation orientée objet, et un peu plus généralement l'organisation de programme python
[ gpocentek] Je vais donc commencer par dire un mot sur les modules, que je n'ai pas vraiment abordé aux cours précédents
[ gpocentek] Python n'est pas un bloc monolithique, mais est composé de modules. Ces modules peuvent être importés dans les scripts avec l'instruction 'import'.
[ gpocentek] Par exemple:
[ gpocentek] import sys, os
[ gpocentek] Ceci importera les modules 'sys' et 'os' (deux modules très utiles). Toutes les variables/fonctions/classes/etc que contiennent ces modules seront alors accessibles dans le script.
[ gpocentek] Dans le script, on appelle les éléments de ces modules (constantes, fonction) en faisant précéder leur nom par le nom du module et un '.':
[ gpocentek] os.listdir("/")
[ gpocentek] os.path.isdir("/bin")
[ gpocentek] sys.path
[ gpocentek] vous pouvez lancer un shell python et lancer toutes ces commandes
[ gpocentek] histoire de voir ce que ça donne
[ yannick_lm] ça marche
[ yannick_lm] un joli vecteur avec le résultat de ls
[ Dohko_] nickel
[ gpocentek] ok
[ gpocentek] La variable sys.path donne des informations importantes pour l'inclusion.
[ gpocentek] En effet, python doit savoir où se trouvent les modules à importer, et la variable sys.path fournit une liste des emplacements où python cherchera les modules. On peut bien sûr compléter la liste pour ajouter un chemin particulier.
[ gpocentek] oui ?
[ Dohko_] ok et tu ajoutes comment au path ?
[ yannick_lm] sous windows, les fonctions de os. marchent pareil ?
[ gpocentek] (le mode +m fait des siennes)
[ gpocentek] alors
[ gpocentek] yannick_lm: oui, ça prend en compte les différences des systèmes et ça adapte les résultats
[ yannick_lm] ok
[ gpocentek] Dohko_: sys.path.append("/un/chemin/")
[ gpocentek] c'est une simple liste
[ gpocentek] append ajoute un élément à la liste
[ gpocentek] (cf les cours précédents)
[ Dohko_] on peut appender une liste à cette liste directement ?
[ effraie] plop (/me s'installe au fond)
[ gpocentek] hello effraie
[ gpocentek] Dohko_: à priori oui
[ Dohko_] ok :)
[ paulska] Salut
[ gpocentek] ok
[ gpocentek] Il arrive qu'on ait besoin que d'un simple élément dans un module. Par exemple la fonction 'exit' du module 'sys'. Avec un import standard on aurait par exemple :
[ gpocentek] import sys
[ gpocentek] sys.exit(0)
[ gpocentek] On peut aussi utiliser :
[ gpocentek] from sys import exit
[ gpocentek] exit(0)
[ gpocentek] Ca permet d'alléger l'écriture
[ gpocentek] On peut même donner le nom que l'on veut au module importé :
[ gpocentek] from os import path as p
[ gpocentek] p.join("hello", "world")
[ yannick_lm] ah bien
[ gpocentek] (je vous laisse tester tout ça dans le shell)
[ gpocentek] ça marche ?
[ Dohko_] par contre on ne peut pas faire appel directement au module sans import c'est bien ça ?
[ yannick_lm] yep
[ paulska] Oui oui
[ gpocentek] Dohko_: c'est ça
[ Dohko_] ok alors c'est tout bon
[ gpocentek] si le module est pas importé python saura pas de quoi tu parles
[ gpocentek] On peut également importer plusieurs élément d'un module en les séparant par une virgule :
[ gpocentek] from os import listdir, path
[ gpocentek] par convention c'est ce qui est fait
[ gpocentek] même si on peut utiliser plusieurs syntaxe
[ gpocentek] on peut également importer tous les éléments d'un module :
[ gpocentek] from os import *
[ gpocentek] c'est clair pour tout le monde ça ?
[ Dohko_] ce qui est équivalent à "import os" ?
[ gpocentek] Dohko_: presque mais pas tout à fait
[ gpocentek] import os te fera utiliser os.path
[ gpocentek] alors que from os import * te permettra d'utiliser juste 'path'
[ Dohko_] compris
[ yannick_lm] ok
[ gpocentek] c'est l'espace de nommage qui est sous entendu
[ yannick_lm] euh "espace de nommage" ?
[ gpocentek] yannick_lm: oui, j'explique
[ gpocentek] quand tu accède aux éléments de os, tu appèle "os.path"
[ gpocentek] path est dans l'espace de nommage de 'os'
[ yannick_lm] c'est la liste des fonctions, en gros ?
[ gpocentek] en utilisant le "from os import" tu sous-entend que l'espace de nommage est os, et tu n'as plus besoin de le préciser
[ gpocentek] oui
[ yannick_lm] ok
[ gpocentek] donc, passons à plus intéressant, les classes
[ gpocentek] est-ce que vous êtes familiers avec la programmation orientée objet ?
[ yannick_lm] java ...
[ paulska] Un petit peu
[ gpocentek] ok
[ Dohko_] oui, Java, Ruby
[ illovae] bonsoir
[ yannick_lm] bonsoir illovae
[ gpocentek] j'ai une petite intro, je vous la copie quand même ;)
[ gapz] 'soir illovae, effraie et les autres :)
[ paulska] Salut
[ Dohko_] bonsoir :)
[ gpocentek] La programmation orientée objet est un moyen efficace d'organiser son code. On a déjà utilisé des objets dans les cours précédents (les chaînes de caractère par exemple). Tout est objet en Python.
[ gpocentek] Un objet est aussi appelé une 'instance de classe'.
[ gpocentek] Une classe est en fait la description générique d'un objet. Elle décrit les variables et les fonctions qui lui sont associées.
[ gpocentek] Une classe se définit grâce au mot clé 'class' :
[ gpocentek] class Pouet:
[ gpocentek] variable1 = 1
[ gpocentek] variable2 = 2
[ gpocentek] def get_vars(self):
[ gpocentek] return (variable1, variable2)
[ gpocentek] voilà une définition de classe
[ gpocentek] comme d'habitude c'est l'indentation qui fait office de blocs
[ gpocentek] Pour créer une instance de cette classe (un objet), on utilise la syntaxe suivante :
[ gpocentek] pouet = Pouet() print pouet.get_vars()
[ gpocentek] hum
[ gpocentek] pouet = Pouet()
[ gpocentek] print pouet.get_vars()
[ gpocentek] la première ligne va créer notre objet
[ gpocentek] la seconde est un appel à la méthode 'get_vars' de l'objet 'pouet'
[ gpocentek] (désolé pour les noms ;) )
[ gpocentek] Même s'il n'existe pas de règle, les noms de classes commencent en général par une majuscule. Les objets étant un type de variables, ils sont nommés en utilisant uniquement des minuscules.
[ gpocentek] est-ce que c'est clair tout ça ?
[ Dohko_] oui
[ illovae] ouai à peu près
[ paulska] Oui
[ gpocentek] illovae: hésite pas si t'as des questions
[ illovae] bah j'imagine que ça viendra plus tard (l'histoire de get_vars toussa == me = noob de première)
[ gapz] :)
[ gpocentek] illovae: c'est juste un exemple bateau
[ illovae] oui :)
[ gapz] l'important c'est de faire les exemples illovae ;)
[ illovae] gapz: arf c'est vrai
[ gpocentek] dans la définition de la classe on écrit une méthode (fonction) quelconque
[ gpocentek] je vais continuer et on reagrdera une classe entière
[ gapz] en plus, tu vas aimer les class de gpocentek (quoi ? j'annonce déja la fin :P)
[ illovae] classroom* ?
[ gpocentek] vous pouvez récupérer le fichier qui la contient : http://gauvain.pocentek.net/tmp/pouet.py
[ illovae] fait
[ gpocentek] vous avez récupérer le fichier ?
[ Dohko_] oui
[ gpocentek] récupéré* pardon
[ gpocentek] ok
[ gpocentek] vous pouvez y jeter un oeil, on va détailler
[ gpocentek] vous voyez que j'y défini 3 classes
[ gpocentek] qu'on va regarder dans le détail
[ gpocentek] on commence avec 'Pouet'
[ gpocentek] Dans la définition de classe ,chaque variable et méthode de l'objet doit être utilisée avec le mot clef 'self'. Pour toutes les méthodes, le premier argument est 'self' dans la déclaration de cette méthode, mais il est omis lors de l'appel.
[ Dohko_] ok
[ gpocentek] regarde la classe Pouet de tout à l'heure (pas celle du fichier)
[ gpocentek] def get_vars(self):
[ gpocentek] regardez*
[ gpocentek] elle prend un argument, 'self'
[ gpocentek] self représente l'objet lui même
[ Dohko_] si il n'y a pas ce self, c'est une méthode statique ?
[ gpocentek] et vous remarquez que lors de l'appel de la méthode, il n'y a pas de self
[ gpocentek] print pouet.get_vars()
[ gpocentek] Dohko_: une méthode sans self en python c'est une erreur plutôt ;)
[ gapz] pour faire une methode static fait rajouter des trucs du style @static
[ Dohko_] ok :)
[ gpocentek] en fait dès qu'on appelle une méthode, python passe l'objet en question comme premier argument
[ gpocentek] Dohko_: ça dépasse le cours en fait, mais gapz se fera une joie de t'en dire plus
[ gpocentek] ok donc
[ gpocentek] est-ce que l'histoire du 'self' vous parait claire ?
[ Dohko_] oui
[ yannick_lm] c'est bon pour moi
[ paulska] Oui oui
[ gpocentek] illovae: ?
[ illovae] :>
[ illovae] non mais euh c'est pas grave t'en fais pas pour moi :D
[ gapz] Dohko_: @staticmethod donc depuis Python 2.4, on appel ca des "decorators" si tu veux creuser un peu plus
[ Dohko_] gapz: entendu merci pour la piste
[ gpocentek] illovae: ok, on va l'utiliser, ça deviendra plus clair
[ illovae] gpocentek: ok
[ gpocentek] donc
[ gpocentek] Certaines méthodes ont des rôles particuliers.
[ gpocentek] on va en voir 3
[ gpocentek] === __init__ ===
[ gpocentek] les noms sont importants pour ces méthodes
[ gpocentek] La méthode __init__ est un constructeur, elle est appelée lorsque une nouvelle instance de classe est crée
[ gapz] Dohko_: et tu peux meme aller voir la PEP 318 pour encore plus d'info (http://www.python.org/dev/peps/pep-0318/)
[ gpocentek] regardez le fichier téléchargé
[ gpocentek] on a une méthode __init__ pour la classe Pouet
[ gpocentek] elle prend 3 arguments dont 2 optionnels (s'ils ne sont pas donné on prend les valeurs par défaut)
[ Dohko_] pourquoi 3 ?
[ Dohko_] le self compte pas si ?
[ gpocentek] dans la déclaration il compte
[ Dohko_] ah ok
[ gpocentek] dans l'appel on n'aura besoin que de 2 arguments
[ Dohko_] on est d'accord :)
[ gpocentek] :)
[ gpocentek] donc cette méthode va créer self.foo et self.bar en tenant compte des arguments passés
[ gpocentek] on utilisera donc pour créer un objet :
[ gpocentek] pouet = Pouet (2,6)
[ gpocentek] (par exemple)
[ Dohko_] ok
[ gpocentek] d'ailleurs ouvrez un shell dans le même répertoire
[ gpocentek] un shell python
[ illovae] on tape juste python c'est ça ?
[ gpocentek] illovae: oui
[ gpocentek] et on va se servir du fichier .py comme d'un module :
[ gapz] illovae: et ipython si tu veux la completion ;-)
[ illovae] gapz: ok
[ gpocentek] from pouet import *
[ gpocentek] python commence par regarder dans le répertoire courent pour faire des imports
[ gpocentek] ici le fichier pouet.py est vu comme un module
[ gpocentek] on va pouvoir utiliser ce qu'il y a dedans
[ gpocentek] ok ?
[ yannick_lm] ok
[ Dohko_] ok
[ illovae] moi j'ai une erreur
[ gpocentek] donc on va créer notre objet
[ gpocentek] illovae: laquelle ?
[ illovae] ImportError: No module named pouet
[ paulska] Idem
[ illovae] j'utilise ipython s'il faut ça vient de là
[ gpocentek] est-ce que vous avez lancé le shell dans le répertoire où se trouve le pouet.py ?
[ illovae] hum
[ paulska] Autant pour moi je n'ai pas fait attention au nom du fichier
[ illovae] et moi je suis complètement crevé...
[ illovae] désolé ^^'
[ gpocentek] ok :)
[ gpocentek] donc on crée notre objet
[ gpocentek] pouet = Pouet (2,6)
[ gpocentek] >>> pouet
[ gpocentek]
[ gpocentek] pouet est bien une instance de Pouet
[ illovae] je pige pas ce qu'on fait là en fait
[ Dohko_] print pouet.bar => 6 :)
[ gpocentek] Dohko_: ouep
[ gpocentek] illovae: t'as raté le petit topo sur les modules du début en fait...
[ illovae] gpocentek: ah ok je vais lire ça
[ gpocentek] illovae: on en reparlera si tu veux (http://gauvain.pocentek.net/2008-01-21-python-episode-3.log.html)
[ illovae] pfff je suis désolé je fais mon boulet
[ Dohko_] est-ce qu'il y a une histoire de public, protected etc ?
[ gpocentek] comme Dohko_ vous l'a montré, on peut accéder à foo et bar
[ gpocentek] Dohko_: oui et non, j'y reviendrai à la fin si tu veux bien
[ Dohko_] ok
[ gpocentek] >>> print pouet.foo, pouet.bar
[ gpocentek] 2 6
[ gpocentek] donc on accède à nos attribut de cette façon
[ yannick_lm] ok
[ gpocentek] ok pour tout le monde ?
[ paulska] Une petite question concernant le pouet = Pouet(2,6). Cela ne gene pas d'avoir une variable du meme nom que le module ?
[ gpocentek] paulska: pouet != Pouet
[ gpocentek] python est sensible à la casse
[ gpocentek] pouet et Pouet sont différents
[ paulska] Mais j'ai bien un from pouet import *
[ gpocentek] ah oui
[ gpocentek] paulska: là c'est lié au nom de fichier
[ gpocentek] mais ça ne gêne pas
[ paulska] D'accord
[ gpocentek] python sait distinguer de quoi tu parles selon le contexte
[ Dohko_] mais on pourrait aussi faire un Pouet = Pouet(3,8) non ?
[ Dohko_] et l'instance pouet et Pouet seraient différentes ?
[ gpocentek] Dohko_: tout à fait, c'était juste un exemple
[ Dohko_] ok c'est bon pour moi
[ gpocentek] Dohko_: Pouet c'est une classe, pouet une instance, nuance
[ gpocentek] tu peux pas comparer les deux
[ Dohko_] je suis d'accord, mais rien n'empeche de déclarer une instance du même nom que ta classe
[ gpocentek] on continue ?
[ yannick_lm] ok
[ gpocentek] === __str__ ===
[ paulska] ok
[ gpocentek] La méthode __str__ doit retourner une chaîne de caractères qui sera affichée lors d'un appel à 'print objet' :
[ gpocentek] def __str__(self):
[ gpocentek] return "foo: %s, bar: %s" % (self.foo, self.bar)
[ gpocentek] c'est ce que vous avez dans le fichier
[ gpocentek] >>> p = Pouet(-8, 6)
[ gpocentek] >>> print p
[ gpocentek] foo: -8, bar: -6
[ gpocentek] et voilà un exemple
[ gpocentek] le texte est formaté selon ce que vous avez défini dans __str__()
[ gpocentek] attention
[ gpocentek] il faut bien retourner la chaine de caractère dans la fonction, et pas imprimer directment avec print
[ gpocentek] ok pour __str__ ?
[ Dohko_] oui
[ yannick_lm] ok
[ gpocentek] ok
[ yannick_lm] question
[ gpocentek] oui ?
[ yannick_lm] c'est quoi le %
[ yannick_lm] c'est une syntaxe à la printf ?
[ gpocentek] exactement
[ yannick_lm] ok
[ gpocentek] (cf les cours précédents)
[ yannick_lm] (autant pour moi)
[ gpocentek] une autre méthode intéressante : __add__
[ gpocentek] quand elle est définie on peut utiliser '+' pour additionner des objets
[ gpocentek] je parle d'addition mais ça peut être autre chose
[ gpocentek] (concaténation pour les chaines de caractères par exemple)
[ gpocentek] regardez comment c'est défini dans pouet.py
[ Dohko_] ok
[ gpocentek] def __add__(self, other):
[ gpocentek] n = Pouet()
[ gpocentek] n.bar = self.bar + other.bar
[ gpocentek] n.foo = self.foo + other.foo
[ gpocentek] return n
[ gpocentek] deux arguments, l'objet, celui qui sera le deuxième membre, et n l'objet résultat
[ gpocentek] >>> p = Pouet(-8, 6)
[ gpocentek] >>> q = Pouet(-8, 6)
[ gpocentek] >>> print p+q
[ gpocentek] foo: -16, bar: -12
[ gpocentek] voilà un exemple d'utilisation
[ yannick_lm] c'est maqique !
[ gpocentek] avouez que c'est pratique ;)
[ paulska] C'est __add__ qui permet cela ?
[ yannick_lm] * magique
[ gpocentek] on peut redéfinir les autres opérateur de cette façon
[ gpocentek] cf http://docs.python.org/ref/numeric-types.html pour toutes les méthodes particulières
[ gpocentek] c'est clair tout ça ?
[ Dohko_] ok
[ yannick_lm] ok
[ paulska] La méthode __add__ est necessaire pour faire cette addition ?
[ gpocentek] vous avez déjà toutes les bases pour utiliser les classes et objets là
[ gpocentek] paulska: oui
[ gpocentek] paulska: si elle n'est pas définie ça ne marchera pas
[ paulska] D'accord, effectivement une belle erreur
[ gpocentek] :)
[ gpocentek] ok
[ gpocentek] passons à la notion d'héritage
[ gpocentek] Le principe d'héritage est assez simple à comprendre avec un exemple.
[ gpocentek] Un chien et un oiseau ont tous les deux des pattes, des yeux, peuvent émettre un cri, etc. mais l'oiseau a une couleur de plumage, alors que le chien a une couleur de pelage. Ces deux animaux ont suffisamment en commun pour faire partie d'une 'meta' catégorie (animal) dont des dérivés existeraient (chien et oiseau). C'est le principe de l'héritage.
[ gpocentek] dans le fichier pouet.py vous avez 2 autres classes définies, Bik et Bak
[ gpocentek] toutes les deux héritent de Pouet :
[ gpocentek] class Bik(Pouet):
[ gpocentek] class Bok(Pouet):
[ gpocentek] c'est spécifié en indiquant la classe mère entre parenthèses
[ gpocentek] je définis juste une variable pour Bik et Bok
[ gpocentek] >>> bik = Bik()
[ gpocentek] >>> bok = Bok()
[ gpocentek] >>> print bik.specific, bok.specific
[ gpocentek] 1 2
[ gpocentek] >>> print bik
[ gpocentek] foo: 0, bar: 0
[ gpocentek] mais vous voyez que la méthode __str__ et les variables de Pouet sont auusi accessibles
[ Dohko_] ok
[ gpocentek] ok ça ?
[ yannick_lm] ok
[ paulska] Oui, toutes les méthodes de ma classe donc
[ gpocentek] oui
[ crevette] gpocentek: je suis un peu a la bourre mais a la place de def __print__(self): c'est pas plutot def __str__(self): ?
[ crevette] a 20:48
[ gpocentek] crevette: euh... tu as vu ça où ?
[ crevette] La méthode __str__ doit retourner une chaîne de caractères qui sera affichée lors d'un appel à 'print objet' :
[ crevette] def __print__(self):
[ crevette] return "foo: %s, bar: %s" % (self.foo, self.bar)
[ gpocentek] crevette: oui bien vu, "typo"
[ gpocentek] c'est défini correctement dans le fichier exemple, on corrigera dans les logs, merci
[ crevette] les autres n'essaient pas les tp ou quoi ?
[ crevette] :)
[ gpocentek] y'a le fichier qui-va-bien fourni ;)
[ crevette] ah j'ai pas vu ledit fichier
[ gpocentek] ok donc
[ gpocentek] Il peut arriver qu'un attribut ou une méthode de la classe mère doive être modifié pour une classe fille. Il suffit de modifier cet attribut. On peut par exemple modifier la façon donc on affiche le contenu de Bok
[ gpocentek] crevette: http://gauvain.pocentek.net/tmp/pouet.py
[ gpocentek] regardez dans le fichier, la méthode __str__ est redéfinie pour Bok
[ gpocentek] >>> print bik
[ gpocentek] foo: 0, bar: 0
[ gpocentek] >>> print bok
[ gpocentek] Bonjour, je suis Bok
[ gpocentek] et c'est donc cette méthode redéfinie, pas celle de Pouet qui est utilisée
[ yannick_lm] gpocentek, comment ça se passe si on veut refaire un constructeur ?
[ gpocentek] si vous avez 25 classes dérivées d'une classe mère, et qu'une seule doit s'imprimer différemment... c'est pratique de la redéfinir
[ yannick_lm] et pouquoi c'est pas self.specific ?
[ gpocentek] yannick_lm: de la même façon
[ gpocentek] 21:06 < yannick_lm> et pouquoi c'est pas self.specific ? << bonne question :)
[ gpocentek] en fait le self n'est à utiliser que dans les méthodes
[ gpocentek] si on se trouve à l'extérieur des déclaration de méthodes le self n'est pas à utiliser
[ gpocentek] c'est le cas pour les attributs 'specific' de Bik et Bok
[ gpocentek] ok ?
[ Dohko_] c'est ok
[ paulska] d'accord
[ yannick_lm] ok
[ gpocentek] ok ok
[ gpocentek] un des avantages de python, c'est que les objets sont dynamiques
[ gpocentek] c'est à dire que de nouveaux attributs (et des méthodes) peuvent être définis à la volée :
[ gpocentek] exemple :
[ gpocentek] >>> bik.random
[ gpocentek] Traceback (most recent call last): File "", line 1, in
[ gpocentek] AttributeError: Bik instance has no attribute 'random'
[ gpocentek] >>> bik.random = "I'm random"
[ gpocentek] >>> bik.random
[ gpocentek] "I'm random"
[ Dohko_] excellent
[ gpocentek] par défaut la classe Bik n'a pas d'attribut random, mais si le besoin s'en fait ressentir... on l'ajoute
[ gpocentek] ATTENTION, c'est bien l'objet qui a été modifié, pas la classe :
[ gpocentek] >>> blo = Bik()
[ gpocentek] >>> blo.random
[ gpocentek] Traceback (most recent call last): File "", line 1, in
[ gpocentek] AttributeError: Bik instance has no attribute 'random'
[ Dohko_] et pour définir une méthode de manière dynamique, on fait comment ?
[ gpocentek] la classe n'a toujours pas d'attribut random
[ gpocentek] Dohko_: c'est un peu plus complexe
[ Dohko_] ok on verra plus tard ou une autre fois :)
[ gpocentek] à mon que gapz ait une meilleure solution il faut créer la fonction, et l'utiliser avec 'eval'
[ gpocentek] Dohko_: ça dépasse le cadre du cours mais c'est faisable ;)
[ gpocentek] à moins*
[ gpocentek] ok
[ gpocentek] pour finir
[ gpocentek] L'ensemble des attributs d'un objet ou d'une classe est accessible par l'attribut __dict__:
[ gpocentek] >>> p = Pouet(1, 1)
[ gpocentek] >>> p.__dict__
[ gpocentek] {'foo': 1, 'bar': 1}
[ gpocentek] >>> p.__dict__["baz"] = 4
[ gpocentek] >>> p.__dict__
[ gpocentek] {'baz': 4, 'foo': 1, 'bar': 1}
[ gpocentek] on peut également ajouter des attributs par ce biais
[ Dohko_] oki
[ gpocentek] Et la fonction dir donne la liste des attributs et méthodes:
[ gpocentek] >>> dir(p)
[ gpocentek] ['__add__', '__doc__', '__init__', '__module__', '__str__', 'bar', 'baz', 'foo']
[ gpocentek] même chose pour la classe :
[ gpocentek] >>> dir(Pouet)
[ gpocentek] ['__add__', '__doc__', '__init__', '__module__', '__str__']
[ Dohko_] donc tout ce qui est introspection est 100% possible je suppose
[ gpocentek] oui
[ gpocentek] on peut supprimer un attribut
[ gpocentek] >>> p.__dict__.pop("foo")
[ gpocentek] 1
[ gpocentek] >>> p.__dict__
[ gpocentek] {'baz': 4, 'bar': 1}
[ gpocentek] on peut les parcourir, etc...
[ gpocentek] voilà ce que j'avais prévu pour ce soir
[ gpocentek] (j'ai fait cour pour une fois)
[ yannick_lm] ok
[ gpocentek] est-ce que vous avez des questions sur ce qu'on a vu, ou sur d'autres chose ?
[ Dohko_] très bien
[ paulska] Merci bien
[ yannick_lm] ah oui
[ Dohko_] au niveau IDE, qu'est ce que tu conseilles ?
[ gpocentek] l'idée était de préparer le terrain pour le prochain cours sur pygtk
[ yannick_lm] niveau fichiers et classes, comment ça se passe ?
[ gpocentek] Dohko_: vim of course :)
[ Dohko_] lol
[ gpocentek] Dohko_: geany, ou eric (dédié python)
[ gpocentek] yannick_lm: hum, c'est à dire ?
[ yannick_lm] quand tu fais le import pouet
[ yannick_lm] (pardon)
[ yannick_lm] je cherche un moyen de reformuler ma question
[ gpocentek] ok :)
[ yannick_lm] voila
[ yannick_lm] quand tu fais Bik(Pouet)
[ yannick_lm] il va chercher la classe Pouet où ça ?
[ gpocentek] "localement"
[ gpocentek] comme on n'a pas fait d'import il regarde dans le fichier même
[ yannick_lm] ok
[ gpocentek] on n'est pas obligé de définir les classes dans des fichiers séparés
[ gpocentek] tu peux très bien la définir dans ton script et avoir le code qui l'utilise juste après
[ gpocentek] mais quand un projet grossit c'est plus simple d'avoir les classes dans des fichiers séparés
[ yannick_lm] on fait comme on veut, en fait
[ gpocentek] oui
[ yannick_lm] ok
[ gpocentek] y'a pas de règle, juste des bonnes pratiques
[ yannick_lm] des astuces particulières pour vim-python ?
[ gpocentek] pas vraiment...
[ gpocentek] personnelement j'ai un terminal avec vim et un term pour lancer les scripts
[ yannick_lm] je pensai plus à la complétion
[ yannick_lm] gnere compléter après class.
[ gpocentek] je sais pas si y'a de la complétion pour python
[ gpocentek] par par défaut en tout cas
[ yannick_lm] ok
[ gpocentek] gapz: tu sais ça peut-être ?
[ gpocentek] (s'il est encore là)
[ gapz] si si :)
[ gapz] attend 3s j'ai une fourchette dans la main droite :)
[ gapz] la completion dans vim ?
[ gpocentek] te blesse pas :)
[ gpocentek] pour python
[ gapz] dans vim pour python ?
[ gpocentek] sinon ^x ^n
[ gapz] ou dans le shell python ?
[ gpocentek] dans vim pour python
[ gapz] car dans le shell python il y a carrement ipython
[ gapz] dans vim aussi ca existe
[ gapz] attendez je vous file les liens
[ yannick_lm] oui, j'ai testé tout à l'heure
[ Dohko_] :D
[ gapz] :))
[ gapz] bon, j'ai pas ca dans mes bookmarks
[ gapz] attendez, maintenant faut que je retrouve un vieux post :P
[ Dohko_] tu le mettras sur le wiki au pire
[ gpocentek] ouep
[ yannick_lm] oui, c'est pas urgentissime non plus
[ gapz] à chaque fois je met 10ans à les retrouver ces liens en plus :]
[ gpocentek] Dohko_: pas sûr que ça se retrouve sur le wiki
[ gpocentek] on commence à migrer
[ Dohko_] en tout cas, merci pour ce cours très sympa, ça donne déjà de quoi démarrer
[ yannick_lm] gpocentek, encore ?
[ gpocentek] merci à vous :)
[ Dohko_] j'espère qu'il y en aura d'autres
[ Dohko_] ;)
[ gpocentek] yannick_lm: à priori on transfère tout sur u-classroom.net
[ gapz] http://www.tuxed.de/vimpst/video.html
[ gapz] pour vous donner l'eau à la bouche déja
[ gpocentek] Dohko_: moi aussi ;)
[ gpocentek] miam
[ gapz] voila, donc ce qui est utilisé sur la video la c'est:
[ gapz] http://www.vim.org/scripts/script.php?script_id=1074
[ yannick_lm] gpocentek, ah ok
[ gapz] (vous pouvez aussi regarder http://wikipython.flibuste.net/moin.py/Vim)
[ yannick_lm] cool
[ yannick_lm] merci à vous deux
[ gapz] sans doute qu'il existe des trucs plus récent
[ gapz] mais perso, je trouve que la completion c'est pas vraiment pratique dans vim
[ gapz] enfin, c'est que mon avis
[ Lutin] un peu pareil
[ gapz] les morceau de code que je test je le fais souvent dans ipython
[ gpocentek] idem en fait
[ gapz] apres je reprend tout d'un coup
[ gapz] c'est juste fun sur les videos en fait :P
[ gpocentek] les tests des classes je les fait dans le shell
[ yannick_lm] gpocentek, c'est vrai que python est assez bien pour ça
[ gpocentek] yannick_lm: oui
[ yannick_lm] tester des ptis trucs vite fait dans un shell
[ yannick_lm] avec ipython, c'est le pied
[ skateinmars] * gpocentek présente gapz, la bibliothèque officielle de liens pour geeks << pour les liens inutiles vous savez a qui s'adresser :>
[ yannick_lm] (à comparer avec la compilatio d'un truc en java)
[ gapz] :]
[ gpocentek] skateinmars: huhu, à tristan nitot ?
[ skateinmars] =)
[ Dohko_] lol
[ gpocentek] bon, est-ce que je refait ce cours avant pygtk ?
[ gpocentek] refais*
[ gapz] http://geekz.co.uk/schneierfacts/
[ gapz] tu trouves ca si inutile skateinmars ? :)
[ gpocentek] pygtk ça risque d'ameuter plus de monde, sans bases...
[ gapz] gpocentek: bah, si ca se trouve peu de gens sont venu car ils connaissaient déja
[ gapz] ou comme tu dis
[ yannick_lm] gpocentek, tu fais une jolie page
[ gpocentek] gapz: je pense qu'on a surtout pas assuré sur les annonces
[ gapz] c'est assez génant comme situation ouais
[ gpocentek] yannick_lm: ouep...
[ yannick_lm] sur toutes les leçons et ça ira
[ yannick_lm] (je pense)
[ gpocentek] au pire je referai le point si ça coince vraiment
[ gapz] gpocentek: genre dans l'annonce pour pygtk faudra bien noter les prérequis
[ gpocentek] gapz: +1