源碼：?Lib/decimal.py

decimal?模塊為快速正確舍入的十進制浮點運算提供支持梯影。 它提供了?float?數(shù)據(jù)類型以外的幾個優(yōu)點：

Decimal 類型的“設(shè)計是基于考慮人類習慣的浮點數(shù)模型仲吏，并且因此具有以下最高指導原則 —— 計算機必須提供與人們在學校所學習的算術(shù)相一致的算術(shù)概漱。” —— 摘自 decimal 算術(shù)規(guī)范描述移剪。

Decimal 數(shù)字的表示是精確的究珊。 相比之下，1.1?和?2.2?這樣則是不精確的二進制浮點數(shù)表示纵苛。 最終用戶通常不希望?1.1?+?2.2?的結(jié)果會如采用二進制浮點數(shù)時那樣顯示為?3.3000000000000003剿涮。

精確性會延續(xù)到算術(shù)類操作中言津。 對于 decimal 浮點數(shù)，0.1?+?0.1?+?0.1?-?0.3?會精確地等于零取试。 而對于二進制浮點數(shù)悬槽，結(jié)果則為?5.5511151231257827e-017?。 雖然接近于零瞬浓，但其中的誤差將妨礙可靠的相等性檢驗初婆，并且誤差還會不斷累積。 因此瑟蜈，decimal 更適合具有嚴格相等不變性要求的會計類應(yīng)用烟逊。

decimal 模塊包含了有效位的概念，使得?1.30?+?1.20?是?2.50?铺根。 保留尾隨零以表示有效位宪躯。 這是貨幣類應(yīng)用的習慣表示法。 對于乘法位迂，“教科書”方式使用被乘數(shù)中的所有數(shù)位访雪。 例如，?1.3?*?1.2?給出?1.56?而?1.30?*?1.20?給出?1.5600?掂林。

與基于硬件的二進制浮點數(shù)不同臣缀，decimal 模塊具有用戶可更改的精度（默認為28位），可以與給定問題所需的一樣大：

>>>fromdecimalimport*

>>>getcontext().prec=6

>>>Decimal(1)/Decimal(7)

Decimal('0.142857')

>>>getcontext().prec=28

>>>Decimal(1)/Decimal(7)

Decimal('0.1428571428571428571428571429')

二進制和 decimal 浮點數(shù)都是根據(jù)已發(fā)布的標準實現(xiàn)的泻帮。 雖然內(nèi)置浮點類型只公開其功能的一小部分精置，但 decimal 模塊公開了標準的所有必需部分。 在需要時锣杂，程序員可以完全控制舍入和信號處理脂倦。 這包括通過使用異常來阻止任何不精確操作來強制執(zhí)行精確算術(shù)的選項踱稍。

decimal 模塊旨在支持“無偏差硫狞，精確無舍入的十進制算術(shù)（有時稱為定點數(shù)算術(shù)）和有舍入的浮點數(shù)算術(shù)”勿决。 —— 摘自 decimal 算術(shù)規(guī)范說明狭园。

該模塊的設(shè)計以三個概念為中心：decimal 數(shù)值胜臊，算術(shù)上下文和信號庇绽。

decimal 數(shù)值是不可變對象衷畦。 它由符號振劳，系數(shù)和指數(shù)位組成茎截。 為了保持有效位苇侵，系數(shù)位不會截去末尾零。 decimal 數(shù)值也包括特殊值例如?Infinity?企锌，-Infinity?和?NaN?榆浓。 該標準還區(qū)分?-0?和?+0?。

算術(shù)的上下文是指定精度霎俩、舍入規(guī)則哀军、指數(shù)限制沉眶、指示操作結(jié)果的標志以及確定符號是否被視為異常的陷阱啟用器的環(huán)境。 舍入選項包括?ROUND_CEILING?杉适、?ROUND_DOWN?谎倔、?ROUND_FLOOR?、?ROUND_HALF_DOWN,?ROUND_HALF_EVEN?猿推、?ROUND_HALF_UP?片习、?ROUND_UP?以及?ROUND_05UP.

信號是在計算過程中出現(xiàn)的異常條件組。 根據(jù)應(yīng)用程序的需要蹬叭，信號可能會被忽略藕咏，被視為信息，或被視為異常秽五。 十進制模塊中的信號有：Clamped?孽查、?InvalidOperation?、?DivisionByZero?坦喘、?Inexact?盲再、?Rounded?、?Subnormal?瓣铣、?Overflow?答朋、?Underflow?以及?FloatOperation?。對于每個信號棠笑，都有一個標志和一個陷阱啟動器梦碗。 遇到信號時，其標志設(shè)置為 1 蓖救，然后洪规，如果陷阱啟用器設(shè)置為 1 ，則引發(fā)異常藻糖。 標志是粘性的淹冰，因此用戶需要在監(jiān)控計算之前重置它們库车。

快速入門教程

通常使用 decimal 的方式是先導入該模塊巨柒，通過?getcontext()?查看當前上下文，并在必要時為精度柠衍、舍入或啟用的陷阱設(shè)置新值:

>>>fromdecimalimport*

>>>getcontext()

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

>>>getcontext().prec=7??????# Set a new precision

可以基于整數(shù)洋满、字符串、浮點數(shù)或元組構(gòu)造 Decimal 實例珍坊。 基于整數(shù)或浮點數(shù)構(gòu)造將執(zhí)行該整數(shù)或浮點值的精確轉(zhuǎn)換牺勾。 Decimal 數(shù)字包括特殊值例如?NaN?表示“非數(shù)字”，正的和負的?Infinity?和?-0

>>>getcontext().prec=28

>>>Decimal(10)

Decimal('10')

>>>Decimal('3.14')

Decimal('3.14')

>>>Decimal(3.14)

Decimal('3.140000000000000124344978758017532527446746826171875')

>>>Decimal((0, (3,1,4),-2))

Decimal('3.14')

>>>Decimal(str(2.0**0.5))

Decimal('1.4142135623730951')

>>>Decimal(2)**Decimal('0.5')

Decimal('1.414213562373095048801688724')

>>>Decimal('NaN')

Decimal('NaN')

>>>Decimal('-Infinity')

Decimal('-Infinity')

如果?FloatOperation?信號被捕獲阵漏，構(gòu)造函數(shù)中的小數(shù)和浮點數(shù)的意外混合或排序比較會引發(fā)異常

>>>c=getcontext()

>>>c.traps[FloatOperation]=True

>>>Decimal(3.14)

Traceback (most recent call last):

? File"<stdin>", line1, in <module>

decimal.FloatOperation: [<class 'decimal.FloatOperation'>]

>>>Decimal('3.5')<3.7

Traceback (most recent call last):

? File"<stdin>", line1, in <module>

decimal.FloatOperation: [<class 'decimal.FloatOperation'>]

>>>Decimal('3.5')==3.5

True

3.3 新版功能.

新 Decimal 的重要性僅由輸入的位數(shù)決定驻民。 上下文精度和舍入僅在算術(shù)運算期間發(fā)揮作用翻具。

>>>getcontext().prec=6

>>>Decimal('3.0')

Decimal('3.0')

>>>Decimal('3.1415926535')

Decimal('3.1415926535')

>>>Decimal('3.1415926535')+Decimal('2.7182818285')

Decimal('5.85987')

>>>getcontext().rounding=ROUND_UP

>>>Decimal('3.1415926535')+Decimal('2.7182818285')

Decimal('5.85988')

如果超出了 C 版本的內(nèi)部限制，則構(gòu)造一個 decimal 將引發(fā)?InvalidOperation

>>>Decimal("1e9999999999999999999")

Traceback (most recent call last):

? File"<stdin>", line1, in <module>

decimal.InvalidOperation: [<class 'decimal.InvalidOperation'>]

在 3.3 版更改.

Decimal 數(shù)字能很好地與 Python 的其余部分交互回还。 以下是一個小小的 decimal 浮點數(shù)飛行馬戲團：

>>>data=list(map(Decimal,'1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))

>>>max(data)

Decimal('9.25')

>>>min(data)

Decimal('0.03')

>>>sorted(data)

[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),

Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]

>>>sum(data)

Decimal('19.29')

>>>a,b,c=data[:3]

>>>str(a)

'1.34'

>>>float(a)

1.34

>>>round(a,1)

Decimal('1.3')

>>>int(a)

1

>>>a*5

Decimal('6.70')

>>>a*b

Decimal('2.5058')

>>>c%a

Decimal('0.77')

Decimal 也可以使用一些數(shù)學函數(shù)：

>>>getcontext().prec=28

>>>Decimal(2).sqrt()

Decimal('1.414213562373095048801688724')

>>>Decimal(1).exp()

Decimal('2.718281828459045235360287471')

>>>Decimal('10').ln()

Decimal('2.302585092994045684017991455')

>>>Decimal('10').log10()

Decimal('1')

quantize()?方法將數(shù)字四舍五入為固定指數(shù)裆泳。 此方法對于將結(jié)果舍入到固定的位置的貨幣應(yīng)用程序非常有用：

>>>Decimal('7.325').quantize(Decimal('.01'), rounding=ROUND_DOWN)

Decimal('7.32')

>>>Decimal('7.325').quantize(Decimal('1.'), rounding=ROUND_UP)

Decimal('8')

如上所示，getcontext()?函數(shù)訪問當前上下文并允許更改設(shè)置柠硕。 這種方法滿足大多數(shù)應(yīng)用程序的需求工禾。

對于更高級的工作，使用 Context() 構(gòu)造函數(shù)創(chuàng)建備用上下文可能很有用蝗柔。 要使用備用活動闻葵，請使用?setcontext()?函數(shù)。

根據(jù)標準癣丧，decimal?模塊提供了兩個現(xiàn)成的標準上下文?BasicContext?和?ExtendedContext?槽畔。 前者對調(diào)試特別有用，因為許多陷阱都已啟用：

>>>myothercontext=Context(prec=60, rounding=ROUND_HALF_DOWN)

>>>setcontext(myothercontext)

>>>Decimal(1)/Decimal(7)

Decimal('0.142857142857142857142857142857142857142857142857142857142857')

>>>ExtendedContext

Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,

??????? capitals=1, clamp=0, flags=[], traps=[])

