Discussion :

[Aurelien68]

Bonjour, comme dit dans le titre, j'aurai besoin d'aide dans pour un exercice.
Voici l'énoncé :
"Écrire fonction facture utilisant une boucle dans laquelle le restaurateur va entrer

les montants des factures de son restaurant.
La boucle se terminera seulement si on entre une valeur négative.
Avec les montants ainsi entrés, construire progressivement une liste.
Après chaque entrée d’un nouveau montant (et donc à chaque itération de la boucle), afficher le nombre de
montants entrés, le montant le plus élevé, le plus bas, la moyenne de tous les montants."

Or, je bloque dès le début ,je ne comprends pas comment faire pour demander à l'utilisateur d'entrer plusieurs nombre sans savoir combien il doit en entrer.

[wiztricks]

Salut,

Or, je bloque dès le début ,je ne comprends pas comment faire pour demander à l'utilisateur d'entrer plusieurs nombre sans savoir combien il doit en entrer.

On vous demande d'écrire une boucle et on vous dit: "La boucle se terminera seulement si on entre une valeur négative"...

Ce qui est une condition de sortie de la boucle où à chaque itération on demande à l'utilisateur de saisir un nombre, s'il est positif, on l'ajoute à la liste et on affiche les différents calculs demandés et s'il est négatif on sort de la boucle...

Après comment on écrit çà... dépend du Python que vous connaissez (et du contenu des chapitres de votre cours qu'il serait bon de revoir... pour l'occasion) et le seul intérêt de ce genre d'exercice est d'essayer de vous motiver à pratiquer... et pour avoir de l'aide (et savoir quel Python vous connaissez) postez du code.

- W

[Invité]

Bonjour,

C'est pourtant écrit !

"Après chaque entrée d’un nouveau montant (et donc à chaque itération de la boucle)"

Donc à chaque itération tu lui demandes...

@Wiz "Après comment on écrit çà... dépend du Python que vous connaisse"
Y a plusieurs façon d'écrire une fonction aussi simple ?
Tu penses au générateur ? (Jamais utilisé, donc je peux dire des conneries pour ne pas changer... )

[Aurelien68]

Ce serait donc quelque chose comme ça :

Code :

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

1
2
3
4
5
6
def Facture(x):
    facture = []
    while x>=0:
        facture.append(x)
        x=input(x)
    return(facture)

[wiztricks]

Salut,

Ce serait donc quelque chose comme ça

Par exemple... puis vous demandez à Python de l'exécuter.

Si ça sort des messages d'erreurs, vous essayez de comprendre pourquoi en relisant votre code.

ça vous oblige à pratiquer et à maîtriser un peu ce qu'il se passe.
Et le seul intérêt de ce genre d'exercice est dans tout ce que vous allez découvrir en essayant d'écrire le code.

- W

[Sve@r]

Bonjour

Ce serait donc quelque chose comme ça :

Code :

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

1
2
3
4
5
6
def Facture(x):
    facture = []
    while x>=0:
        facture.append(x)
        x=input(x)
    return(facture)

Il y a de l'idée. Mais en premier lieu ce qui gène c'est ce "x" en tant que paramètre de fonction. Un paramètre est une valeur venue de l'appelant de la fonction pour permettre à sa fonction de faire son travail. Et franchement, a-t-elle besoin de recevoir ce "x" pour le faire saisir ???

Et ensuite il y a le souci de la toute première itération, quand "x" n'a pas encore été saisi. Il ne peut donc pas être évalué.

Ces deux points devraientt te faire réfléchir à la façon de changer certains éléments pour que les soucis qu'ils entrainent disparaissent.

[Aurelien68]

Bonjour

Il y a de l'idée. Mais en premier lieu ce qui gène c'est ce "x" en tant que paramètre de fonction. Un paramètre est une valeur venue de l'appelant de la fonction pour permettre à sa fonction de faire son travail. Et franchement, a-t-elle besoin de recevoir ce "x" pour le faire saisir ???

Ensuite il y a le souci de la toute première itération, quand "x" n'a pas encore été saisi. Il ne peut donc pas être évalué.
Et enfin il y a le fait que si on entre un nombre négarif, celui-ci sera ajouté au tableau alors qu'il ne le doit pas.

Tout ça devrait te faire réfléchir à la façon de changer certains éléments pour que tous ces soucis disparaissent.

Quelque chose du genre alors ?

Code :

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

1
2
3
4
5
6
7
8
 
def Facture():
    facture = []
    x=input(x)
    while x>=0:
        facture.append(x)
        x=input(x)
    return(facture)

[wiztricks]

Quelque chose du genre alors ?

