Une calculatrice extensible en notation polonaise inverse

INTRODUCTION

Comme j'ai beaucoup travaillé avec des calculatrices HP utilisant cette technique de calcul, je me suis amusé à en faire une en Python qui fonctionne en console.

Le principe de la "notation polonaise inverse" est de mettre les opérateurs après les données qu'ils doivent traiter. Ainsi, un calcul '2+3' s'écrira en fait: '2 3 +'. Autre exemple plus complexe: un calcul '3+(1+2)*4' s'écrira comme '3 1 2 + 4 * +'. Plus d'information ici:
https://fr.wikipedia.org/wiki/Notati...onaise_inverse

L'avantage principal est qu'on se passe complètement des parenthèses. En contrepartie, il faut un peu de pratique pour faire ça couramment...

C'est une technique de traitement basée sur une pile 'lifo' (last in, first out). Il y a d'ailleurs un langage complet basé sur cette technique, le 'Forth', que j'ai un peu pratiqué dans le passé:
https://fr.wikipedia.org/wiki/Forth_(langage) .

Ce que je vous propose ici, c'est un code avec comme priorité la simplicité et la lisibilité. J'ai donc exclu les astuces complexes qui pourraient rendre le calcul plus rapide. J'ai aussi exclu les nombreuses vérifications qu'il faudrait faire pour en faire un outil de production (en prenant en charge toutes les bêtises possibles de l'utilisateur...), mais il vous sera facile de les ajouter. J'ai aussi facilité la possibilité d'ajouter toutes les fonctions dont vous avez besoin, autant que vous le souhaitez. Vous pouvez donc vous faire une calculatrice NPI sur mesure...


DESCRIPTION DU CODE


Pile 'lifo'

Pour stocker les opérateurs, ses arguments, et son résultat, on utilise une pile 'lifo' (last in, first out). La pile ici s'appelle 'pile' (ça, c'est original :D) qui est de type 'list'. On la met en variable globale pour éviter les très nombreux passages de paramètres. On pourrait aussi utiliser les listes de type 'deque' du module 'collections'. La déclaration de la pile est donc ici (il est difficile de faire plus simple...):

Code:

---

pile = []

---

Dictionnaire des opérateurs et fonctions associées

Il faut pouvoir reconnaître l'opérateur ('+', '-', etc...) et savoir quelle fonction doit être exécutée. Le meilleur objet le plus rapide pour faire ça est un dictionnaire. Voilà celui utilisé ici:

Code:

---

1 2 3 4 5

# dictionnaire des opérateurs operateurs = {'+':plus, '-':moins, '*':mult, '/':divis, '//': divisint, '^':puiss, 'dup': dup, 'swap': swap, 'sin': sinus, 'cos': cosinus, 'sqrt': mathsqrt, 'pi': mathpi, 'sum': sommeliste, 'mult': multliste, 'factprem': factprem}

---

Ce dictionnaire est placé en variable globale pour les mêmes raisons que la pile.


Dictionnaire des variables et de leurs valeurs

Au court d'une session, on peut créer une variable, lui affecter une nouvelle valeur et l'utiliser dans une expression à calculer. Ces variables et leurs valeurs sont placées dans un dictionnaire pour une rapidité d'accès.

Pour déclarer une nouvelle variable ou changer sa valeur, on tape le nom de la variable précédée de ':' (exemple ':toto'). Quand on utilise la variable, on n'utilise pas ce caractère (exemple 'toto').

Code:

---

1 2	# dictionnaire des variables variables = {}

---

Ce dictionnaire est placé en variable globale pour les mêmes raisons que la pile.


Fonctions de traitement associées aux opérateurs

Chaque opérateur reconnu dans l'expression à calculer lancera la fonction qui lui est associée, et qui:

- dépilera les arguments donc elle a besoin

- fera le traitement demandé

- empilera le résultat

Voilà l'exemple de la fonction associée à '+':

