Hướng dẫn should i use decimal or float python? - tôi nên sử dụng thập phân hoặc float python?

Question

Khi làm việc với số thập phân trong Python, chúng ta thường chuyển sang phao. Phao phục vụ chúng tôi tốt cho hầu hết các mục đích, chẳng hạn như các bộ phận đơn giản, nhưng chúng có những hạn chế có thể trở nên vô cùng có vấn đề đối với các trường hợp sử dụng nhất định. Chúng chỉ đơn giản là không đủ chính xác. Tuy nhiên, Floats không phải là lựa chọn duy nhất của chúng tôi và hôm nay chúng tôi sẽ xem mô -đun

a = 10
b = a / 77
c = b * 77

if a != c:
    print("Things got weird...")

# Things got weird...

6 và tại sao bạn có thể sử dụng nó.

Nội dung chính Show

Nhìn nhanh vào nhị phân
Phân số trong nhị phân
Phao trong Python
Nhập a = 10 b = a / 77 c = b * 77 if a != c: print("Things got weird...") # Things got weird... 6
Tạo đối tượng print(f"{a:.20f}") # 10.00000000000000000000 print(f"{c:.20f}") # 9.99999999999999822364 5
Sử dụng một số nguyên
Sử dụng một chuỗi
Sử dụng một chiếc phao
Sử dụng một tuple
Đối tượng x = decimal.Decimal("0.1") print(x) # 0.1 print(f"{x:.20f}") # 0.10000000000000000000 4
Một số phương pháp a = 10 b = a / 77 c = b * 77 if a != c: print("Things got weird...") # Things got weird... 6 hữu ích
x = decimal.Decimal((1, (1, 3, 0, 4, 2), -3)) print(x) # -13.042 1
x = decimal.Decimal((1, (1, 3, 0, 4, 2), -3)) print(x) # -13.042 4
import decimal print(decimal.getcontext()) # Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow]) 1
Vì vậy, chúng ta có nên sử dụng a = 10 b = a / 77 c = b * 77 if a != c: print("Things got weird...") # Things got weird... 6?
Tôi nên sử dụng thập phân hay nổi?
Phao có hiệu quả hơn số thập phân không?
Tôi nên sử dụng Float Double hay thập phân?
Làm thế nào chính xác là thập phân trong Python?

Nhìn nhanh vào nhị phân

Trước khi chúng ta có thể hiểu đúng vấn đề với phao, chúng ta cần xem xét nhanh cách các con số được thể hiện trong nhị phân.

Hệ thống số mà chúng ta sử dụng trong cuộc sống hàng ngày là một hệ thống số cơ sở 10, còn được gọi là hệ thống số thập phân. Chúng tôi sử dụng mười chữ số duy nhất trong các kết hợp khác nhau để thể hiện tất cả các số. Mặt khác, nhị phân là một hệ thống số cơ sở-2 và chỉ sử dụng hai chữ số duy nhất: thường là 0 và 1. Khi các số được lưu trữ trong máy tính của chúng tôi, chúng được lưu trữ ở định dạng nhị phân này.

Một số nhị phân có thể trông giống như thế này: 10101101, xảy ra là 173.

Vậy làm thế nào để chúng ta có được 173 trong số 10101101?

Nhị phân hoạt động trong sức mạnh của 2, do đó 1 bên phải 1 trong 10101101, đại diện cho 1 x 2⁰. Sau đó, chúng tôi thực hiện một bước bên trái, nơi chúng tôi tìm thấy 0. 0 này biểu thị 0 x 2¹, là 0 x 2. Một bước khác bên trái và chúng tôi tìm thấy 1, lần này đại diện cho 1 x 2², là 4. Mỗi bước bên trái, công suất tăng thêm 1.

Tổng cộng chúng ta có một cái gì đó trông như thế này:

.

Đó là:

(1 x 128) + (0 x 64) + (1 x 32) + (0 x 16) + (1 x 8) + (1 x 4) + (0 x 2) + (1 x 1)

Nếu chúng tôi thêm tất cả những điều này, chúng tôi sẽ nhận được 173. Như bạn có thể thấy, các biểu diễn nhị phân của các con số có xu hướng rất lâu so với các biểu diễn thập phân, nhưng cuối cùng chúng tôi có thể thể hiện bất kỳ số nguyên nào theo cách này.

