如何在Python中对数字进行四舍五入

如何在Python中对数字进行四舍五入

这是大数据时代，在这个时代，每天都有新的公司试图利用他们的信息来做出更好的选择。许多企业正在使用Python强大的数据科学环境来分析他们的数据，正如Python在数据分析领域的日益流行所表明的那样。

每个数据科学家都应该意识到数据集可能存在偏差。基于有偏数据得出的结论可能会导致昂贵的错误。

偏差可以通过多种方式进入数据集。如果我们正式学过统计学，我们肯定熟悉像报告偏差、样本偏差和选择偏差这样的术语。在处理定量数据时，另一个需要考虑的重要偏差是四舍五入偏差。

内置round()函数

Python中的round()方法接受两个数值输入，n和ndigits，并将给定的n四舍五入到ndigits，返回结果。因为ndigits选项默认设置为0，如果省略它，将得到一个四舍五入到最近整数的值。正如我们将看到的，round()并不总是按预期运行。

假设我们希望将一个数字四舍五入到最近的4.5。数字将四舍五入到最接近的整数，即5。另一方面，数字4.74将减少到一个小数位，得到4.7。

当处理具有多个小数位的浮点数时，快速而简单地对数字进行四舍五入非常重要。Python的round()函数使得事情变得简单直接。

语法：

round(number, number of digits)

参数：

1. 数字： 这是将被取整的数字。
2. 小数位数（可选）： 要将提供的数字取整到的小数位数。

代码

# Rounding integers
print (round(17))

# For floating type
print (round(23.71))  

# giving second parameter also

# when the last digit is equal to 5 
print (round(7.465845, 5)) 

# when the last digit is greater than 5 
print (round(7.47786, 4))   

# when the last digit is less than 5 
print (round(7.473772, 5))

输出：

17
24
7.46584
7.4779
7.47377

在某些情况下，round()函数的行为不符合预期。

代码

print (round(1.5))
print (round(2))
print (round(2.5))

输出：

2
2
2

round()算法会将1.5四舍五入为2，将2.5四舍五入为2。这不是错误，这是round()算法的工作原理。

截断小数

截断是一种通过将数字减少到特定小数位数来四舍五入的最简单方法之一。在该算法中，将特定位置右边的每个数字替换为0。truncate()函数适用于正数和负数。

我们可以使用以下方法来创建截断函数：

1. 通过将给定数字乘以10的p次方，将小数点向右移动p个位置。
2. 使用int()函数获取更新后数字的整数部分。
3. 通过除以10的p次方，将小数点向左移动p个位置。

代码

# first define truncate function
# setting default decimal places to 0, it will truncate all the decimal places and will return integer part only

def truncate(n, decimal_place = 0):
    v = 10 ** decimal_place
    return int(n * v) / v

print(truncate(56.9))
print(truncate(-7.396, 1))
print(truncate(8.525, 2))

# if we pass negative number in second argument it will truncate n towards left
print(truncate(535.643, -1))
print(truncate(-56236.753, -4))

输出：

56.0
-7.3
8.52
530.0
-50000.0

trunc()方法，通常被称为截断函数，是一个Python Math函数，它从表达式中移除小数值并返回整数结果。因为这个函数是Python math包的一部分，我们必须导入math来使用它。

语法

math.trunc(number)

只有一个参数的操作。在这种情况下，数可以是正数也可以是负数。

代码

import math 
n = 45.3467
#using inbuilt trunc function of math module to truncate decimals of n
print("Truncated number is: ", math.trunc(n))

输出：

Truncated number is:  45

向上取整

另一种方法是”向上取整”，它涉及将一个值舍入到特定的数字。例如：

在数学中，术语“ceiling”通常用来描述大于某个数或等于某个数的最接近的整数。在本教程中，我们将使用两个函数进行“向上取整”，即ceil()函数和math()操作。

在两个连续的整数之间，存在一个非整数的值。考虑值6.2，它将落在6和7之间。天花板是区间的上端点，而地板是其下端点。因此，6.2的天花板是7，6.2的地板是6。

Python的math.ceil()方法用于应用天花板方法。它通常返回最接近给定数的整数，该整数大于或等于给定数。

代码

import math

c1 = math.ceil(6.2)
print( "Ceiling for 6.2: ", c1)
c2 = math.ceil(6)
print( "Ceiling for 6: ", c2)
c3 = math.ceil(-0.8)
print( "Ceiling for -0.8: ", c3)

输出:

Ceiling for 6.2:  7
Ceiling for 6:  6
Ceiling for -0.8:  0

让我们专注于使用 round_up() 函数执行“向上取整”方法的代码:

我们可以使用以下方法来创建向上取整的函数:

1. 首先，将 num 乘以 10 ** decimal_place; 将 num 的小数位置向右移动适当的位置数。
2. 使用 math.ceil() 模块，将结果数向上舍入到最接近的整数。
3. 最后，通过将结果数除以 10 ** decimal_place，将小数位置推回到左边。

代码

# importing the required library
import math

# defining a function to round up decimals
def round_up(num, decimal_place = 0): 
    cons = 10 ** decimal_place 
    return math.ceil(num * cons) / cons

# applying on positive numbers
print(round_up(5.1))
print(round_up(5.73, 1))
print(round_up(5.246, 2))

# applying on negative numbers
print(round_up(46.25, -1))
print(round_up(754.357, -2))

输出：

6.0
5.8
5.25
50.0
800.0

向上取整通常将一个值沿着数轴向右移动，而向下取整通常将一个值向左移动。

向下取整

我们有一种称为向下取整的方法，类似于向上取整。

在Python中，我们可以使用截断或四舍五入的相同机制将数值向下四舍五入。在对整数进行四舍五入之前，我们必须首先移动小数点。最后，返回小数点。

