IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Python Discussion :

Enregistrer une liste de commande pour les reexecute plus tard


Sujet :

Python

  1. #1
    Membre du Club
    Inscrit en
    Juillet 2008
    Messages
    167
    Détails du profil
    Informations forums :
    Inscription : Juillet 2008
    Messages : 167
    Points : 58
    Points
    58
    Par défaut Enregistrer une liste de commande pour les reexecute plus tard
    Bonjour,
    j'ai un petit soucis avec EVAL(),
    Objectif: enregistrer des commandes dans un fichier, puis les exécuter plus tard, dans le même ordre et avec les même paramètres.(record/play)
    voila mon script
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
     
    class Myclass():
    	def funct_1(self):
    		print "function one"
     
    	def funct_2(self, param1):
    		x = parm1 + 1
    		print x
    puis:
    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
    33
     
    import Myclass
     
     class Saver(): 
    	def __init__(self):
    		global _obj
    		_obj = Myclass()
     
    	def getListCmd(self):
            """Recupere la liste des commandes a enregistre
            """
            cmd = []
            m_cmd =""
            print """
                    tapez les commandes  que vous voulez rajouter au fichie
                   """
            while (m_cmd != "end"):
                m_cmd = raw_input(sys.ps1)
                if m_cmd != "end":
                    m_dict = _obj.__class__.__dict__
     
                    list_cmd = eval(m_cmd,m_dict)
                    cmd.append(list_cmd)
                    self.log.info("add test %s "%list_cmd)
            return cmd
     
        def save(self,m_file):       
            fichier = open(m_file, "wb")
            self.log.info("Creat record file %s "%m_file)
            self.list_scenario_record =  self.getListCmd()
            cPickle.dump(self.list_scenario_record, fichier)
            self.log.info("End record ")
            fichier.close()
    en executant , j'ai ce message d'erreur:
    TypeError: funct_1() takes exactly 1 argument (0 given)
    ben le seul argument est "self" donc sans argument .
    avez vous une idée???

  2. #2
    Membre éprouvé
    Homme Profil pro
    Inscrit en
    Décembre 2007
    Messages
    758
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France

    Informations professionnelles :
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Décembre 2007
    Messages : 758
    Points : 970
    Points
    970
    Par défaut
    bonjour,

    lorsqu'on appelle une méthode de classe, implicitement le premier argument ( désigné self) est automatiquement relié à l'instance de la classe manipulée. Si tu appelles la méthode indépendamment de l'instance alors cette liaison n'est pas effectuée.

    en gros:

    si:

    alors:

    et

    sont équivalents.

    Ici, ton eval prend en argument le dictionnaire de la classe Myclass, ce qui permet de rendre la fonction func_1 disponible. Pour autant eval ne sait pas sur quelle instance doit s'exécuter la fonction, d'où le message d'erreur.

  3. #3
    Membre du Club
    Inscrit en
    Juillet 2008
    Messages
    167
    Détails du profil
    Informations forums :
    Inscription : Juillet 2008
    Messages : 167
    Points : 58
    Points
    58
    Par défaut
    ok merci
    simple précis et concis

  4. #4
    Membre du Club
    Inscrit en
    Juillet 2008
    Messages
    167
    Détails du profil
    Informations forums :
    Inscription : Juillet 2008
    Messages : 167
    Points : 58
    Points
    58
    Par défaut
    en fait , j'avais bien creer un objet
    _obj = Myclass()
    et j'utilise bien les attributs de cette objet
    m_dict = _obj.__class__.__dict__
    list_cmd = eval(m_cmd,m_dict)
    j'ai enchanté trop rapidement

  5. #5
    Expert éminent sénior
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 204
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 204
    Points : 36 632
    Points
    36 632
    Par défaut
    Salut,

    Juste pour infos, il y a deux bibliothèques/modules Python qui sont peut être à regarder/utiliser dans ce cas.

    cmd: permet de construire des interfaces de type commandes voir exemple de D.Hellmann
    C'est adapté pour construire une interface "détachée" du code qui exécutera les commandes.

    code: permet de construire un interpréteur Python et de le contrôler. Il y a plein d'exemples sur Google mais ils sont assez limités.

    Dans les deux cas, on contrôle ce qui a été tapé et rejouer peut se résumer à sauvegarder les bonnes commandes pour les rejouer.

    Une autre stratégie pourrait être de sauvegarder la séquence des commandes côté "code" mais cela demande de créer une interface supplémentaire (entre les "strings" tapées par l'utilisateur et ce qui sera, in fine, exécuté).
    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  6. #6
    Membre du Club
    Inscrit en
    Juillet 2008
    Messages
    167
    Détails du profil
    Informations forums :
    Inscription : Juillet 2008
    Messages : 167
    Points : 58
    Points
    58
    Par défaut
    disant que je m'approche du but, je ne comprends pas pourquoi il considère pas _obj comme objet

  7. #7
    Membre du Club
    Inscrit en
    Juillet 2008
    Messages
    167
    Détails du profil
    Informations forums :
    Inscription : Juillet 2008
    Messages : 167
    Points : 58
    Points
    58
    Par défaut
    Bonjour,
    je me permet de relancer, car je ne comprend toujours pas pourquoi je n'arrive pas a récupéré la liste des mothode d'une instance de classe.
    voila j'ai réécris le script:
    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
     
    class TestEval:   
     
        Name = "BaseClass"
        # __init__ is a class constructor    
        def __init__(self, arg1, arg2):
            # These values are created
            # when the class is instantiated.
            self.value1 = arg1
            self.value2 = arg2
     
        def display(self):
            print self.Name
            print self.value1
            print self.value2
    et
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
     
    import TestEvalMod
     
    class GetEval:
     
        def getListCmd(self):               
            #creation de l'objet 
            global _obj
            _obj = TestEvalMod.TestEval(1,2)
            m_dict = _obj.__dict__        
            print m_dict
     
    a = GetEval()
    a.getListCmd()
    et voila le resultat:
    D:\brouillon>python GetEval.py
    {'value2': 2, 'value1': 1}

  8. #8
    Expert éminent sénior
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 204
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 204
    Points : 36 632
    Points
    36 632
    Par défaut
    Salut,
    je me permet de relancer, car je ne comprend toujours pas pourquoi je n'arrive pas a récupéré la liste des mothode d'une instance de classe.
    modules, class et instances ont tous leurs __dict__
    Imaginez que la classe TestEval sous classe d'autres classes A, B, C

    Chacune aura son __dict__ et une instance de TestEval aura son propre __dict_ dans lequel pourront être rangées attributs et méthodes associée à l'instance.

    Lorsque l'interpréteur essaie de trouver à quoi correspond un attribut, il regardera dans le __dict__ de l'instance, s'il ne trouve rien il ira voir dans celui de la classe.

    Maintenant par rapport à ce que j'ai compris de ce que vous souhaitiez faire:
    1 - vous récupérez un identifiant tapé à la console,
    2 - si la méthode correspondante existe, vous l'exécutez et affichez son retour ou vous affichez une erreur

    Les fonction hasattr, getattr,... "savent" comment utiliser les informations dans la hiérarchie de __dict__ associée à un objet et sont largement suffisante pour faire ce que vous voulez.

    Ce que çà ne fait pas c'est retourner la liste de... mais pour autant que cela vous soit utile ici, regardez le module inspect.
    Bon courage,
    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  9. #9
    Membre du Club
    Inscrit en
    Juillet 2008
    Messages
    167
    Détails du profil
    Informations forums :
    Inscription : Juillet 2008
    Messages : 167
    Points : 58
    Points
    58
    Par défaut
    je pense que j'ai pas bien expliqué le probleme , je reprends,
    voila ce que j'ai fais jusqu'a maintenant:
    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
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
     
    obj = module.MyClass() # MyClass contient les methodes qu'on peut exécuter (function_name)
     
    function_name = 'function_1' #nom de la methode a ecéxuté 
    tests_function_1=[]
    tests_function_1.append([function_name, (parm1, parm2)])
    function_name = 'function_2'
    tests_function_2=[]
    tests_function_2.append([function_name, (parm8, parm9)])
     
    tests_all = [] \
        + tests_function_1 \
    	+ tests_function_2 \
        + []
     
    def run(tests = tests_all):
        pass_count = 0
        fail_count = 0
        rest_count = len(tests)
        for test_item in tests:
            print '-' * 60
            f_name, f_args = test_item
            ## Get the function object
            func = getattr(obj, f_name, None)
            # Check if function exists
            if not func:
                log.error("ERROR: test function '%s' doesn't exist" % f_name)
                continue
            # Run the test
            try:
                log.info("RUNNING: test function '%s%s'" % (f_name, str(f_args)))
                rest_count = rest_count - 1
                ## Call the test function
                if not f_args:
                    func()         ## No arguments
     
                else:
                    func(*f_args)  ## Many arguments    
                pass_count = pass_count + 1
            except KeyboardInterrupt:
                break
            except:
                # An error occured
                log.warn("WARNING: test function '%s' failed" % f_name)
                fail_count = fail_count + 1
        log.info('=' * 60)
        log.info("Results: ran %d tests, %d pass, %d fail, %d remaining" %
                (len(tests), pass_count, fail_count, rest_count))
        log.info('=' * 60)
     
    def main():
        run()
    donc je rentre les fonctions sous le format:
    [nom de la fonction, (paramètre, paramètres, ...)]
    et sa marche, maintenant je souhaite rentrer la liste des fonctions sous le format standard
    nom_fonction(paramètre, paramètres, ...)
    je ne sais pas si vous avez compris l'objectif de ma démarche
    en tout cas merci infiniment pour vos interventions toujours aussi constructives.

  10. #10
    Membre du Club
    Inscrit en
    Juillet 2008
    Messages
    167
    Détails du profil
    Informations forums :
    Inscription : Juillet 2008
    Messages : 167
    Points : 58
    Points
    58
    Par défaut
    j'ai trouvé ,
    en fait il suffit juste de faire un:
    exec(self.obj.commande)
    merci a tous

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Réponses: 4
    Dernier message: 30/11/2011, 14h22
  2. Compter les produits d'une liste de commande
    Par Asterius dans le forum Hibernate
    Réponses: 0
    Dernier message: 23/02/2010, 01h36
  3. Filtrer une list "Assigned To" pour les taches
    Par lcaufrie dans le forum SharePoint
    Réponses: 2
    Dernier message: 20/04/2009, 15h16
  4. [VBA-E]Archiver une mise en forme pour la reproduire plus tard
    Par tazamorte dans le forum Macros et VBA Excel
    Réponses: 10
    Dernier message: 31/01/2007, 12h12
  5. [debutant][JNI]Stocker des objet pour les rappeler plus tard
    Par Celenor dans le forum Entrée/Sortie
    Réponses: 7
    Dernier message: 28/03/2004, 03h28

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo