Discussion :

[Nadia Teach]

Bonsoir,
je voudrais remplir un tableau avec des réels, le réel doit varier entre 0 et 20.

Code :

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

1
2
3
4
5
6
 
def remplissage(n,t):
    for i in range(n):
        t[i]=-1
        while t[i] not in range(0,21):
            t[i]=float(input("Donner la moyenne de l'élève n°"+str(i)+":"))

La fonction n'accepte pas les réels, mais uniquement les entiers.
Comment régler ce problème ?
Merci!

[Sve@r]

Bonjour

La fonction n'accepte pas les réels, mais uniquement les entiers.

Quelle fonction ???

Comment régler ce problème ?

Ben... tu lui passes des entiers

Et on met son code entre balises [code] et [/code] si on veut qu'il soit lisible.

[Nadia Teach]

Message modifié.
Je voudrais que la fonction remplissage accepte des réels.

[Sve@r]

Je voudrais que la fonction remplissage accepte des réels.

Le souci n'est pas là. Le souci est "comment faire qu'un réel soit compris entre 0 et 20". Tu as voulu utiliser range() pour checker mais ça ne peut pas marcher car range() ne donne que des entiers (et même si ça avait marché, ça aurait été bien lourd de générer 20 nombres à chaque fois).
Pourquoi tu ne reviens pas aux bases ? Celles qui existaient bien avant range() ? Comment on fait dans les autres langages pour voir si une valeur est comprise entre 0 et 20 ? On fait des tests !!!

PS: "Donner la moyenne de l'élève n°"+str(i)+":" => "Donner la moyenne de l'élève n° %d:" % i

[Nadia Teach]

Le souci n'est pas là. Le souci est "comment faire qu'un réel soit compris entre 0 et 20". Tu as voulu utiliser range() pour checker mais ça ne peut pas marcher car range() ne donne que des entiers (et même si ça avait marché, ça aurait été bien lourd de générer 20 nombres à chaque fois).
Pourquoi tu ne reviens pas aux bases ? Celles qui existaient bien avant range() ? Comment on fait dans les autres langages pour voir si une valeur est comprise entre 0 et 20 ? On fait des tests !!!

PS: "Donner la moyenne de l'élève n°"+str(i)+":" => "Donner la moyenne de l'élève n° %d:" % i

Merci!

[wiztricks]

Comment régler ce problème ?

t[i]=float(...) va assigner un nombre flottant à t[i].
Par contre, si t[i] est un nombre flottant, il ne sera jamais dans range(0, 21) - puisque ce sont des entiers...

- W

[Nadia Teach]

t[i]=float(...) va assigner un nombre flottant à t[i].
Par contre, si t[i] est un nombre flottant, il ne sera jamais dans range(0, 21) - puisque ce sont des entiers...

- W

Est-ce qu'il y a moyen de faire en sorte que l'intervalle soit un intervalle de réels?

[Sve@r]

Est-ce qu'il y a moyen de faire en sorte que l'intervalle soit un intervalle de réels?

Pourquoi faire ? Pour tester que le nombre entré est compris entre 0 et 20?

Déjà parlons mathématiques. Quels sont les nombres réels compris entre (allez, facile) 0 et 1.
On a 0; 0.1; 0.2; 0.3; 0.4; 0.5; 0.6; 0.7; 0.8; 0.9 et enfin 1. Ouf c'est fini.
Ah non, on a aussi 0.01; 0.02; 0.03; 0.04... 0.98 et 0.99. Enfin on y est.
Ah non, on a aussi 0.001; 0.002; 0.003; 0.004... C'est bon? Tu as enfin compris ???

Donc je reprends: Pourquoi faire ? Tu ne sais pas écrire un test logique vérifiant qu'un nombre est plus grand que 1 et plus petit que 20 ???

[Nadia Teach]

Pourquoi faire ? Pour tester que le nombre entré est compris entre 0 et 20?