>>>setcontext(ExtendedContext)

>>>Decimal(1)/Decimal(7)

Decimal('0.142857143')

>>>Decimal(42)/Decimal(0)

Decimal('Infinity')

>>>setcontext(BasicContext)

>>>Decimal(42)/Decimal(0)

Traceback (most recent call last):

? File"<pyshell#143>", line1, in -toplevel-

??? Decimal(42)/Decimal(0)

DivisionByZero: x / 0

上下文還具有用于監(jiān)視計算期間遇到的異常情況的信號標志胁编。 標志保持設(shè)置直到明確清除竟痰，因此最好通過使用?clear_flags()?方法清除每組受監(jiān)控計算之前的標志。:

>>>setcontext(ExtendedContext)

>>>getcontext().clear_flags()

>>>Decimal(355)/Decimal(113)

Decimal('3.14159292')

>>>getcontext()

Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,

??????? capitals=1, clamp=0, flags=[Inexact, Rounded], traps=[])

flags?條目顯示對?Pi?的有理逼近被舍入（超出上下文精度的數(shù)字被拋棄）并且結(jié)果是不精確的（一些丟棄的數(shù)字不為零）掏呼。

使用上下文的?traps?字段中的字典設(shè)置單個陷阱：

>>>setcontext(ExtendedContext)

>>>Decimal(1)/Decimal(0)

Decimal('Infinity')

>>>getcontext().traps[DivisionByZero]=1

>>>Decimal(1)/Decimal(0)

Traceback (most recent call last):

? File"<pyshell#112>", line1, in -toplevel-

??? Decimal(1)/Decimal(0)

DivisionByZero: x / 0

大多數(shù)程序僅在程序開始時調(diào)整當前上下文一次坏快。 并且，在許多應(yīng)用程序中憎夷，數(shù)據(jù)在循環(huán)內(nèi)單個強制轉(zhuǎn)換為?Decimal?莽鸿。 通過創(chuàng)建上下文集和小數(shù)，程序的大部分操作數(shù)據(jù)與其他 Python 數(shù)字類型沒有區(qū)別拾给。

Decimal 對象

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

根據(jù)?value?構(gòu)造一個新的?Decimal?對象祥得。

value?可以是整數(shù)，字符串蒋得，元組级及，float?，或另一個?Decimal?對象额衙。 如果沒有給出?value饮焦，則返回?Decimal('0')。 如果?value?是一個字符串窍侧，它應(yīng)該在前導和尾隨空格字符以及下劃線被刪除之后符合十進制數(shù)字字符串語法:

sign?????????? ::=?'+'|'-'

digit????????? ::=?'0'|'1'|'2'|'3'|'4'|'5'|'6'|'7'|'8'|'9'

indicator????? ::=?'e'|'E'

digits???????? ::=? digit [digit]...

decimal-part?? ::=? digits'.'[digits]|['.'] digits

exponent-part? ::=? indicator [sign] digits

infinity?????? ::=?'Infinity'|'Inf'

nan??????????? ::=?'NaN'[digits]|'sNaN'[digits]

numeric-value? ::=? decimal-part [exponent-part]|infinity

numeric-string ::=? [sign] numeric-value|[sign] nan

當上面出現(xiàn)?digit?時也允許其他十進制數(shù)碼县踢。 其中包括來自各種其他語言系統(tǒng)的十進制數(shù)碼（例如阿拉伯-印地語和天城文的數(shù)碼）以及全寬數(shù)碼?'\uff10'?到?'\uff19'。

如果?value?是一個?tuple?伟件，它應(yīng)該有三個組件硼啤，一個符號（?0?表示正數(shù)或?1?表示負數(shù)），一個數(shù)字的?tuple?和整數(shù)指數(shù)斧账。 例如谴返，?Decimal((0,?(1,?4,?1,?4),?-3))?返回?Decimal('1.414')煞肾。

如果?value?是?float?，則二進制浮點值無損地轉(zhuǎn)換為其精確的十進制等效值嗓袱。 此轉(zhuǎn)換通常需要53位或更多位數(shù)的精度扯旷。 例如，?Decimal(float('1.1'))?轉(zhuǎn)換為``Decimal(‘1.100000000000000088817841970012523233890533447265625’)``索抓。

context?精度不會影響存儲的位數(shù)钧忽。 這完全由?value?中的位數(shù)決定。 例如逼肯，Decimal('3.00000')?記錄所有五個零耸黑，即使上下文精度只有三。

context?參數(shù)的目的是確定?value?是格式錯誤的字符串時該怎么做篮幢。 如果上下文陷阱?InvalidOperation大刊，則引發(fā)異常；否則三椿，構(gòu)造函數(shù)返回一個新的 Decimal缺菌，其值為?NaN。

構(gòu)造完成后搜锰，?Decimal?對象是不可變的伴郁。

在 3.2 版更改:?現(xiàn)在允許構(gòu)造函數(shù)的參數(shù)為?float?實例。

在 3.3 版更改:?float?參數(shù)在設(shè)置?FloatOperation?陷阱時引發(fā)異常蛋叼。 默認情況下焊傅，陷阱已關(guān)閉。

在 3.6 版更改:?允許下劃線進行分組狈涮，就像代碼中的整數(shù)和浮點文字一樣狐胎。

十進制浮點對象與其他內(nèi)置數(shù)值類型共享許多屬性，例如?float?和?int?歌馍。 所有常用的數(shù)學運算和特殊方法都適用握巢。 同樣，十進制對象可以復制松却、pickle暴浦、打印、用作字典鍵玻褪、用作集合元素肉渴、比較公荧、排序和強制轉(zhuǎn)換為另一種類型（例如?float?或?int?）带射。

算術(shù)對十進制對象和算術(shù)對整數(shù)和浮點數(shù)有一些小的差別。 當余數(shù)運算符?%?應(yīng)用于Decimal對象時循狰，結(jié)果的符號是?被除數(shù)?的符號窟社，而不是除數(shù)的符號:

>>>(-7)%4

1

>>>Decimal(-7)%Decimal(4)

Decimal('-3')

整數(shù)除法運算符?//?的行為類似券勺，返回真商的整數(shù)部分（截斷為零）而不是它的向下取整，以便保留通常的標識?x?==?(x?//?y)?*?y?+?x?%?y:

>>>-7//4

-2

>>>Decimal(-7)//Decimal(4)

Decimal('-1')

%?和?//?運算符實現(xiàn)了?remainder?和?divide-integer?操作（分別）灿里，如規(guī)范中所述关炼。

十進制對象通常不能與浮點數(shù)或?fractions.Fraction?實例在算術(shù)運算中結(jié)合使用：例如,嘗試將?Decimal?加到?float?，將引發(fā)?TypeError匣吊。 但是儒拂，可以使用 Python 的比較運算符來比較?Decimal?實例?x?和另一個數(shù)字?y?。 這樣可以避免在對不同類型的數(shù)字進行相等比較時混淆結(jié)果色鸳。

在 3.2 版更改:?現(xiàn)在完全支持?Decimal?實例和其他數(shù)字類型之間的混合類型比較社痛。

除了標準的數(shù)字屬性，十進制浮點對象還有許多專門的方法：

adjusted()

在移出系數(shù)最右邊的數(shù)字之后返回調(diào)整后的指數(shù)命雀，直到只剩下前導數(shù)字：Decimal('321e+5').adjusted()?返回 7 蒜哀。 用于確定最高有效位相對于小數(shù)點的位置。

as_integer_ratio()

返回一對?(n,?d)?整數(shù)吏砂，表示給定的?Decimal?實例作為分數(shù)撵儿、最簡形式項并帶有正分母:

>>>Decimal('-3.14').as_integer_ratio()

(-157, 50)

轉(zhuǎn)換是精確的。 在 Infinity 上引發(fā) OverflowError 狐血，在 NaN 上引起 ValueError 淀歇。

3.6 新版功能.

as_tuple()

返回一個?named tuple?表示的數(shù)字：?DecimalTuple(sign,?digits,?exponent)。

canonical()

返回參數(shù)的規(guī)范編碼匈织。 目前房匆，一個?Decimal?實例的編碼始終是規(guī)范的，因此該操作返回其參數(shù)不變报亩。

compare(other,?context=None)

比較兩個 Decimal 實例的值浴鸿。?compare()?返回一個 Decimal 實例，如果任一操作數(shù)是 NaN 弦追，那么結(jié)果是 NaN

