decimal.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2021, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# 
# Translators:
# Alpha Du <alphanow@gmail.com>, 2019
# Naisen Xu <723648649@qq.com>, 2019
# ppcfish <ppcfish@gmail.com>, 2019
# Freesand Leo <yuqinju@163.com>, 2020
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-01-01 16:02+0000\n"
"PO-Revision-Date: 2019-09-01 03:10+0000\n"
"Last-Translator: Freesand Leo <yuqinju@163.com>, 2020\n"
"Language-Team: Chinese (China) (https://www.transifex.com/python-doc/teams/5390/zh_CN/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: zh_CN\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../library/decimal.rst:2
msgid ":mod:`decimal` --- Decimal fixed point and floating point arithmetic"
msgstr ":mod:`decimal` --- 十进制定点和浮点运算"

#: ../../library/decimal.rst:15
msgid "**Source code:** :source:`Lib/decimal.py`"
msgstr "**源码：** :source:`Lib/decimal.py`"

#: ../../library/decimal.rst:33
msgid ""
"The :mod:`decimal` module provides support for fast correctly-rounded "
"decimal floating point arithmetic. It offers several advantages over the "
":class:`float` datatype:"
msgstr ""
":mod:`decimal` 模块为快速正确舍入的十进制浮点运算提供支持。 它提供了 :class:`float` 数据类型以外的几个优点："

#: ../../library/decimal.rst:37
msgid ""
"Decimal \"is based on a floating-point model which was designed with people "
"in mind, and necessarily has a paramount guiding principle -- computers must"
" provide an arithmetic that works in the same way as the arithmetic that "
"people learn at school.\" -- excerpt from the decimal arithmetic "
"specification."
msgstr ""
"Decimal 类型的“设计是基于考虑人类习惯的浮点数模型，并且因此具有以下最高指导原则 —— 计算机必须提供与人们在学校所学习的算术相一致的算术。” "
"—— 摘自 decimal 算术规范描述。"

#: ../../library/decimal.rst:42
msgid ""
"Decimal numbers can be represented exactly.  In contrast, numbers like "
":const:`1.1` and :const:`2.2` do not have exact representations in binary "
"floating point. End users typically would not expect ``1.1 + 2.2`` to "
"display as :const:`3.3000000000000003` as it does with binary floating "
"point."
msgstr ""
"Decimal 数字的表示是精确的。 相比之下，:const:`1.1` 和 :const:`2.2` 这样则是不精确的二进制浮点数表示。 "
"最终用户通常不希望 ``1.1 + 2.2`` 的结果会如采用二进制浮点数时那样显示为 :const:`3.3000000000000003`。"

#: ../../library/decimal.rst:47
msgid ""
"The exactness carries over into arithmetic.  In decimal floating point, "
"``0.1 + 0.1 + 0.1 - 0.3`` is exactly equal to zero.  In binary floating "
"point, the result is :const:`5.5511151231257827e-017`.  While near to zero, "
"the differences prevent reliable equality testing and differences can "
"accumulate. For this reason, decimal is preferred in accounting applications"
" which have strict equality invariants."
msgstr ""
"精确性会延续到算术类操作中。 对于 decimal 浮点数，``0.1 + 0.1 + 0.1 - 0.3`` 会精确地等于零。 "
"而对于二进制浮点数，结果则为 :const:`5.5511151231257827e-017` 。 "
"虽然接近于零，但其中的误差将妨碍可靠的相等性检验，并且误差还会不断累积。 因此，decimal 更适合具有严格相等不变性要求的会计类应用。"

#: ../../library/decimal.rst:54
msgid ""
"The decimal module incorporates a notion of significant places so that "
"``1.30 + 1.20`` is :const:`2.50`.  The trailing zero is kept to indicate "
"significance. This is the customary presentation for monetary applications. "
"For multiplication, the \"schoolbook\" approach uses all the figures in the "
"multiplicands.  For instance, ``1.3 * 1.2`` gives :const:`1.56` while ``1.30"
" * 1.20`` gives :const:`1.5600`."
msgstr ""
"decimal 模块包含了有效位的概念，使得 ``1.30 + 1.20`` 是 :const:`2.50` 。 保留尾随零以表示有效位。 "
"这是货币类应用的习惯表示法。 对于乘法，“教科书”方式使用被乘数中的所有数位。 例如， ``1.3 * 1.2`` 给出 :const:`1.56` 而"
" ``1.30 * 1.20`` 给出 :const:`1.5600` 。"

#: ../../library/decimal.rst:61
msgid ""
"Unlike hardware based binary floating point, the decimal module has a user "
"alterable precision (defaulting to 28 places) which can be as large as "
"needed for a given problem:"
msgstr "与基于硬件的二进制浮点数不同，decimal 模块具有用户可更改的精度（默认为28位），可以与给定问题所需的一样大："

#: ../../library/decimal.rst:73
msgid ""
"Both binary and decimal floating point are implemented in terms of published"
" standards.  While the built-in float type exposes only a modest portion of "
"its capabilities, the decimal module exposes all required parts of the "
"standard. When needed, the programmer has full control over rounding and "
"signal handling. This includes an option to enforce exact arithmetic by "
"using exceptions to block any inexact operations."
msgstr ""
"二进制和 decimal 浮点数都是根据已发布的标准实现的。 虽然内置浮点类型只公开其功能的一小部分，但 decimal 模块公开了标准的所有必需部分。"
" 在需要时，程序员可以完全控制舍入和信号处理。 这包括通过使用异常来阻止任何不精确操作来强制执行精确算术的选项。"

#: ../../library/decimal.rst:80
msgid ""
"The decimal module was designed to support \"without prejudice, both exact "
"unrounded decimal arithmetic (sometimes called fixed-point arithmetic) and "
"rounded floating-point arithmetic.\"  -- excerpt from the decimal arithmetic"
" specification."
msgstr ""
"decimal 模块旨在支持“无偏差，精确无舍入的十进制算术（有时称为定点数算术）和有舍入的浮点数算术”。 —— 摘自 decimal 算术规范说明。"

#: ../../library/decimal.rst:85
msgid ""
"The module design is centered around three concepts:  the decimal number, "
"the context for arithmetic, and signals."
msgstr "该模块的设计以三个概念为中心：decimal 数值，算术上下文和信号。"

#: ../../library/decimal.rst:88
msgid ""
"A decimal number is immutable.  It has a sign, coefficient digits, and an "
"exponent.  To preserve significance, the coefficient digits do not truncate "
"trailing zeros.  Decimals also include special values such as "
":const:`Infinity`, :const:`-Infinity`, and :const:`NaN`.  The standard also "
"differentiates :const:`-0` from :const:`+0`."
msgstr ""
"decimal 数值是不可变对象。 它由符号，系数和指数位组成。 为了保持有效位，系数位不会截去末尾零。 decimal 数值也包括特殊值例如 "
":const:`Infinity` ，:const:`-Infinity` 和 :const:`NaN` 。 该标准还区分 :const:`-0` 和 "
":const:`+0` 。"

#: ../../library/decimal.rst:94
msgid ""
"The context for arithmetic is an environment specifying precision, rounding "
"rules, limits on exponents, flags indicating the results of operations, and "
"trap enablers which determine whether signals are treated as exceptions.  "
"Rounding options include :const:`ROUND_CEILING`, :const:`ROUND_DOWN`, "
":const:`ROUND_FLOOR`, :const:`ROUND_HALF_DOWN`, :const:`ROUND_HALF_EVEN`, "
":const:`ROUND_HALF_UP`, :const:`ROUND_UP`, and :const:`ROUND_05UP`."
msgstr ""
"算术的上下文是指定精度、舍入规则、指数限制、指示操作结果的标志以及确定符号是否被视为异常的陷阱启用器的环境。 舍入选项包括 "
":const:`ROUND_CEILING` 、 :const:`ROUND_DOWN` 、 :const:`ROUND_FLOOR` 、 "
":const:`ROUND_HALF_DOWN`, :const:`ROUND_HALF_EVEN` 、 :const:`ROUND_HALF_UP` "
"、 :const:`ROUND_UP` 以及 :const:`ROUND_05UP`."

#: ../../library/decimal.rst:101
msgid ""
"Signals are groups of exceptional conditions arising during the course of "
"computation.  Depending on the needs of the application, signals may be "
"ignored, considered as informational, or treated as exceptions. The signals "
"in the decimal module are: :const:`Clamped`, :const:`InvalidOperation`, "
":const:`DivisionByZero`, :const:`Inexact`, :const:`Rounded`, "
":const:`Subnormal`, :const:`Overflow`, :const:`Underflow` and "
":const:`FloatOperation`."
msgstr ""
"信号是在计算过程中出现的异常条件组。 根据应用程序的需要，信号可能会被忽略，被视为信息，或被视为异常。 "
"十进制模块中的信号有：:const:`Clamped` 、 :const:`InvalidOperation` 、 "
":const:`DivisionByZero` 、 :const:`Inexact` 、 :const:`Rounded` 、 "
":const:`Subnormal` 、 :const:`Overflow` 、 :const:`Underflow` 以及 "
":const:`FloatOperation` 。"

#: ../../library/decimal.rst:108
msgid ""
"For each signal there is a flag and a trap enabler.  When a signal is "
"encountered, its flag is set to one, then, if the trap enabler is set to "
"one, an exception is raised.  Flags are sticky, so the user needs to reset "
"them before monitoring a calculation."
msgstr ""
"对于每个信号，都有一个标志和一个陷阱启动器。 遇到信号时，其标志设置为 1 ，然后，如果陷阱启用器设置为 1 ，则引发异常。 "
"标志是粘性的，因此用户需要在监控计算之前重置它们。"

#: ../../library/decimal.rst:116
msgid ""
"IBM's General Decimal Arithmetic Specification, `The General Decimal "
"Arithmetic Specification <http://speleotrove.com/decimal/decarith.html>`_."
msgstr ""
"IBM 的通用十进制算术规范描述 `The General Decimal Arithmetic Specification "
"<http://speleotrove.com/decimal/decarith.html>`_。"

#: ../../library/decimal.rst:125
msgid "Quick-start Tutorial"
msgstr "快速入门教程"

#: ../../library/decimal.rst:127
msgid ""
"The usual start to using decimals is importing the module, viewing the "
"current context with :func:`getcontext` and, if necessary, setting new "
"values for precision, rounding, or enabled traps::"
msgstr ""
"通常使用 decimal 的方式是先导入该模块，通过 :func:`getcontext` "
"查看当前上下文，并在必要时为精度、舍入或启用的陷阱设置新值::"

#: ../../library/decimal.rst:139
msgid ""
"Decimal instances can be constructed from integers, strings, floats, or "
"tuples. Construction from an integer or a float performs an exact conversion"
" of the value of that integer or float.  Decimal numbers include special "
"values such as :const:`NaN` which stands for \"Not a number\", positive and "
"negative :const:`Infinity`, and :const:`-0`::"
msgstr ""
"可以基于整数、字符串、浮点数或元组构造 Decimal 实例。 基于整数或浮点数构造将执行该整数或浮点值的精确转换。 Decimal 数字包括特殊值例如"
" :const:`NaN` 表示“非数字”，正的和负的 :const:`Infinity` 和 :const:`-0` ::"

#: ../../library/decimal.rst:163
msgid ""
"If the :exc:`FloatOperation` signal is trapped, accidental mixing of "
"decimals and floats in constructors or ordering comparisons raises an "
"exception::"
msgstr "如果 :exc:`FloatOperation` 信号被捕获，构造函数中的小数和浮点数的意外混合或排序比较会引发异常 ::"

#: ../../library/decimal.rst:182
msgid ""
"The significance of a new Decimal is determined solely by the number of "
"digits input.  Context precision and rounding only come into play during "
"arithmetic operations."
msgstr "新 Decimal 的重要性仅由输入的位数决定。 上下文精度和舍入仅在算术运算期间发挥作用。"

#: ../../library/decimal.rst:199
msgid ""
"If the internal limits of the C version are exceeded, constructing a decimal"
" raises :class:`InvalidOperation`::"
msgstr "如果超出了 C 版本的内部限制，则构造一个 decimal 将引发 :class:`InvalidOperation` ::"

#: ../../library/decimal.rst:209
msgid ""
"Decimals interact well with much of the rest of Python.  Here is a small "
"decimal floating point flying circus:"
msgstr "Decimal 数字能很好地与 Python 的其余部分交互。 以下是一个小小的 decimal 浮点数飞行马戏团："

#: ../../library/decimal.rst:241
msgid "And some mathematical functions are also available to Decimal:"
msgstr "Decimal 也可以使用一些数学函数："

#: ../../library/decimal.rst:253
msgid ""
"The :meth:`quantize` method rounds a number to a fixed exponent.  This "
"method is useful for monetary applications that often round results to a "
"fixed number of places:"
msgstr ":meth:`quantize` 方法将数字四舍五入为固定指数。 此方法对于将结果舍入到固定的位置的货币应用程序非常有用："

#: ../../library/decimal.rst:262
msgid ""
"As shown above, the :func:`getcontext` function accesses the current context"
" and allows the settings to be changed.  This approach meets the needs of "
"most applications."
msgstr "如上所示，:func:`getcontext` 函数访问当前上下文并允许更改设置。 这种方法满足大多数应用程序的需求。"

#: ../../library/decimal.rst:266
msgid ""
"For more advanced work, it may be useful to create alternate contexts using "
"the Context() constructor.  To make an alternate active, use the "
":func:`setcontext` function."
msgstr ""
"对于更高级的工作，使用 Context() 构造函数创建备用上下文可能很有用。 要使用备用活动，请使用 :func:`setcontext` 函数。"

#: ../../library/decimal.rst:270
msgid ""
"In accordance with the standard, the :mod:`decimal` module provides two "
"ready to use standard contexts, :const:`BasicContext` and "
":const:`ExtendedContext`. The former is especially useful for debugging "
"because many of the traps are enabled:"
msgstr ""
"根据标准，:mod:`decimal` 模块提供了两个现成的标准上下文 :const:`BasicContext` 和 "
":const:`ExtendedContext` 。 前者对调试特别有用，因为许多陷阱都已启用："

