Acrobaties de variables [Résolu]

[LeHibou2]

Bonjour à tous,

Depuis tout à l'heure j'ai réussi à faire la translation de programmes d'autres langages vers python.

Parfait. J'ai progressé.
Maintenant, savoir faire d'une manière c'est bien, mais j'aime la voltige.

Ma question, qui semblera sûrement idiote, est de la masturbation intellectuelle.

Soit fichier1 et fichier2, tel que :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
 
#! /usr/bin/python
#coding:utf-8
 
#FICHIER1
import fichier2
 
class maClasse1 :
    def __init__(self):
        '''mes définitions'''
    def roulebille():
        '''ici l'objet de la question'''

Et fichier2, fille

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#! /usr/bin/python
#coding:utf-8
 
#FICHIER2
 
class maClass2(fichier1.maClasse1) :
 
  def __init__(self):
    fichier1.maClasse1.__init__(self)
 
  def cherche(self):
    '''ici pleins de variables locales'''

La question c'est de savoir si je peux réutiliser des variables locales définies dans cherche(), du fichier2, dans une nouvelle fonction du fichier1.
global ne m'a pas aidé.

Actuellement, je règle le problème en passant par des variables "self" du constructeur que je récupère.

Votre avis ?

Merci à vous,

A bientôt,

LeHibou

[VinsS]

Salut,

Tu l'a testé ?

Code :

1
2
3
4
5
6
7
 
#! /usr/bin/python
#coding:utf-8
 
#FICHIER2
 
class maClass2(fichier1.maClasse1) :

sans importer fichier1 ce sera difficile, et si tu importes fichier1 qui lui-même importe fichier2 tu crées une boucle d'import que Python rejetera immédiatement.

Et puis pourquoi veux-tu faire cet héritage, est-il justifié ?

Pour répondre à ta question:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
#! /usr/bin/python
#coding:utf-8
 
#FICHIER1
from fichier2 import maClass2
 
class maClasse1(object):
    def __init__(self):
        '''mes définitions'''
 
    def roulebille(self):
        self.mc2 = maClass2()
 
        # Maintenant tu peux
        self.mc2.attribut_machin = 'foo'
        self.bar = self.mc2.attribut_chose
        # etc

Tu remarqueras quelques corrections.

Envoyé par LeHibou2

Actuellement, je règle le problème en passant par des variables "self" du constructeur que je récupère.

Quoique la terminologie soit incorrecte, je crois comprendre ce que tu veux dire, c'est effectivement ainsi que l'on fait (donc comme dans mon exemple) et il est inutile de chercher une autre façon de faire.

[LeHibou2]

Merci VinsS,

Je dois avouer qu'hier je n'avais plus les yeux en face des trous.
J'ai simplifié bêtement mon exemple et j'ai coupé des choses importantes.

Je ne m'en rendais même plus compte.

En tout cas, merci à toi,

A bientôt,

LeHibou

[LeHibou2]

Le plus simple étant -évidemment- de faire un return de la valeur de la fonction, voire un tuple, et de le réutiliser dans une variable temporaire...

[wiztricks]

Si maClass2 hérite de maClass1 alors tous les attributs sont accessibles suivant "self":

Exemple:

Code :

1
2
3
4
5
6
7
8
9
10
class A:
    def foo(self):
         print (self.a)
 
class B(A):
    def __init__(self, a):
       self.a = a
 
b = B(3)
b.foo()

- W

[LeHibou2]

Oui, tu as raison, et je ne me permettrais pas de discuter cet état de fait.

Mais j'ai changé d'avis quant à la nécessité de faire un héritage en vue de débugger plus simplement.

Parce que le programme est devenu trop complexe avec des appels de partout et surveiller les variables ainsi que leur valeur d'appel devenait problématique.

Résultat : mise à jour du design -> pas d'héritage mais du transfert de valeur à la voltige avec contrôle des itérations.

Et là, l'air est revenu.

Bonne soirée et bonnes fêtes à vous

A bientôt,

LeHibou

[VinsS]

L'héritage te permet de faire ceci:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
# -*- coding: utf-8 -*-
 
class A(object):
    def __init__(self):
        pass
 
    def abrege(self, chain):
        return chain[:5] + '...'
 
class B(A):
    def __init__(self):
        super(B, self).__init__()
 
    def format(self, st):
        if len(st) > 8:
            st = self.abrege(st)
 
        return st
 
a = A()
b = B()
 
print b.format('Supercalifragilistisexpidilicious')

où tu peux constater que B a hérité de la méthode abrege() de A.

[LeHibou2]

C'est très vrai VinsS,

Code :

1
2
 
a = A()

Tu as instancié "a" pour une raison particulière ?

[VinsS]

Envoyé par LeHibou2

Tu as instancié "a" pour une raison particulière ?

Non, l'habitude.

[LeHibou2]

Merci beaucoup de tes lumières,

Elles me seront utiles dans un cas que je prévois.

A bientôt,

LeHibou