Python3的四舍五入round()函数坑爹？不，更科学

已于 2022-08-30 11:14:10 修改
阅读量1.3w 收藏 20
点赞数 5
文章标签： Python round
于 2018-06-06 15:41:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lly1122334/article/details/80596026
版权

文章目录

问题描述

Python2 中，round() 的结果就是我们所理解的四舍五入，round(1.5)=2，round(2.5)=3。

Python3 中，round() 有较大改动，round(1.5)=2，而round(2.5)仍然等于2，只有round(2.6)才等于3，这是为什么呢？




解决方案

原来 Python2 的 round() 是四舍五入，而 Python3 的 round() 为四舍六入五成双，即高位为单数则进1凑成双数，高位为双数则不进位。

这让我想起了大二时候的大物实验，第一节讲的计数方法，其中印象最深刻的就是“四舍六入五成双”，它的作用是让统计数据更公平，降低舍入的误差。

具体查阅：

  1. 浮点算术：争议和限制
  2. What Every Computer Scientist Should Know About Floating-Point Arithmetic




进一步阅读

由于有浮点精度表示错误，在追求精度的情况下应使用 Decimal，务必用字符串进行实例化

from decimal import Decimal

print(0.29 * 100)  # 28.999999999999996
print(Decimal(0.29) * 100)  # 28.99999999999999800159855567
print(Decimal('0.29') * 100)  # 29.00
print(Decimal('1.5093').quantize(Decimal('1.00')))  # 1.51




强制四舍五入

使用 decimal

from decimal import Decimal, ROUND_HALF_UP


def round(number, ndigits=None):
    """强制四舍五入"""
    exp = Decimal('1.{}'.format(ndigits * '0')) if ndigits else Decimal('1')
    return type(number)(Decimal(number).quantize(exp, ROUND_HALF_UP))


print(round(4.115, 2), type(round(4.115, 2)))
print(round(4.116, 2), type(round(4.116, 2)))
print(round(4.125, 2), type(round(4.125, 2)))
print(round(4.126, 2), type(round(4.126, 2)))
print(round(2.5), type(round(2.5)))
print(round(3.5), type(round(3.5)))
print(round(5), type(round(5)))
print(round(6), type(round(6)))
# 4.12 <class 'float'>
# 4.12 <class 'float'>
# 4.13 <class 'float'>
# 4.13 <class 'float'>
# 3.0 <class 'float'>
# 4.0 <class 'float'>
# 5 <class 'int'>
# 6 <class 'int'>

使用 math

import math


def round(number, ndigits=0):
    """强制四舍五入"""
    exp = number * 10 ** ndigits
    if abs(exp) - abs(math.floor(exp)) < 0.5:
        return type(number)(math.floor(exp) / 10 ** ndigits)
    return type(number)(math.ceil(exp) / 10 ** ndigits)


print(round(4.115, 2), type(round(4.115, 2)))
print(round(4.116, 2), type(round(4.116, 2)))
print(round(4.125, 2), type(round(4.125, 2)))
print(round(4.126, 2), type(round(4.126, 2)))
print(round(2.5), type(round(2.5)))
print(round(3.5), type(round(3.5)))
print(round(5), type(round(5)))
print(round(6), type(round(6)))
# 4.12 <class 'float'>
# 4.12 <class 'float'>
# 4.13 <class 'float'>
# 4.13 <class 'float'>
# 3.0 <class 'float'>
# 4.0 <class 'float'>
# 5 <class 'int'>
# 6 <class 'int'>

对比

方法耗时（运算一百万次）易读性
使用 decimal1.99 s高
使用 math1.21 s低




四舍五入策略

查看舍入模式，默认为 decimal.ROUND_HALF_EVEN

from decimal import getcontext

print(getcontext())
# Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])

切换舍入模式

from decimal import *

print(Decimal('1.5093').quantize(Decimal('1.00'), rounding=ROUND_DOWN))  # 临时切换
getcontext().rounding = ROUND_DOWN  # 全局切换

所有舍入模式

舍入模式功能
decimal.ROUND_CEILING向上取整
decimal.ROUND_FLOOR向下取整
decimal.ROUND_DOWN截断
decimal.ROUND_UP舍入到零的反方向
decimal.ROUND_HALF_UP舍入到最接近的数，同样接近则舍入到零的反方向（四舍五入）
decimal.ROUND_HALF_DOWN舍入到最接近的数，同样接近则舍入方向为零
decimal.ROUND_HALF_EVEN舍入到最接近的数，同样接近则舍入到最接近的偶数
decimal.ROUND_05UP四舍五入，趋近于零
import math
from decimal import *


