# Chuyển đổi ký hiệu khoa học thành python thập phân

Mô-đun

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
4 cung cấp hỗ trợ cho số học dấu phẩy động thập phân được làm tròn chính xác nhanh chóng. Nó cung cấp một số lợi thế so với kiểu dữ liệu
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
6

• 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

• Decimal numbers can be represented exactly. In contrast, numbers like

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
7 and
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
8 do not have exact representations in binary floating point. End users typically would not expect
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
9 to display as
```>>> 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')
```
0 as it does with binary floating point

• The exactness carries over into arithmetic. Trong dấu phẩy động thập phân,

```>>> 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')
```
1 chính xác bằng 0. In binary floating point, the result is
```>>> 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')
```
2. 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

• The decimal module incorporates a notion of significant places so that

```>>> 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')
```
3 is
```>>> 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')
```
4. Số 0 ở cuối được giữ để biểu thị tầm quan trọng. This is the customary presentation for monetary applications. For multiplication, the “schoolbook” approach uses all the figures in the multiplicands. For instance,
```>>> 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')
```
5 gives
```>>> 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')
```
6 while
```>>> 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')
```
7 gives
```>>> 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')
```
8

• 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

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
4

• 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

• 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

The module design is centered around three concepts. the decimal number, the context for arithmetic, and signals

A decimal number is immutable. Nó có dấu, chữ số hệ số và số mũ. To preserve significance, the coefficient digits do not truncate trailing zeros. Decimals also include special values such as

```>>> 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')
```
9,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
60, and
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
61. The standard also differentiates
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
62 from
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
63

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

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
64,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
65,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
66,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
67,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
68,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
69,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
60, and
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
61

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.

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
62,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
63,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
64,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
65,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
66,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
67,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
68,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
69 and
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
60

Đối với mỗi tín hiệu, có một cờ và trình kích hoạt bẫy. 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

• IBM’s General Decimal Arithmetic Specification, The General Decimal Arithmetic Specification

## Quick-start Tutorial¶

The usual start to using decimals is importing the module, viewing the current context with

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
61 and, if necessary, setting new values for precision, rounding, or enabled traps

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
8

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

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
61 which stands for “Not a number”, positive and negative
```>>> 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')
```
9, and
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
62

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
2

If the

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
60 signal is trapped, accidental mixing of decimals and floats in constructors or ordering comparisons raises an exception

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
4

New in version 3. 3

Tầm quan trọng của Số thập phân mới chỉ được xác định bởi số lượng chữ số đầu vào. Độ chính xác của ngữ cảnh và làm tròn chỉ phát huy tác dụng trong các phép toán số học

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
5