Code:

---

1 2 3 4

def plus(): """ opérateur '+'     """ pile.append(pile.pop()+pile.pop())

---

Il faut, bien sûr, faire attention aux fonctions qui nécessitent que les arguments soient dans un ordre donné. Voilà l'exemple d'une fonction division associée à l'opérateur '/':

Code:

---

1 2 3 4 5

def divis(): """ opérateur '/'     """ b, a = pile.pop(), pile.pop() pile.append(a/b)

---

Fonction d'évaluation de l'expression saisie

La fonction d'évaluation de l'expression saisie, convertit cette expression en liste si nécessaire, et teste chaque élément de cette liste (token):

- si c'est un opérateur => on exécute la fonction associée à cet opérateur, qui récupèrera les arguments dont elle a besoin sur la pile et empilera son résultat.

- si c'est une chaîne de caractère précédée de ':', il s'agit d'une nouvelle variable, ou d'une variable existante dont on veut changer la valeur. Sa valeur est celle du sommet de la pile.

- si c'est une variable existante dans le dictionnaire des variables, on la remplace par sa valeur.

- dans les autres cas, c'est un argument, et on l'empile sur la pile. Comme l'argument est une chaine (str), on utilise eval pour le convertir en objet Python. Cela permettra d'avoir, bien sûr, des nombres (int et float), mais aussi des objets plus complexes comme des listes (type list) ou des dictionnaires (type dict). Ainsi, cette calculatrice supporte le traitement des objets Python quelconques: int, float, list, dict, ...

Voilà la fonction d'évaluation NPI:

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

def eval_npi(expression): """Calcule une expression (chaine ou liste) écrite selon la notation        polonaise inverse. Si l'expression est une chaine, les données sont        séparées par des espaces. Possibilité d'utiliser des variables.        Attention: une donnée ne doit pas elle-même contenir d'espaces !     """ # Convertit en liste si nécessaire ====================================== if isinstance(expression, str): expression = expression.split()   # Calcule =============================================================== for token in expression:   if token in operateurs: # => lancement de la fonction associée à l'opérateur reconnu operateurs[token]()   elif token.startswith(':'): # création de la variable ou affectation d'une nouvelle valeur variables[token[1:]] = pile[-1]   elif token in variables: # empilage de la valeur de la variable reconnue pile.append(variables[token])   else: # empilage de la donnée dans son type d'origine (quelconque) pile.append(eval(token))   # Lit, dépile et retourne le résultat =================================== return pile.pop()

---

Interpréteur pour la console

C'est une fonction avec une boucle de type 'read-eval-print' qui ne s'arrêtera que si on le demande (ici => saisie de 'stop'), et fera donc:

- saisie de l'expression à calculer

- test pour savoir si l'utilisateur demande l'arrêt de la calculatrice

- évaluation de l'expression à calculer par la fonction précédente 'eval_npi(expression)

- affichage du résultat de cette évaluation

- retour à la saisie

Voilà la fonction proposée:

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

def interp_npi(): """Interpréteur (boucle read-eval-print) de calcul en notation polonaise        inverse. Pour la saisie, chaque donnée est séparée par un espace.        Attention: une donnée ne doit pas contenir elle-même d'espace !        Écrire "stop" pour arrêter le programme     """ while True:   # saisit l'expression à calculer ==================================== expression = input("?: ")   # teste pour arrêter le programme =================================== if expression.strip() == "stop": print("Arrêt demandé") break   # Calcule l'expression ============================================== try: resultat = eval_npi(expression) except Exception as msgerr: resultat = "Erreur: " + str(msgerr)   # Affiche le résultat =============================================== print(resultat)

---

Vous voyez que, en cas d'erreur de calcul, cet interpréteur récupère l'exception et en affiche le message d'erreur. Par exemple:

Code:

---

1 2	?: 1 0 / Erreur: division by zero

---

Exemples d'utilisation de l'interpréteur en console

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

