Discussion :

[outiat]

Bonsoir,

J'ai une autre question :

J'ai 2 modules, module1 et module 2

Code :

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

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 :

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

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

[Sve@r]

Bonjour

JJ'ai 2 modules, module1 et module 2

Code :

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

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.

[fred1599]

Bonjour,

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 :

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

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 :

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

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

[Sve@r]

puis l'appel à cette variable dans l'autre module,

Code :

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

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

[fred1599]

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

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.

[Sve@r]

et que conceptuellement ça ressemble à du bricolage.

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

[danielhagnoul]

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

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

[fred1599]

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

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

[Sve@r]

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

Code :

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

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

[fred1599]

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

Moins verbeux et lisible serait Test.DATA = data

[Sve@r]

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

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

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

[outiat]

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

[VinsS]

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.

[fred1599]

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

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

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 :

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