Pb d'accès aux données d'un objet

**richard** · 15/06/2007, 08h46

Bonjour,

J'ai un problème lié à ce code (petit prototype d'un programme de gestion de notes)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
#!/usr/bin/python
# -*- coding: iso-8859-1 -*-
 
# ------------------- carnet de notes  --------------------------#
 
 
import Tkinter
 
class note:
    "definition d'un objet note comportant 3 données : le coef / le resultat / le trimestre "
    def __init__(self, c =0, r =0, t =1):
        self.coef=c
        self.resultat=r
        self.trimestre=t
 
    def definit(self):
        "fixe les données de la note en cours"
 
        print " Coef ?"
        self.coef= input()
        print " resultat ?"
        self.resultat= input()
        print " Trimestre ?"
        self.trimestre = input()
 
 
 
    def affiche_note(self):
        print str(self.coef) + "," + str(self.resultat) + "," + str(self.trimestre)
 
 
class serie_note(note):
    "definition d'une série comme liste de notes d'un élève"
 
 
    def __init__(self,ln=[]):
        note.__init__(self,c=0,r=0,t=1)
 
        self.liste_note=ln
 
    def ajoute(self):
 
        self.definit()
        self.liste_note.append(note)
 
    def affiche(self):
        print str(self.coef)
        print self.liste_note.coef #ne fonctionne pas comme prévu
 
 
 
class eleve(serie_note):
    "definition d'un objet eleve comme une liste de note + un nom "
 
    def __init__(self,n='nobody'):
        serie_note.__init__(self)
 
        self.nom=n
 
 
    def nommer(self):
        print "Nom de l'élève ?"
        self.nom=raw_input()
 
    def affiche_eleve(self):
        print "Voici l'élève et ses notes"
        print str(self.nom)
        #note.affiche_note(self)
        serie_note.affiche(self)
 
#--------------  Test de la classe *note*  -------------------#
 
bidule = note()
bidule.coef=2
bidule.resultat=14
bidule.trimestre=2
bidule.affiche_note()
 
#--------------------- fin du test classe *note* ----------#
#--------------------- Test de la classe *Eleve*  et "serie_note"------------#
 
First=eleve()
First.nommer()
#First.coef=2
#First.resultat=14
#First.trimestre=2
First.ajoute()
First.ajoute()
First.affiche_eleve()
 
#------------------- fin du test# classe ------------#

Dans la classe "serie_note" (qui a comme attribut" une liste contenant des objets notes) je n'arrive pas à imprimer à l'écran la liste contenu dans l'objet (pardon, l'instance de classe) . Comment faire pour accèder au contenu de cette liste. Cela doit êter trivial mais comme je n'ai fait essentiellement que du procédural à part pour les IHM et quelques scripts en POO simples en python jusque là, j'avoue que j'ai du mal sur ce petit bout de code.

Je peux le faire en procédural bien sûr mais je préférerais passer tout en objets pour ce petit logiciel.

Merci.

**Vladislav IV** · 15/06/2007, 10h42

Salut,

Envoyé par richard

l'objet (pardon, l'instance de classe)

Objet = instance de classe

Alors le problème est simple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

print self.liste_note.coef #ne fonctionne pas comme prévu

Cette ligne ne peut fonctionner, puisque self.liste_note est une liste de notes. Il faut donc parcourir cette liste, pour accéder à chaque note.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
for note in self.liste_note:
    print note.coef

Cette boucle affiche le coef de chaque note contenue dans la liste.

Mais partons du français : serie_note est une liste de notes... Donc cette classe n'a aucune raison d'hériter de la classe note, non ? En gros, tu dis que ta liste de notes est une note

Il y a aussi un problème avec cette méthode, de la classe serie_note :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
def ajoute(self):
    self.definit()
    self.liste_note.append(note)

Tu utilises une variable 'note' qui n'est pas définie... Elle n'est donc pas ajoutée à ta liste. Je le verrai plutot comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
def ajoute(self):
    uneNote = note()
    uneNote.definit()
    self.liste_note.append(uneNote)