#: ../../library/decimal.rst:299
msgid ""
"Contexts also have signal flags for monitoring exceptional conditions "
"encountered during computations.  The flags remain set until explicitly "
"cleared, so it is best to clear the flags before each set of monitored "
"computations by using the :meth:`clear_flags` method. ::"
msgstr ""
"上下文还具有用于监视计算期间遇到的异常情况的信号标志。 标志保持设置直到明确清除，因此最好通过使用 :meth:`clear_flags` "
"方法清除每组受监控计算之前的标志。::"

#: ../../library/decimal.rst:312
msgid ""
"The *flags* entry shows that the rational approximation to :const:`Pi` was "
"rounded (digits beyond the context precision were thrown away) and that the "
"result is inexact (some of the discarded digits were non-zero)."
msgstr ""
"*flags* 条目显示对 :const:`Pi` 的有理逼近被舍入（超出上下文精度的数字被抛弃）并且结果是不精确的（一些丢弃的数字不为零）。"

#: ../../library/decimal.rst:316
msgid ""
"Individual traps are set using the dictionary in the :attr:`traps` field of "
"a context:"
msgstr "使用上下文的 :attr:`traps` 字段中的字典设置单个陷阱："

#: ../../library/decimal.rst:331
msgid ""
"Most programs adjust the current context only once, at the beginning of the "
"program.  And, in many applications, data is converted to :class:`Decimal` "
"with a single cast inside a loop.  With context set and decimals created, "
"the bulk of the program manipulates the data no differently than with other "
"Python numeric types."
msgstr ""
"大多数程序仅在程序开始时调整当前上下文一次。 并且，在许多应用程序中，数据在循环内单个强制转换为 :class:`Decimal` 。 "
"通过创建上下文集和小数，程序的大部分操作数据与其他 Python 数字类型没有区别。"

#: ../../library/decimal.rst:343
msgid "Decimal objects"
msgstr "Decimal 对象"

#: ../../library/decimal.rst:348
msgid "Construct a new :class:`Decimal` object based from *value*."
msgstr "根据 *value* 构造一个新的 :class:`Decimal` 对象。"

#: ../../library/decimal.rst:350
msgid ""
"*value* can be an integer, string, tuple, :class:`float`, or another "
":class:`Decimal` object. If no *value* is given, returns ``Decimal('0')``.  "
"If *value* is a string, it should conform to the decimal numeric string "
"syntax after leading and trailing whitespace characters, as well as "
"underscores throughout, are removed::"
msgstr ""
"*value* 可以是整数，字符串，元组，:class:`float` ，或另一个 :class:`Decimal` 对象。 如果没有给出 "
"*value*，则返回 ``Decimal('0')``。 如果 *value* "
"是一个字符串，它应该在前导和尾随空格字符以及下划线被删除之后符合十进制数字字符串语法::"

#: ../../library/decimal.rst:366
msgid ""
"Other Unicode decimal digits are also permitted where ``digit`` appears "
"above.  These include decimal digits from various other alphabets (for "
"example, Arabic-Indic and Devanāgarī digits) along with the fullwidth digits"
" ``'\\uff10'`` through ``'\\uff19'``."
msgstr ""
"当上面出现 ``digit`` 时也允许其他十进制数码。 其中包括来自各种其他语言系统的十进制数码（例如阿拉伯-印地语和天城文的数码）以及全宽数码 "
"``'\\uff10'`` 到 ``'\\uff19'``。"

#: ../../library/decimal.rst:371
msgid ""
"If *value* is a :class:`tuple`, it should have three components, a sign "
"(:const:`0` for positive or :const:`1` for negative), a :class:`tuple` of "
"digits, and an integer exponent. For example, ``Decimal((0, (1, 4, 1, 4), "
"-3))`` returns ``Decimal('1.414')``."
msgstr ""
"如果 *value* 是一个 :class:`tuple` ，它应该有三个组件，一个符号（ :const:`0` 表示正数或 :const:`1` "
"表示负数），一个数字的 :class:`tuple` 和整数指数。 例如， ``Decimal((0, (1, 4, 1, 4), -3))`` 返回 "
"``Decimal('1.414')``。"

#: ../../library/decimal.rst:376
msgid ""
"If *value* is a :class:`float`, the binary floating point value is "
"losslessly converted to its exact decimal equivalent.  This conversion can "
"often require 53 or more digits of precision.  For example, "
"``Decimal(float('1.1'))`` converts to "
"``Decimal('1.100000000000000088817841970012523233890533447265625')``."
msgstr ""
"如果 *value* 是 :class:`float` ，则二进制浮点值无损地转换为其精确的十进制等效值。 此转换通常需要53位或更多位数的精度。 "
"例如， ``Decimal(float('1.1'))`` "
"转换为``Decimal('1.100000000000000088817841970012523233890533447265625')``。"

#: ../../library/decimal.rst:382
msgid ""
"The *context* precision does not affect how many digits are stored. That is "
"determined exclusively by the number of digits in *value*. For example, "
"``Decimal('3.00000')`` records all five zeros even if the context precision "
"is only three."
msgstr ""
"*context* 精度不会影响存储的位数。 这完全由 *value* 中的位数决定。 例如，``Decimal('3.00000')`` "
"记录所有五个零，即使上下文精度只有三。"

#: ../../library/decimal.rst:387
msgid ""
"The purpose of the *context* argument is determining what to do if *value* "
"is a malformed string.  If the context traps :const:`InvalidOperation`, an "
"exception is raised; otherwise, the constructor returns a new Decimal with "
"the value of :const:`NaN`."
msgstr ""
"*context* 参数的目的是确定 *value* 是格式错误的字符串时该怎么做。 如果上下文陷阱 "
":const:`InvalidOperation`，则引发异常；否则，构造函数返回一个新的 Decimal，其值为 :const:`NaN`。"

#: ../../library/decimal.rst:392
msgid "Once constructed, :class:`Decimal` objects are immutable."
msgstr "构造完成后， :class:`Decimal` 对象是不可变的。"

#: ../../library/decimal.rst:394
msgid ""
"The argument to the constructor is now permitted to be a :class:`float` "
"instance."
msgstr "现在允许构造函数的参数为 :class:`float` 实例。"

#: ../../library/decimal.rst:398
msgid ""
":class:`float` arguments raise an exception if the :exc:`FloatOperation` "
"trap is set. By default the trap is off."
msgstr ":class:`float` 参数在设置 :exc:`FloatOperation` 陷阱时引发异常。 默认情况下，陷阱已关闭。"

#: ../../library/decimal.rst:402
msgid ""
"Underscores are allowed for grouping, as with integral and floating-point "
"literals in code."
msgstr "允许下划线进行分组，就像代码中的整数和浮点文字一样。"

#: ../../library/decimal.rst:406
msgid ""
"Decimal floating point objects share many properties with the other built-in"
" numeric types such as :class:`float` and :class:`int`.  All of the usual "
"math operations and special methods apply.  Likewise, decimal objects can be"
" copied, pickled, printed, used as dictionary keys, used as set elements, "
"compared, sorted, and coerced to another type (such as :class:`float` or "
":class:`int`)."
msgstr ""
"十进制浮点对象与其他内置数值类型共享许多属性，例如 :class:`float` 和 :class:`int` 。 所有常用的数学运算和特殊方法都适用。"
" 同样，十进制对象可以复制、pickle、打印、用作字典键、用作集合元素、比较、排序和强制转换为另一种类型（例如 :class:`float` 或 "
":class:`int` ）。"

#: ../../library/decimal.rst:413
msgid ""
"There are some small differences between arithmetic on Decimal objects and "
"arithmetic on integers and floats.  When the remainder operator ``%`` is "
"applied to Decimal objects, the sign of the result is the sign of the "
"*dividend* rather than the sign of the divisor::"
msgstr ""
"算术对十进制对象和算术对整数和浮点数有一些小的差别。 当余数运算符 ``%`` 应用于Decimal对象时，结果的符号是 *被除数* "
"的符号，而不是除数的符号::"

#: ../../library/decimal.rst:423
msgid ""
"The integer division operator ``//`` behaves analogously, returning the "
"integer part of the true quotient (truncating towards zero) rather than its "
"floor, so as to preserve the usual identity ``x == (x // y) * y + x % y``::"
msgstr ""
"整数除法运算符 ``//`` 的行为类似，返回真商的整数部分（截断为零）而不是它的向下取整，以便保留通常的标识 ``x == (x // y) * y "
"+ x % y``::"

#: ../../library/decimal.rst:432
msgid ""
"The ``%`` and ``//`` operators implement the ``remainder`` and ``divide-"
"integer`` operations (respectively) as described in the specification."
msgstr ""
"``%`` 和 ``//`` 运算符实现了 ``remainder`` 和 ``divide-integer`` 操作（分别），如规范中所述。"

#: ../../library/decimal.rst:436
msgid ""
"Decimal objects cannot generally be combined with floats or instances of "
":class:`fractions.Fraction` in arithmetic operations: an attempt to add a "
":class:`Decimal` to a :class:`float`, for example, will raise a "
":exc:`TypeError`.  However, it is possible to use Python's comparison "
"operators to compare a :class:`Decimal` instance ``x`` with another number "
"``y``.  This avoids confusing results when doing equality comparisons "
"between numbers of different types."
msgstr ""
"十进制对象通常不能与浮点数或 :class:`fractions.Fraction` 实例在算术运算中结合使用：例如,尝试将 "
":class:`Decimal` 加到 :class:`float` ，将引发 :exc:`TypeError`。 但是，可以使用 Python "
"的比较运算符来比较 :class:`Decimal` 实例 ``x`` 和另一个数字 ``y`` 。 "
"这样可以避免在对不同类型的数字进行相等比较时混淆结果。"

#: ../../library/decimal.rst:444
msgid ""
"Mixed-type comparisons between :class:`Decimal` instances and other numeric "
"types are now fully supported."
msgstr "现在完全支持 :class:`Decimal` 实例和其他数字类型之间的混合类型比较。"

#: ../../library/decimal.rst:448
msgid ""
"In addition to the standard numeric properties, decimal floating point "
"objects also have a number of specialized methods:"
msgstr "除了标准的数字属性，十进制浮点对象还有许多专门的方法："

#: ../../library/decimal.rst:454
msgid ""
"Return the adjusted exponent after shifting out the coefficient's rightmost "
"digits until only the lead digit remains: ``Decimal('321e+5').adjusted()`` "
"returns seven.  Used for determining the position of the most significant "
"digit with respect to the decimal point."
msgstr ""
"在移出系数最右边的数字之后返回调整后的指数，直到只剩下前导数字：``Decimal('321e+5').adjusted()`` 返回 7 。 "
"用于确定最高有效位相对于小数点的位置。"

#: ../../library/decimal.rst:461
msgid ""
"Return a pair ``(n, d)`` of integers that represent the given "
":class:`Decimal` instance as a fraction, in lowest terms and with a positive"
" denominator::"
msgstr "返回一对 ``(n, d)`` 整数，表示给定的 :class:`Decimal` 实例作为分数、最简形式项并带有正分母::"

#: ../../library/decimal.rst:468
msgid ""
"The conversion is exact.  Raise OverflowError on infinities and ValueError "
"on NaNs."
msgstr "转换是精确的。 在 Infinity 上引发 OverflowError ，在 NaN 上引起 ValueError 。"

#: ../../library/decimal.rst:475
msgid ""
"Return a :term:`named tuple` representation of the number: "
"``DecimalTuple(sign, digits, exponent)``."
msgstr ""
"返回一个 :term:`named tuple` 表示的数字： ``DecimalTuple(sign, digits, exponent)``。"

#: ../../library/decimal.rst:481
msgid ""
"Return the canonical encoding of the argument.  Currently, the encoding of a"
" :class:`Decimal` instance is always canonical, so this operation returns "
"its argument unchanged."
msgstr "返回参数的规范编码。 目前，一个 :class:`Decimal` 实例的编码始终是规范的，因此该操作返回其参数不变。"

#: ../../library/decimal.rst:487
msgid ""
"Compare the values of two Decimal instances.  :meth:`compare` returns a "
"Decimal instance, and if either operand is a NaN then the result is a NaN::"
msgstr ""
"比较两个 Decimal 实例的值。 :meth:`compare` 返回一个 Decimal 实例，如果任一操作数是 NaN ，那么结果是 NaN "
"::"

#: ../../library/decimal.rst:498
msgid ""
"This operation is identical to the :meth:`compare` method, except that all "
"NaNs signal.  That is, if neither operand is a signaling NaN then any quiet "
"NaN operand is treated as though it were a signaling NaN."
msgstr ""
"除了所有 NaN 信号之外，此操作与 :meth:`compare` 方法相同。 也就是说，如果两个操作数都不是信令NaN，那么任何静默的 NaN "
"操作数都被视为信令NaN。"

#: ../../library/decimal.rst:504
msgid ""
"Compare two operands using their abstract representation rather than their "
"numerical value.  Similar to the :meth:`compare` method, but the result "
"gives a total ordering on :class:`Decimal` instances.  Two :class:`Decimal` "
"instances with the same numeric value but different representations compare "
"unequal in this ordering:"
msgstr ""
"使用它们的抽象表示而不是它们的数值来比较两个操作数。 类似于 :meth:`compare` 方法，但结果给出了一个总排序 "
":class:`Decimal` 实例。 两个 :class:`Decimal` 实例具有相同的数值但不同的表示形式在此排序中比较不相等："

#: ../../library/decimal.rst:513
msgid ""
"Quiet and signaling NaNs are also included in the total ordering.  The "
"result of this function is ``Decimal('0')`` if both operands have the same "
"representation, ``Decimal('-1')`` if the first operand is lower in the total"
" order than the second, and ``Decimal('1')`` if the first operand is higher "
"in the total order than the second operand.  See the specification for "
"details of the total order."
msgstr ""
"静默和发出信号的 NaN 也包括在总排序中。 这个函数的结果是 ``Decimal('0')`` 如果两个操作数具有相同的表示，或是 "
"``Decimal('-1')`` 如果第一个操作数的总顺序低于第二个操作数，或是 ``Decimal('1')`` "
"如果第一个操作数在总顺序中高于第二个操作数。 有关总排序的详细信息，请参阅规范。"

