Làm thế nào để có được các số sau dấu thập phân?

Làm cách nào để lấy các số sau dấu thập phân?

Ví dụ, nếu tôi có 5.55, làm thế nào để tôi nhận được .55?

Một cách tiếp cận dễ dàng cho bạn:

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

5.55 % 1

Hãy nhớ rằng điều này sẽ không giúp bạn với các vấn đề làm tròn dấu phẩy động. Tức là bạn có thể nhận được:

0.550000000001

Hoặc nếu không thì giảm một chút so với 0,55 mà bạn đang mong đợi.

Sử dụng modf :

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

Thế còn:

a = 1.3927278749291
b = a - int(a)

b
>> 0.39272787492910011

Hoặc, sử dụng numpy:

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

Sử dụng decimalmô-đun từ thư viện chuẩn, bạn có thể giữ lại độ chính xác ban đầu và tránh các vấn đề làm tròn dấu phẩy động:

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

Như tất cả các ghi chú trong các nhận xét, trước tiên bạn sẽ phải chuyển đổi floatcác s gốc thành chuỗi.

Hãy thử Modulo:

5.55%1 = 0.54999999999999982

tương tự như câu trả lời được chấp nhận, cách tiếp cận thậm chí dễ dàng hơn bằng cách sử dụng chuỗi sẽ là

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

Đây là một giải pháp tôi đã thử:

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

Đôi khi các số không ở sau quan trọng

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)

Sử dụng giá trị sàn và trừ kết quả cho số ban đầu:

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

Số thực không được lưu trữ ở định dạng thập phân (cơ số 10). Hãy đọc qua tài liệu python về điều này để tự thỏa mãn tại sao. Do đó, không nên lấy biểu diễn base10 từ một float.

Bây giờ có các công cụ cho phép lưu trữ dữ liệu số ở định dạng thập phân. Dưới đây là một ví dụ sử dụng Decimalthư viện.

from decimal import *

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

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

Thí dụ:

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

Điều này sẽ cung cấp cho bạn hai số sau dấu thập phân, 55 từ ví dụ đó. Nếu bạn cần một số bạn giảm 10 phép tính trên hoặc tăng lên tùy thuộc vào số lượng số bạn muốn sau số thập phân.

import math

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

Nó chắc chắn đã hoạt động

Chỉ cần sử dụng phép chia toán tử đơn giản '/' và phép chia tầng '//', bạn có thể dễ dàng nhận được phần phân số của bất kỳ số float nào.

number = 5.55

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

print(result)

Thế còn:

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

round(b, length-2)

Đầu ra:
print(b)
0.23399999999999999
round(b, length-2)
0.234

Vì vòng được gửi đến một độ dài của chuỗi số thập phân ('0,234'), chúng ta chỉ có thể trừ 2 để không đếm '0' và tìm ra số điểm thập phân mong muốn. Điều này sẽ hoạt động hầu hết các lần, trừ khi bạn có nhiều chữ số thập phân và lỗi làm tròn khi tính toán b ảnh hưởng đến tham số thứ hai của vòng.

Bạn có thể muốn thử điều này:

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

Nó sẽ trở lại 0.55.

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

sản lượng: 0,55

Xem những gì tôi thường làm để lấy các số sau dấu thập phân trong python 3:

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

Nếu bạn đang sử dụng gấu trúc:

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

Một tùy chọn khác sẽ là sử dụng remô-đun với re.findallhoặc 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))

Đầu ra

0.55
0.55
5

Nếu bạn muốn đơn giản hóa / sửa đổi / khám phá biểu thức, nó sẽ được giải thích ở bảng trên cùng bên phải của regex101.com . Nếu muốn, bạn cũng có thể xem trong liên kết này , nó sẽ khớp như thế nào với một số đầu vào mẫu.

Nguồn

Làm thế nào để loại bỏ các số thực bổ sung trong phép trừ python?

Tôi nhận thấy rằng những con số thực sự lớn với các phần thực sự lớn có thể gây ra sự cố khi sử dụng modulo 1 để lấy phân số.

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

Thay vào đó, tôi lấy phần tích phân và trừ nó đi trước để giúp đơn giản hóa phần còn lại của nó.

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

Một ví dụ khác sử dụng 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

Một giải pháp là sử dụng modulo và làm tròn.

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

Đầu ra của bạn sẽ là 0,55

Bạn có thể sử dụng cái này:

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

Một giải pháp điên rồ khác là (không cần chuyển đổi trong một chuỗi):

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