පාවෙන දශම ලක්ෂ දෙකකට සීමා කිරීම

මට 13.95 ටa රවුම් වීමට අවශ්‍යයි .

>>> a
13.949999999999999
>>> round(a, 2)
13.949999999999999

මෙම roundකාර්යය මම බලාපොරොත්තු මාර්ගය වැඩ කරන්නේ නැහැ.

සියලු සංඛ්‍යා හරියටම නිරූපණය කළ නොහැකි පාවෙන ලක්ෂ්‍ය සංඛ්‍යා සමඟ ඔබ පැරණි ගැටලුවට මුහුණ දී සිටී. විධාන රේඛාව ඔබට මතකයෙන් සම්පූර්ණ පාවෙන ලක්ෂ්‍ය ආකෘතිය පෙන්වයි.

පාවෙන ලක්ෂ්‍ය නිරූපණය සමඟ, ඔබේ වටකුරු අනුවාදය එකම අංකයකි. පරිගණක ද්විමය බැවින් ඒවා පාවෙන ලක්ෂ්‍ය සංඛ්‍යා පූර්ණ සංඛ්‍යාවක් ලෙස ගබඩා කර එය දෙකක බලයකින් බෙදයි. එබැවින් 13.95 125650429603636838 / (2 ** 53) ට සමාන ආකාරයකින් නිරූපණය කෙරේ.

ද්විත්ව නිරවද්‍යතා සංඛ්‍යා වල බිටු 53 ක් (ඉලක්කම් 16) නිරවද්‍යතාවයක් ඇති අතර සාමාන්‍ය පාවෙන කොටස්වල බිටු 24 ක් (ඉලක්කම් 8) නිරවද්‍යතාවයක් ඇත. මෙම පිඹුරා පාවෙමින් අවස්ථාවක වර්ගය ද්විත්ව නිරවද්යතාවයකින් භාවිතා වටිනාකම් ගබඩා කිරීම සඳහා.

උදාහරණයක් වශයෙන්,

>>> 125650429603636838/(2**53)
13.949999999999999

>>> 234042163/(2**24)
13.949999988079071

>>> a = 13.946
>>> print(a)
13.946
>>> print("%.2f" % a)
13.95
>>> round(a,2)
13.949999999999999
>>> print("%.2f" % round(a, 2))
13.95
>>> print("{:.2f}".format(a))
13.95
>>> print("{:.2f}".format(round(a, 2)))
13.95
>>> print("{:.15f}".format(round(a, 2)))
13.949999999999999

ඔබ සිටින්නේ දශම ස්ථාන දෙකකට පසුව නම් (උදාහරණයක් ලෙස මුදල් වටිනාකමක් පෙන්වීමට), එවිට ඔබට වඩා හොඳ තේරීම් කිහිපයක් තිබේ:

1. ඩොලර් නොව, ශතවල නිඛිල සහ ගබඩා අගයන් භාවිතා කර ඩොලර් බවට පරිවර්තනය කිරීම සඳහා 100 න් බෙදන්න.
2. නැතහොත් දශම වැනි ස්ථාවර ලක්ෂ්‍ය අංකයක් භාවිතා කරන්න .

නව ආකෘති පිරිවිතර ඇත, සංගීත ආකෘති පිරිවිතර මිනි-භාෂාව :

ඔබට මෙය කළ හැක්කේ:

"{:.2f}".format(13.949999999999999)

සටහන 1: ඉහත දැක්වෙන්නේ නූල් ය. පාවෙන ලෙස ලබා ගැනීම සඳහා, සරලව ඔතා float(...):

float("{:.2f}".format(13.949999999999999))

සටහන 2: සමඟ float()එතීමෙන් කිසිවක් වෙනස් නොවේ:

>>> x = 13.949999999999999999
>>> x
13.95
>>> g = float("{:.2f}".format(x))
>>> g
13.95
>>> x == g
True
>>> h = round(x, 2)
>>> h
13.95
>>> x == h
True

ගොඩනගනු round()ලැබුවේ පයිතන් 2.7 හෝ ඊට පසුවය.

උදාහරණයක්:

>>> round(14.22222223, 2)
14.22

පරීක්ෂා කරන්න ලේඛගතකිරීම .

සරලම ප්‍රවේශය වන්නේ format()ශ්‍රිතය භාවිතා කිරීමයි .

උදාහරණයක් වශයෙන්:

a = 13.949999999999999
format(a, '.2f')

13.95