Je n'ai pas le temps d'approfondir, mais une dernière chose : tu utilises une variable 'note', et tu as défini une classe 'note'... Tu me suis ? Pour éviter les problèmes, nommes tes classes en partant d'une majuscule, et tes variables avec des minuscules

**richard** · 15/06/2007, 12h08

Envoyé par Vladislav IV

Salut,

Objet = instance de classe

Oui, je savais, mais comme j'ai appris la POO avec le pascal Objet, le vocabulaire n'est pas celui de Python

Envoyé par Vladislav IV

Alors le problème est simple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

print self.liste_note.coef #ne fonctionne pas comme prévu

Cette ligne ne peut fonctionner, puisque self.liste_note est une liste de notes. Il faut donc parcourir cette liste, pour accéder à chaque note.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
for note in self.liste_note:
    print note.coef

Cette boucle affiche le coef de chaque note contenue dans la liste.

OK, mais pourtant si je définis la liste "note" ainsi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
note = []
note.append(12)
note.append(15)
note.append(16)

je peux ensuite l'afficher en faisant un simple "print note". Ce n'est pas possible avec une liste composée d'objets ? Pourquoi ?

Envoyé par Vladislav IV

Mais partons du français : serie_note est une liste de notes... Donc cette classe n'a aucune raison d'hériter de la classe note, non ? En gros, tu dis que ta liste de notes est une note

Non, je veux dire que serie_note est une liste de notes. mais peut-être la sémantique utilisée n'est-elle pas bonne. Proposition ?
Ce qui m'intéresse, en fait, c'est de partir d'un objet simple possédant quelques méthodes de base et d'élargir les compétences de cet objet par héritages successifs : note est un objet simple, serie_note hérite des attributs de note mais devient une liste d'objets note qui possède des méthodes liées à la structure de données liste, enfin eleve est un objet qui hérite de serie_note et qui ajoute d'autres attributs.

Maintenant, du point de vue de la conception tu sembles dire qu'il faudrait que je parte d'un objet serie_note, pourrais-tu approfondir un peu, SVP ?

Envoyé par Vladislav IV

Il y a aussi un problème avec cette méthode, de la classe serie_note
Je n'ai pas le temps d'approfondir, mais une dernière chose : tu utilises une variable 'note', et tu as défini une classe 'note'... Tu me suis ? Pour éviter les problèmes, nommes tes classes en partant d'une majuscule, et tes variables avec des minuscules

Merci du conseil. C'était confus, en effet.

Merci pour toutes ces infos ... S'il y a d'autres suggestions ...

**Matthieu Brucher** · 15/06/2007, 13h08

Un objet n'est pas forcément une instance de classe, une classe, le type, est aussi un objet.

**richard** · 15/06/2007, 13h08

OK, je devais être distrait ... j'ai compris (l'évidence !

) pour le "print" : comme les données sont elles-mêmes encapsulées dans un objet et que cet objet est contenu dans une liste, pour accèder au données, il faut accèder aux attributs de l'objet note, bref, il y a deux couches au lieu d'une.

Pour la conception objet du programme, je reste à l'écoute des suggestions ...

**richard** · 15/06/2007, 13h13

Envoyé par Miles

Un objet n'est pas forcément une instance de classe, une classe, le type, est aussi un objet.

