Discussion :

[darkterreur]

Bonjour,

Je rencontre actuellement un blocage de logique et j'aurai souhaiter un petit coup de pouce pour me débloquer.

Imaginons que je créer un objet comme ceci

Code :

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

maCarte = carte()

Dans le cadre de mes besoins, j'en ai une multitude dans une liste "listeCarte[]".

Si je décide de passer une carte au hasard dans une fonction qui modifie les attributs de ma carte tel que la couleur par exemple.

Code :

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

changeCouleur(listeCarte[3])

Voila pour l'exemple

et je voudrai savoir si mon objet en "listeCarte[3]" a bien changer de couleur ou si c'est seulement la copie de l'objet envoyé dans la fonction qui a changer de couleur.

Voila j'espère avoir été suffisamment clair sinon dite le moi.

Je vous remercie par avance.

[VinsS]

Salut,

Si carte est une classe alors la réponse est oui, si non, faudra montrer le code de carte() pour comprendre.

D'ailleurs, si la couleur est un attribut de la carte, tu devrais pouvoir faire:

Code :

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

1
2
 
print carte.couleur

pour vérifier.

[darkterreur]

Bonjour,

En effet carte est une classe et couleur un de ses attributs.

Et l'espace d'un grand instant il m' sembler qu'il fallait que je fasse ceci

Code :

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

listeCarte[3] = changeCouleur(listeCarte[3])

avec un return dans ma fonction pour que ma liste soit à jour.

Donc si je t'ai bien comprit je peux balancer un objet en paramètre de ma fonction, le modifier, le torturer.
Il sera toujours a jour dans ma liste d'objet ?

[Clodion]

Bonjour,

En effet carte est une classe et couleur un de ses attributs.

Et l'espace d'un grand instant il m' sembler qu'il fallait que je fasse ceci

Code :

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

listeCarte[3] = changeCouleur(listeCarte[3])

avec un return dans ma fonction pour que ma liste soit à jour.

Donc si je t'ai bien comprit je peux balancer un objet en paramètre de ma fonction, le modifier, le torturer.
Il sera toujours a jour dans ma liste d'objet ?

Bonsoir,

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
class MonObj():
    def __init__(self, couleur = "rouge"):
        self.couleur = couleur
    def quelle_couleur(self):
        return self.couleur
    def change_couleur(self, nv_couleur):
        self.couleur = nv_couleur
 
lst = []
for k in range(10):
    obj = MonObj()
    lst.append(obj)
mon_obj = lst[3]
print "départ: ", mon_obj.quelle_couleur(), lst[3].quelle_couleur()
 
mon_obj.change_couleur("vert")
print "change couleur: ", mon_obj.quelle_couleur(), lst[3].quelle_couleur()

Code :

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

1
2
3
4
5
>>> ================================ RESTART ================================
>>> 
départ:  rouge rouge
change couleur:  vert vert
>>>

La liste ne contient pas les objets, mais la référence à chacun de ces objets.
Tant que celle-ci n'est pas ôtée de liste, toutes les opérations qui le modifieront (l'objet) ne changeront pas sa référence, et donc seront toujours "visibles" à partir de la liste!

De même, une méthode s'applique à un objet d'une classe particulière, donc:

Code :

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

listeCarte[3] = changeCouleur(listeCarte[3])

