第三章 decimal模块

1. decimal 模块介绍

decimal 模块是 Python 提供的用于进行十进制定点和浮点运算的内置模块。使用它可以快速正确地进行十进制定点和浮点数的舍入运算，并且可以控制有效数字的个数。

使用 decimal 模块主要是因为它与 Python 自带的浮点数相比，有以下优点 ：

• 基于浮点模型，提供与数字计算相同的一些方法。

• 可以准确表示十进制浮点数字。而 Python 自带的浮点数，对于小数的表示并不精确，例如，1.1+2.2 的结果为 3.3000000000000003，这显然不是我们需要的。

• decimal 模块可以保留尾随零。例如，使用 Python 自带的浮点数运算时，1.10+1.20=2.3，而使用 decimal 模块则可以得到 2.30 的结果。

• 使用 decimal 模块时，用户可以更改精度（默认为 28 位）。

• 综合以上优点，在需要进行精确计算时，建议采用 decimal 模块。

2. 常数，decimal 提供的常量

说明：这里的精度指用于控制小数点后数字的位数。如果精度为 4，则小数点后应该是 3 位。

输出当前系统的 decimal 相关常量。分别输出 decimal.MAX_PREC、decimal.MAX_EMAX、decimal.MIN_EMIN、decimal.MIN_ETINY、decimal.HAVE_THREADS 的值，代码如下：

import decimal

print('decimal.MAX_PREC：',decimal.MAX_PREC)
print('decimal.MAX_EMAX：',decimal.MAX_EMAX)
print('decimal.MIN_EMIN：',decimal.MIN_EMIN)
print('decimal.MIN_ETINY：',decimal.MIN_ETINY)
print('decimal.HAVE_THREADS：',decimal.HAVE_THREADS)

3. 舍入模式，指定精度截取时的舍入模式

指定不同的舍入模式。使用 Decimal 对象的 to_integral_value() 方法将浮点数转换为整数时，指定不同的舍入模式，代码如下：

import decimal 			# 导入十进制定点和浮点运算模块

