Bagaimana cara mendapatkan angka setelah koma desimal?

Jawaban:

28

Pendekatan yang mudah untuk Anda:

number_dec = str(number-int(number))[1:]
lllluuukke.dll
sumber
30
Latihan untuk pembaca: buatlah itu berfungsi untuk angka yang lebih besar dari atau sama dengan 10
Intuisi
11
number_dec = str(number-int(number)).split('.')[1]
Ryan Allen
28
Tidak suka karena ini adalah pendekatan rumit yang tidak perlu. Jawaban yang saya cari adalah jawaban berikutnya 5.55 % 1, yang juga merupakan jawaban yang lebih berguna secara umum - seseorang dapat menggunakan pendekatan pembagian modulo dalam berbagai bahasa, sedangkan jawaban di atas khusus untuk Python.
Rebus
3
CATATAN: Solusi ini mengembalikan string termasuk titik ( .55), yang mungkin tidak Anda harapkan karena judul pertanyaan!
T. Christiansen
8
str(5.55 - int(5.55))[1:]mengembalikan .5499999999999998alih-alih yang .55disebutkan dalam pertanyaan.
Cristian Ciupitu
199
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.

jer
sumber
7
Adapun modf, itu dapat mengacaukan presisi juga: math.modf(5.55)akan kembali (0.5499999999999998, 5.0).
bereal
1
apakah ada yang tahu mana yang akan menjadi operasi yang lebih cepat, metode ini dijelaskan di atas, atau: float b = a - int (a)? saya curiga nanti, tetapi ingin melihat apakah ada konfirmasi
hokkuk
4
Pada Raspberry Pi, metode x%1ini hampir dua kali lebih cepat dari x-int(x)dan modf(x)[0]metode (waktunya adalah 980ns, 1.39us, dan 1.47us rata-rata lebih dari 1000000 berjalan). Nilai saya xselalu positif jadi saya tidak perlu khawatir tentang itu.
coderforlife
Tentunya pengoperasian modul lebih cepat. Itu tidak harus melakukan pencarian nama apa pun. Sedangkan memanggil fungsi int melakukan pencarian pada variabel global.
Enrico Borba
suka tidak hanya memiliki frac ()
mckenzm
155

Gunakan modf :

>>> import math
>>> frac, whole = math.modf(2.5)
>>> frac
0.5
>>> whole
2.0
Anthony V
sumber
2
Solusi bagus, tapi, math.modf(2.53) = (0.5299999999999998, 2.0)jawaban yang diharapkan adalah 0,53
Lord Loh.
4
@LordLord. itu karena pembulatan floating point, dan akan terjadi dengan metode apapun.
Rena
@LordLord. Coba gunakan round (0.5299999999999998, 2) untuk mendapatkan 0.53 Cara lain adalah dengan menggunakan desimal dari paket desimal. docs.python.org/2/library/decimal.html
SirJ
57

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)
Jim Brissom
sumber
33

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

intuitif
sumber
Untuk kepentingan penanya asli: float harus dikonversi menjadi string sebelum dapat dikonversi ke Desimal. Jadi jika Anda punya n = 5.55, n adalah pelampung, dan Anda harus melakukannya Decimal(str(n)) % 1untuk mendapatkan bagian pecahan. (Ini tidak diperlukan jika Anda memiliki bilangan bulat, tetapi tidak ada salahnya.)
kindall
2
@intuited: Tidak perlu desimal, ini juga berfungsi untuk float: 10.0/3 % 1setidaknya di sistem saya
aherok
2
Anda dapat menggunakan from_float daripada menggunakan string. d = Decimal.from_float (1.2)
Matthew Purdon
@ Intuited Bagaimana cara mendapatkan bagian desimal sebagai integer? Saya telah mencoba metode to_integer () tetapi tipenya masih Desimal.
D1X
1
@MatthewPurdon - Jika Anda menggunakan Decimal.from_float(1.2)(yang sekarang dapat ditulis sebagai Decimal(1.2)), Anda akan mengalami masalah pembulatan, yang coba dihindari oleh jawaban ini.
John Y
7

Coba Modulo:

5.55%1 = 0.54999999999999982
Juri Robl
sumber
5

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
yosemite_k
sumber
number = 5.55; "." in numbermemberi TypeError: argument of type 'float' is not iterable. Dan apa yang akan Anda lakukan jika number = 1e-5?
Mark Dickinson
@ tandai pertanyaannya adalah Bagaimana cara mendapatkan angka setelah koma desimal? jadi pengguna mengharapkan float dalam notasi desimal (bukan notasi ilmiah), saya telah menambahkan blok untuk notasi ilmiah juga
yosemite_k
Angka adalah angka; itu hanya representasi dari angka yang mungkin dalam notasi ilmiah. Jadi "float dalam notasi desimal" tidak masuk akal di sini; pada saat Python melihatnya, itu hanya a float; Python tidak menyimpan pengetahuan apa pun tentang format aslinya. number = 1e-5Contoh saya berlaku sama baiknya untuk number = 0.00001: strrepresentasi bilangan dalam notasi ilmiah. Anda pasti ingin berurusan dengan e+sebaik-baiknya e-.
Mark Dickinson
4
import math
orig = 5.55
whole = math.floor(orig)    # whole = 5.0
frac = orig - whole         # frac = 0.55
Kevin Lacquement
sumber
>>> frac 0,5499999999999998
macm
4
>>> n=5.55
>>> if "." in str(n):
...     print "."+str(n).split(".")[-1]
...
.55
anjing hantu74
sumber
2
Ini tidak masalah untuk nomor varietas taman, tetapi tidak berfungsi dengan baik untuk nomor yang cukup besar (atau kecil) sehingga memerlukan notasi ilmiah.
kindall
2

Ini adalah solusi yang saya coba:

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

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)
George Fisher
sumber
apa fungsinya untuk 0,000005?
Aditya Patnaik
2

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)
Sony
sumber
1

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

sumber
5
Jika Anda mau import math, mengapa tidak menggunakan saja math.modf()?
ire_and_curses
@ire_and_curses: Saya memberikan solusi alternatif untuk masalah ini.
1
floor melakukan hal yang sama seperti casting ke int sehingga bisa menggantikan math.floor (t) dengan int (t)
QuantumKarl
@QuantumKarl Tidak, mereka berbeda. math.floor(-1.1) == -2tapi int(-1.1) == -1. Padahal untuk pertanyaan ini menggunakan intlebih tepat.
Lambda Fairy
1

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
jpp
sumber
1

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.

jujur
sumber
Ini bagus karena mengembalikan nilai non-pecahan, tetapi akan merusak angka negatif
Meong
Sayangnya itu tidak berhasil sebagian besar waktu. @ Meow
Marquis dari Lorne
1
import math

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

Ini pasti berhasil

Ali
sumber
apa maksud operator //?
l --''''''--------- '' '' '' '' '' ''
0

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.

MH
sumber
Ada penjelasan?
0

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.

Ashkan Mirzaee
sumber
0
number=5.55
decimal=(number-int(number))
decimal_1=round(decimal,2)
print(decimal)
print(decimal_1)

keluaran: 0,55

Sanchit Aluna
sumber
0

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])
Suraj Rao
sumber
0

Jika Anda menggunakan panda:

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

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?

Emma
sumber
0

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')
Droogans
sumber
0

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
camilom108
sumber
0

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

Gideon Antwi
sumber
0

Anda dapat menggunakan ini:

number = 5.55
int(str(number).split('.')[1])
Mario Monroy
sumber
-2

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