Comment obtenir des nombres après la virgule décimale?

Comment obtenir les nombres après une virgule décimale?

Par exemple, si je l'ai 5.55, comment puis-je l'obtenir .55?

Une approche simple pour vous:

number_dec = str(number-int(number))[1:]

5.55 % 1

Gardez à l'esprit que cela ne vous aidera pas avec les problèmes d'arrondi en virgule flottante. Ie, vous pouvez obtenir:

0.550000000001

Ou sinon un peu en dehors des 0,55 que vous attendez.

Utilisez modf :

>>> import math
>>> frac, whole = math.modf(2.5)
>>> frac
0.5
>>> whole
2.0

Qu'en est-il de:

a = 1.3927278749291
b = a - int(a)

b
>> 0.39272787492910011

Ou, en utilisant numpy:

import numpy
a = 1.3927278749291
b = a - numpy.fix(a)

En utilisant le decimalmodule de la bibliothèque standard, vous pouvez conserver la précision d'origine et éviter les problèmes d'arrondi en virgule flottante:

>>> from decimal import Decimal
>>> Decimal('4.20') % 1
Decimal('0.20')

Comme Kindall notes dans les commentaires, vous devez convertir natif floatde chaînes à la première.

Essayez Modulo:

5.55%1 = 0.54999999999999982

similaire à la réponse acceptée, une approche encore plus simple utilisant des chaînes serait

def number_after_decimal(number1):
    number = str(number1)
    if 'e-' in number: # scientific notation
        number_dec = format(float(number), '.%df'%(len(number.split(".")[1].split("e-")[0])+int(number.split('e-')[1])))
    elif "." in number: # quick check if it is decimal
        number_dec = number.split(".")[1]
    return number_dec

import math
orig = 5.55
whole = math.floor(orig)    # whole = 5.0
frac = orig - whole         # frac = 0.55

>>> n=5.55
>>> if "." in str(n):
...     print "."+str(n).split(".")[-1]
...
.55

C'est une solution que j'ai essayée:

num = 45.7234
(whole, frac) = (int(num), int(str(num)[(len(str(int(num)))+1):]))

Parfois, les zéros de fin comptent

In [4]: def split_float(x):
   ...:     '''split float into parts before and after the decimal'''
   ...:     before, after = str(x).split('.')
   ...:     return int(before), (int(after)*10 if len(after)==1 else int(after))
   ...: 
   ...: 

In [5]: split_float(105.10)
Out[5]: (105, 10)

In [6]: split_float(105.01)
Out[6]: (105, 1)

In [7]: split_float(105.12)
Out[7]: (105, 12)

En utilisant simplement la division d' opérateur «/» et la division de plancher «//», vous pouvez facilement obtenir la partie fraction d'un flottant donné.

number = 5.55

result = (number/1) - (number//1)

print(result)

Utilisez le plancher et soustrayez le résultat du nombre d'origine:

>> import math #gives you floor.
>> t = 5.55 #Give a variable 5.55
>> x = math.floor(t) #floor returns t rounded down to 5..
>> z = t - x #z = 5.55 - 5 = 0.55

Les nombres flottants ne sont pas stockés au format décimal (base10). Lisez la documentation python à ce sujet pour vous convaincre pourquoi. Par conséquent, obtenir une représentation base10 à partir d'un flottant n'est pas conseillé.

Il existe maintenant des outils qui permettent de stocker des données numériques au format décimal. Voici un exemple d'utilisation de la Decimalbibliothèque.

from decimal import *

x = Decimal('0.341343214124443151466')
str(x)[-2:] == '66'  # True

y = 0.341343214124443151466
str(y)[-2:] == '66'  # False

Exemple:

import math
x = 5.55
print((math.floor(x*100)%100))

Cela vous donnera deux nombres après la virgule décimale, 55 de cet exemple. Si vous avez besoin d'un nombre, vous réduisez de 10 les calculs ci-dessus ou augmentez en fonction du nombre de nombres que vous voulez après la virgule.

import math

x = 1245342664.6
print( (math.floor(x*1000)%1000) //100 )

Cela a vraiment fonctionné

Qu'en est-il de:

a = 1.234
b = a - int(a)
length = len(str(a))

round(b, length-2)

Production:
print(b)
0.23399999999999999
round(b, length-2)
0.234

Puisque l'arrondi est envoyé à la longueur de la chaîne de décimales ('0,234'), nous pouvons simplement moins 2 pour ne pas compter le '0.', et déterminer le nombre souhaité de décimales. Cela devrait fonctionner la plupart du temps, à moins que vous n'ayez beaucoup de décimales et que l'erreur d'arrondi lors du calcul de b interfère avec le deuxième paramètre d'arrondi.

Vous pouvez essayer ceci:

your_num = 5.55
n = len(str(int(your_num)))
float('0' + str(your_num)[n:])

Il reviendra 0.55.

number=5.55
decimal=(number-int(number))
decimal_1=round(decimal,2)
print(decimal)
print(decimal_1)

sortie: 0,55

Voyez ce que je fais souvent pour obtenir des nombres après la virgule décimale en python 3:

a=1.22
dec=str(a).split('.')
dec= int(dec[1])

Si vous utilisez des pandas:

df['decimals'] = df['original_number'].mod(1)

Une autre option serait d'utiliser le re module avec re.findallou re.search:

import re


def get_decimcal(n: float) -> float:
    return float(re.search(r'\.\d+', str(n)).group(0))


def get_decimcal_2(n: float) -> float:
    return float(re.findall(r'\.\d+', str(n))[0])


def get_int(n: float) -> int:
    return int(n)


print(get_decimcal(5.55))
print(get_decimcal_2(5.55))
print(get_int(5.55))

Production

0.55
0.55
5

Si vous souhaitez simplifier / modifier / explorer l'expression, cela a été expliqué dans le panneau supérieur droit de regex101.com . Si vous le souhaitez, vous pouvez également regarder dans ce lien , comment il correspondrait à certains exemples d'entrées.

La source

Comment se débarrasser des nombres flottants supplémentaires dans la soustraction python?

J'ai trouvé que de très grands nombres avec de très grandes parties fractionnaires peuvent poser des problèmes lors de l'utilisation de modulo 1 pour obtenir la fraction.

import decimal

>>> d = decimal.Context(decimal.MAX_PREC).create_decimal(
... '143000000000000000000000000000000000000000000000000000000000000000000000000000.1231200000000000000002013210000000'
... )
...
>>> d % 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
decimal.InvalidOperation: [<class 'decimal.DivisionImpossible'>]

J'ai plutôt saisi la partie intégrale et l'ai soustraite d'abord pour aider à simplifier le reste.

>>> d - d.to_integral()
Decimal('0.1231200000000000000002013210')

Un autre exemple utilisant modf

from math import modf
number = 1.0124584

# [0] decimal, [1] integer
result = modf(number)
print(result[0])
# output = 0124584
print(result[1])
# output = 1

Une solution utilise modulo et arrondi.

import math

num = math.fabs(float(5.55))
rem = num % 1

rnd_by =   len(str(num)) - len(str(int(num))) - 1

print(str(round(rem,rnd_by)))

Votre sortie sera de 0,55

Vous pouvez utiliser ceci:

number = 5.55
int(str(number).split('.')[1])

Une autre solution folle est (sans conversion en chaîne):

number = 123.456
temp = 1

while (number*temp)%10 != 0:
    temp = temp *10
    print temp
    print number

temp = temp /10
number = number*temp
number_final = number%temp
print number_final