Sans vouloir dévier le sujet initial, en Pascal Objet (mais je ne sais pas dans les autres langages objet) l'objet est une instance de classe, et un Type objet est une classe (abstraite donc). Ce sont les recommandations de Niklaus Wirth. Maintenant ceci ne vaut peut-être que pour le Pascal Objet qui fait la différence entre un Type (= une classe abstraite) qu'on ne peut pas manipuler et qui sert de "patron général" et une variable (l'objet / la classe instanciée) que l'on peut manipuler.

Probablement différent en Python mais je ne sais comment le dire.

**Matthieu Brucher** · 15/06/2007, 13h57

En Python, tout est un objet.

**Vladislav IV** · 15/06/2007, 15h00

Envoyé par Miles

Un objet n'est pas forcément une instance de classe, une classe, le type, est aussi un objet.

Si, c'est le principe même de la POO : on a des classes, et des objets, qui sont des instances de ces classes. Un objet est toujours l'instance d'une classe.

Pour le cas du type, c'est un peu tordu, on a effectivement un objet 'type', une fonction 'type', et une classe 'type' (nécessaire, puisque l'on en a une instance).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
>>>#documentation de la fonction 'type'
>>> print type.__doc__
type(object) -> the object''s type
type(name, bases, dict) -> a new type
>>>#affichage du nom de la classe à l'origine de l'objet 'type'
>>> type.__class__.__name__
'type'

Edit : au temps pour moi, il n'y a pas de fonction 'type', c'est la classe 'type' qui dispose d'une méthode '__call__'.

**Matthieu Brucher** · 15/06/2007, 15h05

Pardon, je me suis mal exprimé.
Une classe est un type, OK ? Cette classe est elle aussi un objet, qui peut être une instance d'une méta-classe, au besoin.

**Vladislav IV** · 15/06/2007, 15h09

Pour en revenir au sujet, richard, je pense qu'il y a un problème au niveau de ta conception : tu ne peux pas dire que ta collection de notes est une note. C'est pourtant ce que tu essaies de faire. Tu devrais plutot considérer qu'il y a des notes, et qu'un étudiant possède un ensemble de notes.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
class Note:
    [...]
 
class Etudiant:
    def __init__(self):
        self.lesNotes = []
 
    def ajouterNote(self, uneNote):
        self.lesNotes.append(uneNote)

Je pense que ce serai plus simple et plus logique.

**Vladislav IV** · 15/06/2007, 15h10

Envoyé par Miles

Pardon, je me suis mal exprimé.
Une classe est un type, OK ? Cette classe est elle aussi un objet, qui peut être une instance d'une méta-classe, au besoin.

Aaah oui ! Je dois dire que je ne suis pas encore aventuré sur ces sentiers-là !

Edit : en effet, on a le type 'type', qui se décline (entre autres) en 'instance' pour les objets, et en 'classobj' pour les classes.

Edit 2 : je crois qu'il vaut mieux éviter de parler des métaclasses, ce serai plus simple !

**richard** · 15/06/2007, 15h52

Envoyé par Vladislav IV

Pour en revenir au sujet, richard, je pense qu'il y a un problème au niveau de ta conception : tu ne peux pas dire que ta collection de notes est une note. C'est pourtant ce que tu essaies de faire. Tu devrais plutot considérer qu'il y a des notes, et qu'un étudiant possède un ensemble de notes.

Je pense que ce serai plus simple et plus logique.

Je te remercie de cette suggestion. Je vais partir sur ton modèle, c'est d'ailleurs ce que j'avais fait au tout début et puis j'ai voulu créer une classe intermédiaire serie_note mais ce n'était pas une bonne idée.

Remarque : comme je voudrais que la classe Etudiant soit composée d'une liste d'objets Note qui possèdent chacun les attributs de cette classe il faudra donc que je passe en paramètre à la méthode "ajouterNote " un objet Note (bref que "uneNote" soit une variable du type "Note"). C'est bizarre, je le visualise très bien en Pascal Objet, mais j'ai du mal à le concevoir en Python.

<HS = On>
Pour le reste de la discussion, classe, métaclasse, objet ... je dois dire que le plus simple à penser (pour moi) c'est quand même la notion de type abstrait (la classe) et celle de variable objet (l'instance de classe) . Même si en effet en Python 'tout est objet", ça ne change pas grand-chose à mon sens puisque quand on utilise un type prédéfini comme la liste ou le dictionnaire dans une fonction (et non pas une méthode), on ne se préoccupe pas de la sémantique objet sous-jacente, on fait du procédural, c'est tout. Donc on manipule ces types (presque) comme s'ils n'était pas des objets. D'ailleurs je connais certaines personnes qui se servent de Python uniquement en programmation procédurale, qui ignorent totalement la POO et cela ne les empêche pas de manipuler - implicitement - des objets.
<HS = OFF>