#: ../../library/decimal.rst:520 ../../library/decimal.rst:531
#: ../../library/decimal.rst:559 ../../library/decimal.rst:834
msgid ""
"This operation is unaffected by context and is quiet: no flags are changed "
"and no rounding is performed.  As an exception, the C version may raise "
"InvalidOperation if the second operand cannot be converted exactly."
msgstr ""
"此操作不受上下文影响且静默：不更改任何标志且不执行舍入。 作为例外，如果无法准确转换第二个操作数，则C版本可能会引发InvalidOperation。"

#: ../../library/decimal.rst:526
msgid ""
"Compare two operands using their abstract representation rather than their "
"value as in :meth:`compare_total`, but ignoring the sign of each operand. "
"``x.compare_total_mag(y)`` is equivalent to "
"``x.copy_abs().compare_total(y.copy_abs())``."
msgstr ""
"比较两个操作数使用它们的抽象表示而不是它们的值，如 :meth:`compare_total`，但忽略每个操作数的符号。 "
"``x.compare_total_mag(y)`` 相当于 ``x.copy_abs().compare_total(y.copy_abs())``。"

#: ../../library/decimal.rst:537
msgid ""
"Just returns self, this method is only to comply with the Decimal "
"Specification."
msgstr "只返回self，这种方法只符合 Decimal 规范。"

#: ../../library/decimal.rst:542
msgid ""
"Return the absolute value of the argument.  This operation is unaffected by "
"the context and is quiet: no flags are changed and no rounding is performed."
msgstr "返回参数的绝对值。 此操作不受上下文影响并且是静默的：没有更改标志且不执行舍入。"

#: ../../library/decimal.rst:548
msgid ""
"Return the negation of the argument.  This operation is unaffected by the "
"context and is quiet: no flags are changed and no rounding is performed."
msgstr "回到参数的否定。 此操作不受上下文影响并且是静默的：没有标志更改且不执行舍入。"

#: ../../library/decimal.rst:553
msgid ""
"Return a copy of the first operand with the sign set to be the same as the "
"sign of the second operand.  For example:"
msgstr "返回第一个操作数的副本，其符号设置为与第二个操作数的符号相同。 例如："

#: ../../library/decimal.rst:565
msgid ""
"Return the value of the (natural) exponential function ``e**x`` at the given"
" number.  The result is correctly rounded using the :const:`ROUND_HALF_EVEN`"
" rounding mode."
msgstr "返回给定数字的（自然）指数函数``e**x``的值。结果使用 :const:`ROUND_HALF_EVEN` 舍入模式正确舍入。"

#: ../../library/decimal.rst:576
msgid "Classmethod that converts a float to a decimal number, exactly."
msgstr "将浮点数转换为十进制数的类方法。"

#: ../../library/decimal.rst:578
msgid ""
"Note `Decimal.from_float(0.1)` is not the same as `Decimal('0.1')`. Since "
"0.1 is not exactly representable in binary floating point, the value is "
"stored as the nearest representable value which is `0x1.999999999999ap-4`.  "
"That equivalent value in decimal is "
"`0.1000000000000000055511151231257827021181583404541015625`."
msgstr ""
"注意， `Decimal.from_float(0.1)` 与 `Decimal('0.1')` 不同。 由于 0.1 "
"在二进制浮点中不能精确表示，因此该值存储为最接近的可表示值，即 `0x1.999999999999ap-4` 。 "
"十进制的等效值是`0.1000000000000000055511151231257827021181583404541015625`。"

#: ../../library/decimal.rst:584
msgid ""
"From Python 3.2 onwards, a :class:`Decimal` instance can also be constructed"
" directly from a :class:`float`."
msgstr "从 Python 3.2 开始，:class:`Decimal` 实例也可以直接从 :class:`float` 构造。"

#: ../../library/decimal.rst:602
msgid ""
"Fused multiply-add.  Return self*other+third with no rounding of the "
"intermediate product self*other."
msgstr "混合乘法加法。 返回 self*other+third ，中间乘积 self*other 没有四舍五入。"

#: ../../library/decimal.rst:610
msgid ""
"Return :const:`True` if the argument is canonical and :const:`False` "
"otherwise.  Currently, a :class:`Decimal` instance is always canonical, so "
"this operation always returns :const:`True`."
msgstr ""
"如果参数是规范的，则为返回 :const:`True`，否则为 :const:`False` 。 目前，:class:`Decimal` "
"实例总是规范的，所以这个操作总是返回 :const:`True` 。"

#: ../../library/decimal.rst:616
msgid ""
"Return :const:`True` if the argument is a finite number, and :const:`False` "
"if the argument is an infinity or a NaN."
msgstr "如果参数是一个有限的数，则返回为 :const:`True` ；如果参数为无穷大或 NaN ，则返回为 :const:`False`。"

#: ../../library/decimal.rst:621
msgid ""
"Return :const:`True` if the argument is either positive or negative infinity"
" and :const:`False` otherwise."
msgstr "如果参数为正负无穷大，则返回为 :const:`True` ，否则为 :const:`False` 。"

#: ../../library/decimal.rst:626
msgid ""
"Return :const:`True` if the argument is a (quiet or signaling) NaN and "
":const:`False` otherwise."
msgstr "如果参数为 NaN （无论是否静默），则返回为 :const:`True` ，否则为 :const:`False` 。"

#: ../../library/decimal.rst:631
msgid ""
"Return :const:`True` if the argument is a *normal* finite number.  Return "
":const:`False` if the argument is zero, subnormal, infinite or a NaN."
msgstr "如果参数是一个有限正规数，返回 :const:`True`，如果参数是0、次正规数、无穷大或是NaN，返回 :const:`False`。"

#: ../../library/decimal.rst:636
msgid ""
"Return :const:`True` if the argument is a quiet NaN, and :const:`False` "
"otherwise."
msgstr "如果参数为静默 NaN，返回 :const:`True`，否则返回 :const:`False`。"

#: ../../library/decimal.rst:641
msgid ""
"Return :const:`True` if the argument has a negative sign and :const:`False` "
"otherwise.  Note that zeros and NaNs can both carry signs."
msgstr "如果参数带有负号，则返回为 :const:`True`，否则返回 :const:`False`。注意，0 和 NaN 都可带有符号。"

#: ../../library/decimal.rst:646
msgid ""
"Return :const:`True` if the argument is a signaling NaN and :const:`False` "
"otherwise."
msgstr "如果参数为显式 NaN，则返回 :const:`True`，否则返回 :const:`False`。"

#: ../../library/decimal.rst:651
msgid ""
"Return :const:`True` if the argument is subnormal, and :const:`False` "
"otherwise."
msgstr "如果参数为次正规数，则返回 :const:`True`，否则返回 :const:`False`。"

#: ../../library/decimal.rst:656
msgid ""
"Return :const:`True` if the argument is a (positive or negative) zero and "
":const:`False` otherwise."
msgstr "如果参数是0（正负皆可），则返回 :const:`True`，否则返回 :const:`False`。"

#: ../../library/decimal.rst:661
msgid ""
"Return the natural (base e) logarithm of the operand.  The result is "
"correctly rounded using the :const:`ROUND_HALF_EVEN` rounding mode."
msgstr "返回操作数的自然对数（以 e 为底）。结果是使用 :const:`ROUND_HALF_EVEN` 舍入模式正确四舍五入的。"

#: ../../library/decimal.rst:666
msgid ""
"Return the base ten logarithm of the operand.  The result is correctly "
"rounded using the :const:`ROUND_HALF_EVEN` rounding mode."
msgstr "返回操作数的以十为底的对数。结果是使用 :const:`ROUND_HALF_EVEN` 舍入模式正确四舍五入的。"

#: ../../library/decimal.rst:671
msgid ""
"For a nonzero number, return the adjusted exponent of its operand as a "
":class:`Decimal` instance.  If the operand is a zero then "
"``Decimal('-Infinity')`` is returned and the :const:`DivisionByZero` flag is"
" raised.  If the operand is an infinity then ``Decimal('Infinity')`` is "
"returned."
msgstr ""
"对于一个非零数，返回其运算数的调整后指数作为一个 :class:`Decimal` 实例。 如果运算数为零将返回 "
"``Decimal('-Infinity')`` 并且产生 the :const:`DivisionByZero` 标志。如果运算数是无限大则返回 "
"``Decimal('Infinity')`` 。"

#: ../../library/decimal.rst:679
msgid ""
":meth:`logical_and` is a logical operation which takes two *logical "
"operands* (see :ref:`logical_operands_label`).  The result is the digit-wise"
" ``and`` of the two operands."
msgstr ""
":meth:`logical_and` 是需要两个 *逻辑运算数* 的逻辑运算（参考 :ref:`logical_operands_label` "
"）。结果是按位输出的两运算数的 “和”。"

#: ../../library/decimal.rst:685
msgid ""
":meth:`logical_invert` is a logical operation.  The result is the digit-wise"
" inversion of the operand."
msgstr ":meth:`logical_invert` 是一个逻辑运算。 结果是按位的倒转的运算数。"

#: ../../library/decimal.rst:690
msgid ""
":meth:`logical_or` is a logical operation which takes two *logical operands*"
" (see :ref:`logical_operands_label`).  The result is the digit-wise ``or`` "
"of the two operands."
msgstr ""
":meth:`logical_or` 是需要两个 *logical operands* 的逻辑运算（请参阅 "
":ref:`logical_operands_label` ）。结果是两个运算数的按位的 ``or`` 。"

#: ../../library/decimal.rst:696
msgid ""
":meth:`logical_xor` is a logical operation which takes two *logical "
"operands* (see :ref:`logical_operands_label`).  The result is the digit-wise"
" exclusive or of the two operands."
msgstr ""
":meth:`logical_xor` 是需要两个 *逻辑运算数* 的逻辑运算（参考 :ref:`logical_operands_label` "
"）。结果是按位输出的两运算数的异或运算。"

#: ../../library/decimal.rst:702
msgid ""
"Like ``max(self, other)`` except that the context rounding rule is applied "
"before returning and that :const:`NaN` values are either signaled or ignored"
" (depending on the context and whether they are signaling or quiet)."
msgstr ""
"像 ``max(self, other)`` 一样，除了在返回之前应用上下文舍入规则并且用信号通知或忽略 :const:`NaN` "
"值（取决于上下文以及它们是发信号还是安静）。"

#: ../../library/decimal.rst:709
msgid ""
"Similar to the :meth:`.max` method, but the comparison is done using the "
"absolute values of the operands."
msgstr "与 :meth:`.max` 方法相似，但是操作数使用绝对值进行比较。"

#: ../../library/decimal.rst:714
msgid ""
"Like ``min(self, other)`` except that the context rounding rule is applied "
"before returning and that :const:`NaN` values are either signaled or ignored"
" (depending on the context and whether they are signaling or quiet)."
msgstr ""
"像 ``min(self, other)`` 一样，除了在返回之前应用上下文舍入规则并且用信号通知或忽略 :const:`NaN` "
"值（取决于上下文以及它们是发信号还是安静）。"

#: ../../library/decimal.rst:721
msgid ""
"Similar to the :meth:`.min` method, but the comparison is done using the "
"absolute values of the operands."
msgstr "与 :meth:`.min` 方法相似，但是操作数使用绝对值进行比较。"

#: ../../library/decimal.rst:726
msgid ""
"Return the largest number representable in the given context (or in the "
"current thread's context if no context is given) that is smaller than the "
"given operand."
msgstr "返回小于给定操作数的上下文中可表示的最大数字（或者当前线程的上下文中的可表示的最大数字如果没有给定上下文）。"

#: ../../library/decimal.rst:732
msgid ""
"Return the smallest number representable in the given context (or in the "
"current thread's context if no context is given) that is larger than the "
"given operand."
msgstr "返回大于给定操作数的上下文中可表示的最小数字（或者当前线程的上下文中的可表示的最小数字如果没有给定上下文）。"

#: ../../library/decimal.rst:738
msgid ""
"If the two operands are unequal, return the number closest to the first "
"operand in the direction of the second operand.  If both operands are "
"numerically equal, return a copy of the first operand with the sign set to "
"be the same as the sign of the second operand."
msgstr ""
"如果两运算数不相等，返回在第二个操作数的方向上最接近第一个操作数的数。如果两操作数数值上相等，返回将符号设置为与第二个运算数相同的第一个运算数的拷贝。"

#: ../../library/decimal.rst:745
msgid ""
"Normalize the number by stripping the rightmost trailing zeros and "
"converting any result equal to :const:`Decimal('0')` to "
":const:`Decimal('0e0')`. Used for producing canonical values for attributes "
"of an equivalence class. For example, ``Decimal('32.100')`` and "
"``Decimal('0.321000e+2')`` both normalize to the equivalent value "
"``Decimal('32.1')``."
msgstr ""
"通过去除尾随的零并将所有结果等于 :const:`Decimal('0')` 的转化为 :const:`Decimal('0e0')` "
"来标准化数字。用于为等效类的属性生成规范值。比如， ``Decimal('32.100')`` 和 ``Decimal('0.321000e+2')``"
" 都被标准化为相同的值 ``Decimal('32.1')``。"

#: ../../library/decimal.rst:754
msgid ""
"Return a string describing the *class* of the operand.  The returned value "
"is one of the following ten strings."
msgstr "返回一个字符串描述运算数的 *class* 。返回值是以下十个字符串中的一个。"

#: ../../library/decimal.rst:757
msgid "``\"-Infinity\"``, indicating that the operand is negative infinity."
msgstr "``\"-Infinity\"`` ，指示操作数为负无穷大。"

#: ../../library/decimal.rst:758
msgid "``\"-Normal\"``, indicating that the operand is a negative normal number."
msgstr "``\"-Normal\"`` ，指示该操作数是负正常数字。"

#: ../../library/decimal.rst:759
msgid "``\"-Subnormal\"``, indicating that the operand is negative and subnormal."
msgstr "``\"-Subnormal\"`` ，指示该操作数是负的次正规数。"

