Question basique : Comment répéter un appel à une fonction ?

Version imprimable

Bonjour,

Je m'amuse avec SpeechRecognition pour en faire un Cortana en moins bien mais ma passion c'est de réinventer la roue :mouarf: !
Bref, j'aimerais répéter la dernière commande que j'ai transmise vocalement à mon script. J'utilise une liste et lambda mais je me demande si je fais les choses correctement.

Exemple bidon :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 commands = [] def main_thread(audio): if audio == 'toto': func = lambda : do_something_1(1,2,3) elif audio == 'tata': func = lambda : do_something_2("a","b") elif audio == 'répète': commands[-1]() func() command.append(func) def do_something_1(arg1, arg2, arg3): '''do something''' return True def do_something_2(arg1, arg2): '''do something else''' return False
Je ne vois pas d'autres manières de faire... Dites-moi comment vous auriez géré la chose si le cœur vous en dit !?

Merci d'avance et bonne soirée/journée !

Bonjour

Citation:

Envoyé par LeNarvalo

Dites-moi comment vous auriez géré la chose si le cœur vous en dit !?

C'est juste un souci de persistance des valeur entre chaque appel (style le "static" du C). Ca ce résoud assez facilement.

Si tu ne veux pas en passer par l'objet, alors moi je passerais par un attribut de fonction (ce qui "lie" visuellement la variable avec la fonction)
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 25 from functools import partial def main_thread(audio): if audio == 'toto': func=partial(do_something_1, 1,2,3) main_thread.history.append(func) elif audio == 'tata': func=partial(do_something_2, "a","b") main_thread.history.append(func) elif audio == 'répète': func=main_thread.history.pop() func() # main_thread() def do_something_1(arg1, arg2, arg3): '''do something''' print(arg1, arg2, arg3) return True def do_something_2(arg1, arg2): '''do something else''' print(arg1, arg2) return False main_thread.history=list()
Remarque qq part ça reste de l'objet (une fonction étant un objet)...

16/01/2023, 19h52
Invité

Merci pour ta réponse, je vais me pencher un peu sur functools que je n'utilise jamais. :oops:

Par contre squatter la fonction j'en connais un ou deux qui ne devrait pas être content ! Et puis le pop() ça m'empêcher de "re-répéter"...

Je n'ai pas compris le "Si tu ne veux pas en passer par l'objet", il faudrait que je passe par une class dans l'idéal ?

Citation:

Envoyé par LeNarvalo

Par contre squatter la fonction j'en connais un ou deux qui ne devrait pas être content !

Sisi, c'est autorisé. La fonction c'est un objet donc tu as le droit de lui créer des attributs.

Citation:

Envoyé par LeNarvalo

Et puis le pop() ça m'empêcher de "re-répéter"...

Une fois que le principe est montré...
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 def main_thread(audio): if audio == 'toto': func=partial(do_something_1, 1,2,3) main_thread.history.append((audio, func)) func() elif audio == 'tata': func=partial(do_something_2, "a","b") main_thread.history.append((audio, func)) func() elif audio == "history": print(tuple("%d: %s" % (i, x[0]) for (i, x) in enumerate(main_thread.history))) elif isinstance(audio, int): (label, func)=main_thread.history[audio] print("repeat %d (%s)" % (audio, label)) func() # main_thread()
Citation:

Envoyé par LeNarvalo

Je n'ai pas compris le "Si tu ne veux pas en passer par l'objet", il faudrait que je passe par une class dans l'idéal ?

A la base il n'y a rien d'obligé. Mais avec une classe tu peux commencer une vraie gestion...

16/01/2023, 20h44
Invité

Citation:

Envoyé par Sve@r

Sisi, c'est autorisé. La fonction c'est un objet donc tu as le droit de lui créer des attributs.

Hum, ok ! Je pensais que c'était déconseillé comme pour les instances de classe.

Citation:

Envoyé par Sve@r