aorbisa NaN?==>Decimal('NaN')

a<b???????????==>Decimal('-1')

a==b??????????==>Decimal('0')

a>b???????????==>Decimal('1')

compare_signal(other,?context=None)

除了所有 NaN 信號之外岳链，此操作與?compare()?方法相同。 也就是說劲件，如果兩個操作數(shù)都不是信令NaN掸哑，那么任何靜默的 NaN 操作數(shù)都被視為信令NaN。

compare_total(other,?context=None)

使用它們的抽象表示而不是它們的數(shù)值來比較兩個操作數(shù)零远。 類似于?compare()?方法苗分，但結(jié)果給出了一個總排序?Decimal?實例。 兩個?Decimal?實例具有相同的數(shù)值但不同的表示形式在此排序中比較不相等：

>>>Decimal('12.0').compare_total(Decimal('12'))

Decimal('-1')

靜默和發(fā)出信號的 NaN 也包括在總排序中牵辣。 這個函數(shù)的結(jié)果是?Decimal('0')?如果兩個操作數(shù)具有相同的表示摔癣，或是?Decimal('-1')?如果第一個操作數(shù)的總順序低于第二個操作數(shù)，或是?Decimal('1')?如果第一個操作數(shù)在總順序中高于第二個操作數(shù)。 有關(guān)總排序的詳細信息择浊，請參閱規(guī)范戴卜。

此操作不受上下文影響且靜默：不更改任何標志且不執(zhí)行舍入。 作為例外琢岩，如果無法準確轉(zhuǎn)換第二個操作數(shù)投剥，則C版本可能會引發(fā)InvalidOperation。

compare_total_mag(other,?context=None)

比較兩個操作數(shù)使用它們的抽象表示而不是它們的值担孔，如?compare_total()江锨，但忽略每個操作數(shù)的符號。?x.compare_total_mag(y)?相當于?x.copy_abs().compare_total(y.copy_abs())糕篇。

此操作不受上下文影響且靜默：不更改任何標志且不執(zhí)行舍入泳桦。 作為例外，如果無法準確轉(zhuǎn)換第二個操作數(shù)娩缰，則C版本可能會引發(fā)InvalidOperation灸撰。

conjugate()

只返回self，這種方法只符合 Decimal 規(guī)范拼坎。

copy_abs()

返回參數(shù)的絕對值浮毯。 此操作不受上下文影響并且是靜默的：沒有更改標志且不執(zhí)行舍入。

copy_negate()

回到參數(shù)的否定泰鸡。 此操作不受上下文影響并且是靜默的：沒有標志更改且不執(zhí)行舍入债蓝。

copy_sign(other,?context=None)

返回第一個操作數(shù)的副本，其符號設(shè)置為與第二個操作數(shù)的符號相同盛龄。 例如：

>>>Decimal('2.3').copy_sign(Decimal('-1.5'))

Decimal('-2.3')

此操作不受上下文影響且靜默：不更改任何標志且不執(zhí)行舍入饰迹。 作為例外，如果無法準確轉(zhuǎn)換第二個操作數(shù)余舶，則C版本可能會引發(fā)InvalidOperation啊鸭。

exp(context=None)

返回給定數(shù)字的（自然）指數(shù)函數(shù)``e**x``的值。結(jié)果使用?ROUND_HALF_EVEN?舍入模式正確舍入匿值。

>>>Decimal(1).exp()

Decimal('2.718281828459045235360287471')

>>>Decimal(321).exp()

Decimal('2.561702493119680037517373933E+139')

from_float(f)

將浮點數(shù)轉(zhuǎn)換為十進制數(shù)的類方法赠制。

注意，?Decimal.from_float(0.1)?與?Decimal(‘0.1’)?不同挟憔。 由于 0.1 在二進制浮點中不能精確表示钟些，因此該值存儲為最接近的可表示值，即?0x1.999999999999ap-4?绊谭。 十進制的等效值是`0.1000000000000000055511151231257827021181583404541015625`政恍。

注解

從 Python 3.2 開始，Decimal?實例也可以直接從?float?構(gòu)造达传。

>>>Decimal.from_float(0.1)

Decimal('0.1000000000000000055511151231257827021181583404541015625')

>>>Decimal.from_float(float('nan'))

Decimal('NaN')

>>>Decimal.from_float(float('inf'))

Decimal('Infinity')

>>>Decimal.from_float(float('-inf'))

Decimal('-Infinity')

3.1 新版功能.

fma(other,?third,?context=None)

混合乘法加法篙耗。 返回 self*other+third 迫筑，中間乘積 self*other 沒有四舍五入。

>>>Decimal(2).fma(3,5)

Decimal('11')

is_canonical()

如果參數(shù)是規(guī)范的鹤树，則為返回?True铣焊，否則為?False?逊朽。 目前罕伯，Decimal?實例總是規(guī)范的，所以這個操作總是返回?True?叽讳。

is_finite()

如果參數(shù)是一個有限的數(shù)追他，則返回為?True?；如果參數(shù)為無窮大或 NaN 岛蚤，則返回為?False邑狸。

is_infinite()

如果參數(shù)為正負無窮大，則返回為?True?涤妒，否則為?False?单雾。

is_nan()

如果參數(shù)為 NaN （無論是否靜默），則返回為?True?她紫，否則為?False?硅堆。

is_normal(context=None)

如果參數(shù)是一個有限正規(guī)數(shù)，返回?True贿讹，如果參數(shù)是0渐逃、次正規(guī)數(shù)、無窮大或是NaN民褂，返回?False茄菊。

is_qnan()

如果參數(shù)為靜默 NaN，返回?True赊堪，否則返回?False面殖。

is_signed()

如果參數(shù)帶有負號，則返回為?True哭廉，否則返回?False畜普。注意，0 和 NaN 都可帶有符號群叶。

is_snan()

如果參數(shù)為顯式 NaN吃挑，則返回?True，否則返回?False街立。

is_subnormal(context=None)

如果參數(shù)為次正規(guī)數(shù)舶衬，則返回?True，否則返回?False赎离。

is_zero()

如果參數(shù)是0（正負皆可）逛犹，則返回?True，否則返回?False。

ln(context=None)

返回操作數(shù)的自然對數(shù)（以 e 為底）虽画。結(jié)果是使用?ROUND_HALF_EVEN?舍入模式正確四舍五入的舞蔽。

log10(context=None)

返回操作數(shù)的以十為底的對數(shù)。結(jié)果是使用?ROUND_HALF_EVEN?舍入模式正確四舍五入的码撰。

logb(context=None)

對于一個非零數(shù)渗柿，返回其運算數(shù)的調(diào)整后指數(shù)作為一個?Decimal?實例。 如果運算數(shù)為零將返回?Decimal('-Infinity')?并且產(chǎn)生 the?DivisionByZero?標志脖岛。如果運算數(shù)是無限大則返回?Decimal('Infinity')?朵栖。

logical_and(other,?context=None)

logical_and()?是需要兩個?邏輯運算數(shù)?的邏輯運算（參考?邏輯操作數(shù)?）。結(jié)果是按位輸出的兩運算數(shù)的 “和”柴梆。

logical_invert(context=None)

logical_invert()?是一個邏輯運算陨溅。 結(jié)果是按位的倒轉(zhuǎn)的運算數(shù)。

logical_or(other,?context=None)

logical_or()?是需要兩個?logical operands?的邏輯運算（請參閱?邏輯操作數(shù)?）绍在。結(jié)果是兩個運算數(shù)的按位的?or?门扇。

logical_xor(other,?context=None)

logical_xor()?是需要兩個?邏輯運算數(shù)?的邏輯運算（參考?邏輯操作數(shù)?）。結(jié)果是按位輸出的兩運算數(shù)的異或運算偿渡。

max(other,?context=None)

像?max(self,?other)?一樣臼寄，除了在返回之前應(yīng)用上下文舍入規(guī)則并且用信號通知或忽略?NaN?值（取決于上下文以及它們是發(fā)信號還是安靜）。

max_mag(other,?context=None)

與?max()?方法相似卸察，但是操作數(shù)使用絕對值進行比較脯厨。

min(other,?context=None)

像?min(self,?other)?一樣，除了在返回之前應(yīng)用上下文舍入規(guī)則并且用信號通知或忽略?NaN?值（取決于上下文以及它們是發(fā)信號還是安靜）坑质。

min_mag(other,?context=None)

與?min()?方法相似合武，但是操作數(shù)使用絕對值進行比較。

next_minus(context=None)

返回小于給定操作數(shù)的上下文中可表示的最大數(shù)字（或者當前線程的上下文中的可表示的最大數(shù)字如果沒有給定上下文）涡扼。

next_plus(context=None)

返回大于給定操作數(shù)的上下文中可表示的最小數(shù)字（或者當前線程的上下文中的可表示的最小數(shù)字如果沒有給定上下文）稼跳。

next_toward(other,?context=None)

如果兩運算數(shù)不相等，返回在第二個操作數(shù)的方向上最接近第一個操作數(shù)的數(shù)吃沪。如果兩操作數(shù)數(shù)值上相等汤善，返回將符號設(shè)置為與第二個運算數(shù)相同的第一個運算數(shù)的拷貝。

normalize(context=None)

