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
关注
Python中四舍五入的讲解
hmh4640219的博客
01-15 8142
round()函数 （注意：下面的我也不清楚是否正确，我只是发表一下我的观点） 对于简单的舍入运算，使用内置的 round(value, ndigits) 函数即可 强烈建议不要去深究，就直接得结果就好 ndigiths可以为正数，也可以为负数，还可以为0,可以为空 n：就是精确到第n位小数，对整数没有影响，1为精确到十分位（注意:小数就是从十分位往后推的） -n：就是精确到整数位，-1为精确到十位，然后就是百位千位…有小数位就全舍掉，不管多大，但会保留一个为0的小数位 0：精确到个位，但会保留一个为0的
你真的搞懂了Python中的四舍五入吗？1.45保留小数点后1位，四舍五入得多少？
Python实践 专攻重难点
11-23 3983
先来看看Python内置的四舍五入函数： round(x, n) 该函数返回传入的x数值（浮点型或整型）的四舍五入值； 参数n表示对x进行四舍五入时保留/参考的数位精度； 参数n可以不传入，此时其默认值为0，但若传入的话，则必须为整型； 当n为0时，返回的结果为整型，n为负整数或正整数时，返回值的数值类型与传入的x数值的类型一样（整型或者浮点型）； 若n为正整数，则表示四舍五入时保留/参考的小...
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()函数只有一个参数，不指定位数的时候，返回一个整数，而且是最靠近的整数，类似于四
python3 四舍五入
长门有希的博客
08-01 386
from decimal import Decimal, ROUND_HALF_UP print(Decimal('0.344').quantize(Decimal('0.0'), rounding=ROUND_HALF_UP))
python四舍五入取整数
最新发布
Dxy1239310216的博客
08-02 661
在Python中，如果你想要对一个浮点数进行四舍五入并取整（即只保留整数部分），你可以使用内置的round()函数，但不指定第二个参数（即小数位数），或者明确指定为0。这样，Python就会将浮点数四舍五入到最接近的整数。
Python3 里面的四舍五入
Luxmlb的博客
06-08 346
Python3 里面的四舍五入
Python3 round() 函数
weixin_30487701的博客
03-05 163
Python3round() 函数 Python3 数字 描述 round()方法返回浮点数x的四舍五入值。 语法 以下是 round() 方法的语法: round( x [, n] ) 参数 x -- 数字表达式。 n -- 表示从小数点位数，其中 x 需要四舍五入，默认值为 0。 返回值 返回浮点数x的四舍五入值。 实例 以下展示了...
python3 四舍五入实现--简单易用（非round）
wayne17的博客
06-06 997
round()，四舍六入五平分，无法满足要求，int( )只舍不进也不满足要求。下面使用 decimal 包实现严格四舍五入： 负数也适用，代码是长了点，贵在可以直接用。
python round_Python3 round() 函数
weixin_39628594的博客
11-30 170
Python3 round() 函数
python实现我们通常所了解的四舍五入，大于或等于5入，解决round()函数不完全四舍五入的问题
05-11
python实现我们通常所了解的四舍五入，大于或等于5入，解决round()函数不完全四舍五入的问题；使用方法 把文件放在python模块文件夹里 使用时: import sswr sswr.sswr(num,ws) #unm为要四舍五入的数，ws为保留小数...
Python round() 函数
weixin_33881140的博客
10-17 653
描述 round() 函数返回浮点数x的四舍五入值。 语法 以下是 round() 方法的语法: round( x [, n] ) 参数 x -- 数值表达式。 n -- 数值表达式，保留几位小数 返回值 返回浮点数x的四舍五入值。 实例 以下展示了使用 round() 方法的实例： #!/usr/bin/python3 prin...
python3 round_Python3 round() 函数
weixin_39531635的博客
12-15 96
Python3 round() 函数描述round() 方法返回浮点数x的四舍五入值。语法以下是 round() 方法的语法:round(x[,n])参数x -- 数字表达式。n -- 表示从小数点位数，其中 x 需要四舍五入，默认值为 0。返回值返回浮点数x的四舍五入值。实例以下展示了使用 round() 方法的实例：#!/usr/bin/python3print("round(7...
python3 round函数
Ibelievesunshine的博客
01-15 608
round函数：对给定的数进行四舍五入，只有一个参数的情况下，是将其四舍五入后为整型，第二个参数是保留几位小数 a = round(2.523456) print(a) print('a的类型',type(a)) b =round(2.523456,1) print(b) print('b的类型',type(b)) c =round(2.523456,2) print(c) print('c的...
python3中round函数_Python3
weixin_42612405的博客
01-29 614
Python3 round() 函数描述round() 方法返回浮点数x的四舍五入值。语法以下是 round() 方法的语法:round( x [, n] )参数x -- 数值表达式。n -- 数值表达式。返回值返回浮点数x的四舍五入值。实例以下展示了使用 round() 方法的实例：#!/usr/bin/python3print ("round(70.23456) : ", round(70....
python3中round的用法_浅谈python3中的round函数
weixin_39593593的博客
12-15 1259
在很多人眼里，round可能是一个四舍五入函数，但到了python3当中并没有你想的那么简单，这已经不再是一个高精度的四舍五入函数了，可能计算的结果会让你出乎意料。首先看一段代码：# coding=utf-8a = 1.2345b = 1.23456c = 1.2335print(str(a) + "取后三位结果: " + str(round(a, 3)))print(str(b) + "取后三位...
Python3内置的round()函数
skyucca的博客
01-14 446
【代码】Python3内置的round()函数。
python3：小数位的四舍五入（用两种方法解决round 遇5不进）
热门推荐
上海 彭彭
11-07 4万+
小数位的四舍五入在项目中经常用到，今天群里有人提出1.325 如何才能变成1.33? 当时我一看这么简单，分秒就可以解决： 我回复是这样的的 round(1.315,2) 有个小伙伴 当时就回复： 他要的结果是 1.32， 你打印出是1.31，我看到我想怎么可能呢，我自己运行下， 结果真是1.31 . 我想都没有想，自认为我是对的，好吧，怪不得开发不能测试自己的代码. 我就开始查找原因，我们通过...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

XerCis

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

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

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

打赏作者

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

抵扣说明：

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

余额充值