#: ../../library/decimal.rst:760
msgid "``\"-Zero\"``, indicating that the operand is a negative zero."
msgstr "``\"-Zero\"`` ，指示该操作数是负零。"

#: ../../library/decimal.rst:761
msgid "``\"+Zero\"``, indicating that the operand is a positive zero."
msgstr "``\"-Zero\"`` ，指示该操作数是正零。"

#: ../../library/decimal.rst:762
msgid "``\"+Subnormal\"``, indicating that the operand is positive and subnormal."
msgstr "``\"+Subnormal\"`` ，指示该操作数是正的次正规数。"

#: ../../library/decimal.rst:763
msgid "``\"+Normal\"``, indicating that the operand is a positive normal number."
msgstr "``\"+Normal\"`` ，指示该操作数是正的正规数。"

#: ../../library/decimal.rst:764
msgid "``\"+Infinity\"``, indicating that the operand is positive infinity."
msgstr "``\"+Infinity\"`` ，指示该运算数是正无穷。"

#: ../../library/decimal.rst:765
msgid "``\"NaN\"``, indicating that the operand is a quiet NaN (Not a Number)."
msgstr "``\"NaN\"`` ，指示该运算数是沉寂的 NaN （非数字）。"

#: ../../library/decimal.rst:766
msgid "``\"sNaN\"``, indicating that the operand is a signaling NaN."
msgstr "``\"sNaN\"`` ，指示该运算数是信号 NaN 。"

#: ../../library/decimal.rst:770
msgid ""
"Return a value equal to the first operand after rounding and having the "
"exponent of the second operand."
msgstr "返回的值等于四舍五入的第一个运算数并且具有第二个操作数的指数。"

#: ../../library/decimal.rst:776
msgid ""
"Unlike other operations, if the length of the coefficient after the quantize"
" operation would be greater than precision, then an "
":const:`InvalidOperation` is signaled. This guarantees that, unless there is"
" an error condition, the quantized exponent is always equal to that of the "
"right-hand operand."
msgstr ""
"与其他运算不同，如果量化运算后的系数长度大于精度，那么会发出一个 :const:`InvalidOperation` "
"信号。这保证了除非有一个错误情况，量化指数恒等于右手运算数的指数。"

#: ../../library/decimal.rst:782
msgid ""
"Also unlike other operations, quantize never signals Underflow, even if the "
"result is subnormal and inexact."
msgstr "与其他运算不同，量化永不信号下溢，即使结果不正常且不精确。"

#: ../../library/decimal.rst:785
msgid ""
"If the exponent of the second operand is larger than that of the first then "
"rounding may be necessary.  In this case, the rounding mode is determined by"
" the ``rounding`` argument if given, else by the given ``context`` argument;"
" if neither argument is given the rounding mode of the current thread's "
"context is used."
msgstr ""
"如果第二个运算数的指数大于第一个运算数的指数那或许需要四舍五入。在这种情况下，舍入模式由给定 ``rounding`` 参数决定，其余的由给定 "
"``context`` 参数决定；如果参数都未给定，使用当前线程上下文的舍入模式。"

#: ../../library/decimal.rst:791
msgid ""
"An error is returned whenever the resulting exponent is greater than "
":attr:`Emax` or less than :attr:`Etiny`."
msgstr "每当结果的指数大于 :attr:`Emax` 或小于 :attr:`Etiny` 就会返回错误。"

#: ../../library/decimal.rst:796
msgid ""
"Return ``Decimal(10)``, the radix (base) in which the :class:`Decimal` class"
" does all its arithmetic.  Included for compatibility with the "
"specification."
msgstr ""
"返回 ``Decimal(10)``，即 :class:`Decimal` 类进行所有算术运算所用的数制（基数）。 "
"这是为保持与规范描述的兼容性而加入的。"

#: ../../library/decimal.rst:802
msgid ""
"Return the remainder from dividing *self* by *other*.  This differs from "
"``self % other`` in that the sign of the remainder is chosen so as to "
"minimize its absolute value.  More precisely, the return value is ``self - n"
" * other`` where ``n`` is the integer nearest to the exact value of ``self /"
" other``, and if two integers are equally near then the even one is chosen."
msgstr ""
"返回 *self* 除以 *other* 的余数。 这与 ``self % other`` 的区别在于所选择的余数要使其绝对值最小化。 "
"更准确地说，返回值为 ``self - n * other`` 其中 ``n`` 是最接近 ``self / other`` "
"的实际值的整数，并且如果两个整数与实际值的差相等则会选择其中的偶数。"

#: ../../library/decimal.rst:809
msgid "If the result is zero then its sign will be the sign of *self*."
msgstr "如果结果为零则其符号将为 *self* 的符号。"

#: ../../library/decimal.rst:820
msgid ""
"Return the result of rotating the digits of the first operand by an amount "
"specified by the second operand.  The second operand must be an integer in "
"the range -precision through precision.  The absolute value of the second "
"operand gives the number of places to rotate.  If the second operand is "
"positive then rotation is to the left; otherwise rotation is to the right. "
"The coefficient of the first operand is padded on the left with zeros to "
"length precision if necessary.  The sign and exponent of the first operand "
"are unchanged."
msgstr ""
"返回对第一个操作数的数码按第二个操作数所指定的数量进行轮转的结果。 第二个操作数必须为 -precision 至 precision 精度范围内的整数。"
" 第二个操作数的绝对值给出要轮转的位数。 如果第二个操作数为正值则向左轮转；否则向右轮转。 如有必要第一个操作数的系数会在左侧填充零以达到 "
"precision 所指定的长度。 第一个操作数的符号和指数保持不变。"

#: ../../library/decimal.rst:831
msgid ""
"Test whether self and other have the same exponent or whether both are "
":const:`NaN`."
msgstr "检测自身与 other 是否具有相同的指数或是否均为 :const:`NaN`。"

#: ../../library/decimal.rst:840
msgid ""
"Return the first operand with exponent adjusted by the second. Equivalently,"
" return the first operand multiplied by ``10**other``.  The second operand "
"must be an integer."
msgstr ""
"返回第一个操作数使用第二个操作数对指数进行调整的结果。 等价于返回第一个操作数乘以 ``10**other`` 的结果。 第二个操作数必须为整数。"

#: ../../library/decimal.rst:846
msgid ""
"Return the result of shifting the digits of the first operand by an amount "
"specified by the second operand.  The second operand must be an integer in "
"the range -precision through precision.  The absolute value of the second "
"operand gives the number of places to shift.  If the second operand is "
"positive then the shift is to the left; otherwise the shift is to the right."
"  Digits shifted into the coefficient are zeros.  The sign and exponent of "
"the first operand are unchanged."
msgstr ""
"返回第一个操作数的数码按第二个操作数所指定的数量进行移位的结果。 第二个操作数必须为 -precision 至 precision 范围内的整数。 "
"第二个操作数的绝对值给出要移动的位数。 如果第二个操作数为正值则向左移位；否则向右移位。 移入系数的数码为零。 第一个操作数的符号和指数保持不变。"

#: ../../library/decimal.rst:856
msgid "Return the square root of the argument to full precision."
msgstr "返回参数的平方根精确到完整精度。"

#: ../../library/decimal.rst:861 ../../library/decimal.rst:1437
msgid ""
"Convert to a string, using engineering notation if an exponent is needed."
msgstr "转换为字符串，如果需要指数则会使用工程标注法。"

#: ../../library/decimal.rst:863 ../../library/decimal.rst:1439
msgid ""
"Engineering notation has an exponent which is a multiple of 3.  This can "
"leave up to 3 digits to the left of the decimal place and may require the "
"addition of either one or two trailing zeros."
msgstr "工程标注法的指数是 3 的倍数。 这会在十进制位的左边保留至多 3 个数码，并可能要求添加一至两个末尾零。"

#: ../../library/decimal.rst:867
msgid ""
"For example, this converts ``Decimal('123E+1')`` to ``Decimal('1.23E+3')``."
msgstr "例如，此方法会将 ``Decimal('123E+1')`` 转换为 ``Decimal('1.23E+3')``。"

#: ../../library/decimal.rst:871
msgid ""
"Identical to the :meth:`to_integral_value` method.  The ``to_integral`` name"
" has been kept for compatibility with older versions."
msgstr "与 :meth:`to_integral_value` 方法相同。 保留 ``to_integral`` 名称是为了与旧版本兼容。"

#: ../../library/decimal.rst:876
msgid ""
"Round to the nearest integer, signaling :const:`Inexact` or :const:`Rounded`"
" as appropriate if rounding occurs.  The rounding mode is determined by the "
"``rounding`` parameter if given, else by the given ``context``.  If neither "
"parameter is given then the rounding mode of the current context is used."
msgstr ""
"舍入到最接近的整数，发出信号 :const:`Inexact` 或者如果发生舍入则相应地发出信号 :const:`Rounded`。 如果给出 "
"``rounding`` 形参则由其确定舍入模式，否则由给定的 ``context`` 来确定。 如果没有给定任何形参则会使用当前上下文的舍入模式。"

#: ../../library/decimal.rst:884
msgid ""
"Round to the nearest integer without signaling :const:`Inexact` or "
":const:`Rounded`.  If given, applies *rounding*; otherwise, uses the "
"rounding method in either the supplied *context* or the current context."
msgstr ""
"舍入到最接近的整数而不发出 :const:`Inexact` 或 :const:`Rounded` 信号。 如果给出 *rounding* "
"则会应用其所指定的舍入模式；否则使用所提供的 *context* 或当前上下文的舍入方法。"

#: ../../library/decimal.rst:892
msgid "Logical operands"
msgstr "逻辑操作数"

#: ../../library/decimal.rst:894
msgid ""
"The :meth:`logical_and`, :meth:`logical_invert`, :meth:`logical_or`, and "
":meth:`logical_xor` methods expect their arguments to be *logical operands*."
"  A *logical operand* is a :class:`Decimal` instance whose exponent and sign"
" are both zero, and whose digits are all either :const:`0` or :const:`1`."
msgstr ""
":meth:`logical_and`, :meth:`logical_invert`, :meth:`logical_or` 和 "
":meth:`logical_xor` 方法期望其参数为 *逻辑操作数*。 *逻辑操作数* 是指数位与符号位均为零的 :class:`Decimal` "
"实例，并且其数字位均为 :const:`0` 或 :const:`1`。"

#: ../../library/decimal.rst:906
msgid "Context objects"
msgstr "Context 对象"

#: ../../library/decimal.rst:908
msgid ""
"Contexts are environments for arithmetic operations.  They govern precision,"
" set rules for rounding, determine which signals are treated as exceptions, "
"and limit the range for exponents."
msgstr "上下文是算术运算所在的环境。 它们管理精度、设置舍入规则、确定将哪些信号视为异常，并限制指数的范围。"

#: ../../library/decimal.rst:912
msgid ""
"Each thread has its own current context which is accessed or changed using "
"the :func:`getcontext` and :func:`setcontext` functions:"
msgstr "每个线程都有自己的当前上下文，可使用 :func:`getcontext` 和 :func:`setcontext` 函数来读取或修改："

#: ../../library/decimal.rst:918
msgid "Return the current context for the active thread."
msgstr "返回活动线程的当前上下文。"

#: ../../library/decimal.rst:923
msgid "Set the current context for the active thread to *c*."
msgstr "将活动线程的当前上下文设为 *c*。"

#: ../../library/decimal.rst:925
msgid ""
"You can also use the :keyword:`with` statement and the :func:`localcontext` "
"function to temporarily change the active context."
msgstr "你也可以使用 :keyword:`with` 语句和 :func:`localcontext` 函数来临时改变活动上下文。"

#: ../../library/decimal.rst:930
msgid ""
"Return a context manager that will set the current context for the active "
"thread to a copy of *ctx* on entry to the with-statement and restore the "
"previous context when exiting the with-statement. If no context is "
"specified, a copy of the current context is used."
msgstr ""
"返回一个上下文管理器，它将在进入 with 语句时将活动线程的当前上下文设为 *ctx* 的一个副本并在退出 with 语句时恢复之前的上下文。 "
"如果未指定上下文，则会使用当前上下文的一个副本。"

#: ../../library/decimal.rst:935
msgid ""
"For example, the following code sets the current decimal precision to 42 "
"places, performs a calculation, and then automatically restores the previous"
" context::"
msgstr "例如，以下代码会将当前 decimal 精度设为 42 位，执行一个运算，然后自动恢复之前的上下文::"

#: ../../library/decimal.rst:945
msgid ""
"New contexts can also be created using the :class:`Context` constructor "
"described below. In addition, the module provides three pre-made contexts:"
msgstr "新的上下文也可使用下述的 :class:`Context` 构造器来创建。 此外，模块还提供了三种预设的上下文:"

#: ../../library/decimal.rst:951
msgid ""
"This is a standard context defined by the General Decimal Arithmetic "
"Specification.  Precision is set to nine.  Rounding is set to "
":const:`ROUND_HALF_UP`.  All flags are cleared.  All traps are enabled "
"(treated as exceptions) except :const:`Inexact`, :const:`Rounded`, and "
":const:`Subnormal`."
msgstr ""
"这是由通用十进制算术规范描述所定义的标准上下文。 精度设为九。 舍入设为 :const:`ROUND_HALF_UP`。 清除所有旗标。 "
"启用所有陷阱（视为异常），但 :const:`Inexact`, :const:`Rounded` 和 :const:`Subnormal` 除外。"

#: ../../library/decimal.rst:957
msgid ""
"Because many of the traps are enabled, this context is useful for debugging."
msgstr "由于启用了许多陷阱，此上下文适用于进行调试。"

#: ../../library/decimal.rst:962
msgid ""
"This is a standard context defined by the General Decimal Arithmetic "
"Specification.  Precision is set to nine.  Rounding is set to "
":const:`ROUND_HALF_EVEN`.  All flags are cleared.  No traps are enabled (so "
"that exceptions are not raised during computations)."
msgstr ""
"这是由通用十进制算术规范描述所定义的标准上下文。 精度设为九。 舍入设为 :const:`ROUND_HALF_EVEN`。 清除所有旗标。 "
"不启用任何陷阱（因此在计算期间不会引发异常）。"