通過去除尾隨的零并將所有結(jié)果等于?Decimal('0')?的轉(zhuǎn)化為?Decimal('0e0')?來標準化數(shù)字票彪。用于為等效類的屬性生成規(guī)范值红淡。比如，?Decimal('32.100')?和?Decimal('0.321000e+2')?都被標準化為相同的值?Decimal('32.1')降铸。

number_class(context=None)

返回一個字符串描述運算數(shù)的?class?在旱。返回值是以下十個字符串中的一個。

"-Infinity"?推掸，指示操作數(shù)為負無窮大桶蝎。

"-Normal"?驻仅，指示該操作數(shù)是負正常數(shù)字。

"-Subnormal"?登渣，指示該操作數(shù)是負的次正規(guī)數(shù)噪服。

"-Zero"?，指示該操作數(shù)是負零胜茧。

"-Zero"?粘优，指示該操作數(shù)是正零。

"+Subnormal"?竹揍，指示該操作數(shù)是正的次正規(guī)數(shù)敬飒。

"+Normal"?邪铲，指示該操作數(shù)是正的正規(guī)數(shù)芬位。

"+Infinity"?，指示該運算數(shù)是正無窮带到。

"NaN"?昧碉，指示該運算數(shù)是沉寂的 NaN （非數(shù)字）。

"sNaN"?揽惹，指示該運算數(shù)是信號 NaN 被饿。

quantize(exp,?rounding=None,?context=None)

返回的值等于四舍五入的第一個運算數(shù)并且具有第二個操作數(shù)的指數(shù)。

>>>Decimal('1.41421356').quantize(Decimal('1.000'))

Decimal('1.414')

與其他運算不同搪搏，如果量化運算后的系數(shù)長度大于精度狭握，那么會發(fā)出一個?InvalidOperation?信號。這保證了除非有一個錯誤情況疯溺，量化指數(shù)恒等于右手運算數(shù)的指數(shù)论颅。

與其他運算不同，量化永不信號下溢囱嫩，即使結(jié)果不正常且不精確恃疯。

如果第二個運算數(shù)的指數(shù)大于第一個運算數(shù)的指數(shù)那或許需要四舍五入。在這種情況下墨闲，舍入模式由給定?rounding?參數(shù)決定今妄，其余的由給定?context?參數(shù)決定；如果參數(shù)都未給定鸳碧，使用當前線程上下文的舍入模式盾鳞。

每當結(jié)果的指數(shù)大于?Emax?或小于?Etiny?就會返回錯誤。

radix()

返回?Decimal(10)瞻离，即?Decimal?類進行所有算術(shù)運算所用的數(shù)制（基數(shù)）腾仅。 這是為保持與規(guī)范描述的兼容性而加入的。

remainder_near(other,?context=None)

返回?self?除以?other?的余數(shù)琐脏。 這與?self?%?other?的區(qū)別在于所選擇的余數(shù)要使其絕對值最小化攒砖。 更準確地說缸兔，返回值為?self?-?n?*?other?其中?n?是最接近?self?/?other?的實際值的整數(shù)，并且如果兩個整數(shù)與實際值的差相等則會選擇其中的偶數(shù)吹艇。

如果結(jié)果為零則其符號將為?self?的符號惰蜜。

>>>Decimal(18).remainder_near(Decimal(10))

Decimal('-2')

>>>Decimal(25).remainder_near(Decimal(10))

Decimal('5')

>>>Decimal(35).remainder_near(Decimal(10))

Decimal('-5')

rotate(other,?context=None)

返回對第一個操作數(shù)的數(shù)碼按第二個操作數(shù)所指定的數(shù)量進行輪轉(zhuǎn)的結(jié)果。 第二個操作數(shù)必須為 -precision 至 precision 精度范圍內(nèi)的整數(shù)受神。 第二個操作數(shù)的絕對值給出要輪轉(zhuǎn)的位數(shù)抛猖。 如果第二個操作數(shù)為正值則向左輪轉(zhuǎn)；否則向右輪轉(zhuǎn)。 如有必要第一個操作數(shù)的系數(shù)會在左側(cè)填充零以達到 precision 所指定的長度履磨。 第一個操作數(shù)的符號和指數(shù)保持不變耕皮。

same_quantum(other,?context=None)

檢測自身與 other 是否具有相同的指數(shù)或是否均為?NaN。

此操作不受上下文影響且靜默：不更改任何標志且不執(zhí)行舍入撑教。 作為例外，如果無法準確轉(zhuǎn)換第二個操作數(shù)醉拓，則C版本可能會引發(fā)InvalidOperation伟姐。

scaleb(other,?context=None)

返回第一個操作數(shù)使用第二個操作數(shù)對指數(shù)進行調(diào)整的結(jié)果。 等價于返回第一個操作數(shù)乘以?10**other?的結(jié)果亿卤。 第二個操作數(shù)必須為整數(shù)愤兵。

shift(other,?context=None)

返回第一個操作數(shù)的數(shù)碼按第二個操作數(shù)所指定的數(shù)量進行移位的結(jié)果。 第二個操作數(shù)必須為 -precision 至 precision 范圍內(nèi)的整數(shù)排吴。 第二個操作數(shù)的絕對值給出要移動的位數(shù)秆乳。 如果第二個操作數(shù)為正值則向左移位；否則向右移位钻哩。 移入系數(shù)的數(shù)碼為零屹堰。 第一個操作數(shù)的符號和指數(shù)保持不變。

sqrt(context=None)

返回參數(shù)的平方根精確到完整精度憋槐。

to_eng_string(context=None)

轉(zhuǎn)換為字符串双藕，如果需要指數(shù)則會使用工程標注法。

工程標注法的指數(shù)是 3 的倍數(shù)阳仔。 這會在十進制位的左邊保留至多 3 個數(shù)碼忧陪，并可能要求添加一至兩個末尾零。

例如近范，此方法會將?Decimal('123E+1')?轉(zhuǎn)換為?Decimal('1.23E+3')嘶摊。

to_integral(rounding=None,?context=None)

與?to_integral_value()?方法相同。 保留?to_integral?名稱是為了與舊版本兼容评矩。

to_integral_exact(rounding=None,?context=None)

舍入到最接近的整數(shù)叶堆，發(fā)出信號?Inexact?或者如果發(fā)生舍入則相應(yīng)地發(fā)出信號?Rounded。 如果給出?rounding?形參則由其確定舍入模式斥杜，否則由給定的?context?來確定虱颗。 如果沒有給定任何形參則會使用當前上下文的舍入模式沥匈。

to_integral_value(rounding=None,?context=None)

舍入到最接近的整數(shù)而不發(fā)出?Inexact?或?Rounded?信號。 如果給出?rounding?則會應(yīng)用其所指定的舍入模式忘渔；否則使用所提供的?context?或當前上下文的舍入方法高帖。

邏輯操作數(shù)

logical_and(),?logical_invert(),?logical_or()?和?logical_xor()?方法期望其參數(shù)為?邏輯操作數(shù)。?邏輯操作數(shù)?是指數(shù)位與符號位均為零的?Decimal?實例畦粮，并且其數(shù)字位均為?0?或?1散址。

Context 對象

上下文是算術(shù)運算所在的環(huán)境。 它們管理精度宣赔、設(shè)置舍入規(guī)則预麸、確定將哪些信號視為異常，并限制指數(shù)的范圍儒将。

每個線程都有自己的當前上下文吏祸，可使用?getcontext()?和?setcontext()?函數(shù)來讀取或修改：

decimal.getcontext()

返回活動線程的當前上下文。

decimal.setcontext(c)

將活動線程的當前上下文設(shè)為?c椅棺。

你也可以使用?with?語句和?localcontext()?函數(shù)來臨時改變活動上下文犁罩。

decimal.localcontext(ctx=None)

返回一個上下文管理器齐蔽，它將在進入 with 語句時將活動線程的當前上下文設(shè)為?ctx?的一個副本并在退出 with 語句時恢復之前的上下文两疚。 如果未指定上下文，則會使用當前上下文的一個副本含滴。

例如诱渤，以下代碼會將當前 decimal 精度設(shè)為 42 位，執(zhí)行一個運算谈况，然后自動恢復之前的上下文:

fromdecimalimportlocalcontext

withlocalcontext()asctx:

??? ctx.prec=42??# Perform a high precision calculation

??? s=calculate_something()

s=+s?# Round the final result back to the default precision

新的上下文也可使用下述的?Context?構(gòu)造器來創(chuàng)建勺美。 此外，模塊還提供了三種預(yù)設(shè)的上下文:

class?decimal.BasicContext

這是由通用十進制算術(shù)規(guī)范描述所定義的標準上下文碑韵。 精度設(shè)為九赡茸。 舍入設(shè)為?ROUND_HALF_UP。 清除所有旗標祝闻。 啟用所有陷阱（視為異常）占卧，但?Inexact,?Rounded?和?Subnormal?除外。

由于啟用了許多陷阱联喘，此上下文適用于進行調(diào)試华蜒。

class?decimal.ExtendedContext

這是由通用十進制算術(shù)規(guī)范描述所定義的標準上下文。 精度設(shè)為九豁遭。 舍入設(shè)為?ROUND_HALF_EVEN叭喜。 清除所有旗標。 不啟用任何陷阱（因此在計算期間不會引發(fā)異常）蓖谢。

