Como obter números após o ponto decimal?

Respostas:

30

Uma abordagem fácil para você:

number_dec = str(number-int(number))[1:]
lllluuukke
fonte
30
Exercício para o leitor: faça-o funcionar para números maiores ou iguais a 10
intui
11
number_dec = str(number-int(number)).split('.')[1]
Ryan Allen
26
Voto negativo, porque esta é uma abordagem desnecessariamente complicada. A resposta que eu procurei foi a próxima resposta, 5.55 % 1que também é uma resposta mais geralmente útil - é possível usar a abordagem de divisão de módulos em vários idiomas, enquanto a resposta acima é específica para Python.
guisado
3
NOTA: Esta solução retorna uma string incluindo o ponto ( .55), que você não pode esperar devido ao título das perguntas!
T. Christiansen
8
str(5.55 - int(5.55))[1:]retorna em .5499999999999998vez do .55mencionado na pergunta.
Cristian Ciupitu
197
5.55 % 1

Lembre-se de que isso não ajudará em problemas de arredondamento de ponto flutuante. Ou seja, você pode obter:

0.550000000001

Ou então, um pouco de 0,55 que você está esperando.

jer
fonte
7
Quanto a modf, também pode estragar a precisão: math.modf(5.55)retornará (0.5499999999999998, 5.0).
bereal
1
alguém sabe qual seria a operação mais rápida, esse método descrito acima, ou: float b = a - int (a)? Eu suspeito que o mais tarde, mas queria ver se havia confirmação
hokkuk
4
Em um Raspberry Pi, esse método x%1era quase duas vezes mais rápido que os métodos x-int(x)e modf(x)[0](os tempos eram 980ns, 1,39us e 1,47us, em média, em 1000000 execuções). Meu valor xsempre foi positivo, então não precisei me preocupar com isso.
Coderforlife
Definitivamente, a operação do módulo é mais rápida. Ele não precisa fazer nenhuma pesquisa de nome. Enquanto a chamada da função int faz uma pesquisa nas variáveis ​​globais.
Enrico Borba
fantasia não apenas tendo um frac ()
mckenzm 09/03
154

Use modf :

>>> import math
>>> frac, whole = math.modf(2.5)
>>> frac
0.5
>>> whole
2.0
Anthony V
fonte
2
Boa solução, mas a math.modf(2.53) = (0.5299999999999998, 2.0)resposta esperada é 0,53
Lord Loh.
4
@LordLoh. isso é devido ao arredondamento do ponto flutuante e ocorrerá com qualquer método.
Rena
@LordLoh. Tente usar a ronda (0,5299999999999998, 2) para obter 0,53. Outra maneira é usar decimal no pacote decimal. docs.python.org/2/library/decimal.html
SirJ
57

A respeito:

a = 1.3927278749291
b = a - int(a)

b
>> 0.39272787492910011

Ou, usando numpy:

import numpy
a = 1.3927278749291
b = a - numpy.fix(a)
Jim Brissom
fonte
33

Usando o decimalmódulo da biblioteca padrão, você pode manter a precisão original e evitar problemas de arredondamento de ponto flutuante:

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

Como notas gentis nos comentários, você precisará primeiro converter s nativos em strings.float

intuído
fonte
Para o benefício do solicitante de pergunta original: os carros alegóricos devem ser convertidos em cadeias de caracteres antes que possam ser convertidos em decimais. Portanto, se você tiver n = 5.55, n é uma bóia e deve fazer Decimal(str(n)) % 1para obter a parte fracionária. (Isto não é necessário se você tiver um inteiro, mas não faz mal.)
Kindall
2
@intuited: Ele não precisa ser decimal, ele funciona também para float: 10.0/3 % 1pelo menos no meu sistema
aherok
2
Você pode usar from_float em vez de usar uma string. d = Decimal.from_float (1.2)
Matthew Purdon
@intuited Como se obtém a parte decimal como um número inteiro? Eu tentei métodos to_integer (), mas o tipo ainda é decimal.
D1X
1
@ MatthewPurdon - Se você usar Decimal.from_float(1.2)(que agora pode ser escrito como Decimal(1.2)), você terá problemas de arredondamento, os quais esta resposta estava tentando evitar.
John Y
7

Experimente o Módulo:

5.55%1 = 0.54999999999999982
Juri Robl
fonte
5

