blocks|key|1859118|text|我无法控制它的存储方式，但至少格式化是正确的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1859119|'%25.1f'+%25+round(n,+1)+#+Gives+you+'5.6'|code-block|syntax|javascript|1859120|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I can't help the way it's stored, but at least formatting works correctly: 

<pre><code>'%.1f' % round(n, 1) # Gives you '5.6'
</code></pre>

blocks|key|1859745|text|即使不需要舍入，格式化也能正常工作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1859746|"%25.1f"+%25+n|code-block|syntax|javascript|1859747|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Formatting works correctly even without having to round:

<pre><code>"%.1f" % n
</code></pre>

blocks|key|1859870|text|如果你使用Decimal模块，你可以在不使用'round‘函数的情况下进行近似。下面是我用来进行舍入的代码，尤其是在编写货币应用程序时：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1859871|from+decimal+import+Decimal,+ROUND_UP

Decimal(str(16.2)).quantize(Decimal('.01'),+rounding=ROUND_UP)|code-block|syntax|javascript|1859872|这将返回一个为16.20的十进制数。|1859873|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

If you use the Decimal module you can approximate without the use of the 'round' function. Here is what I've been using for rounding especially when writing monetary applications:
<pre><code>from decimal import Decimal, ROUND_UP

Decimal(str(16.2)).quantize(Decimal('.01'), rounding=ROUND_UP)
</code></pre>
This will return a Decimal Number which is 16.20.

blocks|key|2073701|text|round(5.59,+1)运行得很好。问题是5.6不能精确地表示为二进制浮点数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2073702|>>>+5.6
5.5999999999999996
>>>+|code-block|syntax|javascript|2073703|正如Vinko所说，您可以使用字符串格式化来进行舍入以进行显示。|2073704|Python有一个module+for+decimal+arithmetic，如果你需要的话。|2073705|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/lib/module-decimal.html^0|0|E|0|0|0|9|T|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|11|8|@]|D|@$9|12|A|13|1|14]]|E|$]]|$1|O|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

<code>round(5.59, 1)</code> is working fine. The problem is that 5.6 cannot be represented exactly in binary floating point.

<pre><code>&gt;&gt;&gt; 5.6
5.5999999999999996
&gt;&gt;&gt; 
</code></pre>

As Vinko says, you can use string formatting to do rounding for display.

Python has a <a href="http://docs.python.org/lib/module-decimal.html" rel="noreferrer">module for decimal arithmetic</a> if you need that.

blocks|key|2073569|text|如果你使用str(round(n,+1))而不仅仅是round(n,+1)，你会得到'5.6‘。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2073570|entityMap^0|5|G|Q|B|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

You get '5.6' if you do <code>str(round(n, 1))</code> instead of just <code>round(n, 1)</code>.

blocks|key|2073134|text|您可以将数据类型切换为整数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2073135|>>>+n+=+5.59
>>>+int(n+*+10)+/+10.0
5.5
>>>+int(n+*+10+%2B+0.5)
56|code-block|syntax|javascript|2073136|然后通过插入区域设置的小数分隔符来显示数字。|2073137|但是，Jimmy's+answer更好。|offset|length|2073138|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/56820/round-in-python-doesnt-seem-to-be-rounding-properly#56833^0|0|0|0|3|E|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|X|8|@]|9|@$K|Y|L|Z|1|10]]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

You can switch the data type to an integer:

<pre><code>&gt;&gt;&gt; n = 5.59
&gt;&gt;&gt; int(n * 10) / 10.0
5.5
&gt;&gt;&gt; int(n * 10 + 0.5)
56
</code></pre>

And then display the number by inserting the locale's decimal separator.

However, <a href="https://stackoverflow.com/questions/56820/round-in-python-doesnt-seem-to-be-rounding-properly#56833">Jimmy's answer</a> is better.

