Partage

[exercices][confirmé] Calculatrice simple mais précise

1 2 >>

Anonyme

4 juillet 2010 à 12:37:43

Créer une calculatrice (mode console), simple, mais avec une précision décimale (module decimal)

N'oubliez pas de prendre en compte exceptions et erreurs

Résultat : Lundi soir

Merci de votre participation

Exemple d'utilisation du module Decimal et de son intérêt.

>>> 5.75/2.5
2.2999999999999998 # Arithmétique flottante
>>> from decimal import Decimal as D
>>> D('5.75')/D('2.5')
Decimal('2.3') # Arithmétique décimale

Voila mon code en version 2.6

import decimal, re, operator
entree=re.compile(r'''(?x)   # autorise les commentaires et les espaces
                 (\d+\.?\d*) # nombre avec partie fractionnaire éventuelle
                 \s*         # espaces éventuels
                 ([-+/*])    # opérateur
                 $''')       # fin de chaîne

oper={ '+' : operator.add, '-' : operator.sub, '*' : operator.mul, '/' : operator.truediv}

total=decimal.Decimal('0')

def affiche_total():
    print '=====\n', total
print """Bienvenue dans la calculatrice :
Entrez un nombre et un opérateur,
une ligne vide pour voir le résultat courant,
q pour quitter :"""
while True:
    try:
        ligne_bande=raw_input().strip()
    except EOFError:
        ligne_bande='q'
    if not ligne_bande:
        affiche_total()
        continue
    elif ligne_bande=='q':
        affiche_total()
        break
    try:
        num_text, op = entree.match(ligne_bande).groups()
    except AttributeError:
        print 'Entree incorrecte : %r' % ligne_bande
        print 'Entree un nombre et un operateur, une ligne vide pour le total, q pour quitter'
        continue
    total=oper[op](total, decimal.Decimal(num_text))

EPonix

4 juillet 2010 à 12:48:55

Peux tu développer le problème s'il te plait ?

Quelles sont les syntaxes autorisés ?
La calculatrice c'est simplement un menu avec le choix de l'opération ?

Skety

4 juillet 2010 à 12:55:07

Excuser moi, je ne voudrais pas casser ce topic mais à cette allure on aura un gros désordre sur ce forum je pense avec cette manière de procéder, je crois que l'on devrait d'abord discuter de la marche à suivre du "comment" dans propositions d'exercices avant de se lancer dans une course du genre : "je suis un héro, j'ai proposer beaucoup d'exercices, blablabla..." ici

Anonyme

4 juillet 2010 à 12:56:29

Citation

Quelles sont les syntaxes autorisés ?

Toutes celles que tu connais

Citation

La calculatrice c'est simplement un menu avec le choix de l'opération ?

La seule limite est ton imagination

La seule obligation est d'utiliser une arithmétique décimale et non flottante.

Cette calculatrice peut-être créée différemment selon les niveaux.

Maxibolt

4 juillet 2010 à 13:00:27

Je pense que tu veux faire trop d'exercices en même temps : un exercice par semaine serait à mon avis un meilleur choix. Là, on se retrouve avec plein de trucs à faire, et on ne sait pas lequel choisir.

Anonyme

4 juillet 2010 à 13:01:55

eval(input(>>>))

Ok, je sors ->[]

Anonyme

4 juillet 2010 à 13:03:43

Citation

Je pense que tu veux faire trop d'exercices en même temps : un exercice par semaine serait à mon avis un meilleur choix. Là, on se retrouve avec plein de trucs à faire, et on ne sait pas lequel choisir.

En effet, tu dois avoir raison, je ne vais pas mettre de limite de temps et arrêter d'en faire, car beaucoup de critiques ici, je pense que je vais arrêter aussi.

Pluggi

4 juillet 2010 à 13:07:28

Il ne faut pas spécialement arrêter, mais mieux structurer les sujets et peut-être donner des pistes de travail pour les moins meilleurs

.
Sinon, ton "module décimal" ça n'est pas très clair, tu devrais l'expliquer histoire d'anticiper les futures question.

J'ai également envie de te dire que la calculatrice sera très rapidement faite avec un eval(input('>.....'))

Anonyme

4 juillet 2010 à 13:15:26

Citation

J'ai également envie de te dire que la calculatrice sera très rapidement faite avec un eval(input('>.....'))

Je ne pense pas que ton imagination et ton savoir faire se limite à cette ligne de programme. Maintenant je peux me tromper

Citation

mais mieux structurer les sujets et peut-être donner des pistes de travail pour les moins bons

Je ne pense pas que je dois apprendre à quelqu'un ce qu'est une calculatrice simple.

