소수점 이하 숫자를 얻는 방법?

소수점 뒤의 숫자는 어떻게 구합니까?

예를 들어, 내가있는 5.55경우 어떻게 얻을 수 .55있습니까?

당신을위한 쉬운 접근 :

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

5.55 % 1

이것은 부동 소수점 반올림 문제에 도움이되지 않습니다. 즉, 다음을 얻을 수 있습니다.

0.550000000001

아니면 당신이 기대하는 0.55에서 약간 떨어져 있습니다.

modf 사용 :

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

이건 어떤가요:

a = 1.3927278749291
b = a - int(a)

b
>> 0.39272787492910011

또는 numpy를 사용하여 :

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

decimal표준 라이브러리 의 모듈을 사용하면 원래 정밀도를 유지하고 부동 소수점 반올림 문제를 방지 할 수 있습니다.

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

주석의 모든 메모 처럼 먼저 native float를 문자열 로 변환해야합니다 .

Modulo 시도 :

5.55%1 = 0.54999999999999982

받아 들여지는 대답과 비슷하게 문자열을 사용하는 더 쉬운 접근 방식은

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

이것은 내가 시도한 해결책입니다.

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

때때로 후행 0이 중요합니다.

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)

floor를 사용하고 원래 숫자에서 결과를 뺍니다.

>> 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

부동 숫자는 10 진수 (base10) 형식으로 저장되지 않습니다. 파이썬 문서를 읽으십시오그 이유를 충족시키기 위해 이것에 를 보십시오. 따라서 float에서 base10 표현을 얻는 것은 바람직하지 않습니다.

이제 10 진수 형식으로 숫자 데이터를 저장할 수있는 도구가 있습니다. 아래는 Decimal라이브러리 를 사용한 예 입니다.

from decimal import *

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

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

예:

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

이것은 소수점 뒤에 두 개의 숫자를 제공합니다. 하나의 숫자가 필요한 경우 위의 계산을 10으로 줄이거 나 소수점 뒤에 원하는 숫자의 수에 따라 늘립니다.

import math

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

확실히 효과가 있었다

간단한 연산자 구분 '/' 및 바닥 구분 '//'을 사용 하면 주어진 float의 분수 부분을 쉽게 얻을 수 있습니다.

number = 5.55

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

print(result)

이건 어떤가요:

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를 계산할 때 반올림 오류가 반올림의 두 번째 매개 변수를 방해하지 않는 한 대부분의 경우 작동합니다.

이것을 시도해 볼 수 있습니다.

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

반환 0.55됩니다.

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

출력 : 0.55

파이썬 3에서 소수점 뒤의 숫자를 얻기 위해 자주하는 일을보십시오 :

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

pandas를 사용하는 경우 :

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

또 다른 옵션은 또는 다음 re과 함께 모듈 을 사용하는 것입니다 .re.findallre.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.com의 오른쪽 상단 패널에 설명되어 있습니다. 원하는 경우이 링크 에서 일부 샘플 입력과 어떻게 일치하는지 볼 수도 있습니다.

출처

파이썬 빼기에서 추가 부동 숫자를 제거하는 방법은 무엇입니까?

정말 큰 분수 부분을 가진 정말 큰 숫자는 분수를 얻기 위해 모듈로 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')

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

솔루션은 모듈로 및 반올림을 사용합니다.

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)))

출력은 0.55입니다.

이것을 사용할 수 있습니다 :

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

또 다른 미친 해결책은 (문자열로 변환하지 않고) 다음과 같습니다.

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