由于禁用了陷阱捂蕴，此上下文適用于希望結(jié)果值為?NaN?或?Infinity?而不是引發(fā)異常的應(yīng)用譬涡。 這允許應(yīng)用在出現(xiàn)當其他情況下會中止程序的條件時仍能完成運行。

class?decimal.DefaultContext

此上下文被?Context?構(gòu)造器用作新上下文的原型啥辨。 改變一個字段（例如精度）的效果將是改變?Context?構(gòu)造器所創(chuàng)建的新上下文的默認值昂儒。

此上下文最適用于多線程環(huán)境。 在線程開始前改變一個字段具有設(shè)置全系統(tǒng)默認值的效果委可。 不推薦在線程開始后改變字段渊跋，因為這會要求線程同步避免競爭條件。

在單線程環(huán)境中着倾，最好完全不使用此上下文拾酝。 而是簡單地電顯式創(chuàng)建上下文，具體如下所述卡者。

默認值為?prec=28,?rounding=ROUND_HALF_EVEN蒿囤，并為?Overflow,?InvalidOperation?和?DivisionByZero?啟用陷阱。

在已提供的三種上下文之外崇决，還可以使用?Context?構(gòu)造器創(chuàng)建新的上下文材诽。

class?decimal.Context(prec=None,?rounding=None,?Emin=None,?Emax=None,?capitals=None,?clamp=None,?flags=None,?traps=None)

創(chuàng)建一個新上下文。 如果某個字段未指定或為?None恒傻，則從?DefaultContext?拷貝默認值脸侥。 如果?flags?字段未指定或為?None，則清空所有旗標盈厘。

prec?為一個 [1,?MAX_PREC] 范圍內(nèi)的整數(shù)睁枕，用于設(shè)置該上下文中算術(shù)運算的精度。

rounding?選項應(yīng)為?Rounding Modes?小節(jié)中列出的常量之一沸手。

traps?和?flags?字段列出要設(shè)置的任何信號外遇。 通常，新上下文應(yīng)當只設(shè)置 traps 而讓 flags 為空契吉。

Emin?和?Emax?字段給定指數(shù)所允許的外部上限跳仿。?Emin?必須在 [MIN_EMIN,?0] 范圍內(nèi)，Emax?在 [0,?MAX_EMAX] 范圍內(nèi)捐晶。

capitals?字段為?0?或?1?(默認值)菲语。 如果設(shè)為?1，指數(shù)將附帶打印大寫的?E租悄；其他情況則將使用小寫的?e:?Decimal('6.02e+23')谨究。

clamp?字段為?0?(默認值) 或?1。 如果設(shè)為?1泣棋，則?Decimal?實例的指數(shù)?e?的表示范圍在此上下文中將嚴格限制為?Emin?-?prec?+?1?<=?e?<=?Emax?-?prec?+?1胶哲。 如果?clamp?為?0?則將適用較弱的條件:?Decimal?實例調(diào)整后的指數(shù)最大值為?Emax。 當?clamp?為?1?時潭辈，一個較大的普通數(shù)值將在可能的情況下減小其指數(shù)并為其系統(tǒng)添加相應(yīng)數(shù)量的零鸯屿，以便符合指數(shù)值限制澈吨；這可以保持數(shù)字值但會丟失有效末尾零的信息。 例如:

>>>

>>>Context(prec=6, Emax=999, clamp=1).create_decimal('1.23e999')

Decimal('1.23000E+999')

clamp?值為?1?時即允許與在 IEEE 754 中描述的固定寬度十進制交換格式相兼容寄摆。

Context?類定義了幾種通用方法以及大量直接在給定上下文中進行算術(shù)運算的方法谅辣。 此外，對于上述的每種?Decimal?方法（不包括?adjusted()?和?as_tuple()?方法）都有一個相應(yīng)的?Context?方法婶恼。 例如桑阶，對于一個?Context?的實例?C?和?Decimal?的實例?x，C.exp(x)?就等價于?x.exp(context=C)勾邦。 每個?Context?方法都接受一個 Python 整數(shù)（即?int?的實例）在任何接受 Decimal 的實例的地方使用蚣录。

clear_flags()

將所有旗標重置為?0。

clear_traps()

將所有陷阱重置為零?0眷篇。

3.3 新版功能.

copy()

返回上下文的一個副本萎河。

copy_decimal(num)

返回 Decimal 實例 num 的一個副本。

create_decimal(num)

基于?num?創(chuàng)建一個新 Decimal 實例但使用?self?作為上下文蕉饼。 與?Decimal?構(gòu)造器不同虐杯，該上下文的精度、舍入方法昧港、旗標和陷阱會被應(yīng)用于轉(zhuǎn)換過程擎椰。

此方法很有用處，因為常量往往被給予高于應(yīng)用所需的精度慨飘。 另一個好處在于立即執(zhí)行舍入可以消除超出當前精度的數(shù)位所導致的意外效果确憨。 在下面的示例中，使用未舍入的輸入意味著在總和中添加零會改變結(jié)果：

>>>getcontext().prec=3

>>>Decimal('3.4445')+Decimal('1.0023')

Decimal('4.45')

>>>Decimal('3.4445')+Decimal(0)+Decimal('1.0023')

Decimal('4.44')

此方法實現(xiàn)了 IBM 規(guī)格描述中的轉(zhuǎn)換為數(shù)字操作瓤的。 如果參數(shù)為字符串，則不允許有開頭或末尾的空格或下劃線吞歼。

create_decimal_from_float(f)

基于浮點數(shù)?f?創(chuàng)建一個新的 Decimal 實例圈膏，但會使用?self?作為上下文來執(zhí)行舍入。 與?Decimal.from_float()?類方法不同篙骡，上下文的精度稽坤、舍入方法、旗標和陷阱會應(yīng)用到轉(zhuǎn)換中糯俗。

>>>context=Context(prec=5, rounding=ROUND_DOWN)

>>>context.create_decimal_from_float(math.pi)

Decimal('3.1415')

>>>context=Context(prec=5, traps=[Inexact])

>>>context.create_decimal_from_float(math.pi)

Traceback (most recent call last):

???...

decimal.Inexact: None

3.1 新版功能.

Etiny()

返回一個等于?Emin?-?prec?+?1?的值即次正規(guī)化結(jié)果中的最小指數(shù)值尿褪。 當發(fā)生向下溢出時，指數(shù)會設(shè)為?Etiny得湘。

Etop()

返回一個等于?Emax?-?prec?+?1?的值杖玲。

使用 decimal 的通常方式是創(chuàng)建?Decimal?實例然后對其應(yīng)用算術(shù)運算,這些運算發(fā)生在活動線程的當前上下文中。 一種替代方式則是使用上下文的方法在特定上下文中進行計算淘正。 這些方法類似于?Decimal?類的方法摆马，在此僅簡單地重新列出臼闻。

abs(x)

返回?x?的絕對值。

add(x,?y)

返回?x?與?y?的和囤采。

canonical(x)

返回相同的 Decimal 對象?x述呐。

compare(x,?y)

對?x?與?y?進行數(shù)值比較。

compare_signal(x,?y)

對兩個操作數(shù)進行數(shù)值比較蕉毯。

compare_total(x,?y)

對兩個操作數(shù)使用其抽象表示進行比較乓搬。

compare_total_mag(x,?y)

對兩個操作數(shù)使用其抽象表示進行比較，忽略符號代虾。

copy_abs(x)

返回?x?的副本缤谎，符號設(shè)為 0。

copy_negate(x)

返回?x?的副本褐着，符號取反坷澡。

copy_sign(x,?y)

從?y?拷貝符號至?x。

divide(x,?y)

返回?x?除以?y?的結(jié)果含蓉。

divide_int(x,?y)

返回?x?除以?y?的結(jié)果频敛，截短為整數(shù)。

divmod(x,?y)

兩個數(shù)字相除并返回結(jié)果的整數(shù)部分馅扣。

exp(x)

返回?e ** x斟赚。

fma(x,?y,?z)

返回?x?乘以?y?再加?z?的結(jié)果。

is_canonical(x)

如果?x?是規(guī)范的則返回?True差油；否則返回?False拗军。

is_finite(x)

如果?x?為有限數(shù)則返回``True``；否則返回?False蓄喇。

is_infinite(x)

如果?x?是無限的則返回?True发侵；否則返回?False。

is_nan(x)

如果?x?是 qNaN 或 sNaN 則返回?True妆偏；否則返回?False刃鳄。

is_normal(x)

如果?x?是正規(guī)數(shù)則返回?True；否則返回?False钱骂。

is_qnan(x)

如果?x?是靜默 NaN 則返回?True叔锐；否則返回?False。

is_signed(x)

x?是負數(shù)則返回?True见秽；否則返回?False愉烙。

is_snan(x)

如果?x?是顯式 NaN 則返回?True；否則返回?False解取。

is_subnormal(x)

如果?x?是次標準數(shù)則返回?True步责；否則返回?False。

is_zero(x)

如果?x?為零則返回?True；否則返回?False勺择。

ln(x)

返回?x?的自然對數(shù)（以 e 為底）创南。

log10(x)

返回?x?的以 10 為底的對數(shù)。

logb(x)

返回操作數(shù)的 MSD 等級的指數(shù)省核。

logical_and(x,?y)

在操作數(shù)的每個數(shù)碼間應(yīng)用邏輯運算?and稿辙。

logical_invert(x)