#: ../../library/decimal.rst:967
msgid ""
"Because the traps are disabled, this context is useful for applications that"
" prefer to have result value of :const:`NaN` or :const:`Infinity` instead of"
" raising exceptions.  This allows an application to complete a run in the "
"presence of conditions that would otherwise halt the program."
msgstr ""
"由于禁用了陷阱，此上下文适用于希望结果值为 :const:`NaN` 或 :const:`Infinity` 而不是引发异常的应用。 "
"这允许应用在出现当其他情况下会中止程序的条件时仍能完成运行。"

#: ../../library/decimal.rst:975
msgid ""
"This context is used by the :class:`Context` constructor as a prototype for "
"new contexts.  Changing a field (such a precision) has the effect of "
"changing the default for new contexts created by the :class:`Context` "
"constructor."
msgstr ""
"此上下文被 :class:`Context` 构造器用作新上下文的原型。 改变一个字段（例如精度）的效果将是改变 :class:`Context` "
"构造器所创建的新上下文的默认值。"

#: ../../library/decimal.rst:979
msgid ""
"This context is most useful in multi-threaded environments.  Changing one of"
" the fields before threads are started has the effect of setting system-wide"
" defaults.  Changing the fields after threads have started is not "
"recommended as it would require thread synchronization to prevent race "
"conditions."
msgstr ""
"此上下文最适用于多线程环境。 在线程开始前改变一个字段具有设置全系统默认值的效果。 不推荐在线程开始后改变字段，因为这会要求线程同步避免竞争条件。"

#: ../../library/decimal.rst:984
msgid ""
"In single threaded environments, it is preferable to not use this context at"
" all.  Instead, simply create contexts explicitly as described below."
msgstr "在单线程环境中，最好完全不使用此上下文。 而是简单地电显式创建上下文，具体如下所述。"

#: ../../library/decimal.rst:987
msgid ""
"The default values are :attr:`prec`\\ =\\ :const:`28`, :attr:`rounding`\\ "
"=\\ :const:`ROUND_HALF_EVEN`, and enabled traps for :class:`Overflow`, "
":class:`InvalidOperation`, and :class:`DivisionByZero`."
msgstr ""
"默认值为 :attr:`prec`\\ =\\ :const:`28`, :attr:`rounding`\\ =\\ "
":const:`ROUND_HALF_EVEN`，并为 :class:`Overflow`, :class:`InvalidOperation` 和 "
":class:`DivisionByZero` 启用陷阱。"

#: ../../library/decimal.rst:992
msgid ""
"In addition to the three supplied contexts, new contexts can be created with"
" the :class:`Context` constructor."
msgstr "在已提供的三种上下文之外，还可以使用 :class:`Context` 构造器创建新的上下文。"

#: ../../library/decimal.rst:998
msgid ""
"Creates a new context.  If a field is not specified or is :const:`None`, the"
" default values are copied from the :const:`DefaultContext`.  If the *flags*"
" field is not specified or is :const:`None`, all flags are cleared."
msgstr ""
"创建一个新上下文。 如果某个字段未指定或为 :const:`None`，则从 :const:`DefaultContext` 拷贝默认值。 如果 "
"*flags* 字段未指定或为 :const:`None`，则清空所有旗标。"

#: ../../library/decimal.rst:1002
msgid ""
"*prec* is an integer in the range [:const:`1`, :const:`MAX_PREC`] that sets "
"the precision for arithmetic operations in the context."
msgstr "*prec* 为一个 [:const:`1`, :const:`MAX_PREC`] 范围内的整数，用于设置该上下文中算术运算的精度。"

#: ../../library/decimal.rst:1005
msgid ""
"The *rounding* option is one of the constants listed in the section "
"`Rounding Modes`_."
msgstr "*rounding* 选项应为 `Rounding Modes`_ 小节中列出的常量之一。"

#: ../../library/decimal.rst:1008
msgid ""
"The *traps* and *flags* fields list any signals to be set. Generally, new "
"contexts should only set traps and leave the flags clear."
msgstr "*traps* 和 *flags* 字段列出要设置的任何信号。 通常，新上下文应当只设置 traps 而让 flags 为空。"

#: ../../library/decimal.rst:1011
msgid ""
"The *Emin* and *Emax* fields are integers specifying the outer limits "
"allowable for exponents. *Emin* must be in the range [:const:`MIN_EMIN`, "
":const:`0`], *Emax* in the range [:const:`0`, :const:`MAX_EMAX`]."
msgstr ""
"*Emin* 和 *Emax* 字段给定指数所允许的外部上限。 *Emin* 必须在 [:const:`MIN_EMIN`, :const:`0`] "
"范围内，*Emax* 在 [:const:`0`, :const:`MAX_EMAX`] 范围内。"

#: ../../library/decimal.rst:1015
msgid ""
"The *capitals* field is either :const:`0` or :const:`1` (the default). If "
"set to :const:`1`, exponents are printed with a capital :const:`E`; "
"otherwise, a lowercase :const:`e` is used: :const:`Decimal('6.02e+23')`."
msgstr ""
"*capitals* 字段为 :const:`0` 或 :const:`1` (默认值)。 如果设为 :const:`1`，指数将附带打印大写的 "
":const:`E`；其他情况则将使用小写的 :const:`e`: :const:`Decimal('6.02e+23')`。"

#: ../../library/decimal.rst:1019
msgid ""
"The *clamp* field is either :const:`0` (the default) or :const:`1`. If set "
"to :const:`1`, the exponent ``e`` of a :class:`Decimal` instance "
"representable in this context is strictly limited to the range ``Emin - prec"
" + 1 <= e <= Emax - prec + 1``.  If *clamp* is :const:`0` then a weaker "
"condition holds: the adjusted exponent of the :class:`Decimal` instance is "
"at most ``Emax``.  When *clamp* is :const:`1`, a large normal number will, "
"where possible, have its exponent reduced and a corresponding number of "
"zeros added to its coefficient, in order to fit the exponent constraints; "
"this preserves the value of the number but loses information about "
"significant trailing zeros.  For example::"
msgstr ""
"*clamp* 字段为 :const:`0` (默认值) 或 :const:`1`。 如果设为 :const:`1`，则 "
":class:`Decimal` 实例的指数 ``e`` 的表示范围在此上下文中将严格限制为 ``Emin - prec + 1 <= e <= "
"Emax - prec + 1``。 如果 *clamp* 为 :const:`0` 则将适用较弱的条件: :class:`Decimal` "
"实例调整后的指数最大值为 ``Emax``。 当 *clamp* 为 :const:`1` "
"时，一个较大的普通数值将在可能的情况下减小其指数并为其系统添加相应数量的零，以便符合指数值限制；这可以保持数字值但会丢失有效末尾零的信息。 例如::"

#: ../../library/decimal.rst:1034
msgid ""
"A *clamp* value of :const:`1` allows compatibility with the fixed-width "
"decimal interchange formats specified in IEEE 754."
msgstr "*clamp* 值为 :const:`1` 时即允许与在 IEEE 754 中描述的固定宽度十进制交换格式相兼容。"

#: ../../library/decimal.rst:1037
msgid ""
"The :class:`Context` class defines several general purpose methods as well "
"as a large number of methods for doing arithmetic directly in a given "
"context. In addition, for each of the :class:`Decimal` methods described "
"above (with the exception of the :meth:`adjusted` and :meth:`as_tuple` "
"methods) there is a corresponding :class:`Context` method.  For example, for"
" a :class:`Context` instance ``C`` and :class:`Decimal` instance ``x``, "
"``C.exp(x)`` is equivalent to ``x.exp(context=C)``.  Each :class:`Context` "
"method accepts a Python integer (an instance of :class:`int`) anywhere that "
"a Decimal instance is accepted."
msgstr ""
":class:`Context` 类定义了几种通用方法以及大量直接在给定上下文中进行算术运算的方法。 此外，对于上述的每种 "
":class:`Decimal` 方法（不包括 :meth:`adjusted` 和 :meth:`as_tuple` 方法）都有一个相应的 "
":class:`Context` 方法。 例如，对于一个 :class:`Context` 的实例 ``C`` 和 :class:`Decimal` "
"的实例 ``x``，``C.exp(x)`` 就等价于 ``x.exp(context=C)``。 每个 :class:`Context` "
"方法都接受一个 Python 整数（即 :class:`int` 的实例）在任何接受 Decimal 的实例的地方使用。"

#: ../../library/decimal.rst:1050
msgid "Resets all of the flags to :const:`0`."
msgstr "将所有旗标重置为 :const:`0`。"

#: ../../library/decimal.rst:1054
msgid "Resets all of the traps to :const:`0`."
msgstr "将所有陷阱重置为零 :const:`0`。"

#: ../../library/decimal.rst:1060
msgid "Return a duplicate of the context."
msgstr "返回上下文的一个副本。"

#: ../../library/decimal.rst:1064
msgid "Return a copy of the Decimal instance num."
msgstr "返回 Decimal 实例 num 的一个副本。"

#: ../../library/decimal.rst:1068
msgid ""
"Creates a new Decimal instance from *num* but using *self* as context. "
"Unlike the :class:`Decimal` constructor, the context precision, rounding "
"method, flags, and traps are applied to the conversion."
msgstr ""
"基于 *num* 创建一个新 Decimal 实例但使用 *self* 作为上下文。 与 :class:`Decimal` "
"构造器不同，该上下文的精度、舍入方法、旗标和陷阱会被应用于转换过程。"

#: ../../library/decimal.rst:1072
msgid ""
"This is useful because constants are often given to a greater precision than"
" is needed by the application.  Another benefit is that rounding immediately"
" eliminates unintended effects from digits beyond the current precision. In "
"the following example, using unrounded inputs means that adding zero to a "
"sum can change the result:"
msgstr ""
"此方法很有用处，因为常量往往被给予高于应用所需的精度。 另一个好处在于立即执行舍入可以消除超出当前精度的数位所导致的意外效果。 "
"在下面的示例中，使用未舍入的输入意味着在总和中添加零会改变结果："

#: ../../library/decimal.rst:1086
msgid ""
"This method implements the to-number operation of the IBM specification. If "
"the argument is a string, no leading or trailing whitespace or underscores "
"are permitted."
msgstr "此方法实现了 IBM 规格描述中的转换为数字操作。 如果参数为字符串，则不允许有开头或末尾的空格或下划线。"

#: ../../library/decimal.rst:1092
msgid ""
"Creates a new Decimal instance from a float *f* but rounding using *self* as"
" the context.  Unlike the :meth:`Decimal.from_float` class method, the "
"context precision, rounding method, flags, and traps are applied to the "
"conversion."
msgstr ""
"基于浮点数 *f* 创建一个新的 Decimal 实例，但会使用 *self* 作为上下文来执行舍入。 与 "
":meth:`Decimal.from_float` 类方法不同，上下文的精度、舍入方法、旗标和陷阱会应用到转换中。"

#: ../../library/decimal.rst:1112
msgid ""
"Returns a value equal to ``Emin - prec + 1`` which is the minimum exponent "
"value for subnormal results.  When underflow occurs, the exponent is set to "
":const:`Etiny`."
msgstr ""
"返回一个等于 ``Emin - prec + 1`` 的值即次正规化结果中的最小指数值。 当发生向下溢出时，指数会设为 :const:`Etiny`。"

#: ../../library/decimal.rst:1118
msgid "Returns a value equal to ``Emax - prec + 1``."
msgstr "返回一个等于 ``Emax - prec + 1`` 的值。"

#: ../../library/decimal.rst:1120
msgid ""
"The usual approach to working with decimals is to create :class:`Decimal` "
"instances and then apply arithmetic operations which take place within the "
"current context for the active thread.  An alternative approach is to use "
"context methods for calculating within a specific context.  The methods are "
"similar to those for the :class:`Decimal` class and are only briefly "
"recounted here."
msgstr ""
"使用 decimal 的通常方式是创建 :class:`Decimal` 实例然后对其应用算术运算,这些运算发生在活动线程的当前上下文中。 "
"一种替代方式则是使用上下文的方法在特定上下文中进行计算。 这些方法类似于 :class:`Decimal` 类的方法，在此仅简单地重新列出。"

#: ../../library/decimal.rst:1130
msgid "Returns the absolute value of *x*."
msgstr "返回 *x* 的绝对值。"

#: ../../library/decimal.rst:1135
msgid "Return the sum of *x* and *y*."
msgstr "返回 *x* 与 *y* 的和。"

#: ../../library/decimal.rst:1140
msgid "Returns the same Decimal object *x*."
msgstr "返回相同的 Decimal 对象 *x*。"

#: ../../library/decimal.rst:1145
msgid "Compares *x* and *y* numerically."
msgstr "对 *x* 与 *y* 进行数值比较。"

#: ../../library/decimal.rst:1150
msgid "Compares the values of the two operands numerically."
msgstr "对两个操作数进行数值比较。"

#: ../../library/decimal.rst:1155
msgid "Compares two operands using their abstract representation."
msgstr "对两个操作数使用其抽象表示进行比较。"

#: ../../library/decimal.rst:1160
msgid ""
"Compares two operands using their abstract representation, ignoring sign."
msgstr "对两个操作数使用其抽象表示进行比较，忽略符号。"

#: ../../library/decimal.rst:1165
msgid "Returns a copy of *x* with the sign set to 0."
msgstr "返回 *x* 的副本，符号设为 0。"

#: ../../library/decimal.rst:1170
msgid "Returns a copy of *x* with the sign inverted."
msgstr "返回 *x* 的副本，符号取反。"

#: ../../library/decimal.rst:1175
msgid "Copies the sign from *y* to *x*."
msgstr "从 *y* 拷贝符号至 *x*。"

#: ../../library/decimal.rst:1180
msgid "Return *x* divided by *y*."
msgstr "返回 *x* 除以 *y* 的结果。"

#: ../../library/decimal.rst:1185
msgid "Return *x* divided by *y*, truncated to an integer."
msgstr "返回 *x* 除以 *y* 的结果，截短为整数。"