**Vladislav IV** · 15/06/2007, 16h31

Envoyé par richard

Remarque : comme je voudrais que la classe Etudiant soit composée d'une liste d'objets Note qui possèdent chacun les attributs de cette classe il faudra donc que je passe en paramètre à la méthode "ajouterNote " un objet Note (bref que "uneNote" soit une variable du type "Note"). C'est bizarre, je le visualise très bien en Pascal Objet, mais j'ai du mal à le concevoir en Python.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
unEtudiant = Etudiant()
uneNote = Note(c=1, r=13, t=2)
unEtudiant.ajouterNote(uneNote)

**Vladislav IV** · 15/06/2007, 16h54

Pour approfondir, tu peux en effet passer n'importe quoi en paramètre, cela sera ajouté à la liste de notes de l'étudiant. Mais a priori, tu ne serai pas assez fourbe pour mettre un nombre flottant dans cette liste, hmm ?

Python exploite le principe du duck typing, qui dit en gros que si ça a les propriétés d'un canard, et que ça réagit comme un canard, alors il y a de bonnes chances pour que ce soit un canard. Autrement dit, si par malheur tu te retrouves avec un objet qui n'est pas une note, mais qui en a tout le comportement, tout se passera bien.

Tu peux toutefois mettre un filtre au début de tes méthodes pour vérifier que l'objet passé est bien une Note.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
class Etudiant:
    [...]
    def ajouterNote(self, uneNote):
        if uneNote.__class__.__name__ == 'Note':
            self.lesNotes.append(uneNote)

Ce qui n'ajoutera à la liste que les objets de type Note (excluant de fait les classes dérivées).

Mais malgré le caractère dynamique de Python, je ne pense pas que beaucoup de "Pythonistes " mettent en place ce genre de vérifications. Ce qui n'empêche pas la Terre de tourner, malgré ce que certains avancent.

**richard** · 15/06/2007, 17h22

Excellent, le test d'appartenance à la classe.

Ca m'ouvre pas mal d'horizon pour traquer les bugs

Je te remercie vivement encore une fois.

**Matthieu Brucher** · 15/06/2007, 17h36

Mieux, utiliser isinstance().

**richard** · 15/06/2007, 18h22

Envoyé par Miles

Mieux, utiliser isinstance().

Tiens, comme dans Canterbury Pascal avec l'opérateur d'appartenance "IS". Il va falloir que je fasse une plongée en eaux profondes dans le manuel de référence.

**** Edit ************************

En fait je viens de lire ceci

la fonction prédéfinie isinstance(I,C) renvoie TRUE si l'objet I est une instance de la classe C ou de l'une de ses sous-classes

Parfois dangereux, donc, quand on a besoin d'un test spécifique. la solution de Vladislav IV me paraît meilleure dans mon cas précis.

**Vladislav IV** · 15/06/2007, 23h02

isinstance fonctionne pour les classes dérivées ? Damned, et moi qui ai joué les bricoleurs sur l'un de mes projets !

**Matthieu Brucher** · 15/06/2007, 23h44

Naturellement que ça marche !

**richard** · 16/06/2007, 09h58

Envoyé par Vladislav IV

isinstance fonctionne pour les classes dérivées ? Damned, et moi qui ai joué les bricoleurs sur l'un de mes projets !

Tu n'avais pas utilisé la solution que tu m'as donnée page précédente ?
Le recours au nom de la classe qui est un identificateur unique me paraît excellent pour lever les ambigüités.

Pb d'accès aux données d'un objet

Python

Discussions similaires

Partager

Partager