一旦小数点被移动，我们可以使用math.ceil()来将数值向上舍入到最接近的整数。要”向下四舍五入”，我们必须在将小数点重新定位后先将结果数值舍入到最接近的整数。

math.floor()提供了一个小于或等于指定数值的最小整数。

代码

import math

c1 = math.floor(6.2)
print( "Floor value for 6.2: ", c1)
c2 = math.floor(6)
print( "Floor value for 6: ", c2)
c3 = math.floor(-0.8)
print( "Floor value for -0.8: ", c3)

输出：

Floor value for 6.2:  6
Floor value for 6:  6
Floor value for -0.8:  -1

我们可以使用以下方法来实现向下取整函数：

1. 首先，通过将n乘以10 ** 小数位数，将num中的小数位置向右移动适当数量的空格。
2. 使用math.floor，将得到的数字向上舍入到最接近的整数 ().
3. 最后，通过将得到的数字除以10 ** 小数位数，将小数位数移到左边。

代码

# importing the required library
import math

# defining a function to round down decimals
def round_down(num, decimal_place = 0):
    cons = 10 ** decimal_place
    return math.floor(num * cons) / cons

# applying function on positive and negative values
print(round_down(4.6))
print(round_down(3.74, 1))
print(round_down(-5.7))

输出：

4.0
3.7
-6.0

四舍五入偏差

有三种四舍五入技术：truncate()、round_down()和round_up()。对于维持特定数字的一定精度水平来说，这三种策略都是相当基本的。

truncate()、round_down()和round_up()之间存在一种关键区别，这显示了四舍五入的一个重要组成部分：关于零的对称。

请记住，round_up()在零附近是不对称的。在数学中，如果对于任何n的值，函数f(n) + f(-n) = 0，那么函数f(n)关于零是对称的。例如，round_up(5.5)返回6，而round_up(-5.5)返回-5。round_down()和round_up()函数都不具有关于0的对称性。

相反，truncate()方法在零附近是对称的。这是因为truncate()在将小数点位置移到右边后会删除剩余的数字。当原始数字是正数时，这相当于将值向下推。负数会被四舍五入上。因此，truncate(5.5)得到5，而truncate(-5.5)得到-5。

通过对称性原理引入了四舍五入偏差的概念，该原理概述了四舍五入对数据集中的数值的影响。

由于在正无穷的路径上始终向上舍入数值，因此“向上舍入”的方法具有对正无穷的偏差。同样地，“向下舍入”的技术具有对负无穷的偏差。

对于正数，”截断”技术对负无穷具有偏差，而对于负数，它具有对正无穷的偏差。总的来说，具有这种倾向的舍入算法被认为具有对零的偏差。

让我们看看它在实践中是如何工作的。以下面的浮点数列表为例：

numeric_values = [3.52, -5.36, 0.96, -2.63, 8.24, -9.43, 6.35, 5.86]

让我们使用 statistics.mean() 函数来计算 numeric_values 的平均值。

代码

import statistics

mean = statistics.mean(numeric_values)
print ("original mean: ", mean)

输出：

original mean:  0.93875

现在，使用列表推导式，在数字值列表的每个数字上执行truncate()、round_down()和round_up()以将数字舍入到小数点后一位，并计算修订后的平均值：

代码

roundingUp_data = [round_up(x, 1) for x in numeric_values]
print(roundingUp_data)
print ("Rounded up mean: ", statistics.mean(roundingUp_data))

roundingDown_data = [round_down(x, 1) for x in numeric_values]
print ("Rounded dwn mean: ", statistics.mean(roundingDown_data))


truncate_data = [truncate(x, 1) for x in numeric_values]
print ("Truncated mean: ", statistics.mean(truncate_data))

输出：

[3.6, -5.3, 1.0, -2.6, 8.3, -9.4, 6.4, 5.9]
Rounded up mean:  0.9875000000000002
Rounded dwn mean:  0.8874999999999998
Truncated mean:  0.9249999999999998

当numeric_values中的值被四舍五入时，修正后的均值为0.98、0.88和0.924。向下舍入将平均值降低到约0.887。截断数字的平均值约为0.924，最接近原始均值。

这并不意味着当保持均值尽可能接近时我们必须在舍入不同值时进行截断。结果是正负数比近似为1。对于所有正数的集合，truncate()方法的行为类似于round_up()，对于所有负数的集合，它的行为类似于round_down()。

此例说明了舍入偏差对由舍入数据生成的数字的影响。在从舍入数据中进行推断时，我们需要承担这些后果。

在舍入时，通常我们希望舍入到最接近的一定精度的数字，而不仅仅是向上或向下舍入。

如果我们被要求将数字2.63和2.68舍入到最接近的小数位，我们很可能会选择2.6和2.7。而truncate()、round_down()和round_up()方法则不会执行类似的操作。

记住的要点

在收集完成后舍入数据

如果我们处理的是大量的信息，存储可能会成为一个挑战。例如，在工业炉中，将使用温度监控器以八位小数记录每20秒的温度。这些值将有助于避免可能导致任何热源或元件出现故障的过度振荡。使用Python脚本，我们可以检查这些测量值，并寻找较大的波动。

因为测量值是每天进行一次，所以会有很多。保留3位小数的精度是一个选择。然而，消除太多的特定性可能会导致计算变化。如果我们有足够的空间，可以轻松地以完全准确的方式存储所有数据。当容量有限时，最好保留至少2或3个小数位的精度。

最后，一旦计算出每日平均温度，将该值四舍五入到最高精度。

减少误差

在对大型数据集进行复杂计算时舍入数字时，最重要的是要注意错误的增长。