Citation

Et par exemple ton "module décimal" ça n'est pas très clair, tu devrais l'expliquer histoire d'anticiper les futures question

Quelles questions, ce module est expliqué maintes et maintes fois sur le net?

Pluggi

4 juillet 2010 à 13:26:34

Citation : fred1599

Je ne pense pas que ton imagination et ton savoir faire se limite à cette ligne de programme. Maintenant je peux me tromper

Qui sait, peut-être que si

Non mais ce que je voulais dire par là, c'est que à part cette ligne de code, il y avait juste à broder autour et à gérer des exceptions. Donc bon c'est pas très complexe.

Citation : fred1599

Je ne pense pas que je dois apprendre à quelqu'un ce qu'est une calculatrice simple.

Effectivement, tu n'as pas besoin d'expliquer ce qu'est une calculatrice, mais il faudrait plutot dire quelles opérations tu attends. Même si ce ne sont que les opérations basiques (+-/*) il faut quand même le dire

Citation : fred1599

Quelles questions, ce module est expliqué maintes et maintes fois sur le net?

Je ne sais pas, mais au moins le débutant n'aurait pas à chercher, s'il y a des zones d'ombres sur ce que c'est, il devra te demander et tu perdra du temps et lui également

Tout est affaire d'anticipation

Maxibolt

4 juillet 2010 à 13:44:03

L'idée des exercices est très bonne en soi, je pense juste que tu devrais en donner moins d'un coup : un exercice par semaine (ou pour deux semaines éventuellement), plus évolué que "une boucle for", et ce sera vraiment une excellente chose. Je ne te critique pas, je pense seulement que tu t'y prends mal pour avoir le résultat que tu recherches.

nohar

4 juillet 2010 à 16:49:15

+1 pour tout ce qui s'est dit au-dessus : là ça fait un peu beaucoup, on a de quoi s'occuper.

Sinon, je vais faire cet exo, en ajoutant une contrainte : ma calculette sera en notation post-fixée... un peu comme "dc".

J'éditerai ce post quand j'aurai eu le temps de le faire.

voilà :

J'ai légèrement amélioré le programme en séparant "opération" de "instruction" et collant les opérateurs et leurs caractères correspondants dans un dictionnaire (plus facile à faire évoluer par la suite), de manière similaire à la solution de fred1599 (plus élégante qu'un branchement conditionnel, il faut bien l'avouer

).

Pylint me donne un 9.78 / 10 pour ce programme, à cause de l'utilisation de la fonction input. :-°

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Calculatrice à notation post-fixée.

"""
import operator
from decimal import Decimal, InvalidOperation

PILE = list()
INSTRUCTIONS = ['e', 'p']
OPERATIONS = {'+': operator.add, '-': operator.sub, '*': operator.mul, '/': 
        operator.truediv, '^': operator.pow}

def applique_instruction(instruction):
    """
    Applique une instruction sur la pile.
    * instruction: caractère décrivant l'instruction à appliquer

    """
    if instruction == 'e':
        del PILE[:]
    elif instruction == 'p' and len(PILE) > 0:
        print(PILE[-1])

def applique_operation(operation):
    """
    Applique une opération sur les deux éléments du dessus de la pile et empile
    le résultat.
    * operation: l'opération à appliquer.
    """
    if len(PILE) >= 2 and operation in OPERATIONS:
        droite, gauche = PILE.pop(), PILE.pop()
        PILE.append(OPERATIONS[operation](gauche, droite))
    else:
        raise SyntaxError

def traite(mot):
    """
    Traite un mot de l'expression.
    - si le mot est une instruction ou une opération, celle-ci est appliquée.
    - si le mot est un nombre celui-ci est empilé.

    """
    if mot in INSTRUCTIONS:
        applique_instruction(mot)
    elif mot in OPERATIONS:
        applique_operation(mot)
    else:
        try:
            PILE.append(Decimal(mot))
        except InvalidOperation:
            print("Erreur : '{0}' n'est pas reconnu".format(mot))
            raise SyntaxError  

def calcule(expression):
    """
    Evalue l'expression entrée par l'utilisateur.
    expression: chaine de caractère à évaluer

    """
    for mot in expression.split():
        try:
            traite(mot)
        except SyntaxError:
            del PILE[:]
            print("Erreur de syntaxe, la pile a été réinitialisée")
            return
    if len(PILE) > 0:
        print(PILE[-1])
    else:
        print("pile vide")

def main():
    """
    Fonction principale
    
    """
    import sys
    print(
"""
Entrez une expression post-fixée à évaluer.
La pile est mémorisée entre 2 entrées.
'e' efface la pile
'p' affiche un résultat intermédiaire
'q' quitte le programme
Opérations autorisées: + - * / ^

