Questions sur les classes

Bonsoir,

J'ai une autre question :

J'ai 2 modules, module1 et module 2
Code:

1 2 3 4 5 6 7 8 9 module1 class test: def __init__(self,data): self.data = data module2 import module1 class test2: ....
Est-il possible de récupérer la variable data dans ma classe test2 sans devoir appeler la class test ? Si il y a une méthode spécial ou une astuce magique.
J'utilise une class pour récupérer un fichier et y extraire des choses, donc j'utilise comme paramètre le data dans un troisième module

Code:

module1.test(data)

et j'aimerais pouvoir utiliser les attributs dans un autre fichier ou je n'ai pas accès au data pour appeler la class.
Après pas mal de recherches, je n'ai pas l'impression que c'est possible ^^

Merci

Bonjour
Citation:
Envoyé par outiat
JJ'ai 2 modules, module1 et module 2
Code:

1 2 3 4 5 6 7 8 9 module1 class test: def __init__(self,data): self.data = data module2 import module1 class test2: ....
Est-il possible de récupérer la variable data dans ma classe test2 sans devoir appeler la class test ? Si il y a une méthode spécial ou une astuce magique.
Non, aucune possibilité. Toutefois si tu regardes bien, la variable data ne provient pas de ta classe test. Elle s'y trouve, oui, mais elle y a été mise depuis l'extérieur. Donc peut-être que tu peux la récupérer depuis cet extérieur avant qu'elle entre dans la classe test.

Bonjour,

Citation:

Est-il possible de récupérer la variable data dans ma classe test2 sans devoir appeler la class test ?

Bah c'est surtout du bon sens que de faire cet appel à test pour récupérer la variable data.
Sinon je vois pas trop l'intérêt de la création de cette classe.

Même si on devait récupérer cette variable data, il faudra bien un moment avoir créé une instance de cette classe quelque-part.

Maintenant si c'est une constante que tu souhaites récupérer d'une classe, c'est possible, dans ce cas tu auras besoin d'une variable de classe.
Code:

1 2 3 4 class Test: DATA = None def __init__(self, data): self.data = data
puis l'appel à cette variable dans l'autre module,
Code:

1 2 3 4 5 6 7 8 from test import Test class Test2: def __init__(self, data=Test.DATA): self.data = data t = Test2() print(t.data)
Sinon une classe est faîte pour construire de multiples instances, donc être appelée...

Citation:
Envoyé par fred1599
puis l'appel à cette variable dans l'autre module,
Code:

1 2 class Test2: def __init__(self, data=Test.DATA):
Moi j'ai dit que ce n'était pas possible car il avait précisé "sans devoir appeler la classe Test"...8-)

Citation:

Envoyé par Sve@r

Moi j'ai dit que ce n'était pas possible car il avait précisé "sans devoir appeler la classe Test"...8-)

Ma deuxième solution n'est pas réellement une réponse à la question du PO, mais plus une proposition de conception différente.

Une solution pourrait être de faire de la sérialisation, mais en vue du besoin actuel, je dirais que c'est overkill et que conceptuellement ça ressemble à du bricolage.

Citation:

Envoyé par fred1599

et que conceptuellement ça ressemble à du bricolage.

Oui, ça m'avait traversé l'esprit aussi :mouarf:

:salut:

Pour que l'exemple de @fred1599 fonctionne, je dois écrire :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Test:
    DATA = None
 
    def __init__(self, data):
        self.__class__.DATA = data
 
 
class Test2:
    def __init__(self):
        self.data = Test.DATA
 
 
obj = Test([1, 2, 3])
 
t = Test2()
 
print(t.data) #[1, 2, 3]

Citation:
Envoyé par danielhagnoul
:salut:

Pour que l'exemple de @fred1599 fonctionne, je dois écrire :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 class Test: DATA = None def __init__(self, data): self.__class__.DATA = data class Test2: def __init__(self): self.data = Test.DATA obj = Test([1, 2, 3]) t = Test2() print(t.data) #[1, 2, 3]
Ça fonctionne je pense, la question reposait sur la création de deux modules (module1 et module2).

Citation:
Envoyé par danielhagnoul
Pour que l'exemple de @fred1599 fonctionne, je dois écrire :
Code:

1 2 3 4 5 class Test: DATA = None def __init__(self, data): self.__class__.DATA = data
Exact. Car en écrivant self.DATA=data on crée juste un attribut d'instance "DATA" qui masque l'attribut de classe "Test.DATA" (lequel reste toutefois toujours accessible depuis tout ce qui n'est pas instance).
Bien vu :applo:

Citation:

Envoyé par Sve@r

Exact. Car en écrivant self.DATA=data on crée juste un attribut d'instance "DATA" qui masque l'attribut de classe "Test.DATA" (lequel reste toutefois toujours accessible depuis tout ce qui n'est pas instance).
Bien vu :applo:

Moins verbeux et lisible serait Test.DATA = data

Citation:

Envoyé par fred1599

Moins verbeux et lisible serait Test.DATA = data

Ouais mais... on lie alors une action au nom de la classe. Si ce nom évolue faut recoder l'action.
Ou alors on définit __init__ comme une méthode de classe...
Code:

1 2 3 4 5 6 class Test: DATA = None @classmethod def __init__(cls, data): cls.DATA = data
... ce qui permet alors aussi d'hériter de "Test" sans casser la logique...

Bonjour,
Merci pour vos réponses
Je me doutais que je ne pouvais pas le faire ^^

Salut,

À l'intérieur d'une application toutes les classes sont liées entre elles.

L'application elle-même est lancée par un noyau qui se chargera d'instancier les divers autres objets et il suffira d'en suivre le fil conducteur pour accéder à tous les attributs de n'importe quel autre objet.

Je pense que le PO devrait se demander pourquoi ses classes Test et Test1 ne peuvent communiquer entre elles alors que l'une a forcément instancié l'autre.

Citation:
Envoyé par Sve@r
Ouais mais... on lie alors une action au nom de la classe. Si ce nom évolue faut recoder l'action.
Ou alors on définit __init__ comme une méthode de classe...
Code:

1 2 3 4 5 6 class Test: DATA = None @classmethod def __init__(cls, data): cls.DATA = data
... ce qui permet alors aussi d'hériter de "Test" sans casser la logique...
Ah ok, là oui effectivement on va un peu plus loin du problème actuel,.. mais on réutilise bien le nom de la classe Test dans Test2 :?

Une solution différente pour le plaisir,
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 def create_class(name, data): my_class = type(name, (), {'DATA': data}) my_class.__init__ = lambda self, data: setattr(self, 'data', data) return my_class Test = create_class('Test', [1, 2, 3]) class Test2: def __init__(self): self.data = Test.DATA t = Test2() print(t.data) # [1, 2, 3]