#: ../../library/decimal.rst:1190
msgid "Divides two numbers and returns the integer part of the result."
msgstr "两个数字相除并返回结果的整数部分。"

#: ../../library/decimal.rst:1195
msgid "Returns `e ** x`."
msgstr "返回 `e ** x`。"

#: ../../library/decimal.rst:1200
msgid "Returns *x* multiplied by *y*, plus *z*."
msgstr "返回 *x* 乘以 *y* 再加 *z* 的结果。"

#: ../../library/decimal.rst:1205
msgid "Returns ``True`` if *x* is canonical; otherwise returns ``False``."
msgstr "如果 *x* 是规范的则返回 ``True``；否则返回 ``False``。"

#: ../../library/decimal.rst:1210
msgid "Returns ``True`` if *x* is finite; otherwise returns ``False``."
msgstr "如果 *x* 为有限数则返回``True``；否则返回 ``False``。"

#: ../../library/decimal.rst:1215
msgid "Returns ``True`` if *x* is infinite; otherwise returns ``False``."
msgstr "如果 *x* 是无限的则返回 ``True``；否则返回 ``False``。"

#: ../../library/decimal.rst:1220
msgid ""
"Returns ``True`` if *x* is a qNaN or sNaN; otherwise returns ``False``."
msgstr "如果 *x* 是 qNaN 或 sNaN 则返回 ``True``；否则返回 ``False``。"

#: ../../library/decimal.rst:1225
msgid ""
"Returns ``True`` if *x* is a normal number; otherwise returns ``False``."
msgstr "如果 *x* 是正规数则返回 ``True``；否则返回 ``False``。"

#: ../../library/decimal.rst:1230
msgid "Returns ``True`` if *x* is a quiet NaN; otherwise returns ``False``."
msgstr "如果 *x* 是静默 NaN 则返回 ``True``；否则返回 ``False``。"

#: ../../library/decimal.rst:1235
msgid "Returns ``True`` if *x* is negative; otherwise returns ``False``."
msgstr "*x* 是负数则返回 ``True``；否则返回 ``False``。"

#: ../../library/decimal.rst:1240
msgid ""
"Returns ``True`` if *x* is a signaling NaN; otherwise returns ``False``."
msgstr "如果 *x* 是显式 NaN 则返回 ``True``；否则返回 ``False``。"

#: ../../library/decimal.rst:1245
msgid "Returns ``True`` if *x* is subnormal; otherwise returns ``False``."
msgstr "如果 *x* 是次标准数则返回 ``True``；否则返回 ``False``。"

#: ../../library/decimal.rst:1250
msgid "Returns ``True`` if *x* is a zero; otherwise returns ``False``."
msgstr "如果 *x* 为零则返回 ``True``；否则返回 ``False``。"

#: ../../library/decimal.rst:1255
msgid "Returns the natural (base e) logarithm of *x*."
msgstr "返回 *x* 的自然对数（以 e 为底）。"

#: ../../library/decimal.rst:1260
msgid "Returns the base 10 logarithm of *x*."
msgstr "返回 *x* 的以 10 为底的对数。"

#: ../../library/decimal.rst:1265
msgid "Returns the exponent of the magnitude of the operand's MSD."
msgstr "返回操作数的 MSD 等级的指数。"

#: ../../library/decimal.rst:1270
msgid "Applies the logical operation *and* between each operand's digits."
msgstr "在操作数的每个数码间应用逻辑运算 *and*。"

#: ../../library/decimal.rst:1275
msgid "Invert all the digits in *x*."
msgstr "反转 *x* 中的所有数位。"

#: ../../library/decimal.rst:1280
msgid "Applies the logical operation *or* between each operand's digits."
msgstr "在操作数的每个数位间应用逻辑运算 *or*。"

#: ../../library/decimal.rst:1285
msgid "Applies the logical operation *xor* between each operand's digits."
msgstr "在操作数的每个数位间应用逻辑运算 *xor*。"

#: ../../library/decimal.rst:1290
msgid "Compares two values numerically and returns the maximum."
msgstr "对两个值执行数字比较并返回其中的最大值。"

#: ../../library/decimal.rst:1295 ../../library/decimal.rst:1305
msgid "Compares the values numerically with their sign ignored."
msgstr "对两个值执行忽略正负号的数字比较。"

#: ../../library/decimal.rst:1300
msgid "Compares two values numerically and returns the minimum."
msgstr "对两个值执行数字比较并返回其中的最小值。"

#: ../../library/decimal.rst:1310
msgid "Minus corresponds to the unary prefix minus operator in Python."
msgstr "对应于 Python 中的单目取负运算符执行取负操作。"

#: ../../library/decimal.rst:1315
msgid "Return the product of *x* and *y*."
msgstr "返回 *x* 和 *y* 的积。"

#: ../../library/decimal.rst:1320
msgid "Returns the largest representable number smaller than *x*."
msgstr "返回小于 *x* 的最大数字表示形式。"

#: ../../library/decimal.rst:1325
msgid "Returns the smallest representable number larger than *x*."
msgstr "返回大于 *x* 的最小数字表示形式。"

#: ../../library/decimal.rst:1330
msgid "Returns the number closest to *x*, in direction towards *y*."
msgstr "返回 *x* 趋向于 *y* 的最接近的数字。"

#: ../../library/decimal.rst:1335
msgid "Reduces *x* to its simplest form."
msgstr "将 *x* 改写为最简形式。"

#: ../../library/decimal.rst:1340
msgid "Returns an indication of the class of *x*."
msgstr "返回 *x* 的类的表示。"

#: ../../library/decimal.rst:1345
msgid ""
"Plus corresponds to the unary prefix plus operator in Python.  This "
"operation applies the context precision and rounding, so it is *not* an "
"identity operation."
msgstr "对应于 Python 中的单目前缀取正运算符执行取正操作。 此操作将应用上下文精度和舍入，因此它 *不是* 标识运算。"

#: ../../library/decimal.rst:1352
msgid ""
"Return ``x`` to the power of ``y``, reduced modulo ``modulo`` if given."
msgstr "返回 ``x`` 的 ``y`` 次方，如果给出了模数 ``modulo`` 则取其余数。"

#: ../../library/decimal.rst:1354
msgid ""
"With two arguments, compute ``x**y``.  If ``x`` is negative then ``y`` must "
"be integral.  The result will be inexact unless ``y`` is integral and the "
"result is finite and can be expressed exactly in 'precision' digits. The "
"rounding mode of the context is used. Results are always correctly-rounded "
"in the Python version."
msgstr ""
"如为两个参数则计算 ``x**y``。 如果 ``x`` 为负值则 ``y`` 必须为整数。 除非 ``y`` 为整数且结果为有限值并可在 "
"'precision' 位内精确表示否则结果将是不精确的。 上下文的舍入模式将被使用。 结果在 Python 版中总是会被正确地舍入。"

#: ../../library/decimal.rst:1360
msgid ""
"The C module computes :meth:`power` in terms of the correctly-rounded "
":meth:`exp` and :meth:`ln` functions. The result is well-defined but only "
"\"almost always correctly-rounded\"."
msgstr ""
"C 模块计算 :meth:`power` 时会使用已正确舍入的 :meth:`exp` 和 :meth:`ln` 函数。 "
"结果是经过良好定义的，但仅限于“几乎总是正确地舍入”。"

#: ../../library/decimal.rst:1365
msgid ""
"With three arguments, compute ``(x**y) % modulo``.  For the three argument "
"form, the following restrictions on the arguments hold:"
msgstr "带有三个参数时，计算 ``(x**y) % modulo``。 对于三个参数的形式，参数将会应用以下限制："

#: ../../library/decimal.rst:1368
msgid "all three arguments must be integral"
msgstr "三个参数必须都是整数"

#: ../../library/decimal.rst:1369
msgid "``y`` must be nonnegative"
msgstr "``y`` 必须是非负数"

#: ../../library/decimal.rst:1370
msgid "at least one of ``x`` or ``y`` must be nonzero"
msgstr "``x`` 或 ``y`` 至少有一个不为零"

#: ../../library/decimal.rst:1371
msgid "``modulo`` must be nonzero and have at most 'precision' digits"
msgstr "``modulo`` 必须不为零且至多有 'precision' 位"

#: ../../library/decimal.rst:1373
msgid ""
"The value resulting from ``Context.power(x, y, modulo)`` is equal to the "
"value that would be obtained by computing ``(x**y) % modulo`` with unbounded"
" precision, but is computed more efficiently.  The exponent of the result is"
" zero, regardless of the exponents of ``x``, ``y`` and ``modulo``.  The "
"result is always exact."
msgstr ""
"来自 ``Context.power(x, y, modulo)`` 的结果值等于使用无限精度计算 ``(x**y) % modulo`` "
"所得到的值，但其计算过程更高效。 结果的指数为零，无论 ``x``, ``y`` 和 ``modulo`` 的指数是多少。 结果值总是完全精确的。"

#: ../../library/decimal.rst:1383
msgid "Returns a value equal to *x* (rounded), having the exponent of *y*."
msgstr "返回的值等于 *x* (舍入后)，并且指数为 *y*。"

#: ../../library/decimal.rst:1388
msgid "Just returns 10, as this is Decimal, :)"
msgstr "恰好返回 10，因为这是 Decimal 对象 :)"

#: ../../library/decimal.rst:1393
msgid "Returns the remainder from integer division."
msgstr "返回整除所得到的余数。"

#: ../../library/decimal.rst:1395
msgid ""
"The sign of the result, if non-zero, is the same as that of the original "
"dividend."
msgstr "结果的符号，如果不为零，则与原始除数的符号相同。"

#: ../../library/decimal.rst:1401
msgid ""
"Returns ``x - y * n``, where *n* is the integer nearest the exact value of "
"``x / y`` (if the result is 0 then its sign will be the sign of *x*)."
msgstr ""
"返回 ``x - y * n``，其中 *n* 为最接近 ``x / y`` 实际值的整数（如结果为 0 则其符号将与 *x* 的符号相同）。"

#: ../../library/decimal.rst:1407
msgid "Returns a rotated copy of *x*, *y* times."
msgstr "返回 *x* 翻转 *y* 次的副本。"

#: ../../library/decimal.rst:1412
msgid "Returns ``True`` if the two operands have the same exponent."
msgstr "如果两个操作数具有相同的指数则返回 ``True``。"

#: ../../library/decimal.rst:1417
msgid "Returns the first operand after adding the second value its exp."
msgstr "返回第一个操作数对第二个值添加其指数后的结果。"

#: ../../library/decimal.rst:1422
msgid "Returns a shifted copy of *x*, *y* times."
msgstr "返回 *x* 变换 *y* 次的副本。"

#: ../../library/decimal.rst:1427
msgid "Square root of a non-negative number to context precision."
msgstr "非负数基于上下文精度的平方根。"

#: ../../library/decimal.rst:1432
msgid "Return the difference between *x* and *y*."
msgstr "返回 *x* 和 *y* 的差。"

#: ../../library/decimal.rst:1446
msgid "Rounds to an integer."
msgstr "舍入到一个整数。"

#: ../../library/decimal.rst:1451
msgid "Converts a number to a string using scientific notation."
msgstr "使用科学计数法将一个数字转换为字符串。"

#: ../../library/decimal.rst:1458
msgid "Constants"
msgstr "常量"

#: ../../library/decimal.rst:1460
msgid ""
"The constants in this section are only relevant for the C module. They are "
"also included in the pure Python version for compatibility."
msgstr "本节中的常量仅与 C 模块相关。 它们也被包含在纯 Python 版本以保持兼容性。"

#: ../../library/decimal.rst:1464
msgid "32-bit"
msgstr "32位"

#: ../../library/decimal.rst:1464
msgid "64-bit"
msgstr "64位"

#: ../../library/decimal.rst:1466 ../../library/decimal.rst:1468
msgid ":const:`425000000`"
msgstr ":const:`425000000`"

#: ../../library/decimal.rst:1466 ../../library/decimal.rst:1468
msgid ":const:`999999999999999999`"
msgstr ":const:`999999999999999999`"

#: ../../library/decimal.rst:1470
msgid ":const:`-425000000`"
msgstr ":const:`-425000000`"

#: ../../library/decimal.rst:1470
msgid ":const:`-999999999999999999`"
msgstr ":const:`-999999999999999999`"

#: ../../library/decimal.rst:1472
msgid ":const:`-849999999`"
msgstr ":const:`-849999999`"

#: ../../library/decimal.rst:1472
msgid ":const:`-1999999999999999997`"
msgstr ":const:`-1999999999999999997`"

#: ../../library/decimal.rst:1478
msgid ""
"The value is ``True``.  Deprecated, because Python now always has threads."
msgstr "该值为 ``True``。 已弃用，因为 Python 现在总是启用线程。"

#: ../../library/decimal.rst:1484
msgid ""
"The default value is ``True``. If Python is compiled ``--without-decimal-"
"contextvar``, the C version uses a thread-local rather than a coroutine-"
"local context and the value is ``False``.  This is slightly faster in some "
"nested context scenarios."
msgstr ""
"默认值为 ``True``。 如果 Python 的编译带有 ``--without-decimal-contextvar`` 选项，则 C "
"版本会使用线程局部而不是协程局部上下文并且该值为 ``False``。 这在某些嵌套上下文场景中将稍快一些。"

#: ../../library/decimal.rst:1488
msgid "backported to 3.7 and 3.8"
msgstr "向下移植到 3.7 和 3.8"

#: ../../library/decimal.rst:1492
msgid "Rounding modes"
msgstr "舍入模式"

#: ../../library/decimal.rst:1496
msgid "Round towards :const:`Infinity`."
msgstr "舍入方向 :const:`Infinity`。"

#: ../../library/decimal.rst:1500
msgid "Round towards zero."
msgstr "舍入方向为零。"

#: ../../library/decimal.rst:1504
msgid "Round towards :const:`-Infinity`."
msgstr "舍入方向为 :const:`-Infinity`。"

#: ../../library/decimal.rst:1508
msgid "Round to nearest with ties going towards zero."
msgstr "舍入到最接近的数，同样接近则舍入方向为零。"