Déjà parlons mathématiques. Quels sont les nombres réels compris entre (allez, facile) 0 et 1.
On a 0; 0.1; 0.2; 0.3; 0.4; 0.5; 0.6; 0.7; 0.8; 0.9 et enfin 1. Ouf c'est fini.
Ah non, on a aussi 0.01; 0.02; 0.03; 0.04... 0.98 et 0.99. Enfin on y est.
Ah non, on a aussi 0.001; 0.002; 0.003; 0.004... C'est bon? Tu as enfin compris ???

Donc je reprends: Pourquoi faire ? Tu ne sais pas écrire un test logique vérifiant qu'un nombre est plus grand que 1 et plus petit que 20 ???

Il s'agit de remplir un tableau avec les moyennes d'élèves. Je demandais juste s'il était possible d'utiliser range dans ce cas. Pas la peine d'utiliser ce ton.

[Nadia Teach]

Merci!

[Sve@r]

Pas la peine d'utiliser ce ton.

Je t'ai dit une première fois ici comment tester si un nombre est compris entre 1 et 20. Plus expliqué en quoi un intervalle ne conviendra pas. Plus expliqué aussi d'une façon différente par wiztricks. Et tu réitères à vouloir utiliser un intervalle pour le faire. Tu es enseignant! Quel ton utiliseras-tu toi si tu dis à un élève une première fois de faire tel truc en lui expliquant la raison et qu'il ne le fait pas et que tu doives le lui redire une seconde fois?
Donc voilà, telles sont les règles pour tes élèves, telles sont les règles pour toi. Tu viens demander de l'aide, je prends du temps à t'aider et à t'expliquer les choses et toi tu ne prends pas en retour la politesse de lire et de réfléchir sur les réponses donc je prends le ton que je veux si je dois te le dire une seconde fois.

[MPython Alaplancha]

Bonjour,

Est-ce qu'il y a moyen de faire en sorte que l'intervalle soit un intervalle de réels?

Avec numpy:

Code :

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