මෙය දශම ලක්ෂ්‍ය දෙකකට වටකුරු නූලක් ලෙස පාවෙන අංකයක් නිපදවයි.

භාවිත

print"{:.2f}".format(a)

වෙනුවට

print"{0:.2f}".format(a)

බහු විචල්‍යයන් ප්‍රතිදානය කිරීමට උත්සාහ කිරීමේදී දෙවැන්න ප්‍රතිදාන දෝෂ වලට තුඩු දිය හැකි බැවිනි (අදහස් බලන්න).

බොහෝ සංඛ්‍යා පාවෙන ආකාරයෙන් නිරූපණය කළ නොහැක. ඔබේ ගණිතමය සූත්‍රය හෝ ඇල්ගොරිතම අවශ්‍ය වන නිසා ඔබට අංකය වට කිරීමට අවශ්‍ය නම්, ඔබට වටය භාවිතා කිරීමට අවශ්‍යය. ඔබට දර්ශනය නිශ්චිත නිරවද්‍යතාවයකට සීමා කිරීමට අවශ්‍ය නම්, වටය පවා භාවිතා නොකර එය එම නූල ලෙස සංයුති කරන්න. (ඔබට එය විකල්ප රවුම් ක්‍රමයක් සමඟ ප්‍රදර්ශනය කිරීමට අවශ්‍ය නම්, සහ ටොන් ගණනක් තිබේ නම්, එවිට ඔබට ප්‍රවේශයන් දෙක මිශ්‍ර කළ යුතුය.)

>>> "%.2f" % 3.14159
'3.14'
>>> "%.2f" % 13.9499999
'13.95'

අවසාන වශයෙන්, සමහර විට වඩාත්ම වැදගත් දෙය නම්, ඔබට නිශ්චිත ගණිතයක් අවශ්‍ය නම් ඔබට පාවෙන කිසිවක් අවශ්‍ය නොවේ. සුපුරුදු උදාහරණය වන්නේ මුදල් සමඟ ගනුදෙනු කිරීම සහ 'ශත' පූර්ණ සංඛ්‍යාවක් ලෙස ගබඩා කිරීමයි.

පහත කේතය උත්සාහ කරන්න:

>>> a = 0.99334
>>> a = int((a * 100) + 0.5) / 100.0 # Adding 0.5 rounds it up
>>> print a
0.99

TLDR;)

ආදාන / ප්‍රතිදානයේ වටකුරු ගැටළුව පයිතන් 2.7.0 සහ 3.1 මගින් නිශ්චිතවම විසඳා ඇත .

නිවැරදිව වටකුරු අංකයක් ආපසු හැරවිය හැකි ලෙස පෙරළා හැරවිය හැකිය:
str -> float() -> repr() -> float() ...නැතහොත් Decimal -> float -> str -> Decimal
තවදුරටත් ගබඩා කිරීම සඳහා දශම වර්ගයක් අවශ්‍ය නොවේ.

(එතකොට, එය රාශිභූත පසුගිය බීටු දෝෂ ඉවත් කිරීම සඳහා වටකුරු සංඛ්යා ෙහෝ අඩු කිරීෙමන් ප්රතිඵලයක් රවුම් අවශ්ය විය හැක. නිශ්චිතවූ දශම අංක ගණිතමය තවමත් ප්රයෝජනවත් විය හැකි නමුත්, විසින් string බවට පරිවර්තනය str()(වලංගු ඉලක්කම් 12 දක්වා යයි වරදවා වටහා සමග සිටින බව ) සාමාන්‍යයෙන් ප්‍රමාණවත් වන්නේ නිරවද්‍ය නිරවද්‍යතාවයක් හෝ අනුක්‍රමික ගණිතමය මෙහෙයුම් සංඛ්‍යාවක් අවශ්‍ය නොවේ නම් පමණි.)

අසීමිත පරීක්ෂණය :

import random
from decimal import Decimal
for x in iter(random.random, None):           # Verify FOREVER that rounding is fixed :-)
    assert float(repr(x)) == x                # Reversible repr() conversion.
    assert float(Decimal(repr(x))) == x
    assert len(repr(round(x, 10))) <= 12      # Smart decimal places in repr() after round.
    if x >= 0.1:                              # Implicit rounding to 12 significant digits
        assert str(x) == repr(round(x, 12))   # by str() is good enough for small errors.
        y = 1000 * x                             # Decimal type is excessive for shopping
        assert str(y) == repr(round(y, 12 - 3))  # in a supermaket with Python 2.7+ :-)

