classe en argument d'une fonction

Version imprimable

Bonjour developpeurs, developpeuses,

J'ai deux fichiers Calcul.py et CodeUtilisateur.py
Dans Calculs.py j'ai une classe Resultat et un appel a la fonction Initcodeutilisateur qui se trouve dans le fichier CodeUtilisateur.py.

Je voudrais instancier la classe Resultat dans Initcodeutilisateur et je voulais savoir si il était possible de passer en argument à la fonction Initcodeutilisateur la classe résultat (je rappele que la fonction et la classe sont dans 2 fichiers différents !)

Calcul.py :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 try : from CodeUtilisateur import Initcodeutilisateur except : print "Erreur à l'initialisation code utilisateur - Syntaxe error" class Resultat(): def __init__(self): pass def __call__(self, freq): print freq return '__call__' try:Initcodeutilisateur(class) #Je voudrais passer en argument la classe Resultat ! except: print "Erreur à l'exécution de l'init du code utilisateur !"
CodeUtilisateur.py:
Code:

1 2 3 def Initcodeutilisateur(Resultat()): #Ou Resultat est la classe Resultat ! somme = Resultat() produit = Resultat()
Ainsi, le

Code:

try:Initcodeutilisateur(class)

Va appeler

Code:

def Initcodeutilisateur(Resultat()):

Qui va instancier la classe Resultat grace aux lignes:
Code:

1 2 somme = Resultat() produit = Resultat()
Est-ce que c'est possible? Si oui, comment je peux faire svp?
Merci d'avance pour vos réponses et vos conseils avisés !

TeqPAF

Oui, c'est tout à fait possible.

Code:

1
2
3
4
5
6
7
8
9
>>> class Test(object):
            def __init__(self):
                foo=5
 
>>> def foo(cls):
            print cls().foo
 
>>> foo(Test)
5

Test est la classe, et Test() en est une instance.

Merciiiii N.Tooooxxxxxx :D

Voila un probleme résolu...
Pour ne pas refaire un post je reviens vers vous pour la suite :
J'appele ma fonction d'init:
Code:

1 2 try : InitCodeUtilisateur(TM, ConteneurResultat) except: print 'ERROR'
Avec un import avant...
J'ai le script CodeUtilisateur suivant:
Code:

1 2 3 def InitCodeUtilisateur(TM, Resultat): TM.result.somme = Resultat('freq_TCCANCELREP') TM.result.produit = Resultat('freq_TCTDELREP')
Ces deux lignes vont instancier la classe ConteneurResultat qui suit :
Code:

1 2 3 4 5 6 7 8 9 class ConteneurResultat(): def __init__(self, freq): self.freq = freq print 'la frequence est : ', freq pass def freq(self): return self.freq def __call__(self): return '__call__'
A la sortie de cet "enchainement" (on va appeler ça comme ça), je voudrais récuppérer TM.result.somme.freq et TM.result.produit.freq.
Le problème c'est que la partie initialisation est effectuée par l'utilisateur c'est lui qui écrit son script et qui déclare les variables qu'il veut (somme, produit, blabla, toto, tata, ...) il peut les appeler comme il veut !
Donc je ne peux pas mettre directement:

Code:

freq_somme = TM.result.somme.freq

puisque je ne sais pas si sa variable il l'a appelé 'somme'...

Comment je peux faire pour récupérer les fréquences relatives a chaque variable déclaré comme attribut de la classe ConteneurResultat?
NB : Je ne peux pas non plus aller lire le code utilisateur !

Est-ce que quelqu'un aurait une idée?

Merci d'avance !

TeqPAF

Je dois avouer ne pas avoir compris... Serait-il possible d'inclure des lignes de doc style

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def blabla(a,b):
    '''DEF:
        sert à additionner un nombre a à l'attribut foo de l'instance b
    IN:
        a <-- int|float|complex
        b <-- Foo object
    OUT:
        None'''
    b.foo+=a
 
def Foo(object):
    '''Classe servant à définir un type d'objet,
    dont le but n'est autre qu'illustrer l'exemple'''
    def __init__(self, val):
        '''DEF:
            init de l'objet
        IN:
            val <-- int|float|complex
        OUT:
            None'''
    self.foo=val

s'il te plaît ?

Et puis dans

Code:

1
2
3
4
5
6
7
8
9
class ConteneurResultat():
    def __init__(self, freq):
        self.freq = freq
        print 'la frequence est : ', freq
        pass
    def freq(self):
        return self.freq
    def __call__(self):
        return '__call__'

la partie en rouge est inutile (la orange aussi) :lol:
Pour la partie en bleu, quel est le but ?