Si vous aviez essayé, vous auriez pu constater que ça plante.... avec un joli message d'erreur. Donc il y a de ça, mais c'est un poil plus compliqué.

- W

[Sve@r]

Quelque chose du genre alors ?

Code :

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

1
2
3
4
5
6
7
8
 
def Facture():
    facture = []
    x=input(x)
    while x>=0:
        facture.append(x)
        x=input(x)
    return(facture)

Ok ça ça fonctionne. C'est juste très "scolaire" comme façon de programmer. On peut améliorer certains éléments (comme cette répétition de la saisie, qui accessoirement, ne s'écrit pas comme ça). Et les parenthèses au return ne sont pas nécessaire (on n'est pas en C)

Code python :

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

1
2
3
4
5
6
7
def Facture():
    facture = []
    while True:
        x=input("Entrez une valeur (un nombre négatif pour arrêter) ?")
        if x < 0: break
        facture.append(x)
    return facture

Maintenant certains professeurs puristes refusent l'utilisation du break. On peut alors encore un peu changer ça...

Code python :

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

1
2
3
4
5
6
def Facture():
    facture = []
    while True:
        x=input("Entrez une valeur (un nombre négatif pour arrêter) ?")
        if x < 0: return facture
        facture.append(x)

... mais ça place le return non pas en fin de fonction (comme le voudrait la logique de lecture) mais en plein milieu (distinction entre "logique de lecture" et "logique de programmation" qui peuvent avoir des difficultés à cohabiter). A toi de voir...

PS: il y a un autre souci dont j'ai oublié de parler: la fonction input() ne renvoie pas un nombre mais une chaine. Si par exemples tu tapes "123" alors tu obtiendras la string "123" qui n'a pas le même comportement que le nombre 123. Mais tu dois avoir dans ton cours la solution à ce souci (peut-être pas directement mais noyée dans certains exemples qui parlent des types Python et de leurs conversions)

[Invité]

Ce serait donc quelque chose comme ça :

Code :

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

1
2
3
4
5
6
def Facture(x):
    facture = []
    while x>=0:
        facture.append(x)
        x=input(x)
    return(facture)

return(facture) quel est l'intérêt de retourner la liste ?
Si on suit juste l'exercice vous pouvez mettre des print dans la boucle pour afficher ce qui est demandé min, max, mean, len.

input() retourne un string pas un int ou un float (sous python 3). https://docs.python.org/fr/3/library...built-in-types

Code :

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

1
2
3
4
>>> type(input("montant ?\n"))
montant ?
5.1
<class 'str'>

Et je vous conseille de ne pas mettre d'argument dans la fonction pour cet exercice, et plutôt faire :

Code :

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

1
2
3
4
5
6
7
def facture():
    factures = []
    montant = float(input("Quel est le montant ?\n"))
    while montant>=0:
        factures.append(montant)
        montant = float(input("Quel est le montant ?\n"))
        print('Moyenne :', moyenne) #Exemple : moyenne = statistics.mean(factures)

Une autre façon d'écrire cette fonction mais qui ne respecte pas les consignes :

Code :

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

1
2
3
4
5
6
def f(fs=[]):
	x = float(input("Montant ?\n"))
	if x >= 0:
		fs.append(x)
		print("Moyenne :")
		f(fs)

Attention !!!
Ce type de fonction a un maximum de récursions (en clair on peut pas appeler indéfiniment une fonction à partir d'elle-même, la limite est fixée par défaut à 1000) :

Code :

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

1
2
3
4
5
6
7
8
9
>>> def f():
	f()
 
 
>>> f()
Traceback (most recent call last):
  [...]
  [Previous line repeated 1022 more times]
RecursionError: maximum recursion depth exceeded

[Sve@r]

Une autre façon d'écrire cette fonction mais qui ne respecte pas les consignes :

Code :

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

1
2
3
4
5
6
def f(fs=[]):
	x = float(input("Montant ?\n"))
	if x >= 0:
		fs.append(x)
		print("Moyenne :")
		f(fs)

Ouch... beaucoup de notions complexes dans cet exemple

• la récursivité
• les valeurs par défaut des arguments de fonction
• l'utilisation de types mutables comme valeur par défaut (ce qui pose parfois plus de souci que ça n'en résout)

... notions peut-être un peu complexes pour un débutant qui découvre à peine la saisie, les boucles et les tests...

[Invité]

• l'utilisation de types mutables comme valeur par défaut (ce qui pose parfois plus de souci que ça n'en résout)

J'ai fait ça moi ?
J'avais oublié que ça s'appelait comme ça. ^^