#: ../../library/decimal.rst:1512
msgid "Round to nearest with ties going to nearest even integer."
msgstr "舍入到最接近的数，同样接近则舍入到最接近的偶数。"

#: ../../library/decimal.rst:1516
msgid "Round to nearest with ties going away from zero."
msgstr "舍入到最接近的数，同样接近则舍入到零的反方向。"

#: ../../library/decimal.rst:1520
msgid "Round away from zero."
msgstr "舍入到零的反方向。"

#: ../../library/decimal.rst:1524
msgid ""
"Round away from zero if last digit after rounding towards zero would have "
"been 0 or 5; otherwise round towards zero."
msgstr "如果最后一位朝零的方向舍入后为 0 或 5 则舍入到零的反方向；否则舍入方向为零。"

#: ../../library/decimal.rst:1531
msgid "Signals"
msgstr "信号"

#: ../../library/decimal.rst:1533
msgid ""
"Signals represent conditions that arise during computation. Each corresponds"
" to one context flag and one context trap enabler."
msgstr "信号代表在计算期间引发的条件。 每个信号对应于一个上下文旗标和一个上下文陷阱启用器。"

#: ../../library/decimal.rst:1536
msgid ""
"The context flag is set whenever the condition is encountered. After the "
"computation, flags may be checked for informational purposes (for instance, "
"to determine whether a computation was exact). After checking the flags, be "
"sure to clear all flags before starting the next computation."
msgstr ""
"上下文旗标将在遇到特定条件时被设定。 在完成计算之后，将为了获得信息而检测旗标（例如确定计算是否精确）。 "
"在检测旗标后，请确保在开始下一次计算之前清除所有旗标。"

#: ../../library/decimal.rst:1541
msgid ""
"If the context's trap enabler is set for the signal, then the condition "
"causes a Python exception to be raised.  For example, if the "
":class:`DivisionByZero` trap is set, then a :exc:`DivisionByZero` exception "
"is raised upon encountering the condition."
msgstr ""
"如果为信号设定了上下文的陷阱启用器，则条件会导致特定的 Python 异常被引发。 举例来说，如果设定了 :class:`DivisionByZero`"
" 陷阱，则当遇到此条件时就将引发 :exc:`DivisionByZero` 异常。"

#: ../../library/decimal.rst:1549
msgid "Altered an exponent to fit representation constraints."
msgstr "修改一个指数以符合表示限制。"

#: ../../library/decimal.rst:1551
msgid ""
"Typically, clamping occurs when an exponent falls outside the context's "
":attr:`Emin` and :attr:`Emax` limits.  If possible, the exponent is reduced "
"to fit by adding zeros to the coefficient."
msgstr ""
"通常，限位将在一个指数超出上下文的 :attr:`Emin` 和 :attr:`Emax` 限制时发生。 "
"在可能的情况下，会通过给系数添加零来将指数缩减至符合限制。"

#: ../../library/decimal.rst:1558
msgid "Base class for other signals and a subclass of :exc:`ArithmeticError`."
msgstr "其他信号的基类，并且也是 :exc:`ArithmeticError` 的一个子类。"

#: ../../library/decimal.rst:1563
msgid "Signals the division of a non-infinite number by zero."
msgstr "非无限数被零除的信号。"

#: ../../library/decimal.rst:1565
msgid ""
"Can occur with division, modulo division, or when raising a number to a "
"negative power.  If this signal is not trapped, returns :const:`Infinity` or"
" :const:`-Infinity` with the sign determined by the inputs to the "
"calculation."
msgstr ""
"可在除法、取余队法或对一个数求负数次幂时发生。 如果此信号未被陷阱捕获，则返回 :const:`Infinity` 或 "
":const:`-Infinity` 并且由对计算的输入来确定正负符号。"

#: ../../library/decimal.rst:1572
msgid "Indicates that rounding occurred and the result is not exact."
msgstr "表明发生了舍入且结果是不精确的。"

#: ../../library/decimal.rst:1574
msgid ""
"Signals when non-zero digits were discarded during rounding. The rounded "
"result is returned.  The signal flag or trap is used to detect when results "
"are inexact."
msgstr "有非零数位在舍入期间被丢弃的信号。 舍入结果将被返回。 此信号旗标或陷阱被用于检测结果不精确的情况。"

#: ../../library/decimal.rst:1581
msgid "An invalid operation was performed."
msgstr "执行了一个无效的操作。"

#: ../../library/decimal.rst:1583
msgid ""
"Indicates that an operation was requested that does not make sense. If not "
"trapped, returns :const:`NaN`.  Possible causes include::"
msgstr "表明请求了一个无意义的操作。 如未被陷阱捕获则返回 :const:`NaN`。 可能的原因包括::"

#: ../../library/decimal.rst:1599
msgid "Numerical overflow."
msgstr "数值的溢出。"

#: ../../library/decimal.rst:1601
msgid ""
"Indicates the exponent is larger than :attr:`Emax` after rounding has "
"occurred.  If not trapped, the result depends on the rounding mode, either "
"pulling inward to the largest representable finite number or rounding "
"outward to :const:`Infinity`.  In either case, :class:`Inexact` and "
":class:`Rounded` are also signaled."
msgstr ""
"表明在发生舍入之后的指数大于 :attr:`Emax`。 如果未被陷阱捕获，则结果将取决于舍入模式，或者向下舍入为最大的可表示有限数，或者向上舍入为 "
":const:`Infinity`。 无论哪种情况，都将引发 :class:`Inexact` 和 :class:`Rounded` 信号。"

#: ../../library/decimal.rst:1610
msgid "Rounding occurred though possibly no information was lost."
msgstr "发生了舍入，但或许并没有信息丢失。"

#: ../../library/decimal.rst:1612
msgid ""
"Signaled whenever rounding discards digits; even if those digits are zero "
"(such as rounding :const:`5.00` to :const:`5.0`).  If not trapped, returns "
"the result unchanged.  This signal is used to detect loss of significant "
"digits."
msgstr ""
"一旦舍入丢弃了数位就会发出此信号；即使被丢弃的数位是零 (例如将 :const:`5.00` 舍入为 :const:`5.0`)。 "
"如果未被陷阱捕获，则不经修改地返回结果。 此信号用于检测有效位数的丢弃。"

#: ../../library/decimal.rst:1620
msgid "Exponent was lower than :attr:`Emin` prior to rounding."
msgstr "在舍入之前指数低于 :attr:`Emin`。"

#: ../../library/decimal.rst:1622
msgid ""
"Occurs when an operation result is subnormal (the exponent is too small). If"
" not trapped, returns the result unchanged."
msgstr "当操作结果是次标准数（即指数过小）时就会发出此信号。 如果未被陷阱捕获，则不经修改过返回结果。"

#: ../../library/decimal.rst:1628
msgid "Numerical underflow with result rounded to zero."
msgstr "数字向下溢出导致结果舍入到零。"

#: ../../library/decimal.rst:1630
msgid ""
"Occurs when a subnormal result is pushed to zero by rounding. "
":class:`Inexact` and :class:`Subnormal` are also signaled."
msgstr ""
"当一个次标准数结果通过舍入转为零时就会发出此信号。 同时还将引发 :class:`Inexact` 和 :class:`Subnormal` 信号。"

#: ../../library/decimal.rst:1636
msgid "Enable stricter semantics for mixing floats and Decimals."
msgstr "为 float 和 Decimal 的混合启用更严格的语义。"

#: ../../library/decimal.rst:1638
msgid ""
"If the signal is not trapped (default), mixing floats and Decimals is "
"permitted in the :class:`~decimal.Decimal` constructor, "
":meth:`~decimal.Context.create_decimal` and all comparison operators. Both "
"conversion and comparisons are exact. Any occurrence of a mixed operation is"
" silently recorded by setting :exc:`FloatOperation` in the context flags. "
"Explicit conversions with :meth:`~decimal.Decimal.from_float` or "
":meth:`~decimal.Context.create_decimal_from_float` do not set the flag."
msgstr ""
"如果信号未被捕获（默认），则在 :class:`~decimal.Decimal` "
"构造器、:meth:`~decimal.Context.create_decimal` 和所有比较运算中允许 float 和 Decimal 的混合。 "
"转换和比较都是完全精确的。 发生的任何混合运算都将通过在上下文旗标中设置 :exc:`FloatOperation` 来静默地记录。 通过 "
":meth:`~decimal.Decimal.from_float` 或 "
":meth:`~decimal.Context.create_decimal_from_float` 进行显式转换则不会设置旗标。"

#: ../../library/decimal.rst:1646
msgid ""
"Otherwise (the signal is trapped), only equality comparisons and explicit "
"conversions are silent. All other mixed operations raise "
":exc:`FloatOperation`."
msgstr "在其他情况下（即信号被捕获），则只静默执行相等性比较和显式转换。 所有其他混合运算都将引发 :exc:`FloatOperation`。"

#: ../../library/decimal.rst:1650
msgid "The following table summarizes the hierarchy of signals::"
msgstr "以下表格总结了信号的层级结构::"

#: ../../library/decimal.rst:1671
msgid "Floating Point Notes"
msgstr "浮点数说明"

#: ../../library/decimal.rst:1675
msgid "Mitigating round-off error with increased precision"
msgstr "通过提升精度来缓解舍入误差"

#: ../../library/decimal.rst:1677
msgid ""
"The use of decimal floating point eliminates decimal representation error "
"(making it possible to represent :const:`0.1` exactly); however, some "
"operations can still incur round-off error when non-zero digits exceed the "
"fixed precision."
msgstr ""
"使用十进制浮点数可以消除十进制表示错误（即能够完全精确地表示 :const:`0.1` "
"这样的数）；然而，某些运算在非零数位超出给定的精度时仍然可能导致舍入错误。"

#: ../../library/decimal.rst:1681
msgid ""
"The effects of round-off error can be amplified by the addition or "
"subtraction of nearly offsetting quantities resulting in loss of "
"significance.  Knuth provides two instructive examples where rounded "
"floating point arithmetic with insufficient precision causes the breakdown "
"of the associative and distributive properties of addition:"
msgstr ""
"舍入错误的影响可能因接近相互抵销的加减运算被放大从而导致损失有效位。 Knuth "
"提供了两个指导性示例，其中出现了精度不足的浮点算术舍入，导致加法的交换律和分配律被打破："

#: ../../library/decimal.rst:1705
msgid ""
"The :mod:`decimal` module makes it possible to restore the identities by "
"expanding the precision sufficiently to avoid loss of significance:"
msgstr ":mod:`decimal` 模块则可以通过充分地扩展精度来避免有效位的丢失："

#: ../../library/decimal.rst:1725
msgid "Special values"
msgstr "特殊的值"

#: ../../library/decimal.rst:1727
msgid ""
"The number system for the :mod:`decimal` module provides special values "
"including :const:`NaN`, :const:`sNaN`, :const:`-Infinity`, "
":const:`Infinity`, and two zeros, :const:`+0` and :const:`-0`."
msgstr ""
":mod:`decimal` 模块的数字系统提供了一些特殊的值，包括 :const:`NaN`, :const:`sNaN`, "
":const:`-Infinity`, :const:`Infinity` 以及两种零值 :const:`+0` 和 :const:`-0`。"

#: ../../library/decimal.rst:1731
msgid ""
"Infinities can be constructed directly with:  ``Decimal('Infinity')``. Also,"
" they can arise from dividing by zero when the :exc:`DivisionByZero` signal "
"is not trapped.  Likewise, when the :exc:`Overflow` signal is not trapped, "
"infinity can result from rounding beyond the limits of the largest "
"representable number."
msgstr ""
"无穷大可以使用 ``Decimal('Infinity')`` 来构建。 它们也可以在不捕获 :exc:`DivisionByZero` "
"信号捕获时通过除以零来产生。 类似地，当不捕获 :exc:`Overflow` 信号时，也可以通过舍入到超出最大可表示数字限制的方式产生无穷大的结果。"

#: ../../library/decimal.rst:1736
msgid ""
"The infinities are signed (affine) and can be used in arithmetic operations "
"where they get treated as very large, indeterminate numbers.  For instance, "
"adding a constant to infinity gives another infinite result."
msgstr "无穷大是有符号的（仿射）并可用于算术运算，它们会被当作极其巨大的不确定数字来处理。 例如，无穷大加一个常量结果也将为无穷大。"

#: ../../library/decimal.rst:1740
msgid ""
"Some operations are indeterminate and return :const:`NaN`, or if the "
":exc:`InvalidOperation` signal is trapped, raise an exception.  For example,"
" ``0/0`` returns :const:`NaN` which means \"not a number\".  This variety of"
" :const:`NaN` is quiet and, once created, will flow through other "
"computations always resulting in another :const:`NaN`.  This behavior can be"
" useful for a series of computations that occasionally have missing inputs "
"--- it allows the calculation to proceed while flagging specific results as "
"invalid."
msgstr ""
"某些不存在有效结果的运算将会返回 :const:`NaN`，或者如果捕获了 :exc:`InvalidOperation` 信号则会引发一个异常。 "
"例如，``0/0`` 会返回 :const:`NaN` 表示结果“不是一个数字”。 这样的 :const:`NaN` "
"是静默产生的，并且在产生之后参与其它计算时总是会得到 :const:`NaN` 的结果。 这种行为对于偶而缺少输入的各类计算都很有用处 --- "
"它允许在将特定结果标记为无效的同时让计算继续运行。"

#: ../../library/decimal.rst:1748
msgid ""
"A variant is :const:`sNaN` which signals rather than remaining quiet after "
"every operation.  This is a useful return value when an invalid result needs"
" to interrupt a calculation for special handling."
msgstr ""
"另一种变体形式是 :const:`sNaN`，它在每次运算后会发出信号而不是保持静默。 "
"当对于无效结果需要中断计算进行特别处理时，这是一个很有用的返回值。"

