J'ai deux ou trois petits programmes que j'ai dans un vieux langage que
j'aimerai mettre en Python. (je ne suis pas trop programmeur...)
Pour étudier ce langage j'ai téléchargé et imprimé un
fichier .pdf :"Apprendre à programmer avec Python" de Gérard Swinnen. (370
pages!)
Là, il y a un truc qui me chagrine.
C'est écrit ça :
a,b=7.3,12
y=3*a+b/5
Et là ça me donne :
y=23.899999999999999 (??!!)
Pourquoi ça ne donne pas y=24.3?
Et pourquoi a=7.2999999999999998 alors que j'avais écrit 7.3?
Ce n'est pas la peine que j'aille plus loin si ça c'est faux.
(Ca se trouve l'explication est donné plus loin mais je n'en suis pas encore
là.)
il me semble que toutes les explications données dans ce fil de discussion sont erronées. Toutes les informations fausses... Rien que ça.
Un peu de fatigue, et j'ai posté un peu trop bas dans le fil de discussion. J'eusse du répondre juste avant ton "post", veuilles m'en excuser.
En effet Python spécifie que lorsqu'il est en présence d'opérations binaires avec des types d'opérandes hétérogènes il "élargit" l'opérande du plus petit type au type de l'autre [1]. Aucune restriction n'existe concernant la position des opérandes. Il me semble que l'interprétation du précepte de base est un peu abusive.
Du tout. Quand je parle de position, je veux simplement dire, en prenant par exemple le cas de l'addition, a + b versus b + a. Pour le reste c'est peut-être mal traduit, j'ai essayé de reproduire fidèlement en français ce qui est donné dans la Library Reference. Quand à ton explication, elle est correcte (et n'entre pas en conflit avec mon interprétation), car elle s'appuie sur les priorités des opérateurs: b / 5 donne effectivement 2 car les deux opérandes sont des entiers et que la division est effectuée indépendamment de ce qui se passe autour.
J'en profite pour mentionner, à l'attention de G-raison tout particulièrement, qu'en Python on peut écrire un entier sous la forme d'un nombre en virgule flottante en mettant simplement un point immédiatement après le dernier chiffre et rien d'autre (le 0 est optionnel) et que les littéraux en notation scientifique, par exemple 1e3, sont systématiquement des flottants même s'il ne contiennent pas de . (point). L'opérateur // est bien pratique pour faire des division entière avec des flottants, mais attention le résultat est quand même un nombre en virgule flottante (12 // 5. = 2.0).
Je ne ferai pas un cours sur le nombres en virgule flottante, d'autant plus que c'est déjà expliqué ici : http://fr.wikipedia.org/wiki/Nombre_flottant
Merci.
Bon week-end à tous !
Laurent
Bonsoir,
Bonjour,
il me semble que toutes les explications données dans ce fil de
discussion sont erronées.
Toutes les informations fausses... Rien que ça.
Un peu de fatigue, et j'ai posté un peu trop bas dans le fil de discussion.
J'eusse du répondre juste avant ton "post", veuilles m'en excuser.
En effet Python spécifie que lorsqu'il est en présence d'opérations
binaires avec des types d'opérandes hétérogènes il "élargit" l'opérande
du plus petit type au type de l'autre [1]. Aucune restriction n'existe
concernant la position des opérandes.
Il me semble que l'interprétation du précepte de base est un peu abusive.
Du tout. Quand je parle de position, je veux simplement dire, en prenant
par exemple le cas de l'addition, a + b versus b + a.
Pour le reste c'est peut-être mal traduit, j'ai essayé de reproduire
fidèlement en français ce qui est donné dans la Library Reference.
Quand à ton explication, elle est correcte (et n'entre pas en conflit
avec mon interprétation), car elle s'appuie sur les priorités des
opérateurs: b / 5 donne effectivement 2 car les deux opérandes sont des
entiers et que la division est effectuée indépendamment de ce qui se
passe autour.
J'en profite pour mentionner, à l'attention de G-raison tout
particulièrement, qu'en Python on peut écrire un entier sous la forme
d'un nombre en virgule flottante en mettant simplement un point
immédiatement après le dernier chiffre et rien d'autre (le 0 est
optionnel) et que les littéraux en notation scientifique, par exemple
1e3, sont systématiquement des flottants même s'il ne contiennent pas de
. (point).
L'opérateur // est bien pratique pour faire des division entière avec
des flottants, mais attention le résultat est quand même un nombre en
virgule flottante (12 // 5. = 2.0).
Je ne ferai pas un cours sur le nombres en virgule flottante, d'autant
plus que c'est déjà expliqué ici :
http://fr.wikipedia.org/wiki/Nombre_flottant
il me semble que toutes les explications données dans ce fil de discussion sont erronées. Toutes les informations fausses... Rien que ça.
Un peu de fatigue, et j'ai posté un peu trop bas dans le fil de discussion. J'eusse du répondre juste avant ton "post", veuilles m'en excuser.
En effet Python spécifie que lorsqu'il est en présence d'opérations binaires avec des types d'opérandes hétérogènes il "élargit" l'opérande du plus petit type au type de l'autre [1]. Aucune restriction n'existe concernant la position des opérandes. Il me semble que l'interprétation du précepte de base est un peu abusive.
Du tout. Quand je parle de position, je veux simplement dire, en prenant par exemple le cas de l'addition, a + b versus b + a. Pour le reste c'est peut-être mal traduit, j'ai essayé de reproduire fidèlement en français ce qui est donné dans la Library Reference. Quand à ton explication, elle est correcte (et n'entre pas en conflit avec mon interprétation), car elle s'appuie sur les priorités des opérateurs: b / 5 donne effectivement 2 car les deux opérandes sont des entiers et que la division est effectuée indépendamment de ce qui se passe autour.
J'en profite pour mentionner, à l'attention de G-raison tout particulièrement, qu'en Python on peut écrire un entier sous la forme d'un nombre en virgule flottante en mettant simplement un point immédiatement après le dernier chiffre et rien d'autre (le 0 est optionnel) et que les littéraux en notation scientifique, par exemple 1e3, sont systématiquement des flottants même s'il ne contiennent pas de . (point). L'opérateur // est bien pratique pour faire des division entière avec des flottants, mais attention le résultat est quand même un nombre en virgule flottante (12 // 5. = 2.0).
Je ne ferai pas un cours sur le nombres en virgule flottante, d'autant plus que c'est déjà expliqué ici : http://fr.wikipedia.org/wiki/Nombre_flottant
Merci.
Bon week-end à tous !
Laurent
G-raison
Cémoi wrote:
J'en profite pour mentionner, à l'attention de G-raison tout particulièrement, qu'en Python on peut écrire un entier sous la forme d'un nombre en virgule flottante en mettant simplement un point immédiatement après le dernier chiffre et rien d'autre (le 0 est optionnel) et que les littéraux en notation scientifique, par exemple 1e3, sont systématiquement des flottants même s'il ne contiennent pas de . (point). L'opérateur // est bien pratique pour faire des division entière avec des flottants, mais attention le résultat est quand même un nombre en virgule flottante (12 // 5. = 2.0).
Vu, bon à savoir merci. ;-)
Laurent
-- @+ gr
Cémoi wrote:
J'en profite pour mentionner, à l'attention de G-raison tout
particulièrement, qu'en Python on peut écrire un entier sous la forme
d'un nombre en virgule flottante en mettant simplement un point
immédiatement après le dernier chiffre et rien d'autre (le 0 est
optionnel) et que les littéraux en notation scientifique, par exemple
1e3, sont systématiquement des flottants même s'il ne contiennent pas de
. (point).
L'opérateur // est bien pratique pour faire des division entière avec
des flottants, mais attention le résultat est quand même un nombre en
virgule flottante (12 // 5. = 2.0).
J'en profite pour mentionner, à l'attention de G-raison tout particulièrement, qu'en Python on peut écrire un entier sous la forme d'un nombre en virgule flottante en mettant simplement un point immédiatement après le dernier chiffre et rien d'autre (le 0 est optionnel) et que les littéraux en notation scientifique, par exemple 1e3, sont systématiquement des flottants même s'il ne contiennent pas de . (point). L'opérateur // est bien pratique pour faire des division entière avec des flottants, mais attention le résultat est quand même un nombre en virgule flottante (12 // 5. = 2.0).