A la base il n'y a rien d'obligé. Mais avec une classe tu peux commencer une vraie gestion...

Okay ! Ca me paraît un peu lourd à mettre en œuvre pour le moment.

Merci encore.
16/01/2023, 20h56
fred1599

Citation:

Envoyé par LeNarvalo

Hum, ok ! Je pensais que c'était déconseillé comme pour les instances de classe.

Déconseillé pour des fonctions de modules dont tu ne connais pas les détails d'implémentation...
16/01/2023, 21h00
Invité

Dacodac ! :ange:

Citation:

Envoyé par LeNarvalo

Hum, ok ! Je pensais que c'était déconseillé comme pour les instances de classe.

C'est vrai que depuis P3, on peut faire autrement. Sauf que j'ai encore du mal à voir comment appliquer l'exemple de ce tuto à ton cas...

[edit]Ok, j'y suis arrivé, sans squatter la fonction :king:
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 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 from functools import partial def thread(): def action(m): nonlocal h if m == "toto": func=partial(do_something_1, 1, 2, 3) h.append((m, func)) func() elif m == "titi": func=partial(do_something_2, "x", "y") h.append((m, func)) func() elif m == "history": print(tuple("%d: %s" % (i, x[0]) for (i, x) in enumerate(h))) elif isinstance(m, int): (label, func)=h[m] print("repeat %d (%s)" % (m, label)) func() # if # action() h=list() return action # thread() def do_something_1(arg1, arg2, arg3): '''do something''' print(arg1, arg2, arg3) return True def do_something_2(arg1, arg2): '''do something else''' print(arg1, arg2) return False audio=thread() audio("toto") audio("titi") audio("titi") audio("toto") audio("history") audio(-1) audio(2)
L'astuce c'est que la fonction qu'on appelle (thread) se contente d'initialiser l'historique et de renvoyer une autre fonction qui, elle, fera appel à cet historique lorsqu'elle sera appelée.
Ensuite, quand on appelle l'item créé (audio) on appelle en réalité la fonction "action".

16/01/2023, 22h19
Invité

Citation:

Envoyé par Beginner.

Ben ta méthode est bien je trouve mais pourquoi utiliser une liste, une simple variable (genre last_commande) suffirait, non ?

Oui mais je ne sais pas du tout où je vais donc je prévois large ! ^^

Oki doki Sve@r ! :)

Pourquoi pas un dictionnaire ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
actions = {"toto":lambda:do_something1(1,2,3),
           "tata":lambda:do_something2("a","b")}
 
def main_thread(audio):
    action = actions.get(audio)
    if action:
        actions["répète"] = action
        action()
    else:
        do_default()
 
 
def do_default():
    print("pas compris ou rien à répéter ")
 
def do_something1(*args):
    print(*args)
 
main_thread("toto")
main_thread("répète")

Peut être même qu'un générateur aurait fait l'affaire.

Il y a aussi possibilité avec les dictionnaires comme dis par @josmiley,

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
25
26
27
28
29
30
31
32
33
34
35
36
def func_1(): return 1
 
def func_2(): return 42
 
 
def execute_command(audio):
    if audio == "repeat" and commands["repeat"] is not None:
        func = commands["repeat"]
        commands["repeat"] = None
        return func()
 
     if audio == "repeat" and commands["repeat"] is None:
        return None
 
     if audio in commands:
        commands["repeat"] = commands[audio]
        return commands[audio]()
 
    return None
 
 
commands = {
    "toto": func_1,
    "tata": func_2,
    "repeat": None
}
 
assert execute_command("repeat") is None
assert execute_command("tata") == 42
assert commands["repeat"].__name__ == "func_2"
assert execute_command("repeat") == 42
assert commands["repeat"] is None
assert execute_command("tata") == 42
assert execute_command("toto") == 1
assert commands["repeat"].__name__ == "func_1"
assert execute_command("repeat") == 1

17/01/2023, 12h22
papajoker

bonjour

Citation:

Envoyé par LeNarvalo