#: ../../library/decimal.rst:1752
msgid ""
"The behavior of Python's comparison operators can be a little surprising "
"where a :const:`NaN` is involved.  A test for equality where one of the "
"operands is a quiet or signaling :const:`NaN` always returns :const:`False` "
"(even when doing ``Decimal('NaN')==Decimal('NaN')``), while a test for "
"inequality always returns :const:`True`.  An attempt to compare two Decimals"
" using any of the ``<``, ``<=``, ``>`` or ``>=`` operators will raise the "
":exc:`InvalidOperation` signal if either operand is a :const:`NaN`, and "
"return :const:`False` if this signal is not trapped.  Note that the General "
"Decimal Arithmetic specification does not specify the behavior of direct "
"comparisons; these rules for comparisons involving a :const:`NaN` were taken"
" from the IEEE 854 standard (see Table 3 in section 5.7).  To ensure strict "
"standards-compliance, use the :meth:`compare` and :meth:`compare-signal` "
"methods instead."
msgstr ""
"Python 中比较运算符的行为在涉及 :const:`NaN` 时可能会令人有点惊讶。 相等性检测在操作数中有静默型或信号型 :const:`NaN`"
" 时总是会返回 :const:`False` (即使是执行 "
"``Decimal('NaN')==Decimal('NaN')``)，而不等性检测总是会返回 :const:`True`。 当尝试使用 ``<``, "
"``<=``, ``>`` 或 ``>=`` 运算符中的任何一个来比较两个 Decimal 值时，如果运算数中有 :const:`NaN` 则将引发 "
":exc:`InvalidOperation` 信号，如果此信号未被捕获则将返回 :const:`False`。 "
"请注意通用十进制算术规范并未规定直接比较行为；这些涉及 :const:`NaN` 的比较规则来自于 IEEE 854 标准 (见第 5.7 节表 3)。"
" 要确保严格符合标准，请改用 :meth:`compare` 和 :meth:`compare-signal` 方法。"

#: ../../library/decimal.rst:1765
msgid ""
"The signed zeros can result from calculations that underflow. They keep the "
"sign that would have resulted if the calculation had been carried out to "
"greater precision.  Since their magnitude is zero, both positive and "
"negative zeros are treated as equal and their sign is informational."
msgstr ""
"有符号零值可以由向下溢出的运算产生。 它们保留符号是为了让运算结果能以更高的精度传递。 "
"由于它们的大小为零，正零和负零会被视为相等，且它们的符号具有信息。"

#: ../../library/decimal.rst:1770
msgid ""
"In addition to the two signed zeros which are distinct yet equal, there are "
"various representations of zero with differing precisions yet equivalent in "
"value.  This takes a bit of getting used to.  For an eye accustomed to "
"normalized floating point representations, it is not immediately obvious "
"that the following calculation returns a value equal to zero:"
msgstr ""
"在这两个不相同但却相等的有符号零之外，还存在几种零的不同表示形式，它们的精度不同但值也都相等。 这需要一些时间来逐渐适应。 "
"对于习惯了标准浮点表示形式的眼睛来说，以下运算返回等于零的值并不是显而易见的："

#: ../../library/decimal.rst:1785
msgid "Working with threads"
msgstr "使用线程"

#: ../../library/decimal.rst:1787
msgid ""
"The :func:`getcontext` function accesses a different :class:`Context` object"
" for each thread.  Having separate thread contexts means that threads may "
"make changes (such as ``getcontext().prec=10``) without interfering with "
"other threads."
msgstr ""
":func:`getcontext` 函数会为每个线程访问不同的 :class:`Context` 对象。 具有单独线程上下文意味着线程可以修改上下文 "
"(例如 ``getcontext().prec=10``) 而不影响其他线程。"

#: ../../library/decimal.rst:1791
msgid ""
"Likewise, the :func:`setcontext` function automatically assigns its target "
"to the current thread."
msgstr "类似的 :func:`setcontext` 会为当前上下文的目标自动赋值。"

#: ../../library/decimal.rst:1794
msgid ""
"If :func:`setcontext` has not been called before :func:`getcontext`, then "
":func:`getcontext` will automatically create a new context for use in the "
"current thread."
msgstr ""
"如果在调用 :func:`setcontext` 之前调用了 :func:`getcontext`，则 :func:`getcontext` "
"将自动创建一个新的上下文在当前线程中使用。"

#: ../../library/decimal.rst:1798
msgid ""
"The new context is copied from a prototype context called *DefaultContext*. "
"To control the defaults so that each thread will use the same values "
"throughout the application, directly modify the *DefaultContext* object. "
"This should be done *before* any threads are started so that there won't be "
"a race condition between threads calling :func:`getcontext`. For example::"
msgstr ""
"新的上下文拷贝自一个名为 *DefaultContext* 的原型上下文。 要控制默认值以便每个线程在应用运行期间都使用相同的值，可以直接修改 "
"*DefaultContext* 对象。 这应当在任何线程启动 *之前* 完成以使得调用 :func:`getcontext` "
"的线程之间不会产生竞争条件。 例如::"

#: ../../library/decimal.rst:1823
msgid "Recipes"
msgstr "例程"

#: ../../library/decimal.rst:1825
msgid ""
"Here are a few recipes that serve as utility functions and that demonstrate "
"ways to work with the :class:`Decimal` class::"
msgstr "以下是一些用作工具函数的例程，它们演示了使用 :class:`Decimal` 类的各种方式::"

#: ../../library/decimal.rst:1980
msgid "Decimal FAQ"
msgstr "Decimal FAQ"

#: ../../library/decimal.rst:1982
msgid ""
"Q. It is cumbersome to type ``decimal.Decimal('1234.5')``.  Is there a way "
"to minimize typing when using the interactive interpreter?"
msgstr "Q. 总是输入 ``decimal.Decimal('1234.5')`` 是否过于笨拙。 在使用交互解释器时有没有最小化输入量的方式？"

#: ../../library/decimal.rst:1985
msgid "A. Some users abbreviate the constructor to just a single letter:"
msgstr "A. 有些用户会将构造器简写为一个字母："

#: ../../library/decimal.rst:1991
msgid ""
"Q. In a fixed-point application with two decimal places, some inputs have "
"many places and need to be rounded.  Others are not supposed to have excess "
"digits and need to be validated.  What methods should be used?"
msgstr ""
"Q. 在带有两个十进制位的定点数应用中，有些输入值具有许多位，需要被舍入。 另一些数则不应具有多余位，需要验证有效性。 这种情况应该用什么方法？"

#: ../../library/decimal.rst:1995
msgid ""
"A. The :meth:`quantize` method rounds to a fixed number of decimal places. "
"If the :const:`Inexact` trap is set, it is also useful for validation:"
msgstr ""
"A. 用 :meth:`quantize` 方法舍入到固定数量的十进制位。 如果设置了 :const:`Inexact` 陷阱，它也适用于验证有效性："

#: ../../library/decimal.rst:2013
msgid ""
"Q. Once I have valid two place inputs, how do I maintain that invariant "
"throughout an application?"
msgstr "Q. 当我使用两个有效位的输入时，我要如何在一个应用中保持有效位不变？"

#: ../../library/decimal.rst:2016
msgid ""
"A. Some operations like addition, subtraction, and multiplication by an "
"integer will automatically preserve fixed point.  Others operations, like "
"division and non-integer multiplication, will change the number of decimal "
"places and need to be followed-up with a :meth:`quantize` step:"
msgstr ""
"A. 某些运算例如与整数相加、相减和相乘将会自动保留固定的小数位数。 其他运算，例如相除和非整数相乘则将会改变小数位数，需要再加上 "
":meth:`quantize` 处理步骤："

#: ../../library/decimal.rst:2034
msgid ""
"In developing fixed-point applications, it is convenient to define functions"
" to handle the :meth:`quantize` step:"
msgstr "在开发定点数应用时，更方便的做法是定义处理 :meth:`quantize` 步骤的函数："

#: ../../library/decimal.rst:2047
msgid ""
"Q. There are many ways to express the same value.  The numbers :const:`200`,"
" :const:`200.000`, :const:`2E2`, and :const:`.02E+4` all have the same value"
" at various precisions. Is there a way to transform them to a single "
"recognizable canonical value?"
msgstr ""
"Q. 表示同一个值有许多方式。 数字 :const:`200`, :const:`200.000`, :const:`2E2` 和 "
":const:`.02E+4` 的值都相同但有精度不同。 是否有办法将它们转换为一个可识别的规范值？"

#: ../../library/decimal.rst:2052
msgid ""
"A. The :meth:`normalize` method maps all equivalent values to a single "
"representative:"
msgstr "A. :meth:`normalize` 方法可将所有相同的值映射为统一表示形式："

#: ../../library/decimal.rst:2059
msgid ""
"Q. Some decimal values always print with exponential notation.  Is there a "
"way to get a non-exponential representation?"
msgstr "Q. 有些十进制值总是被打印为指数表示形式。 是否有办法得到一个非指数表示形式？"

#: ../../library/decimal.rst:2062
msgid ""
"A. For some values, exponential notation is the only way to express the "
"number of significant places in the coefficient.  For example, expressing "
":const:`5.0E+3` as :const:`5000` keeps the value constant but cannot show "
"the original's two-place significance."
msgstr ""
"A. 对于某些值来说，指数表示形式是表示系数中有效位的唯一办法。 例如，将 :const:`5.0E+3` 表示为 :const:`5000` "
"可以让值保持恒定，但是无法显示原本的两位有效数字。"

#: ../../library/decimal.rst:2067
msgid ""
"If an application does not care about tracking significance, it is easy to "
"remove the exponent and trailing zeroes, losing significance, but keeping "
"the value unchanged:"
msgstr "如果一个应用不必关心追踪有效位，则可以很容易地移除指数和末尾的零，丢弃有效位但让值保持不变："

#: ../../library/decimal.rst:2077
msgid "Q. Is there a way to convert a regular float to a :class:`Decimal`?"
msgstr "Q. 是否有办法将一个普通浮点数转换为 :class:`Decimal`？"

#: ../../library/decimal.rst:2079
msgid ""
"A. Yes, any binary floating point number can be exactly expressed as a "
"Decimal though an exact conversion may take more precision than intuition "
"would suggest:"
msgstr "A. 是的，任何二进制浮点数都可以精确地表示为 Decimal 值，但精确的转换可能需要比直觉设想更高的精度："

#: ../../library/decimal.rst:2088
msgid ""
"Q. Within a complex calculation, how can I make sure that I haven't gotten a"
" spurious result because of insufficient precision or rounding anomalies."
msgstr "Q. 在一个复杂的计算中，我怎样才能保证不会得到由精度不足和舍入异常所导致的虚假结果。"

#: ../../library/decimal.rst:2091
msgid ""
"A. The decimal module makes it easy to test results.  A best practice is to "
"re-run calculations using greater precision and with various rounding modes."
" Widely differing results indicate insufficient precision, rounding mode "
"issues, ill-conditioned inputs, or a numerically unstable algorithm."
msgstr ""
"A. 使用 decimal 模块可以很容易地检测结果。 最好的做法是使用更高的精度和不同的舍入模式重新进行计算。 "
"明显不同的结果表明存在精度不足、舍入模式问题、不符合条件的输入或是结果不稳定的算法。"

#: ../../library/decimal.rst:2096
msgid ""
"Q. I noticed that context precision is applied to the results of operations "
"but not to the inputs.  Is there anything to watch out for when mixing "
"values of different precisions?"
msgstr "Q. 我发现上下文精度的应用只针对运算结果而不针对输入。在混合使用不同精度的值时有什么需要注意的吗？"

#: ../../library/decimal.rst:2100
msgid ""
"A. Yes.  The principle is that all values are considered to be exact and so "
"is the arithmetic on those values.  Only the results are rounded.  The "
"advantage for inputs is that \"what you type is what you get\".  A "
"disadvantage is that the results can look odd if you forget that the inputs "
"haven't been rounded:"
msgstr ""
"A. 是的。 原则上所有值都会被视为精确值，在这些值上进行的算术运算也是如此。 只有结果会被舍入。 对于输入来说其好处是“所输入即所得”。 "
"而其缺点则是如果你忘记了输入没有被舍入，结果看起来可能会很奇怪："

#: ../../library/decimal.rst:2113
msgid ""
"The solution is either to increase precision or to force rounding of inputs "
"using the unary plus operation:"
msgstr "解决办法是提高精度或使用单目加法运算对输入执行强制舍入："

#: ../../library/decimal.rst:2122
msgid ""
"Alternatively, inputs can be rounded upon creation using the "
":meth:`Context.create_decimal` method:"
msgstr "此外，还可以使用 :meth:`Context.create_decimal` 方法在创建输入时执行舍入："

#: ../../library/decimal.rst:2128
msgid "Q. Is the CPython implementation fast for large numbers?"
msgstr "Q. CPython 实现对于巨大数字是否足够快速？"

#: ../../library/decimal.rst:2130
msgid ""
"A. Yes.  In the CPython and PyPy3 implementations, the C/CFFI versions of "
"the decimal module integrate the high speed `libmpdec "
"<https://www.bytereef.org/mpdecimal/doc/libmpdec/index.html>`_ library for "
"arbitrary precision correctly-rounded decimal floating point arithmetic. "
"``libmpdec`` uses `Karatsuba multiplication "
"<https://en.wikipedia.org/wiki/Karatsuba_algorithm>`_ for medium-sized "
"numbers and the `Number Theoretic Transform "
"<https://en.wikipedia.org/wiki/Discrete_Fourier_transform_(general)#Number-"
"theoretic_transform>`_ for very large numbers.  However, to realize this "
"performance gain, the context needs to be set for unrounded calculations."
msgstr ""
"A. 是的，在 CPython 和 PyPy3 实现中，decimal 模块的 C/CFFI 版本集成了高速 `libmpdec "
"<https://www.bytereef.org/mpdecimal/doc/libmpdec/index.html>`_ "
"库用于实现任意精度正确舍入的十进制浮点算术。 ``libmpdec`` 会对中等的数字使用 `Karatsuba 乘法 "
"<https://en.wikipedia.org/wiki/Karatsuba_algorithm>`_ 而对非常巨大的数字使用 `数字原理变换 "
"<https://en.wikipedia.org/wiki/Discrete_Fourier_transform_(general)#Number-"
"theoretic_transform>`_ 。 但是，想要实现这种性能提升，需要对未舍入的运算设置上下文。"