Bagaimana cara mendapatkan angka setelah koma desimal?

Bagaimana cara mendapatkan angka setelah koma desimal?

Misalnya, jika sudah 5.55, bagaimana cara mendapatkannya .55?

Pendekatan yang mudah untuk Anda:

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

5.55 % 1

Ingatlah bahwa ini tidak akan membantu Anda dengan masalah pembulatan floating point. Yaitu, Anda mungkin mendapatkan:

0.550000000001

Atau sebaliknya sedikit dari 0,55 yang Anda harapkan.

Gunakan modf :

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

Bagaimana dengan:

a = 1.3927278749291
b = a - int(a)

b
>> 0.39272787492910011

Atau, menggunakan numpy:

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

Dengan menggunakan decimalmodul dari pustaka standar, Anda dapat mempertahankan presisi asli dan menghindari masalah pembulatan floating point:

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

Sebagai catatan kindall di komentar, Anda harus mengonversi native ke string terlebih dahulu.float

Coba Modulo:

5.55%1 = 0.54999999999999982

mirip dengan jawaban yang diterima, pendekatan yang lebih mudah menggunakan string akan menjadi

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

Ini adalah solusi yang saya coba:

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

Terkadang tertinggal nol penting

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)

Hanya dengan menggunakan operator sederhana divisi '/' dan lantai divisi '//' Anda bisa dengan mudah mendapatkan bagian pecahan dari pelampung yang diberikan.

number = 5.55

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

print(result)

Gunakan floor dan kurangi hasilnya dari bilangan asli:

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

Angka float tidak disimpan dalam format desimal (base10). Bacalah dokumentasi python tentang ini untuk memuaskan diri Anda mengapa. Oleh karena itu, untuk mendapatkan representasi base10 dari float tidak disarankan.

Sekarang ada alat yang memungkinkan penyimpanan data numerik dalam format desimal. Di bawah ini adalah contoh menggunakan Decimalperpustakaan.

from decimal import *

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

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

Contoh:

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

Ini akan memberi Anda dua angka setelah koma, 55 dari contoh itu. Jika Anda membutuhkan satu angka, kurangi dengan 10 kalkulasi di atas atau tambah tergantung berapa banyak angka yang Anda inginkan setelah desimal.

import math

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

Ini pasti berhasil

Bagaimana dengan:

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

round(b, length-2)

Keluaran:
print(b)
0.23399999999999999
round(b, length-2)
0.234

Karena putaran dikirim ke panjang string desimal ('0,234'), kita hanya dapat minus 2 untuk tidak menghitung '0', dan mencari tahu jumlah titik desimal yang diinginkan. Ini seharusnya bekerja paling sering, kecuali Anda memiliki banyak tempat desimal dan kesalahan pembulatan saat menghitung b mengganggu parameter putaran kedua.

Anda mungkin ingin mencoba ini:

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

Ini akan kembali 0.55.

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

keluaran: 0,55

Lihat apa yang sering saya lakukan untuk mendapatkan angka setelah koma desimal di python 3:

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

Jika Anda menggunakan panda:

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

Pilihan lainnya adalah menggunakan remodul dengan re.findallatau 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))

Keluaran

0.55
0.55
5

Jika Anda ingin menyederhanakan / memodifikasi / menjelajahi ekspresi, itu telah dijelaskan di panel kanan atas regex101.com . Jika mau, Anda juga dapat melihat di tautan ini , bagaimana kecocokannya dengan beberapa masukan sampel.

Sumber

Bagaimana cara menghilangkan bilangan mengambang tambahan dalam pengurangan python?

Saya telah menemukan bahwa angka yang sangat besar dengan bagian pecahan yang sangat besar dapat menyebabkan masalah saat menggunakan modulo 1 untuk mendapatkan pecahan.

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

Saya malah mengambil bagian integral dan menguranginya terlebih dahulu untuk membantu menyederhanakan sisanya.

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

Contoh lain menggunakan 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

Solusinya menggunakan modulo dan pembulatan.

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

Output Anda akan menjadi 0,55

Anda dapat menggunakan ini:

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

Solusi gila lainnya adalah (tanpa mengubah dalam string):

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