Discussion :

[Shifou]

Bonsoir à tous!

J'ai essayé de réaliser un programme (basique) où un employeur peut rentrer le nom d'un employé et ensuite son salaire, pour maximum 10 employés. Le programme renvoie , une fois toute les infos mémorisées, le nombre de billets (500,200,100,50,20,10,5) ainsi que de pièces (2,1,0.5,0.2,0.1,0.05,0.02,0.01), de manière décroissante, nécessaires pour payer chaque salaires.

Jusque là tout va bien, le programme fonctionne bien. Mon seul problème est que j'aimerai pouvoir afficher à la fin du programme le nombre TOTAL de chaque billets et pièces nécessaire pour payer TOUS les salaires.

J'ai essayé de plusieurs façon, mais rien n'a été concluant.

Je vous envoie tout le code du programme en dessous :

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
53
54
55
56
57
58
59
60
61
62
63
64
 
# Classe de l'employé
 
class employee(object):
    def __init__(self,name,salary):
        self.name =  name
        self.salary = salary
 
 
# Fonction qui permet l'encodage du nom du salarié aisni que de son salaire
 
table_emp_sal = []
num_rest = 0
go_on = True
 
 
while num_rest < 10 and go_on == True:
    name = input('Votre Nom : \n' )
    salary = 0
 
    while salary < 10 or salary >= 5000 :
        salary = float(input('Introduisez un salaire se situant entre 10€ et 5000€ : \n'))
    table_emp_sal.append(employee(name,salary))
 
    if go_on and num_rest < 9 :
        next = input('Vous pouvez encore ajouter '+ str(10-(num_rest+1)) +'\n'+'Voulez-vous continuer ? oui/non' +'\n' )
 
    if next == 'non':
        go_on=False
 
    if next == 'oui':
        go_on=True
 
    num_rest += 1
 
 
# Fonction comptage de billet sur base d'un salaire réel positif
notes = [200, 100, 50, 20,
             10, 5, 2, 1, 0.5,
             0.10, 0.05, 0.02, 0.01,]
 
note_counter = [0, 0, 0, 0, 0,
                   0, 0, 0, 0, 0,
                   0, 0, 0,]
 
def count_currency(salary):
 
 
    for i, j in zip(notes, note_counter):
        if salary >= i:
            j = salary // i
            salary = salary - j * i
            print (i ," : ", j)
 
# Affichage des résultats pour chaque employé
 
for t in table_emp_sal :
    print("Voici le nombre de billets nécessaires pour {} qui a un salaire de {}".format(t.name, t.salary))
    count_currency(t.salary)
 
 
'\n'
 
# Calcul pour afficher le résultat total

Merci beaucoup !

[wiztricks]

Salut,

Jusque là tout va bien, le programme fonctionne bien. Mon seul problème est que j'aimerai pouvoir afficher à la fin du programme le nombre TOTAL de chaque billets et pièces nécessaire pour payer TOUS les salaires.

C'est la somme des différents billets nécessaires pour chaque employé.
Donc une boucle qui balaie ... et qui fait la somme de ...

J'ai essayé de plusieurs façon, mais rien n'a été concluant.

L'important est déjà de montrer ce que vous avez essayé histoire de comprendre ce que vous n'avez pas compris pour essayer de vous l'expliquer.

- W

[Sve@r]

Bonjour

Jusque là tout va bien, le programme fonctionne bien. Mon seul problème est que j'aimerai pouvoir afficher à la fin du programme le nombre TOTAL de chaque billets et pièces nécessaire pour payer TOUS les salaires.

Tout va bien tout va bien, faut le dire vite. Tu crées un objet "employe" et tu ne t'en sers même pas de façon intelligente : tu fais tout en dehors. Au final quand tu veux ensuite faire évoluer ton truc t'es coincé tellement t'as pas posé de fondations sérieuses à ton code.

Et puis coder en Python ce n'est pas qu'écrire des lignes, c'est aussi écrire des lignes aérées pour les rendre plus lisibles !!!

Code python :

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
#!/usr/bin/env python3
# coding: utf-8
 
# Classe de l'employé
 class employe(object):
	def __init__(self, name, salary):
		self.name = name
		self.salary = salary
	# __init__()
 
	# Fonction qui permet l'encodage du nom du salarié ainsi que son salaire
        @classmethod
	def saisie(cls):
		name = input('Votre Nom : \n' )
		salary = 0
		while salary < 10 or salary >= 5000 :
			salary = float(input('Introduisez un salaire se situant entre 10€ et 5000€ : \n'))
		return cls(name, salary)
	# saisie()
 
	# Fonction qui compte les billets et pièces
	def billets(self):
		caisse={
			500 : 0,
			200 : 0,
			100 : 0,
			50 : 0,
			20 : 0,
			10 : 0,
			5 : 0,
			2 : 0,
			1 : 0,
			0.5 : 0,
			0.2 : 0,
			0.1 : 0,
			0.05 : 0,
			0.02 : 0,
			0.01 : 0,
		}
		cash=self.salary
		for k in sorted(caisse.keys(), reverse=True):
			(caisse[k], cash)=divmod(cash, k)
		assert cash < 0.01
		return caisse
	 # billets()
