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

[darkterreur]

Bonsoir,

J'ai prit le temps de faire quelque essaye comme plus que recommander.

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
from carte import *
 
 
def changeColor(objCarte):
    objCarte.couleurCarte = "bleu"
 
 
listeCarte = []
 
maCarte1 = carte("ecureuil", 12, "toto", "rouge")
maCarte2 = carte("banane", 22, "...toto...", "rouge")
maCarte3 = carte("flan", 2, "miam", "rouge")
 
listeCarte.append(maCarte1)
listeCarte.append(maCarte2)
listeCarte.append(maCarte3)
 
 
for elt in listeCarte:
    print(elt.couleurCarte)
 
changeColor(maCarte2)
print("changement sur carte")
 
for elt in listeCarte:
    print(elt.couleurCarte)
 
 
changeColor(listeCarte[2])
print("changement sur liste")
for elt in listeCarte:
    print(elt.couleurCarte)

ce qui me donne ceci:

rouge
rouge
rouge
changement sur carte
rouge
bleu
rouge
changement sur liste
rouge
bleu
bleu

Donc ca fonctionne en revanche je n'ai pas bien compris votre dernier cadre.

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
 
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

Pouvons nous en rediscuter ?
Si j'ai bien comprit mon exemple ne devrais pas fonctionner car il s'agit d'une référence
c'est bien cela?

Et pour répondre a une des question il est possible que j'ai mal conçu mon projet mais malheureusement les 3/4 des traitement doivent se faire dans le main pour manipuler les objets. tel que main -> joueurs -> cartes
Mais main n'est pas un objet.

[Sve@r]

...en revanche je n'ai pas bien compris votre dernier cadre.

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

Si j'ai bien comprit mon exemple ne devrais pas fonctionner car il s'agit d'une référence
c'est bien cela?

Bonjour

Pas tout à fait. Il voulait juste montrer que si tu écrases la référence reçue par autre chose, Python génère une nouvelle zone mémoire pour stocker le "autre chose" mais ne touche pas à l'objet d'origine.

Et pour répondre a une des question il est possible que j'ai mal conçu mon projet mais malheureusement les 3/4 des traitement doivent se faire dans le main pour manipuler les objets. tel que main -> joueurs -> cartes
Mais main n'est pas un objet.

Non mais si t'as pas besoin, pour un joueur particulier, de stocker autre chose que les cartes qu'il a en main, rien ne t'empêche de créer une simple variable "joueur" ne contenant que la liste de ses cartes...
joueur=(carte(1, "carreau"), carte(2, "pique"), carte(3, "trèfle"))...

[darkterreur]

Ha ok je vous remercie je n'avais pas compris cela comme ça.

merci à vous