Ca me paraît un peu lourd à mettre en œuvre pour le moment.

Oui, le bon mot est bien "le moment" : Puisque tu ne sais pas où tu vas, il n'est pas encore possible de définir des classes. Autant rester avec un code facilement remplaçable (et pas forcément propre "pour le moment"). Donc, pour moi, ta question me semble beaucoup trop anticipée.

Si tu as besoin d'un historique, tu peux aussi regarder du côté des décorateurs ?

Puisque tu désires ratisser "large", il serait bien d'envisager comme commande 2 mots (lancer/fermer navigateur...). Si tu as le dernier python, la nouvelle forme switch case peut être intéressante pour ton cas.
17/01/2023, 20h17
Invité

@papajoker

Je prends note de tout ça ! :)

Je me demandais si en faite c'était pas plus logique de passer du temps à concevoir un plan d'action plutôt que de partir tout azimut. Dis autrement réfléchir à l'architecture du script en amont. Mais pour le coup python serait bien moins amusant à mes yeux. Vive la bidouille !

J'ai peu de connaissance sur les décorateurs, j'en ai utilisé deux ou trois fois sans comprendre ce que je faisais. Je viens de lire un article à ce sujet, ça me paraît plus clair mais pas assez pour voir comment exploiter ça.

J'utilise déjà des commandes avec plusieurs mots, google est assez fort pour reconnaître ce qu'on raconte ! =)

Pour le match case je ne sais pas si c'est bien adapté car j'ai des instructions du genre if 'coupe le son' in texte et des elif 'plus fort' in text or (('augmente' in text or 'monte' in text) and ('son' in text or 'volume' in text or 'audio' in text)). Peut-on utiliser match et case avec in ?

Merci pour vos participations, je suis un peu rassuré je n'ai pas loupé un truc évident ! =)

Citation:

Envoyé par LeNarvalo

Pour le match case je ne sais pas si

Pas fort en recherche web :lol:

Petit exemple avec de quoi s'amuser

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
25
26
27
28
29
30
31
32
33
34
35
36
37
 
def executer(commandes):
    print("\t\t\t\t#quoi  faire de : ", commandes, "?")
    match commandes:
        case ['avancer', direction] if direction == "arrière":
            print("Avancer vers l'", direction, "???????")
        case ['avancer', direction] if direction in ['droite', 'gauche']:
            print("Tourner vers la ", direction)
        case ['avancer', direction] :
            print("Avancer a l'aveuglette vers ", direction)
        case 'avancer':
            print("Avancer vers nulle part !")
        case ['reculer', direction]:
            print("reculer: ", direction)
        case [action, 'le son', *hauteur] if action in ['augmente', 'coupe']:
            print(f'sur le son : {action.upper()}R de :', hauteur)
        case [action, 'le son']:
            print(f'sur le son,  MAUVAISE COMMANDE: {action.upper()}')
        case [action, sur, *params]: # if sur in ('volume','son')
            print("appel à function volume(action, params) qui fait un autre match case en interne")
        case _:
            print("?? commande inconnue :", commandes)
 
# commande :tuple = decouper_ordonner('augmenter le volume de 50 pourcent environ')
# executer(commande)
executer(('avancer','droite'))
executer(('avancer','gauche'))
executer(('avancer','avant'))
executer('avancer')
executer(('reculer', 'droite'))
executer('reculer')  # non géré
executer(('avancer','arrière')) # gère l'erreur
executer(('a', 'b'))
executer(('augmente','le son'))
executer(('augmente','le son', '10%'))
executer(('coupe','le son'))
executer(('éteindre','le son'))

Pour les décorateurs, ici l'idée est juste de ne pas polluer le code métier avec cette histoire d'historique

18/01/2023, 17h16
Invité

Oh la vache c'est un sacré bordel ! Je crois que je vais rester sur mon if 'toto' in text ! :mouarf:

Citation:

Envoyé par LeNarvalo

