`decimal` — 십진수 고정 소수점 및 부동 소수점 산술¶

decimal 모듈은 빠르고 올바르게 반올림된 십진 부동 소수점 산술을 지원합니다. 이는 float 데이터형보다 몇 가지 이점을 제공합니다:

Decimal “은 사람을 염두에 두고 설계된 부동 소수점 모델에 기반하며, 필연적으로 최고 원리를 갖습니다 – 컴퓨터는 사람들이 학교에서 배우는 산술과 같은 방식으로 동작하는 산술을 반드시 제공해야 한다.” – 십진 산술 명세에서 발췌한 내용입니다.
Decimal 숫자는 정확하게 표현될 수 있습니다. 이와 대조적으로, 1.1 및 2.2 와 같은 숫자는 이진 부동 소수점에서 정확한 표현을 갖지 않습니다. 일반적으로 최종 사용자는 1.1 + 2.2 가 이진 부동 소수점처럼 3.3000000000000003 로 표시될 것이라고 예상하지 않습니다.
정확성은 산술 계산으로 이어집니다. 십진 부동 소수점에서는 0.1 + 0.1 + 0.1 - 0.3 이 정확히 0과 같습니다. 이진 부동 소수점에서는 그 결과가 5.5511151231257827e-017 입니다. 0에 가깝긴 하지만, 이러한 차이점들은 신뢰할 수 있는 동등성 테스트를 방해하며 차이가 누적될 수 있습니다. 이러한 이유로, 엄격한 동등성 불변성을 가진 회계 애플리케이션에서는 십진 부동 소수점을 사용하는 것이 선호됩니다.
십진 모듈은 유효숫자 개념을 통합하여 1.30 + 1.20 이 2.50 이 되도록 합니다. 끝의 0은 유효성을 나타내기 위해 유지됩니다. 이는 화폐 애플리케이션의 일반적인 표현 방식입니다. 곱셈의 경우, “학교 방식”은 곱하는 수의 모든 숫자를 사용합니다. 예를 들어, 1.3 * 1.2 는 1.56 을 산출하는 반면, 1.30 * 1.20 은 1.5600 을 산출합니다.
하드웨어 기반 이진 부동 소수점과는 달리, decimal 모듈은 사용자가 변경할 수 있는 정밀도(기본값은 28자리)를 가지며, 주어진 문제에 따라 필요한 만큼 커질 수 있습니다:
```
>>> from decimal import *
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal('0.1428571428571428571428571429')
```
이진 및 십진 부동 소수점 모두 출판된 표준에 따라 구현됩니다. 내장 float 형이 기능의 적당한 부분만을 드러내지만, decimal 모듈은 표준의 모든 필수 부분을 노출합니다. 필요한 경우, 프로그래머는 자리 올림(rounding) 및 신호(signal) 처리를 완전히 제어할 수 있습니다. 여기에는 정확하지 않은 연산을 차단하기 위한 예외를 사용하여 정확한 산술을 강제하는 옵션이 포함됩니다.
decimal 모듈은 “편견 없이, (때로 고정 소수점 산술이라고도 불리는) 정확한 자리 올림 없는 십진 산술과 자리 올림 있는 부동 소수점 산술을 모두” 지원하도록 설계되었습니다. – 십진 산술 명세에서 발췌.

모듈 설계의 중심 개념은 세 가지입니다: 십진수, 산술을 위한 컨텍스트, 신호(signal).

십진 숫자는 불변합니다. 부호, 계수 숫자, 지수 값을 가집니다. 유효성을 유지하기 위해, 계수 숫자는 후행 0을 자르지 않습니다. 십진수는 또한 Infinity, -Infinity, NaN 과 같은 특수 값도 포함합니다. 표준은 또한 -0 과 +0 을 구별합니다.

산술 컨텍스트는 정밀도, 자리 올림 규칙, 지수에 대한 제한, 연산 결과를 나타내는 플래그 및 신호가 예외로 처리될지를 결정하는 트랩 활성화기(trap enabler)를 지정하는 환경입니다. 자리 올림 옵션에는 ROUND_CEILING, ROUND_DOWN, ROUND_FLOOR, ROUND_HALF_DOWN, ROUND_HALF_EVEN, ROUND_HALF_UP, ROUND_UP 및 ROUND_05UP 가 있습니다.

신호는 계산 과정에서 발생하는 예외적인 조건의 그룹입니다. 응용 프로그램의 필요에 따라, 신호가 무시되거나, 정보로 간주하거나, 예외로 처리될 수 있습니다. decimal 모듈의 신호는 Clamped, InvalidOperation, DivisionByZero, Inexact, Rounded, Subnormal, Overflow, Underflow, FloatOperation 입니다.

각 신호에는 플래그와 트랩 활성화기가 있습니다. 신호와 만났을 때, 플래그가 1로 설정되고 트랩 활성화기가 1로 설정된 경우, 예외가 발생합니다. 플래그는 상태가 유지되므로(sticky) 계산을 감시하기 전에 재설정할 필요가 있습니다.

IBM의 일반 십진 산술 명세서, The General Decimal Arithmetic Specification\.\

빠른 시작 자습서¶

decimal을 사용하는 일반적인 시작은 모듈을 임포트하고, getcontext() 로 현재 컨텍스트를 보고, 필요하다면 정밀도, 자리 올림 또는 활성화된 트랩에 대해 새 값을 설정하는 것입니다:

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

>>> getcontext().prec = 7       # 새로운 정밀도 설정

십진 인스턴스는 정수, 문자열, float 또는 튜플로부터 구성될 수 있습니다. 정수나 float로부터의 구성은 해당 정수 또는 float의 값을 정확하게 변환합니다. 십진 숫자는 “Not a number”를 의미하는 NaN, 양의 및 음의 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 신호를 트랩 하는 경우, 실수로 생성자나 대소비교에서 Decimal 수와 실수(float)를 혼합하면 예외가 발생합니다:

>>> c = getcontext()
>>> c.traps[FloatOperation] = True
>>> Decimal(3.14)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
decimal.FloatOperation: [<class 'decimal.FloatOperation'>]
>>> Decimal('3.5') < 3.7
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
decimal.FloatOperation: [<class 'decimal.FloatOperation'>]
>>> Decimal('3.5') == 3.5
True

Added in version 3.3.

새로운 Decimal의 유효 숫자는 입력된 숫자의 개수에 의해서만 결정됩니다. 컨텍스트 정밀도 및 자리 올림은 오직 산술 연산 중에만 작용합니다.

>>> 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 버전의 내부 제한을 초과하면, Decimal 을 만들 때 InvalidOperation 를 일으킵니다:

>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
decimal.InvalidOperation: [<class 'decimal.InvalidOperation'>]

버전 3.3에서 변경.

십진수는 Python의 나머지 부분과 잘 상호작용합니다. 여기 작은 십진 부동 소수점 비행 서커스가 있습니다:

>>> 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')

십진수는 고정 소수점 또는 과학적 표기법으로 형식화될 수 있으며 (내장 format() 또는 포맷 문자열 리터럴 사용), 내장 float 유형과 동일한 형식 지정 구문을 사용합니다 (참조 포맷 명세 미니 언어).

>>> format(Decimal('2.675'), "f")
'2.675'
>>> format(Decimal('2.675'), ".2f")
'2.68'
>>> f"{Decimal('2.675'):.2f}"
'2.68'
>>> format(Decimal('2.675'), ".2e")
'2.68e+0'
>>> with localcontext() as ctx:
...     ctx.rounding = ROUND_DOWN
...     print(format(Decimal('2.675'), ".2f"))
...
2.67

그리고 Decimal에는 몇 가지 수학 함수도 있습니다:

>>> 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() 메서드는 숫자를 고정 지수로 반올림합니다. 이 메서드는 결과를 고정된 자릿수로 반올림하는 경우가 많은 화폐 애플리케이션에 유용합니다:

>>> Decimal('7.325').quantize(Decimal('.01'), rounding=ROUND_DOWN)
Decimal('7.32')
>>> Decimal('7.325').quantize(Decimal('1.'), rounding=ROUND_UP)
Decimal('8')

위에서 보듯이, getcontext() 함수는 현재 컨텍스트에 액세스하고 설정을 변경할 수 있게 합니다. 이 방법은 대부분 응용 프로그램의 요구를 충족시킵니다.

고급 작업을 위해, Context() 생성자를 사용하여 대체 컨텍스트를 만드는 것이 유용할 수 있습니다. 대체 컨텍스트를 활성화하려면, setcontext() 함수를 사용하십시오.

표준에 따라, decimal 모듈은 바로 사용할 수 있는 두 개의 표준 컨텍스트, BasicContext 와 ExtendedContext 를 제공합니다. 전자는 많은 트랩이 활성화되어있어 디버깅에 특히 유용합니다:

>>> 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>", line 1, in -toplevel-
    Decimal(42) / Decimal(0)
DivisionByZero: x / 0

컨텍스트는 또한 계산 중 발생하는 예외 조건을 모니터링하기 위한 신호 플래그를 가집니다. 이 플래그들은 명시적으로 지워질 때까지 설정된 상태를 유지하므로, clear_flags() 메서드를 사용하여 모니터링되는 모든 계산 세트가 시작되기 전에 플래그를 지우는 것이 가장 좋습니다.

>>> 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 항목은 파이에 대한 유리 근사화가 반올림되었고 (컨텍스트 정밀도를 넘는 자릿수는 버려짐) 결과가 부정확하다(버려진 일부 자릿수가 0이 아님)는 것을 보여줍니다.

개별 트랩은 컨텍스트의 traps 속성의 딕셔너리를 사용하여 설정됩니다:

>>> setcontext(ExtendedContext)
>>> Decimal(1) / Decimal(0)
Decimal('Infinity')
>>> getcontext().traps[DivisionByZero] = 1
>>> Decimal(1) / Decimal(0)
Traceback (most recent call last):
  File "<pyshell#112>", line 1, in -toplevel-
    Decimal(1) / Decimal(0)
