Affichage en notation scientifique.

[Dominique]

Bonjour,

Je m'amuse avec « 100 énigmes mathématique123654789s résolues avec Python »

Soit t=1236354, 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

[Dominique]

Il faut bien sûr lire « 100 énigmes mathématiques résolues avec Python
»... (éditions ellipses)

[Alain Ketterlin]

Dominique <z...@aol.com> writes:

> Je m'amuse avec « 100 énigmes mathématique123654789s résolues avec Python »
>
> Soit t=1236354, 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]

Le 14/09/2022 à 17:00, Stefan Ram a écrit :

> Alain Ketterlin <al...@universite-de-strasbourg.fr.invalid> writes:
>> 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".
>
> 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

[Dominique]

Le 14/09/2022 à 18:10, Stefan Ram a écrit :
> r...@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.

Merci pour le tuyau,

Dominique

[Alain Ketterlin]

r...@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)).

[...]
> 13 13 99999999999999 99999999999999 13.999999999999996
> 14 15 999999999999999 999999999999999 15.0
> 15 16 9999999999999999 9999999999999999 16.0

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.