Nếu vượt quá giới hạn nội bộ của phiên bản C, việc xây dựng số thập phân sẽ tăng

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
63

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```

Thay đổi trong phiên bản 3. 3

Số thập phân tương tác tốt với phần lớn phần còn lại của Python. Đây là một rạp xiếc bay dấu phẩy động thập phân nhỏ

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

Và một số hàm toán học cũng có sẵn cho Số thập phân

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
6

Phương thức

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
67 làm tròn một số thành số mũ cố định. Phương pháp này hữu ích cho các ứng dụng tiền tệ thường làm tròn kết quả đến một số vị trí cố định

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
6

Như được hiển thị ở trên, hàm

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
61 truy cập ngữ cảnh hiện tại và cho phép thay đổi cài đặt. Cách tiếp cận này đáp ứng nhu cầu của hầu hết các ứng dụng

Đối với công việc nâng cao hơn, có thể hữu ích khi tạo các ngữ cảnh thay thế bằng cách sử dụng hàm tạo Context(). Để thực hiện thay thế hoạt động, hãy sử dụng chức năng

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
69

Theo tiêu chuẩn, mô-đun

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
4 cung cấp hai bối cảnh tiêu chuẩn sẵn sàng sử dụng,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
801 và
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
802. Cái trước đặc biệt hữu ích để gỡ lỗi vì nhiều bẫy được bật

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
6

Bối cảnh cũng có cờ tín hiệu để theo dõi các điều kiện đặc biệt gặp phải trong quá trình tính toán. Các cờ vẫn được đặt cho đến khi bị xóa rõ ràng, vì vậy tốt nhất là xóa các cờ trước mỗi bộ tính toán được giám sát bằng cách sử dụng phương pháp

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
803

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
80

Mục cờ cho thấy giá trị gần đúng hợp lý của

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
804 đã được làm tròn (các chữ số nằm ngoài độ chính xác của ngữ cảnh đã bị loại bỏ) và kết quả là không chính xác (một số chữ số bị loại bỏ khác 0)

Các bẫy riêng lẻ được đặt bằng cách sử dụng từ điển trong trường

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
805 của ngữ cảnh

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
81

Hầu hết các chương trình chỉ điều chỉnh bối cảnh hiện tại một lần, khi bắt đầu chương trình. Và, trong nhiều ứng dụng, dữ liệu được chuyển đổi thành

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
806 với một lần truyền bên trong một vòng lặp. Với tập ngữ cảnh và số thập phân được tạo, phần lớn chương trình thao tác dữ liệu không khác gì với các loại số Python khác

## Đối tượng thập phân¶

lớp thập phân. Số thập phân(giá trị=', context=None)

Xây dựng một đối tượng

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
806 mới dựa trên giá trị

giá trị có thể là một số nguyên, chuỗi, tuple,

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
6 hoặc một đối tượng
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
806 khác. Nếu không có giá trị nào được đưa ra, trả về
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
810. Nếu giá trị là một chuỗi, thì giá trị đó phải tuân theo cú pháp chuỗi số thập phân sau khi các ký tự khoảng trắng ở đầu và cuối, cũng như dấu gạch dưới trong suốt, được xóa

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
82

Các chữ số thập phân Unicode khác cũng được cho phép khi

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
811 xuất hiện ở trên. Chúng bao gồm các chữ số thập phân từ nhiều bảng chữ cái khác (ví dụ: chữ số Ả Rập-Ấn Độ và chữ số Devanāgarī) cùng với các chữ số có độ rộng đầy đủ từ
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
812 đến
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
813

Nếu giá trị là một

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
814, nó phải có ba thành phần, một dấu (
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
815 cho số dương hoặc
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
816 cho số âm), một
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
814 chữ số và một số mũ nguyên. Ví dụ:
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
818 trả về
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
819

Nếu giá trị là một

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
6, thì giá trị dấu phẩy động nhị phân được chuyển đổi dễ dàng thành số thập phân tương đương chính xác của nó. Chuyển đổi này thường có thể yêu cầu độ chính xác từ 53 chữ số trở lên. Ví dụ:
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
821 chuyển đổi thành
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
822

Độ chính xác của ngữ cảnh không ảnh hưởng đến số lượng chữ số được lưu trữ. Điều đó được xác định độc quyền bởi số chữ số trong giá trị. Ví dụ:

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
823 ghi lại tất cả năm số không ngay cả khi độ chính xác của ngữ cảnh chỉ là ba

Mục đích của đối số ngữ cảnh là xác định phải làm gì nếu giá trị là một chuỗi không đúng định dạng. Nếu bối cảnh bẫy

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
63, một ngoại lệ sẽ được nêu ra;

Sau khi được xây dựng, các đối tượng

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
806 là bất biến

Đã thay đổi trong phiên bản 3. 2. Đối số của hàm tạo hiện được phép là một thể hiện của

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
6.

Đã thay đổi trong phiên bản 3. 3. ______06 đối số đưa ra một ngoại lệ nếu bẫy

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
60 được đặt. Theo mặc định bẫy tắt.

Đã thay đổi trong phiên bản 3. 6. Dấu gạch dưới được cho phép để nhóm, như với các ký tự dấu phẩy động và tích phân trong mã.

Các đối tượng dấu phẩy động thập phân chia sẻ nhiều thuộc tính với các kiểu số dựng sẵn khác, chẳng hạn như

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
6 và
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
831. Tất cả các phép toán thông thường và các phương pháp đặc biệt được áp dụng. Tương tự như vậy, các đối tượng thập phân có thể được sao chép, chọn, in, sử dụng làm khóa từ điển, được sử dụng làm phần tử tập hợp, so sánh, sắp xếp và ép buộc sang loại khác (chẳng hạn như
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
6 hoặc
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
831)

Có một số khác biệt nhỏ giữa số học trên các đối tượng thập phân và số học trên số nguyên và số float. Khi toán tử còn lại

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
834 được áp dụng cho các đối tượng Số thập phân, dấu của kết quả là dấu của số bị chia chứ không phải là dấu của số chia

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
83

Toán tử chia số nguyên

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
835 hoạt động tương tự, trả về phần nguyên của thương số thực (cắt ngắn về 0) thay vì giá trị sàn của nó, để giữ nguyên giá trị thông thường
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
836

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
84

Các toán tử

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
834 và
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
835 thực hiện các phép toán
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
839 và
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
840 (tương ứng) như được mô tả trong đặc tả

Các đối tượng thập phân thường không thể được kết hợp với số float hoặc thể hiện của

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
841 trong các phép toán số học. một nỗ lực để thêm một
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
806 vào một
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
6, chẳng hạn, sẽ tăng một
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
844. Tuy nhiên, có thể sử dụng các toán tử so sánh của Python để so sánh một thể hiện
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
806
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
846 với một số khác
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
847. Điều này tránh kết quả khó hiểu khi thực hiện so sánh bình đẳng giữa các số loại khác nhau

Đã thay đổi trong phiên bản 3. 2. So sánh kiểu hỗn hợp giữa các phiên bản

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
806 và các kiểu số khác hiện đã được hỗ trợ đầy đủ.

Ngoài các thuộc tính số tiêu chuẩn, các đối tượng dấu phẩy động thập phân còn có một số phương thức chuyên biệt

đã điều chỉnh()

Trả về số mũ đã điều chỉnh sau khi dịch chuyển các chữ số ngoài cùng bên phải của hệ số cho đến khi chỉ còn lại chữ số dẫn đầu.

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
849 trả về bảy. Được sử dụng để xác định vị trí của chữ số có nghĩa nhất đối với dấu thập phân

as_integer_ratio()

Trả về một cặp số nguyên

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
850 đại diện cho thể hiện
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
806 đã cho dưới dạng phân số, theo số hạng thấp nhất và có mẫu số dương

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
85

Việc chuyển đổi là chính xác. Tăng OverflowError trên vô số và ValueError trên NaN

Mới trong phiên bản 3. 6

as_tuple()

Trả về một bộ có tên đại diện cho số.

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
852.

chính tắc()

Trả lại mã hóa chính tắc của đối số. Hiện tại, mã hóa của phiên bản

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
806 luôn là chuẩn, vì vậy thao tác này trả về đối số của nó không thay đổi

so sánh(khác , bối cảnh=None)

So sánh các giá trị của hai trường hợp thập phân.

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
854 trả về một thể hiện Số thập phân và nếu một trong hai toán hạng là NaN thì kết quả là NaN

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
86

so sánh_signal(khác , bối cảnh=None)

Thao tác này giống với phương pháp

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
854, ngoại trừ việc tất cả các tín hiệu NaN. Nghĩa là, nếu không có toán hạng nào là NaN báo hiệu thì bất kỳ toán hạng NaN yên tĩnh nào cũng được coi như thể đó là NaN báo hiệu

so_total(khác , bối cảnh=None)

So sánh hai toán hạng bằng cách sử dụng biểu diễn trừu tượng của chúng thay vì giá trị số của chúng. Tương tự như phương pháp

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
854, nhưng kết quả cho tổng thứ tự trên các phiên bản
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
806. Hai trường hợp
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
806 có cùng giá trị số nhưng cách biểu diễn khác nhau so sánh không bằng nhau theo thứ tự này

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
87

NaN yên tĩnh và báo hiệu cũng được bao gồm trong tổng số thứ tự. Kết quả của hàm này là

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
810 nếu cả hai toán hạng có cùng biểu diễn,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
860 nếu toán hạng đầu tiên có tổng thứ tự thấp hơn toán hạng thứ hai và
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
861 nếu toán hạng thứ nhất có tổng thứ tự cao hơn toán hạng thứ hai. Xem thông số kỹ thuật để biết chi tiết về tổng số đơn đặt hàng

Hoạt động này không bị ảnh hưởng bởi ngữ cảnh và yên tĩnh. không có cờ nào được thay đổi và không có phép làm tròn nào được thực hiện. Là một ngoại lệ, phiên bản C có thể tăng InvalidOperation nếu toán hạng thứ hai không thể được chuyển đổi chính xác

so sánh_total_mag(khác , bối cảnh=None)

So sánh hai toán hạng bằng cách sử dụng biểu diễn trừu tượng thay vì giá trị của chúng như trong

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
862, nhưng bỏ qua dấu của từng toán hạng.
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
863 tương đương với
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
864

Hoạt động này không bị ảnh hưởng bởi ngữ cảnh và yên tĩnh. không có cờ nào được thay đổi và không có phép làm tròn nào được thực hiện. Là một ngoại lệ, phiên bản C có thể tăng InvalidOperation nếu toán hạng thứ hai không thể được chuyển đổi chính xác

liên hợp()

Chỉ trả về self, phương thức này chỉ tuân theo Đặc tả thập phân

copy_abs()

Trả về giá trị tuyệt đối của đối số. Hoạt động này không bị ảnh hưởng bởi bối cảnh và yên tĩnh. không có cờ nào được thay đổi và không có phép làm tròn nào được thực hiện

copy_negate()

Trả về phủ định của đối số. Hoạt động này không bị ảnh hưởng bởi bối cảnh và yên tĩnh. không có cờ nào được thay đổi và không có phép làm tròn nào được thực hiện

copy_sign(khác , bối cảnh=None)

Trả về một bản sao của toán hạng thứ nhất với dấu được đặt giống với dấu của toán hạng thứ hai. Ví dụ

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
88

Hoạt động này không bị ảnh hưởng bởi ngữ cảnh và yên tĩnh. không có cờ nào được thay đổi và không có phép làm tròn nào được thực hiện. Là một ngoại lệ, phiên bản C có thể tăng InvalidOperation nếu toán hạng thứ hai không thể được chuyển đổi chính xác

exp(bối cảnh=Không có)

Trả về giá trị của hàm số mũ (tự nhiên)

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
865 tại số đã cho. Kết quả được làm tròn chính xác bằng cách sử dụng chế độ làm tròn
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
68

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
89

classmethod from_float(f)

Hàm tạo thay thế chỉ chấp nhận các phiên bản của

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
6 hoặc
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
831

Lưu ý

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
869 không giống với
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
870. kể từ 0. 1 không thể biểu diễn chính xác trong dấu phẩy động nhị phân, giá trị được lưu dưới dạng giá trị biểu diễn gần nhất là
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
871. Giá trị tương đương ở dạng thập phân là
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
872

Ghi chú

Từ Python 3. 2 trở đi, một phiên bản

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
806 cũng có thể được xây dựng trực tiếp từ một phiên bản
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
6

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
20

Mới trong phiên bản 3. 1

fma(khác , thứ ba, context=None)

Hợp nhất nhân-thêm. Trả về self*other+thứ ba mà không làm tròn sản phẩm trung gian self*other

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
21

is_canonical()

Trả về

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
875 nếu đối số là hợp quy và ngược lại là
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
876. Hiện tại, một phiên bản
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
806 luôn là hợp quy, vì vậy thao tác này luôn trả về
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
875

is_finite()

Trả về

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
875 nếu đối số là một số hữu hạn và
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
876 nếu đối số là vô hạn hoặc NaN

is_infinite()

Trả về

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
875 nếu đối số là vô cực dương hoặc âm và ngược lại là
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
876

is_nan()

Trả về

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
875 nếu đối số là NaN (im lặng hoặc có tín hiệu) và ngược lại là
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
876

is_normal(bối cảnh=Không có)

Trả về

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
875 nếu đối số là một số hữu hạn bình thường. Trả về
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
876 nếu đối số bằng 0, không bình thường, vô hạn hoặc NaN

is_qnan()

Trả về

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
875 nếu đối số là NaN yên tĩnh và ngược lại là
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
876

is_signed()

Trả về

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
875 nếu đối số có dấu âm và ngược lại là
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
876. Lưu ý rằng cả số không và NaN đều có thể mang dấu

is_snan()

Trả về

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
875 nếu đối số là NaN báo hiệu và ngược lại là
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
876

is_subnormal(bối cảnh=Không có)

Trả về

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
875 nếu đối số không bình thường và ngược lại là
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
876

is_zero()

Trả về

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
875 nếu đối số là số 0 (dương hoặc âm) và ngược lại là
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
876

ln(bối cảnh=Không có)

Trả về logarit tự nhiên (cơ số e) của toán hạng. Kết quả được làm tròn chính xác bằng cách sử dụng chế độ làm tròn

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
68

log10(bối cảnh=Không có)

Trả về logarit cơ số 10 của toán hạng. Kết quả được làm tròn chính xác bằng cách sử dụng chế độ làm tròn

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
68

logb(bối cảnh=Không có)

Đối với một số khác 0, hãy trả về số mũ đã điều chỉnh của toán hạng của nó dưới dạng phiên bản

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
806. Nếu toán hạng là số 0 thì hàm
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
200 được trả về và cờ
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
64 được nâng lên. Nếu toán hạng là vô cùng thì trả về
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
202

logic_and(khác , bối cảnh=None)

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
203 là một phép toán logic nhận hai toán hạng logic (xem Toán hạng logic ). Kết quả là
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
204 chữ số khôn ngoan của hai toán hạng.

logic_invert(bối cảnh=Không có)

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
205 là một hoạt động hợp lý. Kết quả là nghịch đảo chữ số của toán hạng

logic_or(khác , bối cảnh=None)

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
206 là một phép toán logic nhận hai toán hạng logic (xem Toán hạng logic ). Kết quả là
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
207 chữ số khôn ngoan của hai toán hạng.

logic_xor(khác , bối cảnh=None)

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
208 là một phép toán logic nhận hai toán hạng logic (xem Toán hạng logic ). Kết quả là loại trừ chữ số hoặc của hai toán hạng.

tối đa(khác , bối cảnh=None)

Giống như

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
209 ngoại trừ quy tắc làm tròn ngữ cảnh được áp dụng trước khi trả về và các giá trị
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
61 được báo hiệu hoặc bỏ qua (tùy thuộc vào ngữ cảnh và liệu chúng có báo hiệu hay không)

max_mag(khác , bối cảnh=None)

Tương tự như phương pháp

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
211, nhưng việc so sánh được thực hiện bằng cách sử dụng các giá trị tuyệt đối của toán hạng

phút(khác , bối cảnh=None)

Giống như

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
212 ngoại trừ quy tắc làm tròn ngữ cảnh được áp dụng trước khi trả về và các giá trị
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
61 được báo hiệu hoặc bỏ qua (tùy thuộc vào ngữ cảnh và liệu chúng có báo hiệu hay không)

min_mag(khác , bối cảnh=None)

Tương tự như phương pháp

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
214, nhưng việc so sánh được thực hiện bằng cách sử dụng các giá trị tuyệt đối của toán hạng

next_minus(bối cảnh=Không có)

Trả về số lớn nhất có thể biểu thị trong ngữ cảnh đã cho (hoặc trong ngữ cảnh của luồng hiện tại nếu không có ngữ cảnh nào được cung cấp) nhỏ hơn toán hạng đã cho

next_plus(bối cảnh=Không có)

Trả về số nhỏ nhất có thể biểu diễn trong ngữ cảnh đã cho (hoặc trong ngữ cảnh của luồng hiện tại nếu không có ngữ cảnh nào được cung cấp) lớn hơn toán hạng đã cho

next_toward(khác , bối cảnh=None)

Nếu hai toán hạng không bằng nhau, hãy trả về số gần toán hạng thứ nhất theo hướng của toán hạng thứ hai. Nếu cả hai toán hạng đều bằng nhau về số lượng, hãy trả về một bản sao của toán hạng đầu tiên với dấu được đặt giống với dấu của toán hạng thứ hai

chuẩn hóa(bối cảnh=Không có)

Chuẩn hóa số bằng cách loại bỏ các số 0 ở cuối bên phải và chuyển đổi bất kỳ kết quả nào bằng

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
810 thành
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
216. Được sử dụng để tạo ra các giá trị chuẩn cho các thuộc tính của một lớp tương đương. Ví dụ:
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
217 và
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
218 đều chuẩn hóa thành giá trị tương đương
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
219

số_lớp(bối cảnh=Không có)

Trả về một chuỗi mô tả lớp của toán hạng. Giá trị trả về là một trong mười chuỗi sau

• ```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
220, chỉ ra rằng toán hạng là vô cực âm