DivisionByZero: x / 0

대부분 프로그램은 프로그램 시작 시에 한 번만 현재 컨텍스트를 조정합니다. 그리고, 많은 응용 프로그램에서, 데이터는 루프 내에서 단일형변환으로 Decimal로 변환되어, 프로그램 대부분은 다른 파이썬 숫자 형과 별로 다르지 않게 데이터를 조작합니다.

Decimal 객체¶

class decimal.Decimal(value='0', context=None)¶

value 를 기반으로 새 Decimal 객체를 만듭니다.

value 는 정수, 문자열, 튜플, float 또는 다른 Decimal 객체일 수 있습니다. value 가 주어지지 않으면, Decimal('0') 을 반환합니다. value 가 문자열이면, 앞뒤의 공백 문자 및 밑줄이 제거된 후 십진수 문자열 문법에 맞아야 합니다:

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

다른 유니코드 십진 숫자를 digit 가 나타나는 곳에도 허용합니다. 여기에는 다양한 다른 알파벳(예를 들어, 아라비아-인디아 및 데바나가리 숫자)의 십진 숫자와 전체 너비의 숫자 '\uff10' 부터 '\uff19' 까지가 포함됩니다. 대/소문자는 구분하지 않으므로, 예를 들어 inf, Inf, INFINITY, iNfINity 는 모두 양의 무한대에 대한 허용 가능한 표기입니다.

만약 value 가 tuple 이라면, 부호(양의 경우 0 또는 음의 경우 1), digits의 tuple, 정수 지수로 구성된 세 가지 구성 요소를 가져야 합니다. 예를 들어, Decimal((0, (1, 4, 1, 4), -3)) 은 Decimal('1.414') 를 반환합니다.

만약 value 가 float 이라면, 이 이진 부동 소수점 값은 손실 없이 정확한 십진 등가값으로 변환됩니다. 이 변환 과정은 종종 53자리 이상의 정밀도를 요구할 수 있습니다. 예를 들어, Decimal(float('1.1')) 은 Decimal('1.100000000000000088817841970012523233890533447265625') 으로 변환됩니다.

context 정밀도는 저장되는 자릿수에 영향을 주지 않습니다. 저장되는 자릿수는 value 의 자릿수만으로 결정됩니다. 예를 들어 Decimal('3.00000') 은 컨텍스트 정밀도가 단지 3이라도 5개의 모든 0을 기록합니다.

context 인수의 목적은 value 가 잘못된 문자열일 때 처리할 방식을 결정하는 것입니다. 만약 컨텍스트가 InvalidOperation 을 포획하면 예외가 발생하며, 그렇지 않은 경우 생성자는 NaN 값을 가진 새로운 Decimal을 반환합니다.

일단 만들어지면, Decimal 객체는 불변입니다.

버전 3.2에서 변경: 생성자에 대한 인자는 이제 float 인스턴스가 될 수 있습니다.

버전 3.3에서 변경: float 인자는 FloatOperation 트랩이 설정되면 예외를 발생시킵니다. 기본적으로 트랩은 꺼져 있습니다.

버전 3.6에서 변경: 코드에서의 정수와 부동 소수점 리터럴과 마찬가지로, 밑줄로 무리 지을 수 있습니다.

Decimal 부동 소수점 객체는 float 및 int`와 같은 다른 내장 숫자형과 많은 속성을 공유합니다. 일반적인 모든 수학 연산 및 특수 메서드가 적용됩니다. 마찬가지로, decimal 객체는 복사, 피클링, 출력, 딕셔너리 키로 사용, 세트 요소로 사용, 비교, 정렬 및 다른 유형(예: :class:`float 또는 int)으로 강제 변환될 수 있습니다.

Decimal 객체에 대한 산술과 정수 및 실수에 대한 산술에는 약간의 차이가 있습니다. Decimal 객체에 나머지 연산자 % 가 적용될 때, 결과의 부호는 제수의 부호가 아닌 피제수의 부호가 됩니다:

>>> (-7) % 4
1
>>> Decimal(-7) % Decimal(4)
Decimal('-3')

정수 나눗셈 연산자 // 의 동작 역시 비슷한 차이를 보입니다. 즉, 가장 가까운 정수로 내림하는 대신 실제 몫의 정수 부(0을 향해 자르기)를 돌려줍니다. 그래서 일반적인 항등식 x == (x // y) * y + x % y 를 유지합니다:

>>> -7 // 4
-2
>>> Decimal(-7) // Decimal(4)
Decimal('-1')

% 와 // 연산자는 명세에 설명된 대로 각각 remainder 와 divide-integer 연산을 구현합니다.

Decimal 객체는 일반적으로 산술 연산에서 float 나 fractions.Fraction 인스턴스와 결합 할 수 없습니다: 예를 들어, float 에 a Decimal을 더하려고 하면 TypeError 를 일으킵니다. 그러나, 파이썬의 비교 연산자를 사용하여 Decimal 인스턴스 x 와 다른 숫자 y 를 비교할 수 있습니다. 이렇게 해서 서로 다른 형의 숫자 간에 동등 비교를 할 때 혼란스러운 결과를 피합니다.

버전 3.2에서 변경: Decimal 인스턴스와 다른 숫자 형 사이의 혼합형 비교가 이제 완전히 지원됩니다.

일반적인 숫자 속성 외에도, decimal 부동 소수점 객체는 여러 가지 특수 메서드를 가집니다:

adjusted()¶: 최상위 숫자만 남을 때까지 계수의 가장 오른쪽 숫자들을 밀어내도록 조정된 지수를 반환합니다. Decimal('321e+5').adjusted() 는 7을 반환합니다. 소수점으로부터의 최상위 유효 숫자의 위치를 결정하는 데 사용됩니다.

as_integer_ratio()¶

주어진 Decimal 인스턴스를, 분모가 양수인 기약 분수로 나타내는 정수의 쌍 (n, d) 을 돌려줍니다:

>>> Decimal('-3.14').as_integer_ratio()
(-157, 50)

변환은 정확합니다. 무한대는 OverflowError를, NaN 은 ValueError를 일으킵니다.

Added in version 3.6.

as_tuple()¶: 숫자의 네임드 튜플 표현을 반환합니다: DecimalTuple(sign, digits, exponent).

canonical()¶: 인자의 규범적인 인코딩을 돌려줍니다. 현재 Decimal 인스턴스의 인코딩은 항상 규범적이므로, 이 연산은 인자를 변경하지 않고 반환합니다.

compare(other, context=None)¶

두 Decimal 인스턴스의 값을 비교합니다. compare() 는 Decimal 인스턴스를 반환하고, 피연산자 중 하나가 NaN이면 결과는 NaN입니다:

a or b is a NaN  ==> Decimal('NaN')
a < b            ==> Decimal('-1')
a == b           ==> Decimal('0')
a > b            ==> Decimal('1')

compare_signal(other, context=None)¶: 이 연산은, 모든 NaN 이 신호를 준다는 것을 제외하면 compare() 메서드와 같습니다. 즉, 피연산자가 모두 신호를 주는 NaN이 아니면, 모든 조용한 NaN 피연산자가 마치 신호를 주는 NaN 인 것처럼 처리됩니다.

compare_total(other, context=None)¶

두 개의 피연산자를 숫자 값 대신 추상 표현을 사용하여 비교합니다. compare() 메서드와 비슷하지만, 결과는 Decimal 인스턴스에 대해 전 순서(total ordering)를 부여합니다. 같은 숫자 값을 갖지만 다른 표현의 두 Decimal 인스턴스는 이 순서에 의해 다른 것으로 비교됩니다:

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

조용한 NaN과 신호를 주는 NaN도 전 순서에 포함됩니다. 이 함수의 결과는, 두 피연산자가 같은 표현을 가질 때 Decimal('0'), 첫 번째 피연산자가 전 순서에서 두 번째 피연산자보다 낮으면 Decimal('-1'), 첫 번째 피연산자가 전 순서에서 두 번째 피연산자보다 높으면 Decimal('1') 입니다. 전 순서에 대한 세부 사항은 명세를 참조하십시오.

이 연산은 컨텍스트의 영향을 받지 않고, 조용합니다: 어떤 플래그도 변경되지 않고, 어떤 자리 올림도 수행되지 않습니다. 예외적으로, 두 번째 피연산자를 정확하게 변환할 수 없으면 C 버전은 InvalidOperation을 발생시킬 수 있습니다.

compare_total_mag(other, context=None)¶

compare_total()처럼 두 개의 피연산자를 숫자 값 대신 추상 표현을 사용하여 비교하지만, 각 피연산자의 부호를 무시합니다. x.compare_total_mag(y) 는 x.copy_abs().compare_total(y.copy_abs()) 와 동등합니다.

conjugate()¶: 그냥 self를 돌려줍니다. 이 메서드는 Decimal 명세를 준수하기 위한 것뿐입니다.

copy_abs()¶: 인자의 절댓값을 반환합니다. 이 연산은 컨텍스트의 영향을 받지 않고, 조용합니다: 어떤 플래그도 변경되지 않고, 어떤 자리 올림도 수행되지 않습니다.

copy_negate()¶: 인자의 음의 부정을 돌려줍니다. 이 연산은 컨텍스트의 영향을 받지 않고, 조용합니다: 어떤 플래그도 변경되지 않고, 어떤 자리 올림도 수행되지 않습니다.

copy_sign(other, context=None)¶

두 번째 피연산자의 부호와 같은 부호로 설정된 첫 번째 피연산자의 복사본을 반환합니다. 예를 들어:

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

exp(context=None)¶

주어진 숫자에 대한 (자연) 지수 함수 e**x 의 값을 반환합니다. 결과는 ROUND_HALF_EVEN 자리 올림 모드를 사용하여 올바르게 자리 올림 됩니다.

>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal(321).exp()
Decimal('2.561702493119680037517373933E+139')

