[débutante] Comment réutiliser ma fonction ?

Version imprimable

Bonjour à tous,

Je débute en programmation (depuis septembre) et dans le cadre de mes cours j'ai un exercice de conversion de chiffres en lettres (exemple : 10 -> dix).

J'ai coder un programme qui je crois fonctionne correctement jusqu'à 9999. Nous avons pas d'objectif précis donc je pourrais m'en tenir là mais j'aurais aimé faire un programme plus complet pour pratiquer et progresser.

Comme j'ai déjà mis en place les règles d'orthographe pour les centaines, dizaines et unités, je me demandais si je ne pouvais pas réutiliser ma fonction pour les dizaine de mille et les centaines de mille. Je ne vois pas trop comment faire mais ce serait bien pratique ;-)

Voici mon code :

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
import os
 
list1 = ["", "un", "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf"]
list2 = ["dix", "onze", "douze", "treize", "quatorze", "quinze", "seize", "dix sept", "dix huit", "dix neuf"]
list3 = ["", "dix", "vingt", "trente", "quarante", "cinquante", "soixante", "soixante", "quatre vingt", "quatre vingt"]
list4 = ["mille", "million", "milliard"]
 
nb = 0
 
def convNbToLetter(nb):
 
	conv = ''
	i = True
	while i :
		nb = int(input("choisissez un nb : "))
		if nb != 0:
			millier = nb //1000
			centaine = (nb - millier * 1000)//100
			dizaine = (nb -millier * 1000 - centaine * 100) // 10
			unite = nb - millier*1000 - centaine*100- dizaine*10
 
			if millier == 1 : conv += list4[0]
			elif millier in [2,3,4,5,6,7,8,9]: conv += list1[millier] + " " + list4[0]
 
			if centaine == 1: conv += " cent"
			elif centaine != 0: 
				conv += " " + list1[centaine] + " cent"
				if dizaine == 0 and unite == 0: conv+="s"
			if dizaine not in [0,1]:
				conv += " " + list3[dizaine]
			if unite == 0:
				if dizaine in [1, 7, 9]: conv += " dix"
				elif dizaine == 8: conv+="s"
			elif unite == 1:
				if dizaine in [1, 9]: conv += " " + list2[unite]
				elif dizaine == 7: conv += " et onze"
				elif dizaine in [2, 3, 4, 5, 6]: conv += " et un"
				elif dizaine in [0, 8]: conv += " " + list1[unite]
			elif unite in [2, 3, 4, 5, 6, 7, 8, 9]:
				if dizaine in [1, 7, 9]: conv += " " + list2[unite]
				else: conv += " " + list1[unite]
 
 
		print("Votre nombre s'écrit :", conv.replace(" ", "-").strip("-").capitalize() + ".")
		boucle = input("Voulez-vous convertir un autre nombre ? Tapez 'O' pour oui et 'N' pour non : ")
		if boucle == "O": 
			conv = ""
			continue
		else : i = False
 
convNbToLetter(nb)
 
os.system("pause")

Au passage, si vous avez des conseils à me donner par rapport à mon code je suis preneuse :-)
Merci d'avance pour votre aide !

15/11/2017, 16h23
wiztricks

Salut,

Relisez votre code.
Presque toutes les instructions sont dans le corps de la fonction "convNbToLetter". Si vous voulez ré-utiliser, il faut découper çà en opérations plus élémentaires i.e. des fonctions qui feront moins de choses que l'on pourra composer entre elles via des fonctions "chapeau".
Reprenez votre fonction "convNbToLetter". Sa définition suppose qu'elle est appelée avec un entier et comme c'est une fonction elle pourrait retourner la traduction en lettre à l'appelant qui va afficher ce résultat et éventuellement demander à l'utilisateur s'il veut essayer un autre nombre où sortir.
Ce faisant, on a poussé hors de la fonction "convNbToLetter" des activités "ailleurs", ce qui permet de la simplifier puisqu'elle va faire moins de choses.

Pour le reste, vous avez un tas de règles de grammaire à traduire en code. La grosse difficulté sera de retrouver comment a été traduite une règle particulière. Et çà va dépendre du livre de grammaire de départ. Si je prend ce tas de règles là, çà parle de mots simples, mots composés inférieurs à cent, accords,...
Si on ne retrouve pas cette terminologie dans le code, çà ne va pas être facile à relire...