ප්‍රලේඛනය

නිකුතු සටහන් බලන්න පයිතන් 2.7 - වෙනත් භාෂා වෙනස්කම් හතරවන ඡේදය කරයි:

පාවෙන ලක්ෂ්‍ය අංක සහ නූල් අතර පරිවර්තනය දැන් බොහෝ වේදිකාවල නිවැරදිව වට කර ඇත. මෙම පරිවර්තනයන් විවිධ ස්ථානවල සිදු වේ: str () පාවෙන සහ සංකීර්ණ සංඛ්‍යා මත; පාවෙන සහ සංකීර්ණ ඉදිකිරීම්කරුවන්; සංඛ්‍යා හැඩතල ගැන්වීම; භාවිතා කරමින් පාවෙන සහ සංකීර්ණ සංඛ්‍යා අනුක්‍රමිකකරණය සහ අක්‍රීය කිරීමmarshal, pickleසහ jsonමොඩියුල සහ අක්‍රීය කිරීම; පයිතන් කේතයේ පාවෙන සහ මන inary කල්පිත වචනාර්ථ විග්‍රහ කිරීම; සහ දශම සිට පාවෙන පරිවර්තනය.

මේ හා සම්බන්ධව, පාවෙන ලක්ෂ්‍ය අංක x හි repr () දැන් x වෙත ආපසු යාමට සහතික වන කෙටිම දශම නූල් මත පදනම්ව ප්‍රති result ලයක් ලබා දෙයි. ප්‍රති round ලයක් ලබා දෙයි. මීට පෙර එය x සිට 17 දශම ඉලක්කම් දක්වා වූ නූලක් ලබා දුන්නේය.

අදාළ ගැටළුව

වැඩි විස්තර:float පයිතන් 2.7 ට පෙර ආකෘතිකරණය ධාරාවට සමාන විය numpy.float64. සෑම වර්ගයක්ම වැදගත් වන පරිදි මෙම වර්ග දෙකම එකම 64 බිට් ආකෘතිකරණය කර ඇත; අනුක්‍රමය හිඩැස් නැති අතර පරිවර්තනය ආපසු හැරවිය හැකිය. සරලවම: ඔබට සමහර විට numpy.float64 අංකයක් තිබේ නම්, එය සංඛ්‍යාත්මක සකසනයන් සඳහා නොව මිනිසුන් සඳහා ආකෘතිකරණය කිරීම සඳහා සාමාන්‍ය පාවෙන බවට පරිවර්තනය කරන්න, එසේ නොමැතිනම් පයිතන් 2.7+ සමඟ තවත් කිසිවක් අවශ්‍ය නොවේ. බිට් 52 මැන්ටිස්සා සමඟ අයිඊඊඊ 754 ද්විත්ව නිරවද්‍යතාව . විශාල වෙනසක් වන්නේ np.float64.__repr__අතිරික්ත දශම සංඛ්‍යාවක් සමඟ නිතර සංයුති කර ඇති අතර එමඟින් කිසිදු බිට් එකක් නැති නොවේ. නමුත් වලංගු IEEE 754 අංකයක් 13.949999999999999 සහ 13.950000000000001 අතර නොමැත. repr(float(number_as_string))ප්‍රති result ලය යහපත් නොවන අතර පරිවර්තනය අංකී සමඟ ආපසු හැරවිය නොහැක. අනිත් අතට:float.__repr__

ඔබට ප්‍රතිදාන ආකෘතිය වෙනස් කළ හැකිය:

>>> a = 13.95
>>> a
13.949999999999999
>>> print "%.2f" % a
13.95

පයිතන් <3 (උදා. 2.6 හෝ 2.7) සමඟ, එසේ කිරීමට ක්‍රම දෙකක් තිබේ.

# Option one 
older_method_string = "%.9f" % numvar

# Option two (note ':' before the '.9f')
newer_method_string = "{:.9f}".format(numvar)

3 ට වැඩි පයිතන් අනුවාද සඳහා (උදා: 3.2 හෝ 3.3), දෙවන විකල්පය වඩාත් සුදුසු බව සලකන්න .

දෙවන විකල්පය පිළිබඳ වැඩි විස්තර සඳහා, පයිතන් ප්‍රලේඛනයෙන් සංගීත හැඩතල ගැන්වීම පිළිබඳ මෙම සබැඳිය යෝජනා කරමි .