classmethod from_float(f, /)¶

float 또는 :class:`int`의 인스턴스만 허용하는 대체 생성자입니다.

주의할 점은 Decimal.from_float(0.1) 이 Decimal('0.1') 과 같지 않다는 것입니다. 0.1은 이진 부동 소수점에서 정확하게 표현할 수 없기 때문에, 그 값은 가장 가까운 표현 가능한 값인 0x1.999999999999ap-4 로 저장됩니다. 십진법에서 이와 등가인 값은 0.1000000000000000055511151231257827021181583404541015625 입니다.

참고

파이썬 3.2 이후부터는, Decimal 인스턴스를 float에서 직접 생성할 수 있습니다.

>>> 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')

Added in version 3.1.

classmethod from_number(number, /)¶

float, int 또는 :class:`Decimal`의 인스턴스만 허용하며, 문자열이나 튜플은 허용하지 않는 대체 생성자입니다.

>>> Decimal.from_number(314)
Decimal('314')
>>> Decimal.from_number(0.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
>>> Decimal.from_number(Decimal('3.14'))
Decimal('3.14')

Added in version 3.14.

fma(other, third, context=None)¶

합성된 곱셈-덧셈(fused multiply-add). 중간값 self*other의 자리 올림 없이 self*other+third를 반환합니다.

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

is_canonical()¶: 인자가 규범적이면 True를 반환하고, 그렇지 않으면 False를 반환합니다. 현재 Decimal 인스턴스는 항상 규범적이므로 이 연산은 항상 True를 반환합니다.

is_finite()¶: 인자가 유한 수이면 True를 반환하고, 인자가 무한대나 NaN 이면 False를 반환합니다.

is_infinite()¶: 인자가 양이나 음의 무한대면 True를 반환하고, 그렇지 않으면 False를 반환합니다.

is_nan()¶: 인자가 (조용한 또는 신호를 주는) NaN이면 True를 반환하고, 그렇지 않으면 False를 반환합니다.

is_normal(context=None)¶: 인자가 정상(normal) 유한 수이면 True를 반환합니다. 인자가 0, 비정상(subnormal), 무한대 또는 NaN 이면 False를 반환합니다.

is_qnan()¶: 인자가 조용한 NaN이면 True를 반환하고, 그렇지 않으면 False를 반환합니다.

is_signed()¶: 인자가 음의 부호를 가지면 True를 반환하고, 그렇지 않으면 False를 반환합니다. 0과 NaN 모두 부호를 가질 수 있다는 것에 유의하세요.

is_snan()¶: 인자가 신호를 주는 NaN이면 True를 반환하고, 그렇지 않으면 False를 반환합니다.

is_subnormal(context=None)¶: 인자가 비정상(subnormal)이면 True를 반환하고, 그렇지 않으면 False를 반환합니다.

is_zero()¶: 인자가 (양 또는 음의) 0이면 True를 반환하고, 그렇지 않으면 False를 반환합니다.

ln(context=None)¶: 피연산자의 자연로그(밑 e)를 반환합니다. 결과는 ROUND_HALF_EVEN 자리 올림 모드를 사용하여 올바르게 반올림됩니다.

log10(context=None)¶: 피연산자의 상용로그를 반환합니다. 결과는 ROUND_HALF_EVEN 자리 올림 모드를 사용하여 올바르게 반올림됩니다.

logb(context=None)¶: 0이 아닌 수의 경우, 피연산자의 조정된 지수를 Decimal 인스턴스로 반환합니다. 피연산자가 0이면 Decimal('-Infinity') 가 반환되고 DivisionByZero 플래그가 발생합니다. 피연산자가 무한대면 Decimal('Infinity') 가 반환됩니다.

logical_and(other, context=None)¶: logical_and() 는 두 개의 논리적 피연산자(논리적 피연산자를 보세요)를 취하는 논리적 연산입니다. 결과는 두 피연산자의 자릿수별 and 입니다.

logical_invert(context=None)¶: logical_invert() 는 논리적 연산입니다. 결과는 피연산자의 자릿수별 반전입니다.

logical_or(other, context=None)¶: logical_or() 는 두 개의 논리적 피연산자(논리적 피연산자를 보세요)를 취하는 논리적 연산입니다. 결과는 두 피연산자의 자릿수별 or 입니다.

logical_xor(other, context=None)¶: logical_xor()은 두 개의 논리적 피연산자(논리적 피연산자를 보세요)를 취하는 논리적 연산입니다. 결과는 두 피연산자의 자릿수별 배타적 or입니다.

max(other, context=None)¶: max(self, other)``와 유사하지만, 반환하기 전에 컨텍스트 반올림 규칙이 적용되며, ``NaN 값은 신호되거나 무시됩니다 (컨텍스트 및 신호 여부와 관계없이).

max_mag(other, context=None)¶: max()와 비슷하지만, 피연산자의 절댓값을 사용하여 비교가 이루어집니다.

min(other, context=None)¶: min(self, other)``와 유사하지만, 반환하기 전에 컨텍스트 반올림 규칙이 적용되며, ``NaN 값은 신호되거나 무시됩니다 (컨텍스트 및 신호 여부와 관계없이).

min_mag(other, context=None)¶: min()과 비슷하지만, 피연산자의 절댓값을 사용하여 비교가 이루어집니다.

next_minus(context=None)¶: 주어진 피연산자보다 작고, 주어진 컨텍스트(또는 context가 주어지지 않으면 현재 스레드의 컨텍스트)에서 표현 가능한 가장 큰 수를 돌려줍니다.

next_plus(context=None)¶: 주어진 피연산자보다 크고, 주어진 컨텍스트(또는 context가 주어지지 않으면 현재 스레드의 컨텍스트)에서 표현 가능한 가장 작은 수를 돌려줍니다.

next_toward(other, context=None)¶: 두 피연산자가 같지 않으면, 두 번째 피연산자의 방향으로 첫 번째 피연산자에 가장 가까운 숫자를 반환합니다. 두 피연산자가 수치로 같으면, 첫 번째 피연산자의 복사본을 반환하는데, 부호를 두 번째 피연산자의 것으로 설정합니다.

normalize(context=None)¶

현재 컨텍스트 또는 지정된 컨텍스트 내에서 등가 클래스의 표준 값을 생성하는 데 사용됩니다.

이 연산은 단항 플러스 연산과 동일한 의미를 가지지만, 최종 결과가 유한한 경우 모든 후행 0이 제거되고 부호가 보존되는 가장 간단한 형태로 축소됩니다. 즉, 계수가 0이 아니면서 10의 배수인 경우 계수는 10으로 나누어지고 지수는 1만큼 증가합니다. 그렇지 않은 경우(계수가 0인 경우) 지수는 0으로 설정됩니다. 모든 경우에 부호는 변경되지 않습니다.

예를 들어, Decimal('32.100') 과 Decimal('0.321000e+2') 는 모두 같은 값인 Decimal('32.1') 으로 정규화됩니다.

반올림이 가장 간단한 형태로 축소되기 전에 적용된다는 점에 유의하십시오.

최신 버전의 사양에서는 이 연산이 reduce 라고도 알려져 있습니다.

number_class(context=None)¶

피연산자의 클래스 를 설명하는 문자열을 반환합니다. 반환 값은 다음 10개의 문자열 중 하나입니다.

"-Infinity", 피연산자가 음의 무한대임을 나타냅니다.
"-Normal", 피연산자가 음의 정상 수임을 나타냅니다.
"-Subnormal", 피연산자가 음의 비정상 수임을 나타냅니다.
"-Zero", 피연산자가 음의 0임을 나타냅니다.
"+Zero", 피연산자가 양의 0임을 나타냅니다.
"+Subnormal", 피연산자가 양의 비정상 수임을 나타냅니다.
"+Normal", 피연산자가 양의 정상 수임을 나타냅니다.
"+Infinity", 피연산자가 양의 무한대임을 나타냅니다.
"NaN", 피연산자가 조용한 NaN(Not a Number)임을 나타냅니다.
"sNaN", 피연산자가 신호를 주는 NaN임을 나타냅니다.

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

자리 올림 후에 첫 번째 피연산자와 같고 두 번째 피연산자의 지수를 갖는 값을 반환합니다.

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

다른 연산과 달리, quantize 연산 후의 계수의 길이가 정밀도보다 크면, InvalidOperation 신호를 줍니다. 이는, 에러 조건이 없으면, quantize 된 지수가 항상 오른쪽 피연산자의 지수와 같음을 보장합니다.

또한, 다른 연산과는 달리, 결과가 비정상(subnormal)이고 부정확한 경우조차도, quantize는 결코 Underflow 신호를 보내지 않습니다.

두 번째 피연산자의 지수가 첫 번째 피연산자의 지수보다 크면 자리 올림이 필요할 수 있습니다. 이 경우, 자리 올림 모드는 (주어지면) rounding 인자에 의해 결정됩니다. 그렇지 않으면 주어진 context 인자에 의해 결정됩니다; 두 인자 모두 주어지지 않으면, 현재 스레드의 컨텍스트의 자리 올림 모드가 사용됩니다.

결과 지수가 :attr:`~Context.Emax`보다 크거나 :meth:`~Context.Etiny`보다 작은 경우 오류가 반환됩니다.

radix()¶: Decimal 클래스가 모든 산술을 수행하는 진수(기수)인 Decimal(10) 을 반환합니다. 명세와의 호환성을 위해 포함됩니다.

remainder_near(other, context=None)¶

self 를 other 로 나눈 나머지를 반환합니다. 이것은 나머지의 절댓값을 최소화하기 위해 나머지의 부호가 선택된다는 점에서 self % other 와 다릅니다. 좀 더 정확히 말하면, 반환 값은 self - n * other 인데, 여기서 n 은 self / other 의 정확한 값에 가장 가까운 정수이고, 두 개의 정수와의 거리가 같으면 짝수가 선택됩니다.

결과가 0이면 그 부호는 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)¶: 첫 번째 피연산자의 계수를 두 번째 피연산자로 지정된 양만큼 회전한 결과를 반환합니다. 두 번째 피연산자는 -precision에서 precision 범위의 정수여야 합니다. 두 번째 피연산자의 절댓값은 회전할 자리의 수를 나타냅니다. 두 번째 피연산자가 양수면 왼쪽으로 회전합니다; 그렇지 않으면 오른쪽으로 회전합니다. 필요하면 정밀도에 맞추기 위해 첫 번째 피연산자의 계수에 0이 왼쪽에 채워집니다. 첫 번째 피연산자의 부호와 지수는 변경되지 않습니다.