Oh la vache c'est un sacré bordel !

??? j'attends ton code simple qui peut gérer ces 8 commandes très simples ...

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
25
26
27
28
29
30
31
32
33
34
def executer(commande):
    commandes = [ s for s in commande.split() if len(s)>2 or s.isdigit()]
    match commandes:
        case [action, objet, *params] if objet in ('volume','son'):
            try:
                param = int(params[0]) if params else 10
            except ValueError:
                param = 10
            param = param if action == "augmenter" else param*-1
            if action == "couper": param = -100
            print(f"set_volume({param})")
 
        case ['rechercher',*params] |\
             ['recherche', *params] if 'web' in params:
            print(f"navigateur('http://chercheettrouve.fr?q={'&'.join(params)})")
 
        case ['rechercher',*params] | ['recherche', *params]:
            print(f"find('{' & '.join(params)}')")
 
        case ['fermer', programme]:
            print(f"kill(get_pid('{programme}'))")
 
        case _:
            print("?? commande vovale inconnue :", commandes)
 
 
executer('augmenter le son')
executer('augmenter le son de 15 pourcent')
executer('baisser le volume de 44 pourcent')
executer('couper le son')
executer('fermer python')
executer('rechercher sur le web un tuto python')
executer('recherche web un tuto protocol zéro')
executer('recherche bash python')

Citation:

Envoyé par LeNarvalo

je vais rester sur mon if 'toto' in text !

:roll: mais match/case peut très bien utiliser cette syntaxe (fait ici pour détecter les commandes volume/son)

Ben c'est le bordel dans le sens que c'est pas facilement lisible.

Code:

1
2
3
4
5
case ['rechercher',*params] |\
     ['recherche', *params] if 'web' in params:
 
#commands = r.recognize_google(audio, language="fr-FR")
elif 'recherche' in commands and 'web' in commands:

Et si plus compliqué :

Code:

1
2
3
4
5
6
commands = 'recherches sur le web si toto habite sur la planète mars'
for w in ('recherche', 'web', 'toto', 'planète', 'mars'):
    if w not in commands:
        break
else:
    print('Oui')

PS : Ou plus mieux :

Code:

all(w in commands for w in ('recherche', 'web', 'toto', 'planète', 'mars'))

18/01/2023, 23h54
papajoker
Tu ne me sembles pas trop objectif ... ici, tu ne réponds pas en ne donnant QUE les 2 exemples les plus simples (ta demande était sur le volume). Il est clair que pour une structure simple, match/case est surdimensionné. Je suppose que tu désires avoir 50 commandes dont certaines complexes ?
ps: ton second exemple : rien à voir avec le mien beaucoup plus simple : recherche de mots sur le web et autre commande* distincte sur disque dur, toi, je ne vois pas de (simulation de) commande* mais juste un parcours des mots
* : oui, mes commandes ne sont que des "print"

De plus, tu ne sembles pas avoir lu la doc

case ['rechercher',*params] | ['recherche', *params] if 'web' in params: pas top ok mais existe d'autres formes ! Mais en fonction de ton besoin (et si j'écris toutes les formes, tu vas justement me dire que c'est trop compliqué :lol:)

case [('cherche'|'chercher'|'recherche'), *params]:.
ou, ce qui me semble plus réaliste suivant ta demande (commandes vocales) :
Code:

1 2 cles_recherche = ('trouver','cherche','chercher','recherche','rechercher') # lire depuis params de l'app case cles_recherche as action, *params: print(action, params)
Pas de regex dans la condition case (type case [regex,autre]) mais il est possible dans match d'avoir le résultat d'une regex
22/01/2023, 11h43
wiztricks

Citation:

Envoyé par LeNarvalo

Je ne vois pas d'autres manières de faire... Dites-moi comment vous auriez géré la chose si le cœur vous en dit !?

On étudie le command pattern pour en comprendre la structure, comment l'adapter à son code et les simplifications dans sa réalisation avec Python.

- W