"""
    )
    while True:
        exp = input('>>> ').lower()
        if 'q' not in exp:
            calcule(exp)
        else:
            sys.exit(0)

if __name__ == '__main__':
    main()

Voilà un exemple d'utilisation pour le calcul de :
(((3 * 5) + 10) / 4² - 1.56) * 10 000

en affichant les résultats intermédiaires après chaque opération :

Entrez une expression post-fixée à évaluer.
La pile est mémorisée entre 2 entrées.
'e' efface la pile
'p' affiche un résultat intermédiaire
'q' quitte le programme
Opérations autorisées: + - * / ^


>>> 3 5 * p 10 + p 4 2 ^ p / p 1.56 - p 10000 *
15
25
16
1.5625
0.0025
25.0000

Zeste de Savoir, le site qui en a dans le citron !

Anonyme

4 juillet 2010 à 23:02:15

Oh c'est excellent !

candide

5 juillet 2010 à 1:10:41

Citation : NoHaR

Sinon, je vais faire cet exo, en ajoutant une contrainte : ma calculette sera en notation post-fixée... un peu comme "dc".

Pour le coup, je trouve ça dommage, tu perds la quasi totalité des débutants (et même au-delà) avec cette histoire de notation post-fixe bien artificielle. Faudrait pas que les débutants pensent qu'il faut être très savant pour faire une calculatrice. D'ailleurs dans le cours C de matéo, il me semble qu'assez rapidement une implémentation de calculatrice est proposée. Au passage, le PO aurait pu donner des spécifications plus précises mais bon, visiblement il a choisi la quantité d'exos plus que la qualité ...

nohar

5 juillet 2010 à 7:21:27

Citation : candide

Citation : NoHaR

Sinon, je vais faire cet exo, en ajoutant une contrainte : ma calculette sera en notation post-fixée... un peu comme "dc".

Pour le coup, je trouve ça dommage, tu perds la quasi totalité des débutants (et même au-delà) avec cette histoire de notation post-fixe bien artificielle. Faudrait pas que les débutants pensent qu'il faut être très savant pour faire une calculatrice. D'ailleurs dans le cours C de matéo, il me semble qu'assez rapidement une implémentation de calculatrice est proposée. Au passage, le PO aurait pu donner des spécifications plus précises mais bon, visiblement il a choisi la quantité d'exos plus que la qualité ...

J'ai montré une exécution du programme à ma copine (commerciale, pas du tout matheuse, et qui n'a absolument jamais programmé de sa vie), sa réaction : « WOW ! Je savais pas qu'on pouvait faire une calculatrice sans parenthèses aussi facilement ! C'est astucieux. ». Elle en a compris le fonctionnement en un coup d'œil.

Les débutants te mettent 1-0 sur ce coup. :-°

Plus sérieusement, candide, nous n'avons pas la même approche de la pédagogie. Tu prônes l'apprentissage sans effort, et moi celui par la curiosité. J'aime montrer des choses qui vont au-delà du "banal" programme qui agit comme tous les autres, d'autres façons de faire. C'est mon choix, et jusqu'ici cela ne m'a jamais desservi.

Zeste de Savoir, le site qui en a dans le citron !

GuilOooo

5 juillet 2010 à 10:34:11

Salut,

fred1599, quoi qu'il arrive sur le forum, ça ne te donne pas le droit d'insulter d'autres membres, même en mettant des points de suspention au milieu des mots. Tu reçois 10% pour insultes, attention à ne pas recommencer.

Cette digression est finie, on reprend sur le sujet de l'exercice. Merci de ne plus faire dériver ce topic, que ce soit en attaques personnelles ou vers quoi que ce soit d'autre.

Bonne continuation !
GuilOooo

J'ai déménagé sur Zeste de savoir — Ex-manager des modérateurs.

Pluggi

5 juillet 2010 à 13:57:06

Eh bien j'ai retrouvé une vieille calculatrice que j'avais programmé à mes débuts en Python 2.6, donc je vous la poste ici en espérant que ça réponde aux attentes

Mon programme utilise un module que j'ai créé moi-même, c'est pourquoi il y a deux morceaux.

Voici le module :
<secret>

#! /usr/bin/python2
#-*- coding: utf-8 -*-

import decimal, re, operator

parse_entree = re.compile(r'''(?x)		# autorise les commentaires et les espaces
		([-+]?[.]?\d+\.?\d*)		# nombre avec partie fractionnaire éventuelle, signe  + ou - éventuel
		\s*				# espaces éventuels
		([-+/*])			# opérateur
		\s*				# espaces éventuels
		([-+]?[.]?\d+\.?\d*)		# nombre avec partie fractionnaire éventuelle, signe  + ou - éventuel
		$''')				# fin de chaîne

oper = { '+': operator.add, '-': operator.sub,
	'*': operator.mul, '/': operator.truediv,
	}

def calc(entree):
	total = decimal.Decimal('0')
	calcul = entree.strip()
	try:
		num_text1, op, num_text2 = parse_entree.match(calcul).groups()
	except AttributeError:
		print 'Entrée incorrecte : %r' % calcul
		print 'Entrez un nombre, un opérateur et un nombre.'
		raise AttributeError
	try:
		total = oper[op](decimal.Decimal(num_text1), decimal.Decimal(num_text2))
	except ZeroDivisionError:
		raise ZeroDivisionError
	return total

if __name__ == '__main__':
	while 1:
		instruction = raw_input('\nEntrez un nombre, un opérateur et un nombre.\n')
		print calc(instruction)

</secret>

Et voici l'interface graphique :
<secret>

#! /usr/bin/env python
#-*- coding: utf-8 -*-



textParams = {
	"bg":"white",
	"fg":"#2321F1",
	"highlightthickness":0,
	"width":23,
	"font":("Arial",16, 'bold')
}


operatorParams = {
	"bg":"#ae9f89",
	"fg":"black",
	"relief":"groove",
	"font":("Arial", 12, 'bold')
}




class App:

	def __init__(self, master):
		"""Interface graphique calculatrice."""
		
		frame = Frame(master)
		frame.pack()

		self.texte = Entry(frame, **textParams)
		self.texte.grid(row=0, columnspan=5)

		Button(frame, text='CE', command=self.buttonCE, width=3, height=5).grid(row=1, column=0, rowspan=2)
		Button(frame, text='C', command=self.buttonC, width=3, height=5).grid(row=3, column=0, rowspan=2)

		for i in range(9):
			(l,c) = divmod(i,3)
			l, c, v = 3-l, c+1, i+1
			Button(frame, text=str(v), command=self.buttonAction(v), width=3, height=2).grid(row=l, column=c)


		Button(frame, text='0', command=self.buttonAction(0), width=3, height=2).grid(row=4, column=1, columnspan=1)
		Button(frame, text=',', command=self.buttonAction('.'), width=3, height=2).grid(row=4, column=2)
		Button(frame, text='÷', command=self.buttonAction('/'), width=3, height=2, **operatorParams).grid(row=4, column=4)
		Button(frame, text='x', command=self.buttonAction('*'), width=3, height=2, **operatorParams).grid(row=3, column=4)
		Button(frame, text='-', command=self.buttonAction('-'), width=3, height=2, **operatorParams).grid(row=2, column=4)
		Button(frame, text='+', command=self.buttonAction('+'), width=3, height=2, **operatorParams).grid(row=1, column=4)
		Button(frame, text='=', command=self.buttonEgal, width=3, height=2, **operatorParams).grid(row=4, column=3)



	def buttonAction(self,i):
		def f():
			self.texte.insert(END, str(i))
		return f



	def buttonEgal(self):
		"""Lance l'analyse de l'entrée et
		exécute le calcul."""
		resultat = ""
		operations = self.texte.get()


		try:
			resultat = calcul.calc(operations)
			
		except AttributeError:
			tkMessageBox.showwarning("Mauvaise entrée", "Entrez un nombre, un opérateur et un nombre.")

		except ZeroDivisionError:
			print "Erreur : division par zéro."
			tkMessageBox.showwarning("Mauvaise entrée", "Division par zéro.")

		except ValueError:
			tkMessageBox.showwarning("Mauvaise entrée", "Mauvaise entrée, réessayez")
		self.texte.delete(0, END)
		self.texte.insert(END, resultat)



	def buttonCE(self):
		"""Efface l'écran"""
		self.texte.delete(0, END)



	def buttonC(self):
		"""Efface le caractère tapé"""
		texte = self.texte.get()[:-1]
		self.texte.delete(0, END)
		self.texte.insert(END, texte)