blocks|key|1859716|text|浮点数学容易受到微小但令人讨厌的精度误差的影响。如果你能处理整数或定点，你就能保证精确度。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1859717|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Floating point math is vulnerable to slight, but annoying, precision inaccuracies. If you can work with integer or fixed point, you will be guaranteed precision.

blocks|key|2073825|text|这确实是一个很大的问题。试试下面的代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2073826|print+"%25.2f"+%25+(round((2*4.4%2B3*5.6%2B3*4.4)/8,2),)|code-block|syntax|javascript|2073827|它显示4.85。然后你就可以做到：|2073828|print+"Media+=+%25.1f"+%25+(round((2*4.4%2B3*5.6%2B3*4.4)/8,1),)|2073829|它显示了4.8。你手工计算过吗?确切的答案是4.85，但如果你试一下：|2073830|print+"Media+=+%25.20f"+%25+(round((2*4.4%2B3*5.6%2B3*4.4)/8,20),)|2073831|您可以看到事实:浮点数存储为分母为2的幂的分数的最接近的有限和。|2073832|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

It's a big problem indeed. Try out this code:

<pre><code>print "%.2f" % (round((2*4.4+3*5.6+3*4.4)/8,2),)
</code></pre>

It displays 4.85. Then you do: 

<pre><code>print "Media = %.1f" % (round((2*4.4+3*5.6+3*4.4)/8,1),)
</code></pre>

and it shows 4.8. Do you calculations by hand the exact answer is 4.85, but if you try: 

<pre><code>print "Media = %.20f" % (round((2*4.4+3*5.6+3*4.4)/8,20),)
</code></pre>

you can see the truth: the float point is stored as the nearest finite sum of fractions whose denominators are powers of two.

blocks|key|1859594|text|您可以使用字符串格式操作符%25，类似于sprintf。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1859595|mystring+=+"%25.2f"+%25+5.5999|code-block|syntax|javascript|1859596|entityMap^0|D|1|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

You can use the string format operator <code>%</code>, similar to sprintf.

<pre><code>mystring = "%.2f" % 5.5999
</code></pre>

blocks|key|1860050|text|我正在做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1860051|int(round(+x+,+0))|code-block|syntax|javascript|1860052|在这种情况下，我们首先在单位级别正确地进行舍入，然后转换为整数以避免打印浮点数。|1860053|所以|1860054|>>>+int(round(5.59,0))
6|1860055|我认为这个答案比格式化字符串效果更好，而且对我来说使用round函数也更有意义。|1860056|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

I am doing:

<pre><code>int(round( x , 0))
</code></pre>

In this case, we first round properly at the unit level, then we convert to integer to avoid printing a float.

so 

<pre><code>&gt;&gt;&gt; int(round(5.59,0))
6
</code></pre>

I think this answer works better than formating the string, and it also makes more sens to me to use the round function.

blocks|key|1860380|text|在这种情况下，我会完全避免依赖round()。考虑一下|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1860381|print(round(61.295,+2))
print(round(1.295,+2))|code-block|syntax|javascript|1860382|将输出|1860383|61.3
1.29|1860384|如果您需要四舍五入到最接近的整数，则这不是所需的输出。要绕过此行为，请使用math.ceil()+(如果要向下舍入，则使用math.floor()+)：|1860385|from+math+import+ceil
decimal_count+=+2
print(ceil(61.295+*+10+**+decimal_count)+/+10+**+decimal_count)
print(ceil(1.295+*+10+**+decimal_count)+/+10+**+decimal_count)|1860386|输出|1860387|61.3
1.3|1860388|希望这能有所帮助。|1860389|entityMap^0|F|7|0|0|0|0|11|B|1P|C|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|14|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1B|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1C|8|@]|D|@]|E|$]]|$1|U|3|V|5|H|7|1D|8|@]|D|@]|E|$I|J]]|$1|W|3|X|5|6|7|1E|8|@]|D|@]|E|$]]|$1|Y|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]]|Z|$]]

I would avoid relying on <code>round()</code> at all in this case. Consider