Phân số trong nhị phân

Vì vậy, chúng tôi đã thực hiện một sự bồi dưỡng nhanh về cách các số nguyên có thể được thể hiện trong nhị phân, nhưng còn phân số thì sao? Hóa ra, nó hoạt động giống như vậy, chỉ với sức mạnh tiêu cực.

Ví dụ: 2⁻ là ½ và 2⁻² là ¼, có nghĩa là bây giờ chúng ta có thể đại diện cho 0,75, 0,5 và 0,25. Sử dụng các sức mạnh tiêu cực lớn hơn dần dần, chúng ta có thể đại diện cho tất cả các loại số thập phân.

Tuy nhiên, giống như có những con số mà chúng ta không thể đại diện với số chữ số thập phân hữu hạn (ví dụ: ⅓), cũng có những con số chúng ta không thể đại diện trong nhị phân. Ví dụ, số 0.1 không có biểu diễn nhị phân hữu hạn.

Phao trong Python

Vậy điều gì xảy ra khi chúng ta viết

a = 10
b = a / 77
c = b * 77

if a != c:
    print("Things got weird...")

# Things got weird...

7 trong Python? Hãy xem:

print(f"{0.1:.20f}")  # 0.10000000000000000555

Đối với những người không quen thuộc với cú pháp ở trên,

a = 10
b = a / 77
c = b * 77

if a != c:
    print("Things got weird...")

# Things got weird...

8 là một cách để nói với Python, chúng tôi muốn 20 chữ số sau điểm thập phân cho chiếc phao này. Chúng tôi có một bài đăng bạn có thể xem dưới đây:

https://blog.tecladocode.com/python-formatting-numbers-for-printing/

Như chúng ta có thể thấy, chúng ta thực sự không nhận được

a = 10
b = a / 77
c = b * 77

if a != c:
    print("Things got weird...")

# Things got weird...

7: Chúng ta nhận được xấp xỉ gần như

a = 10
b = a / 77
c = b * 77

if a != c:
    print("Things got weird...")

# Things got weird...

7. Thật không may, đôi khi một xấp xỉ gần như không đủ tốt.

Điều này đặc biệt phổ biến khi thực hiện so sánh:

a = 10
b = a / 77
c = b * 77

if a != c:
    print("Things got weird...")

# Things got weird...

Nếu chúng ta in

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

1 và

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

2, chúng ta có thể thấy những gì đã xảy ra:

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

Lỗi xấp xỉ này có thể được ghép mạnh mẽ trong một loạt các hoạt động, có nghĩa là chúng ta thực sự có thể kết thúc với sự khác biệt khá đáng kể giữa các số nên giống hệt nhau.

Bạn có thể đọc thêm về những vấn đề này trong tài liệu Python: https://docs.python.org/3/tutorial/floatingpoint.html

Nhập a = 10 b = a / 77 c = b * 77 if a != c: print("Things got weird...") # Things got weird... 6

Như đã đề cập khi bắt đầu bài đăng này, Python có một cách khác để xử lý các số thập phân, đó là mô -đun

a = 10
b = a / 77
c = b * 77

if a != c:
    print("Things got weird...")

# Things got weird...

6. Không giống như phao, các đối tượng

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

5 được xác định trong mô -đun

a = 10
b = a / 77
c = b * 77

if a != c:
    print("Things got weird...")

# Things got weird...

6 không dễ bị mất độ chính xác này, bởi vì chúng không dựa vào các phân số nhị phân.

Tạo đối tượng print(f"{a:.20f}") # 10.00000000000000000000 print(f"{c:.20f}") # 9.99999999999999822364 5

Trước khi chúng ta đi sâu vào các đối tượng

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

5, chúng ta hãy xem xét cách xác định chúng. Thực tế có một số cách để làm điều này.

Sử dụng một số nguyên

Cách đầu tiên để tạo một đối tượng

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

5 chúng tôi sử dụng số nguyên. Trong trường hợp này, chúng tôi chỉ cần chuyển số nguyên như một đối số cho hàm tạo

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

5:

import decimal

x = decimal.Decimal(34)  # 34

Bây giờ chúng ta có thể sử dụng

import decimal

x = decimal.Decimal(34)  # 34