Citation:

Comme j'ai déjà mis en place les règles d'orthographe pour les centaines, dizaines et unités, je me demandais si je ne pouvais pas réutiliser ma fonction pour les dizaine de mille et les centaines de mille. Je ne vois pas trop comment faire mais ce serait bien pratique ;-)

Ben il faudrait déjà que ce soient les mêmes règles. Mais il va falloir fabriquer la fonction qui pourra être réutilisée à une séquence semblable en entrée pour qu'on puisse lui appliquer le même traitement.

- W
15/11/2017, 17h48
Sve@r
Citation:

Envoyé par Romenag

Comme j'ai déjà mis en place les règles d'orthographe pour les centaines, dizaines et unités, je me demandais si je ne pouvais pas réutiliser ma fonction pour les dizaine de mille et les centaines de mille.

Bonjour

La terminologie des nombres va par puissances de 1000. De 1 à 999, c'est une certaine grammaire qui permet de construire l'écriture du nombre. Ensuite, à partir de 1 000 jusqu'à 999 000, c'est exactement la même grammaire sauf qu'on rajoute "mille" derrière => ex 18 = dix-huit, 18 000 = dix-huit mille. Bon il y a une exception car si 1 s'écrit "un", 1 000 ne s'écrit pas "un mille" mais simplement "mille" mais cette exception est facile à gérer. Et ensuite pour 1 000 000 jusqu'à 999 000 000 c'est encore la même chose (mais on parle de "million" et non plus de "mille"). Et etc etc etc.

Donc moi, j'écrirais une fonction qui marche pour 1 jusqu'à 999 puis je l'appliquerais en successif sur les différentes parties du nombre découpé par puissances de 1000...
Exemple: 123 456 789 = f(123) "million" + f(456) "mille" + f(789)
Donc un truc qui pourrait ressembler à ça pour commencer...
Code:

1 2 3 4 5 liste=("million", "mille", "") for (unite, i) in enumerate(liste, 1): n=nombre // 1000 ** (len(liste)-i) txt+="%d %s" % (f(n), unite) print(txt)
Ensuite plus qu'à gérer les cas particuliers (0, 1000, autres ?)...

:salut:
Voici un exemple de solution. Etudies le et essaies de comprendre ma demarche tu pourras apporter des ameliorations.

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
to_19_fr = (u'zéro', 'un', 'deux', 'trois', 'quatre', 'cinq', 'six',
          'sept', 'huit', 'neuf', 'dix', 'onze', 'douze', 'treize',
          'quatorze', 'quinze', 'seize', 'dix-sept', 'dix-huit', 'dix-neuf')
tens_fr = ('vingt', 'trente', 'quarante', 'Cinquante', 'Soixante', 'Soixante-dix', 'Quatre-vingts', 'Quatre-vingt Dix')
denom_fr = ('',
          'Mille', 'Millions', 'Milliards', 'Billions', 'Quadrillions',
          'Quintillion', 'Sextillion', 'Septillion', 'Octillion', 'Nonillion',
          'Décillion', 'Undecillion', 'Duodecillion', 'Tredecillion', 'Quattuordecillion',
          'Sexdecillion', 'Septendecillion', 'Octodecillion', 'Icosillion', 'Vigintillion')
 
def _convert_nn_fr(val):
    """ convert a value < 100 to French
    """
    if val < 20:
        return to_19_fr[val]
    for (dcap, dval) in ((k, 20 + (10 * v)) for (v, k) in enumerate(tens_fr)):
        if dval + 10 > val:
            if val % 10:
                if dval == 70 or dval == 90:
                    return tens_fr[dval / 10 - 3] + '-' + to_19_fr[val % 10 + 10]
                else:
                    return dcap + '-' + to_19_fr[val % 10]
            return dcap
 