反轉(zhuǎn)?x?中的所有數(shù)位。

logical_or(x,?y)

在操作數(shù)的每個數(shù)位間應(yīng)用邏輯運算?or气忠。

logical_xor(x,?y)

在操作數(shù)的每個數(shù)位間應(yīng)用邏輯運算?xor邻储。

max(x,?y)

對兩個值執(zhí)行數(shù)字比較并返回其中的最大值。

max_mag(x,?y)

對兩個值執(zhí)行忽略正負號的數(shù)字比較旧噪。

min(x,?y)

對兩個值執(zhí)行數(shù)字比較并返回其中的最小值吨娜。

min_mag(x,?y)

對兩個值執(zhí)行忽略正負號的數(shù)字比較。

minus(x)

對應(yīng)于 Python 中的單目取負運算符執(zhí)行取負操作淘钟。

multiply(x,?y)

返回?x?和?y?的積宦赠。

next_minus(x)

返回小于?x?的最大數(shù)字表示形式。

next_plus(x)

返回大于?x?的最小數(shù)字表示形式米母。

next_toward(x,?y)

返回?x?趨向于?y?的最接近的數(shù)字勾扭。

normalize(x)

將?x?改寫為最簡形式。

number_class(x)

返回?x?的類的表示铁瞒。

plus(x)

對應(yīng)于 Python 中的單目前綴取正運算符執(zhí)行取正操作妙色。 此操作將應(yīng)用上下文精度和舍入，因此它?不是?標識運算慧耍。

power(x,?y,?modulo=None)

返回?x?的?y?次方身辨，如果給出了模數(shù)?modulo?則取其余數(shù)。

如為兩個參數(shù)則計算?x**y芍碧。 如果?x?為負值則?y?必須為整數(shù)煌珊。 除非?y?為整數(shù)且結(jié)果為有限值并可在 ‘precision’ 位內(nèi)精確表示否則結(jié)果將是不精確的。 上下文的舍入模式將被使用师枣。 結(jié)果在 Python 版中總是會被正確地舍入怪瓶。

在 3.3 版更改:?C 模塊計算?power()?時會使用已正確舍入的?exp()?和?ln()?函數(shù)。 結(jié)果是經(jīng)過良好定義的践美，但僅限于“幾乎總是正確地舍入”。

帶有三個參數(shù)時找岖，計算?(x**y)?%?modulo陨倡。 對于三個參數(shù)的形式，參數(shù)將會應(yīng)用以下限制：

三個參數(shù)必須都是整數(shù)

y?必須是非負數(shù)

x?或?y?至少有一個不為零

modulo?必須不為零且至多有 ‘precision’ 位

來自?Context.power(x,?y,?modulo)?的結(jié)果值等于使用無限精度計算?(x**y)?%?modulo?所得到的值许布，但其計算過程更高效兴革。 結(jié)果的指數(shù)為零，無論?x,?y?和?modulo?的指數(shù)是多少。 結(jié)果值總是完全精確的杂曲。

quantize(x,?y)

返回的值等于?x?(舍入后)庶艾，并且指數(shù)為?y。

radix()

恰好返回 10擎勘，因為這是 Decimal 對象 :)

remainder(x,?y)

返回整除所得到的余數(shù)咱揍。

結(jié)果的符號，如果不為零棚饵，則與原始除數(shù)的符號相同煤裙。

remainder_near(x,?y)

返回?x?-?y?*?n，其中?n?為最接近?x?/?y?實際值的整數(shù)（如結(jié)果為 0 則其符號將與?x?的符號相同）噪漾。

rotate(x,?y)

返回?x?翻轉(zhuǎn)?y?次的副本硼砰。

same_quantum(x,?y)

如果兩個操作數(shù)具有相同的指數(shù)則返回?True。

scaleb(x,?y)

返回第一個操作數(shù)對第二個值添加其指數(shù)后的結(jié)果欣硼。

shift(x,?y)

返回?x?變換?y?次的副本题翰。

sqrt(x)

非負數(shù)基于上下文精度的平方根。

subtract(x,?y)

返回?x?和?y?的差诈胜。

to_eng_string(x)

轉(zhuǎn)換為字符串豹障，如果需要指數(shù)則會使用工程標注法。

工程標注法的指數(shù)是 3 的倍數(shù)耘斩。 這會在十進制位的左邊保留至多 3 個數(shù)碼沼填，并可能要求添加一至兩個末尾零。

to_integral_exact(x)

舍入到一個整數(shù)括授。

to_sci_string(x)

使用科學計數(shù)法將一個數(shù)字轉(zhuǎn)換為字符串坞笙。

常量

本節(jié)中的常量僅與 C 模塊相關(guān)。 它們也被包含在純 Python 版本以保持兼容性荚虚。

32位64位

decimal.MAX_PREC425000000999999999999999999

decimal.MAX_EMAX425000000999999999999999999

decimal.MIN_EMIN-425000000-999999999999999999

decimal.MIN_ETINY-849999999-1999999999999999997

decimal.HAVE_THREADS

The default value is?True. If Python is compiled without threads, the C version automatically disables the expensive thread local context machinery. In this case, the value is?False.

舍入模式

decimal.ROUND_CEILING

舍入方向?Infinity薛夜。

decimal.ROUND_DOWN

舍入方向為零。

decimal.ROUND_FLOOR

舍入方向為?-Infinity版述。

decimal.ROUND_HALF_DOWN

舍入到最接近的數(shù)梯澜，同樣接近則舍入方向為零。

decimal.ROUND_HALF_EVEN

舍入到最接近的數(shù)渴析，同樣接近則舍入到最接近的偶數(shù)晚伙。

decimal.ROUND_HALF_UP

舍入到最接近的數(shù)，同樣接近則舍入到零的反方向俭茧。

decimal.ROUND_UP

舍入到零的反方向咆疗。

decimal.ROUND_05UP

如果最后一位朝零的方向舍入后為 0 或 5 則舍入到零的反方向；否則舍入方向為零母债。

信號

信號代表在計算期間引發(fā)的條件午磁。 每個信號對應(yīng)于一個上下文旗標和一個上下文陷阱啟用器尝抖。

上下文旗標將在遇到特定條件時被設(shè)定。 在完成計算之后迅皇，將為了獲得信息而檢測旗標（例如確定計算是否精確）昧辽。 在檢測旗標后，請確保在開始下一次計算之前清除所有旗標登颓。

如果為信號設(shè)定了上下文的陷阱啟用器搅荞，則條件會導致特定的 Python 異常被引發(fā)。 舉例來說挺据，如果設(shè)定了?DivisionByZero?陷阱取具，則當遇到此條件時就將引發(fā)?DivisionByZero?異常。

class?decimal.Clamped

修改一個指數(shù)以符合表示限制扁耐。

通常暇检，限位將在一個指數(shù)超出上下文的?Emin?和?Emax?限制時發(fā)生。 在可能的情況下婉称，會通過給系數(shù)添加零來將指數(shù)縮減至符合限制块仆。

class?decimal.DecimalException

其他信號的基類，并且也是?ArithmeticError?的一個子類王暗。

class?decimal.DivisionByZero

非無限數(shù)被零除的信號悔据。

可在除法、取余隊法或?qū)σ粋€數(shù)求負數(shù)次冪時發(fā)生俗壹。 如果此信號未被陷阱捕獲科汗，則返回?Infinity?或?-Infinity?并且由對計算的輸入來確定正負符號。

class?decimal.Inexact

表明發(fā)生了舍入且結(jié)果是不精確的绷雏。

有非零數(shù)位在舍入期間被丟棄的信號头滔。 舍入結(jié)果將被返回。 此信號旗標或陷阱被用于檢測結(jié)果不精確的情況涎显。

class?decimal.InvalidOperation

執(zhí)行了一個無效的操作坤检。

表明請求了一個無意義的操作。 如未被陷阱捕獲則返回?NaN期吓。 可能的原因包括:

Infinity-Infinity

0*Infinity

Infinity/Infinity

x%0

Infinity%x

sqrt(-x)andx>0

0**0

x**(non-integer)

x**Infinity

class?decimal.Overflow

數(shù)值的溢出早歇。

表明在發(fā)生舍入之后的指數(shù)大于?Emax。 如果未被陷阱捕獲讨勤，則結(jié)果將取決于舍入模式箭跳，或者向下舍入為最大的可表示有限數(shù)，或者向上舍入為?Infinity潭千。 無論哪種情況衅码，都將引發(fā)?Inexact?和?Rounded?信號。

class?decimal.Rounded

發(fā)生了舍入脊岳，但或許并沒有信息丟失。

一旦舍入丟棄了數(shù)位就會發(fā)出此信號；即使被丟棄的數(shù)位是零 (例如將?5.00?舍入為?5.0)割捅。 如果未被陷阱捕獲奶躯，則不經(jīng)修改地返回結(jié)果。 此信號用于檢測有效位數(shù)的丟棄亿驾。

class?decimal.Subnormal

在舍入之前指數(shù)低于?Emin嘹黔。

當操作結(jié)果是次標準數(shù)（即指數(shù)過小）時就會發(fā)出此信號莫瞬。 如果未被陷阱捕獲儡蔓，則不經(jīng)修改過返回結(jié)果。

class?decimal.Underflow

數(shù)字向下溢出導致結(jié)果舍入到零疼邀。

