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

Réponses:

28

Une approche simple pour vous:

number_dec = str(number-int(number))[1:]
lllluuukke
la source
31
Exercice pour le lecteur: faites en sorte que cela fonctionne pour des nombres supérieurs ou égaux à 10
intuitif le
11
number_dec = str(number-int(number)).split('.')[1]
Ryan Allen
28
Downvoter car il s'agit d'une approche inutilement compliquée. La réponse que j'ai recherchée était la réponse suivante 5.55 % 1, qui est également une réponse plus généralement utile - on peut utiliser l'approche de division modulo dans plusieurs langues, alors que la réponse ci-dessus est spécifique à Python.
Ragoût
3
REMARQUE: cette solution renvoie une chaîne comprenant le point ( .55), ce à quoi vous ne pouvez pas vous attendre en raison du titre des questions!
T. Christiansen
8
str(5.55 - int(5.55))[1:]renvoie .5499999999999998au lieu de celui .55mentionné dans la question.
Cristian Ciupitu
199
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.

secousse
la source
7
Quant à lui modf, il peut également visser la précision: math.modf(5.55)reviendra (0.5499999999999998, 5.0).
bereal
1
est-ce que quelqu'un sait quelle serait l'opération la plus rapide, cette méthode décrite ci-dessus, ou: float b = a - int (a)? Je soupçonne le plus tard, mais je voulais voir s'il y avait une confirmation
hokkuk
4
Sur un Raspberry Pi, cette méthode x%1était presque deux fois plus rapide que les méthodes x-int(x)et modf(x)[0](les délais étaient de 980ns, 1,39us et 1,47us en moyenne sur 1000000 exécutions). Ma valeur pour xétait toujours positive, donc je n'avais pas à m'inquiéter à ce sujet.
coderforlife
Le fonctionnement du module est certainement plus rapide. Il n'a pas à faire de recherche de nom. Alors que l'appel de la fonction int effectue une recherche sur les variables globales.
Enrico Borba
fantaisie pas seulement avoir un frac ()
mckenzm
155

Utilisez modf :

>>> import math
>>> frac, whole = math.modf(2.5)
>>> frac
0.5
>>> whole
2.0
Anthony V
la source
2
Bonne solution, mais la math.modf(2.53) = (0.5299999999999998, 2.0)réponse attendue est 0,53
Lord Loh.
4
@LordLoh. c'est à cause de l'arrondi en virgule flottante, et cela se produira avec n'importe quelle méthode.
Rena
@LordLoh. Essayez d'utiliser round (0.5299999999999998, 2) pour obtenir 0.53. Une autre façon consiste à utiliser Decimal from decimal package. docs.python.org/2/library/decimal.html
SirJ
57

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)
Jim Brissom
la source
33

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.

intuité
la source
Pour le bénéfice du questionnaire original: les flottants doivent être convertis en chaînes avant de pouvoir être convertis en décimales. Donc, si vous avez n = 5.55, n est un flottant, et vous devriez le faire Decimal(str(n)) % 1pour obtenir la partie fractionnaire. (Ce n'est pas nécessaire si vous avez un entier, mais cela ne fait pas de mal.)
kindall
2
@intuited: Cela n'a pas besoin d'être décimal, cela fonctionne aussi pour float: 10.0/3 % 1au moins sur mon système
aherok
2
Vous pouvez utiliser from_float au lieu d'utiliser une chaîne. d = Decimal.from_float (1.2)
Matthew Purdon
@intuited Comment obtient-on la partie décimale sous forme d'entier? J'ai essayé les méthodes to_integer () mais le type est toujours Decimal.
D1X
1
@MatthewPurdon - Si vous utilisez Decimal.from_float(1.2)(qui peut maintenant être écrit comme Decimal(1.2)), vous aurez des problèmes d'arrondi, que cette réponse essayait d'éviter.
John Y
7

Essayez Modulo:

5.55%1 = 0.54999999999999982
Juri Robl
la source
5

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
yosemite_k
la source
number = 5.55; "." in numberdonne TypeError: argument of type 'float' is not iterable. Et que feriez-vous si number = 1e-5?
Mark Dickinson
@mark la question est Comment obtenir les nombres après une virgule décimale? donc l'utilisateur s'attend à un flottement en notation décimale (pas en notation scientifique), j'ai également ajouté un bloc pour la notation scientifique
yosemite_k
Un nombre est un nombre; ce ne sont que des représentations d'un nombre qui pourrait être en notation scientifique. Donc "flotter en notation décimale" n'a pas beaucoup de sens ici; au moment où Python le voit, c'est juste un float; Python ne garde aucune connaissance du format dans lequel il a été initialement exprimé. Mon number = 1e-5exemple s'applique également à number = 0.00001: la strreprésentation du nombre est en notation scientifique. Vous aurez envie de traiter e+aussi bien que e-, en passant.
Mark Dickinson
4
import math
orig = 5.55
whole = math.floor(orig)    # whole = 5.0
frac = orig - whole         # frac = 0.55
Kevin Lacquement
la source
>>> frac 0.5499999999999998
macm
4
>>> n=5.55
>>> if "." in str(n):
...     print "."+str(n).split(".")[-1]
...
.55
ghostdog74
la source
2
Cela convient aux nombres de variétés de jardin, mais ne fonctionne pas aussi bien pour les nombres suffisamment grands (ou petits) pour nécessiter une notation scientifique.
kindall
2

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

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

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)
George Fisher
la source
qu'est-ce que cela fait pour 0,000005?
Aditya Patnaik
2

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)
Sony
la source
1

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

la source
5
Si vous allez import math, pourquoi ne pas simplement utiliser math.modf()?
ire_and_curses
@ire_and_curses: Je propose une solution alternative au problème.
1
floor fait la même chose que la conversion en un int et pourrait donc remplacer math.floor (t) par int (t)
QuantumKarl
@QuantumKarl Non, ils sont différents. math.floor(-1.1) == -2mais int(-1.1) == -1. Bien que pour cette question, l'utilisation intest plus correcte.
Lambda Fairy
1

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
jpp
la source
1

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.

Franc
la source
C'est bien car il renvoie une valeur non fractionnaire, mais se cassera sur les nombres négatifs
Meow
Malheureusement, cela ne fonctionne pas la plupart du temps. @Meow
Marquis of Lorne
1
import math

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

Cela a vraiment fonctionné

Ali
la source
que signifie l'opérateur //?
l --''''''--------- '' '' '' '' '' ''
0

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.

MH
la source
Une explication?
0

Vous pouvez essayer ceci:

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

Il reviendra 0.55.

Ashkan Mirzaee
la source
0
number=5.55
decimal=(number-int(number))
decimal_1=round(decimal,2)
print(decimal)
print(decimal_1)

sortie: 0,55

Sanchit Aluna
la source
0

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])
Suraj Rao
la source
0

Si vous utilisez des pandas:

df['decimals'] = df['original_number'].mod(1)
erickfis
la source
0

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?

Emma
la source
0

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')
Droogans
la source
0

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
camilom108
la source
0

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

Gideon Antwi
la source
0

Vous pouvez utiliser ceci:

number = 5.55
int(str(number).split('.')[1])
Mario Monroy
la source
-2

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
Romulus
la source