Problème de listes dans un calculateur

Version imprimable

1 pièce(s) jointe(s)

Bonjour,
Je commence à apprendre à programmer en Python ; ainsi, j'ai voulu coder une fonction qui, à partir de deux arguments, en calcule la somme, la différence, le produit, le quotient, l'exponentiation, ou même la concaténation selon ce que souhaite l'utilisateur.
Mon premier programme fonctionnait, puis j'ai voulu le rendre plus complexe : l'utilisateur peut attribuer une liste de chaîne de caractères ('addition', ...) à la variable opération, pour que toutes ces opérations soient effectuées à la suite, dans l'ordre.
Mais mon programme ne fonctionne pas correctement lorsque j'entre des listes : est-ce que quelqu'un peut m'expliquer d'où vient le problème ?

Voilà le programme :

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
44
45
46
47
48
49
def calc(x, y):
    operation = input("Entrez le type d'opération à* effectuer : ")
    if isinstance(operation, list):
        for i in range(len(operation) - 1):
            if type(x) == type(y):
                if isinstance(x, str):
                    if (operation[i] == 'concaténation' or operation[i] == 'Concaténation'):
                        return(x+y)
                    else:
                        print('Erreur')
                elif isinstance(operation[i], str):
                    if (operation[i] == 'addition' or operation[i] == 'Addition'):
                        return(x+y)
                    elif (operation[i] == 'soustraction' or operation[i] == 'Soustraction'):
                        return(x-y)
                    elif (operation[i] == 'multiplication' or operation[i] == 'Multiplication'):
                        return(x*y)
                    elif ((operation[i] == 'division' or operation[i] == 'Division') and not y == 0):
                        return(x/y)
                    elif ((operation[i] == 'exponentiation' or operation[i] == 'Exponentiation') and not (x, y) == (0, 0)):
                        return(x**y)
                    else:
                        print('Erreur')
                else:
                    print('Erreur')
            else:
                print('Erreur')
    else:
        if type(x) == type(y):
            if isinstance(x, str):
                if (operation == 'concaténation' or operation == 'Concaténation'):
                    return(x+y)
                else:
                    print('Erreur')
            elif isinstance(operation, str):
                if (operation == 'addition' or operation == 'Addition'):
                    return(x+y)
                elif (operation == 'soustraction' or operation == 'Soustraction'):
                    return(x-y)
                elif (operation == 'multiplication' or operation == 'Multiplication'):
                    return(x*y)
                elif ((operation == 'division' or operation == 'Division') and not y == 0):
                    return(x/y)
                elif ((operation == 'exponentiation' or operation == 'Exponentiation') and not (x, y) == (0, 0)):
                    return(x**y)
                else:
                    print('Erreur')
            else:
                print('Erreur')

Pièce jointe 292598

09/07/2017, 13h25
fred1599

Bonjour,

En fait vous souhaitez montrer toutes les mauvaises pratiques (je caricature un peu j'avoue) en python à la fois ? ;)

Je pense qu'il faut revoir la conception et ce qu'offre python comme outils pour votre problématique. Pour cela rien de tel qu'un bon tutoriel, comme celui de Swinnen très connu.

Le nombre de mot clé isinstance semble trop important, savez-vous qu'en C on ne vérifie pas les types ? Et pourtant on est capable de résoudre le même problème. Prenez attention aux vérifications de types type(x) == type(y) qui n'est plus adapté aux versions actuelles python.

On souhaite évaluer une expression dont le type est str, prenez le temps de regarder sympy.

Il y a comme souvent en python, beaucoup d'autres solutions, je vous laisse rechercher comment évaluer une expression mathématiques sur votre moteur de recherche préféré.
09/07/2017, 13h33
Neirp

Merci beaucoup pour le lien, je vais regarder :)
10/07/2017, 17h36
Sve@r
Bonjour

Déjà vite fait, on peut simplifier une instruction de ce style if (operation == 'addition' or operation == 'Addition') en if (operation.lower() == 'addition').
Ensuite il faut essayer de décorréler le code qui fait un travail ; de l'affichage du résultat de ce travail. C'est ce qu'on nomme la philosophie "MVC" (Modèle/Vue/controleur). Le modèle, c'est tout ce qui concerne le stockage permanent (fichier, bdd, etc). Bon ici il n'y en a pas. La vue, c'est la façon de rentrer les valeurs (par le clavier, un port série, etc) et de récupérer le résultat (à l'écran, dans un mail, etc). Et le controleur c'est tout ce qui concerne le traitement des données (les calculs).
En faisant de la sorte, tu gagnes en simplicité et en évolutivité. Donc par exemple remplacer les print("erreur") par un code retour, voire même un raise pourquoi pas, en laissant à l'appelant le soin de gérer ce retour (afficher le pb, ne pas l'afficher mais l'arranger, etc). Ansi, le but de la fonction "calc" étant de faire un calcul, elle ne doit faire que ce calcul (et non afficher ses états d'âme).

Et enfin on gagne aussi à commencer par filtrer tous les soucis éventuels pour pouvoir ensuite être tranquille au lieu de tout évaluer selon l'avancée de son code. Et donc remplacer un code de ce type
Code:

1 2 3 4 5 6 7 if isinstance(x, str): if (operation == 'concaténation' or operation == 'Concaténation'): return(x+y) else: print('Erreur') else: print("Erreur")
par un code de ce type
Code:

1 2 3 4 5 if not isinstance(x, str): return None if (operation.lower() != 'concaténation'): return None return x+y
C'est moins académique (le puriste te dira qu'il ne doit y avoir qu'un seul return par fonction) mais ç'est bien plus simple ensuite à faire évoluer...

Salut,

Citation:

Envoyé par Neirp

Mais mon programme ne fonctionne pas correctement lorsque j'entre des listes : est-ce que quelqu'un peut m'expliquer d'où vient le problème ?

Vous avez au moins 2 soucis.
Le premier est ici:
Code:

1 2 operation = input("Entrez le type d'opération à* effectuer : ") if isinstance(operation, list):
input retournera toujours une chaîne de caractère (peut être vide).
Si l'utilisateur entre plusieurs opérations (séparés par des espaces), il va falloir découper cette chaines en liste de... avec .split() qui retournera une liste de 0, 1 ou plus ~~d'opérations~~ chaînes de caractères.

Puis vous allez avoir un autre soucis car si vous écrivez une fonction qui contient une boucle avec des "return" dedans, genre:
Code:

1 2 3 4 5 6 def calc(x, y): ... for i in range(len(operation) - 1): ... if (operation[i] == 'concaténation' or operation[i] == 'Concaténation'): return(x+y)
la fonction (et la boucle) se terminera dès l'exécution du premier "return" rencontré.

Si calc(x, y) "fonctionne", il serait plus simple d'ajouter dans les arguments l'opération à effectuer (et donc la saisir en dehors) i.e.:
Code:

1 2 3 saisie des opérations, for op in operations: print (op, calc(x, y, op))
- W