當一個次標準數(shù)結(jié)果通過舍入轉(zhuǎn)為零時就會發(fā)出此信號喂江。 同時還將引發(fā)?Inexact?和?Subnormal?信號。

class?decimal.FloatOperation

為 float 和 Decimal 的混合啟用更嚴格的語義旁振。

如果信號未被捕獲（默認）获询，則在?Decimal?構(gòu)造器、create_decimal()?和所有比較運算中允許 float 和 Decimal 的混合拐袜。 轉(zhuǎn)換和比較都是完全精確的吉嚣。 發(fā)生的任何混合運算都將通過在上下文旗標中設(shè)置?FloatOperation?來靜默地記錄。 通過?from_float()?或?create_decimal_from_float()?進行顯式轉(zhuǎn)換則不會設(shè)置旗標蹬铺。

在其他情況下（即信號被捕獲）尝哆，則只靜默執(zhí)行相等性比較和顯式轉(zhuǎn)換。 所有其他混合運算都將引發(fā)?FloatOperation甜攀。

以下表格總結(jié)了信號的層級結(jié)構(gòu):

exceptions.ArithmeticError(exceptions.Exception)

??? DecimalException

??????? Clamped

??????? DivisionByZero(DecimalException, exceptions.ZeroDivisionError)

??????? Inexact

??????????? Overflow(Inexact, Rounded)

??????????? Underflow(Inexact, Rounded, Subnormal)

??????? InvalidOperation

??????? Rounded

??????? Subnormal

??????? FloatOperation(DecimalException, exceptions.TypeError)

浮點數(shù)說明

通過提升精度來緩解舍入誤差

使用十進制浮點數(shù)可以消除十進制表示錯誤（即能夠完全精確地表示?0.1?這樣的數(shù)）秋泄；然而，某些運算在非零數(shù)位超出給定的精度時仍然可能導致舍入錯誤赴邻。

舍入錯誤的影響可能因接近相互抵銷的加減運算被放大從而導致?lián)p失有效位印衔。 Knuth 提供了兩個指導性示例，其中出現(xiàn)了精度不足的浮點算術(shù)舍入姥敛，導致加法的交換律和分配律被打破：

# Examples from Seminumerical Algorithms, Section 4.2.2.

>>>fromdecimalimportDecimal, getcontext

>>>getcontext().prec=8

>>>u, v, w=Decimal(11111113), Decimal(-11111111), Decimal('7.51111111')

>>>(u+v)+w

Decimal('9.5111111')

>>>u+(v+w)

Decimal('10')

>>>u, v, w=Decimal(20000), Decimal(-6), Decimal('6.0000003')

>>>(u*v)+(u*w)

Decimal('0.01')

>>>u*(v+w)

Decimal('0.0060000')

decimal?模塊則可以通過充分地擴展精度來避免有效位的丟失：

>>>getcontext().prec=20

>>>u, v, w=Decimal(11111113), Decimal(-11111111), Decimal('7.51111111')

>>>(u+v)+w

Decimal('9.51111111')

>>>u+(v+w)

Decimal('9.51111111')

>>>

>>>u, v, w=Decimal(20000), Decimal(-6), Decimal('6.0000003')

>>>(u*v)+(u*w)

Decimal('0.0060000')

>>>u*(v+w)

Decimal('0.0060000')

特殊的值

decimal?模塊的數(shù)字系統(tǒng)提供了一些特殊的值奸焙，包括?NaN,?sNaN,?-Infinity,?Infinity?以及兩種零值?+0?和?-0。

無窮大可以使用?Decimal('Infinity')?來構(gòu)建彤敛。 它們也可以在不捕獲?DivisionByZero?信號捕獲時通過除以零來產(chǎn)生与帆。 類似地，當不捕獲?Overflow?信號時墨榄，也可以通過舍入到超出最大可表示數(shù)字限制的方式產(chǎn)生無窮大的結(jié)果玄糟。

無窮大是有符號的（仿射）并可用于算術(shù)運算，它們會被當作極其巨大的不確定數(shù)字來處理袄秩。 例如阵翎，無窮大加一個常量結(jié)果也將為無窮大逢并。

某些不存在有效結(jié)果的運算將會返回?NaN，或者如果捕獲了?InvalidOperation?信號則會引發(fā)一個異常郭卫。 例如砍聊，0/0?會返回?NaN?表示結(jié)果“不是一個數(shù)字”。 這樣的?NaN?是靜默產(chǎn)生的贰军，并且在產(chǎn)生之后參與其它計算時總是會得到?NaN?的結(jié)果玻蝌。 這種行為對于偶而缺少輸入的各類計算都很有用處 — 它允許在將特定結(jié)果標記為無效的同時讓計算繼續(xù)運行。

另一種變體形式是?sNaN词疼，它在每次運算后會發(fā)出信號而不是保持靜默俯树。 當對于無效結(jié)果需要中斷計算進行特別處理時，這是一個很有用的返回值贰盗。

Python 中比較運算符的行為在涉及?NaN?時可能會令人有點驚訝许饿。 相等性檢測在操作數(shù)中有靜默型或信號型?NaN?時總是會返回?False?(即使是執(zhí)行?Decimal('NaN')==Decimal('NaN'))，而不等性檢測總是會返回?True童太。 當嘗試使用?<,?<=,?>?或?>=?運算符中的任何一個來比較兩個 Decimal 值時米辐，如果運算數(shù)中有?NaN?則將引發(fā)?InvalidOperation?信號，如果此信號未被捕獲則將返回?False书释。 請注意通用十進制算術(shù)規(guī)范并未規(guī)定直接比較行為翘贮；這些涉及?NaN?的比較規(guī)則來自于 IEEE 854 標準 (見第 5.7 節(jié)表 3)。 要確保嚴格符合標準爆惧，請改用?compare()?和?compare-signal()?方法狸页。

有符號零值可以由向下溢出的運算產(chǎn)生。 它們保留符號是為了讓運算結(jié)果能以更高的精度傳遞扯再。 由于它們的大小為零芍耘，正零和負零會被視為相等，且它們的符號具有信息熄阻。

在這兩個不相同但卻相等的有符號零之外斋竞，還存在幾種零的不同表示形式，它們的精度不同但值也都相等秃殉。 這需要一些時間來逐漸適應(yīng)坝初。 對于習慣了標準浮點表示形式的眼睛來說，以下運算返回等于零的值并不是顯而易見的：

>>>1/Decimal('Infinity')

Decimal('0E-1000026')

使用線程

getcontext()?函數(shù)會為每個線程訪問不同的?Context?對象钾军。 具有單獨線程上下文意味著線程可以修改上下文 (例如?getcontext().prec=10) 而不影響其他線程鳄袍。

類似的?setcontext()?會為當前上下文的目標自動賦值。

如果在調(diào)用?setcontext()?之前調(diào)用了?getcontext()吏恭，則?getcontext()?將自動創(chuàng)建一個新的上下文在當前線程中使用拗小。

新的上下文拷貝自一個名為?DefaultContext?的原型上下文。 要控制默認值以便每個線程在應(yīng)用運行期間都使用相同的值樱哼，可以直接修改?DefaultContext?對象哀九。 這應(yīng)當在任何線程啟動?之前?完成以使得調(diào)用?getcontext()?的線程之間不會產(chǎn)生競爭條件剿配。 例如:

# Set applicationwide defaults for all threads about to be launched

DefaultContext.prec=12

DefaultContext.rounding=ROUND_DOWN

DefaultContext.traps=ExtendedContext.traps.copy()

DefaultContext.traps[InvalidOperation]=1

setcontext(DefaultContext)

# Afterwards, the threads can be started

t1.start()

t2.start()

t3.start()

...

例程

以下是一些用作工具函數(shù)的例程，它們演示了使用?Decimal?類的各種方式:

defmoneyfmt(value, places=2, curr='', sep=',', dp='.',

???????????? pos='', neg='-', trailneg=''):

???"""Convert Decimal to a money formatted string.

??? places:? required number of places after the decimal point

??? curr:??? optional currency symbol before the sign (may be blank)

??? sep:???? optional grouping separator (comma, period, space, or blank)

??? dp:????? decimal point indicator (comma or period)

???????????? only specify as blank when places is zero

??? pos:???? optional sign for positive numbers: '+', space or blank

??? neg:???? optional sign for negative numbers: '-', '(', space or blank

??? trailneg:optional trailing minus indicator:? '-', ')', space or blank

??? >>> d = Decimal('-1234567.8901')

??? >>> moneyfmt(d, curr='$')

??? '-$1,234,567.89'

??? >>> moneyfmt(d, places=0, sep='.', dp='', neg='', trailneg='-')

??? '1.234.568-'

??? >>> moneyfmt(d, curr='$', neg='(', trailneg=')')

??? '($1,234,567.89)'

??? >>> moneyfmt(Decimal(123456789), sep=' ')

??? '123 456 789.00'

??? >>> moneyfmt(Decimal('-0.02'), neg='<', trailneg='>')

??? '<0.02>'

??? """

??? q=Decimal(10)**-places?????# 2 places --> '0.01'

??? sign, digits, exp=value.quantize(q).as_tuple()

??? result=[]

??? digits=list(map(str, digits))

??? build,next=result.append, digits.pop

???ifsign:

??????? build(trailneg)

???foriinrange(places):

??????? build(next()ifdigitselse'0')