# 向上取整
def round_ceiling(n, decimals=0):
    multiplier = 10 ** decimals
    return math.ceil(n * multiplier) / multiplier


getcontext().rounding = ROUND_CEILING
print('ROUND_CEILING')
print(Decimal('1.32').quantize(Decimal('1.0')))  # 1.4
print(Decimal('-1.32').quantize(Decimal('1.0')))  # -1.3
print(round_ceiling(1.32, 1.0))  # 1.4
print(round_ceiling(-1.32, 1.0))  # -1.3


# 向下取整
def round_floor(n, decimals=0):
    multiplier = 10 ** decimals
    return math.floor(n * multiplier) / multiplier


getcontext().rounding = ROUND_FLOOR
print('ROUND_FLOOR')
print(Decimal('1.32').quantize(Decimal('1.0')))  # 1.3
print(Decimal('-1.32').quantize(Decimal('1.0')))  # -1.4
print(round_floor(1.32, 1.0))  # 1.4
print(round_floor(-1.32, 1.0))  # -1.3


# 截断
def round_down(n, decimals=0):
    multiplier = 10 ** decimals
    return int(n * multiplier) / multiplier


getcontext().rounding = ROUND_DOWN
print('ROUND_DOWN')
print(Decimal('1.32').quantize(Decimal('1.0')))  # 1.3
print(Decimal('-1.32').quantize(Decimal('1.0')))  # -1.3
print(round_down(1.32, 1.0))  # 1.3
print(round_down(-1.32, 1.0))  # -1.3

# 将所有值从零进行舍入
getcontext().rounding = ROUND_UP
print('ROUND_UP')
print(Decimal('1.32').quantize(Decimal('1.0')))  # 1.4
print(Decimal('-1.32').quantize(Decimal('1.0')))  # -1.4


# 四舍五入到最接近的数字，并通过从0舍入来打破平局
def round_half_up(n, decimals=0):
    def _round_half_up(n, decimals=0):
        multiplier = 10 ** decimals
        return math.floor(n * multiplier + 0.5) / multiplier

    rounded_abs = _round_half_up(abs(n), decimals)
    return math.copysign(rounded_abs, n)


getcontext().rounding = ROUND_HALF_UP
print('ROUND_HALF_UP')
print(Decimal('1.35').quantize(Decimal('1.0')))  # 1.4
print(Decimal('-1.35').quantize(Decimal('1.0')))  # -1.4
print(round_half_up(1.35, 1.0))  # 1.4
print(round_half_up(-1.35, 1.0))  # -1.4

# 舍入到最接近的数，同样接近则舍入方向为零
getcontext().rounding = ROUND_HALF_DOWN
print('ROUND_HALF_DOWN')
print(Decimal('1.35').quantize(Decimal('1.0')))  # 1.3
print(Decimal('-1.35').quantize(Decimal('1.0')))  # -1.3

# 舍入到最接近的数，同样接近则舍入到最接近的偶数
getcontext().rounding = ROUND_HALF_EVEN  # 默认
print('ROUND_HALF_EVEN')
print(Decimal('15.255').quantize(Decimal('1')))  # 15
print(Decimal('15.255').quantize(Decimal('1.0')))  # 15.3
print(Decimal('15.255').quantize(Decimal('1.00')))  # 15.26

# 四舍五入，趋近于零
getcontext().rounding = ROUND_05UP  # 四舍五入为0或5则取反方向的值
print('ROUND_05UP')
print(Decimal('1.38').quantize(Decimal('1.0')))  # 1.3
print(Decimal('1.35').quantize(Decimal('1.0')))  # 1.3
print(Decimal('-1.35').quantize(Decimal('1.0')))  # -1.3
print(Decimal('1.49').quantize(Decimal('1.0')))  # 1.4
print(Decimal('1.51').quantize(Decimal('1.0')))  # 1.6




常用函数

函数功能例子
round()四舍六入五成双round(1.5) == 2
round(2.5) == 2
math.ceil()向上取整math.ceil(1.5) == 2
math.ceil(2) == 2
math.floor()向下取整math.floor(2.5) == 2
math.floor(2) == 2