# en Python: 2+3 ?: 2 3 + 5   # en Python: 3+(1+2)*4 ?: 3 1 2 + 4 15   # en Python: 2**100 ?: 2 100 ^ 1267650600228229401496703205376   # en Python: sin(5) ?: 5 sin -0.9589242746631385   # en Python: sum([1,2,3,4,5]) ?: [1,2,3,4,5] sum 15   # en Python: math.sqrt(2) ?: 2 sqrt 1.4142135623730951   # en Python: math.pi ?: pi 3.141592653589793

---

Ajout de fonctions supplémentaires

On voit bien ici la facilité avec laquelle on peut ajouter des fonctions supplémentaires:

- on ajoute au dictionnaire le nom de l'opérateur comme clé, avec comme valeur le nom de la fonction de traitement (sans ses parenthèses!).

- on ajoute la fonction de traitement

A titre d'exemple, j'ai mis comme fonction supplémentaire la décomposition d'un nombre entier en facteurs premiers, qu'on ne trouve pas souvent dans une calculatrice. Opérateur: 'factprem' et fonction à appeler: 'facteurspremiers'. Voilà un exemple d'utilisation:

Code:

---

1 2	?: 12345678901234567890 factprem [2,3,3,5,101,3541,3607,3803,27961]

---

On peut bien sûr vérifier que c'est juste puisque j'ai ajouté une fonction qui calcule le produit de tous les éléments d'une liste: 'multlist' qui sera appelé par l'opérateur 'mult':

Code:

---

1 2	?: [2,3,3,5,101,3541,3607,3803,27961] mult 12345678901234567890

---

Et voilà le code complet:

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 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218

