Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Dominique
Le 14/09/2022 Í 15:55, Dominique a écrit :
Bonjour, Je m'amuse avec « 100 énigmes mathématique123654789s résolues avec Python » Soit t36354, est-il possible d'avoir ce nombre en notation scientifique 1.236354e6 et récupérer dans une variable l'exposant (6 ici) ? Merci et bon orage :) Dominique
Il faut bien sÍ»r lire « 100 énigmes mathématiques résolues avec Python »... (éditions ellipses)
Le 14/09/2022 Í 15:55, Dominique a écrit :
Bonjour,
Je m'amuse avec « 100 énigmes mathématique123654789s résolues avec Python »
Soit t36354, est-il possible d'avoir ce nombre en notation
scientifique 1.236354e6 et récupérer dans une variable l'exposant (6 ici) ?
Merci et bon orage :)
Dominique
Il faut bien sÍ»r lire « 100 énigmes mathématiques résolues avec Python
»... (éditions ellipses)
Bonjour, Je m'amuse avec « 100 énigmes mathématique123654789s résolues avec Python » Soit t36354, est-il possible d'avoir ce nombre en notation scientifique 1.236354e6 et récupérer dans une variable l'exposant (6 ici) ? Merci et bon orage :) Dominique
Il faut bien sÍ»r lire « 100 énigmes mathématiques résolues avec Python »... (éditions ellipses)
Alain Ketterlin
Dominique writes:
Je m'amuse avec « 100 énigmes mathématique123654789s résolues avec Python » Soit t36354, est-il possible d'avoir ce nombre en notation scientifique 1.236354e6 et récupérer dans une variable l'exposant (6 ici) ?
Il y a deux choses complètement différentes dans ta question : 1) pour formater un flottant en notation scientifique : "%e" % (123456.0) # ou "{:e}".format (123456.0) avec des tas de variantes (cf. https://docs.python.org/3/library/string.html#formatspec) 2) Pour extraire mantisse est exposant, il y a math.frexp, mais
math.frexp (123456.0)
(0.94189453125, 17) Tout est normal : dans le codage IEEE 754 (utilisé par Python et le reste du monde), mantisse et exposant sont codés en binaire (pour le dire vite), et c'est ça qu'on récupère. Bien sÍ»r, m*2**e est égal au nombre initial. Si par contre tu veux tout cela "en base 10", tu peux jongler avec math.floor (math.log10 (...)), qui te donnera l'exposant. Il faut ensuite diviser explicitement (et gérer le signe Í part). Je ne connais pas de raccourci. -- Alain.
Dominique <zzz@aol.com> writes:
Je m'amuse avec « 100 énigmes mathématique123654789s résolues avec Python »
Soit t36354, est-il possible d'avoir ce nombre en notation
scientifique 1.236354e6 et récupérer dans une variable l'exposant (6
ici) ?
Il y a deux choses complètement différentes dans ta question :
1) pour formater un flottant en notation scientifique :
"%e" % (123456.0) # ou "{:e}".format (123456.0)
avec des tas de variantes (cf.
https://docs.python.org/3/library/string.html#formatspec)
2) Pour extraire mantisse est exposant, il y a math.frexp, mais
math.frexp (123456.0)
(0.94189453125, 17)
Tout est normal : dans le codage IEEE 754 (utilisé par Python et le
reste du monde), mantisse et exposant sont codés en binaire (pour le
dire vite), et c'est ça qu'on récupère. Bien sÍ»r, m*2**e est égal au
nombre initial.
Si par contre tu veux tout cela "en base 10", tu peux jongler avec
math.floor (math.log10 (...)), qui te donnera l'exposant. Il faut
ensuite diviser explicitement (et gérer le signe Í part). Je ne
connais pas de raccourci.
Je m'amuse avec « 100 énigmes mathématique123654789s résolues avec Python » Soit t36354, est-il possible d'avoir ce nombre en notation scientifique 1.236354e6 et récupérer dans une variable l'exposant (6 ici) ?
Il y a deux choses complètement différentes dans ta question : 1) pour formater un flottant en notation scientifique : "%e" % (123456.0) # ou "{:e}".format (123456.0) avec des tas de variantes (cf. https://docs.python.org/3/library/string.html#formatspec) 2) Pour extraire mantisse est exposant, il y a math.frexp, mais
math.frexp (123456.0)
(0.94189453125, 17) Tout est normal : dans le codage IEEE 754 (utilisé par Python et le reste du monde), mantisse et exposant sont codés en binaire (pour le dire vite), et c'est ça qu'on récupère. Bien sÍ»r, m*2**e est égal au nombre initial. Si par contre tu veux tout cela "en base 10", tu peux jongler avec math.floor (math.log10 (...)), qui te donnera l'exposant. Il faut ensuite diviser explicitement (et gérer le signe Í part). Je ne connais pas de raccourci. -- Alain.
Dans l'énoncé du problème, une variante précise était en effet indiquée : 1.236354e6. Je ne l'obtiens ici qu'avec "replace". f"{chiffre:e}".replace( "e+0", "e" ).replace( "e-0", "e-" )
2) Pour extraire mantisse est exposant, il y a math.frexp, mais
On pourrait aussi utiliser des chaÍ®nes de caractères pour la séparation. def separez( chiffre ): notation = f"{chiffre:.6e}" .replace( "e+0", "e" ) .replace( "e-0", "e-" ) pos = notation.find( 'e' ) return notation[ :pos ], notation[ pos+1: ] ( mantisse, exposant )= separez( 1236354 ) print( mantisse, exposant )
1) pour formater un flottant en notation scientifique :
"%e" % (123456.0) # ou "{:e}".format (123456.0)
vec des tas de variantes (cf.
https://docs.python.org/3/library/string.html#formatspec)
Dans l'énoncé du problème, une variante précise était en
effet indiquée : 1.236354e6. Je ne l'obtiens ici qu'avec
"replace".
Dans l'énoncé du problème, une variante précise était en effet indiquée : 1.236354e6. Je ne l'obtiens ici qu'avec "replace". f"{chiffre:e}".replace( "e+0", "e" ).replace( "e-0", "e-" )
2) Pour extraire mantisse est exposant, il y a math.frexp, mais
On pourrait aussi utiliser des chaÍ®nes de caractères pour la séparation. def separez( chiffre ): notation = f"{chiffre:.6e}" .replace( "e+0", "e" ) .replace( "e-0", "e-" ) pos = notation.find( 'e' ) return notation[ :pos ], notation[ pos+1: ] ( mantisse, exposant )= separez( 1236354 ) print( mantisse, exposant )
Dans l'énoncé du problème, une variante précise était en effet indiquée : 1.236354e6. Je ne l'obtiens ici qu'avec "replace". f"{chiffre:e}".replace( "e+0", "e" ).replace( "e-0", "e-" )
2) Pour extraire mantisse est exposant, il y a math.frexp, mais
On pourrait aussi utiliser des chaÍ®nes de caractères pour la séparation. def separez( chiffre ): notation = f"{chiffre:.6e}" .replace( "e+0", "e" ) .replace( "e-0", "e-" ) pos = notation.find( 'e' ) return notation[ :pos ], notation[ pos+1: ] ( mantisse, exposant )= separez( 1236354 ) print( mantisse, exposant )
Bonsoir, J'ai trouvé cette solution : from math import log10 test=int(input('Nombre ')) exp=int(log10(test)) print(exp) Pour résoudre certains exercices du livre, c'est de cet exposant dont j'ai besoin. Je vous remercie pour votre aide, Dominique
1) pour formater un flottant en notation scientifique :
"%e" % (123456.0) # ou "{:e}".format (123456.0)
vec des tas de variantes (cf.
https://docs.python.org/3/library/string.html#formatspec)
Dans l'énoncé du problème, une variante précise était en
effet indiquée : 1.236354e6. Je ne l'obtiens ici qu'avec
"replace".
Dans l'énoncé du problème, une variante précise était en effet indiquée : 1.236354e6. Je ne l'obtiens ici qu'avec "replace". f"{chiffre:e}".replace( "e+0", "e" ).replace( "e-0", "e-" )
2) Pour extraire mantisse est exposant, il y a math.frexp, mais
On pourrait aussi utiliser des chaÍ®nes de caractères pour la séparation. def separez( chiffre ): notation = f"{chiffre:.6e}" .replace( "e+0", "e" ) .replace( "e-0", "e-" ) pos = notation.find( 'e' ) return notation[ :pos ], notation[ pos+1: ] ( mantisse, exposant )= separez( 1236354 ) print( mantisse, exposant )
Bonsoir, J'ai trouvé cette solution : from math import log10 test=int(input('Nombre ')) exp=int(log10(test)) print(exp) Pour résoudre certains exercices du livre, c'est de cet exposant dont j'ai besoin. Je vous remercie pour votre aide, Dominique
ram
Dominique writes:
Bonsoir,
Bonsoir !
J'ai trouvé cette solution : from math import log10 test=int(input('Nombre ')) exp=int(log10(test)) print(exp)
Oui, mais cette approche pourrait entraÍ®ner quelques irrégularités (comme d'autres approches peut-être). Remarquez dans la sortie du programme suivant comment la valeur 14 manque dans la deuxième colonne ! from math import log10 num = '' for i in range( 16 ): num += '9' e = int( log10( int( num ))) print( i, e, num, int( num ), log10( int( num ))) sortie : 0 0 9 9 0.9542425094393249 1 1 99 99 1.99563519459755 2 2 999 999 2.9995654882259823 3 3 9999 9999 3.9999565683801923 4 4 99999 99999 4.999995657033466 5 5 999999 999999 5.999999565705301 6 6 9999999 9999999 6.99999995657055 7 7 99999999 99999999 7.999999995657055 8 8 999999999 999999999 8.999999999565706 9 9 9999999999 9999999999 9.99999999995657 10 10 99999999999 99999999999 10.999999999995657 11 11 999999999999 999999999999 11.999999999999567 12 12 9999999999999 9999999999999 12.999999999999957 13 13 99999999999999 99999999999999 13.999999999999996 14 15 999999999999999 999999999999999 15.0 15 16 9999999999999999 9999999999999999 16.0
Dominique <zzz@aol.com> writes:
Bonsoir,
Bonsoir !
J'ai trouvé cette solution :
from math import log10
test=int(input('Nombre '))
exp=int(log10(test))
print(exp)
Oui, mais cette approche pourrait entraͮner quelques
irrégularités (comme d'autres approches peut-être).
Remarquez dans la sortie du programme suivant comment
la valeur 14 manque dans la deuxième colonne !
from math import log10
num = ''
for i in range( 16 ):
num += '9'
e = int( log10( int( num )))
print( i, e, num, int( num ), log10( int( num )))
J'ai trouvé cette solution : from math import log10 test=int(input('Nombre ')) exp=int(log10(test)) print(exp)
Oui, mais cette approche pourrait entraÍ®ner quelques irrégularités (comme d'autres approches peut-être). Remarquez dans la sortie du programme suivant comment la valeur 14 manque dans la deuxième colonne ! from math import log10 num = '' for i in range( 16 ): num += '9' e = int( log10( int( num ))) print( i, e, num, int( num ), log10( int( num ))) sortie : 0 0 9 9 0.9542425094393249 1 1 99 99 1.99563519459755 2 2 999 999 2.9995654882259823 3 3 9999 9999 3.9999565683801923 4 4 99999 99999 4.999995657033466 5 5 999999 999999 5.999999565705301 6 6 9999999 9999999 6.99999995657055 7 7 99999999 99999999 7.999999995657055 8 8 999999999 999999999 8.999999999565706 9 9 9999999999 9999999999 9.99999999995657 10 10 99999999999 99999999999 10.999999999995657 11 11 999999999999 999999999999 11.999999999999567 12 12 9999999999999 9999999999999 12.999999999999957 13 13 99999999999999 99999999999999 13.999999999999996 14 15 999999999999999 999999999999999 15.0 15 16 9999999999999999 9999999999999999 16.0
ram
(Stefan Ram) writes:
e = int( log10( int( num )))
Les irrégularités pourraient être évitées en utilisant int( Decimal( num ).log10() ) au lieu de int( log10( int( num ))) (après "from decimal import Decimal"). (Dans ce cas, num devrait être une chaÍ®ne de caractères ou un nombre entier, car la conversion en nombre Í virgule flottante pourrait entraÍ®ner des erreurs.) (Mais on peut probablement aussi utiliser la longueur du nombre entier comme chaÍ®ne de caractères pour calculer le logarithme décimal.)
ram@zedat.fu-berlin.de (Stefan Ram) writes:
e = int( log10( int( num )))
Les irrégularités pourraient être évitées en utilisant
int( Decimal( num ).log10() ) au lieu de int( log10( int( num )))
(après "from decimal import Decimal").
(Dans ce cas, num devrait être une chaÍ®ne de caractères
ou un nombre entier, car la conversion en nombre Í virgule
flottante pourrait entraͮner des erreurs.)
(Mais on peut probablement aussi utiliser la longueur du
nombre entier comme chaÍ®ne de caractères pour calculer le
logarithme décimal.)
Les irrégularités pourraient être évitées en utilisant int( Decimal( num ).log10() ) au lieu de int( log10( int( num ))) (après "from decimal import Decimal"). (Dans ce cas, num devrait être une chaÍ®ne de caractères ou un nombre entier, car la conversion en nombre Í virgule flottante pourrait entraÍ®ner des erreurs.) (Mais on peut probablement aussi utiliser la longueur du nombre entier comme chaÍ®ne de caractères pour calculer le logarithme décimal.)
Dominique
Le 14/09/2022 Í 18:10, Stefan Ram a écrit :
(Stefan Ram) writes: (Mais on peut probablement aussi utiliser la longueur du nombre entier comme chaÍ®ne de caractères pour calculer le logarithme décimal.)
J'avais pensé Í cette méthode... J'ai préféré l'approche arithmétique, mais vous avez raison, l'anomalie (14) que vous soulevez dans le précédent post est ennuyeuse. Je peux la contourner avec un len(str(num)) et j'aurai mon exposant + 1. C'est sans doute l'option que je vais adopter. Merci pour le tuyau, Dominique
Le 14/09/2022 Í 18:10, Stefan Ram a écrit :
ram@zedat.fu-berlin.de (Stefan Ram) writes:
(Mais on peut probablement aussi utiliser la longueur du
nombre entier comme chaÍ®ne de caractères pour calculer le
logarithme décimal.)
J'avais pensé Í cette méthode... J'ai préféré l'approche arithmétique,
mais vous avez raison, l'anomalie (14) que vous soulevez dans le
précédent post est ennuyeuse. Je peux la contourner avec un
len(str(num)) et j'aurai mon exposant + 1. C'est sans doute l'option que
je vais adopter.
(Stefan Ram) writes: (Mais on peut probablement aussi utiliser la longueur du nombre entier comme chaÍ®ne de caractères pour calculer le logarithme décimal.)
J'avais pensé Í cette méthode... J'ai préféré l'approche arithmétique, mais vous avez raison, l'anomalie (14) que vous soulevez dans le précédent post est ennuyeuse. Je peux la contourner avec un len(str(num)) et j'aurai mon exposant + 1. C'est sans doute l'option que je vais adopter. Merci pour le tuyau, Dominique
Alain Ketterlin
(Stefan Ram) writes: [...]
Oui, mais cette approche pourrait entraÍ®ner quelques irrégularités (comme d'autres approches peut-être).
Cela n'est pas lié spécialement Í log10, c'est tout simplement la représentation des flottants qui a une précision limitée (j'utilise des chaÍ®nes seulement pour comparer Í ton code) :
float ( int ('9'*15) )
999999999999999.0
float ( int ('9'*16) )
1e+16 (et effectivement le module decimal permet d'étendre cette précision, mais elle restera toujours finie). Tu peux utiliser des entiers (ou même des chaÍ®nes de caractères pour une raison qui m'échappe) si tu veux, mais log10 () va convertir son argument en flottant avant de calculer quoi que ce soit, ce qui aggrave les risque d'imprécision.
from math import log10 num = '' for i in range( 16 ): num += '9' e = int( log10( int( num ))) print( i, e, num, int( num ), log10( int( num )))
int (... un flottant ...) arrondit vers zéro. Il vaut mieux utiliser math.floor() pour les petits nombres. Note que pour i tu traites le nombre (10*(i+2)) - 1 (ou '9'*(i+1)). [...]
for i in [14, 15, 16]: print (float (int ('9'*i)), math.log10 (float (int ('9'*i)))) affiche 99999999999999.0 13.999999999999996 999999999999999.0 15.0 1e+16 16.0 donc : pour 14 tout est (Í peu près) ok, pour 15 c'est log10 qui arrondit, pour 16, c'est la conversion en entier qui arrondit. -- Alain.
ram@zedat.fu-berlin.de (Stefan Ram) writes:
[...]
Oui, mais cette approche pourrait entraͮner quelques
irrégularités (comme d'autres approches peut-être).
Cela n'est pas lié spécialement Í log10, c'est tout simplement la
représentation des flottants qui a une précision limitée (j'utilise des
chaÍ®nes seulement pour comparer Í ton code) :
float ( int ('9'*15) )
999999999999999.0
float ( int ('9'*16) )
1e+16
(et effectivement le module decimal permet d'étendre cette précision,
mais elle restera toujours finie).
Tu peux utiliser des entiers (ou même des chaÍ®nes de caractères pour une
raison qui m'échappe) si tu veux, mais log10 () va convertir son
argument en flottant avant de calculer quoi que ce soit, ce qui aggrave
les risque d'imprécision.
from math import log10
num = ''
for i in range( 16 ):
num += '9'
e = int( log10( int( num )))
print( i, e, num, int( num ), log10( int( num )))
int (... un flottant ...) arrondit vers zéro. Il vaut mieux utiliser
math.floor() pour les petits nombres.
Note que pour i tu traites le nombre (10*(i+2)) - 1 (ou '9'*(i+1)).
Oui, mais cette approche pourrait entraÍ®ner quelques irrégularités (comme d'autres approches peut-être).
Cela n'est pas lié spécialement Í log10, c'est tout simplement la représentation des flottants qui a une précision limitée (j'utilise des chaÍ®nes seulement pour comparer Í ton code) :
float ( int ('9'*15) )
999999999999999.0
float ( int ('9'*16) )
1e+16 (et effectivement le module decimal permet d'étendre cette précision, mais elle restera toujours finie). Tu peux utiliser des entiers (ou même des chaÍ®nes de caractères pour une raison qui m'échappe) si tu veux, mais log10 () va convertir son argument en flottant avant de calculer quoi que ce soit, ce qui aggrave les risque d'imprécision.
from math import log10 num = '' for i in range( 16 ): num += '9' e = int( log10( int( num ))) print( i, e, num, int( num ), log10( int( num )))
int (... un flottant ...) arrondit vers zéro. Il vaut mieux utiliser math.floor() pour les petits nombres. Note que pour i tu traites le nombre (10*(i+2)) - 1 (ou '9'*(i+1)). [...]
for i in [14, 15, 16]: print (float (int ('9'*i)), math.log10 (float (int ('9'*i)))) affiche 99999999999999.0 13.999999999999996 999999999999999.0 15.0 1e+16 16.0 donc : pour 14 tout est (Í peu près) ok, pour 15 c'est log10 qui arrondit, pour 16, c'est la conversion en entier qui arrondit. -- Alain.