<pre><code>print(round(61.295, 2))
print(round(1.295, 2))
</code></pre>

will output

<pre><code>61.3
1.29
</code></pre>

which is not a desired output if you need solid rounding to the nearest integer. To bypass this behavior go with <code>math.ceil()</code> (or <code>math.floor()</code> if you want to round down):

<pre><code>from math import ceil
decimal_count = 2
print(ceil(61.295 * 10 ** decimal_count) / 10 ** decimal_count)
print(ceil(1.295 * 10 ** decimal_count) / 10 ** decimal_count)
</code></pre>

outputs

<pre><code>61.3
1.3
</code></pre>

Hope that helps.

blocks|key|1859986|text|完美的作品|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1859987|format(5.59,+'.1f')+#+to+display
float(format(5.59,+'.1f'))+#to+round|code-block|syntax|javascript|1859988|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Works Perfect 

<pre><code>format(5.59, '.1f') # to display
float(format(5.59, '.1f')) #to round
</code></pre>

blocks|key|1860411|text|另一个可能的选择是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1860412|def+hard_round(number,+decimal_places=0):
++++"""
++++Function:
++++-+Rounds+a+float+value+to+a+specified+number+of+decimal+places
++++-+Fixes+issues+with+floating+point+binary+approximation+rounding+in+python
++++Requires:
++++-+`number`:
++++++++-+Type:+int%7Cfloat
++++++++-+What:+The+number+to+round
++++Optional:
++++-+`decimal_places`:
++++++++-+Type:+int+
++++++++-+What:+The+number+of+decimal+places+to+round+to
++++++++-+Default:+0
++++Example:
++++```
++++hard_round(5.6,1)
++++```
++++"""
++++return+int(number*(10**decimal_places)%2B0.5)/(10**decimal_places)|code-block|syntax|javascript|1860413|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Another potential option is:

<pre><code>def hard_round(number, decimal_places=0):
 """
 Function:
 - Rounds a float value to a specified number of decimal places
 - Fixes issues with floating point binary approximation rounding in python
 Requires:
 - `number`:
 - Type: int|float
 - What: The number to round
 Optional:
 - `decimal_places`:
 - Type: int 
 - What: The number of decimal places to round to
 - Default: 0
 Example:
 ```
 hard_round(5.6,1)
 ```
 """
 return int(number*(10**decimal_places)+0.5)/(10**decimal_places)
</code></pre>

blocks|key|2073988|text|代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2073989|x1+=+5.63
x2+=+5.65
print(float('%25.2f'+%25+round(x1,1)))++#+gives+you+'5.6'
print(float('%25.2f'+%25+round(x2,1)))++#+gives+you+'5.7'|code-block|syntax|javascript|2073990|输出：|2073991|5.6
5.7|2073992|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Code:

<pre><code>x1 = 5.63
x2 = 5.65
print(float('%.2f' % round(x1,1))) # gives you '5.6'
print(float('%.2f' % round(x2,1))) # gives you '5.7'
</code></pre>

Output:

<pre><code>5.6
5.7
</code></pre>

blocks|key|2074083|text|问题只出现在最后一位数是5的时候。0.045在内部存储为0.044999999999999...您可以简单地将最后一位数增加到6，然后四舍五入。这将为您提供所需的结果。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2074084|import+re