# -*- coding: utf-8 -*-   import math   #############################################################################◙ def facteurspremiers(n): """Décompose un nombre entier n en facteurs premiers par la méthode des        divisions. Retourne la liste des facteurs premiers trouvés.        Si la liste ne retourne qu'un seul élément égal à n: n est premier     """ n = int(n) # au cas où n ne serait pas entier if n<2: return [] # pas de nombre premier avant 2 np = [] # liste pour stocker les nombres premiers trouvés   # recherche de tous les facteurs 2 s'il y en a ========================== while n>=2: q, r = divmod(n, 2) if r==0: np.append(2) # on a trouvé un nouveau facteur 2 n = q else: break # plus de facteur 2   # recherche les facteurs premiers > 2 =================================== i = 3 rac2n = int(math.sqrt(n))+1 # limite de recherche pour i while i<=n: if i > rac2n: np.append(n) # on empile le n restant break # on a fini q, r = divmod(n, i) if r==0: np.append(i) # on a trouvé un nouveau facteur premier n = q else: i += 2 # on ne teste que les nombres impairs   # retourne la liste des nombres premiers trouvés ======================== return np   ############################################################################# def plus(): """ opérateur '+'     """ pile.append(pile.pop()+pile.pop())   #============================================================================ def moins(): """ opérateur '-'     """ b, a = pile.pop(), pile.pop() pile.append(a-b)   #============================================================================ def mult(): """ opérateur '*'     """ pile.append(pile.pop()*pile.pop())   #============================================================================ def divis(): """ opérateur '/'     """ b, a = pile.pop(), pile.pop() pile.append(a/b)   #============================================================================ def divisint(): """ opérateur '//'     """ b, a = pile.pop(), pile.pop() pile.append(int(a//b))   #============================================================================ def puiss(): """ opérateur puissance '^' (** en Python)     """ b, a = pile.pop(), pile.pop() pile.append(a**b)   #============================================================================ def dup(): """ duplique le dernier élément de la pile     """ pile.append(pile[-1])   #============================================================================ def swap(): """ inverse les deux derniers éléments de la pile     """ b, a = pile.pop(), pile.pop() pile.append(b) pile.append(a)   #============================================================================ def sinus(): """Calcule le sinus     """ pile.append(math.sin(pile.pop()))   #============================================================================ def cosinus(): """Calcule le cosinus     """ pile.append(math.cos(pile.pop()))   #============================================================================ def mathpi(): """Empile la valeur de pi du module math     """ pile.append(math.pi)   #============================================================================ def mathsqrt(): """Calcule la racine carrée de la dernière valeur empilée     """ pile.append(math.sqrt(pile.pop()))   #============================================================================ def sommeliste(): """Calcule la somme des éléments d'une liste     """ pile.append(sum(pile.pop()))   #============================================================================ def multliste(): """Calcule le produit des éléments d'une liste     """ liste = pile.pop() produit = 1 for elem in liste: produit *= elem pile.append(produit)   #============================================================================ def factprem(): """Décompose le nombre au sommet de la pile en facteur premiers par la        méthode des divisions. Empile les résultats sous forme de liste     """ pile.append(facteurspremiers(pile.pop()))   ############################################################################# def eval_npi(expression): """Calcule une expression (chaine ou liste) écrite selon la notation        polonaise inverse. Si l'expression est une chaine, les données sont        séparées par des espaces. Possibilité d'utiliser des variables.        Attention: une donnée ne doit pas elle-même contenir d'espaces !     """ # Convertit en liste si nécessaire ====================================== if isinstance(expression, str): expression = expression.split()   # Calcule =============================================================== for token in expression:   if token in operateurs: # => lancement de la fonction associée à l'opérateur reconnu operateurs[token]()   elif token.startswith(':'): # création de la variable ou affectation d'une nouvelle valeur variables[token[1:]] = pile[-1]   elif token in variables: # empilage de la valeur de la variable reconnue pile.append(variables[token])   else: # empilage de la donnée dans son type d'origine (quelconque) pile.append(eval(token))   # Lit, dépile et retourne le résultat =================================== return pile.pop()   ############################################################################# def interp_npi(): """Interpréteur (boucle read-eval-print) de calcul en notation polonaise        inverse. Pour la saisie, chaque donnée est séparée par un espace.        Attention: une donnée ne doit pas contenir elle-même d'espace !        Ecrire "stop" pour arrêter le programme     """ while True:   # saisit l'expression à calculer ==================================== expression = input("?: ")   # teste pour arrêter le programme =================================== if expression.strip() == "stop": print("Arrêt demandé") break   # Calcule l'expression ============================================== try: resultat = eval_npi(expression) except Exception as msgerr: resultat = "Erreur: " + str(msgerr)   # Affiche le résultat =============================================== print(resultat)   ############################################################################# if __name__ == "__main__":   # pile de calcul ======================================================== pile = []   # dictionnaire des opérateurs =========================================== operateurs = {'+':plus, '-':moins, '*':mult, '/':divis, '//': divisint, '^':puiss, 'dup': dup, 'swap': swap, 'sin': sinus, 'cos': cosinus, 'sqrt': mathsqrt, 'pi': mathpi, 'sum': sommeliste, 'mult': multliste, 'factprem': factprem}   # dictionnaire des variables ============================================ variables = {}   # Lancement de l'interpréteur NPI ======================================= interp_npi()

---

CONCLUSION

Vous voyez que, malgré la simplicité de son code (copieusement commenté), l'ajout possible de nouvelles fonctions et la possibilité de traiter n'importe quel objet Python donnent à cette calculatrice NPI de grosses potentialités qu'on ne trouve pas ailleurs sur le web.

Mais ce n'est qu'une calculatrice et non un langage! Pour que ça en devienne un, il faudrait ajouter beaucoup de choses, en commençant par des structures de contrôle (if, for, while, ...). On pourrait peut-être s'inspirer du langage Forth? Un simili Forth qui pourrait traiter n'importe quel objet Python. Un rève ? Et pourquoi pas un projet? :D

Amusez-vous bien! Et bons calculs NPI ! :D