def _convert_nnn_fr(val):
    """ convert a value < 1000 to french
 
        special cased because it is the level that kicks
        off the < 100 special case.  The rest are more general.  This also allows you to
        get strings in the form of 'forty-five hundred' if called directly.
    """
    word = ''
    (mod, rem) = (val % 100, val // 100)
    if rem > 0:
        if rem == 1:
            word = 'Cent'
        else:
            word = to_19_fr[rem] + ' Cent'
        if mod > 0:
            word += ' '
    if mod > 0:
        word += _convert_nn_fr(mod)
    return word
 
def french_number(val):
    if val < 100:
        return _convert_nn_fr(val)
    if val < 1000:
        return _convert_nnn_fr(val)
    for (didx, dval) in ((v - 1, 1000 ** v) for v in range(len(denom_fr))):
        if dval > val:
            mod = 1000 ** didx
            l = val // mod
            r = val - (l * mod)
            if l == 1:
                ret = denom_fr[didx]
            else:
                ret = _convert_nnn_fr(l) + ' ' + denom_fr[didx]
            if r > 0:
                ret = ret + ', ' + french_number(r)
            return ret

si t'as compris le code tu pourras aisement demarrer le programme

1 pièce(s) jointe(s)

Merci pour vos réponses, malheureusement comme je vous ai dit je débute et je ne comprends pas vraiment vos solutions. Je préférerais donc utiliser le programme que j'ai réussi à coder afin d'utiliser des choses que je comprends.

Citation:

Envoyé par wiztricks

Relisez votre code.
Presque toutes les instructions sont dans le corps de la fonction "convNbToLetter". Si vous voulez ré-utiliser, il faut découper çà en opérations plus élémentaires i.e. des fonctions qui feront moins de choses que l'on pourra composer entre elles via des fonctions "chapeau".

- W

J'ai allégé ma fonction et j'ai expliqué ma volonté à mon prof hier qui m'a mis sur la voie mais je n'arrive pas à appliquer ce qu'il m'a expliqué. Il m'a fait ajouter un paramètre à ma fonction puis les lignes 45 et 46.
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 import os def programme(nb, fin): conv = "" i = True list1 = ["", "un", "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf"] list2 = ["dix", "onze", "douze", "treize", "quatorze", "quinze", "seize", "dix sept", "dix huit", "dix neuf"] list3 = ["", "dix", "vingt", "trente", "quarante", "cinquante", "soixante", "soixante", "quatre vingt", "quatre vingt"] if nb != 0: centaine = nb//100 dizaine = (nb - centaine * 100) // 10 unite = nb - centaine*100- dizaine*10 # print(centaine) # print(dizaine) # print(unite) if centaine == 1: conv += " cent" elif centaine != 0: conv += " " + list1[centaine] + " cent" if dizaine == 0 and unite == 0: conv+="s" if dizaine not in [0,1]: conv += " " + list3[dizaine] if unite == 0: if dizaine in [1, 7, 9]: conv += " dix" elif dizaine == 8: conv+="s" elif unite == 1: if dizaine in [1, 9]: conv += " " + list2[unite] elif dizaine == 7: conv += " et onze" elif dizaine in [2, 3, 4, 5, 6]: conv += " et un" elif dizaine in [0, 8]: conv += " " + list1[unite] elif unite in [2, 3, 4, 5, 6, 7, 8, 9]: if dizaine in [1, 7, 9]: conv += " " + list2[unite] else: conv += " " + list1[unite] conv += fin print("Votre nombre s'écrit :", conv.replace(" ", "-").strip("-").capitalize() + ".") i = True while i : nb = int(input("Choisissez un nombre :")) unites = nb % 1000 milliers = nb // 1000 boucle = input("Voulez-vous convertir un autre nombre ? Tapez 'O' pour oui et 'N' pour non : ") if boucle == "O": conv = "" continue else : i = False exit() os.system("pause")
Quand j'appelle la fonction de cette façon :
Code:

1 2 programme(unites, "") programme(milliers," mille")
J'obtiens :
Pièce jointe 328427

Donc comme vous pouvez le voir j'ai presque ce que je souhaite obtenir, simplement, je les obtiens séparément.
Mais quand j'essaie de rajouter un paramètre et de grouper les deux valeurs en appelant la fonction comme ça :

Code:

programme(milliers, " mille", unites)

Je n'obtiens pas le résultats escompté... Pouvez-vous m'aider ?

18/11/2017, 19h11
Sve@r

Citation:

Envoyé par Romenag

Mais quand j'essaie de rajouter un paramètre et de grouper les deux valeurs en appelant la fonction comme ça :

Code:

programme(milliers, " mille", unites)

"débuter" ne signifie pas "mettre son cerveau sur off". Ca signifie "lire un tuto", "apprendre les bases", "essayer les exemples". C'est apprendre ce qu'est une fonction, ce que signifie "lui passer des paramètres", réaliser qu'on doit lui en passer déjà autant que ceux attendus (et pas plus) et apprendre ce que signifie "récupérer ce qu'elle renvoie" surtout après 2 mois de prog (en général on voit ça dès le 2° jour !!!)
Mon premier exemple (f(123) "million" + f(456) "mille" + f(789)) était exactement la solution à ton interrogation => programme(milliers, "mille") + programme(unites, "").

Citation:

Envoyé par Romenag

mais je n'arrive pas à appliquer ce qu'il m'a expliqué

Preuve que tu n'as pas compris ce qu'il t'a expliqué.

Citation:

Envoyé par Romenag

Il m'a fait ajouter un paramètre à ma fonction puis les lignes 45 et 46.

As-tu au-moins compris le sens de ce paramètre ? Et la signification de ces lignes ? Ou les as-tu recopiées sans chercher plus loin ???
18/11/2017, 19h40
Romenag

Effectivement j'ai dit avoir commencé en septembre mais pour précision je ne fais pas que de la programmation lors de tous mes cours, je suis en BTS donc j'ai beaucoup de matières générales, mais surtout le premier semestre est réservé à la branche réseau donc nous avons très peu de cours de dév, j'ai dû en avoir 5 en tout. Donc oui quand je dis que je débute, je fais même mes premiers pas et je suis loin d'assimiler toutes les notions relatives aux fonctions et autres.
Je te trouve un peu dur, mon prof n'avez pas de temps à m'accorder, donc non je n'ai pas compris, mis à part que les lignes 45 et 46 servent à récupérer la partie entière des milliers, ainsi que le reste de la division.

En fait je suis peut-être impatiente, mais j'ai envie de progresser et c'est pour ça que je viens vous demander de l'aide.
18/11/2017, 20h03
Sve@r

Citation:

Envoyé par Romenag

mis à part que les lignes 45 et 46 servent à récupérer la partie entière des milliers, ainsi que le reste de la division.

Pas mal. Tu remarqueras aussi que c'est aussi induit par mon premier exemple. Pour trouver que 123 455 789=f(123) "million" + f(456) "mille" + f(789) ; quelque part, il faut diviser 123456789 par 1000000 (ça donne 123) puis ne garder ensuite que le reste de la division qui est justement "456789". Et on recommence avec "456789" et 1000 (d'où la boucle de mon second exemple)...