same_quantum(other, context=None)¶

self와 other가 동일한 지수를 갖는지 여부 또는 둘 다 NaN 인지 테스트합니다.

scaleb(other, context=None)¶: 첫 번째 피연산자의 지수를 두 번째 피연산자만큼 조정한 값을 반환합니다. 달리 표현하면, 첫 번째 피연산자에 10**other 를 곱한 값을 반환합니다. 두 번째 피연산자는 정수여야 합니다.

shift(other, context=None)¶: 첫 번째 피연산자의 계수를 두 번째 피연산자로 지정된 양만큼 이동한 결과를 반환합니다. 두 번째 피연산자는 -precision에서 precision 범위의 정수여야 합니다. 두 번째 피연산자의 절댓값은 이동할 자리의 수를 나타냅니다. 두 번째 피연산자가 양수면 왼쪽으로 이동합니다; 그렇지 않으면 오른쪽으로 이동합니다. 이동으로 인해 계수에 들어오는 숫자는 0입니다. 첫 번째 피연산자의 부호와 지수는 변경되지 않습니다.

sqrt(context=None)¶: 인자의 제곱근을 완전한 정밀도로 반환합니다.

to_eng_string(context=None)¶

문자열로 변환합니다. 지수가 필요하면 공학 표기법을 사용합니다.

공학 표기법의 지수는 3의 배수입니다. 이렇게 하면 소수점 왼쪽에 최대 3자리를 남기게 되고, 하나나 두 개의 후행 0을 추가해야 할 수 있습니다.

예를 들어, 이 메서드는 Decimal('123E+1') 을 Decimal('1.23E+3') 으로 변환합니다.

to_integral(rounding=None, context=None)¶: to_integral_value() 메서드와 같습니다. to_integral 이름은 이전 버전과의 호환성을 위해 유지되었습니다.

to_integral_exact(rounding=None, context=None)¶: Inexact 나 Rounded 신호를 주면서 가장 가까운 정수로 자리 올림 합니다. 자리 올림 모드는 (주어지면) rounding 매개 변수에 의해, 그렇지 않으면 그렇지 않으면 context 에 의해 결정됩니다. 두 매개 변수 모두 지정되지 않으면, 현재 컨텍스트의 자리 올림 모드가 사용됩니다.

to_integral_value(rounding=None, context=None)¶: Inexact 나 Rounded 신호를 주지 않고 가장 가까운 정수로 자리 올림 합니다. 주어지면, rounding 을 적용합니다; 그렇지 않으면, 제공된 context 나 현재 컨텍스트의 자리 올림 방법을 사용합니다.

Decimal numbers can be rounded using the round() function:

round(number)

round(number, ndigits)

ndigits 가 제공되지 않았거나 None 인 경우, number 에 가장 가까운 int 를 반환하며, 이 경우 짝수로 동점 처리하며, Decimal 컨텍스트의 반올림 모드는 무시됩니다. number 가 무한대인 경우 OverflowError 가 발생하며, (조용한 또는 신호) NaN인 경우 ValueError 가 발생합니다.

ndigits 가 int 인 경우, 컨텍스트의 반올림 모드가 존중되며 number 를 Decimal('1E-ndigits') 의 가장 가까운 배수로 반올림한 Decimal 가 반환됩니다. 이 경우, round(number, ndigits) 는 self.quantize(Decimal('1E-ndigits')) 와 동등합니다. number 가 조용한 NaN인 경우 Decimal('NaN') 을 반환합니다. number 가 무한대이거나, 신호 NaN이거나, 또는 양자화 작업 후 계수의 길이가 현재 컨텍스트의 정밀도보다 클 경우 InvalidOperation 이 발생합니다. 다시 말해, 일반적인 경우에는 다음과 같습니다:

ndigits 가 양수이면, ndigits 소수점 자리로 반올림된 number 를 반환합니다:
ndigits 가 0이면, 가장 가까운 정수로 반올림된 number 를 반환합니다:
ndigits 가 음수이면, 10**abs(ndigits) 의 가장 가까운 배수로 반올림된 number 를 반환합니다.

예를 들면:

>>> from decimal import Decimal, getcontext, ROUND_DOWN
>>> getcontext().rounding = ROUND_DOWN
>>> round(Decimal('3.75'))     # 컨텍스트 반올림 무시
4
>>> round(Decimal('3.5'))      # 반올림은 짝수로
4
>>> round(Decimal('3.75'), 0)  # 컨텍스트 반올림 사용
Decimal('3')
>>> round(Decimal('3.75'), 1)
Decimal('3.7')
>>> round(Decimal('3.75'), -1)
Decimal('0E+1')

논리적 피연산자¶

logical_and(), logical_invert(), logical_or(), 및 logical_xor() 메서드는 인수를 논리적 피연산자 로 예상합니다. 논리적 피연산자 란 지수와 부호가 모두 0이며, 모든 자릿수가 0 또는 1 인 Decimal 인스턴스입니다.

Context 객체¶

컨텍스트는 산술 연산을 위한 환경입니다. 정밀도를 제어하고, 자리 올림 규칙을 설정하며, 어떤 신호가 예외로 처리되는지 결정하고, 지수의 범위를 제한합니다.

각 스레드는 자신만의 현재 컨텍스트를 가지는데, getcontext() 와 setcontext() 함수를 사용하여 액세스하거나 변경합니다:

decimal.getcontext()¶: 활성 스레드의 현재 컨텍스트를 돌려줍니다.

decimal.setcontext(c, /)¶: 활성 스레드의 현재 컨텍스트를 c 로 설정합니다.

또한 with 문과 localcontext() 함수를 사용하여 활성 컨텍스트를 일시적으로 변경할 수 있습니다.

decimal.localcontext(ctx=None, **kwargs)¶

현재 스레드의 활성 컨텍스트를 with-문 진입 시 ctx*의 복사본으로 설정하고, `with`-문 종료 시 이전 컨텍스트를 복원하는 컨텍스트 관리자를 반환합니다. 컨텍스트가 지정되지 않으면 현재 컨텍스트의 복사본을 사용합니다. *kwargs 인수는 새 컨텍스트의 속성을 설정하는 데 사용됩니다.

예를 들어, 다음 코드는 현재 십진 정밀도를 42자리로 설정하고, 계산을 수행한 다음, 이전 컨텍스트를 자동으로 복원합니다:

from decimal import localcontext

with localcontext() as ctx:
    ctx.prec = 42   # 고정밀도 계산 수행
    s = calculate_something()
s = +s  # 최종 결과를 기본 정밀도로 반올림

키워드 인수를 사용하면 코드는 다음과 같습니다:

from decimal import localcontext

with localcontext(prec=42) as ctx:
    s = calculate_something()
s = +s

kwargs 가 Context 가 지원하지 않는 속성을 제공할 경우 TypeError 가 발생합니다. kwargs 가 속성에 유효하지 않은 값을 제공할 경우 TypeError 또는 ValueError 중 하나가 발생합니다.

버전 3.11에서 변경: :meth:`localcontext`는 이제 키워드 인수를 사용하여 컨텍스트 속성을 설정하는 것을 지원합니다.

decimal.IEEEContext(bits)¶: IEEE 상호 교환 형식 중 하나의 적절한 값으로 초기화된 컨텍스트 객체를 반환합니다. 인수는 32의 배수여야 하며 :const:`IEEE_CONTEXT_MAX_BITS`보다 작아야 합니다.

Added in version 3.14.

아래에 설명된 Context 생성자를 사용하여 새로운 컨텍스트를 만들 수도 있습니다. 또한, 이 모듈은 세 가지 미리 만들어진 컨텍스트를 제공합니다:

decimal.BasicContext¶

이것은 일반 십진 산술 명세에서 정의된 표준 컨텍스트입니다. 정밀도는 9로 설정됩니다. 자리 올림은 ROUND_HALF_UP으로 설정됩니다. 모든 플래그가 지워집니다. 모든 트랩은 Inexact, Rounded, Subnormal을 제외하고는 활성화됩니다 (예외로 처리됩니다).

많은 트랩이 활성화되었으므로, 이 컨텍스트는 디버깅에 유용합니다.

decimal.ExtendedContext¶

이것은 일반 십진 산술 명세에서 정의된 표준 컨텍스트입니다. 정밀도는 9로 설정됩니다. 자리 올림은 ROUND_HALF_EVEN으로 설정됩니다. 모든 플래그가 지워집니다. 아무 트랩도 활성화되지 않습니다 (그래서 계산 중에 예외가 발생하지 않습니다).

트랩이 비활성화되었기 때문에, 이 컨텍스트는 예외를 발생시키는 대신 NaN 또는 Infinity 의 결과 값을 선호하는 애플리케이션에 유용합니다. 이를 통해 애플리케이션은 그렇지 않으면 프로그램 실행을 중지시킬 수 있는 조건이 존재하는 상황에서도 실행을 완료할 수 있습니다.

decimal.DefaultContext¶

이 컨텍스트는 새로운 컨텍스트의 프로토타입으로 Context 생성자에 의해 사용됩니다. 필드(가령 정밀도)를 변경하면 Context 생성자에 의해 생성된 새로운 컨텍스트에 대한 기본값을 변경하는 효과가 있습니다.

