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 ?
################################## class C1() "Classe sans parent"
class C2(object) "Classe avec parent" ##################################
Ooups ! Pardon pour les ":" manquants bien sûr.
-- François
bruno.desthuilliers
On 19 avr, 16:48, Francois wrote:
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
On 19 avr, 16:48, Francois <mathsatta...@free.fr> wrote:
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
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
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
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 ?
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
[...]
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
[...]
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 ? ;-)
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
On 19 avr, 18:45, Francois wrote:
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.
On 19 avr, 18:45, Francois <mathsatta...@free.fr> wrote:
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.
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
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
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 »