向上取整到十位

from decimal import Decimal, ROUND_UP


def ceil_to_tens_decimal(x):
    """向上取整到十位

    >>> ceil_to_tens_decimal(10.2)
    Decimal('20')
    >>> ceil_to_tens_decimal(10.0)
    Decimal('10')
    >>> ceil_to_tens_decimal(16.7)
    Decimal('20')
    >>> ceil_to_tens_decimal(94.9)
    Decimal('100')
    """
    return (Decimal(x) / 10).quantize(1, rounding=ROUND_UP) * 10




操作建议

  1. 放到后面再四舍五入
  2. 遵守当地货币规定
  3. 纠结的话就用ROUND_HALF_EVEN




浮点数判等

用 math.isclose(a, b)




参考文献

  1. Python2 在线工具
  2. Python3 在线工具
  3. 内置函数 — Python文档
  4. How to Round Numbers in Python
  5. math - how to round to higher 10’s place in python
  6. How to round float 0.5 up to 1.0, while still rounding 0.45 to 0.0, as the usual school rounding
  7. Python快速计算函数耗时timeit
XerCis
关注
python3 小数位的四舍五入(用两种方法解决round 遇5不进)
12-31
round( )函数简介 菜鸟教程中介绍到，round() 函数作用就是，返回浮点数x的四舍五入值。 > round( x [, n] ) 参数x，n均为数值表达式，返回值为x的四舍五入值。n为保留的小数位数，不加n则只保留x四舍五入后的整数部分。 >>> round(2.3) 2 >>> round(2.45, 1) 2.5 特殊情况 上面的结果并没有错误，这里再用2.675测试一下： >>> round(2.675, 2) 2.67 显然结果不符合四舍五入的规则。为什么会这样呢？原因是：round()函数只有一个参数，不指定位数的时候，返回一个整数，而且是最靠近的整数，类似于四
Python 数值四舍五入碰到遇5不进
zhouyinlong1990的博客
01-03 3497
学习编程的过程中，和很多同学一样，偶然遇到了“数值四舍五入碰到遇5不进”的情况，如下： # 遍历[0.5,1.5,...,19.5] for i in [j+0.5 for j in range(20)]: # 对 i round()取整，并输出结果 print(i,'round()取整为' if i > 10 else ' round()取整为',round(i)) 0.5 round()取整为 0 1.5 round()取整为 2 2.5 round()取整为 ...
python小数四舍五入
最新发布
Dxy1239310216的博客
07-02 504
函数的默认行为（即“银行家舍入”），并始终向上或向下舍入，你可以使用。函数接受两个参数：要四舍五入的数字和要保留的小数位数。在Python中，你可以使用内置的。函数来对小数进行四舍五入。
Python3 里面的四舍五入
Luxmlb的博客
06-08 339
Python3 里面的四舍五入
Python3中的round函数（四舍六入五成偶）
qq_53438188的博客
03-03 4350
在python3中，round函数并不是简单地四舍五入，而是四舍六入五成偶 如：round（1.5）= 2 ， round（2.5）=2。 四舍六入成偶具体分为两点（）： 1.若被约的5后面还有数字，一律进一位； 2.若被约的5后面没有数字，5前面为偶数则舍弃此位，若5前为偶数则进一位。 下面举几个例子： # 5后面没有数字且前面为奇数 print(round(1.5)) print(round(3.5)) # 5后面没有数字且前面为偶数 print(round(2.5)) print(round(4.5
Python 3 内置函数 - `round()`函数
曹逗号@INHA
03-24 812
Python 3 内置函数 - round函数 0. round()函数 返回浮点数的四舍六入值。精度要求高的运算，不建议使用该函数。 参数：ndigits: 小数点位数。 1. 使用方法 >>> help(round) # output: Help on built-in function round in module builtins: ## 使用方法： round(number, ndigits=None) Round a number to a given p
Python3的四舍五入round()函数坑爹？不，更科学！
craftsman2020的博客
04-21 1138
Python2中，round()的结果就是我们所理解的四舍五入，round(1.5)=2，round(2.5)=3。 Python3中，对round()函数有较大改动，例如round(1.5)=2，而round(2.5)却等于2，只有round(2.6)才等于3，这是为什么呢？ 原来Python2中的round()是四舍五入，而到了3，round()就变成了“四舍六入五成双”。 这让我想起了大二时候的大物实验，第一节就讲了计数方法，其中印象最深刻的就是这个“四舍六入五成双”，它的作用是让统计数据更公平，降低
python3.0 round函数
vickylolo的博客
07-21 502
round(0.4)=0 round(0.5)=0 round(0.6)=1 round(1.5)=2 round(2.5)=2 这种方法叫“四舍六入五成双”，是为了避免在大量数据统计时舍入误差引起整体的偏移
Python浮点数四舍五入问题的分析与解决方法
01-02
网上有人说，因为在计算机里面，小数是不精确的，例如 1.115 在计算机中实际上是 1.114999999999999991182，所以当你对这个小数精确到小数点后两位的时候，实际上小数点后第三位是 4，所以四舍五入，结果为 1.11. ...
python 浮点数四舍五入需要注意的地方
09-16
在Python中，四舍五入通常使用内置函数`round()`或第三方库如NumPy的`np.round()`来实现。然而，这些函数在处理特定值，特别是涉及到0.5时，遵循一种称为“银行家舍入”或“偶数舍入”的规则。 在Python 3中，`...
python怎样使得数值四舍五入？超简单的方法来了
m0_59236602的博客
09-14 2169
有很多学习python开发语言的小伙伴们想知道在python中如何取四舍五入？那么小编就通过这篇文章给大家分享一个python中四舍五入的实现方法。
Python round() 函数
weixin_33881140的博客
10-17 649
描述 round() 函数返回浮点数x的四舍五入值。 语法 以下是 round() 方法的语法: round( x [, n] ) 参数 x -- 数值表达式。 n -- 数值表达式，保留几位小数 返回值 返回浮点数x的四舍五入值。 实例 以下展示了使用 round() 方法的实例： #!/usr/bin/python3 prin...
谈谈关于Python里面小数点精度控制的问题
weixin_30770783的博客
11-01 1216
基础 浮点数是用机器上浮点数的本机双精度(64 bit)表示的。提供大约17位的精度和范围从-308到308的指数。和C语言里面的double类型相同。Python不支持32bit的单精度浮点数。如果程序需要精确控制区间和数字精度，可以考虑使用numpy扩展库。 Python 3.X对于浮点数默认的是提供17位数字的精度。 关于单精度和双精度的通俗解释： 单精度型和双精度型，其...
python中round() 四舍五入
hllyzms的博客
03-18 5160
注意在Python3中 ，round()函数并不是四舍五入，而是四舍六入五成双 五成双的意思是，高位为单数则进1凑成双数，高位为双数则不进位。 但是也不都是 如 ，最高位是4 双数 4.05 就不进位 num = 1 dd = round(4.050000190734863,num) ss = round(4.05,num) print(dd,ss,dd == ss) # 4.1 4.0 False 高位为单数则进1凑成双数 但是下面 5.05 保留一位 就变成了 5.0 num = 1 ..
python3 四舍五入实现--简单易用（非round）
wayne17的博客
06-06 985
round()，四舍六入五平分，无法满足要求，int( )只舍不进也不满足要求。下面使用 decimal 包实现严格四舍五入： 负数也适用，代码是长了点，贵在可以直接用。
python3巨坑：round函数四舍六入五平分（附四舍五入的方法）
是真想不出昵称啊的博客
08-16 7062
python3中round()对浮点数的取舍遵循的是四舍六入五平分 ，“五平分”就是根据取舍的位数前的小数奇偶性来判断，奇偶平分。奇数则舍弃，偶数则加一。 例如： round(2.135, 2) round(2.145, 2) 输出结果为 2.13 2.15 那么如何在python中实现四舍五入？ 我们可以使用Python提供的decimal模块。用于十进制数学计算，它具有以下特点： 1.提供...
Python3 笔记：三种取整方式
Catherine_CSDN_的博客
05-30 626
取整方式包括向下取整、四舍五入取整、向上取整等。
Python精准四舍五入与小数位数处理详解
- 这是最常见的四舍五入函数，但它的精度较低，且容易引发意外的结果。比如`round(0.5) == 0`，而不是1。因此，除非必要，应尽量避免直接使用。 **截断保留n位小数**可以通过切片操作实现，但这种方式并不四舍五入...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

XerCis

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值