පළමු විකල්පය පිළිබඳ වැඩි විස්තර සඳහා, මෙම සබැඳිය ප්‍රමාණවත් වන අතර විවිධ ධජ පිළිබඳ තොරතුරු ඇත .

යොමුව: පාවෙන ලක්ෂ්‍ය අංකය නිශ්චිත නිරවද්‍යතාවකට පරිවර්තනය කරන්න, ඉන්පසු නූල් වලට පිටපත් කරන්න

මෙහි කිසිවෙකු තවමත් එය සඳහන් කර ඇති බවක් නොපෙනේ, එබැවින් පයිතන් 3.6 හි f-string / template-string ආකෘතියෙන් උදාහරණයක් දෙන්නම්, එය ලස්සනට පිළිවෙලට ඇතැයි මම සිතමි:

>>> f'{a:.2f}'

එය දිගු උදාහරණ සමඟ හොඳින් ක්‍රියා කරයි, ක්‍රියාකරුවන් සමඟ සහ පාරෙන් අවශ්‍ය නොවේ:

>>> print(f'Completed in {time.time() - start:.2f}s')

පයිතන්හි දශම ස්ථාන 2 ක් දක්වා අගය වට කිරීම සඳහා ඔබට ආකෘති ක්‍රියාකරු භාවිතා කළ හැකිය :

print(format(14.4499923, '.2f')) // output is 14.45

පයිතන් 2.7 හි:

a = 13.949999999999999
output = float("%0.2f"%a)
print output

පයිතන් නිබන්ධනයේ පාවෙන ලක්ෂ්‍ය අංක ගණිතය: ගැටළු සහ සීමාවන් යන උපග්‍රන්ථයක් ඇත. එය කියවන්න. එය සිදුවන්නේ කුමක්ද සහ පයිතන් උපරිමයෙන් කරන්නේ ඇයිද යන්න පැහැදිලි කරයි. එය ඔබට ගැලපෙන උදාහරණයක් පවා ඇත. මට ටිකක් උපුටා දැක්වීමට ඉඩ දෙන්න:

>>> 0.1
0.10000000000000001

ඔබ round() අපේක්ෂා කරන තනි අංකයට එය නැවත කැපීමට ශ්‍රිතය භාවිතා කිරීමට ඔබ පෙළඹෙනු ඇත . නමුත් එයින් කිසිදු වෙනසක් නැත:

>>> round(0.1, 1)
0.10000000000000001

ගැටළුව වන්නේ ගබඩා කර ඇති ද්විමය පාවෙන ලක්ෂ්‍ය අගය “0.1” දැනටමත් කළ හැකි හොඳම ද්විමය ආසන්න වීමයි 1/10, එබැවින් එය නැවත වට කිරීමට උත්සාහ කිරීමෙන් එය වඩා හොඳ කළ නොහැක: එය දැනටමත් ලැබෙන තරමට හොඳයි.

තවත් ප්‍රතිවිපාකයක් නම් , 0.1 හරියටම නොවන බැවින් 1/10, අගයන් දහයක් සාරාංශ කිරීමෙන් හරියටම ප්‍රති 0.1yield ල නොලැබේ 1.0:

>>> sum = 0.0
>>> for i in range(10):
...     sum += 0.1
...
>>> sum
0.99999999999999989

ඔබේ ගැටළු වලට එක් විකල්පයක් සහ විසඳුමක් වනුයේ decimalමොඩියුලය භාවිතා කිරීමයි .

Att මැට් පෙන්වා දුන් පරිදි, පයිතන් 3.6 මඟින් එෆ්-නූල් සපයන අතර ඔවුන්ට කැදැලි පරාමිතීන් ද භාවිතා කළ හැකිය :

value = 2.34558
precision = 2
width = 4

print(f'result: {value:{width}.{precision}f}')

එය දර්ශනය වේ result: 2.35

එය ඔබ එය කිරීමට කී දේ හරියටම කරන අතර නිවැරදිව ක්‍රියා කරයි. පාවෙන ලක්ෂ්‍ය ව්යාකූලත්වය පිළිබඳ වැඩිදුර කියවා ඒ වෙනුවට දශම වස්තු උත්සාහ කරන්න .

දශම වස්තුව සහ වටකුරු () ක්‍රමයේ සංයෝජනය භාවිතා කරන්න.

Python 3.7.3
>>> from decimal import Decimal
>>> d1 = Decimal (13.949999999999999) # define a Decimal
>>> d1 
Decimal('13.949999999999999289457264239899814128875732421875')
>>> d2 = round(d1, 2) # round to 2 decimals
>>> d2
Decimal('13.95')