이 컨텍스트는 다중 스레드 환경에서 가장 유용합니다. 스레드가 시작되기 전에 필드 중 하나를 변경하면 시스템 전체의 기본값을 설정하는 효과가 있습니다. 스레드가 시작된 후에 필드를 변경하는 것은. 스레드 동기화를 통해 경쟁 조건을 방지해야 하므로 권장되지 않습니다.

단일 스레드 환경에서는, 이 컨텍스트를 아예 사용하지 않는 것이 좋습니다. 대신, 아래에 설명된 대로 명시적으로 컨텍스트를 만드십시오.

기본값은 Context.prec=28, Context.rounding=ROUND_HALF_EVEN`이며, :class:`Overflow, InvalidOperation, 및 :class:`DivisionByZero`에 대한 활성화된 트랩입니다.

3개의 제공된 컨텍스트 외에도, 새로운 컨텍스트를 Context 생성자를 사용하여 만들 수 있습니다.

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

새로운 컨텍스트를 만듭니다. 필드가 지정되지 않았거나 None 이면, 기본값은 DefaultContext 에서 복사됩니다. flags 필드가 지정되지 않았거나 None 이면, 모든 플래그가 지워집니다.

prec¶: 컨텍스트에서 산술 연산의 정밀도를 설정하는 [1, MAX_PREC] 범위의 정수입니다.

rounding¶: Rounding Modes 섹션에 나열된 상수 중 하나입니다.

traps¶
flags¶: 설정할 모든 신호 목록입니다. 일반적으로 새 컨텍스트는 트랩만 설정하고 플래그는 비워야 합니다.

Emin¶
Emax¶: 지수에 허용되는 외부 한계를 지정하는 정수입니다. Emin 은 [MIN_EMIN, 0] 범위에 있어야 하고, Emax 는 [0, MAX_EMAX] 범위에 있어야 합니다.

capitals¶: 0 또는 1``(기본값)입니다. ``1``로 설정하면 지수는 대문자 ``E``와 함께 출력되고, 그렇지 않으면 소문자 ``e``를 사용합니다. 예: ``Decimal('6.02e+23')

clamp¶

0 (기본값) 또는 1 입니다. 1 로 설정하면, 이 컨텍스트에서 표현 가능한 Decimal 인스턴스의 지수 e 는 Emin - prec + 1 <= e <= Emax - prec + 1 범위로 엄격하게 제한됩니다. clamp 가 0 이면 약한 조건이 적용됩니다. 즉, Decimal 인스턴스의 조정된 지수는 Emax 를 초과하지 않습니다. clamp 가 1 이면, 가능하다면 큰 일반 숫자는 지수를 줄이고 계수에 해당 개수의 0을 추가하여 지수 제약 조건에 맞게 됩니다. 이렇게 하면 숫자의 값은 보존되지만, 중요한 후행 0에 대한 정보는 손실됩니다. 예를 들면:

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

clamp 값이 1 이면 IEEE 754에서 지정한 고정 너비의 십진 교환 형식과 호환됩니다.

Context 클래스는 여러 일반 목적 메서드와 주어진 컨텍스트에서 산술 연산을 수행하기 위한 많은 수의 메서드를 정의합니다. 추가로, 위의 Decimal 메서드 각각에 대해 (adjusted() 와 as_tuple() 메서드를 제외하고) 해당하는 Context 메서드가 있습니다. 예를 들어, Context 인스턴스 C 와 Decimal 인스턴스 x 의 경우, C.exp(x) 는 x.exp(context=C) 와 동일합니다. 각 Context 메서드는 Decimal 인스턴스가 허용되는 곳이라면 어디든 파이썬 정수( int 의 인스턴스)를 받습니다.

clear_flags()¶: 모든 플래그를 0 으로 재설정합니다.

clear_traps()¶: 모든 트랩을 0 으로 재설정합니다.

Added in version 3.3.

copy()¶: 컨텍스트의 복사본을 돌려줍니다.

copy_decimal(num, /)¶: Decimal 인스턴스 num의 복사본을 반환합니다.

create_decimal(num='0', /)¶

self 를 컨텍스트로 사용해서, num 으로 새 Decimal 인스턴스를 만듭니다. Decimal 생성자와 달리, 컨텍스트 정밀도, 자리 올림 방법, 플래그 및 트랩이 변환에 적용됩니다.

이는 상수가 보통 응용 프로그램에 필요한 것보다 더 큰 정밀도로 제공되기 때문에 유용합니다. 또 다른 이점은 자리 올림이 현재 정밀도를 초과하는 자릿수로 인한 의도하지 않은 결과를 즉시 제거한다는 것입니다. 다음 예제에서, 자리 올림 되지 않은 입력을 사용한다는 것은 합계에 0을 추가하면 결과가 달라질 수 있음을 의미합니다.:

>>> getcontext().prec = 3
>>> Decimal('3.4445') + Decimal('1.0023')
Decimal('4.45')
>>> Decimal('3.4445') + Decimal(0) + Decimal('1.0023')
Decimal('4.44')

이 메서드는 IBM 명세의 to-number 연산을 구현합니다. 인자가 문자열이면, 선행 또는 후행 공백이나 밑줄이 허용되지 않습니다.

create_decimal_from_float(f, /)¶

float f 로 새 Decimal 인스턴스를 만들지만, self 를 컨텍스트로 사용하여 자리 올림 합니다. Decimal.from_float() 클래스 메서드와는 달리, 컨텍스트 정밀도, 자리 올림 방법, 플래그 및 트랩이 변환에 적용됩니다.

>>> 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

Added in version 3.1.

Etiny()¶: 비정상 결과에 대한 최소 지수 값인 Emin - prec + 1 과 같은 값을 반환합니다. 언더 플로우가 발생하면, 지수는 Etiny 로 설정됩니다.

Etop()¶: Emax - prec + 1 과 같은 값을 반환합니다.

십진수로 작업하는 일반적인 접근법은 Decimal 인스턴스를 생성한 다음 활성 스레드의 현재 컨텍스트 내에서 진행되는 산술 연산을 적용하는 것입니다. 다른 방법은 특정 컨텍스트 내에서 계산하기 위해 컨텍스트 메서드를 사용하는 것입니다. 메서드는 Decimal 클래스의 메서드와 비슷하며 여기에서는 간단히 설명합니다.

abs(x, /)¶: x 의 절댓값을 돌려줍니다.

add(x, y, /)¶: x 와 y 의 합을 돌려줍니다.

canonical(x, /)¶: 같은 Decimal 객체 x 를 반환합니다.

compare(x, y, /)¶: x 와 y 를 수치로 비교합니다.

compare_signal(x, y, /)¶: 두 피연산자의 값을 수치로 비교합니다.

compare_total(x, y, /)¶: 추상 표현을 사용하여 두 피연산자를 비교합니다.

compare_total_mag(x, y, /)¶: 부호를 무시하고, 추상 표현을 사용하여 두 피연산자를 비교합니다.

copy_abs(x, /)¶: 부호가 0으로 설정되어있는 x 의 복사본을 돌려줍니다.

copy_negate(x, /)¶: 부호가 반전된 x 복사본을 반환합니다.

copy_sign(x, y, /)¶: y 에서 x 로 부호를 복사합니다.

divide(x, y, /)¶: x 를 y 로 나눈 값을 반환합니다.

divide_int(x, y, /)¶: x 를 y 로 나눈 후 정수로 잘라낸 값을 반환합니다.

divmod(x, y, /)¶: 두 숫자를 나누고 결과의 정수 부분을 반환합니다.

exp(x, /)¶: e ** x 를 반환합니다.

fma(x, y, z, /)¶: x 에 y 를 곱한 후 z 를 더한 값을 반환합니다.

is_canonical(x, /)¶: x 가 규범적일 경우 True를 반환합니다; 그렇지 않으면 False를 반환합니다.

is_finite(x, /)¶: x 가 유한이면 True를 반환합니다; 그렇지 않으면 False를 반환합니다.

is_infinite(x, /)¶: x 가 무한대면 True를 반환합니다; 그렇지 않으면 False를 반환합니다.

is_nan(x, /)¶: x 가 qNaN 이나 sNaN 이면 True를 반환합니다; 그렇지 않으면 False를 반환합니다.

is_normal(x, /)¶: x 가 정상 수면 True를 반환합니다; 그렇지 않으면 False를 반환합니다.

is_qnan(x, /)¶: x 가 조용한 NaN이면 True를 반환합니다; 그렇지 않으면 False를 반환합니다.

is_signed(x, /)¶: x 가 음수면 True를 반환합니다; 그렇지 않으면 False를 반환합니다.

is_snan(x, /)¶: x 가 신호를 주는 NaN 이면 True를 반환합니다; 그렇지 않으면 False를 반환합니다.

is_subnormal(x, /)¶: x 가 비정상이면 True를 반환합니다; 그렇지 않으면 False를 반환합니다.

is_zero(x, /)¶: x 가 0이면 True를 반환합니다; 그렇지 않으면 False를 반환합니다.

ln(x, /)¶: x 의 자연로그(밑 e)를 반환합니다.

log10(x, /)¶: x 의 상용로그를 반환합니다.

logb(x, /)¶: 피연산자의 최상위 유효 숫자의 크기의 지수를 반환합니다.

logical_and(x, y, /)¶: 각 피연산자의 자릿수별로 논리적 연산 and 를 적용합니다.

logical_invert(x, /)¶: x 의 모든 자릿수를 반전합니다.

logical_or(x, y, /)¶: 각 피연산자의 자릿수별로 논리적 연산 or 를 적용합니다.

logical_xor(x, y, /)¶: 각 피연산자의 자릿수별로 논리적 연산 xor 를 적용합니다.

max(x, y, /)¶: 두 값을 수치로 비교해, 최댓값을 돌려줍니다.

max_mag(x, y, /)¶: 부호를 무시하고 값을 수치로 비교합니다.

