How do I get the numbers after a decimal point?
For example, if I have 5.55
, how do i get .55
?
jpp
158k34 gold badges274 silver badges333 bronze badges
asked Oct 7, 2010 at 22:38
3
5.55 % 1
Keep in mind this won’t help you with floating point rounding problems. I.e., you may get:
0.550000000001
Or otherwise a little off the 0.55 you are expecting.
answered Oct 7, 2010 at 22:40
jerjer
20.1k5 gold badges45 silver badges69 bronze badges
12
Use modf:
>>> import math
>>> frac, whole = math.modf(2.5)
>>> frac
0.5
>>> whole
2.0
answered May 16, 2014 at 18:58
Anthony VAnthony V
2,1691 gold badge11 silver badges6 bronze badges
4
What about:
a = 1.3927278749291
b = a - int(a)
b
>> 0.39272787492910011
Or, using numpy:
import numpy
a = 1.3927278749291
b = a - numpy.fix(a)
answered Oct 7, 2010 at 22:40
Jim BrissomJim Brissom
31.6k3 gold badges38 silver badges33 bronze badges
0
Using the decimal
module from the standard library, you can retain the original precision and avoid floating point rounding issues:
>>> from decimal import Decimal
>>> Decimal('4.20') % 1
Decimal('0.20')
As kindall notes in the comments, you’ll have to convert native float
s to strings first.
answered Oct 7, 2010 at 22:46
intuitedintuited
23k7 gold badges66 silver badges88 bronze badges
5
An easy approach for you:
number_dec = str(number-int(number))[1:]
answered Mar 5, 2012 at 5:02
lllluuukkelllluuukke
1,2942 gold badges13 silver badges17 bronze badges
14
Try Modulo:
5.55%1 = 0.54999999999999982
answered Oct 7, 2010 at 22:40
Juri RoblJuri Robl
5,5542 gold badges29 silver badges46 bronze badges
To make it work with both positive and negative numbers:
try abs(x)%1
. For negative numbers, without with abs
, it will go wrong.
5.55 % 1
output 0.5499999999999998
-5.55 % 1
output 0.4500000000000002
answered Mar 12, 2021 at 18:19
import math
orig = 5.55
whole = math.floor(orig) # whole = 5.0
frac = orig - whole # frac = 0.55
answered Oct 7, 2010 at 22:42
Kevin LacquementKevin Lacquement
5,0613 gold badges25 silver badges30 bronze badges
1
similar to the accepted answer, even easier approach using strings would be
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
answered Jan 26, 2018 at 14:55
yosemite_kyosemite_k
3,2921 gold badge17 silver badges27 bronze badges
3
>>> n=5.55
>>> if "." in str(n):
... print "."+str(n).split(".")[-1]
...
.55
answered Oct 7, 2010 at 23:42
ghostdog74ghostdog74
325k56 gold badges257 silver badges342 bronze badges
1
Just using simple operator division ‘/’ and floor division ‘//’ you can easily get the fraction part of any given float.
number = 5.55
result = (number/1) - (number//1)
print(result)
answered Apr 10, 2020 at 1:38
SonySony
551 silver badge5 bronze badges
Sometimes trailing zeros matter
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)
answered Jul 20, 2018 at 0:20
George FisherGeorge Fisher
2,9862 gold badges16 silver badges15 bronze badges
1
Another example using 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
answered Mar 24, 2020 at 16:01
This is a solution I tried:
num = 45.7234
(whole, frac) = (int(num), int(str(num)[(len(str(int(num)))+1):]))
answered Jan 4, 2015 at 17:00
kuriankurian
1712 silver badges10 bronze badges
Float numbers are not stored in decimal (base10) format. Have a read through the python documentation on this to satisfy yourself why. Therefore, to get a base10 representation from a float is not advisable.
Now there are tools which allow storage of numeric data in decimal format. Below is an example using the Decimal
library.
from decimal import *
x = Decimal('0.341343214124443151466')
str(x)[-2:] == '66' # True
y = 0.341343214124443151466
str(y)[-2:] == '66' # False
answered Feb 11, 2018 at 12:49
jppjpp
158k34 gold badges274 silver badges333 bronze badges
Easier if the input is a string, we can use split()
decimal = input("Input decimal number: ") #123.456
# split 123.456 by dot = ['123', '456']
after_coma = decimal.split('.')[1]
# because only index 1 is taken then '456'
print(after_coma) # '456'
if you want to make a number type
print(int(after_coma)) # 456
answered Nov 24, 2020 at 4:21
Use floor and subtract the result from the original number:
>> 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
answered Oct 7, 2010 at 22:42
4
Example:
import math
x = 5.55
print((math.floor(x*100)%100))
This is will give you two numbers after the decimal point, 55 from that example. If you need one number you reduce by 10 the above calculations or increase depending on how many numbers you want after the decimal.
ilim
4,4477 gold badges26 silver badges46 bronze badges
answered Sep 30, 2017 at 7:03
FrankFrank
193 bronze badges
2
import math
x = 1245342664.6
print( (math.floor(x*1000)%1000) //100 )
It definitely worked
Blaztix
1,1951 gold badge18 silver badges28 bronze badges
answered Feb 24, 2019 at 0:13
1
Another option would be to use the re
module with re.findall
or 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))
Output
0.55
0.55
5
If you wish to simplify/modify/explore the expression, it’s been explained on the top right panel of regex101.com. If you’d like, you can also watch in this link, how it would match against some sample inputs.
Source
How to get rid of additional floating numbers in python subtraction?
answered Nov 4, 2019 at 5:16
EmmaEmma
27.3k11 gold badges43 silver badges69 bronze badges
You can use this:
number = 5.55
int(str(number).split('.')[1])
answered Jul 24, 2020 at 3:43
2
This is only if you want toget the first decimal
print(int(float(input()) * 10) % 10)
Or you can try this
num = float(input())
b = num - int(num)
c = b * 10
print(int(c))
answered Sep 23, 2020 at 7:16
Using math module
speed of this has to be tested
from math import floor
def get_decimal(number):
'''returns number - floor of number'''
return number-floor(number)
Example:
n = 765.126357123
get_decimal(n)
0.12635712300004798
answered Nov 10, 2020 at 7:05
1
def fractional_part(numerator, denominator):
# Operate with numerator and denominator to
# keep just the fractional part of the quotient
if denominator == 0:
return 0
else:
return (numerator/ denominator)-(numerator // denominator)
print(fractional_part(5, 5)) # Should be 0
print(fractional_part(5, 4)) # Should be 0.25
print(fractional_part(5, 3)) # Should be 0.66...
print(fractional_part(5, 2)) # Should be 0.5
print(fractional_part(5, 0)) # Should be 0
print(fractional_part(0, 5)) # Should be 0
answered Nov 13, 2020 at 15:11
a = 12.587
b = float('0.' + str(a).split('.')[-1])
S.B
12.5k9 gold badges21 silver badges45 bronze badges
answered Jun 9, 2022 at 22:48
EwinEwin
111 silver badge2 bronze badges
1
What about:
a = 1.234
b = a - int(a)
length = len(str(a))
round(b, length-2)
Output:
print(b)
0.23399999999999999
round(b, length-2)
0.234
Since the round is sent to a the length of the string of decimals (‘0.234’), we can just minus 2 to not count the ‘0.’, and figure out the desired number of decimal points. This should work most times, unless you have lots of decimal places and the rounding error when calculating b interferes with the second parameter of round.
answered Apr 23, 2017 at 14:58
M HM H
1482 silver badges7 bronze badges
1
You may want to try this:
your_num = 5.55
n = len(str(int(your_num)))
float('0' + str(your_num)[n:])
It will return 0.55
.
answered Jun 22, 2019 at 0:50
number=5.55
decimal=(number-int(number))
decimal_1=round(decimal,2)
print(decimal)
print(decimal_1)
output: 0.55
answered Jul 12, 2019 at 18:32
Sanchit AlunaSanchit Aluna
4452 gold badges6 silver badges20 bronze badges
See what I often do to obtain numbers after the decimal point in python
3:
a=1.22
dec=str(a).split('.')
dec= int(dec[1])
Suraj Rao
29.3k11 gold badges94 silver badges103 bronze badges
answered Oct 8, 2019 at 7:15
If you are using pandas:
df['decimals'] = df['original_number'].mod(1)
answered Oct 23, 2019 at 19:58
erickfiserickfis
1,00412 silver badges19 bronze badges
Условие: Если задано положительное вещественное число, выведите его первую цифру справа от десятичной точки.
Решение:
y = float(input())
print(int(y * 10) % 10)
Пояснение:
- Вводим вещественное число (т.е. имеющее дробную часть)
- Выводим командой print(): вещественное число, умноженное на 10, которое мы преобразовываем сначала в целое число, а после находим с помощью деления на остаток последнюю цифру, которая и будет являться первой после точки (запятой).
@jfs верно заметил, что число типа float может принимать разные формы: оно может быть такого вида: 1e-5
. И если сложить
0.1 + 0.2
Результат будет не совсем таким, который можно предсказать.
0.30000000000000004
А тут 0.1
после единицы вообще сколько угодно нолей может быть.
В любом случае, вам без преобразования числа в строку никак не найти количество знаков после запятой.
Поэтому я предлагаю следующий код, чтобы не повторяться с предыдущими ответами:
number = 123.123123
s = str(number)
print(abs(s.find('.') - len(s)) - 1)
Преобразовываем в функцию:
def get_count(number):
s = str(number)
if '.' in s:
return abs(s.find('.') - len(s)) - 1
else:
return 0
Как я могу получить числа после десятичной точки?
Например, если у меня есть 5.55
, как мне получить .55
?
23 ответа
Лучший ответ
Простой подход для вас:
number_dec = str(number-int(number))[1:]
24
lllluuukke
5 Мар 2012 в 05:02
Примере:
import math
x = 5.55
print((math.floor(x*100)%100))
Это даст вам два числа после десятичной точки, 55 из этого примера. Если вам нужно одно число, вы уменьшаете на 10 вышеприведенные вычисления или увеличиваете в зависимости от того, сколько чисел вы хотите после десятичной.
1
ilim
16 Апр 2018 в 13:57
Другой вариант — использовать модуль re
с re.findall
или 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))
Выход
0.55
0.55
5
Если вы хотите упростить / изменить / изучить выражение, это объясняется в верхней правой панели regex101. ком. Если хотите, вы можете также посмотреть в эту ссылку, как она будет соответствовать против некоторых входных данных образца.
Источник
Как избавиться от дополнительных плавающих номеров при вычитании питона?
0
Emma
4 Ноя 2019 в 05:16
Что о:
a = 1.3927278749291
b = a - int(a)
b
>> 0.39272787492910011
Или, используя numpy:
import numpy
a = 1.3927278749291
b = a - numpy.fix(a)
52
Jim Brissom
7 Окт 2010 в 22:40
Используйте modf:
>>> import math
>>> frac, whole = math.modf(2.5)
>>> frac
0.5
>>> whole
2.0
149
Anthony V
16 Май 2014 в 18:58
Аналогично принятому ответу, более простой подход с использованием строк будет
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
4
yosemite_k
22 Окт 2019 в 07:58
Что о:
a = 1.234
b = a - int(a)
length = len(str(a))
round(b, length-2)
Выход:
print(b)
0.23399999999999999
round(b, length-2)
0.234
Поскольку раунд отправляется на длину строки десятичных дробей («0,234»), мы можем просто минус 2, чтобы не считать «0», и вычислить желаемое количество десятичных точек. Это должно работать в большинстве случаев, если у вас нет много десятичных разрядов и ошибка округления при вычислении b мешает второму параметру раунда.
0
M H
24 Апр 2017 в 04:07
Используя decimal
из стандартной библиотеки, вы можете сохранить исходную точность и избежать проблем с округлением с плавающей запятой:
>>> from decimal import Decimal
>>> Decimal('4.20') % 1
Decimal('0.20')
kindall notes в комментариях, вам нужно сначала преобразовать нативные float
в строки.
31
Community
23 Май 2017 в 11:54
Иногда конечные нули имеют значение
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)
2
George Fisher
20 Июл 2018 в 00:20
5.55 % 1
Имейте в виду, что это не поможет вам с проблемами округления с плавающей запятой. Т.е. вы можете получить:
0.550000000001
Или иначе немного от 0,55, что вы ожидаете.
176
jer
7 Окт 2010 в 22:40
Я обнаружил, что действительно большие числа с действительно большими дробными частями могут вызвать проблемы при использовании модуля 1 для получения дроби.
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'>]
Вместо этого я взял неотъемлемую часть и сначала вычел ее, чтобы упростить остальную часть.
>>> d - d.to_integral()
Decimal('0.1231200000000000000002013210')
0
Droogans
30 Янв 2020 в 14:15
Посмотрите, что я часто делаю, чтобы получить числа после десятичной точки в Python 3:
a=1.22
dec=str(a).split('.')
dec= int(dec[1])
0
Suraj Rao
8 Окт 2019 в 07:29
Числа с плавающей запятой не сохраняются в десятичном (base10) формате. Прочтите документацию по питону, чтобы понять, почему. Поэтому получать представление base10 из числа с плавающей точкой не рекомендуется.
Теперь есть инструменты, которые позволяют хранить числовые данные в десятичном формате. Ниже приведен пример использования библиотеки Decimal
.
from decimal import *
x = Decimal('0.341343214124443151466')
str(x)[-2:] == '66' # True
y = 0.341343214124443151466
str(y)[-2:] == '66' # False
1
jpp
11 Фев 2018 в 12:49
Используйте пол и вычтите результат из исходного числа:
>> 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
1
thyrglethyrgle
7 Окт 2010 в 22:42
Вы можете попробовать это:
your_num = 5.55
n = len(str(int(your_num)))
float('0' + str(your_num)[n:])
Он вернет 0.55
.
0
Ashkan Mirzaee
22 Июн 2019 в 00:50
Другое безумное решение (без преобразования в строку):
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
-2
Romulus
27 Ноя 2013 в 07:49
import math
x = 1245342664.6
print( (math.floor(x*1000)%1000) //100 )
Это определенно сработало
1
Blaztix
24 Фев 2019 в 01:21
number=5.55
decimal=(number-int(number))
decimal_1=round(decimal,2)
print(decimal)
print(decimal_1)
Выход: 0,55
0
Sanchit Aluna
12 Июл 2019 в 18:32
Это решение, которое я попробовал:
num = 45.7234
(whole, frac) = (int(num), int(str(num)[(len(str(int(num)))+1):]))
1
kurian
4 Янв 2015 в 17:06
Если вы используете панды:
df['decimals'] = df['original_number'].mod(1)
0
erickfis
23 Окт 2019 в 19:58
Попробуйте по модулю:
5.55%1 = 0.54999999999999982
6
Juri Robl
7 Окт 2010 в 22:40
import math
orig = 5.55
whole = math.floor(orig) # whole = 5.0
frac = orig - whole # frac = 0.55
4
Kevin Lacquement
7 Окт 2010 в 22:42
>>> n=5.55
>>> if "." in str(n):
... print "."+str(n).split(".")[-1]
...
.55
4
ghostdog74
7 Окт 2010 в 23:42
С практической точки зрения удобнее задать вид форматирования (например 4 знака после запятой) и любое значение float при выводе на печать форматировать.
А прикинуть, как бы число цифр после десятичной точки считал человек, по какому алгоритму ?
Флоат это число с точкой. Значит, можно перевести в строку str, разбить по точке split и взять из результирующего списка длину второй (правой) части.
len ( str('1.12345').split('.')[1] )
Число цифр — штука коварная. Вот беру я Питон и вбиваю:
>>> 0.1 + 0.2
0.30000000000000004
Сколько цифр должен вывести код?