පයිතන් සහ ජාවාස්ක්‍රිප්ට් වැනි ගතික භාෂාවල පාවෙන ස්ථානය සවි කිරීම සඳහා මම මෙම තාක්ෂණය භාවිතා කරමි

# For example:
a = 70000
b = 0.14
c = a * b

print c # Prints 980.0000000002
# Try to fix
c = int(c * 10000)/100000
print c # Prints 980

ඔබට පහත පරිදි දශම භාවිතා කළ හැකිය:

from decimal import *
getcontext().prec = 6
Decimal(1) / Decimal(7)
# Results in 6 precision -> Decimal('0.142857')

getcontext().prec = 28
Decimal(1) / Decimal(7)
# Results in 28 precision -> Decimal('0.1428571428571428571428571429')

from decimal import Decimal


def round_float(v, ndigits=2, rt_str=False):
    d = Decimal(v)
    v_str = ("{0:.%sf}" % ndigits).format(round(d, ndigits))
    if rt_str:
        return v_str
    return Decimal(v_str)

ප්රතිපල:

Python 3.6.1 (default, Dec 11 2018, 17:41:10)
>>> round_float(3.1415926)
Decimal('3.14')
>>> round_float(3.1445926)
Decimal('3.14')
>>> round_float(3.1455926)
Decimal('3.15')
>>> round_float(3.1455926, rt_str=True)
'3.15'
>>> str(round_float(3.1455926))
'3.15'

orig_float = 232569 / 16000.0

14.5355625

short_float = float("{:.2f}".format(orig_float)) 

14.54

මේ වගේ ලැම්බඩා ශ්‍රිතයක් ගැන කුමක් කිව හැකිද:

arred = lambda x,n : x*(10**n)//1/(10**n)

ඔබට කළ හැකි මේ ආකාරයෙන්:

arred(3.141591657,2)

ලබා ගන්න

3.14

එය 1,2,3 වැනි සරල ය:

1. දශම භාවිතා කරන්නනිවැරදිව නිවැරදිව වටකුරු දශම පාවෙන ලක්ෂ්‍ය අංක ගණිතය සඳහා මොඩියුලය :

   d = දශම (10000000.0000009)

වටය ළඟා කර ගැනීමට:

   d.quantize(Decimal('0.01'))

ප්‍රති results ල ලබා දෙනු ඇත Decimal('10000000.00')

2. ඉහත ඩ්‍රයි කරන්න:

    def round_decimal(number, exponent='0.01'):
        decimal_value = Decimal(number)
        return decimal_value.quantize(Decimal(exponent))

හෝ

    def round_decimal(number, decimal_places=2):
        decimal_value = Decimal(number)
        return decimal_value.quantize(Decimal(10) ** -decimal_places)

3. මෙම පිළිතුර ඉහළට ඔසවන්න :)

PS: අන් අයව විවේචනය කිරීම: හැඩතල ගැන්වීම වටකුරු නොවේ.

අංකයක් විභේදනයකට යොමු කිරීම සඳහා, හොඳම ක්‍රමය පහත දැක්වෙන ක්‍රමයයි, එය ඕනෑම විභේදනයක් සමඟ ක්‍රියා කළ හැකිය (දශම දෙකකට 0.01 හෝ වෙනත් පියවර සඳහා):

>>> import numpy as np
>>> value = 13.949999999999999
>>> resolution = 0.01
>>> newValue = int(np.round(value/resolution))*resolution
>>> print newValue
13.95

>>> resolution = 0.5
>>> newValue = int(np.round(value/resolution))*resolution
>>> print newValue
14.0

lambda x, n: int (x * 10 n + .5) / 10 n වසර ගණනාවක් තිස්සේ බොහෝ භාෂාවලින් මා වෙනුවෙන් වැඩ කර ඇත .

මම භාවිතා කරන ක්‍රමය නූල් පෙති කැපීමයි. එය සාපේක්ෂව ඉක්මන් හා සරල ය.

පළමුවෙන්ම, පාවෙන නූලකට හරවන්න, ඔබ කැමති දිග තෝරන්න.

float = str(float)[:5]

ඉහත තනි පේළියේ දී, අපි අගය නූලකට පරිවර්තනය කර, පසුව එහි පළමු ඉලක්කම් හතරට හෝ අක්ෂරවලට පමණක් ඇතුළත් කර ඇත්තෙමු.

උපකාරවත් වන බලාපොරොත්තුව!