min(x, y, /)¶: 두 값을 수치로 비교해, 최솟값을 돌려줍니다.

min_mag(x, y, /)¶: 부호를 무시하고 값을 수치로 비교합니다.

minus(x, /)¶: minus는 파이썬에서 단항 접두사 빼기 연산자에 해당합니다.

multiply(x, y, /)¶: x 와 y 의 곱을 반환합니다.

next_minus(x, /)¶: x 보다 작고 표현 가능한 가장 큰 수를 반환합니다.

next_plus(x, /)¶: x 보다 크고 표현 가능한 가장 작은 수를 반환합니다.

next_toward(x, y, /)¶: y 방향으로 x 에 가장 가까운 숫자를 반환합니다.

normalize(x, /)¶: x 를 가장 간단한 형태로 환원합니다.

number_class(x, /)¶: x 의 클래스를 가리키는 문자열을 돌려줍니다.

plus(x, /)¶: plus는 파이썬에서 단항 접두사 더하기 연산자에 해당합니다. 이 연산은 컨텍스트 정밀도와 자리 올림을 적용하므로 항등 연산이 아닙니다.

power(x, y, modulo=None)¶

x 의 y 거듭제곱을 돌려줍니다. 주어지면 modulo 모듈로로 환원합니다.

두 개의 인수를 사용하여 x**y 를 계산합니다. x 가 음수이면 y 는 정수여야 합니다. y 가 정수이고 결과가 유한하며 ‘precision’ 자릿수에서 정확하게 표현될 수 없는 한 결과는 부정확할 수 있습니다. 컨텍스트의 자리 올림 모드가 사용됩니다. 결과는 파이썬 버전에서 항상 올바르게 반올림됩니다.

Decimal(0) ** Decimal(0)은 InvalidOperation이 되며, InvalidOperation가 트랩 되지 않으면, Decimal('NaN')이 됩니다.

버전 3.3에서 변경: C 모듈은 power`를 올바르게 반올림된 :meth:`exp() 및 ln() 함수의 측면에서 계산합니다. 결과는 잘 정의되어 있지만, “거의 항상 올바르게 반올림됩니다”.

세 인자로는 (x**y) % modulo 를 계산합니다. 세 인자 형식의 경우, 인자에 다음과 같은 제한이 있습니다:

세 인자는 모두 정수여야 합니다.
y 는 음수가 아니어야 합니다.
x 나 y 중 적어도 하나는 0이 아니어야 합니다
modulo 는 0이 아니고 최대 ‘precision’ 자릿수를 가져야 합니다

Context.power(x, y, modulo) 의 결괏값은 무한 정밀도로 (x**y) % modulo 를 계산할 때 얻을 수 있는 값과 같지만, 더 효율적으로 계산됩니다. 결과의 지수는 x, y 및 modulo 의 지수와 관계없이 0입니다. 결과는 항상 정확합니다.

quantize(x, y, /)¶: y 의 지수를 가지는 (자리 올림 된) x 와 같은 값을 반환합니다.

radix()¶: Decimal이기 때문에 단지 10을 반환합니다, :)

remainder(x, y, /)¶

정수 나눗셈의 나머지를 반환합니다.

결과가 0이 아닐 때, 결과의 부호는 원래의 피제수와 같습니다.

remainder_near(x, y, /)¶: x - y * n 을 반환하는데, n 은 x / y 의 정확한 값에 가장 가까운 정수입니다 (결과가 0이면 그 부호는 x 의 부호가 됩니다).

rotate(x, y, /)¶: x 를 y 번 회전한 복사본을 반환합니다.

same_quantum(x, y, /)¶: 두 피연산자의 지수가 같으면 True를 반환합니다.

scaleb(x, y, /)¶: 첫 번째 피연산자의 지수에 두 번째 값을 더해서 반환합니다.

shift(x, y, /)¶: x 를 y 번 이동한 복사본을 반환합니다.

sqrt(x, /)¶: 음이 아닌 수의 제곱근을 컨텍스트의 정밀도로 반환합니다.

subtract(x, y, /)¶: x 와 y 의 차를 돌려줍니다.

to_eng_string(x, /)¶

문자열로 변환합니다. 지수가 필요하면 공학 표기법을 사용합니다.

공학 표기법의 지수는 3의 배수입니다. 이렇게 하면 소수점 왼쪽에 최대 3자리를 남기게 되고, 하나나 두 개의 후행 0을 추가해야 할 수 있습니다.

to_integral_exact(x, /)¶: 정수로 자리 올림 합니다.

to_sci_string(x, /)¶: 과학 표기법을 사용하여 숫자를 문자열로 변환합니다.

상수¶

decimal.SPEC_VERSION¶: 이 구현이 준수하는 일반 십진 산술 명세의 최고 버전입니다. 명세는 https://speleotrove.com/decimal/decarith.html를 참조하십시오.

Added in version 3.15.

다음 상수는 C 모듈에만 관련됩니다. 호환성을 위해 순수 파이썬 버전에도 포함됩니다.

	32-비트	64-비트
decimal.MAX_PREC¶	`425000000`	`999999999999999999`
decimal.MAX_EMAX¶	`425000000`	`999999999999999999`
decimal.MIN_EMIN¶	`-425000000`	`-999999999999999999`
decimal.MIN_ETINY¶	`-849999999`	`-1999999999999999997`
decimal.IEEE_CONTEXT_MAX_BITS¶	`256`	`512`

decimal.HAVE_THREADS¶: 값은 True입니다. 이제 파이썬에는 항상 스레드가 있기 때문에, 폐지되었습니다.

버전 3.9부터 폐지됨.

decimal.HAVE_CONTEXTVAR¶: 기본값은 True 입니다. 만약 파이썬이 --without-decimal-contextvar 옵션을 사용하여 구성된 경우, C 버전은 코루틴 로컬 대신 스레드 로컬 컨텍스트를 사용하며 값은 False 입니다. 이는 일부 중첩 컨텍스트 시나리오에서 약간 더 빠릅니다.

Added in version 3.8.3.

자리 올림 모드¶

decimal.ROUND_CEILING¶: Infinity 방향으로 반올림합니다.

decimal.ROUND_DOWN¶: 0을 향해 자리 올림 합니다.

decimal.ROUND_FLOOR¶: -Infinity 방향으로 반올림합니다.

decimal.ROUND_HALF_DOWN¶: 가장 가까운 값으로 반올림하고, 동률이면 0에서 가까운 것을 선택합니다.

decimal.ROUND_HALF_EVEN¶: 가장 가까운 값으로 반올림하고, 동률이면 짝수를 선택합니다.

decimal.ROUND_HALF_UP¶: 가장 가까운 값으로 반올림하고, 동률이면 0에서 먼 것을 선택합니다.

decimal.ROUND_UP¶: 0에서 먼 쪽으로 자리 올림 합니다.

decimal.ROUND_05UP¶: 0을 향해 자리 올림 했을 때 마지막 숫자가 0이나 5면 0에서 먼 쪽으로 자리 올림 합니다. 그렇지 않으면 0을 향해 자리 올림 합니다.

신호¶

신호는 계산 중 발생하는 조건을 나타냅니다. 각각은 하나의 컨텍스트 플래그와 하나의 컨텍스트 트랩 활성화기에 대응합니다.

컨텍스트 플래그는 조건이 발생할 때마다 설정됩니다. 계산 후에, 플래그는 정보를 얻기 위한 목적으로 확인될 수 있습니다 (예를 들어, 계산이 정확한지를 판별하기 위해). 플래그를 확인한 후 다음 계산을 시작하기 전에 모든 플래그를 지우십시오.

컨텍스트의 트랩 활성화기가 신호에 대해 설정되면, 조건은 파이썬 예외를 일으킵니다. 예를 들어, DivisionByZero 트랩이 설정되면, 이 조건을 만날 때 DivisionByZero 예외가 발생합니다.

class decimal.Clamped¶

표현 제약 조건에 맞도록 지수를 변경했습니다.

일반적으로, 클램핑은 지수가 컨텍스트의 Emin 및 Emax 한계를 벗어날 때 발생합니다. 가능하다면, 계수에 0을 추가하여 지수를 맞도록 줄입니다.

class decimal.DecimalException¶: 다른 신호의 베이스 클래스이고 ArithmeticError 의 서브 클래스입니다.

class decimal.DivisionByZero¶

무한대가 아닌 숫자를 0으로 나눴다는 신호를 줍니다.

나눗셈, 모듈로 나눗셈 또는 숫자를 음의 거듭제곱으로 올릴 때 발생할 수 있습니다. 이 신호가 트랩되지 않으면 계산에 사용된 입력 값에 의해 결정되는 부호를 가진 Infinity 또는 -Infinity 를 반환합니다.

class decimal.Inexact¶

자리 올림이 발생했고 결과가 정확하지 않음을 나타냅니다.

자리 올림 도중 0이 아닌 숫자가 삭제된 경우 신호를 줍니다. 자리 올림 된 결과가 반환됩니다. 신호 플래그나 트랩은 결과가 정확하지 않을 때를 감지하는 데 사용됩니다.

class decimal.InvalidOperation¶

유효하지 않은 연산이 수행되었습니다.

의미가 없는 연산이 요청되었음을 나타냅니다. 트랩되지 않으면 NaN 을 반환합니다. 가능한 원인으로는 다음이 포함됩니다:

Infinity - Infinity
0 * Infinity
Infinity / Infinity
x % 0
Infinity % x
sqrt(-x) and x > 0
0 ** 0
x ** (non-integer)
x ** Infinity

class decimal.Overflow¶

수치적 오버플로.

반올림이 발생한 후 지수가 Context.Emax 보다 큰 경우를 나타냅니다. 트랩되지 않으면, 결과는 반올림 모드에 따라 가장 크게 표현 가능한 유한한 숫자로 당겨지거나 Infinity 로 안쪽으로 반올림됩니다. 어느 경우든, Inexact 와 Rounded 도 신호됩니다.

