class : object or not object comme parent

Le
Francois
Bonjour à tous,

Je vois que parfois une classe est définie avec la classe « object »
(une classe qui est d'ailleurs assez mystérieuse pour moi) comme parent
et parfois je ne vois pas de parent.

##################################
class C1()
"Classe sans parent"

class C2(object)
"Classe avec parent"
##################################

L'instance d'un objet issue de la classe C1 possède peu d'attributs et
l'instance d'un objet issue de la classe C2 en possède beaucoup plus qui
sont d'ailleurs bien obscurs.


Je voulais savoir quand faut-il définir une classe avec « object » comme
parent et quand ne faut-il pas le faire. À quoi ça correspond tout ça ?

Merci d'avance.


--
François
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
Francois
Le #5148711
##################################
class C1()
"Classe sans parent"

class C2(object)
"Classe avec parent"
##################################


Ooups ! Pardon pour les ":" manquants bien sûr.


--
François

bruno.desthuilliers
Le #5164121
On 19 avr, 16:48, Francois
Bonjour à tous,

Je vois que parfois une classe est définie avec la classe « object »
(une classe qui est d'ailleurs assez mystérieuse pour moi) comme parent
et parfois je ne vois pas de parent.


Python 2.2 a introduit un nouveau modèle objet, plus riche que celui
alors en vigueur. L'ancien modèle objet est resté dans le langage pour
des raisons de compatibilité (il disparaitra dans Python 3.0). Les
classes du "nouveau" modèle sont appelées "new-style", celles
correspondant à l'ancien modèle "classic" ou "old-style". Le moyen le
plus simple pour créer une new-style class est de la faire dériver
(directement ou non) de la classe 'object'.

Dans la pratique, à moins que tu ne doives assurer une compatibilité
avec Python < 2.2, utilise toujours les new-style classes, qui amènent
entre autres le support du protocol Descriptor (et donc des attributs
calculés, aka properties).

Tu peux lire ça pour en savoir plus
http://www.python.org/doc/2.2.3/whatsnew/sect-rellinks.html

HTH

Francois
Le #5164111
Dans la pratique, à moins que tu ne doives assurer une compatibilité
avec Python < 2.2, utilise toujours les new-style classes, qui amènent
entre autres le support du protocol Descriptor (et donc des attributs
calculés, aka properties).

Tu peux lire ça pour en savoir plus
http://www.python.org/doc/2.2.3/whatsnew/sect-rellinks.html



Merci bien Bruno, alias « Docteur ès Python » :-))

Donc, pour ne pas avoir de problème avec la future version 3.0 (tant
attendue), il faut écrire :

###############
class MaClasse(object):
"C'est ma classe"
...
###############

C'est très clair.


Mais est-ce que cela veut dire que quelque chose comme

###############
class MaClasse():
"C'est ma classe"
...
###############

entraînera forcément une erreur avec l'interpréteur Python de la version
3.0 ?

Merci encore.


--
François

Pierre Maurette
Le #5164101

[...]

Mais est-ce que cela veut dire que quelque chose comme

###############
class MaClasse():
"C'est ma classe"
...
###############


ou
class MaClasse:

entraînera forcément une erreur avec l'interpréteur Python de la version 3.0
?


La logique voudrait me semble-t-il - mais Python et moi ... - que comme
en Java les classes old-style soient implicitement considérées comme
dérivant de object.
Avec peut-être un outil(*) ou une erreur "positionnable" pour faciliter
le nettoyage.

(*)Mais quand on fait un peu de Python, va-t-on attendre un outil tout
fai ? ;-)

--
Pierre Maurette

bruno.desthuilliers
Le #5171581
On 19 avr, 18:45, Francois

Dans la pratique, à moins que tu ne doives assurer une compatibilité
avec Python < 2.2, utilise toujours les new-style classes, qui amènent
entre autres le support du protocol Descriptor (et donc des attributs
calculés, aka properties).

Tu peux lire ça pour en savoir plus
http://www.python.org/doc/2.2.3/whatsnew/sect-rellinks.html


Merci bien Bruno, alias « Docteur ès Python » :-))


Ah bin oui, tiens : 7 ans d'études = un doctorat !-)

Donc, pour ne pas avoir de problème avec la future version 3.0 (tant
attendue), il faut écrire :

class MaClasse(object):
"C'est ma classe"
...


Réponse courte: oui.

Réponse longue:
Du point de vue formel - et si j'ai bien suivi -, les deux syntaxes
seront équivalentes. Donc une déclaration 'old-style' ne sera
(serait ?) pas une erreur de syntaxe.
Par contre, il est clairement préférable de passer dès maintenant aux
classes new-style en raison d'une part des fonctionnalités plus
riches, et d'autre part de quelques subtiles incompatibilé.

C'est très clair.

Mais est-ce que cela veut dire que quelque chose comme

###############
class MaClasse():
"C'est ma classe"
...
###############

entraînera forcément une erreur avec l'interpréteur Python de la ver sion
3.0 ?


Si j'ai bien suivi (encore une fois), non. Par contre, certaines
choses possibles avec les classes old-style (comme par exemple
surcharger une __magic_method__ sur une instance particulière) ne le
sont pas avec les classes new-style, donc si ton code repose sur
certaines de ces subtiles différences, il peut très bien casser sans
autre procès.

En tout état de cause, la seule et unique raison de continuer à
utiliser des classes 'old-style' est d'assurer la compatibilité avec
des versions antiques (Python 2.2 date de fin 2001...) de Python. Ce
qui n'est pas AMHA une raison suffisante. En ce qui me concerne,
j'utilise systématiquement les classes new-style depuis leur
apparition, et je m'en porte for bien.


Francois
Le #5171571
Merci bien à Bruno et Pierre pour vos subtiles explications. Tout est
clair et la conclusion est (pour une fois :-) ) limpide :

« à moins de vouloir assurer la compatibilité avec des anciennes
versions de Python, il faut utiliser les new-style classes »


Merci bien.


--
François
Publicité
Poster une réponse
Anonyme