• ```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
221, chỉ ra rằng toán hạng là một số bình thường âm

• ```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
222, chỉ ra rằng toán hạng là âm và không bình thường

• ```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
223, cho biết toán hạng là số 0 âm

• ```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
224, cho biết toán hạng là số 0 dương

• ```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
225, chỉ ra rằng toán hạng là dương và không bình thường

• ```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
226, chỉ ra rằng toán hạng là một số bình thường dương

• ```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
227, chỉ ra rằng toán hạng là dương vô cùng

• ```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
228, chỉ ra rằng toán hạng là một NaN yên tĩnh (Không phải là một số)

• ```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
229, chỉ ra rằng toán hạng là một NaN báo hiệu

số lượng hóa(exp , làm tròn=None, context=None)

Trả về một giá trị bằng toán hạng đầu tiên sau khi làm tròn và có số mũ của toán hạng thứ hai

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
22

Không giống như các thao tác khác, nếu độ dài của hệ số sau thao tác lượng tử hóa lớn hơn độ chính xác, thì một

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
63 được báo hiệu. Điều này đảm bảo rằng, trừ khi có điều kiện lỗi, số mũ được lượng tử hóa luôn bằng số mũ của toán hạng bên phải

Ngoài ra, không giống như các hoạt động khác, lượng tử hóa không bao giờ báo hiệu Underflow, ngay cả khi kết quả là không bình thường và không chính xác

Nếu số mũ của toán hạng thứ hai lớn hơn số mũ của toán hạng thứ nhất thì có thể cần phải làm tròn. Trong trường hợp này, chế độ làm tròn được xác định bởi đối số

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
231 nếu được đưa ra, nếu không thì bởi đối số
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
232 đã cho;

Một lỗi được trả về bất cứ khi nào số mũ kết quả lớn hơn

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
233 hoặc nhỏ hơn
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
234

cơ số()

Trả về

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
235, cơ số (cơ số) trong đó lớp
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
806 thực hiện tất cả các phép tính số học của nó. Bao gồm để tương thích với đặc điểm kỹ thuật

remainder_near(khác , bối cảnh=None)

Trả lại phần còn lại từ việc chia bản thân cho người khác. Điều này khác với

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
237 ở chỗ dấu của phần dư được chọn để giảm thiểu giá trị tuyệt đối của nó. Chính xác hơn, giá trị trả về là
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
238 trong đó
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
239 là số nguyên gần nhất với giá trị chính xác của
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
240 và nếu hai số nguyên gần bằng nhau thì số chẵn được chọn

Nếu kết quả bằng không thì dấu của nó sẽ là dấu của tự

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
23

xoay(khác , bối cảnh=None)

Trả về kết quả của việc xoay các chữ số của toán hạng thứ nhất theo một lượng được chỉ định bởi toán hạng thứ hai. Toán hạng thứ hai phải là một số nguyên trong phạm vi -precision đến precision. Giá trị tuyệt đối của toán hạng thứ hai cho biết số vị trí cần xoay. Nếu toán hạng thứ hai là dương thì phép quay sang trái; . Hệ số của toán hạng đầu tiên được đệm ở bên trái với độ chính xác từ 0 đến độ dài nếu cần. Dấu và số mũ của toán hạng đầu tiên không thay đổi

same_quantum(other , bối cảnh=None)

Kiểm tra xem bản thân và người khác có cùng số mũ hay cả hai đều

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
61

Hoạt động này không bị ảnh hưởng bởi ngữ cảnh và yên tĩnh. không có cờ nào được thay đổi và không có phép làm tròn nào được thực hiện. Là một ngoại lệ, phiên bản C có thể tăng InvalidOperation nếu toán hạng thứ hai không thể được chuyển đổi chính xác

scaleb(khác , bối cảnh=None)

Trả về toán hạng đầu tiên với số mũ được điều chỉnh bởi toán hạng thứ hai. Tương tự, trả về toán hạng đầu tiên nhân với

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
242. Toán hạng thứ hai phải là một số nguyên

chuyển(khác , bối cảnh=None)

Trả về kết quả của việc dịch chuyển các chữ số của toán hạng thứ nhất theo một lượng được chỉ định bởi toán hạng thứ hai. Toán hạng thứ hai phải là một số nguyên trong phạm vi -precision đến precision. Giá trị tuyệt đối của toán hạng thứ hai cho biết số lượng vị trí cần dịch chuyển. Nếu toán hạng thứ hai là số dương thì phép dịch chuyển sang trái; . Các chữ số được chuyển vào hệ số là số không. Dấu và số mũ của toán hạng đầu tiên không thay đổi

sqrt(bối cảnh=Không có)

Trả lại căn bậc hai của đối số về độ chính xác đầy đủ

to_eng_string(bối cảnh=Không có)

Chuyển đổi thành chuỗi, sử dụng ký hiệu kỹ thuật nếu cần số mũ

Ký hiệu kỹ thuật có số mũ là bội số của 3. Điều này có thể để lại tối đa 3 chữ số ở bên trái của vị trí thập phân và có thể yêu cầu thêm một hoặc hai số 0 ở cuối

Ví dụ: điều này chuyển đổi

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
243 thành
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
244

to_integral(làm tròn=Không có, context=None)

Giống với phương pháp

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
245. Tên
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
246 đã được giữ để tương thích với các phiên bản cũ hơn

to_integral_exact(làm tròn=Không có, context=None)

Làm tròn đến số nguyên gần nhất, báo hiệu

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
65 hoặc
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
66 nếu thích hợp nếu làm tròn xảy ra. Chế độ làm tròn được xác định bởi tham số
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
231 nếu được cung cấp, nếu không thì bởi
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
232 đã cho. Nếu không có tham số nào được cung cấp thì chế độ làm tròn của ngữ cảnh hiện tại được sử dụng

to_integral_value(làm tròn=Không có, context=None)

Làm tròn đến số nguyên gần nhất mà không báo hiệu

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
65 hoặc
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
66. Nếu được đưa ra, áp dụng làm tròn;

### Toán hạng logic¶

Các phương thức

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
203,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
205,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
206 và
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
208 mong muốn các đối số của chúng là toán hạng logic. Toán hạng logic là một thực thể
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
806 có số mũ và dấu đều bằng 0 và có tất cả các chữ số là
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
815 hoặc
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
816

## Đối tượng ngữ cảnh¶

Bối cảnh là môi trường cho các hoạt động số học. Chúng chi phối độ chính xác, đặt quy tắc làm tròn, xác định tín hiệu nào được coi là ngoại lệ và giới hạn phạm vi cho số mũ

Mỗi luồng có bối cảnh hiện tại riêng được truy cập hoặc thay đổi bằng cách sử dụng các hàm

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
61 và
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
69

thập phân. getcontext()

Trả về bối cảnh hiện tại cho chuỗi hoạt động

thập phân. setcontext(c)

Đặt bối cảnh hiện tại cho chuỗi hoạt động thành c

Bạn cũng có thể sử dụng câu lệnh

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
262 và hàm
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
263 để tạm thời thay đổi ngữ cảnh hoạt động

thập phân. localcontext(ctx=None , \*\*kwargs)

Trả về trình quản lý ngữ cảnh sẽ đặt ngữ cảnh hiện tại cho luồng đang hoạt động thành một bản sao của ctx khi vào câu lệnh with và khôi phục ngữ cảnh trước đó khi thoát khỏi câu lệnh with. Nếu không có ngữ cảnh nào được chỉ định, một bản sao của ngữ cảnh hiện tại sẽ được sử dụng. Đối số kwargs được sử dụng để đặt các thuộc tính của ngữ cảnh mới

Ví dụ: đoạn mã sau đặt độ chính xác thập phân hiện tại thành 42 vị trí, thực hiện phép tính và sau đó tự động khôi phục ngữ cảnh trước đó

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
24

Sử dụng các đối số từ khóa, mã sẽ như sau

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
25

Tăng

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
844 nếu kwargs cung cấp một thuộc tính mà
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
265 không hỗ trợ. Tăng
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
844 hoặc
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
267 nếu kwargs cung cấp giá trị không hợp lệ cho một thuộc tính

Đã thay đổi trong phiên bản 3. 11. ______4263 hiện hỗ trợ đặt thuộc tính ngữ cảnh thông qua việc sử dụng đối số từ khóa.

Các bối cảnh mới cũng có thể được tạo bằng hàm tạo

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
265 được mô tả bên dưới. In addition, the module provides three pre-made contexts

lớp thập phân. Bối cảnh cơ bản

Đây là ngữ cảnh tiêu chuẩn được xác định bởi Đặc tả số học thập phân chung. Độ chính xác được đặt thành chín. Rounding is set to

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
69. All flags are cleared. Tất cả các bẫy được bật (được coi là ngoại lệ) ngoại trừ
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
65,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
66 và
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
67

Do nhiều bẫy được bật nên bối cảnh này rất hữu ích để gỡ lỗi

lớp thập phân. Ngữ cảnh mở rộng

Đây là ngữ cảnh tiêu chuẩn được xác định bởi Đặc tả số học thập phân chung. Độ chính xác được đặt thành chín. Làm tròn được đặt thành

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
68. All flags are cleared. No traps are enabled (so that exceptions are not raised during computations)

Bởi vì các bẫy bị vô hiệu hóa, bối cảnh này hữu ích cho các ứng dụng muốn có giá trị kết quả là

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
61 hoặc
```>>> 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')
```
9 thay vì đưa ra các ngoại lệ. Điều này cho phép một ứng dụng hoàn thành một lần chạy khi có các điều kiện có thể làm dừng chương trình

lớp thập phân. Ngữ cảnh mặc định

Bối cảnh này được sử dụng bởi hàm tạo

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
265 làm nguyên mẫu cho các bối cảnh mới. Thay đổi một trường (độ chính xác như vậy) có tác dụng thay đổi mặc định cho các ngữ cảnh mới được tạo bởi hàm tạo
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
265

Bối cảnh này hữu ích nhất trong môi trường đa luồng. Thay đổi một trong các trường trước khi chuỗi bắt đầu có tác dụng đặt giá trị mặc định trên toàn hệ thống. Không nên thay đổi các trường sau khi các luồng đã bắt đầu vì nó sẽ yêu cầu đồng bộ hóa luồng để ngăn các điều kiện tương tranh

Trong các môi trường luồng đơn, tốt nhất là không sử dụng ngữ cảnh này. Thay vào đó, chỉ cần tạo bối cảnh một cách rõ ràng như được mô tả bên dưới

Các giá trị mặc định là

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
279=
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
280,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
231=
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
68 và bật bẫy cho
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
68,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
63 và
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
64

Ngoài ba ngữ cảnh được cung cấp, các ngữ cảnh mới có thể được tạo bằng hàm tạo

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
265

lớp thập phân. Bối cảnh(prec=Không có, rounding=None, Emin=None, Emax=None, capitals=None, clamp=None, flags=None, traps=None)

Tạo bối cảnh mới. Nếu một trường không được chỉ định hoặc là

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
287, các giá trị mặc định sẽ được sao chép từ
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
288. Nếu trường cờ không được chỉ định hoặc là
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
287, tất cả các cờ sẽ bị xóa

prec là một số nguyên trong phạm vi [

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
816,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
291] đặt độ chính xác cho các phép tính số học trong ngữ cảnh

Tùy chọn làm tròn là một trong những hằng số được liệt kê trong phần Chế độ làm tròn

Các trường bẫy và cờ liệt kê mọi tín hiệu sẽ được đặt. Nói chung, bối cảnh mới chỉ nên đặt bẫy và để trống cờ

Các trường Emin và Emax là các số nguyên xác định các giới hạn bên ngoài cho phép đối với số mũ. Emin phải nằm trong khoảng [

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
292,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
815], Emax trong khoảng [
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
815,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
295]

Trường chữ hoa là

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
815 hoặc
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
816 (mặc định). Nếu được đặt thành
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
816, số mũ được in bằng chữ hoa
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
299; .
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
401

Trường kẹp là

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
815 (mặc định) hoặc
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
816. Nếu được đặt thành
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
816, số mũ
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
400 của phiên bản
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
806 có thể biểu thị trong ngữ cảnh này bị giới hạn nghiêm ngặt trong phạm vi
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
407. If clamp is
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
815 then a weaker condition holds. số mũ đã điều chỉnh của phiên bản
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
806 nhiều nhất là
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
233. Khi clamp là
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
816, một số bình thường lớn, nếu có thể, sẽ bị giảm số mũ và một số 0 tương ứng được thêm vào hệ số của nó, để phù hợp với các ràng buộc về số mũ; . Ví dụ

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
26

Giá trị kẹp của

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
816 cho phép tương thích với các định dạng trao đổi thập phân có chiều rộng cố định được chỉ định trong IEEE 754

Lớp

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
265 định nghĩa một số phương thức có mục đích chung cũng như một số lượng lớn các phương thức để thực hiện số học trực tiếp trong một ngữ cảnh nhất định. In addition, for each of the
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
806 methods described above (with the exception of the
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
415 and
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
416 methods) there is a corresponding
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
265 method. Ví dụ: đối với phiên bản
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
265
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
419 và
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
806 phiên bản
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
846,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
422 tương đương với
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
423. Mỗi phương thức
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
265 chấp nhận một số nguyên Python (một thể hiện của
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
831) ở bất kỳ đâu mà một thể hiện Số thập phân được chấp nhận

clear_flags()

Đặt lại tất cả các cờ thành

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
815

clear_traps()

Đặt lại tất cả các bẫy thành

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
815

New in version 3. 3

copy()

Trả lại một bản sao của ngữ cảnh

copy_decimal(num)

Trả về một bản sao của ví dụ thập phân num

create_decimal(num)

Tạo một thể hiện Thập phân mới từ num nhưng sử dụng self làm ngữ cảnh. Không giống như hàm tạo

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
806, độ chính xác của ngữ cảnh, phương pháp làm tròn, cờ và bẫy được áp dụng cho chuyển đổi

Điều này rất hữu ích vì các hằng số thường được cung cấp cho độ chính xác cao hơn mức cần thiết của ứng dụng. Một lợi ích khác là làm tròn ngay lập tức loại bỏ các hiệu ứng ngoài ý muốn từ các chữ số vượt quá độ chính xác hiện tại. Trong ví dụ sau, sử dụng đầu vào không được làm tròn có nghĩa là việc thêm 0 vào tổng có thể thay đổi kết quả

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
27

Phương pháp này thực hiện thao tác đánh số của đặc tả IBM. Nếu đối số là một chuỗi, không được phép có khoảng trắng ở đầu hoặc cuối hoặc dấu gạch dưới

create_decimal_from_float(f)

Tạo một thể hiện Thập phân mới từ một float f nhưng làm tròn bằng cách sử dụng self làm ngữ cảnh. Không giống như phương pháp lớp

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
429, độ chính xác ngữ cảnh, phương pháp làm tròn, cờ và bẫy được áp dụng cho chuyển đổi

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
28

Mới trong phiên bản 3. 1

Etiny()

Trả về giá trị bằng

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
430 là giá trị số mũ tối thiểu cho kết quả không bình thường. Khi xảy ra tràn, số mũ được đặt thành
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
234

Etop()

Trả về một giá trị bằng

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
432

Cách tiếp cận thông thường để làm việc với số thập phân là tạo các phiên bản

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
806 và sau đó áp dụng các phép toán số học diễn ra trong ngữ cảnh hiện tại cho chuỗi hoạt động. Một cách tiếp cận khác là sử dụng các phương thức ngữ cảnh để tính toán trong một ngữ cảnh cụ thể. Các phương thức tương tự như các phương thức dành cho lớp
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
806 và chỉ được kể lại ngắn gọn ở đây

abs(x)

Returns the absolute value of x

Trả về tổng của x và y

chính tắc(x)

Trả về cùng một đối tượng thập phân x

so sánh(x , y)

So sánh x và y bằng số

so sánh_signal(x , y)

So sánh các giá trị của hai toán hạng bằng số

so_total(x , y)

So sánh hai toán hạng bằng biểu diễn trừu tượng của chúng

so_total_mag(x , y)

So sánh hai toán hạng bằng biểu diễn trừu tượng của chúng, bỏ qua dấu

copy_abs(x)

Trả về một bản sao của x với dấu được đặt thành 0

copy_negate(x)

Trả về một bản sao của x với dấu đảo ngược

copy_sign(x , y)

Sao chép dấu từ y đến x

chia(x , y)

Trả về x chia cho y

divide_int(x , y)

Trả về x chia cho y, rút ​​gọn thành một số nguyên

divmod(x , y)

Chia hai số và trả về phần nguyên của kết quả

exp(x)

Trả về

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
435

fma(x , y, z)

Trả về x nhân với y, cộng với z

is_canonical(x)

Trả về

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
875 nếu x là chính tắc;

is_finite(x)

Trả về

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
875 nếu x hữu hạn;

is_infinite(x)

Trả về

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
875 nếu x là vô hạn;

is_nan(x)

Trả về

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
875 nếu x là qNaN hoặc sNaN;

is_normal(x)

Trả về

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
875 nếu x là số bình thường;

is_qnan(x)

Trả về

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
875 nếu x là một NaN yên tĩnh;

is_signed(x)

Trả về

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
875 nếu x âm;

is_snan(x)

Trả về

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
875 nếu x là NaN báo hiệu;

is_subnormal(x)

Trả về

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
875 nếu x không bình thường;

is_zero(x)

Trả về

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
875 nếu x là số không;

ln(x)

Trả về logarit tự nhiên (cơ số e) của x

log10(x)

Trả về logarit cơ số 10 của x

logb(x)

Trả về số mũ của độ lớn MSD của toán hạng

logic_and(x , y)

Áp dụng phép toán logic và giữa các chữ số của mỗi toán hạng

logic_invert(x)

Đảo ngược tất cả các chữ số trong x

logical_or(x , y)

Applies the logical operation or between each operand’s digits

logic_xor(x , y)

Áp dụng phép toán logic xor giữa các chữ số của mỗi toán hạng

max(x , y)

So sánh hai giá trị bằng số và trả về giá trị lớn nhất

max_mag(x , y)

So sánh các giá trị bằng số với dấu của chúng bị bỏ qua

phút(x , y)

So sánh hai giá trị bằng số và trả về giá trị nhỏ nhất

min_mag(x , y)

So sánh các giá trị bằng số với dấu của chúng bị bỏ qua

trừ(x)

Dấu trừ tương ứng với toán tử trừ tiền tố một ngôi trong Python

nhân lên(x , y)

Trả về tích của x và y

next_minus(x)

Returns the largest representable number smaller than x

next_plus(x)

Trả về số biểu diễn nhỏ nhất lớn hơn x

next_toward(x , y)

Trả về số gần x nhất, theo hướng về phía y

chuẩn hóa(x)

Reduces x to its simplest form

số_lớp(x)

Returns an indication of the class of x

cộng(x)

Plus tương ứng với toán tử cộng tiền tố một ngôi trong Python. Thao tác này áp dụng độ chính xác của ngữ cảnh và làm tròn, vì vậy đây không phải là thao tác nhận dạng

sức mạnh(x , y, modulo=None)

Đưa

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
846 về lũy thừa của
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
847, giảm modulo
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
458 nếu đã cho

Với hai đối số, tính toán

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
459. If
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
846 is negative then
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
847 must be integral. The result will be inexact unless
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
847 is integral and the result is finite and can be expressed exactly in ‘precision’ digits. Chế độ làm tròn của bối cảnh được sử dụng. Results are always correctly rounded in the Python version

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
463 results in
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
63, and if
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
63 is not trapped, then results in
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
466

Đã thay đổi trong phiên bản 3. 3. Mô-đun C tính toán

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
467 theo các hàm
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
468 và
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
469 được làm tròn chính xác. Kết quả được xác định rõ nhưng chỉ "hầu như luôn được làm tròn chính xác".

Với ba đối số, tính toán

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
470. For the three argument form, the following restrictions on the arguments hold

• cả ba đối số phải là tích phân

• ```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
847 phải không âm