class decimal.Rounded¶

정보가 손실되지는 않았지만 자리 올림이 발생했습니다.

반올림 과정에서 숫자가 버려질 때마다 신호됩니다. 이 숫자가 0인 경우(예: 5.00 을 5.0 으로 반올림하는 경우)에도 마찬가지입니다. 트랩되지 않으면, 변경되지 않은 결과를 반환합니다. 이 신호는 유효 숫자의 손실을 감지하는 데 사용됩니다.

class decimal.Subnormal¶

반올림 이전에 지수가 :attr:`~Context.Emin`보다 낮았습니다.

연산 결과가 비정상(지수가 너무 작음)일 때 발생합니다. 트랩 되지 않으면, 결과를 그대로 반환합니다.

class decimal.Underflow¶

결과가 0으로 자리 올림 되는 수치적 언더플로.

자리 올림에 의해 비정상 결과가 0으로 밀릴 때 발생합니다. Inexact와 Subnormal 신호도 줍니다.

class decimal.FloatOperation¶

float와 Decimal을 혼합하는 데 더 엄격한 의미를 사용합니다.

신호가 트랩되지 않으면 (기본값), Decimal 생성자, create_decimal() 및 모든 비교 연산자에서 float와 Decimal을 혼합 할 수 있습니다. 변환과 비교 모두 정확합니다. 복합 연산의 발생은 컨텍스트 플래그에 FloatOperation 을 설정하여 조용히 기록됩니다. from_float() 나 create_decimal_from_float() 를 사용한 명시적 변환은 플래그를 설정하지 않습니다.

그렇지 않으면 (신호가 트랩되면), 같음 비교와 명시적 변환만 조용히 수행됩니다. 다른 모든 혼합된 연산은 FloatOperation 을 발생시킵니다.

다음 표는 신호의 계층 구조를 요약한 것입니다:

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)

부동 소수점 참고 사항¶

증가시킨 정밀도로 자리 올림 오차 줄이기¶

십진 부동 소수점의 사용은 십진 표현 오류를 제거하고 (0.1 을 정확하게 표현 가능), 그러나 일부 연산에는 여전히 0이 아닌 숫자가 고정 정밀도를 초과할 때 반올림 오류가 발생할 수 있습니다.

반올림 오차의 영향은 거의 상쇄되는 양의 덧셈이나 뺄셈을 통해 증폭되어 유효 숫자 손실을 초래할 수 있습니다. Knuth는 부정확한 정밀도로 반올림된 부동 소수점 산술이 덧셈의 결합법칙과 분배법칙이 붕괴되는 두 가지 교육적인 예시를 제시합니다:

# 정수 계산 알고리즘 예제, 섹션 4.2.2.
>>> from decimal import Decimal, 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 모듈의 숫자 체계는 NaN, sNaN, -Infinity, Infinity 및 두 개의 영(zero)인 +0 과 -0 을 포함한 특수 값을 제공합니다.

무한대는 다음과 같이 직접 생성될 수 있습니다: Decimal('Infinity'). 또한, DivisionByZero 신호가 트랩 되지 않을 때 0으로 나눠서 발생할 수 있습니다. 마찬가지로, Overflow 신호가 트랩 되지 않을 때, 무한대는 표현 가능한 가장 큰 수의 한계를 넘어서 자리 올림 된 결과가 될 수 있습니다.

무한대는 부호가 있고 (아핀) 산술 연산에 사용될 수 있는데, 매우 크고 불확정적(indeterminate)인 숫자로 취급됩니다. 예를 들어, 무한대에 상수를 더하면 또 다른 무한대를 줍니다.

일부 연산은 부정하여 NaN 을 반환하거나, InvalidOperation 신호를 처리하면 예외를 발생시킵니다. 예를 들어, 0/0 은 “숫자가 아님”을 의미하는 NaN 을 반환합니다. 이 종류의 NaN 은 조용(quiet)하며, 생성된 후 다른 계산을 거치면서 항상 또 다른 NaN 을 결과로 초래합니다. 이러한 동작은 간헐적으로 누락된 입력값을 갖는 일련의 계산에 유용할 수 있습니다. 이는 특정 결과를 유효하지 않다고 표시하면서 계산을 진행할 수 있도록 합니다.

변형은 sNaN 이며, 모든 연산 후에 조용하게 유지되기보다는 신호를 보냅니다. 이는 잘못된 결과가 특별한 처리를 위해 계산을 중단해야 할 때 유용한 반환 값입니다.

The behavior of Python’s comparison operators can be a little surprising where a NaN is involved. A test for equality where one of the operands is a quiet or signaling NaN always returns False (even when doing Decimal('NaN')==Decimal('NaN')), while a test for inequality always returns True. An attempt to compare two Decimals using any of the <, <=, > or >= operators will raise the InvalidOperation signal if either operand is a NaN, and return 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 NaN were taken from the IEEE 854 standard (see Table 3 in section 5.7). To ensure strict standards-compliance, use the compare() and compare_signal() methods instead.

부호 있는 0은 언더플로 하는 계산의 결과일 수 있습니다. 계산을 더 정밀하게 수행한다면 얻게 될 결과의 기호를 유지합니다. 크기가 0이기 때문에, 양과 음의 0은 같다고 취급되며 부호는 정보 용입니다.

명확히 다르지만 동일한 두 개의 부호 있는 0 외에도, 정밀도는 다르지만 값이 동등한 다양한 영의 표현이 있습니다. 이는 적응하는 데 시간이 걸릴 수 있습니다. 정규화된 부동 소수점 표현에 익숙한 눈에는 다음 계산이 0과 같은 값을 반환한다는 것이 즉시 명백하지 않습니다:

>>> 1 / Decimal('Infinity')
Decimal('0E-1000026')

스레드로 작업하기¶

getcontext() 함수는 스레드마다 다른 Context 객체에 접근합니다. 별도의 스레드 컨텍스트를 갖는다는 것은 스레드가 다른 스레드를 방해하지 않고 변경할 수 있음을 의미합니다 (가령 getcontext().prec=10).

마찬가지로, setcontext() 함수는 자동으로 대상을 현재 스레드에 할당합니다.

getcontext`가 :func:`setcontext() 호출 이전에 호출되지 않았다면, getcontext`는 현재 스레드에서 사용하기 위해 새로운 컨텍스트를 자동으로 생성합니다. 새로운 컨텍스트 객체는 :data:`decimal.DefaultContext() 객체에서 기본값을 설정받습니다.

sys.flags.thread_inherit_context 플래그는 새 스레드의 컨텍스트에 영향을 미칩니다. 플래그가 false인 경우, 새 스레드는 빈 컨텍스트로 시작합니다. 이 경우, getcontext`는 호출될 때 새로운 컨텍스트 객체를 생성하고 *DefaultContext*의 기본값을 사용합니다. 플래그가 true인 경우, 새 스레드는 :meth:`threading.Thread.start() 호출자의 컨텍스트 사본으로 시작합니다.

각 스레드가 애플리케이션 전반에 걸쳐 동일한 값을 사용하도록 기본값을 제어하려면 DefaultContext 객체를 직접 수정해야 합니다. 이는 스레드들이 :func:`getcontext`를 호출하는 사이에 경쟁 조건(race condition)이 발생하지 않도록 어떠한 스레드가 시작되기도 전에 수행해야 합니다. 예를 들어:

# 시작할 모든 스레드에 대한 애플리케이션 전반의 기본값을 설정합니다
DefaultContext.prec = 12
DefaultContext.rounding = ROUND_DOWN
DefaultContext.traps = ExtendedContext.traps.copy()
DefaultContext.traps[InvalidOperation] = 1
setcontext(DefaultContext)

# 그 후에 스레드를 시작할 수 있습니다
t1.start()
t2.start()
t3.start()
 . . .

조리법¶

다음은 유틸리티 함수로 사용되고 Decimal 클래스로 작업하는 방법을 보여주는 몇 가지 조리법입니다:

def moneyfmt(value, places=2, curr='', sep=',', dp='.',
             pos='', neg='-', trailneg=''):
    """Decimal을 금액 형식의 문자열로 변환합니다.

    places:  소수점 뒤의 필수 자릿수
    curr:    부호 앞의 선택적 통화 기호 (공백일 수 있음)
    sep:     선택적 그룹화 구분 기호 (쉼표, 마침표, 공백 또는 빈칸)
    dp:      소수점 표시기 (쉼표 또는 마침표)
             places가 0인 경우에만 빈칸으로 지정하십시오
    pos:     양수에 대한 선택적 부호: '+', 공백 또는 빈칸
    neg:     음수에 대한 선택적 부호: '-', '(', 공백 또는 빈칸
    trailneg:선택적인 뒤따르는 마이너스 표시기: '-', ')', 공백 또는 빈칸

    >>> 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자릿수 --> '0.01'
    sign, digits, exp = value.quantize(q).as_tuple()
    result = []
    digits = list(map(str, digits))
    build, next = result.append, digits.pop
    if sign:
        build(trailneg)
    for i in range(places):
        build(next() if digits else '0')
    if places:
        build(dp)
    if not digits:
        build('0')
    i = 0
    while digits:
        build(next())
        i += 1
        if i == 3 and digits:
            i = 0
            build(sep)
    build(curr)
    build(neg if sign else pos)
    return ''.join(reversed(result))

def pi():
    """현재 정밀도로 원주율(Pi)을 계산합니다.

    >>> print(pi())
    3.141592653589793238462643383

    """
    getcontext().prec += 2  # 중간 단계를 위한 추가 자릿수
    three = Decimal(3)      # 일반 부동 소수점의 경우 "three=3.0"으로 대체
    lasts, t, s, n, na, d, da = 0, three, 3, 1, 0, 0, 24
    while s != 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               # 단항 플러스는 새로운 정밀도를 적용함

def exp(x):
    """x의 거듭제곱으로 거듭제곱된 e를 반환합니다. 결과 유형은 입력 유형과 일치합니다.

    >>> 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
    while s != lasts:
        lasts = s
        i += 1
        fact *= i
        num *= x
        s += num / fact
    getcontext().prec -= 2
    return +s