def+custom_round(num,+precision=0):
++++#+Get+the+type+of+given+number
++++type_num+=+type(num)
++++#+If+the+given+type+is+not+a+valid+number+type,+raise+TypeError
++++if+type_num+not+in+[int,+float,+Decimal]:
++++++++raise+TypeError("type+{}+doesn't+define+__round__+method".format(type_num.__name__))
++++#+If+passed+number+is+int,+there+is+no+rounding+off.
++++if+type_num+==+int:
++++++++return+num
++++#+Convert+number+to+string.
++++str_num+=+str(num).lower()
++++#+We+will+remove+negative+context+from+the+number+and+add+it+back+in+the+end
++++negative_number+=+False
++++if+num+<+0:
++++++++negative_number+=+True
++++++++str_num+=+str_num[1:]
++++#+If+number+is+in+format+1e-12+or+2e%2B13,+we+have+to+convert+it+to
++++#+to+a+string+in+standard+decimal+notation.
++++if+'e-'+in+str_num:
++++++++#+For+1.23e-7,+e_power+=+7
++++++++e_power+=+int(re.findall('e-[0-9]%2B',+str_num)[0][2:])
++++++++#+For+1.23e-7,+number+=+123
++++++++number+=+''.join(str_num.split('e-')[0].split('.'))
++++++++zeros+=+''
++++++++#+Number+of+zeros+=+e_power+-+1+=+6
++++++++for+i+in+range(e_power+-+1):
++++++++++++zeros+=+zeros+%2B+'0'
++++++++#+Scientific+notation+1.23e-7+in+regular+decimal+=+0.000000123
++++++++str_num+=+'0.'+%2B+zeros+%2B+number
++++if+'e%2B'+in+str_num:
++++++++#+For+1.23e%2B7,+e_power+=+7
++++++++e_power+=+int(re.findall('e\%2B[0-9]%2B',+str_num)[0][2:])
++++++++#+For+1.23e%2B7,+number_characteristic+=+1
++++++++#+characteristic+is+number+left+of+decimal+point.
++++++++number_characteristic+=+str_num.split('e%2B')[0].split('.')[0]
++++++++#+For+1.23e%2B7,+number_mantissa+=+23
++++++++#+mantissa+is+number+right+of+decimal+point.
++++++++number_mantissa+=+str_num.split('e%2B')[0].split('.')[1]
++++++++#+For+1.23e%2B7,+number+=+123
++++++++number+=+number_characteristic+%2B+number_mantissa
++++++++zeros+=+''
++++++++#+Eg:+for+this+condition+=+1.23e%2B7
++++++++if+e_power+>=+len(number_mantissa):
++++++++++++#+Number+of+zeros+=+e_power+-+mantissa+length+=+5
++++++++++++for+i+in+range(e_power+-+len(number_mantissa)):
++++++++++++++++zeros+=+zeros+%2B+'0'
++++++++++++#+Scientific+notation+1.23e%2B7+in+regular+decimal+=+12300000.0
++++++++++++str_num+=+number+%2B+zeros+%2B+'.0'
++++++++#+Eg:+for+this+condition+=+1.23e%2B1
++++++++if+e_power+<+len(number_mantissa):
++++++++++++#+In+this+case,+we+only+need+to+shift+the+decimal+e_power+digits+to+the+right
++++++++++++#+So+we+just+copy+the+digits+from+mantissa+to+characteristic+and+then+remove
++++++++++++#+them+from+mantissa.
++++++++++++for+i+in+range(e_power):
++++++++++++++++number_characteristic+=+number_characteristic+%2B+number_mantissa[i]
++++++++++++number_mantissa+=+number_mantissa[i:]
++++++++++++#+Scientific+notation+1.23e%2B1+in+regular+decimal+=+12.3
++++++++++++str_num+=+number_characteristic+%2B+'.'+%2B+number_mantissa
++++#+characteristic+is+number+left+of+decimal+point.
++++characteristic_part+=+str_num.split('.')[0]
++++#+mantissa+is+number+right+of+decimal+point.
++++mantissa_part+=+str_num.split('.')[1]
++++#+If+number+is+supposed+to+be+rounded+to+whole+number,
++++#+check+first+decimal+digit.+If+more+than+5,+return
++++#+characteristic+%2B+1+else+return+characteristic
++++if+precision+==+0:
++++++++if+mantissa_part+and+int(mantissa_part[0])+>=+5:
++++++++++++return+type_num(int(characteristic_part)+%2B+1)
++++++++return+type_num(characteristic_part)
++++#+Get+the+precision+of+the+given+number.
++++num_precision+=+len(mantissa_part)
++++#+Rounding+off+is+done+only+if+number+precision+is
++++#+greater+than+requested+precision
++++if+num_precision+<=+precision:
++++++++return+num
++++#+Replace+the+last+'5'+with+6+so+that+rounding+off+returns+desired+results
++++if+str_num[-1]+==+'5':
++++++++str_num+=+re.sub('5$',+'6',+str_num)
++++result+=+round(type_num(str_num),+precision)
++++#+If+the+number+was+negative,+add+negative+context+back
++++if+negative_number:
++++++++result+=+result+*+-1
++++return+result|code-block|syntax|javascript|2074085|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The problem is only when last digit is 5. Eg. 0.045 is internally stored as 0.044999999999999... You could simply increment last digit to 6 and round off. This will give you the desired results.