1
2
3
4
5
>>> import numpy as np
>>> numbers = np.arange(0.1, 1, 0.1)
>>> print(numbers)
[0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
>>>

Code :

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

1
2
3
4
5
6
7
8
9
10
>>> numbers = np.arange(0.1, 1, 0.01)
>>> print(numbers)
[0.1  0.11 0.12 0.13 0.14 0.15 0.16 0.17 0.18 0.19 0.2  0.21 0.22 0.23
 0.24 0.25 0.26 0.27 0.28 0.29 0.3  0.31 0.32 0.33 0.34 0.35 0.36 0.37
 0.38 0.39 0.4  0.41 0.42 0.43 0.44 0.45 0.46 0.47 0.48 0.49 0.5  0.51
 0.52 0.53 0.54 0.55 0.56 0.57 0.58 0.59 0.6  0.61 0.62 0.63 0.64 0.65
 0.66 0.67 0.68 0.69 0.7  0.71 0.72 0.73 0.74 0.75 0.76 0.77 0.78 0.79
 0.8  0.81 0.82 0.83 0.84 0.85 0.86 0.87 0.88 0.89 0.9  0.91 0.92 0.93
 0.94 0.95 0.96 0.97 0.98 0.99]
>>>

[wiztricks]

Est-ce qu'il y a moyen de faire en sorte que l'intervalle soit un intervalle de réels?

Un intervalle se définit par des bornes a, b (et le caractère ouvert ou fermé qui a son intérêt en topologie) et un nombre réel x sera dans l'intervalle [a, b] si et seulement si a <= x <= b.

- W

[Invité]

je voudrais remplir un tableau avec des réels, le réel doit varier entre 0 et 20.

Je dirais que c'est impossible puisque comme dit par Sve@r il y a une infinité de nombre entre 0 et 20.

@Hominidié Sans passer par numpy :

Code :

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

1
2
for i in range(0, 20*10**3):
    print(i/10**3)

Je ne sais pas s'il peut y avoir des approximations ou non... Les histoires de virgules flottantes, tout ci tout ça...

[Sve@r]

Je ne sais pas s'il peut y avoir des approximations ou non... Les histoires de virgules flottantes, tout ci tout ça...

Testons ça ensemble...

Code python :

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

1
2
>>> 0.2*3 == 0.6
False

Testé.

la précision des nombres décimaux
On trouve vraiment tout ce qu'il y a à savoir sur ce fabuleux tuto...

[Invité]

Oui mais dans ce cas précis ? Diviser un entier par un entier facteur de 10 peut-il donner un résultat inexact ? Je remets toutes mes certitudes en question...

Code :

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

1
2
(2*3)/10
0.6

Code :

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

1
2
3
4
5
6
7
8
def test(n):
    return len(str(n).split('.')[1]) > 3
 
for i in range(0, 20*10**3):
    if test(i/10**3):
        print(i/10**3)
 
#Nada

Par extrapolation je dirais que non du coup.

[Sve@r]

Oui mais dans ce cas précis ? Diviser un entier par un entier facteur de 10 peut-il donner un résultat inexact ?

Mathématiquement non (la logique mathématique est sans faille). D'ailleurs mathématiquement quand une division n'est pas possible on utilise alors la fraction correspondant à la division comme un nombre manipulable et parfois la fraction arrive à se simplifier et à disparaitre.

Mais le souci de l'informatique, c'est qu'elle tente de convertir un nombre décimal (donc par définition fini) en somme de puissances négatives de 2 (une puissance négative se traduisant par une division ex 2^(-n)=1/(2^n))
Or pour beaucoup de décimaux, le résultat qui est fini en décimal devient infini en binaire.

Pour convertir un décimal en binaire, la méthode est simple: on multiplie le décimal par 2 et on garde la partie entière qu'on enlève pour le tour suivant. Et on s'arrête quand on tombe sur 0 et on récupère les parties entières qu'on a gardé.
Ex 0.8125

• 0.8125 * 2 = 1.625 (on garde 1, reste 0.625)
• 0.625 * 2 = 1.25 (on garde 1, reste 0.25)
• 0.25 * 2 = 0.5 (on garde 0, reste 0.5)
• 0.5 * 2 = 1.0 (on garde 1, reste 0 et c'est fini)

Résultat 0.8125=0.1101 en binaire, ce qui se traduit par 2^(-1) + 2^(-2) + 2^(-4) = 1/2 + 1/4 + 1/16 = 0.8125

Mais si on prend 0.6

• 0.6 * 2 = 1.2 (on garde 1, reste 0.2)
• 0.2 * 2 = 0.4 (on garde 0, reste 0.4)
• 0.4 * 2 = 0.8 (on garde 0, reste 0.8)
• 0.8 * 2 = 1.6 (on garde 1, reste 0.6 et là c'est la zoub)

On dit donc que 0.6 est presque égal à 0.1001 en binaire (enfin je m'arrête à 4 mais l'UAL elle va plus loin donc aura plus de précision sans toutefois arriver à l'absolu). Et "presque égal" en mathématiques c'est absolument la même chose que "totalement inégal". Et effectivement 0.1001 = 2^(-1) + 2^(-4) = 1/2 + 1/16 = 0.5625. On peut continuer, ce qui fera 0.10011001=1/2 + 1/16 + 1/32 + 1/256 = 0.59765625 et etc (0.100110011001= 1/2 + 1/16 + 1/32 + 1/256 + 1/512 + 1/4096 = 0.599853515625) mais on ne tombera jamais sur 0.6.

Et au final

Code python :

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

1
2
3
4
>>> 0.6==3/10*2
True
>>> 0.6==2/10*3
False

Alors pourquoi dans certains cas il arrive à se récupérer là j'en sais rien (l'UAL doit avoir des algos de correction...)