if __name__ == '__main__':
	from Tkinter import *
	import calcul, tkMessageBox
	root = Tk()
	app = App(root)
	root.title('Calculatrice')
	root.resizable(height = False, width = False)
	root.mainloop()

</secret>

realmagma

7 juillet 2010 à 20:53:14

Voici ma calculette,

Je suis un super débutant donc la calculette demande combien de nombres l'utilisateur veut il aditionner, soustraire ou diviser/multiplier. Ses nombres sont mis dans une liste ou chaque élément est additionner/soustrait... à l'élément n+1

(En gros un truc qui ne sert à rien mais j'ai pris du plaisir à le coder)

Il y a des endroits où je peux factoriser notamment avec les if, elif mais alors comment faire ? Bonne question.
Je n'ai pas encore fait de boucles pour redemander à l'utilisateur de refaire une partie ou non, mais je le ferais.

Bien entendu, toutes remarques sont les bienvenues.

Mon code:

############################################
#Programme Exercice avec Python            #
#Auteur: Realmagma                         #
#Licence: Aucune                           #
#Date:  07/07/2010                         #
############################################



#Les Modules Importés      -A
#
#


#Les diférentes fonction   -B
#
#
#Fonction num 1:
def plus(maListeRecue):
    """
       Fonction permettant
       d'additionner des nombres
    """
 
    resultat = 0
    
    for i in range( len(maListeRecue)):        #On parcours "maListeRecue"
        int(maListeRecue[i])                   #En convertissant les éléments en \int\
        resultat = resultat + maListeRecue[i]
        
    print("Le resultat vaut:", resultat)


#
#Fonction num 2:
def moins(maListeRecue):
    """
       Fonction permettant
       de soustraire les nombres
    """
    
    resultat = 0
    
    for i in range( len(maListeRecue)):        #On parcours "maListeRecue"
        int(maListeRecue[i])                   #En convertissant les éléments en \int\
        
        if(i == 0):
            resultat = maListeRecue[i]
        else:
            resultat = resultat - maListeRecue[i]
      
    print("Le resultat vaut:", resultat)


#
#Fonction num 3:
def multiplie(maListeRecue):
    """
       Fonction permettant
       de multiplier les nombres
    """
    
    resultat = 0
    
    for i in range( len(maListeRecue)):        #On parcours "maListeRecue"
        int(maListeRecue[i])                   #En convertissant les éléments en \int\
        
        if(i == 0):
            resultat = maListeRecue[i]
        else:
            resultat = resultat * maListeRecue[i]
      
    print("Le resultat vaut:", resultat)


#
#Fonction num 4:
def divise(maListeRecue):
    """
       Fonction permettant
       de diviser les nombres
    """
    
    resultat = 0
    
    for i in range( len(maListeRecue)):        #On parcours "maListeRecue"
        int(maListeRecue[i])                   #En convertissant les éléments en \int\
        
        if(i == 0):
            resultat = maListeRecue[i]
        else:
            resultat = resultat / maListeRecue[i]
      
    print("Le resultat vaut:", resultat)
    
#Diférentes variables   -C
#
#
maListe = []
chiffre = 0
choixOperation = 0



#Corps du programme     -D
#
#
print("Combien de nombre voulez vous ?")
i = int(input())

while(i > 0):
    print("Entrez un chiffre:")
    chiffre = int(input())
    
    maListe.append(chiffre)          #On ajoute "chiffre" à /maListe/
    print("\nMa liste:", maListe)    #
    i -= 1                           #Une condition pour éviter les boucles infinies

print("""\nQuelle operation voulez-vous faire ?\n\n
         1 = Addition     
         2 = Soustraction 
         3 = Multiplication
         4 = Division """)
      
choixOperation = int(input())        #Demande du choix d'une opération
if(choixOperation == 1):
    plus(maListe)
      
elif(choixOperation == 2):
    moins(maListe)
      
elif(choixOperation == 3):
    multiplie(maListe)
      
elif(choixOperation == 4):
    divise(maListe)
      
else:
      print("Incorrect !")

Maxibolt

7 juillet 2010 à 21:52:57

Sur le bon usage des commentaires : http://da-bhm.org/see.yaws?id=48

Tu peux aussi améliorer le choix d'opération : tu peux par exemple faire une liste de fonctions, et appeler la fonction correspondant au numéro entrée par liste[choix].
Ça te surprend peut-être, mais en Python, une fonction est un "objet" comme un autre : ça veut dire que tu peux parfaitement l'utiliser dans une liste, ou même comme paramètre ou valeur de retour d'une autre fonction !

realmagma

7 juillet 2010 à 22:14:58

Simpas le blog

Donc si j'ai bien compris, tu veux que je mette mes fonctions dans une liste; c'est bien ça ?
Cala ne va t'il pas rallonger mon code qui est déjà assez gros pour ce que c'est

Maxibolt

8 juillet 2010 à 0:50:52

Non, parce que tu vas enlever une série d'if (et si tu voulais en rajouter, ce serait très simple, il suffirait de rajouter un terme dans la liste).

realmagma

8 juillet 2010 à 10:20:36

En faite je ne vois pas ce que tu veux dire :-°

J'ai essayé ceci:

#Diférentes variables   -C
#
#
maListe = []
listeFonction = [plus(maListe), moins(maListe), multiplie(maListe), divise(maListe)]
chiffre = 0
choixOperation = 0

Puis un peut plus bas dans mon code, ceci:

print("""\nQuelle operation voulez-vous faire ?\n\n
         0 = Addition     
         1 = Soustraction 
         2 = Multiplication
         3 = Division """)
      
choixOperation = int(input())        #Demande du choix d'une opération
listeFonction[choixOperation]
print(listeFonction[choixOperation])

J'obtient:

Le resultat vaut: 0
Le resultat vaut: 0
Le resultat vaut: 0
Le resultat vaut: 0
Combien de nombre voulez vous ?

3 (C'est moi qui l'ai rentré)
Entrez un chiffre:

3 (idem)

Ma liste: [3]
Entrez un chiffre:

3 (idem)

Ma liste: [3, 3]
Entrez un chiffre:

3 (idem)

Ma liste: [3, 3, 3]

Quelle operation voulez-vous faire ?


         0 = Addition     
         1 = Soustraction 
         2 = Multiplication
         3 = Division 

0 (idem)

None (Et mince ça n'a aps fonctionné)

Peux-tu me réexpliquer ce que tu essayes de me dire s'il te plaît ?

Maxibolt

8 juillet 2010 à 19:34:19

Non, regarde, plutôt un truc comme ça :

def plus(x, y):
    return x + y

#idem pour les autres

operations = [plus, moins, fois, divise]

nombre1 = int(input("Premier nombre ?"))
nombre2 = int(input("Deuxième nombre ?"))

numero_operation = int(input(
"""Choisir l'opération :
0 : +
1 : -
2 : *
3 : /"""))

fonction = operations[numero_operation]

return function(nombre1, nombre2)

realmagma

9 juillet 2010 à 11:20:20

Bonjour,

merci pour ta réponse Maxibolt. N'ayant pas compris ton code après X relectures, j'ai tenté de le reproduire sous IDLE. J'ai changé la faute d'orthographe function en fonction mais j'ai toujours une erreur, me disant qu'on ne peut pas faire de return en dehors d'une fonction.

Je ne comprends pas pourquoi mon code ne marche pas.
'None' qu'il me dit le compilo. Pourtant j'appelle belle est bien ma fonction contenue dans ma liste... :-°

candide

9 juillet 2010 à 11:26:24

Citation : realmagma

Je ne comprends pas pourquoi mon code ne marche pas.

In code we trust : poste ton code complet.

realmagma

9 juillet 2010 à 11:43:26

C'est exactement le même que le précédant. Je teste des trucs mais sans résultat.
Je vous remercie d'avance. (Si par miracle je trouve la solution, j'éditerai ce post)

############################################
#Programme Exercice avec Python            #
#Auteur: Realmagma                         #
#Licence: Aucune                           #
#Date:  09/07/2010                         #
############################################



#Les Modules Importés      -A
#
#


#Les diférentes fonction   -B
#
#
#Fonction num 1:
def plus(maListeRecue):
    """
       Fonction permettant
       d'additionner des nombres
    """
    resultat = 0
    
    for i in range( len(maListeRecue)):  
        int(maListeRecue[i])      
        resultat = resultat + maListeRecue[i]
        
    print("Le resultat vaut:", resultat)


#
#Fonction num 2:
def moins(maListeRecue):
    """
       Fonction permettant
       de soustraire les nombres
    """ 
    resultat = 0
    
    for i in range( len(maListeRecue)):        
        int(maListeRecue[i])
        
        if(i == 0):
            resultat = maListeRecue[i]
        else:
            resultat = resultat - maListeRecue[i]
      
    print("Le resultat vaut:", resultat)


#
#Fonction num 3:
def multiplie(maListeRecue):
    """
       Fonction permettant
       de multiplier les nombres
    """  
    resultat = 0
    
    for i in range( len(maListeRecue)):        
        int(maListeRecue[i])
        
        if(i == 0):
            resultat = maListeRecue[i]
        else:
            resultat = resultat * maListeRecue[i]
      
    print("Le resultat vaut:", resultat)


#
#Fonction num 4:
def divise(maListeRecue):
    """
       Fonction permettant
       de diviser les nombres
    """   
    resultat = 0
    
    for i in range( len(maListeRecue)):        
        int(maListeRecue[i])
        
        if(i == 0):
            resultat = maListeRecue[i]
        else:
            resultat = resultat / maListeRecue[i]
      
    print("Le resultat vaut:", resultat)




    
#Diférentes variables   -C
#
#
maListe = []
listeFonction = [plus(maListe), moins(maListe), multiplie(maListe), divise(maListe)]
chiffre = 0
choixOperation = 0



#Corps du programme     -D
#
#
print("Combien de nombre voulez vous ?")
i = int(input())

while(i > 0):
    print("Entrez un chiffre:")
    chiffre = int(input())
    
    maListe.append(chiffre)          #On ajoute "chiffre" à /maListe/
    print("\nMa liste:", maListe)    #
    i -= 1                           #Une condition pour éviter les boucles infinies

print("""\nQuelle operation voulez-vous faire ?\n\n
         0 = Addition     
         1 = Soustraction 
         2 = Multiplication
         3 = Division """)
      
choixOperation = int(input())        #Demande du choix d'une opération
listeFonction[choixOperation]
print(listeFonction[choixOperation])

candide

9 juillet 2010 à 12:00:04

Fais un truc beaucoup plus simple mais qui marche. Tes fonctions sont horriblement compliquées et incompréhensibles, tu fais une calculatrice toute simple, donc tes fonctions ne reçoivent a priori que deux arguments, c'est quoi ces listes que tu passes en paramètres ?

Fais d'abord un programme simplissime mais qui marche et ensuite, éventuellement, complexifie-le. Spécifie bien l'objectif de ta calculatrice (le programme demande à l'utilisateur deux nombres et une opération parmi les 4 opérations arithmétiques). Pas besoin de fonctions, ni de liste et bien sûr ne t'occupe pas des exceptions.

realmagma

9 juillet 2010 à 12:51:47

Je crois que tu as raison Candide. Juste pour info

je voulais faire une calculette ou je demandais à l'utilisateur combien de nombres il voulait aditionner/soustraire... . Chaque nombre qu'il entrait sont contenus dans une liste que je passe en paramètre à ma fonction.
Par exemple ma fonction /plus/. L'élément 'n' de ma liste est additionner dans ce cas à l'élément 'n+1'.

Mon code marchait pas trop mal, mais Maxibolt ma conseillé de faire autrement. Et je me suis dit "Tiens c'est pas bête je vais essayé"

Ce que j'ai fait:

J'ai regroupé mes fonctions dans une liste. Je demande à l'utilisateur d'entrer un chiffre entre 0 et 3 où '0' représente l'addition, '1' la soustraction etc... .
Ensuite j'apelle ma liste avec indice '[0]' (en admettant qu'il est rentré '0').

Que contient ma liste (contenant mes fonctions) en indice '0' => Justement l'appel de ma fonction 'plus'.

- Est-ce possible ?
- Le choix des listes sont judicieuses ou non? Plutôt des dictionnaires ?(sachant que j'ai à peine lu cette partit du tutoriel; bien entendu pour l'instant

)

Si ce n'est pas possible et/ou au delà des mes compétences, je suivrais ton conseil Candide.

(Je pose beaucoup (trop?) de question moi :lol:

)

EDIT: J'ai essayé avec les dico. J'y suis presque je le sens. Je vous post mon code au cas ou.

############################################
#Programme Exercice avec Python            #
#Auteur: Realmagma                         #
#Licence: Aucune                           #
#Date:  09/07/2010                         #
############################################



#Les Modules Importés      -A
#
#


#Les diférentes fonction   -B
#
#
#Fonction num 1:
def plus(maListeRecue):
    """
       Fonction permettant
       d'additionner des nombres
    """
    resultat = 0
    
    for i in range( len(maListeRecue)):  
        int(maListeRecue[i])      
        resultat = resultat + maListeRecue[i]
        
    print("Le resultat vaut:", resultat)


#
#Fonction num 2:
def moins(maListeRecue):
    """
       Fonction permettant
       de soustraire les nombres
    """ 
    resultat = 0
    
    for i in range( len(maListeRecue)):        
        int(maListeRecue[i])
        
        if(i == 0):
            resultat = maListeRecue[i]
        else:
            resultat = resultat - maListeRecue[i]
      
    print("Le resultat vaut:", resultat)


#
#Fonction num 3:
def multiplie(maListeRecue):
    """
       Fonction permettant
       de multiplier les nombres
    """  
    resultat = 0
    
    for i in range( len(maListeRecue)):        
        int(maListeRecue[i])
        
        if(i == 0):
            resultat = maListeRecue[i]
        else:
            resultat = resultat * maListeRecue[i]
      
    print("Le resultat vaut:", resultat)


#
#Fonction num 4:
def divise(maListeRecue):
    """
       Fonction permettant
       de diviser les nombres
    """   
    resultat = 0
    
    for i in range( len(maListeRecue)):        
        int(maListeRecue[i])
        
        if(i == 0):
            resultat = maListeRecue[i]
        else:
            resultat = resultat / maListeRecue[i]
      
    print("Le resultat vaut:", resultat)




    
#Diférentes variables   -C
#
#
maListe = []
listeFonction = {0 :"plus(maListe)", 1:"moins(maListe)", 2:"multiplie(maListe)", 3:"divise(maListe)"}
chiffre = 0
choixOperation = 0



#Corps du programme     -D
#
#
print("Combien de nombre voulez vous ?")
i = int(input())

while(i > 0):
    print("Entrez un chiffre:")
    chiffre = int(input())
    
    maListe.append(chiffre)          #On ajoute "chiffre" à /maListe/
    print("\nMa liste:", maListe)    #
    i -= 1                           #Une condition pour éviter les boucles infinies

print("""\nQuelle operation voulez-vous faire ?\n\n
         0 = Addition     
         1 = Soustraction 
         2 = Multiplication
         3 = Division """)
      
choixOperation = int(input())        #Demande du choix d'une opération
listeFonction[choixOperation]
print(listeFonction[choixOperation])

candide

9 juillet 2010 à 14:02:06

Citation : fred1599

Voila mon code en version 2.6

Comment elle marche ta calculatrice ? Pour la clarté des explications, il devrait être obligatoire d'accompagner tout code par une situation où il est exécuté. Déjà, il manque l'en-tête d'encodage. Ensuite, ton code actuel :

# -*- coding: utf-8 -*-

import decimal, re, operator
entree=re.compile(r'''(?x)   # autorise les commentaires et les espaces
                 (\d+\.?\d*) # nombre avec partie fractionnaire éventuelle
                 \s*         # espaces éventuels
                 ([-+/*])    # opérateur
                 $''')       # fin de chaîne

oper={ '+' : operator.add, '-' : operator.sub, '*' : operator.mul, '/' : operator.truediv}

total=decimal.Decimal('0')

def affiche_total():
    print '=====\n', total
print """Bienvenue dans la calculatrice :
Entrez un nombre et un opérateur,
une ligne vide pour voir le résultat courant,
q pour quitter :"""
while True:
    try:
        ligne_bande=raw_input().strip()
    except EOFError:
        ligne_bande='q'
    if not ligne_bande:
        affiche_total()
        continue
    elif ligne_bande=='q':
        affiche_total()
        break
    try:
        num_text, op = entree.match(ligne_bande).groups()
    except AttributeError:
        print 'Entree incorrecte : %r' % ligne_bande
        print 'Entree un nombre et un operateur, une ligne vide pour le total, q pour quitter'
        continue
    total=oper[op](total, decimal.Decimal(num_text))

s'exécute ainsi chez moi :

candide@~/python/sdz/autres$ python calculatrice_fred.py 
Bienvenue dans la calculatrice :
Entrez un nombre et un opérateur,
une ligne vide pour voir le résultat courant,
q pour quitter :
8+
6
Entree incorrecte : '6'
Entree un nombre et un operateur, une ligne vide pour le total, q pour quitter
=====
8
candide@~/python/sdz/autres$

Bon, elle est censée faire quoi ta calculatrice ? Calculer n'importe quelle formule ? genre

(5+6)*3-(2*5-7*4)

?

ou juste 2+3 (genre) ou encore autre chose ?

Ensuite, le message dit "Entrez un nombre et un opérateur". Pas clair ton truc. Déjà, je les sépare par un espace, par une ligne, je les sépare pas ? Pourquoi il n'y a qu'un seul nombre, si je veux faire 2+3, j'ai DEUX nombres et un opérateur. Bon alors, admettons, je rentre un nombre et un opérateur, par exemple 8 et +. La calculatrice passe a la ligne et se met en attente ? Elle attend quoi ? on ne reçoit aucun message, on se croirait sous dos avec windows 95, on peut difficilement gérer plus mal l'interaction avec l'utilisateur. Bon, je rentre ce qui me paraît logique, un autre nombre : boum, "entrée incorrecte", bref code à reprendre complètement, bien la peine de nous mettre des expressions régulières ou le module Decimal.

Anonyme

9 juillet 2010 à 14:09:22

Bienvenue dans la calculatrice :
Entrez un nombre et un opérateur,
une ligne vide pour voir le résultat courant,
q pour quitter :
8+

=====
8
3*

=====
24
6-

=====
18

Ca fonctionne tres bien chez moi, il faut appuyer 2 fois sur entrée, quand tu rentres ton nombre et ton opérateur. Sinon pour la calculette, c'est une idée comme une autre.

1 2 >>