def cos(x):
    """라디안으로 측정된 x의 코사인을 반환합니다.

    테일러 급수 근사법은 x의 작은 값에 대해 가장 잘 작동합니다.
    더 큰 값의 경우, 먼저 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
    while s != lasts:
        lasts = s
        i += 2
        fact *= i * (i-1)
        num *= x * x
        sign *= -1
        s += num / fact * sign
    getcontext().prec -= 2
    return +s

def sin(x):
    """라디안으로 측정된 x의 사인을 반환합니다.

    테일러 급수 근사법은 x의 작은 값에 대해 가장 잘 작동합니다.
    더 큰 값의 경우, 먼저 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
    while s != 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: 일부 사용자는 생성자를 단일 문자로 축약합니다:

>>> D = decimal.Decimal
>>> D('1.23') + D('3.45')
Decimal('4.68')

Q: 소수점 두 자리를 가진 고정 소수점 응용 프로그램에서, 일부 입력은 자릿수가 많아 반올림이 필요합니다. 다른 입력은 과도한 자릿수가 없어야 하며 유효성 검사가 필요합니다. 어떤 메서드를 사용해야 하나요?

A: quantize() 메서드는 고정된 소수점 자릿수로 반올림합니다. 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: 유효한 두 자리 입력 값을 얻었다면, 응용 프로그램 전체에서 해당 불변성을 어떻게 유지할 수 있나요?

A: 덧셈, 뺄셈, 그리고 정수를 이용한 곱셈과 같은 일부 연산은 고정 소수점을 자동으로 유지합니다. 그러나 나눗셈이나 비정수 곱셈과 같은 다른 연산은 소수점 자릿수를 변경하므로, 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')

고정 소수점 응용 프로그램을 개발할 때, quantize() 단계를 처리하기 위한 함수를 정의하는 것이 편리합니다:

>>> def mul(x, y, fp=TWOPLACES):
...     return (x * y).quantize(fp)
...
>>> def div(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: 같은 값을 표현하는 방법이 많이 있습니다. 200, 200.000, 2E2, .02E+4 는 다양한 정밀도에서 모두 같은 값을 가집니다. 이들을 하나의 인식 가능한 표준 값으로 변환하는 방법이 있나요?

A: normalize() 메서드는 모든 등가 값을 단일 대표값으로 매핑합니다:

>>> values = map(Decimal, '200 200.000 2E2 .02E+4'.split())
>>> [v.normalize() for v in values]
[Decimal('2E+2'), Decimal('2E+2'), Decimal('2E+2'), Decimal('2E+2')]

Q: 계산에서 반올림은 언제 발생하나요?

A: 계산 후 에 발생합니다. 십진수 사양의 철학은 숫자가 정확한 것으로 간주되며 현재 컨텍스트와 독립적으로 생성된다는 것입니다. 심지어 현재 컨텍스트보다 높은 정밀도를 가질 수도 있습니다. 계산은 이러한 정확한 입력 값으로 처리되며, 그런 다음 반올림(또는 다른 컨텍스트 연산)이 계산의 결과 에 적용됩니다:

>>> getcontext().prec = 5
>>> pi = Decimal('3.1415926535')   # 5자리보다 많은 자릿수
>>> pi                             # 모든 자릿수가 유지됩니다
Decimal('3.1415926535')
>>> pi + 0                         # 덧셈 후 반올림됩니다
Decimal('3.1416')
>>> pi - Decimal('0.00005')        # 반올림되지 않은 숫자를 뺀 후 반올림
Decimal('3.1415')
>>> pi + 0 - Decimal('0.00005').   # 중간 값은 반올림됩니다
Decimal('3.1416')

Q: 일부 십진수 값은 항상 지수 표기법으로 출력됩니다. 지수가 아닌 표현을 얻는 방법이 있나요?

A: 일부 값의 경우, 지수 표기법만이 계수의 유효 자릿수를 표현할 수 있는 유일한 방법입니다. 예를 들어, 5.0E+3 를 5000 으로 표현하면 값이 일정하게 유지되지만 원래의 두 자리 유효 숫자를 보여줄 수는 없습니다.

응용 프로그램이 유효 숫자를 추적하는 데 신경 쓰지 않으면, 지수 및 후행 0을 제거하고 유효숫자를 잃지만, 값이 바뀌지 않도록 하기는 쉽습니다:

>>> def remove_exponent(d):
...     return d.quantize(Decimal(1)) if d == d.to_integral() else d.normalize()

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

Q: 일반 float를 :class:`Decimal`로 변환하는 방법이 있습니까?

A: 예, 모든 이진 부동 소수점 숫자는 Decimal로 정확하게 표현될 수 있습니다. 비록 정확한 변환이 직관보다 더 많은 정밀도를 필요로 할 수 있습니다:

>>> Decimal(math.pi)
Decimal('3.141592653589793115997963468544185161590576171875')

Q: 복잡한 계산 과정에서, 정밀도 부족이나 반올림 이상으로 인해 부정확한(spurious) 결과를 얻지 않았는지 어떻게 확인할 수 있나요?

A: decimal 모듈은 결과를 테스트하기 쉽게 만듭니다. 가장 좋은 방법은 더 높은 정밀도와 다양한 자리 올림 모드를 사용하여 계산을 다시 실행하는 것입니다. 크게 차이가 나는 결과는 정밀도 부족, 자리 올림 모드 문제, 불량한 입력 조건, 또는 수치적으로 불안정한 알고리즘을 나타냅니다.

Q: 컨텍스트 정밀도가 연산의 결과에 적용되고 입력값에는 적용되지 않는 것을 확인했습니다. 다른 정밀도의 값을 혼합할 때 주의해야 할 점이 있나요?

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:

>>> getcontext().prec = 3
>>> Decimal('3.104') + Decimal('2.104')
Decimal('5.21')
>>> Decimal('3.104') + Decimal('0.000') + Decimal('2.104')
Decimal('5.20')

해법은 정밀도를 높이거나 단항 플러스 연산을 사용하여 입력의 자리 올림을 강제 수행하는 것입니다:

>>> getcontext().prec = 3
>>> +Decimal('1.23456789')      # 단항 플러스는 반올림을 유발합니다.
Decimal('1.23')

다른 방법으로, 입력은 Context.create_decimal() 메서드를 사용하여 생성 시에 자리 올림 될 수 있습니다:

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

Q: Is the CPython implementation fast for large numbers?

A: 네. CPython 및 PyPy3 구현에서는, 십진 모듈의 C/CFFI 버전이 임의 정밀도를 갖춘 올바르게 반올림된 십진 부동 소수점 산술을 위해 고속의 libmpdec 라이브러리를 정확하게 통합합니다 [1]. libmpdec 는 중간 크기 숫자에는 Karatsuba_ multiplication 을, 매우 큰 숫자에는 Number Theoretic Transform 을 사용합니다.

컨텍스트는 정확한 임의 정밀도 산술을 위해 조정되어야 합니다. :attr:`~Context.Emin`과 :attr:`~Context.Emax`는 항상 최대값으로 설정해야 하며, :attr:`~Context.clamp`는 항상 0(기본값)이어야 합니다. :attr:`~Context.prec`을 설정하는 것은 주의가 필요합니다.

가장 쉽게 큰 수 산술을 시험해 보는 방법은 :attr:`~Context.prec`에 최대값을 사용하는 것입니다 [2]:

>>> setcontext(Context(prec=MAX_PREC, Emax=MAX_EMAX, Emin=MIN_EMIN))
>>> x = Decimal(2) ** 256
>>> x / 128
Decimal('904625697166532776746648320380374280103671755200316906558262375061821325312')

불정확한 결과의 경우, :const:`MAX_PREC`은 64비트 플랫폼에서는 너무 크고 사용 가능한 메모리가 충분하지 않을 수 있습니다:

>>> Decimal(1) / 3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
MemoryError

오버 할당(예: Linux)이 있는 시스템에서는 사용 가능한 RAM 양에 맞게 :attr:`~Context.prec`을 조정하는 것이 더 정교한 접근 방식입니다. 8GB의 RAM이 있고 각 연산자에 최대 500MB씩, 동시에 10개의 피연산자를 예상한다고 가정해 봅시다:

>>> import sys
>>>
>>> # 8바이트 워드당 500MB를 사용하여 단일 피연산자에 사용할 수 있는 최대 자릿수
>>> # 워드당 19개의 자릿수 (32비트 빌드의 경우 4바이트와 9자릿수):
>>> maxdigits = 19 * ((500 * 1024**2) // 8)
>>>
>>> # 이것이 작동하는지 확인:
>>> c = Context(prec=maxdigits, Emax=MAX_EMAX, Emin=MIN_EMIN)
>>> c.traps[Inexact] = True
>>> setcontext(c)
>>>
>>> # 사용 가능한 정밀도를 9로 채우기:
>>> x = Decimal(0).logical_invert() * 9
>>> sys.getsizeof(x)
524288112
>>> x + 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  decimal.Inexact: [<class 'decimal.Inexact'>]

일반적으로 (그리고 특히 초과 할당이 없는 시스템에서), 더 엄격한 경계를 추정하고 모든 계산이 정확할 것으로 예상되면 Inexact 트랩을 설정하는 것이 좋습니다.

decimal — 십진수 고정 소수점 및 부동 소수점 산술¶

빠른 시작 자습서¶

Decimal 객체¶

논리적 피연산자¶

Context 객체¶

상수¶

자리 올림 모드¶

신호¶

부동 소수점 참고 사항¶

증가시킨 정밀도로 자리 올림 오차 줄이기¶

특수 값¶

스레드로 작업하기¶

조리법¶

Decimal FAQ¶

`decimal` — 십진수 고정 소수점 및 부동 소수점 산술¶