signifie: applique la fonction (qui n'est pas une méthode, mais une fonction "en générale") à l'objet. En aucun cas cela ne peut être une méthode de cet objet (par définition, une méthode d'objet s'appelle avec la notation pointée: obj.methode).

Sinon, c'est assez facile de "voir" comment cela se passe en utilisant la console!

Clodion

[darkterreur]

Ha merci pour c'est explication.

En effet on oublie parfois de tester par soit même les choses simples.
je vais m'y coller de ce pas

Et donc si ma fonction n'est pas une méthode de mon objet cela ne change rien car je lui balance les référence de mon objet, et il sera quand même a jour dans ma liste sans que j'ai besoin de le faire manuellement ?

Une autre petite question me viens a l'esprit
dans le cas d'une fonction qui n'est pas une méthode, il vaut mieux passer uniquement l'attribut de l'objet qui nous intéresse, ou l'objet complet ?

Pareil si nous passons juste l'id de l'objet et que nous devons retrouver l'objet dans la fonction il vaut mieux passer l'objet?

je me demande si c'est vraiment lourd de carrément passer les objets a chaque fois ?

Autre question si au chargement je créer plein de carte que je met dans une liste, et que par exemple mon joueur choisit mettons 10 cartes, et que l'on copie les 10 objet de ma liste dans une nouvelle liste. Si j'ai bien comprit nous copions les références de l'objet donc je modifier et consulter mon objet dans les deux listes ce sera toujours le même avec les mêmes attributs a jour ?

je vous remercie du temps que vous prenez pour me répondre.

[Clodion]

Une autre petite question me viens a l'esprit
dans le cas d'une fonction qui n'est pas une méthode, il vaut mieux passer uniquement l'attribut de l'objet qui nous intéresse, ou l'objet complet ?

Pareil si nous passons juste l'id de l'objet et que nous devons retrouver l'objet dans la fonction il vaut mieux passer l'objet?

je me demande si c'est vraiment lourd de carrément passer les objets a chaque fois ?

Autre question si au chargement je créer plein de carte que je met dans une liste, et que par exemple mon joueur choisit mettons 10 cartes, et que l'on copie les 10 objet de ma liste dans une nouvelle liste. Si j'ai bien comprit nous copions les références de l'objet donc je modifier et consulter mon objet dans les deux listes ce sera toujours le même avec les mêmes attributs a jour ?

je vous remercie du temps que vous prenez pour me répondre.

Bonsoir,
Ainsi que je l'ai écrit ci-dessus, les objets que nous utilisons en Python sont en réalité des références. Donc passer un objet en argument d'une fonction n'est pas différent de passer une variable quelconque. Ce sont toujours des références.
La "philosophie" de l'orienté objet, est justement, de ne pas intervenir de l'extérieur sur les attributs de cet objet. On utilise des méthodes pour cela.

Sinon, moins de 30s pour tester!

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
>>> class Obj():
	def __init__(self, couleur = "rouge"):
		self.couleur = couleur
	def change_couleur(self, couleur):
		self.couleur = couleur
	def donne_couleur(self):
		return self.couleur
 
 
>>> mon_obj = Obj()
>>> mon_obj.donne_couleur()
'rouge'
>>> def chg_coul(attribut_Obj):
	attribut_Obj = "Blanc"
 
 
>>> chg_coul(mon_obj.couleur)
>>> mon_obj.donne_couleur()
'rouge'
>>>

Maintenant, l'explication: une chaîne de caractère est non modifiable. Lors d'une opération sur cette chaîne, c'est une copie qui en est faite, ce n'est pas la variable elle-même (qui n'est qu'une référence).

Code :

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

1
2
3
4
5
>>> a = "rouge"
>>> chg_coul(a)
>>> a
'rouge'
>>>

Python ne fait pas le lien.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
>>> def chg_coul(attribut_Obj):
	attribut_Obj = "Blanc"
	print attribut_Obj, id(attribut_Obj)
 
 
>>> chg_coul(a)
Blanc 31538080
>>> a
'rouge'
>>> id(a)
34182176
>>>

id renvoie la référence de l'objet (c'est la position en mémoire). Et tout est objet dans Python.

Quand à la dernière question, tout est compris!

Donc voilà. Mais le principe de base pour un objet est d'utiliser ses propres méthodes pour le modifier, pas de le faire de l'extérieur!
Et toujours pareil: un petit test sous Idle, c'est rapide et la réponse est exacte! :-)

Clodion
PS: Il y a de très bons tutos concernant les objets en Python. Si votre âge est suffisant (!!), il y a une série d'articles, en français, chez Sam&Max.
PS2: pensez à appuyer sur le bouton résolu si tel est le cas