<pre><code>import re


def custom_round(num, precision=0):
 # Get the type of given number
 type_num = type(num)
 # If the given type is not a valid number type, raise TypeError
 if type_num not in [int, float, Decimal]:
 raise TypeError("type {} doesn't define __round__ method".format(type_num.__name__))
 # If passed number is int, there is no rounding off.
 if type_num == int:
 return num
 # Convert number to string.
 str_num = str(num).lower()
 # We will remove negative context from the number and add it back in the end
 negative_number = False
 if num &lt; 0:
 negative_number = True
 str_num = str_num[1:]
 # If number is in format 1e-12 or 2e+13, we have to convert it to
 # to a string in standard decimal notation.
 if 'e-' in str_num:
 # For 1.23e-7, e_power = 7
 e_power = int(re.findall('e-[0-9]+', str_num)[0][2:])
 # For 1.23e-7, number = 123
 number = ''.join(str_num.split('e-')[0].split('.'))
 zeros = ''
 # Number of zeros = e_power - 1 = 6
 for i in range(e_power - 1):
 zeros = zeros + '0'
 # Scientific notation 1.23e-7 in regular decimal = 0.000000123
 str_num = '0.' + zeros + number
 if 'e+' in str_num:
 # For 1.23e+7, e_power = 7
 e_power = int(re.findall('e\+[0-9]+', str_num)[0][2:])
 # For 1.23e+7, number_characteristic = 1
 # characteristic is number left of decimal point.
 number_characteristic = str_num.split('e+')[0].split('.')[0]
 # For 1.23e+7, number_mantissa = 23
 # mantissa is number right of decimal point.
 number_mantissa = str_num.split('e+')[0].split('.')[1]
 # For 1.23e+7, number = 123
 number = number_characteristic + number_mantissa
 zeros = ''
 # Eg: for this condition = 1.23e+7
 if e_power &gt;= len(number_mantissa):
 # Number of zeros = e_power - mantissa length = 5
 for i in range(e_power - len(number_mantissa)):
 zeros = zeros + '0'
 # Scientific notation 1.23e+7 in regular decimal = 12300000.0
 str_num = number + zeros + '.0'
 # Eg: for this condition = 1.23e+1
 if e_power &lt; len(number_mantissa):
 # In this case, we only need to shift the decimal e_power digits to the right
 # So we just copy the digits from mantissa to characteristic and then remove
 # them from mantissa.
 for i in range(e_power):
 number_characteristic = number_characteristic + number_mantissa[i]
 number_mantissa = number_mantissa[i:]
 # Scientific notation 1.23e+1 in regular decimal = 12.3
 str_num = number_characteristic + '.' + number_mantissa
 # characteristic is number left of decimal point.
 characteristic_part = str_num.split('.')[0]
 # mantissa is number right of decimal point.
 mantissa_part = str_num.split('.')[1]
 # If number is supposed to be rounded to whole number,
 # check first decimal digit. If more than 5, return
 # characteristic + 1 else return characteristic
 if precision == 0:
 if mantissa_part and int(mantissa_part[0]) &gt;= 5:
 return type_num(int(characteristic_part) + 1)
 return type_num(characteristic_part)
 # Get the precision of the given number.
 num_precision = len(mantissa_part)
 # Rounding off is done only if number precision is
 # greater than requested precision
 if num_precision &lt;= precision:
 return num
 # Replace the last '5' with 6 so that rounding off returns desired results
 if str_num[-1] == '5':
 str_num = re.sub('5$', '6', str_num)
 result = round(type_num(str_num), precision)
 # If the number was negative, add negative context back
 if negative_number:
 result = result * -1
 return result