1 giống như bất kỳ số nào khác và chúng ta sẽ nhận lại đối tượng

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

5 khi thực hiện các hoạt động toán học:

x = decimal.Decimal(34)

print(x + 7)         # 41
print(type(x + 7))   # <class 'decimal.Decimal'>

print(x // 7)        # 4
print(type(x // 7))  # <class 'decimal.Decimal'>

Sử dụng một chuỗi

Có lẽ một chút đáng ngạc nhiên, một trong những cách dễ nhất để tạo đối tượng

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

5 với các thành phần phân số là sử dụng một chuỗi. Chúng ta chỉ cần chuyển một đại diện chuỗi của số cho

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

5 và nó sẽ chăm sóc phần còn lại:

x = decimal.Decimal("0.1")

print(x)            # 0.1
print(f"{x:.20f}")  # 0.10000000000000000000

Như chúng ta có thể thấy, in

import decimal

x = decimal.Decimal(34)  # 34

1 đến 20 số thập phân ở đây mang lại cho chúng ta 19 số 0: Chúng ta không kết thúc với một số 5 ngẫu nhiên ở cuối như chúng ta đã làm khi sử dụng float.

Nếu bạn cần một biểu diễn thập phân chính xác của một số, sử dụng các chuỗi để tạo các đối tượng

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

5 của bạn là một cách rất đơn giản để đạt được điều này.

Sử dụng một chiếc phao

Cũng có thể tạo một đối tượng

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

5 từ một chiếc phao, nhưng tôi thường khuyên bạn nên làm điều này. Ví dụ dưới đây sẽ làm rõ tại sao:

x = decimal.Decimal(0.1)
print(x)  # 0.1000000000000000055511151231257827021181583404541015625

Chuyển đổi thẳng từ một chiếc phao khiến đối tượng

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

5 của chúng ta thừa hưởng tất cả sự thiếu chính xác mà chúng ta đang cố gắng tránh ngay từ đầu. Có thể có những trường hợp bạn muốn bảo tồn sự thiếu chính xác này vì một số lý do, nhưng hầu hết thời gian, đó không phải là trường hợp.

Sử dụng một tuple

Có lẽ phương pháp phức tạp nhất để tạo đối tượng

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

5 là sử dụng một tuple và phương pháp này cho chúng ta một cái nhìn sâu sắc về cách các đối tượng

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

5 hoạt động dưới mui xe.

Tuple chúng tôi cung cấp cho

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

5 có ba phần. Phần tử đầu tiên trong tuple là số

x = decimal.Decimal(34)

print(x + 7)         # 41
print(type(x + 7))   # <class 'decimal.Decimal'>

print(x // 7)        # 4
print(type(x // 7))  # <class 'decimal.Decimal'>

2 hoặc

x = decimal.Decimal(34)

print(x + 7)         # 41
print(type(x + 7))   # <class 'decimal.Decimal'>

print(x // 7)        # 4
print(type(x // 7))  # <class 'decimal.Decimal'>

3 và điều này thể hiện dấu hiệu của số (cho dù đó là dương hay âm). Số 0 ở vị trí đầu tiên này chỉ ra một số dương, trong khi một số đại diện cho một số âm.

Mục thứ hai trong tuple là một tuple khác và điều này chứa tất cả các chữ số trong số kết quả. Ví dụ: số

x = decimal.Decimal(34)

print(x + 7)         # 41
print(type(x + 7))   # <class 'decimal.Decimal'>

print(x // 7)        # 4
print(type(x // 7))  # <class 'decimal.Decimal'>

4 có các chữ số

x = decimal.Decimal(34)

print(x + 7)         # 41
print(type(x + 7))   # <class 'decimal.Decimal'>

print(x // 7)        # 4
print(type(x // 7))  # <class 'decimal.Decimal'>

5.

Mục thứ ba và cuối cùng trong tuple là một số mũ. Điều này cho biết đối tượng

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

5 có bao nhiêu nơi chúng ta cần thay đổi các chữ số xung quanh điểm thập phân. Một số mũ của

x = decimal.Decimal(34)

print(x + 7)         # 41
print(type(x + 7))   # <class 'decimal.Decimal'>

print(x // 7)        # 4
print(type(x // 7))  # <class 'decimal.Decimal'>

7 sẽ khiến các chữ số chuyển 3 không gian sang phải, cho chúng ta

x = decimal.Decimal(34)

print(x + 7)         # 41
print(type(x + 7))   # <class 'decimal.Decimal'>

print(x // 7)        # 4
print(type(x // 7))  # <class 'decimal.Decimal'>

8, trong khi số mũ của

x = decimal.Decimal(34)

print(x + 7)         # 41
print(type(x + 7))   # <class 'decimal.Decimal'>

print(x // 7)        # 4
print(type(x // 7))  # <class 'decimal.Decimal'>

9 sẽ cho chúng ta

x = decimal.Decimal("0.1")

print(x)            # 0.1
print(f"{x:.20f}")  # 0.10000000000000000000

0.

Một ví dụ hoàn chỉnh cho số

x = decimal.Decimal("0.1")

print(x)            # 0.1
print(f"{x:.20f}")  # 0.10000000000000000000

1 trông như thế này:

x = decimal.Decimal((1, (1, 3, 0, 4, 2), -3))
print(x)  # -13.042

Một điều thực sự quan trọng cần lưu ý ở đây là chúng ta cần các dấu ngoặc xung quanh tuple bên ngoài, vì

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

5 mong đợi bộ phim này như một đối số duy nhất. Loại bỏ các dấu ngoặc bên ngoài sẽ gây ra lỗi.

Mặc dù tương đối phức tạp, cú pháp tuple phù hợp nhất để tạo các đối tượng

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

5 theo chương trình.

Đối tượng x = decimal.Decimal("0.1") print(x) # 0.1 print(f"{x:.20f}") # 0.10000000000000000000 4

Một trong những điều thú vị về mô -đun

a = 10
b = a / 77
c = b * 77

if a != c:
    print("Things got weird...")

# Things got weird...

6 là nó cho phép chúng ta xác định hành vi của các đối tượng

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

5 theo nhiều cách khác nhau. Chúng tôi có thể chỉ định mức độ chính xác, giới hạn cho số mũ và thậm chí các quy tắc làm tròn.

Để làm điều này, chúng ta thường sẽ làm việc với chức năng

x = decimal.Decimal("0.1")

print(x)            # 0.1
print(f"{x:.20f}")  # 0.10000000000000000000

7, cho phép chúng ta xem và sửa đổi đối tượng

x = decimal.Decimal("0.1")

print(x)            # 0.1
print(f"{x:.20f}")  # 0.10000000000000000000

4 cho luồng hiện tại.

Chúng ta hãy xem đối tượng

x = decimal.Decimal("0.1")

print(x)            # 0.1
print(f"{x:.20f}")  # 0.10000000000000000000

4 mặc định trông như thế nào:

import decimal

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

Như bạn có thể thấy, chúng tôi có tất cả các loại thuộc tính mà chúng tôi có thể thiết lập để thay đổi cách thức hoạt động của các đối tượng

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

5.

Ví dụ: chúng tôi có thể quyết định chúng tôi muốn có 10 con số quan trọng có giá trị chính xác, mà chúng tôi đã đặt như thế này:

import decimal

decimal.getcontext().prec = 10
x = decimal.Decimal(1) / decimal.Decimal(7)

print(x)  # 0.1428571429

Lưu ý rằng độ chính xác mới này chỉ có liên quan trong các hoạt động toán học. Chúng ta có thể xác định một đối tượng

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

5 với độ chính xác tùy ý, ngay cả khi chúng ta đặt mức độ chính xác thấp hơn bằng cách sử dụng

x = decimal.Decimal("0.1")

print(x)            # 0.1
print(f"{x:.20f}")  # 0.10000000000000000000

7.

a = 10
b = a / 77
c = b * 77

if a != c:
    print("Things got weird...")

# Things got weird...

0

Như tôi đã đề cập trước đó, chúng ta cũng có thể xác định cách làm việc hoạt động cho các đối tượng

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

5, có thể rất hữu ích. Theo mặc định, Python sử dụng làm tròn của các ngân hàng, khác với loại hình tròn mà chúng ta tìm hiểu ở trường.

Chúng tôi nói về việc làm tròn của các nhân viên ngân hàng ở đây nếu bạn không quen thuộc với nó: https://blog.tecladocode.com/rounding-in-python/

Sử dụng

x = decimal.Decimal("0.1")

print(x)            # 0.1
print(f"{x:.20f}")  # 0.10000000000000000000

7, chúng ta có thể thay đổi hành vi làm tròn của Python thành những số thập phân tròn trịa kết thúc trong

x = decimal.Decimal(0.1)
print(x)  # 0.1000000000000000055511151231257827021181583404541015625

5 cách xa

x = decimal.Decimal(34)

print(x + 7)         # 41
print(type(x + 7))   # <class 'decimal.Decimal'>

print(x // 7)        # 4
print(type(x // 7))  # <class 'decimal.Decimal'>

2, đó là cách chúng ta làm tròn trong cuộc sống hàng ngày:

a = 10
b = a / 77
c = b * 77

if a != c:
    print("Things got weird...")

# Things got weird...

1

Một số hành vi làm tròn khác nhau được xác định trong mô -đun

a = 10
b = a / 77
c = b * 77

if a != c:
    print("Things got weird...")

# Things got weird...

6 bằng cách sử dụng hằng số. Bạn có thể đọc thêm về các tùy chọn có sẵn ở đây: https://docs.python.org/3.7/l Library/decimal.html#module-decimal

Một số phương pháp a = 10 b = a / 77 c = b * 77 if a != c: print("Things got weird...") # Things got weird... 6 hữu ích

Mô -đun

a = 10
b = a / 77
c = b * 77

if a != c:
    print("Things got weird...")

# Things got weird...

6 đi kèm với một số phương pháp tiện dụng để làm việc với các đối tượng

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

5. Dưới đây là một số ít mà bạn có thể muốn kiểm tra.

x = decimal.Decimal((1, (1, 3, 0, 4, 2), -3)) print(x) # -13.042 1

Phương pháp

x = decimal.Decimal((1, (1, 3, 0, 4, 2), -3))
print(x)  # -13.042

1 cho phép chúng tôi có được căn bậc hai của bất kỳ

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

5 nào với mức độ chính xác được chỉ định.

a = 10
b = a / 77
c = b * 77

if a != c:
    print("Things got weird...")

# Things got weird...

2

x = decimal.Decimal((1, (1, 3, 0, 4, 2), -3)) print(x) # -13.042 4

Phương pháp

x = decimal.Decimal((1, (1, 3, 0, 4, 2), -3))
print(x)  # -13.042

4 được sử dụng để thay đổi đối tượng

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

5 thành số mũ mới. Ví dụ: giả sử chúng tôi có số

x = decimal.Decimal((1, (1, 3, 0, 4, 2), -3))
print(x)  # -13.042

7 và chúng tôi muốn thay đổi số này để phù hợp với mẫu

x = decimal.Decimal((1, (1, 3, 0, 4, 2), -3))
print(x)  # -13.042

8, chúng tôi có thể viết như sau:

a = 10
b = a / 77
c = b * 77

if a != c:
    print("Things got weird...")

# Things got weird...

3

Một điều cần lưu ý với phương pháp

x = decimal.Decimal((1, (1, 3, 0, 4, 2), -3))
print(x)  # -13.042

4 là nó sẽ tăng ngoại lệ

import decimal

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

0 nếu các giá trị cuối cùng vượt quá mức độ chính xác được xác định.

a = 10
b = a / 77
c = b * 77

if a != c:
    print("Things got weird...")

# Things got weird...

4

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

Phương thức

import decimal

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

1 cho chúng ta biểu diễn tuple của đối tượng

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

5, giống như khi chúng ta tạo một biểu tượng bằng cú pháp tuple.

a = 10
b = a / 77
c = b * 77

if a != c:
    print("Things got weird...")

# Things got weird...

5

Có nhiều phương pháp khác có sẵn cho các đối tượng

print(f"{a:.20f}")  # 10.00000000000000000000
print(f"{c:.20f}")  #  9.99999999999999822364

5 và tôi khuyên bạn nên xem phần này của tài liệu để tìm hiểu thêm: https://docs.python.org/3.7/l Library/decimal.html#decimal-objects

Vì vậy, chúng ta có nên sử dụng a = 10 b = a / 77 c = b * 77 if a != c: print("Things got weird...") # Things got weird... 6?

Không cần thiết. Mặc dù mô -đun

a = 10
b = a / 77
c = b * 77

if a != c:
    print("Things got weird...")

# Things got weird...

6 chắc chắn rất gọn gàng, và nó có lợi ích của độ chính xác tuyệt đối, độ chính xác này có chi phí. Trong trường hợp này, chi phí là gấp đôi.

Thứ nhất, sử dụng mô -đun

a = 10
b = a / 77
c = b * 77

if a != c:
    print("Things got weird...")

# Things got weird...

6 khó hơn nhiều so với sử dụng phao. Điều này rất rõ ràng ngay khi chúng ta nhìn vào đối tượng

import decimal

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

8 ở trên và chúng ta cũng có những thứ như bối cảnh cần xem xét trên đỉnh này. Bạn chỉ cần biết nhiều hơn để thậm chí sử dụng mô -đun.

Tuy nhiên, vấn đề thứ hai có lẽ là cấp bách hơn, và đó là hiệu suất.

a = 10
b = a / 77
c = b * 77

if a != c:
    print("Things got weird...")

# Things got weird...

6 Các hoạt động có khả năng chậm hơn khoảng 3 lần so với các hoạt động sử dụng phao, vì vậy nếu bạn xử lý phần nhạy cảm với hiệu suất của ứng dụng, trong đó độ chính xác tuyệt đối không quan trọng, bạn có thể muốn tránh xa

a = 10
b = a / 77
c = b * 77

if a != c:
    print("Things got weird...")

# Things got weird...

6. Điều này đặc biệt đúng nếu bạn vẫn làm việc với Python 2, vì các hoạt động sau đó có khả năng chậm hơn vài trăm lần!

Mô -đun

a = 10
b = a / 77
c = b * 77

if a != c:
    print("Things got weird...")

# Things got weird...

6 là một công cụ tuyệt vời để có trong bộ công cụ của chúng tôi, nhưng chúng tôi nên luôn nhận thức được liệu chúng tôi có thực sự cần nó cho một ứng dụng cụ thể hay không.

Gói lên

Đó là nó cho bài đăng này trên phao và số thập phân. Chắc chắn có rất nhiều thứ để học, vì vậy một lần nữa, hãy xem tài liệu! Tài liệu mô -đun

a = 10
b = a / 77
c = b * 77

if a != c:
    print("Things got weird...")

# Things got weird...

6 có thể hơi đáng sợ, nhưng hy vọng những gì chúng tôi đã nói ở đây khiến bạn chuẩn bị tốt để lặn ngay.

Nếu bạn đã tận hưởng các bài viết của chúng tôi và bạn muốn đưa Python của mình lên cấp độ tiếp theo, hãy chắc chắn kiểm tra khóa học Python hoàn chỉnh của chúng tôi.

Tôi nên sử dụng thập phân hay nổi?

Float lưu trữ một giá trị gần đúng và số thập phân lưu trữ một giá trị chính xác.Tóm lại, các giá trị chính xác như tiền nên sử dụng thập phân và các giá trị gần đúng như các phép đo khoa học nên sử dụng phao.Khi nhân số không số nguyên và chia cho cùng một số đó, số thập phân sẽ mất độ chính xác trong khi phao không.exact values like money should use decimal, and approximate values like scientific measurements should use float. When multiplying a non integer and dividing by that same number, decimals lose precision while floats do not.

Phao có hiệu quả hơn số thập phân không?

Decimal được sử dụng trong các ứng dụng tài chính đòi hỏi độ chính xác cao và dễ dàng để tránh các lỗi làm tròn trong khi Float được sử dụng khi bạn lưu trữ các số khoa học và để có hiệu suất tốt hơn.Hiệu suất của số thập phân chậm hơn và các loại dữ liệu nổi.Performance of Decimals is slower than and float data types.

Tôi nên sử dụng Float Double hay thập phân?

Phao ít chính xác hơn gấp đôi và thập phân.Double chính xác hơn phao nhưng ít chính xác hơn số thập phân.Decimal chính xác hơn phao và gấp đôi.. Double is more accurate than Float but less accurate than Decimal. Decimal is more accurate than Float and Double.

Làm thế nào chính xác là thập phân trong Python?

Độ chính xác mặc định của thập phân Python Độ chính xác có độ chính xác mặc định là 28 vị trí, trong khi phao có 18 vị trí.28 places, while the float has 18 places.