จะรับตัวเลขหลังจุดทศนิยมได้อย่างไร?

ฉันจะรับตัวเลขหลังจุดทศนิยมได้อย่างไร

ตัวอย่างเช่นถ้าฉันมี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')

ในฐานะที่เป็นkindall บันทึกในความคิดเห็นที่คุณจะมีการแปลงพื้นเมือง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):]))

บางครั้งค่าศูนย์ต่อท้าย

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)

เพียงใช้การหารตัวดำเนินการอย่างง่าย'/'และการแบ่งพื้น '//'คุณก็สามารถรับส่วนเศษส่วนของการลอยที่กำหนดได้อย่างง่ายดาย

number = 5.55

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

print(result)

ใช้พื้นและลบผลลัพธ์ออกจากจำนวนเดิม:

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

ตัวเลขลอยจะไม่ถูกจัดเก็บในรูปแบบทศนิยม (base10) อ่านเอกสาร pythonเกี่ยวกับเรื่องนี้เพื่อตอบสนองตัวเองว่าทำไม ดังนั้นจึงไม่แนะนำให้รับการแสดงฐาน 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))

นี่คือตัวเลขสองตัวหลังจุดทศนิยม 55 จากตัวอย่างนั้น หากคุณต้องการตัวเลขหนึ่งให้คุณลดการคำนวณข้างต้นด้วย 10 หรือเพิ่มขึ้นอยู่กับจำนวนตัวเลขที่คุณต้องการหลังจากทศนิยม

import math

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

ได้ผลแน่นอน

สิ่งที่เกี่ยวกับ:

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

ดูสิ่งที่ฉันมักทำเพื่อให้ได้ตัวเลขหลังจุดทศนิยมใน python 3:

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

หากคุณกำลังใช้แพนด้า:

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

อีกทางเลือกหนึ่งคือการใช้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.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