Wie bekomme ich Zahlen nach dem Komma?

Wie erhalte ich die Zahlen nach einem Dezimalpunkt?

Wenn 5.55ja, wie komme ich zum Beispiel .55?

Ein einfacher Ansatz für Sie:

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

5.55 % 1

Beachten Sie, dass dies bei Gleitkomma-Rundungsproblemen nicht hilfreich ist. Dh Sie können bekommen:

0.550000000001

Oder ansonsten ein wenig von den 0,55, die Sie erwarten.

Verwenden Sie modf :

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

Wie wäre es mit:

a = 1.3927278749291
b = a - int(a)

b
>> 0.39272787492910011

Oder mit numpy:

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

Mit dem decimalModul aus der Standardbibliothek können Sie die ursprüngliche Genauigkeit beibehalten und Gleitkomma-Rundungsprobleme vermeiden:

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

Wie Kindall Hinweise in den Kommentaren, werden Sie nativer konvertieren müssen floatzuerst s in Strings.

Versuchen Sie Modulo:

5.55%1 = 0.54999999999999982

Ähnlich wie bei der akzeptierten Antwort wäre ein noch einfacherer Ansatz mit Zeichenfolgen

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

Dies ist eine Lösung, die ich versucht habe:

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

Manchmal sind nachgestellte Nullen wichtig

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)

Verwenden Sie Boden und subtrahieren Sie das Ergebnis von der ursprünglichen Zahl:

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

Gleitkommazahlen werden nicht im Dezimalformat (base10) gespeichert. Lesen Sie die Python-Dokumentation dazu durch, um sich selbst davon zu überzeugen, warum. Daher ist es nicht ratsam, eine base10-Darstellung von einem Float zu erhalten.

Jetzt gibt es Tools, mit denen numerische Daten im Dezimalformat gespeichert werden können. Unten finden Sie ein Beispiel für die Verwendung der DecimalBibliothek.

from decimal import *

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

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

Beispiel:

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

Dies gibt Ihnen zwei Zahlen nach dem Dezimalpunkt, 55 aus diesem Beispiel. Wenn Sie eine Zahl benötigen, reduzieren Sie die obigen Berechnungen um 10 oder erhöhen sie, je nachdem, wie viele Zahlen Sie nach der Dezimalstelle haben möchten.

import math

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

Es hat definitiv funktioniert

Mit der einfachen Operator- Division '/' und der Floor-Division '//' können Sie leicht den Bruchteil eines bestimmten Schwimmers erhalten.

number = 5.55

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

print(result)

Wie wäre es mit:

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

round(b, length-2)

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

Da die Runde an die Länge der Dezimalzeichenfolge ('0,234') gesendet wird, können wir nur minus 2, um die '0' nicht zu zählen, und die gewünschte Anzahl von Dezimalstellen ermitteln. Dies sollte meistens funktionieren, es sei denn, Sie haben viele Dezimalstellen und der Rundungsfehler bei der Berechnung von b stört den zweiten Parameter der Runde.

Vielleicht möchten Sie dies versuchen:

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

Es wird zurückkehren 0.55.

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

Ausgabe: 0,55

Sehen Sie, was ich oft mache, um Zahlen nach dem Dezimalpunkt in Python 3 zu erhalten:

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

Wenn Sie Pandas verwenden:

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

Eine andere Möglichkeit wäre, das reModul mit re.findalloder zu verwenden 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))

Ausgabe

0.55
0.55
5

Wenn Sie den Ausdruck vereinfachen / ändern / untersuchen möchten, wurde dies im oberen rechten Bereich von regex101.com erläutert . Wenn Sie möchten , können Sie in diesem Link auch sehen , wie es mit einigen Beispieleingaben übereinstimmt.

Quelle

Wie werden zusätzliche schwebende Zahlen bei der Python-Subtraktion entfernt?

Ich habe festgestellt, dass sehr große Zahlen mit sehr großen Bruchteilen Probleme verursachen können, wenn Modulo 1 verwendet wird, um den Bruch zu erhalten.

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

Ich griff stattdessen nach dem integralen Teil und subtrahierte ihn zuerst, um den Rest zu vereinfachen.

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

Ein weiteres Beispiel mit 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

Eine Lösung ist Modulo und Rundung.

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

Ihre Ausgabe wird 0,55 sein

Sie können dies verwenden:

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

Eine andere verrückte Lösung ist (ohne in einen String zu konvertieren):

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