semelhante à resposta aceita, uma abordagem ainda mais fácil usando strings seria

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
fonte
number = 5.55; "." in numberTypeError: argument of type 'float' is not iterable. E o que você faria se number = 1e-5?
Mark Dickinson
@ marque a pergunta é: Como obtenho os números após um ponto decimal? assim que o usuário está esperando flutuante em notação decimal (notação não científica), eu adicionei um bloco de notação científica também
yosemite_k
Um número é um número; são apenas representações de um número que podem estar em notação científica. Portanto, "flutuar em notação decimal" não faz muito sentido aqui; no momento em que o Python o vê, é apenas um float; O Python não mantém nenhum conhecimento de qual formato foi originalmente expresso. Meu number = 1e-5exemplo se aplica igualmente bem a number = 0.00001: a strrepresentação do número está em notação científica. Você vai querer lidar com e+, bem como e-, a propósito.
Mark Dickinson
4
import math
orig = 5.55
whole = math.floor(orig)    # whole = 5.0
frac = orig - whole         # frac = 0.55
Kevin Lacquement
fonte
>>> frac 0.5499999999999998
macm
4
>>> n=5.55
>>> if "." in str(n):
...     print "."+str(n).split(".")[-1]
...
.55
ghostdog74
fonte
2
Isso é bom para números de variedades de jardins, mas não funciona tão bem para números grandes (ou pequenos) o suficiente para exigir notação científica.
Kindall
2

Esta é uma solução que eu tentei:

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

Às vezes, zeros à direita importam

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
fonte
o que isso faz para 0,000005?
Aditya Patnaik
1

Use floor e subtraia o resultado do número original:

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

fonte
5
Se você estiver indo import math, por que não usar math.modf()?
ire_and_curses
@ire_and_curses: estou fornecendo uma solução alternativa para o problema.
1
chão faz o mesmo que a projeção para um int assim poderia substituir Math.floor (t) com int (t)
QuantumKarl
@QuantumKarl Não, eles são diferentes. math.floor(-1.1) == -2mas int(-1.1) == -1. Embora para esta pergunta usando inté mais correto.
fada Lambda
1

Os números flutuantes não são armazenados no formato decimal (base10). Leia a documentação do python sobre isso para entender por que. Portanto, não é aconselhável obter uma representação base10 de um flutuador.

Agora, existem ferramentas que permitem o armazenamento de dados numéricos em formato decimal. Abaixo está um exemplo usando a Decimalbiblioteca.

from decimal import *

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

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

Exemplo:

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

Isso fornecerá dois números após o ponto decimal, 55 desse exemplo. Se você precisar de um número, reduz em 10 os cálculos acima ou aumenta dependendo de quantos números deseja após o decimal.

Frank
fonte
Isso é bom porque ele retornar um valor não-fracionada, mas vai quebrar em números negativos
Meow
Infelizmente, isso não funciona na maioria das vezes. @Meow
Marquis of Lorne
1
import math

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

Definitivamente funcionou

Todos
fonte
o que o operador // significa?
l
1

Usando simples divisão de operador '/' e divisão de piso '//', você pode facilmente obter a parte da fração de qualquer flutuador.

number = 5.55

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

print(result)
Sony
fonte
0

A respeito:

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

round(b, length-2)

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

Como a rodada é enviada para o comprimento da sequência de decimais ('0,234'), podemos apenas menos 2 para não contar o '0' e descobrir o número desejado de pontos decimais. Isso deve funcionar na maioria das vezes, a menos que você tenha muitas casas decimais e o erro de arredondamento ao calcular b interfere no segundo parâmetro da rodada.

MH
fonte
Alguma explicação?
0

Você pode tentar o seguinte:

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

Voltará 0.55.

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

saída: 0.55

Sanchit Aluna
fonte
0

Veja o que geralmente faço para obter números após o ponto decimal no python 3:

a=1.22
dec=str(a).split('.')
dec= int(dec[1])
Suraj Rao
fonte
0

Se você estiver usando pandas:

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

Outra opção seria usar o remódulo com re.findallou 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))

Resultado

0.55
0.55
5

Se você deseja simplificar / modificar / explorar a expressão, isso foi explicado no painel superior direito de regex101.com . Se desejar, também é possível assistir neste link , como ele corresponderia a algumas entradas de amostra.


Fonte

Como se livrar de números flutuantes adicionais na subtração python?

Emma
fonte
0

Descobri que números muito grandes com partes fracionárias muito grandes podem causar problemas ao usar o módulo 1 para obter a fração.

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

Peguei a parte integrante e subtraí-a primeiro para ajudar a simplificar o restante.

>>> d - d.to_integral()
Decimal('0.1231200000000000000002013210')
Droogans
fonte
0

Outro exemplo usando 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
fonte
0

Uma solução está usando módulo e arredondamento.

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

Sua saída será 0,55

Gideon Antwi
fonte
0

Você pode usar isto:

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

Outra solução louca é (sem converter em uma 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
fonte