Problème avec Poo

Version imprimable

Problème avec Poo

Bonjour,

Dans mon apprentissage Python, je suis entrain d'étudier la POO.
J'ai réussi à jouer avec l'utilisation d'une seule classe.
Maintenant, je veux utiliser deux classes, et j'ai un petit soucis.
Voici un exemple de ce que je n'arrive pas à faire :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 def Maclasse1: def __init__(self, x = 1): self.x = 0 def ajout(self, u): self.x = self.x + u def Maclasse2: def additionner(self, r): Maclasse1.ajout(r) machin = Maclass1() pouet = machin.ajout(3)
À partir de là, je voudrais pouvoir appeler la méthode additionner de Maclasse2(qui utilisera la méthode ajout de la Maclasse1). Je n'y arrive pas.
Plus concrètement, j'ai fait une première classe ou j'instancie des objets. Ma seconde classe sert à me créer une interface graphique (avec GTK). Je voudrais, en cliquant sur un bouton, qu'il me rajoute une valeur à l'attribut self.x de mon objet machin.

Je ne sais pas si je suis très clair. Je ne met pas le code pour l'instant, car il est encore assez fouilli et pas forcément des plus lisible, mais j'espère qu'avec l'exemple que je vous ai décris, vous allez comprendre ce que je veux.

Merci à toutes et tous.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Maclasse1:
    def __init__(self, x = 1):
       self.x = 0
 
    def ajout(self, u):
        self.x = self.x + u
 
Maclasse2(Maclasse1):
    def additionner(self, r):
        self.ajout(r)
 
machin = Maclass2()
pouet = machin.ajout(3)
 
truc = machin.additionner(12)

mais je ne suis pas sûr de moi.

21/10/2009, 11h40
D3bian

Merci josmiley pour ta réponse rapide.