PS: et si j'adapte mon exemple à la façon dont ton prof voit la fonction, alors 123 456 789 = f(123, "million") + f(456, "mille") + f(789, "")...
18/11/2017, 21h16
Romenag

Citation:

Envoyé par Sve@r

PS: et si j'adapte mon exemple à la façon dont ton prof voit la fonction, alors 123 456 789 = f(123, "million") + f(456, "mille") + f(789, "")...

Je comprends pas trop... au risque de paraître idiote :
le f de ton exemple, c'est le nom de la fonction ?
on peut additionné des fonctions ? :oops:
19/11/2017, 08h57
Sve@r
Citation:

Envoyé par Romenag

on peut additionné des fonctions ? :oops:

Une fonction correspond à ce qu'elle renvoie. Si une fonction renvoie un nombre, la fonction est considérée comme étant un nombre. Donc on peut l'additionner à tout autre nombre
Code:

1 2 3 def carre(n): return n*n print carre(5) + carre(6)
Dans mon exemple, f (oui ma fonction) étant sensée renvoyer une chaine (f(15, "mille") donnera "quinze mille"), et une chaine pouvant se concaténer à une autre par l'addition ("toto" + "titi" donnera "tototiti"), en concaténant f(15, "mille") à f(16, "") ça donnera "quinze mille seize" (si on part de 15016 comme nombre initial).
D'où la solution de ton programme programme(milliers, "mille") + programme(unites, "")...
20/11/2017, 16h17
Romenag

Merci beaucoup Sve@r, je ne voyais pas les fonctions comme ça, je comprends mieux maintenant.
Je pense avoir réussi ce que je voulais faire.
(Même si j'ai dû tout reprendre pour gérer les tirets)

Encore merci à tous !