print(‘靠近零：',decimal.Decimal(‘3.14’).to_integral_value(decimal.ROUND_HALF_DOWN))
print(‘远离零：',decimal.Decimal(‘3.14’).to_integral_value(decimal.ROUND_UP))   

4. getcontext()方法，获取活动线程的当前上下文

decimal 模块的 getcontext() 方法用于返回活动线程的当前上下文。语法格式如下：

decimal.getcontext()

参数说明：

• 返回值：Context 对象。包含了如下属性。

获取活动线程的当前上下文并输出，代码如下：

import decimal             			# 导入十进制定点和浮点运算模块
print(decimal.getcontext())  

5. setcontext()方法，设置活动线程的当前上下文

decimal 模块的 setcontext() 方法用于设置活动线程的当前上下文。语法格式如下：

decimal.setcontext(c)

参数说明：

• c ：decimal.Context 对象，其中包括如表3 所示的属性。

• 返回值：无。

自定义活动线程的当前上下文，然后再获取设置后的当前上下文 ，代码如下：

import decimal   					# 导入十进制定点和浮点运算模块

c = decimal.Context(
prec=28, rounding=decimal.ROUND_UP,
traps=[decimal.DivisionByZero, decimal.Overflow, decimal.InvalidOperation],
flags=[],
Emax=999999,
Emin=-999999,
capitals=1,
clamp=0
)                      				# 创建decimal.Context对象

decimal.setcontext(c)        		# 设置活动线程的当前上下文
print(decimal.getcontext())    		# 打印活动线程的当前上下文

6. localcontext()方法，返回一个上下文管理器

decimal 模块的 localcontext() 方法用于返回一个上下文管理器。语法格式如下：

decimal.localcontext(ctx=None)

参数说明：

• ctx ：decimal.Context 对象。如果未指定上下文，则使用当前上下文的副本。可以通过 decimal 模块提供的内置上下文类（包括如表4 所示）指定，也可以通过创建自定义的 decimal.Context类的对象指定。

• 返回值：decimal.ContextManager 对象，可以通过 with 语句遍历输出。

使用 localcontext() 方法获取并遍历上下文管理器，代码如下：

import decimal             	# 导入十进制定点和浮点运算模块
with decimal.localcontext(decimal.BasicContext) as ctx:
print(ctx)         			# 打印上下文管理器中的上下文对象

7. Decimal类，浮点模型类

Decimal 类是浮点模型类。实例化 Decimal 类的对象的语法格式如下：

decimal.Decimal(value="0", context=None)

参数说明：

• value ：可以是整数、字符串、元组、浮点数（float）或另一个 Decimal 对象。如果省略 value， 则返回 Decimal( ‘0’ )。如果 value 值是一个字符串，它应该在前导和尾随空格字符以及下划线被删除之后符合十进制数字字符串语法。

• context ：指定一个上下文对象。

• 返回值：Decimal 对象。

方法一：

首先使用 from…import 语句导入 decimal 模块，然后传递不同类型的参数创建 Decimal 类的对象，代码如下：

from decimal import *                            		# 导入十进制定点和浮点运算模块

print(Decimal(7))                                  		# 打印整型参数
print(Decimal(‘0.1’))                           		# 打印字符串类型参数
print(Decimal(0.1))                             		# 打印浮点类型参数
print(Decimal((1, (1, 7, 3, 2), -3)))        			# 打印元组类型参数

方法二：

首先使用 import 语句导入 decimal 模块，然后传递不同类型的参数创建 Decimal 类的对象，代码如下：

import decimal                                          # 导入十进制定点和浮点运算模块

print(decimal.Decimal(7))                             	# 打印整型参数
print(decimal.Decimal(‘0.1’))                       	# 打印字符串类型参数
print(decimal.Decimal(0.1))                 			# 打印浮点类型参数
print(decimal.Decimal((1, (1, 7, 3, 2), -3)))     		# 打印元组类型参数

说明：使用方法二的代码可以输出和方法一一样的运行结果。所不同的是：使用 from…import 语句导入模块后，实例化类的对象时，不需要再带上模块名。因此，推荐采用“方法一”。

比较对 Decimal 对象运算和对整数运算的区别:

首先通过 Decimal 对象对整数 -9 和 4 进行求余运算，然后直接对整数 -9 和 4 进行求余运算，代码如下：

from decimal import *                      			# 导入十进制定点和浮点运算模块

print(Decimal(-9) % +Decimal(4))        			# 通过Decimal对象对整数-9和4求余
print((-9) % 4)                                		# 直接对整数-9和4求余

说明：当对 Decimal 对象进行求余运算时，结果的符号与被除数的符号一致；而使用 % 直接对整数进行求余运算时，则相反，结果的符号与除数的符号一致。

8. adjusted()方法，返回最高有效位相对于小数点的位置

Decimal 类中的 adjusted() 方法用于返回最高有效位相对于小数点的位置。语法格式如下：

Decimal对象名.adjusted()

参数说明：

• 返回值：返回最高有效位相对于小数点的位置。

使用 adjusted() 方法获取最高有效位相对于小数点的位置，代码如下：

from decimal import *                            	# 导入十进制定点和浮点运算模块

decimal_object = Decimal(‘321e+5’)           		# 创建 Decimal对象
print(decimal_object)                             	# 打印对象结果
print(decimal_object.adjusted())                	# 打印最高有效位相对于小数点的位置

9. as_integer_ratio()方法，以元组形式返回对应的分数

Decimal 类中的 as_integer_ratio() 方法用于获取以元组形式返回 Decimal 实例所对应的分数。语法格式如下：

Decimal对象名.as_integer_ratio()

参数说明：

• 返回值：以元组形式返回 Decimal 实例所对应的分数。

使用 as_integer_ratio() 方法获取 Decimal 实例所对应的元组类型分数，代码如下：

from decimal import *                            	# 导入十进制定点和浮点运算模块

decimal_object = Decimal(‘-3.14’)             		# 创建Decimal对象
print(decimal_object.as_integer_ratio())      		# 打印对应元组形式的分数

说明：结果中的元组信息等同于 (-157)/50。

10. as_tuple()方法，返回一个数字的命名元组

Decimal 类中的 as_tuple() 方法用于获取 Decimal 对象中数字的命名元组。语法格式如下：

Decimal对象名.as_tuple()

参数说明：

• 返回值：返回一个数字的命名元组。

使用 as_tuple() 方法获取 Decimal 对象中数字的命名元组，代码如下：

from decimal import *                      	# 导入十进制定点和浮点运算模块

decimal_object = Decimal(‘-3.14’)        	# 创建 Decimal对象
print(decimal_object.as_tuple())          	# 打印 Decimal对象中数字的命名元组

11. canonical()方法，返回参数的规范编码

Decimal 类中的 canonical() 方法用于获取 Decimal 实例中参数的规范编码，由于 Decimal 实例中参数编码始终是规范的，所以调用 canonical() 方法将返回 Decimal 实例中的参数。语法格式如下：

Decimal对象名.canonical()

参数说明：

• 返回值：返回 Decimal 实例中参数的规范编码。

使用 canonical() 方法获取 Decimal 实例中的参数，代码如下：

from decimal import *                            	# 导入十进制定点和浮点运算模块

decimal_object = Decimal(‘-3.14’)             		# 创建Decimal对象
print(decimal_object.canonical())              		# 打印Decimal对象中的参数

12. compare()方法，比较两个 Decimal实例的值

Decimal 类中的 compare() 方法用于比较两个 Decimal 实例的值。在比较时，如果 Decimal 实例a 小于 Decimal 实例 b 时，返回 Decimal 类型的 -1 值；当 a 等于 b 时，将返回 Decimal 类型的 0 值；当 a 大于 b 时，将返回 Decimal 类型的 1 值；当 Decimal 实例 a 或 b 为 NaN 时，此时比较的结果为Decimal 类型的 NaN 值。语法格式如下：

Decimal对象名.compare(other, context=None)

参数说明：

• other ：表示需要进行比较的 Decimal 实例。

• context ：指定一个上下文对象。

• 返回值：a<b 时返回 Decimal( ‘-1’ ) ；a==b 时返回 Decimal( ‘0’ ) ；a>b 时返回 Decimal( ‘1’ ) ；a 或 b 为 NaN 时返回 Decimal( ‘NaN’ )。

使用 compare() 方法比较两个 Decimal 实例的值，代码如下：

from decimal import *           		# 导入十进制定点和浮点运算模块

a = Decimal(‘-3.14’)              		# 创建Decimal对象a
b = Decimal(‘0’)                   		# 创建Decimal对象b
print(a.compare(b))                		# 打印比较结果

13. compare_signal()方法，比较两个非NaN的值

Decimal 类中的 compare_signal() 方法与 compare() 方法相同，只是 compare_signal() 方法不能进行 NaN 值的比较。语法格式如下：

Decimal对象名.compare_signal(other, context=None)

参数说明：

• other ：表示需要进行比较的 Decimal 实例。

• context ：指定一个上下文对象。

• 返回值：a<b 时返回 Decimal( ‘-1’ ) ；a==b 时返回 Decimal( ‘0’ ) ；a>b 时返回 Decimal( ‘1’ )，如果 a、b 中有一个操作数为 NaN，将出现异常信息。

使用 compare_signal() 方法比较两个非 NaN 的值，代码如下：

from decimal import *           		# 导入十进制定点和浮点运算模块

a = Decimal(‘-3.14’)              		# 创建Decimal对象a
b = Decimal(‘0’)                    	# 创建Decimal对象b
print(a.compare_signal(b))       		# 打印比较结果

说明：在使用 compare_signal() 方法比较两个值时，如果其中一个值为 NaN，将出现异常信息。

14. compare_total()方法，抽象比较两个操作数的值

Decimal 类中的 compare_total() 方法用于抽象比较两个操作数的值。语法格式如下：

Decimal对象名.compare_total(other, context=None)

参数说明：

• other ：表示需要进行比较的 Decimal 实例。

• context ：指定一个上下文对象。

• 返回值：a<b 时返回 Decimal( ‘-1’ ) ；a==b 时返回 Decimal( ‘0’ ) ；a>b 时返回 Decimal( ‘1’ )。

使用 compare_total() 方法抽象比较两个操作数的值，代码如下：

from decimal import *                      		# 导入十进制定点和浮点运算模块

a = Decimal(‘1.2’)                      		# 创建Decimal对象a
print(a.compare_total(Decimal(‘NaN’)))
print(a.compare_total(Decimal(‘1.0’)))
print(a.compare_total(Decimal(‘1.5’)))
print(a.compare_total(Decimal(‘inf’)))
print(a.compare_total(Decimal(‘1.20’)))

15. compare_total_mag()方法，抽象比较两个数（忽略符号）

Decimal 类中的 compare_total_mag() 方法用于抽象比较两个操作数的值（忽略符号）。语法格式如下：

Decimal对象名.compare_total_mag(other,context=None)

参数说明：

• other ：表示需要进行比较的 Decimal 实例。

• context ：指定一个上下文对象。

• 返回值：在忽略符号的情况下，a<b 时返回 Decimal( ‘-1’ ) ；a==b 时返回 Decimal( ‘0’ ) ；a>b时返回Decimal( ‘1’ )。

使用 compare_total() 方法在忽略符号的情况下，抽象比较两个操作数的值，代码如下：

from decimal import *      						# 导入十进制定点和浮点运算模块

a = Decimal(‘-1.5’)        						# 创建Decimal对象a
print(a.compare_total_mag(Decimal(‘1.0’)))

16. conjugate()方法，返回实例Decimal自己

Decimal 类中的 conjugate() 方法用于获取实例 Decimal 自己。语法格式如下：

Decimal对象名.conjugate()decimal  

参数说明：

• 返回值：实例 Decimal 自己。

使用 conjugate() 方法用获取 Decimal 实例对象自己，代码如下：

from decimal import *      		# 导入十进制定点和浮点运算模块

a = Decimal(‘-3.14’)        	# 创建Decimal对象a
print(a.conjugate())         	# 打印Decimal自己

17. copy_abs()方法，返回参数的绝对值

Decimal 类中的 copy_abs() 方法用于获取 Decimal 实例对象中参数的绝对值。语法格式如下：

Decimal对象名.copy_abs()

参数说明：

• 返回值：返回 Decimal 实例对象中参数的绝对值。

使用 copy_abs() 方法获取 Decimal 实例对象中参数的绝对值，代码如下：

from decimal import *     	# 导入十进制定点和浮点运算模块

a = Decimal(‘-3.14’         # 创建Decimal实例对象a
print(a.copy_abs())         # 打印Decimal实例对象中参数的绝对值

18. copy_negate()方法，返回操作数的相反数的副本

Decimal 类中的 copy_negate() 方法用于返回操作数的相反数的副本。语法格式如下：

Decimal对象名.copy_negate()

参数说明：

• 返回值：返回一个操作数的相反数的副本。

使用 copy_negate() 方法获取一个数的相反数的副本，代码如下：

from decimal import *                 	# 导入十进制定点和浮点运算模块

a = Decimal(‘-1.2’)                     # 创建 Decimal对象a
b = Decimal(‘1.2’)                      # 创建 Decimal对象b
c = Decimal(3.1415926)              	# 创建 Decimal对象c
d = Decimal(-3.1415926)             	# 创建 Decimal对象d
print(a.copy_negate())
print(b.copy_negate())
print(c.copy_negate())
print(d.copy_negate())

19. copy_sign()方法，返回操作数的副本

Decimal 类中的 copy_sign() 方法用于获取操作数的副本，其符号设置为与第二个操作数相同的符号。语法格式如下：

Decimal对象名.copy_sign()

参数说明：

• 返回值：返回第一个操作数的副本，其符号设置为与第二个操作数相同的符号。

使用 copy_sign() 方法获取操作数的副本，代码如下：

from decimal import *      	# 导入十进制定点和浮点运算模块

a = Decimal(‘-3.14’)       	# 创建Decimal实例对象a
b = Decimal(‘2.16’)      	# 创建Decimal实例对象b
print(a.copy_sign(b))     	# 打印Decimal实例对象a的副本，由于第二操作数b为正数，所以副本为正数

20. exp()方法，求以e为底的指数

Decimal 类中的 exp() 方法用于返回给定数字的（自然）指数函数“e**x”的值，结果使用ROUND_HALF_EVEN 舍入模式进行舍入。语法格式如下：

Decimal对象名.exp(context=None)

参数说明：

• 返回值：返回给定数字的（自然）指数函数 e**x 的值。

使用 exp() 方法获取给定数字以 e 为底的指数，代码如下：

from decimal import *           	# 导入十进制定点和浮点运算模块

a = Decimal(‘-3.14’)           		# 创建Decimal实例对象a
b = Decimal(‘2.16’)         		# 创建Decimal实例对象b

print(a.exp())
print(b.exp())

21. fma()方法，返回先乘法后加法的结果值

Decimal 类中的 fma() 方法包含两个参数分别是 other 与 third，其返回的是 selfother+third 的结果值，其中 selfother 的乘积没有进行四舍五入。语法格式如下：

Decimal对象名.fma(other,third,context=None)

参数说明：

• other ：参数为第二个因数。

• third ：参数为第二个加数。

• context ：指定一个上下文对象。

• 返回值：返回先乘法后加法的结果值。

使用 fma() 方法获取先乘法后加法的结果值，代码如下：

from decimal import *           	# 导入十进制定点和浮点运算模块

a = Decimal(‘2.3’).fma(3,5)     	# 指定字符小数值，计算过程2.3*3+5
b = Decimal(2.3).fma(3,5)      		# 指定小数值，计算过程2.2999999999999998223...*3+5
c = Decimal(3).fma(3,5)         	# 指定整数值，计算过程3*3+5

print(a)
print(b)
print(c)

22. from_float()方法，将浮点数转换为十进制的等效值

Decimal 类中的 from_float() 方法用于将浮点数转换为十进制的等效值，该方法并不接受字符型Decimal( ‘0.1’ ) 的值，只接受 Decimal.from_float(0.1) 的值，由于 0.1 在二进制浮点中不能精确表示，因此该值存储为最接近的可表示值，即 0x1.999999999999ap-4。十进制的等效值是 0.1000000000000000055511151231257827021181583404541015625。语法格式如下：

Decimal对象名.from_float(f)

参数说明：

• f ：指定需要转换的浮点值。

• 返回值：返回将浮点数转换为十进制的等效值。

使用 from_float() 方法获取指定值的十进制的等效值，代码如下：

from decimal import *                      		# 导入十进制定点和浮点运算模块

a = Decimal.from_float(0.1)               		# 浮点值
b = Decimal.from_float(float(‘nan’)) 			# 空值
c = Decimal.from_float(float(‘inf’))      		# 正无穷值
d = Decimal.from_float(float(‘-inf’)) 			# 负无穷值

print(a)
print(b)
print(c)
print(d)

23. is_canonical()方法，判断参数是否规范

Decimal 类中的 is_canonical() 方法用于判断 Decimal 实例对象中参数是否规范，如果参数规范将返回 True，否则将返回 False。由于 Decimal 实例总是规范的，所以调用该方法总是返回 True。语法格式如下：

Decimal对象名.is_canonical()

参数说明：

• 返回值：如果 Decimal 实例对象中参数规范将返回 True，否则返回 False。

使用 is_canonical() 方法判断 Decimal 实例对象中参数是否规范，代码如下：

from decimal import *                 	# 导入十进制定点和浮点运算模块

a = Decimal(‘2.3’).fma(3,5)           	# 指定字符小数值，计算过程2.3*3+5
b = Decimal(2.3).fma(3,5)            	# 指定小数值，计算过程2.2999999999999998223...*3+5
c = Decimal(3).fma(3,5)              	# 指定整数值，计算过程3*3+5

print(a.is_canonical())
print(b.is_canonical())
print(c.is_canonical())

24. is_f inite()方法，判断参数是否为有限数

Decimal 类中的 is_finite() 方法用于判断 Decimal 实例对象中参数是否为有限数，如果是将返回True，如果参数为无穷大或 NaN，将返回 False。语法格式如下：

Decimal对象名.is_finite()

参数说明：

• 返回值：如果 Decimal 实例对象中参数是一个有限数将返回 True，如果参数为无穷大或 NaN，将返回 False。

使用 is_finite() 方法判断 Decimal 实例对象中参数是否为有限数，代码如下：

from decimal import *                 	# 导入十进制定点和浮点运算模块

a = Decimal(‘inf’)                 		# 无穷大的值
b = Decimal(‘nan’)                     	# 空值
c = Decimal(‘2.3333333’)             	# 字符小数值
d = Decimal(3.1415926)              	# 小数值

print(a.is_finite())
print(b.is_finite())
print(c.is_finite())
print(d.is_finite())

25. is_inf inite()方法，判断参数是否为正或负无穷大

Decimal 类中的 is_infinite() 方法用于判断 Decimal 实例对象中参数是否为正或负无穷大的值，如果是返回 True，否则返回 False。语法格式如下：

Decimal对象名.is_infinite()

参数说明：

• 返回值：如果 Decimal 实例对象中参数是一个正或负无穷大的值将返回 True，否则将返回 False。

使用 is_infinite() 方法判断 Decimal 实例对象中参数是否是一个正或负无穷大的值，代码如下：

from decimal import *                      		# 导入十进制定点和浮点运算模块

a = Decimal(‘inf’)                      		# 正无穷大的值
b = Decimal(‘-inf’)                           	# 负无穷大的值
c = Decimal(‘nan’)                           	# 空值
d = Decimal(‘2.3333333’)                  		# 字符小数值

print(a.is_infinite())
print(b.is_infinite())
print(c.is_infinite())
print(d.is_infinite())

26. is_nan()方法，判断参数是否为NaN

Decimal 类中的 is_nan() 方法用于判断 Decimal 实例对象中参数是否为 NaN（无论是否静默），如果是返回 True，否则将返回 False。语法格式如下：

Decimal对象名.is_nan()

参数说明：

• 返回值：如果 Decimal 实例对象中参数是 NaN（无论是否静默）值将返回 True，否则将返回False。

使用 is_nan() 方法判断 Decimal 实例对象中参数是否为 NaN，代码如下：decimal

from decimal import *                 	# 导入十进制定点和浮点运算模块

a = Decimal(‘2.3333333’)             	# 字符小数值
b = Decimal(‘nan’)                      # 空值

print(a.is_nan())
print(b.is_nan())

27. is_normal()方法，判断参数是否是 一个正规的有限数

Decimal 类中的 is_normal() 方法用于判断 Decimal 实例对象中参数是否是一个正规的有限数，如果是将返回 True，如果参数是 0、非正规数值、无穷大或 NaN 将返回 False。语法格式如下：

Decimal对象名.is_normal()

参数说明：

• 返回值：如果 Decimal 实例对象中参数是一个正规的有限数将返回 True，否则将返回 False。

使用 is_normal() 方法判断 Decimal 实例对象中参数是否是一个正规的有限数，代码如下：

from decimal import *                        	# 导入十进制定点和浮点运算模块

a = Decimal(‘2.3333333’)                    	# 字符小数值
b = Decimal(‘nan’)                             	# 空值
c = Decimal(‘inf’)                              # 正无穷大的值
d = Decimal(‘-inf’)                             # 负无穷大的值

print(a.is_normal())
print(b.is_normal())
print(c.is_normal())
print(d.is_normal())

28. is_qnan()方法，判断参数是否为静默NaN

Decimal 类中的 is_qnan() 方法用于判断 Decimal 实例对象中参数是否为静默 NaN，如果是将返回 True，否则返回 False。语法格式如下：

Decimal对象名.is_qnan()

参数说明：

• 返回值：如果 Decimal 实例对象中参数为静默 NaN 将返回 True，否则将返回 False。

使用 is_qnan() 方法判断参数是否为静默 NaN，代码如下：

from decimal import *           	# 导入十进制定点和浮点运算模块

a = Decimal(‘nan’)                	# 静默空值
b = Decimal()                     	# 非静默空值

print(a.is_qnan())
print(b.is_qnan())

29. is_signed()方法，判断参数是否带有负号

Decimal 类中的 is_signed() 方法用于判断 Decimal 实例对象中参数是否带有负号。语法格式如下：decimal

Decimal对象名.is_signed()

参数说明：

• 返回值：如果 Decimal 实例对象中参数带有负号，则返回 True，否则返回 False。其中 0 和NaN 都可带有符号。

使用 is_signed() 方法判断 Decimal 实例对象中参数是否带有负号，代码如下：

from decimal import *                 	# 导入十进制定点和浮点运算模块

a = Decimal(‘-nan’)                    	# 带负号空值
b = Decimal(‘-inf’)                     # 负无穷大的值
c= Decimal(‘-0’)                        # 负0值

print(a.is_signed())
print(b.is_signed())
print(c.is_signed())

30. is_snan()方法，判断参数是否为信号NaN

Decimal类中的is_snan()方法用于判断Decimal实例对象中参数是否为信号NaN。语法格式如下：

Decimal对象名.is_snan()

参数说明：

• 返回值：如果 Decimal 实例对象中参数为信号 NaN 则返回 True，否则返回 False。

使用 is_snan() 方法判断 Decimal 实例对象中参数是否为信号 NaN，代码如下：

from decimal import *           	# 导入十进制定点和浮点运算模块

a = Decimal(‘-nan’)               	# 带负号空值
b = Decimal(‘2.50’)               	# 小数值
c = Decimal(‘sNaN’)             	# 信号NaN

print(a.is_snan())
print(b.is_snan())
print(c.is_snan())

31. is_subnormal()方法，判断参数是否为次正规数

Decimal 类中的 is_subnormal() 方法用于判断 Decimal 实例对象中参数是否为次正规数。语法格式如下：

Decimal对象名.is_subnormal(context=None)

参数说明：

• context ：指定一个上下文对象。

• 返回值：如果 Decimal 实例对象中参数为次正规数则返回 True，否则返回 False。

使用 is_subnormal() 方法判断 Decimal 实例对象中参数是否为次正规数，代码如下：

from decimal import *           	# 导入十进制定点和浮点运算模块

a = Decimal(‘-nan’)               	# 带负号空值
b = Decimal(‘2.50’)               	# 小数值
c = Decimal(‘sNaN’)             	# 信号NaN

print(a.is_subnormal())
print(b.is_subnormal())
print(c.is_subnormal())

32. is_zero()方法，判断参数是否为0

Decimal 类中的 is_zero() 方法用于判断 Decimal 实例对象中参数是否为 0（正负都可以）。语法格式如下：

Decimal对象名.is_subnormal()

参数说明：

• 返回值：如果 Decimal 实例对象中参数为 0（正负都可以）则返回 True，否则返回 False。

使用 is_zero() 方法判断 Decimal 实例对象中参数是否为 0，代码如下：

from decimal import *                 	# 导入十进制定点和浮点运算模块

a = Decimal(‘0’)                        # 参数为0
b = Decimal(‘-0’)                       # 参数为-0
c = Decimal(‘nan’)                      # 参数为空
d = Decimal(‘2.50’)                    	# 小数值

print(a.is_zero())
print(b.is_zero())
print(c.is_zero())
print(d.is_zero())

33. ln()方法，返回操作数的自然（底数e）对数

Decimal 类中的 ln() 方法用于获取操作数的自然（底数 e）对数，使用 ROUND_HALF_EVEN 舍入模式获得舍入结果。语法格式如下：

Decimal对象名.ln(context=None)

参数说明：

• context ：指定一个上下文对象。

• 返回值：返回操作数的自然（底数 e）对数。

使用 ln() 方法获取操作数的自然（底数 e）对数，代码如下：

from decimal import *           	# 导入十进制定点和浮点运算模块

a = Decimal(‘0’)                   	# 参数为0
b = Decimal(‘-0’)                 	# 参数为-0
c = Decimal(‘nan’)                	# 参数为空
d = Decimal(‘2.50’)               	# 小数值

print(a.ln())
print(b.ln())
print(c.ln())
print(d.ln())

34. log10()方法，返回操作数的常用对数

Decimal 类中的 log10() 方法用于获取操作数的常用对数，使用 ROUND_HALF_EVEN 舍入模式获得舍入结果。语法格式如下：

Decimal对象名.log10(context=None)

参数说明：

• context ：指定一个上下文对象。

• 返回值：返回操作数的常用对数。

使用 log10() 方法获取操作数的常用对数，即以 10 为底的对数，代码如下：

from decimal import *           		# 导入十进制定点和浮点运算模块

a = Decimal(‘0’)                   		# 参数为0
b = Decimal(‘0.001’)             		# 参数为浮点数
c = Decimal(‘2’)                   		# 参数为整数
d = Decimal(‘inf’)           			# 正无穷大的值

print(a.log10())
print(b.log10())
print(c.log10())
print(d.log10())

35. logb()方法，返回操作数的调整指数

Decimal 类中的 logb() 方法用于获取操作数的调整指数，将非零数字操作数的调整指数作为Decimal 实例返回值。如果操作数为零，则引发 DivisionByZero 异常；如果操作数是无穷大，则返回Decimal( ‘Infinity’ )。语法格式如下：

Decimal对象名.logb(context=None)

参数说明：

• context ：指定一个上下文对象。

• 返回值：返回操作数的调整指数。

使用 logb() 方法获取操作数的调整指数，代码如下：

from decimal import *           	# 导入十进制定点和浮点运算模块

a = Decimal(‘250’)                	# 整数
b = Decimal(‘2.50’)               	# 浮点
c = Decimal(10)                   	# 整型参数

print(a.logb())
print(b.logb())
print(c.logb())

36. logical_and()方法，返回两个操作数的逻辑与运算值

Decimal 类中的 logical_and() 方法用于对两个逻辑操作数进行逻辑与运算。语法格式如下：decimal

Decimal对象名.logical_and(other,context=None)

参数说明：

• context ：指定一个上下文对象。

• other ：另一个逻辑操作数。一个逻辑操作数是一个Decimal实例，其指数和符号均为 0，而其数字位均为 0 或 1。

• 返回值：返回两个操作数进行逻辑与运算的结果。

使用 logical_and() 方法获取两个逻辑操作数进行逻辑与运算的结果。 代码如下：

from decimal import *                 	# 导入十进制定点和浮点运算模块

a = Decimal(‘0’)                        # 逻辑操作数0
b = Decimal(‘1’)                        # 逻辑操作数1
c = Decimal(0)
d = Decimal(1)

print(a.logical_and(Decimal(‘0’)))
print(b.logical_and(Decimal(‘1’)))
print(c.logical_and(Decimal(0)))
print(d.logical_and(Decimal(1)))

37. logical_invert()方法，对操作数按位取反

Decimal 类中的 logical_invert() 方法用于获取操作数的按位取反的结果 。语法格式如下：

Decimal对象名.logical_invert(context=None)

参数说明：

• context ：指定一个上下文对象。

• 返回值：返回对操作数进行按位取反的结果。

使用 logical_invert() 方法获取操作数的按位取反的结果，代码如下：

from decimal import *           	# 导入十进制定点和浮点运算模块

a = Decimal(‘0’)                   	# 操作数0
b = Decimal(‘1’)                   	# 操作数1
c = Decimal(‘111111111’)
d = Decimal(‘101010101’)

print(a.logical_invert())
print(b.logical_invert())
print(c.logical_invert())
print(d.logical_invert())

38. logical_or()方法，返回两个操作数的逻辑或运算值

Decimal 类中的 logical_or() 方法用于对两个操作数进行逻辑或运算。语法格式如下：

Decimal对象名.logical_or(other，context=None)

参数说明：

• context ：指定一个上下文对象。

• other ：另一个逻辑操作数。一个逻辑操作数是一个Decimal实例，其指数和符号均为 0，而其数字位是 0 或 1。

• 返回值：返回对两个操作数进行逻辑或运算的结果。

使用 logical_or() 方法对两个操作数进行逻辑或运算，代码如下：decimal

from decimal import *                 	# 导入十进制定点和浮点运算模块

a = Decimal(‘0’)                        # 逻辑操作数0
b = Decimal(‘1’)                        # 逻辑操作数1

print(a.logical_or(Decimal(‘0’)))
print(a.logical_or(Decimal(‘1’)))
print(b.logical_or(Decimal(‘0’)))
print(b.logical_or(Decimal(‘1’)))

39. logical_xor()方法，返回两个逻辑操作数的异或运算值

Decimal 类中的 logical_xor() 方法用于获取两个逻辑操作数的异或运算值。语法格式如下：

Decimal对象名.logical_xor(other，context=None)

参数说明：

• context ：指定一个上下文对象。

• other ：另一个逻辑操作数。一个逻辑操作数是一个Decimal实例，其指数和符号均为0，而其数字位是0 或 1。

• 返回值：返回两个逻辑操作数的异或运算值。

使用 logical_xor() 方法获取两个逻辑操作数的异或运算值，代码如下：

from decimal import *                 	# 导入十进制定点和浮点运算模块

a = Decimal(‘0’)                        # 逻辑操作数0
b = Decimal(‘1’)                        # 逻辑操作数1

print(a.logical_xor(Decimal(‘0’)))
print(a.logical_xor(Decimal(‘1’)))
print(b.logical_xor(Decimal(‘0’)))
print(b.logical_xor(Decimal(‘1’)))

40. max()方法，返回两个操作数中比较大的一个

Decimal 类中的 max() 方法用于获取两个操作数中比较大的一个操作数。语法格式如下：

Decimal对象名.max(other，context=None)

参数说明：

• context ：指定一个上下文对象。

• other ：另一个操作数。

• 返回值：返回两个操作数中比较大的一个操作数。

使用 max() 方法获取两个操作数中比较大的一个操作数，代码如下：

from decimal import *                 	# 导入十进制定点和浮点运算模块

a = Decimal(‘0’)                        # 操作数0
b = Decimal(‘1’)                        # 操作数1

print(a.max(Decimal(‘-inf’)))
print(a.max(Decimal(‘1’)))
print(b.max(Decimal(‘3.21’)))
print(b.max(Decimal(‘-3.21’)))

41. max_mag()方法，返回两个操作数中绝对值比较大的一个

Decimal 类中的 max_mag() 方法用于获取两个操作数中绝对值比较大的一个数。语法格式如下：

Decimal对象名.max_mag(other，context=None)

参数说明：

• context ：指定一个上下文对象。

• other ：另一个操作数。

• 返回值：返回两个操作数中绝对值比较大的一个操作数。

使用 max_mag() 方法获取两个操作数中绝对值比较大的一个，代码如下：

from decimal import *                      		# 导入十进制定点和浮点运算模块

a = Decimal(‘0’)                              	# 操作数0
b = Decimal(‘1’)                              	# 操作数1

print(a.max_mag(Decimal(‘-inf’)))
print(a.max_mag(Decimal(‘1’)))
print(b.max_mag(Decimal('3.21')))
print(b.max_mag(Decimal('-3.21')))

42. min()方法，返回操作数中比较小的一个

Decimal 类中的 min() 方法用于获取两个操作数中比较小的一个操作数。语法格式如下：

Decimal对象名.min(other，context=None)

参数说明：

• context ：指定一个上下文对象。

• other ：另一个操作数。

• 返回值：返回两个操作数中比较小的一个操作数。

使用 min() 方法获取两个操作数中比较小的一个操作数，代码如下：

from decimal import *                 	# 导入十进制定点和浮点运算模块

a = Decimal(‘0’)                        # 操作数0
b = Decimal(‘1’)                        # 操作数1

print(a.min(Decimal(‘-inf’)))
print(a.min(Decimal(‘1’)))
print(b.min(Decimal(‘3.21’)))
print(b.min(Decimal(‘-3.21’)))

43. min_mag()方法，返回两个操作数中绝对值比较小的一个

Decimal 类中的 min_mag() 方法用于获取两个操作数中绝对值比较小的一个。语法格式如下：

Decimal对象名.min_mag(other，context=None)

参数说明：

• context ：指定一个上下文对象。

• other ：另一个操作数。

• 返回值：返回两个操作数中绝对值比较小的一个操作数。decimal

使用 min_mag() 方法获取两个操作数中绝对值比较小的一个，代码如下：

from decimal import *                      		# 导入十进制定点和浮点运算模块

a = Decimal(‘0’)                              	# 操作数0
b = Decimal(‘1’)                              	# 操作数1

print(a.min_mag(Decimal(‘-inf’)))
print(a.min_mag(Decimal(‘1’)))
print(b.min_mag(Decimal(‘3.21’)))
print(b.min_mag(Decimal(‘-3.21’)))

44. next_minus()方法，返回小于自身的最大可表示数字

Decimal 类中的 next_minus() 方法用于返回小于自身的最大可表示数字。语法格式如下：

Decimal对象名.next_minus(context=None)

参数说明：

• context ：指定一个上下文对象。

• 返回值：返回小于自身的最大可表示数字。

使用 next_minus() 方法获取小于自身的最大可表示数字，代码如下：

from decimal import *                 	# 导入十进制定点和浮点运算模块

a = Decimal(‘0’)                        # 逻辑操作数0
b = Decimal(‘1’)                        # 逻辑操作数1
c = Decimal(‘inf’)                 		# 无穷大
d = Decimal(‘NaN’)                    	# 空值

print(a.next_minus())
print(b.next_minus())
print(c.next_minus())
print(d.next_minus())

45. next_plus()方法，返回大于自身的 最小可表示数字

Decimal 类中的 next_plus() 方法用于返回大于自身的最小可表示数字。语法格式如下：

Decimal对象名.next_plus(context=None)

参数说明：

• context ：指定一个上下文对象。

• 返回值：返回大于自身的最小可表示数字。

使用 next_plus() 方法获取大于自身的最小可表示数字，代码如下：

from decimal import *           	# 导入十进制定点和浮点运算模块

a = Decimal(‘0’)                   	# 逻辑操作数0
b = Decimal(‘1’)                   	# 逻辑操作数1
c = Decimal(‘-inf’)                	# 负无穷大
d = Decimal(‘NaN’)              	# 空值

print(a.next_plus())
print(b.next_plus())
print(c.next_plus())
print(d.next_plus())

46. next_toward()方法，返回一个最接近自身的数字

Decimal 类中的 next_toward() 方法用于获取一个最接近自身的数字，如果两个操作数不相等，则 返回第二个操作数方向上最接近第一个操作数的数字；如果两个操作数在数字上相等，则返回第一个操作数的副本，其中符号设置成与第二个操作数相同的符号。语法格式如下：

Decimal对象名.next_toward(other,context=None)

参数说明：

• context ：指定一个上下文对象。

• other ：另一个操作数。

• 返回值：返回一个最接近自身的数字。

使用 next_toward() 方法获取一个最接近自身的数字，代码如下：

from decimal import *                      		# 导入十进制定点和浮点运算模块

a = Decimal(‘0’)                              	# 操作数0
b = Decimal(‘1’)                              	# 操作数1
c = Decimal(‘-inf’)                           	# 负无穷大
d = Decimal(‘NaN’)                          	# 空值

print(a.next_toward(Decimal(‘1’)))
print(b.next_toward(Decimal(‘2’)))
print(c.next_toward(Decimal(‘-5’)))
print(d.next_toward(Decimal(‘3’)))

47. normalize()方法，去掉最右边的尾随零来标准化数字

Decimal 类中的 normalize() 方法用于获取一个通过去掉最右边的尾随零来标准化数字的值。语法格式如下：

Decimal对象名.normalize(context=None)

参数说明：

• context ：指定一个上下文对象。

• 返回值：返回一个通过去掉最右边的尾随零来标准化数字的值。

使用 normalize() 方法获取一个通过去掉最右边的尾随零来标准化数字的值，代码如下：

from decimal import *      			# 导入十进制定点和浮点运算模块

a = Decimal(‘1.2000’)      			# 浮点多0值
b = Decimal(‘1.000’)
c = Decimal(‘0.0’)
d = Decimal(‘-120.00’)

print(a.normalize())
print(b.normalize())
print(c.normalize())
print(d.normalize())

48. number_class()方法，返回描述操作数类的字符串

Decimal 类中的 number_class() 方法用于获取描述操作数类的字符串。语法格式如下：decimal

Decimal对象名.number_class(context=None)

参数说明：

• context ：指定一个上下文对象。

• 返回值：返回描述操作数类的字符串。

使用 number_class() 方法获取描述操作数类的字符串，代码如下：

from decimal import *           		# 导入十进制定点和浮点运算模块

a = Decimal(‘inf’)           			# 正无穷值
b = Decimal(‘-inf’)                		# 负无穷值
c = Decimal(‘2.5’)           			# 正常值
d = Decimal(‘-2.5’)               		# 负正常值
e = Decimal(‘0’)                   		# 0值
f = Decimal(‘-0’)                  		# -0值
g = Decimal(‘NaN’)              		# NaN值
h = Decimal(‘sNaN’)             		# sNaN值

print(a.number_class())
print(b.number_class())
print(c.number_class())
print(d.number_class())
print(e.number_class())
print(f.number_class())
print(g.number_class())
print(h.number_class())

49. quantize()方法，返回实例操作数舍入的值

Decimal 类中的 quantize() 方法用于获取实例操作数舍入的值，并具有与参数 exp 指定的操作数相同的小数位数 。语法格式如下：

Decimal对象名.quantize(exp,rounding=None,context=None)

参数说明：

• exp ：指定的一个操作数。

• rounding ：舍入模式的有效值，可设为 ROUND_CEILING、ROUND_FLOOR、ROUND_UP、ROUND_ DOWN、ROUND_HALF_UP、ROUND_HALF_DOWN、ROUND_HALF_EVEN、ROUND_05UP等值。

• context ：指定一个上下文对象。

• 返回值：返回实例操作数舍入的值。

使用 quantize() 方法获取一个操作数舍入的值，代码如下：

from decimal import *                      	# 导入十进制定点和浮点运算模块

a = Decimal(‘1.41421356’)                 	# 浮点值
print(a.quantize(Decimal(‘1.000’)))

50. radix()方法，返回Decimal类完成其算术运算的基数

Decimal 类中的 radix() 方法用于获取 Decimal 类完成其算术运算的基数。语法格式如下：

Decimal对象名.radix()

参数说明：

• 返回值：返回 Decimal 类完成其算术运算的基数。decimal

使用 radix() 方法获取 Decimal 类完成其算术运算的基数，代码如下：

from decimal import *                 	# 导入十进制定点和浮点运算模块

a = Decimal(‘1.41421356’)           	# 浮点值
b = Decimal(‘1’)                        # 数值1
c = Decimal(‘0’)                        # 数值0

print(a.radix())
print(b.radix())
print(c.radix())

51. remainder_near()方法，返回一个接近0的余数

Decimal类中的remainder_near()方法用于获取一个接近0的余数，这与self % other的不同之处在于，所选择的余数要使其绝对值最小化。更准确地说，返回值是 self-n*other，其中 n 是最接近 self/other 精确值的整数，如果两个整数相等，则选择偶数。语法格式如下：

Decimal对象名.remainder_near(other,context=None)

参数说明：

• other ：计算余数的另一操作数。

• context ：指定一个上下文对象。

• 返回值：返回一个接近 0 的余数。

使用 remainder_near() 方法获取一个接近 0 的余数，代码如下：

from decimal import *                 	# 导入十进制定点和浮点运算模块

a = Decimal(18)                        	# 整数值
b = Decimal(25)
c = Decimal(35)

print(a.remainder_near(10))
print(b.remainder_near(10))
print(c.remainder_near(10))

52. rotate()方法，将数字循环移位指定次数

Decimal 类中的 rotate() 方法用于将数字循环移位指定次数，第一个参数必须是 -precision 至 precision精度范围内的整数，其绝对值给出了要循环移位的次数。语法格式如下：

Decimal对象名.rotate(other,context=None)

参数说明：

• other ：指定循环移位的次数。

• context ：指定一个上下文对象。

• 返回值：返回将数字循环移位指定次数的结果。

使用 rotate() 方法获取将操作数循环移位指定次数的结果，代码如下：

from decimal import *           	# 导入十进制定点和浮点运算模块

a = Decimal(1)                    	# 整值
b = Decimal(1.0000)             	# 浮点值

print(a.rotate(1))                  # 向左循环移动1位
print(b.rotate(3))                  # 向左循环移动3位

53. same_quantum()方法，检测两个操作数的指数是否相同

Decimal 类中的 same_quantum() 方法用于检测两个操作数是否具有相同指数或两者是否都为NaN。语法格式如下：

Decimal对象名.same_quantum(other,context=None)

参数说明：

• other ：另一个操作数。

• context ：指定一个上下文对象。

• 返回值：如果两个操作数具有相同指数或两者都为 NaN，则返回 True，否则返回 False。

使用 same_quantum() 方法检测两个操作数是否具有相同指数或两者是否都为 NaN，代码如下：

from decimal import *                 	# 导入十进制定点和浮点运算模块

a = Decimal(1)                          # 整值
b = Decimal(1.0000)                   	# 浮点值
c = Decimal(1.11)                      	# 浮点值
d = Decimal(‘NaN’)                    	# 空值

print(a.same_quantum(0))
print(b.same_quantum(1))
print(c.same_quantum(0))
print(d.same_quantum(0))

54. scaleb()方法，返回乘以10的指定次幂的值

Decimal 类中的 scaleb() 方法用于获取 Decimal 对象中的数乘以 10 的指定次幂（由第一个参数值指定）的值，第一个参数必须是整数。语法格式如下：

Decimal对象名.scaleb(other,context=None)

参数说明：

• other ：第二个操作数，它必须是整数。

• context ：指定一个上下文对象。

• 返回值：返回 Decimal 对象中的数乘以 10 的指定次幂（由第一个参数值指定）的值。

使用 scaleb() 方法获取一个数乘以 10 的指定次幂的值，代码如下：

from decimal import *           	# 导入十进制定点和浮点运算模块

a = Decimal(‘1’)                   	# 整值
b = Decimal(1.0000)             	# 浮点值
c = Decimal(0)                    	# 0值
d = Decimal(-1)                   	# 负值
e = Decimal(‘NaN’)               	# 空值

print(a.scaleb(0))
print(b.scaleb(1))
print(c.scaleb(2))
print(d.scaleb(3))
print(d.scaleb(e))

55. shift()方法，将数字移位指定位数

Decimal类中的shift()方法用于将Decimal对象中的数移位第一个参数所指定的位数。语法格式如下：

Decimal对象名.shift(other,context=None)

参数说明：

• other ：第一个参数，指定位移的位数。

• context ：指定一个上下文对象。

• 返回值：返回将 Decimal 对象中的数移位第一个参数所指定位数的结果。

使用 shift() 方法获取将 Decimal 对象中的数移位第一个参数所指定位数的结果，代码如下：

from decimal import *           	# 导入十进制定点和浮点运算模块

a = Decimal(1)                    	# 整值
b = Decimal(0)                    	# 0值
c = Decimal(-1)                   	# 负值
d = Decimal(‘NaN’)              	# 空值
e = Decimal(1.11)                 	# 浮点值

print(a.shift(2))
print(b.shift(1))
print(c.shift(-1))
print(d.shift(2))
print(e.shift(2))
print(e.shift(-2))

56. sqrt()方法，返回操作数自身的平方根

Decimal 类中的 sqrt() 方法用于获取操作数自身的平方根。语法格式如下：

Decimal对象名.sqrt(context=None)

参数说明：

• context ：指定一个上下文对象。

• 返回值：返回操作数自身的平方根。

使用 sqrt() 方法获取操作数自身的平方根，代码如下：

from decimal import *           	# 导入十进制定点和浮点运算模块

a = Decimal(1)                    	# 整值
b = Decimal(‘3’)                   	# 字符值
c = Decimal(‘NaN’)               	# 空值
d = Decimal(1.11)                	# 浮点值

print(a.sqrt())
print(b.sqrt())
print(c.sqrt())
print(d.sqrt())

57. to_eng_string()方法，转换为工程类型字符串

Decimal 类中的 to_eng_string() 方法用于将操作数转换为工程类型字符串。语法格式如下：decimal

Decimal对象名.to_eng_string(context=None)

参数说明：

• context ：指定一个上下文对象。

• 返回值：返回工程类型的字符串。

使用 to_eng_string() 方法将操作数转换为工程类型字符串，代码如下：

from decimal import *           	# 导入十进制定点和浮点运算模块

a = Decimal(1)                    	# 整值
b = Decimal(‘3’)                   	# 字符值
c = Decimal(‘NaN’)               	# 空值
d = Decimal(1.11)                	# 浮点值
e = Decimal(0.1)

print(a.to_eng_string())
print(b.to_eng_string())
print(c.to_eng_string())
print(d.to_eng_string())
print(e.to_eng_string())

58. to_integral_exact()方法，舍入为最接近的整数（抛异常）

Decimal 类中的 to_integral_exact() 方法用于获取操作数四舍五入为最接近整数的值。语法格式如下：

Decimal对象名.to_integral_exact(rounding=None,context=None)

参数说明：

• rounding ：如果指定该参数将以该模式进行舍入，否则将由指定的 context 参数确定。

• context ：指定一个上下文对象，如果没有指定 rounding 参数，将使用指定上下文对象中的舍入模式，如果两个参数都没有指定，则使用当前上下文的舍入模式。

• 返回值：返回四舍五入后最接近的整数值，该方法会抛出不精确或四舍五入异常。

使用 to_integral_exact() 方法获取操作数四舍五入后最接近整数的值，代码如下：

from decimal import *·              	# 导入十进制定点和浮点运算模块

a = Decimal(7E+3)                     	# 7000值
b = Decimal(5E-3)                     	# 0.005
c = Decimal(1.5)
d = Decimal(0.5)

print(a.to_integral_exact())
print(b.to_integral_exact())
print(c.to_integral_exact())
print(d.to_integral_exact())

59. to_integral_value()方法，舍入为最接近的整数（不抛异常）

Decimal 类中的 to_integral_value() 方法用于获取操作数四舍五入为最接近的整数的值。语法格式如下：

Decimal对象名.to_integral_value(rounding=None,context=None)

参数说明：

• rounding ：如果指定该参数将以该舍入模式进行舍入，否则将由指定的 context 参数确定。

• context ：指定一个上下文对象，如果没有指定 rounding 参数，将使用指定上下文对象中的舍入模式，如果两个参数都没有指定，则使用当前上下文的舍入模式。

• 返回值：返回四舍五入后最接近的整数的值，该方法不会抛出不精确或四舍五入异常。decimal

使用 to_integral_value() 方法获取操作数四舍五入后最接近整数的值，代码如下：

from decimal import * 			# 导入十进制定点和浮点运算模块

a = Decimal(7E+3)   			# 7000值
b = Decimal(5E-3)   			# 0.005....
c = Decimal(1.5)
d = Decimal(0.5)

print(a.to_integral_value())
print(b.to_integral_value())
print(c.to_integral_value())
print(d.to_integral_value())

说明：为了与旧版本兼容，Python 还保留了 to_integral() 方法。

60. Context类，上下文类

Context 类的构造方法可以创建一个自定义的上下文对象。语法格式如下：

decimal.Context(prec = None，rounding = None，Emin = None，Emax = None，capitals = None，clamp = None，flags = None，traps = None )

参数说明：

• prec ：用于指定上下文中算术运算的精度，默认值为 None。

• rounding ：用于指定舍入模式，默认值为 None。

• Emin ：用于指定 e 的最小指数位数，默认值为 None。

• Emax ：用于指定 e 的最大指数位数，默认值为 None。

• capitals ：用于指定是否大写，默认值为 None。

• clamp ：用于指定区间限定，默认值为 None。

• flags ：用于指定标记，默认值为 None。

• traps ：用于指定可能出现的陷阱，默认值为 None。

• 返回值：decimal.Context 对象。

创建自定义的上下文对象，并设置活动线程的当前上下文为新定义的上下文对象，代码如下：

import decimal                                                		# 导入十进制定点和浮点运算模块

c = decimal.Context(
prec=28, rounding=decimal.ROUND_UP,

traps=[decimal.DivisionByZero, decimal.Overflow, decimal.InvalidOperation],
flags=[],
Emax=999999,
Emin=-999999,
capitals=1,
clamp=0
)                                                                  	# 创建decimal.Context对象

decimal.setcontext(c)                       						# 设置活动线程的当前上下文
print(decimal.getcontext())                   						# 打印活动线程的当前上下文

创建自定义的上下文对象，然后分别获取需要查看的属性并输出，代码如下：

import decimal                		# 导入十进制定点和浮点运算模块

context = decimal.Context(prec=28, rounding=decimal.ROUND_UP,
traps=[decimal.DivisionByZero, decimal.Overflow, decimal.InvalidOperation],
flags=[],
Emax=999999,
Emin=-999999,
capitals=1,
clamp=0
)                         			# 创建decimal.Context对象

print(‘精度为：',context.prec)
print(‘可能出现的陷阱：',[k for k,v in context.traps.items() if v])
print(‘标记：',[k for k,v in context.flags.items() if v])decimal
print(‘e的最大指数位数：',context.Emax)
print(‘e的最小指数位数：',context.Emin)
print(‘是否大写：',context.capitals)
print(‘区间限定：',context.clamp)
print(‘舍入模式：',context.rounding)

61. clear_flags()方法，将所有标志重置为空

decimal 模块的 Context 类的 clear_flags() 方法用于将所有的标志重置为空。语法格式如下：

clear_flags()

参数说明：

• 返回值：无。

• 快用锦囊

创建 decimal.Context 对象（需要指定 flags 属性），并设置活动线程的当前上下文为该对象；再获取活动线程的当前上下文，并清空 flags 属性值；最后再获取活动线程的当前上下文，代码如下：

import decimal                     			# 导入十进制定点和浮点运算模块

c = decimal.Context(
prec=28, rounding=decimal.ROUND_UP,
traps=[decimal.DivisionByZero, decimal.Overflow, decimal.InvalidOperation],
flags=[decimal.Inexact, decimal.Rounded],
Emax=999999,
Emin=-999999,
capitals=1,
clamp=0
)                                        	# 创建decimal.Context对象

decimal.setcontext(c)              			# 设置活动线程的当前上下文
print(‘清除标记前')
print(decimal.getcontext())          		# 打印活动线程的当前上下文
decimal.getcontext().clear_flags(  )		# 清空flags属性
print(‘清除标记后')
print(decimal.getcontext())           		# 打印活动线程的当前上下文

62. abs()方法，返回绝对值

decimal 模块的 Context 类的 abs() 方法用于返回操作数的绝对值。语法格式如下：

abs(x)

参数说明：

• x ：要计算绝对值的数，是通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：一个数的绝对值。

输出正数、负数、0、正无穷和负无穷的绝对值，代码如下：

import decimal                               	# 导入十进制定点和浮点运算模块

context = decimal.getcontext()            		# 获取上下文对象
context.prec = 3                              	# 设置精度为3

x = decimal.Decimal(‘10.36971’)         		# 通过字符串创建Decimal对象，值为10.36971decimal
y = decimal.Decimal(‘-2’)                  		# 通过字符串创建Decimal对象，值为-2
z = decimal.Decimal(‘0’)                   		# 通过字符串创建Decimal对象，值为0
m = decimal.Decimal(‘Infinity’)    				# 通过字符串创建Decimal对象，值为Infinity
n = decimal.Decimal(‘-Infinity’)      			# 通过字符串创建Decimal对象，值为-Infinity

print(‘x = %s 绝对值为：%s’ % (x,context.abs(x)))  		# 结果为10.4
print(‘y =%s 绝对值为：%s’ % (y,context.abs(y)))     	# 结果为2
print(‘z =%s 绝对值为：%s’ % (z,context.abs(z)))     	# 结果为0
print(‘m =%s 绝对值为：%s’ % (m,context.abs(m)))   		# 结果为Infinity
print(‘n =%s 绝对值为：%s’ % (n,context.abs(n)))     	# 结果为Infinity

63. add()方法，加法运算

decimal 模块的 Context 类的 add() 方法用于进行加法运算。语法格式如下：

add(x, y)

参数说明：

• x ：一个加数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• y ：另一个加数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：两个数的和。

计算不同数的和并输出，代码如下：

import decimal                          	# 导入十进制定点和浮点运算模块

context = decimal.getcontext()       		# 获取上下文对象
context.prec = 3                         	# 设置精度为3

x = decimal.Decimal(‘10’)            		# 通过字符串创建Decimal对象，值为10
y = decimal.Decimal(‘2’)              		# 通过字符串创建Decimal对象，值为2
z = decimal.Decimal(‘3’)              		# 通过字符串创建Decimal对象，值为3
k = decimal.Decimal(‘-5’)             		# 通过字符串创建Decimal对象，值为-5
m = decimal.Decimal(‘Infinity’)     		# 通过字符串创建Decimal对象，值为Infinity
n = decimal.Decimal(‘-Infinity’)     		# 通过字符串创建Decimal对象，值为-Infinity

print(‘%s+%s = %s’ % (x,y,context.add(x,y)))            	# 结果为12
print(‘%s+%s = %s’ % (x,z,context.add(x,z)))            	# 结果为13
print(‘%s+(%s) = %s’ % (x,k,context.add(x,k)))          	# 结果为5
print(‘%s+%s = %s’ % (x,m,context.add(x,m)))           	# 结果为Infinity
print(‘%s+%s = %s’ % (x,n,context.add(x,n)))            	# 结果为-Infinity

64. canonical()方法，返回相同的Decimal对象

decimal 模块的 Context 类的 canonical() 方法用于返回相同的 Decimal 对象。语法格式如下：

canonical(x)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：decimal.Context 对象。

说明：由于当前的 Decimal 对象没有不同的编码，所以返回的都是相同的 Decimal 对象。

创建一个 Decimal 对象的副本，代码如下：

import decimal                                     	# 导入十进制定点和浮点运算模块

x = decimal.Decimal(‘0.1’)                       	# 一个数decimal
result = decimal.getcontext().canonical(x)    		# 返回相同的Decimal对象
print(result)

65. clear_traps()方法，将所有陷阱重置为空

decimal 模块的 Context 类的 clear_traps() 方法用于将所有的陷阱重置为空。语法格式如下：

clear_traps()

参数说明：

• 返回值：无。

首先创建 decimal.Context 对象（需要指定 traps 属性），并设置活动线程的当前上下文为该对象；然后获取活动线程的当前上下文，并清空traps属性值；最后获取活动线程的当前上下文，代码如下：

import decimal                                     	# 导入十进制定点和浮点运算模块

c = decimal.Context(
prec=28, rounding=decimal.ROUND_UP,
traps=[decimal.DivisionByZero, decimal.Overflow, decimal.InvalidOperation],
flags=[],
Emax=999999,
Emin=-999999,
capitals=1,
clamp=0
)                                 					# 创建decimal.Context对象

decimal.setcontext(c)                          		# 设置活动线程的当前上下文
print(‘清除陷阱前')
print(decimal.getcontext())             			# 打印活动线程的当前上下文

decimal.getcontext().clear_traps()        			# 清空traps属性
print(‘清除陷阱后')
print(decimal.getcontext())             			# 打印活动线程的当前上下文

66. compare()方法，从数字上比较两个数

decimal 模块的 Context 类的 compare() 方法用于从数字上比较两个数。语法格式如下：

compare(x, y)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• y ：另一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：返回比较结果的数字。值为 1 表示第一个数大，值为 -1 表示第二个数大，值为 0 表示两个数一样大。两个操作数中，只要有一个为 NaN，则结果为 NaN。

从数字上比较不同数的大小，代码如下：

import decimal                          	# 导入十进制定点和浮点运算模块

context = decimal.getcontext()     			# 获取上下文对象
context.prec = 3                       		# 设置精度为3

x = decimal.Decimal(‘-20’)      	# 通过字符串创建Decimal对象，值为-20
y = decimal.Decimal(‘-10’)      	# 通过字符串创建Decimal对象，值为-10
z = decimal.Decimal(‘-0’)        	# 通过字符串创建Decimal对象，值为-0
k = decimal.Decimal(‘0’)        	# 通过字符串创建Decimal对象，值为0
m = decimal.Decimal(‘20.0’)     	# 通过字符串创建Decimal对象，值为20.0
n = decimal.Decimal(‘20’)       	# 通过字符串创建Decimal对象，值为20

print(‘%s与%s 的比较结果为：%s’ % (x,y,context.compare(x,y)))     	# 结果为-1
print(‘%s与%s 的比较结果为：%s’ % (x,z,context.compare(x,z)))     	# 结果为-1
print(‘%s与%s 的比较结果为：%s’ % (z,k,context.compare(z,k)))     	# 结果为0
print(‘%s与%s 的比较结果为：%s’ % (x,m,context.compare(x,m)))    	# 结果为-1decimal
print(‘%s与%s 的比较结果为：%s’ % (x,n,context.compare(x,n)))     	# 结果为-1
print(‘%s与%s 的比较结果为：%s’ % (m,n,context.compare(m,n)))    	# 结果为0

67. compare_signal()方法，比较两个非NaN的值

decimal 模块的 Context 类的 compare_signal() 方法用于从数字上比较两个操作数的值。语法格式如下：

compare_signal(x, y)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• y ：另一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：返回比较结果的数字。值为 1 表示第一个数大，值为 -1 表示第二个数大，值为 0 表示两个数一样大。

说明：在使用 compare_signal() 方法比较两个值时，如果其中一个值为 NaN，将抛出“decimal.InvalidOperation:[<class ‘decimal.InvalidOperation’ >]”异常。

使用 compare_signal() 方法从数字上比较两个不同数的大小，代码如下：

import decimal                          	# 导入十进制定点和浮点运算模块

context = decimal.getcontext()       		# 获取上下文对象
context.prec = 3               				# 设置精度为3

x = decimal.Decimal(‘-20’)      			# 通过字符串创建Decimal对象，值为-20
y = decimal.Decimal(‘-10’)      			# 通过字符串创建Decimal对象，值为-10
z = decimal.Decimal(‘-0’)             		# 通过字符串创建Decimal对象，值为-0
k = decimal.Decimal(‘0’)              		# 通过字符串创建Decimal对象，值为0
m = decimal.Decimal(‘20.0’)         		# 通过字符串创建Decimal对象，值为20.0
n = decimal.Decimal(‘20’)            		# 通过字符串创建Decimal对象，值为20

print(‘%s与%s 的比较结果为：%s’ % (x,y,context.compare_signal(x,y)))             	# 结果为-1
print(‘%s与%s 的比较结果为：%s’ % (x,z,context.compare_signal(x,z)))              	# 结果为-1
print(‘%s与%s 的比较结果为：%s’ % (z,k,context.compare_signal(z,k)))              	# 结果为0
print(‘%s与%s 的比较结果为：%s’ % (x,m,context.compare_signal(x,m)))              	# 结果为-1
print(‘%s与%s 的比较结果为：%s’ % (x,n,context.compare_signal(x,n)))              	# 结果为-1
print(‘%s与%s 的比较结果为：%s’ % (m,n,context.compare_signal(m,n)))          		# 结果为0

68. compare_total()方法，抽象比较两个操作数的值

decimal 模块的 Context 类的 compare_total() 方法用于抽象比较两个操作数的值。语法格式如下：

compare_total(x, y)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• y ：另一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：返回比较结果的数字。值为 1 表示第一个数大，值为 -1 表示第二个数大，值为 0 表示两个数一样大。

说明：compare_total() 方法与 compare_signal() 方法的区别为：compare_total() 方法比较的是两个数的抽象表示，而 compare_signal() 方法比较的是两个数的数值。例如，0 和 -0，通过这两个方法的比较结果就不同。使用 compare_total() 方法的结果为 0 大，而使用 compare_signal() 方法的结果为两个数一样大。

使用 compare_total() 方法比较不同数的大小，代码如下：

import decimal                          	# 导入十进制定点和浮点运算模块

context = decimal.getcontext()       		# 获取上下文对象
context.prec = 3                         	# 设置精度为3

x = decimal.Decimal(‘-20’)      			# 通过字符串创建Decimal对象，值为-20
y = decimal.Decimal(‘-10’)      			# 通过字符串创建Decimal对象，值为-10
z = decimal.Decimal(‘-0’)             		# 通过字符串创建Decimal对象，值为-0
k = decimal.Decimal(‘0’)              		# 通过字符串创建Decimal对象，值为0
m = decimal.Decimal(‘20.0’)         		# 通过字符串创建Decimal对象，值为20.0
n = decimal.Decimal(‘20’)            		# 通过字符串创建Decimal对象，值为20

print(‘%s与%s 的比较结果为：%s’ % (x,y,context.compare_total(x,y)))      	# 结果为-1
print(‘%s与%s 的比较结果为：%s’ % (x,z,context.compare_total(x,z)))       	# 结果为-1
print(‘%s与%s 的比较结果为：%s’ % (z,k,context.compare_total(z,k)))       	# 结果为-1
print(‘%s与%s 的比较结果为：%s’ % (x,m,context.compare_total(x,m)))     	# 结果为-1
print(‘%s与%s 的比较结果为：%s’ % (x,n,context.compare_total(x,n)))      	# 结果为-1
print(‘%s与%s 的比较结果为：%s’ % (m,n,context.compare_total(m,n)))     	# 结果为-1

69. compare_total_mag()方法，抽象比较两个数（忽略符号）

decimal模块的Context类的compare_total_mag()方法用于抽象比较两个操作数的值（忽略符号）。语法格式如下：

compare_total_mag(x, y)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• y ：另一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：返回比较结果的数字。值为 1 表示第一个数大，值为 -1 表示第二个数大，值为 0 表示两个数一样大。

使用 compare_total_mag() 方法比较不同数的大小（忽略符号），代码如下：

import decimal                                          # 导入十进制定点和浮点运算模块

context = decimal.getcontext()                     		# 获取上下文对象
context.prec = 3                                       	# 设置精度为3

x = decimal.Decimal(‘-20’)                    			# 通过字符串创建Decimal对象，值为-20
y = decimal.Decimal(‘-10’)                    			# 通过字符串创建Decimal对象，值为-10
z = decimal.Decimal(‘-0’)                           	# 通过字符串创建Decimal对象，值为-0
k = decimal.Decimal(‘0’)                            	# 通过字符串创建Decimal对象，值为0
m = decimal.Decimal(‘20.0’)                       		# 通过字符串创建Decimal对象，值为20.0
n = decimal.Decimal(‘20’)                          		# 通过字符串创建Decimal对象，值为20

print(‘%s与%s 的比较结果为：%s’ % (x,y,context.compare_total_mag(x,y)))           # 结果为1
print(‘%s与%s 的比较结果为：%s’ % (x,z,context.compare_total_mag(x,z)))           # 结果为1
print(‘%s与%s 的比较结果为：%s’ % (z,k,context.compare_total_mag(z,k)))           # 结果为0
print(‘%s与%s 的比较结果为：%s’ % (x,m,context.compare_total_mag(x,m)))           # 结果为1
print(‘%s与%s 的比较结果为：%s’ % (x,n,context.compare_total_mag(x,n)))           # 结果为0
print(‘%s与%s 的比较结果为：%s’ % (m,n,context.compare_total_mag(m,n)))           # 结果为-1

70. copy()方法，复制上下文对象

decimal 模块的 Context 类的 copy() 方法用于创建上下文对象的副本。语法格式如下：decimal

copy()

参数说明：

• 返回值：decimal.Context 对象。

创建活动线程的当前上下文对象的一个副本，并清除副本的陷阱属性值，然后再输出活动线程的当前上下文和副本，代码如下：

import decimal                                           	# 导入十进制定点和浮点运算模块

print(‘原：\n’,decimal.getcontext())                 		# 输出活动线程的当前上下文
context1 = decimal.getcontext().copy()             			# 复制上下文对象
context1.clear_traps()                                   	# 清空副本的traps属性
print(‘副本：\n’,context1)                             		# 输出副本
print(‘原：\n’,decimal.getcontext())                 		# 输出活动线程的当前上下文

71. copy_abs()方法，返回一个数的绝对值的副本

decimal 模块的 Context 类的 copy_abs() 方法用于返回一个数的绝对值的副本。语法格式如下：

copy_abs(x)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：一个数的副本，并且将符号设置为 0，即全部变为正数。该值不受上下文对象的影响，不会进行舍入。

返回一个数的绝对值的副本，代码如下：

import decimal                                     # 导入十进制定点和浮点运算模块

context = decimal.getcontext()                     # 获取上下文对象
context.prec = 3                                   # 设置精度为3

x = decimal.Decimal(‘10.36971’)                    # 通过字符串创建Decimal对象，值为10.36971
y = decimal.Decimal(‘-2’)                          # 通过字符串创建Decimal对象，值为-2
z = decimal.Decimal(‘0’)                           # 通过字符串创建Decimal对象，值为0
m = decimal.Decimal(‘Infinity’)                    # 通过字符串创建Decimal对象，值为Infinity
n = decimal.Decimal(‘-Infinity’)                   # 通过字符串创建Decimal对象，值为-Infinity

print(‘x = %s 绝对值为：%s’ % (x,context.copy_abs(x)))              # 结果为10.36971
print(‘y = %s 绝对值为：%s’ % (y,context.copy_abs(y)))              # 结果为2
print(‘z = %s 绝对值为：%s’ % (z,context.copy_abs(z)))              # 结果为0
print(‘m = %s 绝对值为：%s’ % (m,context.copy_abs(m)))              # 结果为Infinity
print(‘n = %s 绝对值为：%s’ % (n,context.copy_abs(n)))              # 结果为Infinity

72. copy_decimal()方法，复制 Decimal对象

decimal 模块的 Context 类的 copy_decimal() 方法用于返回 Decimal 对象的副本。语法格式如下：

copy_decimal(num)

参数说明：

• num ：Decimal 对象，可以通过 decimal.Decimal 类的构造方法创建。

• 返回值：decimal.Decimal 对象。

使用 copy_decimal() 方法复制 Decimal 对象，代码如下：

import decimal                                           	# 导入十进制定点和浮点运算模块

d = decimal.Decimal(‘0.7’)
print(‘原：', d)

d2 = decimal.getcontext().copy_decimal(d)        			# 复制Decimal对象
d2 = d2 * 100                                            	# 进行乘法运算
print(‘副本：', d2)
print(‘原：', d)

73. copy_negate()方法，将一个数进行符号反转

decimal 模块的 Context 类的 copy_negate() 方法用于将一个数进行符号反转，并且返回反转后的这个数的副本。语法格式如下：

copy_negate(x)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：decimal.Decimal 对象，内容为进行符号反转后的数。

输出带有符号反转功能的一个数的副本，代码如下：

import decimal                                     	# 导入十进制定点和浮点运算模块

context = decimal.getcontext()                  	# 获取上下文对象
context.prec = 3                                    # 设置精度为3

x = decimal.Decimal(‘10’)                       	# 通过字符串创建Decimal对象，值为10
y = decimal.Decimal(‘-2’)                        	# 通过字符串创建Decimal对象，值为-2
z = decimal.Decimal(‘0’)                         	# 通过字符串创建Decimal对象，值为0
m = decimal.Decimal(‘Infinity’)         			# 通过字符串创建Decimal对象，值为Infinity
n = decimal.Decimal(‘-Infinity’)              		# 通过字符串创建Decimal对象，值为-Infinity

print(‘x = %s 符号反转后：%s’ % (x,context.copy_negate(x)))   	# 结果为-10
print(‘y = %s 符号反转后：%s’ % (y,context.copy_negate(y)))   	# 结果为2
print(‘z = %s 符号反转后：%s’ % (z,context.copy_negate(z)))   	# 结果为-0
print(‘m = %s 符号反转后：%s’ % (m,context.copy_negate(m)))  	# 结果为-Infinity
print(‘n = %s 符号反转后：%s’ % (n,context.copy_negate(n)))   	# 结果为Infinity

74. copy_sign()方法，将符号从一个数复制到另一个数

decimal 模块的 Context 类的 copy_sign() 方法用于将符号从第二个参数复制到第一个参数。语法格式如下：

copy_sign(x, y)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• y ：另一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：返回第一个参数值，其符号同第二个参数相同。

将符号从一个数复制到另一个数，代码如下：

import decimal                            # 导入十进制定点和浮点运算模块

context = decimal.getcontext()            # 获取上下文对象
context.prec = 3                          # 设置精度为3

x = decimal.Decimal(‘10’)                 # 通过字符串创建Decimal对象，值为10
y = decimal.Decimal(‘-2’)                 # 通过字符串创建Decimal对象，值为-2
z = decimal.Decimal(‘0’)                  # 通过字符串创建Decimal对象，值为0
m = decimal.Decimal(‘Infinity’)           # 通过字符串创建Decimal对象，值为Infinity
n = decimal.Decimal(‘-Infinity’)          # 通过字符串创建Decimal对象，值为-Infinity

print(‘x = %s y =%s 结果为：%s’ % (x,y,context.copy_sign(x,y)))        # 结果为-10
print(‘y = %s x =%s 结果为：%s’ % (y,x,context.copy_sign(y,x)))        # 结果为2
print(‘x = %s z =%s 结果为：%s’ % (x,z,context.copy_sign(x,z)))        # 结果为10
print(‘x = %s m =%s 结果为：%s’ % (x,m,context.copy_sign(x,m)))        # 结果为10
print(‘x = %s n =%s 结果为：%s’ % (x,n,context.copy_sign(x,n)))        # 结果为-10

75. create_decimal()方法，创建一个新的Decimal实例

decimal 模块的 Context 类的 create_decimal() 方法用于使用当前上下文对象创建一个新的 Decimal 实例。语法格式如下：

Context对象名.create_decimal(num)

参数说明：

• num ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：decimal.Decimal 对象。

创建活动线程的当前上下文对象并设置其精度，然后使用 create_decimal() 方法创建一个新 Decimal实例，并进行相应的运算及输出；接下来再更改精度，重新创建一个 Decimal 实例，并进行相应的运算及输出，代码如下：

import decimal                          	# 导入十进制定点和浮点运算模块

context = decimal.getcontext()       		# 创建上下文对象
context.prec = 3                         	# 设置精度为3
d = decimal.Decimal(‘3.1415926’)
print(‘原：',d)

d2 = context.create_decimal(d)      		# 创建Decimal对象的实例
print(‘新：',d2)

d2 = d2*100                             	# 进行乘法运算
print(‘新（运算后）：',d2)
print(‘原：',d)

print(‘==========更改精度为5后=============’)
context.prec = 5                         	# 设置精度为5
d2 = context.create_decimal(d)    			# 创建Decimal对象的实例
print(‘新：',d2)

d2 = d2*100                             	# 进行乘法运算
print(‘新（运算后）：',d2)
print(‘原：',d)

76. create_decimal_from_float()方法，从浮点型创建Decimal实例

decimal 模块的 Context 类的 create_decimal_from_float() 方法用于使用当前上下文对象从浮点型数创建一个对应的 Decimal 实例。语法格式如下：

create_decimal_from_float(f)

参数说明：

• f ：浮点类型数据。

• 返回值：decimal.Context 对象。

创建活动线程的当前上下文对象，然后使用 create_decimal_from_float() 方法分别创建浮点数和整数对应的 Decimal 实例，并输出结果；接下来再更改精度，重新创建浮点数和整数对应的 Decimal实例，并输出结果，代码如下：

import decimal                                            # 导入十进制定点和浮点运算模块

context = decimal.getcontext()                            # 创建上下文对象
num1 = 3.1415926                                          # 浮点数
num2 = 1024                                               # 整数
d2 = context.create_decimal_from_float(num1)              # 创建Decimal对象的实例
print(‘浮点数：',d2)

d3 = context.create_decimal_from_float(num2)              # 创建Decimal对象的实例
print(‘整数：',d3)

print(‘==========更改精度为3后=============’)
context.prec = 3                                          # 设置精度为3
d2 = context.create_decimal_from_float(num1)              # 创建Decimal对象的实例
print(‘浮点数：',d2)

d3 = context.create_decimal_from_float(num2)              # 创建Decimal对象的实例
print(‘整数：',d3)

77. divide()方法，除法运算

decimal 模块的 Context 类的 divide() 方法用于除法运算。语法格式如下：

divide(x, y)

参数说明：

• x ：被除数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。
• y ：除数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。
• 返回值：商。

使用 divide() 方法实现两个数的除法运算，代码如下：

import decimal                                       # 导入十进制定点和浮点运算模块

context = decimal.getcontext()                       # 获取上下文对象
context.prec = 3                                     # 设置精度为3
x = decimal.Decimal(‘10’)                            # 通过字符串创建Decimal对象，值为10
y = decimal.Decimal(‘2’)                             # 通过字符串创建Decimal对象，值为2
z = decimal.Decimal(‘3’)                             # 通过字符串创建Decimal对象，值为3
k = decimal.Decimal(‘-5’)                            # 通过字符串创建Decimal对象，值为-5
m = decimal.Decimal(‘Infinity’)                      # 通过字符串创建Decimal对象，值为Infinity
n = decimal.Decimal(‘-Infinity’)                     # 通过字符串创建Decimal对象，值为-Infinity

print(‘%s/%s = %s’ % (x,y,context.divide(x,y)))        # 结果为5
print(‘%s/%s = %s’ % (x,z,context.divide(x,z)))    	 # 结果为3.33decimal
print(‘%s/%s = %s’ % (x,k,context.divide(x,k)))    	 # 结果为-2
print(‘%s/%s = %s’ % (x,m,context.divide(x,m)))   	 # 结果为0E-1000001
print(‘%s/%s = %s’ % (x,n,context.divide(x,n)))    	 # 结果为-0E-1000001

78. divide_int()方法，整除运算

decimal 模块的 Context 类的 divide_int() 方法用于求两个数整除的结果（直接舍弃小数位）。语法格式如下：

divide_int(x, y)

参数说明：

• x ：被除数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• y ：除数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：整数商。

求两个数的整除结果，代码如下：

import decimal                                  # 导入十进制定点和浮点运算模块

context = decimal.getcontext()                  # 获取上下文对象
context.prec = 3                                # 设置精度为3
x = decimal.Decimal(‘10’)                       # 通过字符串创建Decimal对象，值为10
y = decimal.Decimal(‘2’)                        # 通过字符串创建Decimal对象，值为2
z = decimal.Decimal(‘3’)                        # 通过字符串创建Decimal对象，值为3
k = decimal.Decimal(‘-5’)                       # 通过字符串创建Decimal对象，值为-5
m = decimal.Decimal(‘Infinity’)                 # 通过字符串创建Decimal对象，值为Infinity
n = decimal.Decimal(‘-Infinity’)                # 通过字符串创建Decimal对象，值为-Infinity

print(‘%s//%s = %s’ % (x,y,context.divide_int(x,y)))    	# 结果为5
print(‘%s//%s = %s’ % (x,z,context.divide_int(x,z)))    	# 结果为3
print(‘%s//%s = %s’ % (x,k,context.divide_int(x,k)))    	# 结果为-2
print(‘%s//%s = %s’ % (x,m,context.divide_int(x,m)))  	# 结果为0
print(‘%s//%s = %s’ % (x,n,context.divide_int(x,n)))    	# 结果为-0

79. divmod()方法，返回除法运算后的商和余数

decimal 模块的 Context 类的 divmod() 方法用于进行除法运算并返回一个元组（第一个元素是商的整数部分，第二个元素是余数）。语法格式如下：

divmod(x, y)

参数说明：

• x ：被除数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• y ：除数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：一个元组，第一个元素是以Decimal对象保存的商的整数部分，第二个元素是以Decimal对象保存的余数。

使用 divmod() 方法进行除法运算并分别返回商和余数，代码如下：

import decimal                                                  # 导入十进制定点和浮点运算模块

context = decimal.getcontext()                                  # 获取上下文对象
context.prec = 3                                                # 设置精度为3
x = decimal.Decimal(‘10’)                                       # 通过字符串创建Decimal对象，值为10
y = decimal.Decimal(‘2’)                                        # 通过字符串创建Decimal对象，值为2
z = decimal.Decimal(‘3’)                                        # 通过字符串创建Decimal对象，值为3
k = decimal.Decimal(‘-5’)                                       # 通过字符串创建Decimal对象，值为-5
m = decimal.Decimal(‘Infinity’)                                 # 通过字符串创建Decimal对象，值为Infinity
n = decimal.Decimal(‘-Infinity’)                                # 通过字符串创建Decimal对象，值为-Infinitydecimal  

print(‘%s/%s = %s’ % (x,y,context.divmod(x,y)))              # 结果为(Decimal(‘5’), Decimal(‘0’))
print(‘%s/%s = %s’ % (x,z,context.divmod(x,z)))              # 结果为(Decimal(‘3’), Decimal(‘1’))
print(‘%s/%s = %s’ % (x,k,context.divmod(x,k)))              # 结果为(Decimal(‘-2’), Decimal(‘0’))
print(‘%s/%s = %s’ % (x,m,context.divmod(x,m)))              # 结果为(Decimal(‘0’), Decimal(‘10’))
print(‘%s/%s = %s’ % (x,n,context.divmod(x,n)))              # 结果为(Decimal(‘-0’), Decimal(‘10’))

80. Etiny()方法，返回最小指数值

decimal 模块的 Context 类的 Etiny() 方法用于返回最小指数值。在活动线程的上下文对象中，发生向下溢出时，采用该值。语法格式如下：

Etiny()

参数说明：

• 返回值：返回一个值，该值等于 Emin - prec + 1（即 e 的最小指数位数 - 精度 +1）的结果。当发生向下溢出时，采用该值。

首先输出当前上下文默认的最小指数，然后更改上下文精度后，再输出当前上下文的最小指数，代码如下：

import decimal                                                   	# 导入十进制定点和浮点运算模块	

context = decimal.getcontext()                                   	# 获取上下文对象
print(‘Emin（e的最小指数位数）：‘,decimal.getcontext().Emin)        	# e的最小指数位数
print(‘prec（精度）：‘,context.prec)                              	# 精度值
print(‘Etiny()方法的值：‘,context.Etiny())                         	# 输出当前上下文的最小指数值

context.prec = 3                                                  	# 设置精度为3
print(‘==========更改精度为3后=============‘)
print(‘Emin（e的最小指数位数）：‘,decimal.getcontext().Emin)        	# e的最小指数位数
print(‘prec（精度）：‘,context.prec)                              	# 精度值
print(‘Etiny()方法的值：‘,context.Etiny())                        	# 输出当前上下文的最小指数值

81. Etop()方法，返回最大的指数

decimal 模块的 Context 类的 Etop() 方法用于返回最大的指数。语法格式如下：

Etop()

参数说明：

• 返回值：返回一个值，该值等于 Emax - prec + 1（即 e 的最大指数位数 - 精度 +1）的结果。

首先输出当前上下文默认的最大指数，然后更改上下文精度后，再输出当前上下文的最大指数，代码如下：

import decimal                                                    	# 导入十进制定点和浮点运算模块

context = decimal.getcontext()                                    	# 获取上下文对象
print(‘Emax（e的最大指数位数）：',decimal.getcontext().Emax)         	# e的最大指数位数
print(‘prec（精度）：',context.prec)                             		# 精度值
print(‘Etop()方法的值：',context.Etop())                        		# 输出当前上下文的最大指数值

context.prec = 3                                                 	# 设置精度为3
print(‘==========更改精度为3后=============’)
print(‘Emax（e的最大指数位数）：',decimal.getcontext().Emax)        	# e的最大指数位数
print(‘prec（精度）：',context.prec)                             		# 精度值
print(‘Etop()方法的值：',context.Etop())                      		# 输出当前上下文的最大指数值

82. exp()方法，获取e的x次方

decimal 模块的 Context 类的 exp() 方法用于返回 e 的 x 次方，即 e**x。语法格式如下：

exp(x)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：返回 e 的 x 次方。

使用 exp() 方法返回 e 的 x 次方，代码如下：

import decimal                                      	# 导入十进制定点和浮点运算模块

context = decimal.getcontext()                      	# 获取上下文对象
context.prec = 3                                   		# 设置精度为3
x = decimal.Decimal(‘1’)                               	# 通过字符串创建Decimal对象，值为1
y = decimal.Decimal(‘2’)                               	# 通过字符串创建Decimal对象，值为2
z = decimal.Decimal(‘-Infinity’)                 		# 通过字符串创建Decimal对象，值为-Infinity
k = decimal.Decimal(‘0’)                               	# 通过字符串创建Decimal对象，值为0
m = decimal.Decimal(‘Infinity’)                 		# 通过字符串创建Decimal对象，值为Infinity
n = decimal.Decimal(‘-1’)                             	# 通过字符串创建Decimal对象，值为-1

print(‘x=%s %s’ % (x,context.exp(x)))                		# 结果为2.72
print(‘y=%s %s’ % (y,context.exp(y)))                		# 结果为7.39
print(‘z=%s %s’ % (z,context.exp(z)))           			# 结果为0
print(‘k=%s %s’ % (k,context.exp(k)))                		# 结果为1
print(‘m=%s %s’ % (m,context.exp(m)))             		# 结果为Infinity
print(‘n=%s %s’ % (n,context.exp(n)))                		# 结果为0.368

83. fma()方法，融合的乘法和加法

decimal 模块的 Context 类的 fma() 方法用于进行融合的乘法和加法，即返回 x 乘以 y 加上 z 的值。语法格式如下：

fma(x, y, z)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• y ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• z ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：x 乘以 y 加上 z 的结果。其中，x 乘以 y 的结果不进行四舍五入。

计算 x 乘以 y 加上 z 的结果，代码如下：

import decimal                                         	# 导入十进制定点和浮点运算模块

context = decimal.getcontext()                          # 获取上下文对象
x = decimal.Decimal(‘6’)                        		# 通过字符串创建Decimal对象，值为6
y = decimal.Decimal(‘9’)                          		# 通过字符串创建Decimal对象，值为9
z = decimal.Decimal(‘Inf’)                              # 通过字符串创建Decimal对象，值为Infinity
k = decimal.Decimal(‘-10’)                              # 通过字符串创建Decimal对象，值为-10
m = decimal.Decimal(‘1.1E+10’)                          # 通过字符串创建Decimal对象，值为1.1E+10

print(‘%s*%s+%s=%s’ % (x,y,z,context.fma(x,y,z)))     	# 结果为Infinity
print(‘%s*%s+(%s)=%s’ % (x,y,k,context.fma(x,y,k)))       # 结果为44
print(‘%s*%s+(%s)=%s’ % (x,m,k,context.fma(x,m,k)))       # 结果为65999999990

84. is_canonical()方法，判断一个数是否规范

decimal 模块的 Context 类的 is_canonical() 方法用于判断一个数是否是规范的。语法格式如下：

is_canonical(x)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：布尔类型，如果 x 是规范的，则返回 True，否则返回 False。

说明：目前，Decimal 对象始终是规范的，所以 is_canonical() 方法的返回值始终为 True。

判断一个数是否规范，代码如下：

import decimal                                             	# 导入十进制定点和浮点运算模块

context = decimal.getcontext()                             	# 获取上下文对象
x = decimal.Decimal(‘-Inf’)                                	# 通过字符串创建Decimal对象，值为-Infinity
y = decimal.Decimal(‘nan’)                                  # 通过字符串创建Decimal对象，值为nan
z = decimal.Decimal(‘Inf’)                                  # 通过字符串创建Decimal对象，值为Infinity
k = decimal.Decimal(‘-0’)                                   # 通过字符串创建Decimal对象，值为0
m = decimal.Decimal(‘1.1E+1000’)                            # 通过字符串创建Decimal对象，值为1.1E+1000

print(‘%s 是否规范：%s’ % (x,context.is_canonical(x)))   		# 结果为True
print(‘%s 是否规范：%s’ % (y,context.is_canonical(y)))   		# 结果为True
print(‘%s 是否规范：%s’ % (z,context.is_canonical(z)))    		# 结果为True
print(‘%s 是否规范：%s’ % (k,context.is_canonical(k)))   		# 结果为True
print(‘%s 是否规范：%s’ % (m,context.is_canonical(m)))  		# 结果为True

85. is_f inite()方法，判断一个数是否有限

decimal 模块的 Context 类的 is_finite() 方法用于判断一个数是否有限。语法格式如下：

is_finite(x)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：布尔类型，如果 x 有限，则返回 True，否则返回 False。

判断一个数是否有限，代码如下：

import decimal                                       	# 导入十进制定点和浮点运算模块

context = decimal.getcontext()                        	# 获取上下文对象
####context.prec = 8                                    # 设置精度为8
x = decimal.Decimal(‘-Inf’)                             # 通过字符串创建Decimal对象，值为-Infinity
y = decimal.Decimal(‘nan’)                            	# 通过字符串创建Decimal对象，值为NaN
z = decimal.Decimal(‘Inf’)                            	# 通过字符串创建Decimal对象，值为Infinity
k = decimal.Decimal(‘0’)                              	# 通过字符串创建Decimal对象，值为0
m = decimal.Decimal(‘1.1E+1000’)                        # 通过字符串创建Decimal对象，值为1.1E+1000

print(‘%s 是否有限：%s’ % (x,context.is_finite(x)))   		# 结果为False
print(‘%s 是否有限：%s’ % (y,context.is_finite(y)))   		# 结果为False
print(‘%s 是否有限：%s’ % (z,context.is_finite(z)))   		# 结果为False
print(‘%s 是否有限：%s’ % (k,context.is_finite(k)))   		# 结果为True
print(‘%s 是否有限：%s’ % (m,context.is_finite(m))) 		# 结果为True

86. is_inf inite()方法，判断一个数是否为无穷大

decimal 模块的 Context 类的 is_infinite() 方法用于判断一个数是否为无穷大。语法格式如下：

is_infinite(x)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：布尔类型，如果 x 是无穷大，则返回 True，否则返回 False。

判断一个数是否为无穷大，代码如下：

import decimal                               	# 导入十进制定点和浮点运算模块

context = decimal.getcontext()            		# 获取上下文对象
####context.prec = 8                        	# 设置精度为8
x = decimal.Decimal(‘-Inf’)                		# 通过字符串创建Decimal对象，值为-Infinity
y = decimal.Decimal(‘nan’)           			# 通过字符串创建Decimal对象，值为NaN
z = decimal.Decimal(‘Inf’)                 		# 通过字符串创建Decimal对象，值为Infinity
k = decimal.Decimal(‘0’)                   		# 通过字符串创建Decimal对象，值为0
m = decimal.Decimal(‘1.1E+1000’)       			# 通过字符串创建Decimal对象，值为3.14159

print(‘%s 是否为无穷大：%s’ % (x,context.is_infinite(x)))                    # 结果为True
print(‘%s 是否为无穷大：%s’ % (y,context.is_infinite(y)))                    # 结果为False
print(‘%s 是否为无穷大：%s’ % (z,context.is_infinite(z)))                    # 结果为True
print(‘%s 是否为无穷大：%s’ % (k,context.is_infinite(k)))                    # 结果为False
print(‘m-k = %s 是否为无穷大：%s’ % (m-k,context.is_infinite(m-k)))        	 # 结果为False

87. is_nan()方法，判断一个数是否为qNaN或sNaN

decimal 模块的 Context 类的 is_nan() 方法用于判断一个数是否为 qNaN 或 sNaN。语法格式如下：

is_nan(x)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：布尔类型，如果 x 是 qNaN 或 sNaN，则返回 True，否则返回 False。

说明：NaN（not a number）表示不是一个真实的数值。在 NaN 数中，它的指数部分为可表达的最大值。NaN 包括 sNaN（Signaling NaN）数和 qNaN（Quiet NaN）数。其中 sNaN 数表示一种比较严重的错误值；而 qNaN 在一般情况下，是可以接受的。

判断一个数是否为 qNaN 或 sNaN，代码如下：

import decimal                             	# 导入十进制定点和浮点运算模块

context = decimal.getcontext()            	# 获取上下文对象
x = decimal.Decimal(0)                     	# 0
y = decimal.Decimal(‘nan’)           		# 通过字符串创建Decimal对象，值为NaN
z = decimal.Decimal(‘-nan’)                	# 通过字符串创建Decimal对象，值为-NaN
k = decimal.Decimal(‘-9’)                  	# 通过字符串创建Decimal对象，值为-9
m = decimal.Decimal(‘3.14159’)          	# 通过字符串创建Decimal对象，值为3.14159

print(‘z*x= %s 是否为NaN：%s’ % (z*x,context.is_nan(z*x)))            # 结果为True
print(‘%s 是否为NaN：%s’ % (y,context.is_nan(y)))                     # 结果为True
print(‘%s 是否为NaN：%s’ % (z,context.is_nan(z)))                     # 结果为True
print(‘%s 是否为NaN：%s’ % (k,context.is_nan(k)))                     # 结果为False
print(‘m-k = %s 是否为NaN：%s’ % (m-k,context.is_nan(m-k)))           # 结果为False

88. is_normal()方法，判断一个数是否为正常有限数

decimal 模块的 Context 类的 is_normal() 方法用于判断一个数是否为正常的有限数。语法格式如下：

is_normal(x)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。
• 返回值：布尔类型，如果 x 是正常的有限数，则返回 True，否则返回 False。

判断一个数是否为正常数，代码如下：

import decimal                               	# 导入十进制定点和浮点运算模块

context = decimal.getcontext()            		# 获取上下文对象
x = decimal.Decimal(‘-Inf’)                		# 通过字符串创建Decimal对象，值为-Infinity
y = decimal.Decimal(‘nan’)           			# 通过字符串创建Decimal对象，值为NaN
z = decimal.Decimal(‘-nan’)                		# 通过字符串创建Decimal对象，值为-NaN
k = decimal.Decimal(‘0’)                   		# 通过字符串创建Decimal对象，值为0
m = decimal.Decimal(‘3.14159’)          		# 通过字符串创建Decimal对象，值为3.14159

print(‘%s 是否为正常数：%s’ % (x,context.is_normal(x)))                 	# 结果为False
print(‘%s 是否为正常数：%s’ % (y,context.is_normal(y)))                 	# 结果为False
print(‘%s 是否为正常数：%s’ % (z,context.is_normal(z)))                  	# 结果为False
print(‘%s 是否为正常数：%s’ % (k,context.is_normal(k)))                 	# 结果为False
print(‘m-k = %s 是否为正常数：%s’ % (m-k,context.is_normal(m-k)))   		# 结果为True

89. is_qnan()方法，判断一个数是否为安静的NaN

decimal 模块的 Context 类的 is_qnan() 方法用于判断一个数是否为安静的安静的 NaN。语法格式如下：

is_qnan(x)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：布尔类型，如果 x 是安静的 NaN，则返回 True，否则返回 False。

判断一个数或一个表达式的值是否为安静的 NaN，代码如下：

import decimal                               	# 导入十进制定点和浮点运算模块

context = decimal.getcontext()            		# 获取上下文对象
x = decimal.Decimal(0)                     		# 0
y = decimal.Decimal(‘-nan’)               		# 通过字符串创建Decimal对象，值为-NaN
z = decimal.Decimal(‘nan’)           			# 通过字符串创建Decimal对象，值为NaN
k = decimal.Decimal(‘-9’)                  		# 通过字符串创建Decimal对象，值为-9
m = decimal.Decimal(‘3.14159’)          		# 通过字符串创建Decimal对象，值为3.14159

print(‘z*x= %s 是否为qNaN：%s’ % (z*x,context.is_qnan(z*x)))         	# 结果为True
print(‘%s 是否为qNaN：%s’ % (y,context.is_qnan(y)))                 	# 结果为True
print(‘%s 是否为qNaN：%s’ % (z,context.is_qnan(z)))                 	# 结果为True
print(‘%s 是否为qNaN：%s’ % (k,context.is_qnan(k)))                 	# 结果为False
print(‘%s 是否为qNaN：%s’ % (m-k,context.is_qnan(m-k)))               	# 结果为False

90. is_signed()方法，判断一个数是否为负数

decimal 模块的 Context 类的 is_signed() 方法用于判断一个数是否为负数。语法格式如下：

is_signed(x)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：布尔类型，如果 x 是负数，则返回 True，否则返回 False。

说明：在使用 is_signed() 方法时，零和 NaN 都可以带有符号。例如，指定为 -0，则返回 True。

判断一个数是否为负数，代码如下：

import decimal                               	# 导入十进制定点和浮点运算模块

context = decimal.getcontext()            		# 获取上下文对象
x = decimal.Decimal(0)                     		# 0
y = decimal.Decimal(‘-0’)                  		# 通过字符串创建Decimal对象，值为NaN
z = decimal.Decimal(‘NaN’)               		# 通过字符串创建Decimal对象，值为NaN
k = decimal.Decimal(‘-9’)                  		# 通过字符串创建Decimal对象，值为-9
m = decimal.Decimal(‘3.14159’)          		# 通过字符串创建Decimal对象，值为3.14159

print(‘%s 是否为负数：%s’ % (x,context.is_signed(x)))               	# 结果为False
print(‘%s 是否为负数：%s’ % (y,context.is_signed(y)))               	# 结果为True
print(‘%s 是否为负数：%s’ % (z,context.is_signed(z)))                	# 结果为False
print(‘%s 是否为负数：%s’ % (k,context.is_signed(k)))               	# 结果为True
print(‘%s 是否为负数：%s’ % (m-k,context.is_signed(m-k)))         		# 结果为False

91. is_snan()方法，判断一个数是否为信号NaN

decimal 模块的 Context 类的 is_snan() 方法用于判断一个数是否为信号 NaN。语法格式如下：

is_snan(x)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：布尔类型，如果 x 是信号 NaN，则返回 True，否则返回 False。

判断一个数是否为信号 NaN，代码如下：decimal

import decimal                               	# 导入十进制定点和浮点运算模块

context = decimal.getcontext()            		# 获取上下文对象
x = decimal.Decimal(0)                     		# 0
y = decimal.Decimal(‘sNaN’)              		# 通过字符串创建Decimal对象，值为sNaN
z = decimal.Decimal(‘NaN’)               		# 通过字符串创建Decimal对象，值为NaN
k = decimal.Decimal(‘0.1’)                 		# 通过字符串创建Decimal对象，值为0.1

print(‘%s 是否为sNaN：%s’ % (x,context.is_snan(x)))           	# 结果为False
print(‘%s 是否为sNaN：%s’ % (y,context.is_snan(y)))           	# 结果为True
print(‘%s 是否为sNaN：%s’ % (z,context.is_snan(z)))          	# 结果为False
print(‘%s 是否为sNaN：%s’ % (k,context.is_snan(k)))           	# 结果为False

92. is_subnormal()方法，判断一个数是否为非正规数

decimal 模块的 Context 类的 is_subnormal() 方法用于判断一个数是否为非正规数。语法格式如下：

is_subnormal(x)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：布尔类型，如果 x 是非正规数，则返回 True，否则返回 False。

说明：非正规数是指比最小的正常数更小的非零数字，也称为次正规数。

判断一个数是否为非正规数，代码如下：

import decimal                                     	# 导入十进制定点和浮点运算模块

context = decimal.getcontext()                  	# 获取上下文对象
x = decimal.Decimal(‘1e-9999990’)            		# 比双精度最小标准正浮点数更小的数
y = decimal.Decimal(‘-0’)                        	# 通过字符串创建Decimal对象，值为-0
z = decimal.Decimal(‘NaN’)                     		# 通过字符串创建Decimal对象，值为NaN
k = decimal.Decimal(‘-Infinity’)                	# 通过字符串创建Decimal对象，值为-Infinity

print(‘%s 是否为非正规数：%s’ % (x,context.is_subnormal(x)))                # 结果为True
print(‘%s 是否为非正规数：%s’ % (y,context.is_subnormal(y)))                # 结果为False
print(‘%s 是否为非正规数：%s’ % (z,context.is_subnormal(z)))                # 结果为False
print(‘%s 是否为非正规数：%s’ % (k,context.is_subnormal(k)))                # 结果为False

93. is_zero()方法，判断一个数是否为零

decimal 模块的 Context 类的 is_zero() 方法用于判断一个数是否为零。语法格式如下：

is_zero(x)decimal

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：布尔类型，如果 x 为零，则返回 True，否则返回 False。

判断一个数是否为零，代码如下：

import decimal                                     	# 导入十进制定点和浮点运算模块

context = decimal.getcontext()                  	# 获取上下文对象
x = decimal.Decimal(0)                          	# 0
y = decimal.Decimal(‘-0’)                        	# 通过字符串创建Decimal对象，值为-0
z = decimal.Decimal(‘NaN’)                     		# 通过字符串创建Decimal对象，值为NaN
k = decimal.Decimal(‘0.1’)                       	# 通过字符串创建Decimal对象，值为0.1

print(‘%s 是否为零：%s’%(x,context.is_zero(x)))    	# 结果为True
print(‘%s 是否为零：%s’%(y,context.is_zero(y)))    	# 结果为True
print(‘%s 是否为零：%s’%(z,context.is_zero(z)))    	# 结果为False
print(‘%s 是否为零：%s’%(k,context.is_zero(k)))    	# 结果为False

94. ln()方法，求一个数的自然（以e为底）对数

decimal 模块的 Context 类的 ln() 方法用于返回一个数的自然（以 e 为底）对数。语法格式如下：

ln(x)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：一个数的自然（以 e 为底）对数。

说明：e 为无限不循环小数，通常情况下，取 e=2.71828。

分别求 0、100 和 0.001 的以 e 为底的对数并输出，代码如下：

import decimal                               	# 导入十进制定点和浮点运算模块

context = decimal.getcontext()            		# 获取上下文对象
context.prec = 8                              	# 设置精度为8
x = decimal.Decimal(0)                     		# 0
y = decimal.Decimal(100)                  		# 整数
z = decimal.Decimal(‘0.001’)              		# 通过字符串创建Decimal对象，值为0.001

print(context.ln(x))                          	# 结果为-Infinity
print(context.ln(y))                          	# 结果为4.6051702
print(context.ln(z))                          	# 结果为-6.9077553

95. log10()方法，求一个数的常用对数

decimal 模块的 Context 类的 log10() 方法用于返回一个数的常用对数。语法格式如下：

log10(x)

参数说明：

• x ：一个大于等于零的数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：一个数的常用对数，即以 10 为底的对数。

分别求 0、100 和 0.001 的常用对数并输出，代码如下：

import decimal                               	# 导入十进制定点和浮点运算模块

x = decimal.Decimal(0)                     		# 0decimal
y = decimal.Decimal(100)                  		# 整数
z = decimal.Decimal(‘0.001’)              		# 通过字符串创建Decimal对象，值为0.001

print(decimal.getcontext().log10(x))      # 结果为-Infinity
print(decimal.getcontext().log10(y))      # 结果为2
print(decimal.getcontext().log10(z))      # 结果为-3

96. logb()方法，获取一个数的调整指数

decimal 模块的 Context 类的 logb() 方法用于返回一个数的调整指数。语法格式如下：

logb(x)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。如果指定为 0，则抛出“decimal.DivisionByZero: [<class ‘decimal.DivisionByZero’ >]”异常。

• 返回值：一个数的调整指数，这里的值为将一个数调整为科学记数法表示后的指数。例如，0.001 转换为科学记数法表示为 1E-3，这个数的调整指数即为 -3。

创建小数、负整数和通过字符串创建的整数，然后分别获取这些数的调整指数并输出，代码如下：

import decimal                               	# 导入十进制定点和浮点运算模块

x = decimal.Decimal(0.14159)            		# 小数
y = decimal.Decimal(-300)                 		# 负整数
z = decimal.Decimal(‘1001’)               		# 通过字符串创建Decimal对象，值为1001

print(decimal.getcontext().logb(x))       # 结果为-1
print(decimal.getcontext().logb(y))       # 结果为2
print(decimal.getcontext().logb(z))       # 结果为3

97. logical_and()方法，对两个操作数进行逻辑与运算

decimal 模块的 Context 类的 logical_and() 方法用于对两个操作数的数字进行逻辑与运算。语法格式如下：

logical_and(x, y)

参数说明：

• x ：一个逻辑数字，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• y ：一个逻辑数字，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：进行逻辑与运算的结果。

说明：在使用 logical_and() 方法时，指定的两个操作数必须都是逻辑数字，即由 0 或 1 组成的数。否则将抛出“decimal.InvalidOperation: [<class ‘decimal.InvalidOperation’ >]”异常。

对两个操作数进行与运算，代码如下：decimal

import decimal                                              # 导入十进制定点和浮点运算模块

x = decimal.Decimal(1)                                      # 一个数
y = decimal.Decimal(0)                                      # 第二个数
z = decimal.Decimal(‘01’)                                   # 第三个数（创建为Decimal对象后值为1）

result = decimal.getcontext().logical_and(x,y)          	# 1和0进行逻辑与运算，结果为0
result2 = decimal.getcontext().logical_and(x,z)         	# 1和1进行逻辑与运算，结果为1

print(result)
print(result2)

98. logical_invert()方法，对一个数进行按位取反运算

decimal模块的Context类的logical_invert()方法用于对一个数进行按位取反运算。语法格式如下：

logical_invert(x)

参数说明：

• x ：一个逻辑数字，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：进行按位取反的结果。

说明：在使用 logical_invert() 方法时，指定的操作数必须是逻辑数字，即由 0 或 1 组成的数。否则将抛出“decimal.InvalidOperation: [<class ‘decimal.InvalidOperation’ >]”异常。

对一个二进制数中的所有数字按位取反，代码如下：

import decimal                          	# 导入十进制定点和浮点运算模块

x = decimal.Decimal(11)              		# 值为11的二进制数
y = decimal.Decimal(0)               		# 值为0的二进制数
z = decimal.Decimal(‘10010’)        		# 值为10010的二进制数

print(x,’取反后：',decimal.getcontext().logical_invert(x))
print(y,’取反后：',decimal.getcontext().logical_invert(y))
print(z,’取反后：',decimal.getcontext().logical_invert(z))

程序运行结果如下：

11 取反后： 1111111111111111111111111100
0 取反后： 1111111111111111111111111111
10010 取反后： 1111111111111111111111101101

说明：在进行按位取反运算时，Python 会自动将被取反的数转换为当前精度所指长度的逻辑数字，然后按位依次取反。上面的运行结果中，由于当前上下文对象的默认精度为 28，所以返回的数字长度为 28。如果想改变这个长度，可以为当前上下文指定精度，这可以通过它的 prec 属性设置。

99. logical_or()方法，对两个操作数进行逻辑或运算

decimal 模块的 Context 类的 logical_or() 方法用于对两个操作数进行逻辑或运算。语法格式如下：

logical_or(x, y)

参数说明：

• x ：一个逻辑数字，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。decimal

• y ：一个逻辑数字，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：进行逻辑或运算的结果。

说明：在使用 logical_or() 方法时，指定的两个操作数必须都是逻辑数字，即由 0 或 1 组成的数。否则将抛出“decimal.InvalidOperation: [<class ‘decimal.InvalidOperation’ >]”异常。

对两个操作数进行或运算，代码如下：

import decimal                                       	# 导入十进制定点和浮点运算模块

x = decimal.Decimal(1)                                	# 一个数
y = decimal.Decimal(0)                                	# 第二个数
z = decimal.Decimal(‘01’)                             	# 第三个数（创建为Decimal对象后值为1）

result = decimal.getcontext().logical_or(x,y)       	# 1和0进行逻辑或运算，结果为1
result2 = decimal.getcontext().logical_or(x,z)      	# 1和1进行逻辑或运算，结果为1
print(result)
print(result2)

100. logical_xor()方法，对两个操作数进行逻辑异或运算

decimal 模块的 Context 类的 logical_xor() 方法用于对两个操作数进行逻辑异或运算。语法格式如下：

logical_xor(x, y)

参数说明：

• x ：一个逻辑数字，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• y ：一个逻辑数字，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：进行逻辑异或运算的结果。

说明：在使用 logical_xor() 方法时，指定的两个操作数必须都是逻辑数字，即由 0 或 1 组成的数。否则将抛出“decimal.InvalidOperation: [<class ‘decimal.InvalidOperation’ >]”异常。

对两个操作数进行逻辑异或运算，代码如下：

import decimal                                        	# 导入十进制定点和浮点运算模块

x = decimal.Decimal(1)                                	# 一个数
y = decimal.Decimal(0)                                	# 第二个数
z = decimal.Decimal(‘01’)                             	# 第三个数（创建为Decimal对象后值为1）

result = decimal.getcontext().logical_xor(x,y) 			# 1和0进行逻辑异或运算，结果为1
result2 = decimal.getcontext().logical_xor(x,z)    		# 1和1进行逻辑异或运算，结果为0
print(result)
print(result2)

101. max()方法，求两个数的最大值

decimal 模块的 Context 类的 max() 方法用于求两个数的最大值。语法格式如下：

max(x, y)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• y ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：两个数的最大值。如果其中的一个数为 NaN，则结果为另一个数。只有两个数均为NaN，才返回 NaN。

求两个数的最大值，代码如下：

import decimal                                              # 导入十进制定点和浮点运算模块

x = decimal.Decimal(131)                                    # 一个正数decimal
y = decimal.Decimal(‘-1500’)                                # 一个负数
z = decimal.Decimal(‘0’)                                    # 0

result = decimal.getcontext().max(x,y)                    	# 输出131
result2 = decimal.getcontext().max(x,z)                    	# 输出131
result3 = decimal.getcontext().max(y,z)                  	# 输出0

print(result)
print(result2)
print(result3)

102. max_mag()方法，求两个数绝对值的最大值

decimal 模块的 Context 类的 max_mag() 方法用于求两个数绝对值的最大值，即忽略符号后进行比较求最大值。语法格式如下：

max_mag(x, y)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• y ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：两个数绝对值的最大值。如果其中的一个数为 NaN，则结果为另一个数。只有两个数均为 NaN，才返回 NaN。

求两个数的最大值（忽略符号），代码如下：

import decimal                                      # 导入十进制定点和浮点运算模块

x = decimal.Decimal(131)                            # 一个正数
y = decimal.Decimal(‘-1500’)                        # 一个负数
z = decimal.Decimal(‘0’)                            # 0

result = decimal.getcontext().max_mag(x,y)       	# 输出-1500
result2 = decimal.getcontext().max_mag(x,z)      	# 输出131
result3 = decimal.getcontext().max_mag(y,z)      	# 输出-1500

print(result)
print(result2)
print(result3)

103. min()方法，求两个数的最小值

decimal 模块的 Context 类的 min() 方法用于求两个数的最小值。语法格式如下：

min(x, y)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• y ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。decimal

• 返回值：两个数的最小值。如果其中的一个数为 NaN，则结果为另一个数。只有两个数均为NaN，才返回 NaN。

求两个数的最小值，代码如下：

import decimal                                 # 导入十进制定点和浮点运算模块

x = decimal.Decimal(131)                       # 一个正数
y = decimal.Decimal(‘-1500’)                   # 一个负数
z = decimal.Decimal(‘0’)                       # 0

result = decimal.getcontext().min(x,y)         # 输出-1500
result2 = decimal.getcontext().min(x,z)        # 输出0
result3 = decimal.getcontext().min(y,z)        # 输出-1500

print(result)
print(result2)
print(result3)

104. min_mag()方法，求两个数绝对值的最小值

decimal 模块的 Context 类的 min_mag() 方法用于求两个数绝对值的最小值，即忽略符号后进行

比较求最小值。语法格式如下：

min_mag(x, y)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• y ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：两个数绝对值的最小值。如果其中的一个数为 NaN，则结果为另一个数。只有两个数均为 NaN，才返回 NaN。

求两个数的最小值（忽略符号），代码如下：

import decimal                                         # 导入十进制定点和浮点运算模块

x = decimal.Decimal(131)                               # 一个正数
y = decimal.Decimal(‘-1500’)                           # 一个负数
z = decimal.Decimal(‘0’)                               # 0

result = decimal.getcontext().min_mag(x,y)             # 输出131
result2 = decimal.getcontext().min_mag(x,z)            # 输出0
result3 = decimal.getcontext().min_mag(y,z)            # 输出0

print(result)
print(result2)
print(result3)

105. minus()方法，转换为相反数

decimal 模块的 Context 类的 minus() 方法用于将一个数转换为其相反数，即正数变负数，负数变正数，0 不变。语法格式如下：

minus(x)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：x 的相反数，如果 x 是 0，则返回 0。

求一个数的相反数，代码如下：

import decimal                               	# 导入十进制定点和浮点运算模块

##from decimal import *                   		# 导入十进制定点和浮点运算模块

x = decimal.Decimal(-100)                 		# 一个负数
y = decimal.Decimal(‘101’)           			# 一个正数

result = decimal.getcontext().minus(x)
result2 = decimal.getcontext().minus(y)

print(result)
print(result2)

106. multiply()方法，乘法运算

decimal 模块的 Context 类的 multiply() 方法用于实现乘法运算，即求两个数相乘的积。语法格式如下：

multiply(x, y)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• y ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：两个数的乘积。

求两个数的积，代码如下：

import decimal                                       # 导入十进制定点和浮点运算模块

x = decimal.Decimal(-100)                            # 一个负数
y = decimal.Decimal(‘1.01’)                          # 一个正数
z = decimal.Decimal(‘2.00’)                          # 一个正数
a = decimal.Decimal(‘-2.3’)                          # 一个负数

result = decimal.getcontext().multiply(x,y)        	 # 负数乘以正数
result2 = decimal.getcontext().multiply(y,z)         # 正数乘以正数
result3 = decimal.getcontext().multiply(x,a)         # 负数乘以负数

print(result)
print(result2)
print(result3)

107. next_minus()方法，获取小于一个数的最大数

decimal 模块的 Context 类的 next_minus() 方法用于返回小于一个数的最大可表示数字。语法格式如下：

next_minus(x) 

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：小于 x 的最大可表示数字。

获取小于一个数的最大可表示数，代码如下：

import decimal                                       # 导入十进制定点和浮点运算模块

x = decimal.Decimal(-100)                            # 负整数
y = decimal.Decimal(‘1.01’)                          # 正小数
z = decimal.Decimal(‘-2.3’)                          # 负小数
a = decimal.Decimal(2000)                            # 正整数

result = decimal.getcontext().next_minus(x)
result2 = decimal.getcontext().next_minus(y)
result3 = decimal.getcontext().next_minus(z)
result4 = decimal.getcontext().next_minus(a)

print(‘小于', x, ‘的最大数是', result)
print(‘小于', y, ‘的最大数是', result2)
print(‘小于', z, ‘的最大数是', result3)
print(‘小于', a, ‘的最大数是', result4)

108. next_plus()方法，获取大于一个数的最小数

decimal 模块的 Context 类的 next_plus() 方法用于返回大于一个数的最小可表示数字。语法格式如下：

next_plus(x)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：大于 x 的最小可表示数字。

获取大于一个数的最小可表示数，代码如下：

import decimal                                 	# 导入十进制定点和浮点运算模块

x = decimal.Decimal(-100)                     	# 负整数
y = decimal.Decimal(‘1.01’)                     # 正小数
z = decimal.Decimal(‘-2.3’)                     # 负小数
a = decimal.Decimal(2000)                      	# 正整数

result = decimal.getcontext().next_plus(x)
result2 = decimal.getcontext().next_plus(y)
result3 = decimal.getcontext().next_plus(z)
result4 = decimal.getcontext().next_plus(a)

print(‘大于', x, ‘的最小数是', result)
print(‘大于', y, ‘的最小数是', result2)
print(‘大于', z, ‘的最小数是', result3)
print(‘大于', a, ‘的最小数是', result4)

109. next_toward()方法，获取最接近这个数的数

decimal 模块的 Context 类的 next_toward() 方法用于返回朝第二个参数方向最接近第一个参数的数字。语法格式如下：

next_toward(x, y)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• y ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：返回朝 y 方向最接近 x 的数字。decimal

定义 4 个数（保存在变量 x、y、z、k 中），测试使用 next_toward() 方法返回最接近 x（正数）和z（负数）的数，从而比较正负数对结果的影响，代码如下：

import decimal                                              # 导入十进制定点和浮点运算模块

decimal.getcontext().prec = 3                               # 设置精度为3
x = decimal.Decimal(‘0.1’)                                  # 正数
y = decimal.Decimal(‘0.2’)                                  # 正数
z = decimal.Decimal(‘-0.1’)                                 # 负数
k = decimal.Decimal(‘-0.2’)                                 # 负数

result = decimal.getcontext().next_toward(x,y)         		# 两个正数
result2 = decimal.getcontext().next_toward(z,y)        		# 一正一负
result3 = decimal.getcontext().next_toward(z,k)        		# 两个负数

print(‘x = %s y = %s next_toward(x,y)结果为：%s’ % (x,y,result))
print(‘z = %s y = %s next_toward(z,y)结果为：%s’ % (z,y,result2))
print(‘z = %s k = %s next_toward(z,k)结果为：%s’ % (z,k,result3))

110. normalize()方法，返回一个数的最简单形式

decimal 模块的 Context 类的 normalize() 方法用于返回一个数的最简单形式。语法格式如下：

normalize(x)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：decimal.Context 对象。

返回超出精度的小数或整数、以 0 结尾的小数的最简单形式，代码如下：

import decimal                                           # 导入十进制定点和浮点运算模块

decimal.getcontext().prec = 3                            # 设置精度为3
x = decimal.Decimal(‘3.1415926’)                         # 超出指定精度的小数，并且截取后以0结尾
y = decimal.Decimal(‘0.2000’)                            # 以0结尾的小数
z = decimal.Decimal(‘0.10001’)                      	 # 超出指定精度的小数
k = decimal.Decimal(‘02019’)                             # 超出精度的整数

result = decimal.getcontext().normalize(x)
result2 = decimal.getcontext().normalize(y)
result3 = decimal.getcontext().normalize(z)
result4 = decimal.getcontext().normalize(k)

print(‘x = %s normalize(x)结果为：%s’ % (x,result))
print(‘y = %s normalize(y)结果为：%s’ % (y,result2))
print(‘z = %s normalize(z)结果为：%s’ % (z,result3))
print(‘k = %s normalize(z)结果为：%s’ % (k,result4))

111. number_class()方法，返回一个数的类指示

decimal 模块的 Context 类的 number_class() 方法用于返回 x 的类指示。语法格式如下：

number_class(x)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：字符串，表示参数 x 的类指示。

定义 3 个变量，分别保存正数、负数和 0，使用 number_class() 方法返回每个数的类指示，代码如下：

import decimal                                                # 导入十进制定点和浮点运算模块

x = decimal.Decimal(‘3.1415926’)                              # 正数
y = decimal.Decimal(‘-0.2000’)                                # 负数
z = decimal.Decimal(‘0’)                                      # 0

result = decimal.getcontext().number_class(x)                 # 正数
result2 = decimal.getcontext().number_class(y)                # 负数
result3 = decimal.getcontext().number_class(z)                # 0

print(‘x = %s number_class(x)结果为：%s’ % (x,result))
print(‘y = %s number_class(y)结果为：%s’ % (y,result2))
print(‘z = %s number_class(z)结果为：%s’ % (z,result3))

112. plus()方法，进行一元加法及舍入运算

decimal 模块的 Context 类的 plus() 方法用于进行一元加法运算，并且根据 Context（上下文）精度进行舍入操作。语法格式如下：

plus(x)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：decimal.Context 对象。

分别对正浮点数、负浮点数和正整数进行四舍五入到指定精度（这里为 3）操作，代码如下：

import decimal                                           # 导入十进制定点和浮点运算模块

decimal.getcontext().prec = 3                            # 设置精度为3
x = decimal.Decimal(‘3.1415926’)                         # 正浮点数
y = decimal.Decimal(‘-0.2000’)                           # 负浮点数
z = decimal.Decimal(‘202’)                               # 正整数

result = decimal.getcontext().plus(x)                    # 正浮点数
result2 = decimal.getcontext().plus(y)                   # 负浮点数
result3 = decimal.getcontext().plus(z)                   # 正整数

print(‘x = %s plus(x)结果为：%s’ % (x,result))
print(‘y = %s plus(y)结果为：%s’ % (y,result2))
print(‘z = %s plus(z)结果为：%s’ % (z,result3))

113. power()方法，进行幂运算

decimal 模块的 Context 类的 power() 方法用于计算一个数 x 的 y 次幂。语法格式如下：

power(x, y, modulo=None)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• y ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• modulo ：可选参数，当指定该参数时，计算 (x**y)%modulo。此时，x、y 和 modulo 都必须是 整数，y 必须是非负数，x 和 y 至少有一个是非零数，modulo 必须是非零数，并且不能超过精度所指定的数字位数。如果不符合以上条件中的任何一个，都将抛出“decimal.InvalidOperation: [<class ‘decimal.InvalidOperation’>]”异常。

• 返回值：计算结果。如果指定前两个参数，则计算 xy，即计算 x 的 y 次幂；如果指定 3 个参数，则计算 (xy)%modulo。

计算一个数的 n 次幂，代码如下：

import decimal                                              # 导入十进制定点和浮点运算模块

decimal.getcontext().prec = 3                               # 设置精度为3
x = decimal.Decimal(‘2’)                                    # 正数
y = decimal.Decimal(‘-3’)                                   # 负数
z = decimal.Decimal(‘0’)                                    # 0
k = decimal.Decimal(‘2000’)                                 # 超过精度的数

result = decimal.getcontext().power(x,y)
result2 = decimal.getcontext().power(y,z)
result3 = decimal.getcontext().power(z,x)
result4 = decimal.getcontext().power(k,x)

print(‘x = %s y = %s power(x,y)结果为：%s’ % (x,y,result))
print(‘y = %s z = %s power(y,z)结果为：%s’ % (y,z,result2))
print(‘z = %s x = %s power(z,x)结果为：%s’ % (z,x,result3))
print(‘k = %s x = %s power(k,x)结果为：%s’ % (k,x,result4))

114. quantize()方法，返回一个数根据指数舍入后的值

decimal 模块的 Context 类的 quantize() 方法用于返回一个舍入后的 x 的值，它的指数通过 y 指定。语法格式如下：

quantize(x, y)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象，用于指定一个数。

• y ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象，用于指定指数。它的值可以是 0.1、0.001、0、1e+5（即 100000）、1e-1（即 0.1）、Infinity 等，但是当值为小数时，该值的精度不能超过所设置的上下文的精度。例如，精度为 3，则 y 的小数点后最多有 2 位。

• 返回值：decimal.Context 对象。

使用 quantize() 方法获取一个数根据不同指数舍入后的值，代码如下：

import decimal                               	# 导入十进制定点和浮点运算模块

decimal.getcontext().prec = 4              		# 设置精度为4
x = decimal.Decimal(‘3.14159’)      			# 正数
y = decimal.Decimal(‘0.01’)               		# 两位小数
z = decimal.Decimal(‘0’)                   		# 零
k = decimal.Decimal(‘1e-1’)               		# 0.1
m = decimal.Decimal(‘Infinity’)      			# 正无穷

result = decimal.getcontext().quantize(x,y)
result2 = decimal.getcontext().quantize(x,z)
result3 = decimal.getcontext().quantize(x,k)
result4 = decimal.getcontext().quantize(decimal.Decimal(‘-Inf’),decimal.Decimal(‘Infinity’))

print(‘x = %s y = %s quantize(x,y)结果为：%s’ % (x,y,result))
print(‘x = %s z = %s quantize(x,z)结果为：%s’ % (x,z,result2))
print(‘x = %s k = %s quantize(x,k)结果为：%s’ % (x,k ,result3))
print(‘quantize(decimal.Decimal(\’-Inf\’),decimal.Decimal(\’Infinity\’))结果为：%s’%(result4))

115. radix()方法，获取基数

decimal 模块的 Context 类的 radix() 方法用于获取一个数的基数。语法格式如下：

radix()

参数说明：

• 返回值：10，因为 decimal 模块是十进制模块。

返回当前上下文的基数，代码如下：

import decimal								# 导入十进制定点和浮点运算模块
print(decimal.getcontext().radix())

116. remainder()方法，获取整数除法的余数

decimal 模块的 Context 类的 remainder() 方法用于返回整数除法的余数。语法格式如下：

remainder(x, y)

参数说明：

• x ：一个整数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象，用于指定被除数。

• y ：一个不为 0 的整数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象，用于指定除数。

• 返回值：对两个整数进行求余运算的结果。

说明：当被除数和除数为异号时，使用 remainder() 方法对负数求余的结果与使用 Python 基本运算符中的 % 的结果不同。例如，计算“2019%-4”的结果为 -1，而使用 remainder() 方法求余的结果为 3。

计算两个整数求余的结果，代码如下：decimal

import decimal                               	# 导入十进制定点和浮点运算模块

decimal.getcontext().prec = 4              		# 设置精度为4
x = decimal.Decimal(‘-2019’)              		# 负数
y = decimal.Decimal(‘4’)                   		# 正数
z = decimal.Decimal(‘-4’)                  		# 负数
k = decimal.Decimal(‘2019’)               		# 正数
m = decimal.Decimal(‘0’)                   		# 0

result = decimal.getcontext().remainder(x,y)
result2 = decimal.getcontext().remainder(x,z)
result3 = decimal.getcontext().remainder(k,y)
result4 = decimal.getcontext().remainder(k,z)
result5 = decimal.getcontext().remainder(m,y)

print(‘x = %s y = %s remainder(x,y)结果为：%s’ % (x,y,result))
print(‘x = %s z = %s remainder(x,z)结果为：%s’ % (x,z,result2))
print(‘k = %s y = %s remainder(k,y)结果为：%s’ % (k,x,result3))
print(‘k = %s z = %s remainder(k,z)结果为：%s’ % (k,z,result4))
print(‘m = %s y = %s remainder(m,y)结果为：%s’ % (m,y,result5))

117. remainder_near()方法，获取两数相除的余数

decimal 模块的 Context 类的 remainder_near() 方法用于获取两个数相除的余数（可以为浮点数）。语法格式如下：

remainder_near(x, y)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象，用于指定被除数。

• y ：一个不为 0 的数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象，用于指定除数。

• 返回值：两数相除的余数，其值为 x-y*n 的结果，其中，n 为商（取值为最接近精确值的数）。

分别对正数、负数求余，代码如下：

import decimal                               	# 导入十进制定点和浮点运算模块

decimal.getcontext().prec = 4              		# 设置精度为4
x = decimal.Decimal(‘-2019’)              		# 作为被除数（负数）
y = decimal.Decimal(‘4.5’)                 		# 作为除数（正数）
z = decimal.Decimal(‘-4.5’)                		# 作为除数（负数）
k = decimal.Decimal(‘2019’)               		# 作为被除数（正数）
m = decimal.Decimal(0)                    		# 0

result = decimal.getcontext().remainder_near(x,y)
result2 = decimal.getcontext().remainder_near(x,z)
result3 = decimal.getcontext().remainder_near(k,y)
result4 = decimal.getcontext().remainder_near(k,z)
result5 = decimal.getcontext().remainder_near(m,y)

print(‘x = %s y = %s remainder_near(x,y)结果为：%s’ % (x,y,result))
print(‘x = %s z = %s remainder_near(x,z)结果为：%s’ % (x,z,result2))
print(‘k = %s y = %s remainder_near(k,y)结果为：%s’ % (k,y,result3))
print(‘k = %s z = %s remainder_near(k,z)结果为：%s’ % (k,z,result4))
print(‘m = %s y = %s remainder_near(m,y)结果为：%s’ % (m,y,result5))

118. rotate()方法，将数字循环移位指定次数

decimal 模块的 Context 类的 rotate() 方法用于返回一个数字循环移位多少次的结果。语法格式如下：

rotate(x, y)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象，用于指定被循环移位的数。decimal

• y ：一个整数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。用于指定循环移位次数。当值为正数时，表示顺时针循环移位；值为负数时，表示逆时针循环移位。每次移位一位数字。

• 返回值：decimal.Context 对象，值为 x 循环移位 y 次的结果，符号与原数字相同。例如，2019循环移位 3 次的结果为 9201。

将正数或负数，顺时针或逆时针循环移位指定次数，代码如下：

import decimal                                              # 导入十进制定点和浮点运算模块

decimal.getcontext().prec = 4                               # 设置精度为4
x = decimal.Decimal(‘-2019’)                                # 被循环移位的数（负数）
y = decimal.Decimal(‘3’)                                    # 顺时针循环移位
z = decimal.Decimal(‘-3’)                                   # 逆时针循环移位
k = decimal.Decimal(‘2019’)                                 # 被循环移位的数（正数）

result = decimal.getcontext().rotate(x,y)                   # 顺时针循环移位
result2 = decimal.getcontext().rotate(x,z)                  # 逆时针循环移位
result3 = decimal.getcontext().rotate(k,y)                  # 顺时针循环移位
result4 = decimal.getcontext().rotate(k,z)                  # 逆时针循环移位

print(‘x = %s y = %s rotate(x,y)结果为：%s’ % (x,y,result))
print(‘x = %s z = %s rotate(x,z)结果为：%s’ % (x,z,result2))
print(‘k = %s y = %s rotate(k,y)结果为：%s’ % (k,y,result3))
print(‘k = %s z = %s rotate(k,z)结果为：%s’ % (k,z,result4))

119. same_quantum()方法，判断两个数的指数是否相同

decimal 模块的 Context 类的 same_quantum() 方法用于判断两个操作数是否具有相同的指数。语法格式如下：

same_quantum(x, y)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• y ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：布尔值。如果 x 和 y 的指数相同，则返回 True，否则返回 False。

判断两个操作数是否具有相同的指数，代码如下：

import decimal                                        # 导入十进制定点和浮点运算模块

decimal.getcontext().prec = 4                         # 设置精度为4
x = decimal.Decimal(‘3.14159’)                        # 5位小数
y = decimal.Decimal(‘3.14’)                           # 两位小数
z = decimal.Decimal(‘-3.14’)                          # 两位小数
k = decimal.Decimal(‘6.28’)                           # 两位小数

result = decimal.getcontext().same_quantum(x,y)
result2 = decimal.getcontext().same_quantum(y,z)
result3 = decimal.getcontext().same_quantum(y,k)

print(‘x = %s y = %s same_quantum(x,y)结果为：%s’ % (x,y,result))
print(‘y = %s z = %s same_quantum(y,z)结果为：%s’ % (y,z,result2))
print(‘y = %s k = %s same_quantum(y,k)结果为：%s’ % (y,k,result3))

120. scaleb()方法，计算一个数乘以10的指定次幂

decimal 模块的 Context 类的 scaleb() 方法用于将一个数乘以 10 的指定次幂。语法格式如下：

scaleb(x, y)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。decimal

• y ：一个整数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：decimal.Decimal 对象，其值为 x*10**y。

将一个数分别乘以 10 的正数次幂、负数次幂和零次幂，代码如下：

import decimal                                     	# 导入十进制定点和浮点运算模块

decimal.getcontext().prec = 4                    	# 设置精度为4
x = decimal.Decimal(‘3.14159’)           			# 一个数
y = decimal.Decimal(‘2’)                         	# 正数
z = decimal.Decimal(‘-2’)                        	# 负数
k = decimal.Decimal(‘0’)                         	# 0

result = decimal.getcontext().scaleb(x,y)
result2 = decimal.getcontext().scaleb(x,z)
result3 = decimal.getcontext().scaleb(x,k)

print(‘x = %s y = %s scaleb(x,y)结果为：%s’ % (x,y,result))
print(‘x = %s z = %s scaleb(x,z)结果为：%s’ % (x,z,result2))
print(‘x = %s k = %s scaleb(x,k)结果为：%s’ % (x,k,result3))

121. shift()方法，将数字移位指定位数

decimal 模块的 Context 类的 shift() 方法用于将一个数移位指定位数。语法格式如下：

shift(x, y)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象，用于指定被移位的数。

• y ：一个整数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象，用于指定移位次数。当值为正数时，表示向左移；值为负数时，表示向右移。

• 返回值：decimal.Context 对象，值为 x 移位 y 次的结果。例如，2019 移位 3 次的结果为2019000。

将一个数分别移位不同位数，并显示移位结果，代码如下：

import decimal                                   # 导入十进制定点和浮点运算模块

x = decimal.Decimal(‘12’)                        # 被移位的数（正数）
y = decimal.Decimal(‘9’)                         # 正数
z = decimal.Decimal(‘-3’)                        # 负数
k = decimal.Decimal(‘0’)                         # 0

result = decimal.getcontext().shift(x,y)
result2 = decimal.getcontext().shift(x,z)
result3 = decimal.getcontext().shift(x,k)

print(‘x = %s y = %s shift(x,y)结果为：%s’ % (x,y,result))
print(‘x = %s z = %s shift(x,z)结果为：%s’ % (x,z,result2))
print(‘x = %s k = %s shift(x,k)结果为：%s’ % (x,k,result3))

122. sqrt()方法，获取一个数的平方根

decimal 模块的 Context 类的 sqrt() 方法用于返回一个数的平方根（被精确到上下文设定的精度）。语法格式如下：

sqrt(x)

参数说明：

• x ：一个大于等于零的数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象，用于指定被开平方的数。

• 返回值：decimal.Context 对象，值为开平方的结果。

获取不同数的平方根并输出，代码如下：decimal

import decimal                    # 导入十进制定点和浮点运算模块

x = decimal.Decimal(‘4’)
y = decimal.Decimal(‘2’)
z = decimal.Decimal(‘4.6’)
k = decimal.Decimal(‘0’)

result = decimal.getcontext().sqrt(x)
result2 = decimal.getcontext().sqrt(y)
result3 = decimal.getcontext().sqrt(z)
result4 = decimal.getcontext().sqrt(k)

print(‘x = %s sqrt(x)结果为：%s’ % (x,result))
print(‘y = %s sqrt(y)结果为：%s’ % (y,result2))
print(‘z = %s sqrt(z)结果为：%s’ % (z,result3))
print(‘k = %s sqrt(k)结果为：%s’ % (k,result4))

123. subtract()方法，计算两个数的差

decimal 模块的 Context 类的 subtract() 方法用于计算两个数的差。语法格式如下：

subtract(x, y)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象，用于指定被减数。

• y ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象，用于指定减数。

• 返回值：decimal.Decimal 对象，其值为 x-y 的差。

分别计算 x 与 y、z、k 的差，代码如下：

import decimal                                   # 导入十进制定点和浮点运算模块

decimal.getcontext().prec = 4                    # 设置精度为4
x = decimal.Decimal(‘3.14159’)                   # 被旋转的数（正浮点数）
y = decimal.Decimal(‘2’)                         # 正整数
z = decimal.Decimal(‘-2’)                        # 负整数
k = decimal.Decimal(‘0’)                         # 0

result = decimal.getcontext().subtract(x,y)
result2 = decimal.getcontext().subtract(x,z)
result3 = decimal.getcontext().subtract(x,k)

print(‘x = %s y = %s subtract(x,y)结果为：%s’ % (x,y,result))
print(‘x = %s z = %s subtract(x,z)结果为：%s’ % (x,z,result2))
print(‘x = %s k = %s subtract(x,k)结果为：%s’ % (x,k,result3))

124. to_eng_string()方法，转换为工程类型的字符串

decimal 模块的 Context 类的 to_eng_string() 方法用于将一个数转换为工程类型的字符串，如果需要指数，则为 3 的倍数，即可以在小数点左边留下最多 3 位数，并且还可能需要添加一个或两个尾随零。语法格式如下：

to_eng_string(x)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象，用于指定被转换的数。它可以通过字符串创建，也可通过数值（包括科学记数法形式）创建。

• 返回值：x 被转换为工程类型的字符串，可能是字符串本身，也可能是被转换为以 3 的倍数表示的指数形式。例如，7E+7 转换后的结果为 70E+6。

将不同类型的数转换为工程类型的字符串，代码如下：

import decimal                               		# 导入十进制定点和浮点运算模块

decimal.getcontext().prec = 3              			# 设置精度为3

# 通过字符串类型的科学记数法指定的整数
x = decimal.Decimal(‘7E+7’)
result = decimal.getcontext().to_eng_string(x)
print(‘x = %s to_eng_string(x)结果为：%s’ % (x,result))

# 通过字符串类型的科学记数法指定的小数
y = decimal.Decimal(‘7E-7’)
result2 = decimal.getcontext().to_eng_string(y)
print(‘y = %s to_eng_string(y)结果为：%s’ % (y,result2))

# 正无穷
k = decimal.Decimal(‘infinity’)
result3 = decimal.getcontext().to_eng_string(k)
print(‘k = %s to_eng_string(k)结果为：%s’ % (k,result3))

# 通过字符串参数指定的小数
z = decimal.Decimal(‘0.1’)
result4 = decimal.getcontext().to_eng_string(z)
print(‘z = %s to_eng_string(z)结果为：%s’ % (z,result4))

# 通过数值参数指定的小数
m = decimal.Decimal(0.1)
result5 = decimal.getcontext().to_eng_string(m)
print(‘m = %s to_eng_string(m)结果为：%s’ % (m,result5))

# 通过数值类型的科学记数法指定的整数
n = decimal.Decimal(5E+3)
result6 = decimal.getcontext().to_eng_string(n)
print(‘n = %s to_eng_string(n)结果为：%s’ % (n,result6))

125. to_integral_exact()方法，舍入为整数

decimal 模块的 Context 类的 to_integral_exact() 方法用于将一个数按指定模式舍入为整数。语法格式如下：

to_integral_exact(x)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：decimal.Decimal 对象，其值为舍入后的整数。

将不同的数分别四舍五入为整数，代码如下：

import decimal                                            # 导入十进制定点和浮点运算模块

context = decimal.getcontext()                            # 获取上下文对象
context.prec = 3                                          # 设置精度为3
context.rounding = decimal.ROUND_HALF_UP       			  # 指定四舍五入模式

x = decimal.Decimal(‘1.5’)
y = decimal.Decimal(‘5E-1’)
k = decimal.Decimal(‘4.5’)
z = decimal.Decimal(‘0.414’)
m = decimal.Decimal(‘0.732’)
n = decimal.Decimal(5E+3)

result = decimal.getcontext().to_integral_exact(x)
print(‘x = %s to_integral_exact(x)结果为：%s’ % (x,result))

result2 = context.to_integral_exact(y)
print(‘y = %s to_integral_exact(y)结果为：%s’ % (y,result2))

result3 = context.to_integral_exact(k)
print(‘k = %s to_integral_exact(k)结果为：%s’ % (k,result3))

result4 = context.to_integral_exact(z)
print(‘z = %s to_integral_exact(z)结果为：%s’ % (z,result4))

result5 = context.to_integral_exact(m)
print(‘m = %s to_integral_exact(m)结果为：%s’ % (m,result5))

result6 = context.to_integral_exact(n)
print(‘n = %s to_integral_exact(n)结果为：%s’ % (n,result6))

126. to_sci_string()方法，将数字转换为字符串

decimal 模块的 Context 类的 to_sci_string() 方法用于将数字转换为字符串，如果数字用科学记数法表示，则转换后的字符串也使用科学记数法表示。语法格式如下：decimal

to_sci_string(x)

参数说明：

• x ：一个数，通过 decimal.Decimal 类的构造方法创建的一个 Decimal 对象。

• 返回值：转换后的字符串。

说明: to_sci_string() 方法不受上下文的影响。

使用科学记数法将数字转换为字符串，代码如下：

import decimal       				# 导入十进制定点和浮点运算模块

context = decimal.getcontext()		# 获取上下文对象
context.prec = 3      				# 设置精度为3

x = decimal.Decimal(‘3.1415926’)
y = decimal.Decimal(1E+10)
z = decimal.Decimal(50E-14)
m = decimal.Decimal(‘0.000000000000001’)

result = context.to_sci_string(x)
print(‘x = %s to_sci_string(x)结果为：%s’ % (x,result))

result2 = context.to_sci_string(y)
print(‘y = %s to_sci_string(y)结果为：%s’ % (y,result2))

result3 = context.to_sci_string(z)
print(‘z = %s to_sci_string(z)结果为：%s’ % (z,result3))

result4 = context.to_sci_string(m)
print(‘m = %s to_sci_string(m)结果为：%s’ % (m,result4))