• ít nhất một trong số

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
846 hoặc
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
847 phải khác không

• ```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
458 phải khác 0 và có tối đa các chữ số 'chính xác'

The value resulting from

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
475 is equal to the value that would be obtained by computing
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
470 with unbounded precision, but is computed more efficiently. Số mũ của kết quả bằng 0, bất kể số mũ của
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
846,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
847 và
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
458. The result is always exact

số lượng hóa(x , y)

Trả về một giá trị bằng x (làm tròn), có số mũ là y

cơ số()

Chỉ trả về 10, vì đây là Số thập phân,. )

phần còn lại(x , y)

Trả về phần còn lại từ phép chia số nguyên

Dấu của kết quả, nếu khác không, giống như dấu của số bị chia ban đầu

remainder_near(x , y)

Trả về

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
480, trong đó n là số nguyên gần nhất với giá trị chính xác của
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
481 (nếu kết quả là 0 thì dấu của nó sẽ là dấu của x)

xoay(x , y)

Trả về một bản sao được xoay x, y lần

same_quantum(x , y)

Trả về

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
875 nếu hai toán hạng có cùng số mũ

scaleb(x , y)

Trả về toán hạng đầu tiên sau khi thêm giá trị thứ hai exp của nó

ca(x , y)

Trả về một bản sao đã dịch chuyển của x, y lần

sqrt(x)

Căn bậc hai của một số không âm với độ chính xác theo ngữ cảnh

trừ(x , y)

Trả về sự khác biệt giữa x và y

to_eng_string(x)

Chuyển đổi thành chuỗi, sử dụng ký hiệu kỹ thuật nếu cần số mũ

Ký hiệu kỹ thuật có số mũ là bội số của 3. Điều này có thể để lại tối đa 3 chữ số ở bên trái của vị trí thập phân và có thể yêu cầu thêm một hoặc hai số 0 ở cuối

to_integral_exact(x)

Làm tròn thành một số nguyên

to_sci_string(x)

Chuyển đổi một số thành một chuỗi bằng cách sử dụng ký hiệu khoa học

## Hằng số¶

Các hằng số trong phần này chỉ liên quan đến mô-đun C. Chúng cũng được bao gồm trong phiên bản Python thuần túy để tương thích

32-bit

64-bit

thập phân. MAX_PREC

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
483

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
484

thập phân. MAX_EMAX

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
483

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
484

thập phân. MIN_EMIN

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
487

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
488

thập phân. MIN_ETINY

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
489

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
490

Giá trị là

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
875. Không dùng nữa, vì Python giờ đây luôn có chủ đề

Không dùng nữa kể từ phiên bản 3. 9

thập phân. HAVE_CONTEXTVAR

Giá trị mặc định là

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
875. Nếu Python là
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
493, phiên bản C sử dụng bối cảnh cục bộ luồng thay vì ngữ cảnh cục bộ coroutine và giá trị là
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
876. Điều này nhanh hơn một chút trong một số tình huống ngữ cảnh lồng nhau

Mới trong phiên bản 3. 9. đã nhập ngược về 3. 7 và 3. 8.

## Chế độ làm tròn¶

thập phân. VÒNG_TRẦN

Vòng về phía

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

thập phân. ROUND_DOWN

Làm tròn về số không

decimal. ROUND_FLOOR

Vòng về phía

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
60

thập phân. ROUND_HALF_DOWN

Làm tròn đến gần nhất với các mối quan hệ tiến về 0

thập phân. ROUND_HALF_EVEN

Làm tròn đến gần nhất với các mối quan hệ sẽ đến số nguyên chẵn gần nhất

thập phân. ROUND_HALF_UP

Làm tròn đến gần nhất với các mối quan hệ đi từ số không

thập phân. ROUND_UP

Làm tròn từ số 0

thập phân. ROUND_05UP

Làm tròn từ 0 nếu chữ số cuối cùng sau khi làm tròn về 0 sẽ là 0 hoặc 5;

## Tín hiệu¶

Signals represent conditions that arise during computation. Mỗi cái tương ứng với một cờ ngữ cảnh và một trình kích hoạt bẫy ngữ cảnh

Cờ ngữ cảnh được đặt bất cứ khi nào gặp phải điều kiện. Sau khi tính toán, các cờ có thể được kiểm tra cho các mục đích thông tin (ví dụ: để xác định xem một phép tính có chính xác hay không). Sau khi kiểm tra các cờ, đảm bảo xóa tất cả các cờ trước khi bắt đầu tính toán tiếp theo

Nếu trình kích hoạt bẫy của ngữ cảnh được đặt cho tín hiệu, thì điều kiện sẽ gây ra một ngoại lệ Python được đưa ra. Ví dụ: nếu bẫy

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
64 được đặt, thì ngoại lệ
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
64 sẽ xuất hiện khi gặp điều kiện

lớp thập phân. Đã kẹp

Đã thay đổi số mũ để phù hợp với các ràng buộc biểu diễn

Thông thường, hiện tượng kẹp xảy ra khi một số mũ nằm ngoài giới hạn

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
499 và
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
233 của ngữ cảnh. Nếu có thể, số mũ được giảm xuống cho phù hợp bằng cách thêm các số 0 vào hệ số

class decimal. DecimalException

Base class for other signals and a subclass of

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
501

class decimal. DivisionByZero

Signals the division of a non-infinite number by zero

Can occur with division, modulo division, or when raising a number to a negative power. If this signal is not trapped, returns

```>>> 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')
```
9 or
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
60 with the sign determined by the inputs to the calculation

class decimal. Inexact

Indicates that rounding occurred and the result is not exact

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

class decimal. InvalidOperation

An invalid operation was performed

Indicates that an operation was requested that does not make sense. If not trapped, returns

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
61. Possible causes include

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
29

class decimal. Overflow

Numerical overflow

Indicates the exponent is larger than

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
233 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
```>>> 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')
```
9. In either case,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
65 and
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
66 are also signaled

class decimal. Làm tròn

Rounding occurred though possibly no information was lost

Signaled whenever rounding discards digits; even if those digits are zero (such as rounding

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
509 to
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
510). If not trapped, returns the result unchanged. This signal is used to detect loss of significant digits

class decimal. Subnormal

Exponent was lower than

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
499 prior to rounding

Occurs when an operation result is subnormal (the exponent is too small). If not trapped, returns the result unchanged

class decimal. Underflow

Numerical underflow with result rounded to zero

Occurs when a subnormal result is pushed to zero by rounding.

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
65 và
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
67 cũng được báo hiệu

class decimal. FloatOperation

Enable stricter semantics for mixing floats and Decimals

If the signal is not trapped (default), mixing floats and Decimals is permitted in the

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
806 constructor,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
515 and all comparison operators. Cả chuyển đổi và so sánh đều chính xác. Any occurrence of a mixed operation is silently recorded by setting
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
60 in the context flags. Explicit conversions with
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
517 or
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
518 do not set the flag

Otherwise (the signal is trapped), only equality comparisons and explicit conversions are silent. All other mixed operations raise

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
60

The following table summarizes the hierarchy of signals

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
40

## Floating Point Notes¶

### Mitigating round-off error with increased precision¶

The use of decimal floating point eliminates decimal representation error (making it possible to represent

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
520 exactly); however, some operations can still incur round-off error when non-zero digits exceed the fixed precision

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

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
41

The

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
4 module makes it possible to restore the identities by expanding the precision sufficiently to avoid loss of significance

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
42

### Special values¶

The number system for the

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
4 module provides special values including
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
61,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
524,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
60,
```>>> 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')
```
9, and two zeros,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
63 and
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
62

Infinities can be constructed directly with.

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
202. Ngoài ra, chúng có thể phát sinh từ việc chia cho 0 khi tín hiệu
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
64 không bị mắc kẹt. Tương tự như vậy, khi tín hiệu
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
68 không bị mắc kẹt, vô hạn có thể là kết quả của việc làm tròn vượt quá giới hạn của số lớn nhất có thể biểu thị

Các vô hạn được ký (affine) và có thể được sử dụng trong các phép toán số học khi chúng được coi là các số rất lớn, không xác định. Chẳng hạn, thêm một hằng số vào vô cùng sẽ cho một kết quả vô hạn khác

Some operations are indeterminate and return

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
61, or if the
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
63 signal is trapped, raise an exception. Ví dụ:
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
534 trả về
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
61 có nghĩa là “không phải số”. Loại
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
61 này không hoạt động và sau khi được tạo, sẽ chạy qua các tính toán khác luôn dẫn đến một
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
61 khác. Hành vi này có thể hữu ích đối với một loạt phép tính đôi khi thiếu đầu vào — nó cho phép phép tính tiếp tục trong khi gắn cờ các kết quả cụ thể là không hợp lệ

Một biến thể là

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
524 báo hiệu thay vì giữ im lặng sau mỗi hoạt động. Đây là một giá trị trả về hữu ích khi một kết quả không hợp lệ cần làm gián đoạn phép tính để xử lý đặc biệt

Hành vi của các toán tử so sánh của Python có thể hơi ngạc nhiên khi có liên quan đến

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
61. Một bài kiểm tra về sự bằng nhau khi một trong các toán hạng là yên tĩnh hoặc có tín hiệu
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
61 luôn trả về
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
876 (ngay cả khi thực hiện
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
542), trong khi một bài kiểm tra về sự bất bình đẳng luôn trả về
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
875. Nỗ lực so sánh hai Số thập phân bằng cách sử dụng bất kỳ toán tử nào trong số các toán tử
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
544,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
545,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
546 hoặc
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
547 sẽ tăng tín hiệu
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
63 nếu một trong hai toán hạng là
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
61 và trả về
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
876 nếu tín hiệu này không bị bẫy. Lưu ý rằng đặc tả số học thập phân chung không chỉ định hành vi so sánh trực tiếp; . 7). Để đảm bảo tuân thủ các tiêu chuẩn nghiêm ngặt, hãy sử dụng các phương pháp
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
854 và
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
553 thay thế

Các số 0 có dấu có thể là kết quả của các phép tính nằm dưới. Họ giữ dấu hiệu sẽ có kết quả nếu phép tính được thực hiện với độ chính xác cao hơn. Since their magnitude is zero, both positive and negative zeros are treated as equal and their sign is informational

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. Điều này cần một chút thời gian để làm quen. Đối với một người đã quen với các biểu diễn dấu phẩy động được chuẩn hóa, không rõ ràng ngay lập tức rằng phép tính sau đây trả về một giá trị bằng 0

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
43

## Làm việc với chủ đề¶

Hàm

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
61 truy cập một đối tượng
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
265 khác cho mỗi luồng. Có ngữ cảnh luồng riêng biệt có nghĩa là các luồng có thể thực hiện các thay đổi (chẳng hạn như
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
556) mà không can thiệp vào các luồng khác

Tương tự như vậy, hàm

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
69 sẽ tự động gán mục tiêu của nó cho chuỗi hiện tại

Nếu

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
69 chưa được gọi trước
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
61, thì
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
61 sẽ tự động tạo ngữ cảnh mới để sử dụng trong chuỗi hiện tại

Bối cảnh mới được sao chép từ bối cảnh nguyên mẫu có tên là DefaultContext. Để kiểm soát các giá trị mặc định sao cho mỗi luồng sẽ sử dụng các giá trị giống nhau trong toàn bộ ứng dụng, hãy sửa đổi trực tiếp đối tượng DefaultContext. Điều này nên được thực hiện trước khi bất kỳ luồng nào được bắt đầu để không xảy ra tình trạng chạy đua giữa các luồng gọi

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
61. Ví dụ

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
44

## Recipes¶

Here are a few recipes that serve as utility functions and that demonstrate ways to work with the

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
806 class

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
45

## Câu hỏi thường gặp về số thập phân¶

Q. Thật khó để gõ

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
563. Có cách nào để giảm thiểu việc nhập khi sử dụng trình thông dịch tương tác không?

A. Một số người dùng viết tắt hàm tạo chỉ bằng một chữ cái

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
46

Q. Trong một ứng dụng điểm cố định có hai chữ số thập phân, một số đầu vào có nhiều vị trí và cần được làm tròn. Những người khác không được phép có thừa chữ số và cần được xác thực. Những phương pháp nên được sử dụng?

A. Phương thức

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
67 làm tròn đến một số chữ số thập phân cố định. Nếu bẫy
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
65 được đặt, nó cũng hữu ích cho việc xác thực

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
47

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
48

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
49

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
50

Q. Sau khi tôi có hai giá trị đầu vào hợp lệ, làm cách nào để duy trì giá trị bất biến đó trong toàn bộ ứng dụng?

A. Một số phép toán như cộng, trừ và nhân với một số nguyên sẽ tự động bảo toàn điểm cố định. Others operations, like division and non-integer multiplication, will change the number of decimal places and need to be followed-up with a

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
67 step

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
51

Khi phát triển các ứng dụng điểm cố định, việc xác định các chức năng để xử lý bước

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
67 sẽ thuận tiện

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
52

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
53

Q. There are many ways to express the same value. Các số ________ 4568, ________ 4569, ________ 4570 và ________ 4571 đều có cùng giá trị ở các độ chính xác khác nhau. Có cách nào để chuyển đổi chúng thành một giá trị chuẩn có thể nhận biết được không?

A. Phương pháp

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
572 ánh xạ tất cả các giá trị tương đương với một đại diện duy nhất

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
54

Q. Một số giá trị thập phân luôn in với ký hiệu số mũ. Có cách nào để có được một đại diện không theo cấp số nhân?

A. Đối với một số giá trị, ký hiệu hàm mũ là cách duy nhất để biểu thị số vị trí quan trọng trong hệ số. Ví dụ: biểu thị

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
573 dưới dạng
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
574 giữ giá trị không đổi nhưng không thể hiển thị ý nghĩa hai vị trí của bản gốc

Nếu một ứng dụng không quan tâm đến việc theo dõi ý nghĩa, có thể dễ dàng loại bỏ số mũ và số 0 ở cuối, làm mất ý nghĩa nhưng vẫn giữ nguyên giá trị

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
55

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
56

Q. Có cách nào để chuyển đổi số float thông thường thành

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
806 không?

A. Có, bất kỳ số dấu phẩy động nhị phân nào cũng có thể được biểu thị chính xác dưới dạng Số thập phân mặc dù một chuyển đổi chính xác có thể chính xác hơn so với trực giác sẽ đề xuất

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
57

Q. Trong một phép tính phức tạp, làm cách nào để đảm bảo rằng tôi không nhận được kết quả giả do không đủ độ chính xác hoặc làm tròn bất thường

A. Mô-đun thập phân giúp dễ dàng kiểm tra kết quả. 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

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?

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

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
58

The solution is either to increase precision or to force rounding of inputs using the unary plus operation

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
59

Alternatively, inputs can be rounded upon creation using the

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
576 method

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
0

Q. Việc triển khai CPython có nhanh với số lượng lớn không?

A. Yes. In the CPython and PyPy3 implementations, the C/CFFI versions of the decimal module integrate the high speed libmpdec library for arbitrary precision correctly rounded decimal floating point arithmetic 1.

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
577 uses Karatsuba multiplication for medium-sized numbers and the Number Theoretic Transform for very large numbers

Bối cảnh phải được điều chỉnh cho số học chính xác tùy ý chính xác.

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
499 and
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
233 should always be set to the maximum values,
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
580 should always be 0 (the default). Cài đặt
```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
279 yêu cầu một số cẩn thận

Cách tiếp cận đơn giản nhất để thử số học bignum là sử dụng giá trị lớn nhất cho cả

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
279 2

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
1

Đối với kết quả không chính xác,

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
291 quá lớn trên nền tảng 64 bit và bộ nhớ khả dụng sẽ không đủ

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
2

Trên các hệ thống có phân bổ tổng thể (e. g. Linux), một cách tiếp cận phức tạp hơn là điều chỉnh

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
279 theo dung lượng RAM khả dụng. Giả sử bạn có 8GB RAM và mong đợi 10 toán hạng đồng thời sử dụng tối đa 500MB mỗi toán hạng

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
3

Nói chung (và đặc biệt là trên các hệ thống không có phân bổ tổng thể), nên ước tính các giới hạn thậm chí chặt chẽ hơn và đặt bẫy

```>>> Decimal("1e9999999999999999999")
Traceback (most recent call last):
File "", line 1, in
decimal.InvalidOperation: []
```
65 nếu tất cả các tính toán được mong đợi là chính xác