Quand tu fais obj.attr, ça va chercher obj.attr, et si ça ne le trouve pas, ça va chercher Class.attr, puis si ça ne le trouve pas, ça va chercher celui de la classe parente, etc.

Donc si tu set ton attribut (obj.attr = truc), il existe sur l’objet, et c’est ce qui est retourné. Si tu ne le set pas, alors c’est celui de la classe qui est utilisé, et c’est pourquoi tu vois la modification sembler se “propager”.

Si je modifie l’attribut au niveau de la classe, la classe et toutes les instances crées après ont la nouvelle valeur.

Bizarre, j’ai ça :

>>> class HobJay:
...  classtribut = 'et un'>>> 
...
 
      >>> h1 = HobJay()
      >>> h2 = HobJay()
      >>> h3 = HobJay()
      >>> h1.classtribut
      'et un'
      >>> h2.classtribut
      'et un'
      >>> h3.classtribut
      'et un'
      >>> h2.classtribut = 'et deux'
      >>> h2.classtribut
      'et deux'
      >>> HobJay.classtribut = 'et trois zero !'
      >>> h1.classtribut
      'et trois zero !'
      >>> h2.classtribut
      'et deux'
      >>> h3.classtribut
      'et trois zero !'
      >>> import sys
      >>> print(sys.version)
      3.4.3 (default, Mar 25 2015, 17:13:50)
 
      [GCC 4.9.2 20150304 (prerelease)]

On dirait plutôt que changer l’attribut de classe change l’attribut de toutes les instances, sauf celles dont l’attribut a été changée avant. Comme si l’attribut de classe était “écrasé” par un attribut d’instance chez h2.

Ou alors c’est un comportement qui change avec les versions ?

As-tu un conseil qui peut aider à réfléchir objet ?

Réfléchir objet le moins possible. On utilise les objets quand on veut créer une API particulière ou quand on a un état auquel on fait référence dans de nombreuses fonctions qu’on transforme donc en méthode. Pour le reste, pas besoin d’objets.

Autre question, un peu plus technique, les attributs de classes au niveau de la classe se mettent-ils à jour si 2 objets sont dans des threads différents ?

Oui les espaces mémoires sont partagé entre les threads, pour avoir des variables non partagées, il faut utilise des thread locals variables ou des queues.

Je maitrise bien les notions des classes Python, mon grand défaut est de vouloir (insconciemment) créer des classes outils pour y fourrer un peu tout ce qui a un rapport (donc finalement beaucoup de méthodes).

J’essaie donc de sortir de mon habitude bizarre de tout ranger, et d’utiliser un peu plus les objets et les comportements naturels qui y sont liés, et après plusieurs années de dev procédural ce n’est pas toujours simple (surtout sur la partie intéraction entre les classes, j’hésite souvent entre la dérivation etc…)

As-tu un conseil qui peut aider à réfléchir objet ?

Autre question, un peu plus technique, les attributs de classes au niveau de la classe se mettent-ils à jour si 2 objets sont dans des threads différents ?

écrite toute en majuscule : tout en majuscule (voire tout en lettres capitales, majuscule = 1e lettre du mot toussa)

(object) là haut là: balise code à object + là-haut avec trait d’union

Très clair sinon :)

Quelques petites corrections :

“public static virtuel neconceptuel”
C’est quoi ce “neconceptuel” ? C’est un vrai-mot clé, ou c’est une faute de frappe au mot “neoconceptuel” ?

Y’a dû y avoir confusion dans la lolisation du code. Les instances qui s’appellent “etranger_qui_vole_le_travail_des_francais” devraient être renommées en “flim_pas_sur_le_cyclimse“.
À remplacer à deux endroits.