</code></pre>

blocks|key|2073977|text|这就是我看到的失败之处。如果你想把这两个数字四舍五入到小数点后一位呢?+23.45+23.55我学到的是:+23.4+23.6“规则”是，如果前面的数字是奇数，就应该四舍五入，如果前面的数字是偶数，就不要四舍五入。python中的round函数简单地截断了5。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2073978|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Here's where I see round failing. What if you wanted to round these 2 numbers to one decimal place?
23.45
23.55
My education was that from rounding these you should get:
23.4
23.6
the "rule" being that you should round up if the preceding number was odd, not round up if the preceding number were even.
The round function in python simply truncates the 5.

blocks|key|2074300|text|这里有一个简单的方法，可以将一个浮点数舍入到小数点后的任意位数，它在2021年仍然有效！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2074301|float_number+=+12.234325335563
rounded+=+round(float_number,+3)+#+3+is+the+number+of+decimal+places+to+be+returned.You+can+pass+any+number+in+place+of+3+depending+on+how+many+decimal+places+you+want+to+return.
print(rounded)|code-block|syntax|javascript|2074302|这将打印出来；|2074303|12.234|2074304|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here is an easy way to round a float number to any number of decimal places, and it still works in 2021!
<pre><code>float_number = 12.234325335563
rounded = round(float_number, 3) # 3 is the number of decimal places to be returned.You can pass any number in place of 3 depending on how many decimal places you want to return.
print(rounded)
</code></pre>
And this will print;
<pre><code>12.234
</code></pre>

blocks|key|1859013|text|下面是什么：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1859014|round(n,1)%2Bepsilon|code-block|syntax|javascript|1859015|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

What about:

<pre><code>round(n,1)+epsilon
</code></pre>

The documentation for the <a href="http://docs.python.org/lib/built-in-funcs.html" rel="noreferrer">round()</a> function states that you pass it a number, and the positions past the decimal to round. Thus it should do this:

<pre><code>n = 5.59
round(n, 1) # 5.6
</code></pre>

But, in actuality, good old floating point weirdness creeps in and you get:

<pre><code>5.5999999999999996
</code></pre>

For the purposes of UI, I need to display <code>5.6</code>. I poked around the Internet and found some <a href="http://mail.python.org/pipermail/python-list/2005-September/340383.html" rel="noreferrer">documentation</a> that this is dependent on my implementation of Python. Unfortunately, this occurs on both my Windows dev machine and each Linux server I've tried. <a href="http://www.python.org/doc/2.5.1/tut/node16.html" rel="noreferrer">See here also</a>.

Short of creating my own round library, is there any way around this?

round() doesn't seem to be rounding properly

服务器

Windows

Python

Linux

函数的文档指出，向它传递一个数字，小数点后的位置进行四舍五入。因此，它应该这样做：n = 5.59round(n, 1) # 5.6但是，在现实中，古老的浮点怪癖悄然而至，你会得到：5.5999999999999996出于UI的目的，我需要显示5.6。我在互联网上浏览了一下，发现一些依赖于我的Python实现。不幸的是，在我的Windows dev机器和我尝试过的每台Linux服务器上都会发生这种

问round()似乎不能正确舍入
EN

回答 18

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问round()似乎不能正确舍入EN

回答 18

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问round()似乎不能正确舍入
EN