En fait, Maclasse2 est une boucle (interface graphique gtk).
Dans cette interface, il y a un bouton qui doit utiliser une méthode de Maclasse1 (pour l'objet machin).

Je suis novice, donc je ne m'exprime peut être pas très clairement :)
21/10/2009, 12h36
D3bian

josmiley,

Je viens de tester ta solution. J'ai fait ça avec des classes plus simple que ce que je n'avais fait, et pour l'instant, le resultat obtenu me semble correspondre à ce que je voulais.
Merci à toi.
Pour l'instant, je laisse le post en stand by.
21/10/2009, 13h49
eyquem
Salut,

Je serais intéressé de voir ce que signifie

Citation:

appeler la méthode additionner de Maclasse2

pour toi, D3bian. :koi:

Je ne vois aucune définition de classe dans vos codes, seulement des définitions de fonctions, et encore est-ce avec une erreur de syntaxe puisqu'il faut des parenthèses après le nom d'une fonction. 8O
Code:

1 2 3 4 5 #Pour déclarer une classe: class Maclasse1: #Pour déclarer une fonction, ici sans paramètre: def Maclasse1():
Cette file a été vue 30 fois au moment où j'écris, et personne pour le signaler.
:!:

En outre, une fois que tu auras fait de Maclasse1 une classe, il faut écrire

Code:

class Maclasse2( Maclasse1):

pour faire hériter Maclasse2 de Maclasse1.

Par ailleurs, quand je lis

Citation:

j'ai fait une première classe où j'instancie des objets

je tique, parce que je comprends ça d'une certaine façon et je me dis: on n'instancie rien du tout DANS une classe, une instanciation se fait EN DEHORS de toute classe en appelant une classe comme si on appelait une fonction:

Citation:

Class instantiation uses function notation. Just pretend that the class object is a parameterless function that returns a new instance of the class.

http://www.python.org/doc/2.6.2/tuto...#class-objects
21/10/2009, 14h25
D3bian

Bonjour eyquem,

Pour le code, je me suis trompé dans l'empressement d'ecrire mon post.
Merci d'avoir relevé l'erreur.

Ensuite pour l'instanciation, je te remercie de la définition. Étant débutant en programmation, j'ai encore du mal à tout assimiler.

J'ai un peu avancé mon programme depuis ce matin, mais je vais devoir encore me faire la main sur les classes, avant de les maitriser.

Encore merci pour ton intervention

Techniquement, ce que tu veux faire est peut-être possible avec un héritage (solution de josmiley). Mais ce n'est sans doute pas le mieux à faire. Comme tu ne donnes que des noms abstraits (MaClasse1, MaClasse2) c'est difficile d'en être sûr. J'espère déjà que tu n'as donné ces noms que comme exemple et que ce ne sont pas les noms réels que tu utilises.

L'héritage représente la relation "est un". Il ne convient de l'utiliser que si tu peux dire que partout où on utilise une instance de MaClasse1, on peut utiliser à la place une instance de MaClasse2 (principe de substitution). Par exemple, un labrador "est un" chien. Toute propriété vraie à propos des chiens en général l'est pour les labradors en particulier.

Si ce n'est pas le cas il vaut mieux utiliser une association, si tu peux dire par exemple que toute instance de MaClasse1 est associée à / contient / possède une instance de MaClasse2.
Concrètement cela ressemble à ça:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 class MaClasse1: def __init__(self, x = 1): self.x = 0 def ajout(self, u): self.x = self.x + u class MaClasse2: def __init__(self): self.m1 = MaClasse1() def additionner(self, r): self.m1.ajout(r)
Désolé pour le blabla théorique, mais sans ça on se retrouve vite à faire n'importe quoi en OO.

22/10/2009, 08h47
D3bian

Bonjour dividee,

Je remercie pour cette explication.
Je n'avais pas encore utilisé le principe d'association.
Pour ce que je voulais faire, l'héritage correspond à ce que je voulais dans le résultat.

Merci à tous pour votre aide.

Salut dividee,

Citation:

Désolé pour le blabla théorique, mais sans ça on se retrouve vite à faire n'importe quoi en OO.

+10

Du théorique, j'en redemande, personnellement.
L'autre jambe indispensable à mon avis pour bien avancer dans l'utilisation d'un langage est la connaissance de son implémentation. C'est pour cela que j'ai envie et que je pense indispendable d'apprendre le C.

Citation:

on se retrouve vite à faire n'importe quoi en OO.

Cela confirme une impression diffuse que j'ai depuis quelques temps concernant cette fameuse programmation objet ou orientée-objet.

Mais assez de blabla....

Salut D3bian,

Il va te falloir regarder d'un peu plus près les arguments par défaut aussi.

C'est ce que je viens de faire après avoir remarqué une incohérence dans ton code. Cela m'a permis de réaliser quelque chose que je n'avais pas encore bien distingué.

L'incohérence est celle-ci:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 class MaClasse1: def __init__(self, x = 1): self.x = 0 self.y = x+30 def ajout(self, u,y=23): self.x = self.x + u a = MaClasse1() print a.x b = MaClasse1(45) print b.x
Citation:

0
0

Que l'on passe un argument à la classe lors d'une instanciation ou qu'on n'en passe pas, la valeur de la variable d'instance x juste après une instanciation est toujours 0. Donc l'assignation x=1 dans la définition de __init__() ne sert à rien.

Je précise d'abord que dans mon esprit, argument signifie une valeur passée à une fonction ou une classe; c'est la valeur prise par un paramètre. Et que paramètre est pour moi synonyme de variable.

Après ce constat pratique, je comptais ajouter, en manière de généralisation:

L'écriture d'une assignation d'un argument par défaut dans la déclaration d'une fonction __init__() ne sert que si la fonction __init__() utilise cet argument par défaut pour en faire vraiment quelque chose, (jusque là c'est juste) mais pas modifier immédiatement (et là ça devient faux->) la variable d'instance, qui vient d'être créée par l'assignation d'argument par défaut, sans tenir compte de cet argument.

Ce qui est faux, c'est de croire que l'assignation d'un argument par défaut x=1 créerait la variable d'instance x dont on verrait la modification à la ligne suivante self.x = 0.
Non; la variable d'instance x est créée par l'instruction self.x = 0 uniquement.
L'assignation de l'argument par défaut dans la déclaration de la fonction __init__() crée, comme pour toute fonction, une variable locale à cette fonction.

La preuve:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 def fonction_bateau(a=23): b = 80 c = 100 + a d = 1000 + b return (a,b,c,d) print fonction_bateau() print class MaClasse1: def __init__(self, x = 1): self.x = 0 self.y = x+30 def ajout(self, u,y=23): self.x = self.x + u cl = MaClasse1() print cl.x, cl.y kl = MaClasse1(13) print kl.x, kl.y
Citation:

(23, 80, 123, 1080)

0 31
0 43

Si le return (a,b,c,d) de fonction_bateau() est (23, 80, 123, 1080) , c'est que l'assignation a=23 dans la définition de la fonction crée une variable locale au moment de la déclaration et que a existe tant que le programme ne sort pas de la fonction.

De même, si la variable d'instance y définie par self.y = x+30 prend
la valeur 31 quand on instancie MaClasse1()
et la valeur 43 quand on instancie MaClasse1(13) ,
c'est que
- la valeur de x utilisée dans x+30 est bien la valeur de la variable locale x créée par l'assignation x=1 dans le premier cas ou l'assignation x=1 surchargée par x=13 dans le deuxième cas,
- cette valeur de la variable locale x n'est pas affectée par la création de la variable d'instance self.x à la ligne précédente.

Après une instanciation, la fonction __init__() ne sert plus, elle est close. Toute variable locale y contenue n'existe plus. Donc l'assignation x=1 ne sert vraiment à rien, ni pour une variable d'instance ni pour une variable locale.

Donc il suffit de dire:
L'écriture d'une assignation d'un argument par défaut dans la définition d'une fonction __init__() ne sert que si cet argument par défaut est utilisé dans le corps de la fonction __inut_().

Autrement dit , quelque chose ne sert que si c'est utilisé :haha:

.

Citation:

Envoyé par eyquem

Si le return (a,b,c,d) de fonction_bateau() est (23, 80, 123, 1080) , c'est que l'assignation a=23 dans la définition de la fonction crée une variable locale au moment de la déclaration et que a existe tant que le programme ne sort pas de la fonction.

ce n'est pas tout à fait exact. cela se vérifie dans ton cas car a est de type int et que les int sont non mutables. pour un type mutable (une liste) il en est autrement:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 def append(valeur,liste=[]): liste.append(valeur) return liste def append2(valeur,liste=None): if not liste: liste = [] liste.append(valeur) return liste print append(3) print append(4) print append2(3) print append2(4)
c'est une des raisons pour laquelle il ne faut jamais mettre un objet mutable comme valeur par défaut d'un argument dans une fonction :)

la liste vide est généré au moment de la déclaration de la fonction, pas au moment où elle est appelée. Sa durée de vie s'étend sur la durée de vie du script et non de la fonction.

kango, je n'étais pas au courant de ce comportement que tu pointes et j'en suis surpris. Il a dû déjà en avoir été question d'autres fois mais je n'avais pas fait assez attention.

J'avais bien vu que tu avais pris le temps de faire ce post, merci, mais j'y ai réfléchi depuis l'autre soir.

J'ai essayé des tests divers pour voir si se confirmait ou s'infirmait la seule conclusion à laquelle il me semble que conduit ton code: les variables locales ne s'éteignent pas quand un programme sort d'une fonction, contrairement à ce que je croyais.

Je pense que je croyais ainsi à cause du fait qu'une fois resorti d'une fonction, un programme n'a plus accès aux valeurs de ses variables locales.

Mais donc, comment expliquer autrement le résultat de ton code, sinon par le fait qu'une variable locale continue d'exister après qu'un programme soit sorti de la fonction, ce qui en terme d'implémentation signifie, me semble-t-il, que l'espace de noms de la fonction ne disparaît pas.

Mais je n'arrive toujours pas à être tout à fait convaincu de cette conclusion. Ce qui me gène, c'est de conclure quelque chose de façon indirecte à partir du résultat d'un seul code.

J'ai donc trituré des codes pour essayer de trahir la persistance de l'existence de variables locales une fois un programme sorti d'une fonction. Le problème est que sorti, ça veut dire sorti: on ne peut pas regarder dans une fonction à partir de l'extérieur. Les variables locales d'une fonction ne sont pas des attributs de cette fonction.

Le seul code un peu démonstratif dans ce sens que j'aie obtenu est le suivant, qui utilise l'aliasing de Python:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 def f(valeur,u,liste=[]): print ' entree de fonction: id(liste) =',id(liste),' liste =',liste if u=='1': liste.append(dehor) liste.append(valeur) print ' sortie de fonction: id(liste) =',id(liste),' liste =',liste return liste dehor = [1,3,5,7] print 'dehor =',dehor print '\n*id(f) =',id(f) print f(3,'1') dehor[2] = 'R2D2' print "\nexecution de dehor[2]='R2D2'" print 'dehor =',dehor print '\n*id(f) =',id(f) print f(45,'2')
Citation:

dehor = [1, 3, 5, 7]

*id(f) = 24912624
entree de fonction: id(liste) = 21273296 liste = []
sortie de fonction: id(liste) = 21273296 liste = [[1, 3, 5, 7], 3]
[[1, 3, 5, 7], 3]

execution de dehor[2]='R2D2'
dehor = [1, 3, 'R2D2', 7]

*id(f) = 24912624
entree de fonction: id(liste) = 21273296 liste = [[1, 3, 'R2D2', 7], 3]
sortie de fonction: id(liste) = 21273296 liste = [[1, 3, 'R2D2', 7], 3, 45]
[[1, 3, 'R2D2', 7], 3, 45]

La modification de dehor a lieu après que le programme soit passé par et resorti de f. Cette modification se répercute bien dans liste, qui doit donc bien exister à ce moment là.

Le problème est que j'étais tout disposé à ne pas couper les cheveux en 4 et à accepter comme établi que l'espace de noms d'une fonction ne disparaît pas tant que.... tant que quoi, au fait ? ....tant que le script n'est pas fermé, ou tant que le garbage collector n'est pas passé dessus ?...

Enfin bref, le problème est qu'après ton code et d'autres indices allant dans le même sens, je suis retombé sur ceci qui m'a replongé dans l'indécision:

Citation:

The local namespace for a function is created when the function is called, and deleted when the function returns or raises an exception that is not handled within the function. (Actually, forgetting would be a better way to describe what actually happens.)

http://www.python.org/doc/2.6.2/tuto...nd-name-spaces

Comment concilier ceci avec le résultat de ton code ? Deleted or not deleted ?

En fait, ton code pose deux problèmes:

- une fois qu'une liste == [3] a été créée dans la fonction par append(3) , cette liste perdure après la sortie du programme de la fonction

- au moment où le programme rentre à nouveau dans la fonction, au lieu de recréer liste, il repart sur la base de liste=[3] : cela veut dire qu'il fait un examen de la situation qui lui permet de s'apercevoir qu'il n'a pas besoin de créer la liste vide que spécifie l'argument par défaut, mais qu'il peut prendre la liste == [3] existante

Que faut il penser de toutes ces cogitations ? Je préfèrerais lire des descriptions autorisées plutôt qu'être réduit à ces supputations.

Le fait est que les arguments par défaut d'une fonction sont analysés et créés à la compilation. La fonction en garde alors une référence dans son attribut func_defaults.

Ca ne pose aucun problème pour les types immuables tels que les nombres, strings, None ou autre.
Par contre, quand il s'agit d'un objet muable, c'est le drame.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 >>> def test(arg=[]): ... try: ... arg.append(arg[-1] + 1) ... ... except: ... arg.append(1) ... >>> test.func_defaults ([],) >>> test() >>> test() >>> test() >>> test.func_defaults ([1, 2, 3],)
La méthode simple pour résoudre ça ? Limiter les valeurs par défaut des arguments à des types immuables.
Code:

1 2 3 4 5 >>> def test(arg=None): ... if arg is None: ... arg = [] ... ... # suite du code...
On peut aussi jouer avec cette propriété pour faire des variables dites "statiques" dans une fonction. (! ne pas confondre avec les variables statiques de classe).

Prenons comme exemple la fonction C strtok ( http://www.manpagez.com/man/3/strtok/ )
Cette fonction prend 2 paramètres: une chaine de caractères, et un séparateur. La chaine de caractère peut éventuellement être remplacée par NULL (équivalent de None) pour signaler qu'on continue la découpe de la précédente.
Exemple (bon, ce n'est pas un bon exemple de C car il inclus une grosse erreur, mais autant éviter de noyer les gens.)
Code:

1 2 3 4 5 6 char* url = "un:deux:trois"; char* partie; partie = strtok(url, ":"); // partie est "un" // strtok récupère la chaine précédente, partie vaut "deux" partie = strtok(NULL, ":");
La fonction strtok garde la trace de la chaine de caractère grâce à une variable statique.
Code:

1 2 3 4 5 6 7 8 char* strtok(char* chaine, const char* separateur) { static char* actuelle = NULL; if(chaine != NULL) actuelle = chaine; // ... suite du traitement sur "actuelle" }
En python, on peut faire le même genre de chose grâce justement à cette propriété.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 >>> def strtok(chaine, separateur, static={}): ... if chaine: ... static["pos"] = 0 ... static["actuelle"] = chaine ... ... else: ... if not "pos" in static: ... raise ValueError("Donnez moi une chaine") ... ... pos = static["actuelle"].find(separateur, static["pos"]) ... ... if pos < 0: ... pos = len(static["actuelle"]) ... ... result = static["actuelle"][static["pos"] : pos] ... static["pos"] = pos + 1 ... ... return result ... >>> url = "http://www.aspyct.org" >>> strtok(url, ":") 'http' >>> strtok(None, "/") '' >>> strtok(None, "/") '' >>> strtok(None, "/") 'www.aspyct.org'
Cela dit, il est bien entendu largement plus clair de faire une classe pour ce genre de fonctionnalités.