J'ai juste voulu trouver une autre façon de s'y prendre. Je n'en vois pas d'autres... (Wiz m'a émoustillé)

PS : Oui un tuple c'est mieux !

Code :

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

1
2
3
4
5
6
def f(fs=()):
	x = float(input("Montant ?\n"))
	if x >= 0:
		fs += (x,)
		print(fs)
		f(fs)

Ca me paraît pas tellement intuitif cette syntaxe, j'ai mis un certains à la trouver d'ailleurs fs += (x,)

[fred1599]

On préfère souvent,

Code :

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

1
2
3
4
def f(fs=None):
    if fs is None:
        fs = []
    # suite du code

ce qui évite comme le dit Sve@r des surprises...

[wiztricks]

Salut,

@Wiz "Après comment on écrit çà... dépend du Python que vous connaisse"
Y a plusieurs façon d'écrire une fonction aussi simple ?

On peut saisir le premier item avant l'entrée de la boucle ou initialiser une variable qui rende la condition fausse (pour qu'on entre dans la boucle) ou écrire un while True et sortir de là avec un break ou un return.

Ce qui fait déjà 3 façons pour construire la boucle et qui fonctionneront aussi bien les unes que les autres...

En tous cas, la récursivité n'apporte pas grand chose ici par rapport à la simple boucle puisque son objet (à la récursivité) est de pouvoir découper le problème en parties. Or, ici on accumule sans découper quoi que ce soit...

Comme on demande de fabriquer une liste est-ce qu'on va appliquer len, min, max, sum à toute la liste? Ou comme on saisit une nouvelle valeur à chaque itération avoir un compteur, des valeurs max, min et somme réactualisées à chaque itération.

- W

[Sve@r]

Comme on demande de fabriquer une liste est-ce qu'on va appliquer len, min, max, sum à toute la liste? Ou comme on saisit une nouvelle valeur à chaque itération avoir un compteur, des valeurs max, min et somme réactualisées à chaque itération.

Perso je serais pour les valeurs réactualisées à chaque itération. Déjà question perfo on gagne (plus efficace de comparer une nouvelle entrée à l'entrée mémorisée que d'appliquer systématiquement une action sur tout un ensemble à chaque itération d'autant plus que l'ensemble grandit) et surtout pour l'apprentissage de la programmation, ça montre bien comment enchainer les actions (si ceci alors cela puis ensuite si cela alors ceci). Mais bon, ce n'est pas moi qui ai donné l'exo

[wiztricks]

Perso je serais pour les valeurs réactualisées à chaque itération.

Ça n'a pas trop d'importance quand on débute.
L'essentiel restant de partir sur une logique (qui marche sur le papier) et d'arriver à la traduire en code qui fonctionne.

L'important sera tout ce qu'on aura découvert... et le temps passé à chercher à comprendre. Peut être que le professeur poussera un corrigé un peu différent qui nous permettra de voir des aspects qui nous avaient échappé (et qu'on ne pourra apprécier que si on a fait l'effort de comprendre).

- W

[Invité]

Merci Wiz !

Pour aller plus loin concernant la moyenne, avec quelle méthode risque-t-on le plus de faire des approximations ? (C'est la ""tienne"", nan ?)

Pour le fun :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
import random
from statistics import mean
moy = 0
liste = []
while len(liste) < 10000:
	x = random.randint(0,2)
	moy = (moy*len(liste)+x)/(len(liste)+1)
	liste.append(x)
print(moy)
print(mean(liste))
print(sum(liste)/len(liste))

Aucune idée du pourquoi, du comment... (Je me rappelle plus du nom du module qui permet de voir ce qui se passe derrière)

Pour @fred1599 ou @Sve@r :

l'utilisation de types mutables comme valeur par défaut (ce qui pose parfois plus de souci que ça n'en résout)

Je ne vois pas de quel soucis vous parlez ?

[wiztricks]

Salut,

Merci Wiz !