???ifplaces:

??????? build(dp)

???ifnotdigits:

??????? build('0')

??? i=0

???whiledigits:

??????? build(next())

??????? i+=1

???????ifi==3anddigits:

??????????? i=0

??????????? build(sep)

??? build(curr)

??? build(negifsignelsepos)

???return''.join(reversed(result))

defpi():

???"""Compute Pi to the current precision.

??? >>> print(pi())

??? 3.141592653589793238462643383

??? """

??? getcontext().prec+=2?# extra digits for intermediate steps

??? three=Decimal(3)?????# substitute "three=3.0" for regular floats

??? lasts, t, s, n, na, d, da=0, three,3,1,0,0,24

???whiles!=lasts:

??????? lasts=s

??????? n, na=n+na, na+8

??????? d, da=d+da, da+32

??????? t=(t*n)/d

??????? s+=t

??? getcontext().prec-=2

???return+s??????????????# unary plus applies the new precision

defexp(x):

???"""Return e raised to the power of x.? Result type matches input type.

??? >>> print(exp(Decimal(1)))

??? 2.718281828459045235360287471

??? >>> print(exp(Decimal(2)))

??? 7.389056098930650227230427461

??? >>> print(exp(2.0))

??? 7.38905609893

??? >>> print(exp(2+0j))

??? (7.38905609893+0j)

??? """

??? getcontext().prec+=2

??? i, lasts, s, fact, num=0,0,1,1,1

???whiles!=lasts:

??????? lasts=s

??????? i+=1

??????? fact*=i

??????? num*=x

??????? s+=num/fact

??? getcontext().prec-=2

???return+s

defcos(x):

???"""Return the cosine of x as measured in radians.

??? The Taylor series approximation works best for a small value of x.

??? For larger values, first compute x = x % (2 * pi).

??? >>> print(cos(Decimal('0.5')))

??? 0.8775825618903727161162815826

??? >>> print(cos(0.5))

??? 0.87758256189

??? >>> print(cos(0.5+0j))

??? (0.87758256189+0j)

??? """

??? getcontext().prec+=2

??? i, lasts, s, fact, num, sign=0,0,1,1,1,1

???whiles!=lasts:

??????? lasts=s

??????? i+=2

??????? fact*=i*(i-1)

??????? num*=x*x

??????? sign*=-1

??????? s+=num/fact*sign

??? getcontext().prec-=2

???return+s

defsin(x):

???"""Return the sine of x as measured in radians.

??? The Taylor series approximation works best for a small value of x.

??? For larger values, first compute x = x % (2 * pi).

??? >>> print(sin(Decimal('0.5')))

??? 0.4794255386042030002732879352

??? >>> print(sin(0.5))

??? 0.479425538604

??? >>> print(sin(0.5+0j))

??? (0.479425538604+0j)

??? """

??? getcontext().prec+=2

??? i, lasts, s, fact, num, sign=1,0, x,1, x,1

???whiles!=lasts:

??????? lasts=s

??????? i+=2

??????? fact*=i*(i-1)

??????? num*=x*x

??????? sign*=-1

??????? s+=num/fact*sign

??? getcontext().prec-=2

???return+s

Decimal FAQ

Q. 總是輸入?decimal.Decimal('1234.5')?是否過于笨拙勾栗。 在使用交互解釋器時有沒有最小化輸入量的方式惨篱？

A. 有些用戶會將構(gòu)造器簡寫為一個字母：

>>>D=decimal.Decimal

>>>D('1.23')+D('3.45')

Decimal('4.68')

Q. 在帶有兩個十進制位的定點數(shù)應(yīng)用中烧董，有些輸入值具有許多位缓溅，需要被舍入壁晒。 另一些數(shù)則不應(yīng)具有多余位，需要驗證有效性界牡。 這種情況應(yīng)該用什么方法？

A. 用?quantize()?方法舍入到固定數(shù)量的十進制位漾抬。 如果設(shè)置了?Inexact?陷阱宿亡，它也適用于驗證有效性：

>>>TWOPLACES=Decimal(10)**-2??????# same as Decimal('0.01')

>>># Round to two places

>>>Decimal('3.214').quantize(TWOPLACES)

Decimal('3.21')

>>># Validate that a number does not exceed two places

>>>Decimal('3.21').quantize(TWOPLACES, context=Context(traps=[Inexact]))

Decimal('3.21')

>>>Decimal('3.214').quantize(TWOPLACES, context=Context(traps=[Inexact]))

Traceback (most recent call last):

??...

Inexact: None

Q. 當我使用兩個有效位的輸入時，我要如何在一個應(yīng)用中保持有效位不變纳令？

A. 某些運算例如與整數(shù)相加挽荠、相減和相乘將會自動保留固定的小數(shù)位數(shù)。 其他運算平绩，例如相除和非整數(shù)相乘則將會改變小數(shù)位數(shù)圈匆，需要再加上?quantize()?處理步驟：

>>>a=Decimal('102.72')??????????# Initial fixed-point values

>>>b=Decimal('3.17')

>>>a+b??????????????????????????# Addition preserves fixed-point

Decimal('105.89')

>>>a-b

Decimal('99.55')

>>>a*42?????????????????????????# So does integer multiplication

Decimal('4314.24')

>>>(a*b).quantize(TWOPLACES)????# Must quantize non-integer multiplication

Decimal('325.62')

>>>(b/a).quantize(TWOPLACES)????# And quantize division

Decimal('0.03')

在開發(fā)定點數(shù)應(yīng)用時，更方便的做法是定義處理?quantize()?步驟的函數(shù)：

>>>defmul(x, y, fp=TWOPLACES):

...???return(x*y).quantize(fp)

>>>defdiv(x, y, fp=TWOPLACES):

...???return(x/y).quantize(fp)

>>>mul(a, b)??????????????????????# Automatically preserve fixed-point

Decimal('325.62')

>>>div(b, a)

Decimal('0.03')

Q. 表示同一個值有許多方式捏雌。 數(shù)字?200,?200.000,?2E2?和?02E+4?的值都相同但有精度不同跃赚。 是否有辦法將它們轉(zhuǎn)換為一個可識別的規(guī)范值？

A.?normalize()?方法可將所有相同的值映射為統(tǒng)一表示形式：

>>>values=map(Decimal,'200 200.000 2E2 .02E+4'.split())

>>>[v.normalize()forvinvalues]

[Decimal('2E+2'), Decimal('2E+2'), Decimal('2E+2'), Decimal('2E+2')]

Q. 有些十進制值總是被打印為指數(shù)表示形式性湿。 是否有辦法得到一個非指數(shù)表示形式纬傲？

A. 對于某些值來說，指數(shù)表示形式是表示系數(shù)中有效位的唯一辦法肤频。 例如叹括，將?5.0E+3?表示為?5000?可以讓值保持恒定，但是無法顯示原本的兩位有效數(shù)字宵荒。

如果一個應(yīng)用不必關(guān)心追蹤有效位汁雷，則可以很容易地移除指數(shù)和末尾的零，丟棄有效位但讓值保持不變：

>>>defremove_exponent(d):

...???returnd.quantize(Decimal(1))ifd==d.to_integral()elsed.normalize()

>>>remove_exponent(Decimal('5E+3'))

Decimal('5000')

Q. 是否有辦法將一個普通浮點數(shù)轉(zhuǎn)換為?Decimal骇扇？

A. 是的摔竿，任何二進制浮點數(shù)都可以精確地表示為 Decimal 值，但精確的轉(zhuǎn)換可能需要比直覺設(shè)想更高的精度：

>>>Decimal(math.pi)

Decimal('3.141592653589793115997963468544185161590576171875')

Q. 在一個復雜的計算中少孝，我怎樣才能保證不會得到由精度不足和舍入異常所導致的虛假結(jié)果继低。

A. 使用 decimal 模塊可以很容易地檢測結(jié)果。 最好的做法是使用更高的精度和不同的舍入模式重新進行計算稍走。 明顯不同的結(jié)果表明存在精度不足袁翁、舍入模式問題柴底、不符合條件的輸入或是結(jié)果不穩(wěn)定的算法。

Q. 我發(fā)現(xiàn)上下文精度的應(yīng)用只針對運算結(jié)果而不針對輸入粱胜。在混合使用不同精度的值時有什么需要注意的嗎柄驻？

A. 是的。 原則上所有值都會被視為精確值焙压，在這些值上進行的算術(shù)運算也是如此鸿脓。 只有結(jié)果會被舍入。 對于輸入來說其好處是“所輸入即所得”涯曲。 而其缺點則是如果你忘記了輸入沒有被舍入野哭，結(jié)果看起來可能會很奇怪：

>>>getcontext().prec=3

>>>Decimal('3.104')+Decimal('2.104')

Decimal('5.21')

>>>Decimal('3.104')+Decimal('0.000')+Decimal('2.104')

Decimal('5.20')

解決辦法是提高精度或使用單目加法運算對輸入執(zhí)行強制舍入：

>>>getcontext().prec=3

>>>+Decimal('1.23456789')?????# unary plus triggers rounding

Decimal('1.23')

此外，還可以使用?Context.create_decimal()?方法在創(chuàng)建輸入時執(zhí)行舍入：

>>>Context(prec=5, rounding=ROUND_DOWN).create_decimal('1.2345678')

Decimal('1.2345