# class employe
 
table_emp_sal = []
for i in range(9, 0, -1):
	table_emp_sal.append(employe.saisie())
	again = input("Vous pouvez encore ajouter %d - Voulez-vous continuer (O/N) ?" % i)
	if again in "Nn": break
# for
 
# Affichage des résultats pour chaque employé
 for t in table_emp_sal:
	billets=t.billets()
	print(
		"Voici le nombre de billets nécessaires pour {} qui a un salaire de {} : {}".format(
			t.name,
			t.salary,
			", ".join(
				"%.02f€: %d" % (
					k,
					billets[k],
				) for k in sorted(billets.keys(), reverse=True) if billets[k] != 0
			),
		)
	)
# for

Voilà. Une fois que tu as bien catégorisé toutes tes actions, tu y vois beaucoup plus clair pour rajouter la somme totale des billets...

[danielhagnoul]

[...] Voilà. [...]

Non, la composition du salaire est fausse !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
Votre Nom : 
Dupond
Introduisez un salaire se situant entre 10€ et 5000€ : 
4257.12
Vous pouvez encore ajouter 9 - Voulez-vous continuer (O/N) ?n
Voici le nombre de billets nécessaires pour Dupond qui a un salaire de 4257.12 : 500.00€: 8, 200.00€: 1, 50.00€: 1, 5.00€: 1, 2.00€: 1, 0.10€: 1, 0.01€: 1

Dupond reçoit 0.11 € au lieu de 0.12 €

Voir : https://www.developpez.net/forums/bl...ayer-employes/
qui donne : 'Dupond': {'salaire': 4257.12, 'composition': [(500, 8), (200, 1), (50, 1), (5, 1), (2, 1), (0.1, 1), (0.02, 1)]},

[Sve@r]

Dupond reçoit 0.11 € au lieu de 0.12 €

Erreur due à l'imprécision des calculs en flottants, qui n'est pas spécifique à Python mais à la façon dont le processeur convertit un nombre décimal base 10 en nombre décimal base 2.
Toutefois Python possède une librairie permettant d'effectuer de vrais calculs en décimal (elle decompose un décimal chiffre par chiffre, comme le COBOL, et calcule chiffre par chiffre ce qui fonctionne mais se paye par plus de lenteur).
Suffit donc

• de rajouter from decimal import Decimal en début de code
• de remplacer salary = float(input('Introduisez un salaire se situant entre 10€ et 5000€ : \n')) par salary = Decimal(input('Introduisez un salaire se situant entre 10€ et 5000€ : \n'))
• de remplacer (caisse[k], cash)=divmod(cash, k) par (caisse[k], cash)=divmod(cash, Decimal("%s" % k))

et voilà.

Non, la composition du salaire est fausse !

Et voilà again

[Shifou]

Tout va bien tout va bien, faut le dire vite. Tu crées un objet "employe" et tu ne t'en sers même pas de façon intelligente : tu fais tout en dehors. Au final quand tu veux ensuite faire évoluer ton truc t'es coincé tellement t'as pas posé de fondations sérieuses à ton code.

Et puis coder en Python ce n'est pas qu'écrire des lignes, c'est aussi écrire des lignes aérées pour les rendre plus lisibles !!!

Aie aie aie , je suis désolé, loin de moi l'idée de ternir l'image du Python. J'essaie juste d'apprendre avec les infos que je trouve Mais en tout cas merci pour la re-structure du code. En effet, j'y vois un peu plus clair dès a présent. Néanmoins, (je répète je suis novice, ne m'incendiez pas) j'avoue avoir du mal à comprendre cette partie, au niveau de la cinquième ligne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
	"Voici le nombre de billets nécessaires pour {} qui a un salaire de {} : {}".format(
			t.name,
			t.salary,
			", ".join(
				"%.02f€: %d" % (
					k,
					billets[k],

Merci en tout cas

[Sve@r]

j'avoue avoir du mal à comprendre cette partie, au niveau de la cinquième ligne :

La variable "billets" est un dictionnaire issu du calcul des billets nécessaires. Les clefs de ce dictionnaire sont les valeurs des billets (500, 200, 100, ...). Ses valeurs sont le nombre de billets nécessaires pour chaque billet.

Cette ligne affiche donc, pour un salarié, son nom, son salaire, et le dictionnaire "billets". Et ce dictionnaire est affiché sous forme "valeur du billet en euros: nombre de billets nécessaires" en filtrant les billets dont le nombre vaut 0 (inutiles). Cette écriture (iterable à la volée depuis un for avec eventuellement une condition) est une écriture Python dénommée "listes en intension" (à ne pas confondre avec "intention") ou "listes en compréhension" qui permet de créer une liste en mémoire à partir d'une liste existante. Et comme ici cette liste en intension me génère des chaines du type "xxx€: nombre", me suffit de faire ", ".join(cette_liste) pour avoir au final l'ensemble des valeurs séparées par une virgule.