Pour aller plus loin concernant la moyenne, avec quelle méthode risque-t-on le plus de faire des approximations ? (C'est la ""tienne"", nan ?)

Certainement pas avec ce genre de construction:

Code :

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

       moy = (moy*len(liste)+x)/(len(liste)+1)

puisqu'on propage des erreurs à chaque itération.

Mais ce sont des bases du calcul numérique où on va faire des itérations (souvent) pour converger à un epsilon près. On utilise les nombres flottants (de la machine) parce que c'est plus rapide... et on se prend le chou à contrôler la propagation des erreurs.

On ne va peut être pas sortir le module "decimal" pour 3 calculs où les nombres sont les entiers 0, 1 et 2...

J'adore aussi le "while len(liste) < 10000:", une boucle for _ in range(10000): serait plus approprié puisqu'on connaît le nombre d'itérations!
(ce qui n'est pas le cas dans le problème de départ...)

- W

[MPython Alaplancha]

Bonjour,
On peut aussi construire la boucle avec l'opérateur morse(>=python3.8):

Code :

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

1
2
3
4
5
6
7
8
9
>>> while (x:=int(input("?"))) >= 0:
	print(x)
 
 
?10
10
?15
15
?-1

[Sve@r]

Pour le fun :

Code :

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

1
2
3
4
...
	moy = (moy*len(liste)+x)/(len(liste)+1)
	liste.append(x)
	...

Oh là là !!! Tu utilises une valeur divisée (avec ses erreurs d'approximation) comme base pour le calcul suivant !!! Et en plus tu fais 2 fois un incrément inclus dans le append !!!
Pour le fun oui mais quand-même...

Code :

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

1
2
3
4
...
	liste.append(x)
	moy = sum(liste)/len(liste)
	...

Aucune idée du pourquoi, du comment... (Je me rappelle plus du nom du module qui permet de voir ce qui se passe derrière)

inspect?

Je ne vois pas de quel soucis vous parlez ?

Une des bases de la programmation modulaire, c'est que deux appels différents à une même fonction avec les mêmes paramètres doivent donner deux fois le même résultat. Ou (dit autrement), le résultat de l'étape 2 ne doit pas dépendre du fait que la fonction aura été ou pas appelée à l'étape 1. Parce que sans cette fondamentalité, plus de programmation déterministe possible (surtout si le nombre d'appels dépend par exemple d'une info donnée par l'utilisateur et que le programmeur ne peut donc pas connaitre à l'avance)
Or cela n'est pas possible quand la valeur par défaut est mutable et que l'appel n° 1 la fait muter et devenir alors différente à l'appel n° 2

Code python :

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

1
2
3
4
5
6
7
8
9
10
>>> def f(n, tab=[]):
...	tab.append(n)
...	return tab
...
>>> f(1)
[1]
>>> f(1)
[1, 1]
>>> f(1)
[1, 1, 1]

C'est dû au fait que le paramètre par défaut n'est pas créé lorsque la fonction est appelée mais quand elle est créée (quand l'interpréteur arrive au def fct(...))

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
#!/usr/bin/env python3
# coding: utf-8
 
class cTrace:
	def __init__(self): print("init: ", self)
	def __del__(self): print("del: ", self)
# class cTrace
 
# Première définition de fonction avec un paramètre ayant l’objet comme valeur par défaut
def fct(n=cTrace()): print("fct:", n)
 
# Seconde définition de fonction qui va écraser la première
def fct(n=cTrace()): print("fct:", n)
 
print(1)			# Message témoin
fct("essai")			# Appel avec argument concret (donc pas d’argument par défaut)
print(2)			# Message témoin
fct()				# Appel avec argument par défaut
print(3)			# Message témoin

Résultat

Code :

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

1
2
3
4
5
6
7
8
9
init: <__main__.cTrace object at 0x7f00e496d470>
init: <__main__.cTrace object at 0x7f00e496d550>
del: <__main__.cTrace object at 0x7f00e496d470>
1
fct: essai
2
fct: <__main__.cTrace object at 0x7f00e496d550>
3
del: <__main__.cTrace object at 0x7f00e496d550>

Le premier message "init" provient de l’objet "cTrace()" créé lorsque la fonction est définie. On a déjà là la démonstration que l’argument par défaut est créé à la définition de la fonction et non à son appel. Ensuite, le second message "init" provient d’un second objet "cTrace()" créé lorsque la fonction est de nouveau définie. A ce moment là, la première fonction disparait et avec elle les objets qu’elle a créés d’où le premier message "del". Ensuite le message témoin "1" puis le message en provenance de la fonction, laquelle affiche le paramètre reçu. Puis le second message témoin "2" puis de nouveau le message en provenance de la fonction, laquelle affiche cette fois le paramètre par défaut (objet "cTrace" créé auparavant). Puis le troisième message témoin "3". Puis le programme s’arrête détruisant alors la fonction "fct" ce qui détruit par ricochet son argument par défaut.

Pour résoudre ce souci, on utilise une valeur immuable comme valeur de défaut et on la teste dans la fonction

Code python :

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

1
2
3
4
5
6
7
8
9
10
11
>>> def f(n, tab=None):
...	if tab is None: tab=[]
...	tab.append(n)
...	return tab
...
>>> f(1)
[1]
>>> f(1)
[1]
>>> f(1)
[1]