Hướng dẫn python fixed decimal places - python đã cố định vị trí thập phân

Question

Bạn muốn làm tròn câu trả lời của bạn.

def roundTraditional(val,digits):
   return round(val+10**(-len(str(val))-1), digits)

3 là giải pháp thông thường để làm điều này, tuy nhiên điều này đôi khi không hoạt động như người ta mong đợi từ góc độ toán học khi chữ số ngay lập tức kém hơn (bên trái), chữ số bạn làm tròn để có

def roundTraditional(val,digits):
   return round(val+10**(-len(str(val))-1), digits)

4.sometimes does not operate as one would expect from a math perspective when the digit immediately inferior (to the left of) the digit you're rounding to has a

def roundTraditional(val,digits):
   return round(val+10**(-len(str(val))-1), digits)

4.

Dưới đây là một số ví dụ về hành vi không thể đoán trước này:

>>> round(1.0005,3)
1.0
>>> round(2.0005,3)
2.001
>>> round(3.0005,3)
3.001
>>> round(4.0005,3)
4.0
>>> round(1.005,2)
1.0
>>> round(5.005,2)
5.0
>>> round(6.005,2)
6.0
>>> round(7.005,2)
7.0
>>> round(3.005,2)
3.0
>>> round(8.005,2)
8.01

Giả sử ý định của bạn là thực hiện việc làm tròn truyền thống cho các số liệu thống kê trong khoa học, đây là một trình bao bọc tiện dụng để có được chức năng

def roundTraditional(val,digits):
   return round(val+10**(-len(str(val))-1), digits)

5 hoạt động như mong đợi cần phải có thêm những thứ như

def roundTraditional(val,digits):
   return round(val+10**(-len(str(val))-1), digits)

7.

>>> round(0.075,2)

0.07

>>> round(0.075+10**(-2*6),2)

0.08

Aha! Vì vậy, dựa trên điều này, chúng ta có thể tạo ra một chức năng ...

def roundTraditional(val,digits):
   return round(val+10**(-len(str(val))-1), digits)

Về cơ bản, điều này thêm một giá trị thực sự nhỏ vào chuỗi để buộc nó phải làm tròn đúng các trường hợp không thể đoán trước được, nơi nó không thông thường với chức năng

def roundTraditional(val,digits):
   return round(val+10**(-len(str(val))-1), digits)

5 khi bạn mong đợi. Một giá trị thuận tiện để thêm là

def roundTraditional(val,digits):
   return round(val+10**(-len(str(val))-1), digits)

9 trong đó

def main():
    printC(formeln(typeHere()))

def roundTraditional(val,digits):
    return round(val+10**(-len(str(val))-1))

def typeHere():
    global Fahrenheit
    try:
        Fahrenheit = int(raw_input("Hi! Enter Fahrenheit value, and get it in Celsius!\n"))
    except ValueError:
        print "\nYour insertion was not a digit!"
        print "We've put your Fahrenheit value to 50!"
        Fahrenheit = 50
    return Fahrenheit

def formeln(c):
    Celsius = (Fahrenheit - 32.00) * 5.00/9.00
    return Celsius

def printC(answer):
    answer = str(roundTraditional(answer,2))
    print "\nYour Celsius value is " + answer + " C.\n"

main()

0 là độ dài của chuỗi số bạn đang cố gắng sử dụng

def roundTraditional(val,digits):
   return round(val+10**(-len(str(val))-1), digits)

5 trên Plus

def main():
    printC(formeln(typeHere()))

def roundTraditional(val,digits):
    return round(val+10**(-len(str(val))-1))

def typeHere():
    global Fahrenheit
    try:
        Fahrenheit = int(raw_input("Hi! Enter Fahrenheit value, and get it in Celsius!\n"))
    except ValueError:
        print "\nYour insertion was not a digit!"
        print "We've put your Fahrenheit value to 50!"
        Fahrenheit = 50
    return Fahrenheit

def formeln(c):
    Celsius = (Fahrenheit - 32.00) * 5.00/9.00
    return Celsius

def printC(answer):
    answer = str(roundTraditional(answer,2))
    print "\nYour Celsius value is " + answer + " C.\n"

main()

2.

Cách tiếp cận của việc sử dụng

def main():
    printC(formeln(typeHere()))

def roundTraditional(val,digits):
    return round(val+10**(-len(str(val))-1))

def typeHere():
    global Fahrenheit
    try:
        Fahrenheit = int(raw_input("Hi! Enter Fahrenheit value, and get it in Celsius!\n"))
    except ValueError:
        print "\nYour insertion was not a digit!"
        print "We've put your Fahrenheit value to 50!"
        Fahrenheit = 50
    return Fahrenheit

def formeln(c):
    Celsius = (Fahrenheit - 32.00) * 5.00/9.00
    return Celsius

def printC(answer):
    answer = str(roundTraditional(answer,2))
    print "\nYour Celsius value is " + answer + " C.\n"

main()

3 là có chủ ý, vì nó là số lượng nhỏ lớn nhất bạn có thể thêm vào để buộc sự thay đổi, đồng thời đảm bảo rằng giá trị bạn thêm không bao giờ thay đổi làm tròn ngay cả khi thiếu

def main():
    printC(formeln(typeHere()))

def roundTraditional(val,digits):
    return round(val+10**(-len(str(val))-1))

def typeHere():
    global Fahrenheit
    try:
        Fahrenheit = int(raw_input("Hi! Enter Fahrenheit value, and get it in Celsius!\n"))
    except ValueError:
        print "\nYour insertion was not a digit!"
        print "We've put your Fahrenheit value to 50!"
        Fahrenheit = 50
    return Fahrenheit

def formeln(c):
    Celsius = (Fahrenheit - 32.00) * 5.00/9.00
    return Celsius

def printC(answer):
    answer = str(roundTraditional(answer,2))
    print "\nYour Celsius value is " + answer + " C.\n"

main()

4. Tôi có thể chỉ sử dụng

def main():
    printC(formeln(typeHere()))

def roundTraditional(val,digits):
    return round(val+10**(-len(str(val))-1))

def typeHere():
    global Fahrenheit
    try:
        Fahrenheit = int(raw_input("Hi! Enter Fahrenheit value, and get it in Celsius!\n"))
    except ValueError:
        print "\nYour insertion was not a digit!"
        print "We've put your Fahrenheit value to 50!"
        Fahrenheit = 50
    return Fahrenheit

def formeln(c):
    Celsius = (Fahrenheit - 32.00) * 5.00/9.00
    return Celsius

def printC(answer):
    answer = str(roundTraditional(answer,2))
    print "\nYour Celsius value is " + answer + " C.\n"

main()

5 với một

def main():
    printC(formeln(typeHere()))

def roundTraditional(val,digits):
    return round(val+10**(-len(str(val))-1))

def typeHere():
    global Fahrenheit
    try:
        Fahrenheit = int(raw_input("Hi! Enter Fahrenheit value, and get it in Celsius!\n"))
    except ValueError:
        print "\nYour insertion was not a digit!"
        print "We've put your Fahrenheit value to 50!"
        Fahrenheit = 50
    return Fahrenheit

def formeln(c):
    Celsius = (Fahrenheit - 32.00) * 5.00/9.00
    return Celsius

def printC(answer):
    answer = str(roundTraditional(answer,2))
    print "\nYour Celsius value is " + answer + " C.\n"

main()

6 có khả năng để trừ đi

def main():
    printC(formeln(typeHere()))

def roundTraditional(val,digits):
    return round(val+10**(-len(str(val))-1))

def typeHere():
    global Fahrenheit
    try:
        Fahrenheit = int(raw_input("Hi! Enter Fahrenheit value, and get it in Celsius!\n"))
    except ValueError:
        print "\nYour insertion was not a digit!"
        print "We've put your Fahrenheit value to 50!"
        Fahrenheit = 50
    return Fahrenheit

def formeln(c):
    Celsius = (Fahrenheit - 32.00) * 5.00/9.00
    return Celsius

def printC(answer):
    answer = str(roundTraditional(answer,2))
    print "\nYour Celsius value is " + answer + " C.\n"

main()

2 nữa ... nhưng đơn giản hơn khi luôn trừ

def main():
    printC(formeln(typeHere()))

def roundTraditional(val,digits):
    return round(val+10**(-len(str(val))-1))

def typeHere():
    global Fahrenheit
    try:
        Fahrenheit = int(raw_input("Hi! Enter Fahrenheit value, and get it in Celsius!\n"))
    except ValueError:
        print "\nYour insertion was not a digit!"
        print "We've put your Fahrenheit value to 50!"
        Fahrenheit = 50
    return Fahrenheit

def formeln(c):
    Celsius = (Fahrenheit - 32.00) * 5.00/9.00
    return Celsius

def printC(answer):
    answer = str(roundTraditional(answer,2))
    print "\nYour Celsius value is " + answer + " C.\n"

main()

2 vì điều đó sẽ không thay đổi nhiều phạm vi áp dụng của số thập phân này có thể xử lý đúng. Cách tiếp cận này sẽ thất bại nếu các giá trị của bạn đạt đến giới hạn của loại, điều này sẽ thất bại, nhưng đối với gần như toàn bộ phạm vi giá trị thập phân hợp lệ mà nó sẽ hoạt động.

Vì vậy, mã đã hoàn thành sẽ giống như:

def main():
    printC(formeln(typeHere()))

def roundTraditional(val,digits):
    return round(val+10**(-len(str(val))-1))

def typeHere():
    global Fahrenheit
    try:
        Fahrenheit = int(raw_input("Hi! Enter Fahrenheit value, and get it in Celsius!\n"))
    except ValueError:
        print "\nYour insertion was not a digit!"
        print "We've put your Fahrenheit value to 50!"
        Fahrenheit = 50
    return Fahrenheit

def formeln(c):
    Celsius = (Fahrenheit - 32.00) * 5.00/9.00
    return Celsius

def printC(answer):
    answer = str(roundTraditional(answer,2))
    print "\nYour Celsius value is " + answer + " C.\n"

main()

... nên cung cấp cho bạn kết quả bạn mong đợi.

Bạn cũng có thể sử dụng thư viện thập phân để thực hiện điều này, nhưng trình bao bọc mà tôi đề xuất đơn giản hơn và có thể được ưa thích trong một số trường hợp.

Chỉnh sửa: Cảm ơn Blckknght vì đã chỉ ra rằng trường hợp rìa ____24 chỉ xảy ra đối với các giá trị nhất định ở đây. Thanks Blckknght for pointing out that the

def roundTraditional(val,digits):
   return round(val+10**(-len(str(val))-1), digits)

4 fringe case occurs only for certain values here.

15. Số học dấu phẩy động: Các vấn đề và giới hạnFloating Point Arithmetic: Issues and Limitations¶

Số điểm nổi được thể hiện trong phần cứng máy tính dưới dạng phân số cơ sở 2 (nhị phân). Ví dụ: phân số thập phân

có giá trị 1/10 + 2/100 + 5/1000, và giống như cách phân số nhị phân

Có giá trị 0/2 + 0/4 + 1/8. Hai phân số này có các giá trị giống hệt nhau, sự khác biệt thực sự duy nhất là phần đầu tiên được viết trong ký hiệu phân số cơ sở 10 và thứ hai trong cơ sở 2.

Thật không may, hầu hết các phân số thập phân không thể được biểu diễn chính xác dưới dạng phân số nhị phân. Một hậu quả là, nói chung, các số điểm nổi thập phân bạn nhập chỉ được xấp xỉ bằng các số điểm nổi nhị phân thực sự được lưu trữ trong máy.

Vấn đề dễ hiểu hơn lúc đầu trong cơ sở 10. Xem xét phân số 1/3. Bạn có thể xấp xỉ đó là một phân số cơ sở 10:

hoặc tốt hơn,

và như thế. Cho dù bạn có sẵn sàng viết ra bao nhiêu chữ số, kết quả sẽ không bao giờ chính xác là 1/3, nhưng sẽ là xấp xỉ ngày càng tốt hơn 1/3.

Theo cách tương tự, cho dù có bao nhiêu chữ số cơ sở mà bạn sẵn sàng sử dụng, giá trị thập phân 0.1 không thể được biểu diễn chính xác dưới dạng phân số cơ sở 2. Trong cơ sở 2, 1/10 là phần lặp lại vô hạn

0.0001100110011001100110011001100110011001100110011...

Dừng lại ở bất kỳ số lượng bit hữu hạn, và bạn nhận được một xấp xỉ. Trên hầu hết các máy ngày nay, các phao được xấp xỉ bằng cách sử dụng phần nhị phân với tử số sử dụng 53 bit đầu tiên bắt đầu với bit quan trọng nhất và với mẫu số làm sức mạnh của hai. Trong trường hợp 1/10, phần nhị phân là

0.0001100110011001100110011001100110011001100110011...

0 gần với nhưng không chính xác bằng giá trị thực là 1/10.

Nhiều người dùng không nhận thức được xấp xỉ vì cách hiển thị các giá trị. Python chỉ in một xấp xỉ thập phân cho giá trị thập phân thực của xấp xỉ nhị phân được lưu trữ bởi máy. Trên hầu hết các máy, nếu Python in giá trị thập phân thực sự của xấp xỉ nhị phân được lưu trữ cho 0,1, nó sẽ phải hiển thị

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

Đó là nhiều chữ số hơn hầu hết mọi người thấy hữu ích, vì vậy Python giữ cho số chữ số có thể quản lý được bằng cách hiển thị giá trị tròn thay thế

Chỉ cần nhớ, mặc dù kết quả được in trông giống như giá trị chính xác là 1/10, giá trị được lưu trữ thực tế là phần nhị phân có thể đại diện gần nhất.

Thật thú vị, có nhiều số thập phân khác nhau có chung phân số nhị phân gần đúng gần nhất. Ví dụ: các số

0.0001100110011001100110011001100110011001100110011...

1 và

0.0001100110011001100110011001100110011001100110011...

2 và

0.0001100110011001100110011001100110011001100110011...

3 đều được xấp xỉ bằng

0.0001100110011001100110011001100110011001100110011...

0. Vì tất cả các giá trị thập phân này có cùng xấp xỉ, bất kỳ một trong số chúng có thể được hiển thị trong khi vẫn bảo tồn

0.0001100110011001100110011001100110011001100110011...

5 bất biến.

Trong lịch sử, chức năng python và chức năng

0.0001100110011001100110011001100110011001100110011...

6 tích hợp sẽ chọn một hàm có 17 chữ số quan trọng,

0.0001100110011001100110011001100110011001100110011...

2. Bắt đầu với Python 3.1, Python (trên hầu hết các hệ thống) hiện có thể chọn ngắn nhất trong số này và chỉ đơn giản là hiển thị

0.0001100110011001100110011001100110011001100110011...

1.

Lưu ý rằng đây là bản chất của điểm nổi nhị phân: Đây không phải là một lỗi trong Python và nó cũng không phải là một lỗi trong mã của bạn. Bạn sẽ thấy cùng một loại trong tất cả các ngôn ngữ hỗ trợ số học dấu phẩy động phần cứng của bạn (mặc dù một số ngôn ngữ có thể không hiển thị sự khác biệt theo mặc định hoặc trong tất cả các chế độ đầu ra).

Để có đầu ra dễ chịu hơn, bạn có thể muốn sử dụng định dạng chuỗi để tạo ra một số chữ số quan trọng hạn chế:

>>> format(math.pi, '.12g')  # give 12 significant digits
'3.14159265359'

>>> format(math.pi, '.2f')   # give 2 digits after the point
'3.14'

>>> repr(math.pi)
'3.141592653589793'

Điều quan trọng là phải nhận ra rằng, theo một nghĩa thực tế, là một ảo tưởng: Bạn chỉ đơn giản là làm tròn màn hình của giá trị máy thật.

Một ảo ảnh có thể quên đi một ảo ảnh khác. Ví dụ, vì 0,1 không chính xác 1/10, tổng hợp ba giá trị là 0,1 có thể không mang lại chính xác 0,3, cũng vậy:

>>> .1 + .1 + .1 == .3
False

Ngoài ra, vì 0.1 không thể đến gần hơn với giá trị chính xác là 1/10 và 0.3 không thể tiến gần hơn đến giá trị chính xác là 3/10, sau đó hoạt động trước với hàm

0.0001100110011001100110011001100110011001100110011...

9 không thể giúp đỡ:

>>> round(.1, 1) + round(.1, 1) + round(.1, 1) == round(.3, 1)
False

Mặc dù các số không thể được gần với các giá trị chính xác dự định của chúng, hàm

0.0001100110011001100110011001100110011001100110011...

9 có thể hữu ích cho việc sau khi tròn để kết quả với các giá trị không chính xác có thể so sánh với nhau:

>>> round(.1 + .1 + .1, 10) == round(.3, 10)
True

Số học dấu phẩy động nhị phân giữ nhiều bất ngờ như thế này. Vấn đề với các loại 0.1 0,1 được giải thích chi tiết chính xác dưới đây, trong phần Lỗi đại diện trên mạng. Xem những nguy hiểm của điểm nổi để biết một tài khoản đầy đủ hơn về những bất ngờ phổ biến khác.

Như đã nói gần cuối, không có câu trả lời dễ dàng. Tuy nhiên, don không nên cảnh giác quá mức với điểm nổi! Các lỗi trong các hoạt động nổi Python được kế thừa từ phần cứng dấu phẩy động và trên hầu hết các máy theo thứ tự không quá 1 phần trong 2 ** 53 mỗi hoạt động. Điều đó nhiều hơn đủ cho hầu hết các nhiệm vụ, nhưng bạn cần phải nhớ rằng nó không phải là số học thập phân và mọi hoạt động nổi đều có thể bị lỗi làm tròn mới.

Mặc dù các trường hợp bệnh lý tồn tại, nhưng đối với hầu hết các phép số học thông thường của số học dấu phẩy động, bạn sẽ thấy kết quả mà bạn mong đợi cuối cùng nếu bạn chỉ cần hiển thị kết quả cuối cùng của mình với số chữ số thập phân bạn mong đợi.

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

1 thường đủ và để kiểm soát tốt hơn, hãy xem các định dạng định dạng phương thức

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

2 trong cú pháp chuỗi định dạng.Format String Syntax.

Đối với các trường hợp sử dụng yêu cầu biểu diễn thập phân chính xác, hãy thử sử dụng mô-đun

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

3 thực hiện số học thập phân phù hợp cho các ứng dụng kế toán và ứng dụng chính xác cao.

Một dạng khác của số học chính xác được hỗ trợ bởi mô -đun

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

4 thực hiện số học dựa trên các số hợp lý (do đó các số như 1/3 có thể được biểu diễn chính xác).

Nếu bạn là người dùng nặng về các hoạt động nổi, bạn nên xem gói Numpy và nhiều gói khác cho các hoạt động toán học và thống kê do dự án SCIPY cung cấp. Nhìn thấy .

Python cung cấp các công cụ có thể giúp trong những dịp hiếm hoi khi bạn thực sự muốn biết giá trị chính xác của một chiếc phao. Phương pháp

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

5 biểu thị giá trị của một chiếc phao dưới dạng một phần:

>>> round(0.075,2)

0.07

>>> round(0.075+10**(-2*6),2)

0.08

0

Vì tỷ lệ này là chính xác, nó có thể được sử dụng để tái tạo giá trị ban đầu:

>>> round(0.075,2)

0.07

>>> round(0.075+10**(-2*6),2)

0.08

1

Phương pháp

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

6 thể hiện sự nổi trong thập lục phân (cơ sở 16), một lần nữa đưa ra giá trị chính xác được lưu trữ bởi máy tính của bạn:

>>> round(0.075,2)

0.07

>>> round(0.075+10**(-2*6),2)

0.08

2

Biểu diễn thập lục phân chính xác này có thể được sử dụng để xây dựng lại giá trị nổi chính xác:

>>> round(0.075,2)

0.07

>>> round(0.075+10**(-2*6),2)

0.08

3

Vì biểu diễn là chính xác, nó rất hữu ích cho việc chuyển các giá trị đáng tin cậy trên các phiên bản khác nhau của Python (tính độc lập nền tảng) và trao đổi dữ liệu với các ngôn ngữ khác hỗ trợ cùng định dạng (như Java và C99).

Một công cụ hữu ích khác là chức năng

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

7 giúp giảm thiểu sự chính xác trong quá trình tổng kết. Nó theo dõi các chữ số bị mất của các chữ số vì các giá trị được thêm vào tổng số chạy. Điều đó có thể tạo ra sự khác biệt về độ chính xác tổng thể để các lỗi không tích lũy đến điểm mà chúng ảnh hưởng đến tổng số cuối cùng:

>>> round(0.075,2)

0.07

>>> round(0.075+10**(-2*6),2)

0.08

4

15.1. Lỗi đại diệnRepresentation Error¶

Phần này giải thích chi tiết ví dụ về 0,1 0,1 và cho thấy cách bạn có thể thực hiện phân tích chính xác các trường hợp như thế này. Sự quen thuộc cơ bản với biểu diễn điểm nổi nhị phân được giả định.

Lỗi đại diện đề cập đến thực tế là một số phân số thập phân (hầu hết,) không thể được biểu diễn chính xác dưới dạng phân số nhị phân (cơ sở 2). Đây là lý do chính tại sao Python (hoặc Perl, C, C ++, Java, Fortran và nhiều người khác) thường giành được hiển thị số thập phân chính xác mà bạn mong đợi.

Tại sao vậy? 1/10 không thể đại diện chính xác như một phần nhị phân. Hầu như tất cả các máy ngày nay (tháng 11 năm 2000) sử dụng số học nổi của IEEE-754, và gần như tất cả các nền tảng đều lập bản đồ python nổi lên IEEE-754. 754 nhân đôi chứa 53 bit độ chính xác, vì vậy, trên đầu vào, máy tính cố gắng chuyển đổi 0,1 thành phân số gần nhất mà nó có thể của Mẫu J/2 ** n trong đó J là một số nguyên chứa chính xác 53 bit. Viết lại

như

và nhớ lại rằng J có chính xác 53 bit (là

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

8 nhưng

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

9), giá trị tốt nhất cho N là 56:

>>> round(0.075,2)

0.07

>>> round(0.075+10**(-2*6),2)

0.08

5

Đó là, 56 là giá trị duy nhất cho n để lại J với chính xác 53 bit. Giá trị tốt nhất có thể cho J sau đó là công cụ làm tròn:

>>> round(0.075,2)

0.07

>>> round(0.075+10**(-2*6),2)

0.08

6

Vì phần còn lại là hơn một nửa của 10, nên phép tính gần đúng tốt nhất có được bằng cách làm tròn lên:

Do đó, xấp xỉ tốt nhất có thể với 1/10 trong 754 độ chính xác kép là:

>>> round(0.075,2)

0.07

>>> round(0.075+10**(-2*6),2)

0.08

7

Chia cả tử số và mẫu số cho hai phần giảm phân số thành:

>>> round(0.075,2)

0.07

>>> round(0.075+10**(-2*6),2)

0.08

8

Lưu ý rằng vì chúng tôi đã làm tròn, điều này thực sự lớn hơn một chút so với 1/10; Nếu chúng tôi không làm tròn, thương số sẽ nhỏ hơn một chút so với 1/10. Nhưng trong mọi trường hợp, nó có thể chính xác là 1/10!

Vì vậy, máy tính không bao giờ nhìn thấy 1/10: những gì nó thấy là phần chính xác được đưa ra ở trên, xấp xỉ kép tốt nhất 754 mà nó có thể nhận được:

>>> round(0.075,2)

0.07

>>> round(0.075+10**(-2*6),2)

0.08

9

Nếu chúng ta nhân phân số đó với 10 ** 55, chúng ta có thể thấy giá trị ra thành 55 chữ số thập phân:

def roundTraditional(val,digits):
   return round(val+10**(-len(str(val))-1), digits)

0

Có nghĩa là số chính xác được lưu trữ trong máy tính bằng với giá trị thập phân 0.100000000000000000055511151231257827021181583404541015625. Thay vì hiển thị giá trị thập phân đầy đủ, nhiều ngôn ngữ (bao gồm các phiên bản cũ của Python), kết quả tròn đến 17 chữ số quan trọng:

def roundTraditional(val,digits):
   return round(val+10**(-len(str(val))-1), digits)

1

Các mô -đun

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

4 và

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

3 giúp các tính toán này dễ dàng:

def roundTraditional(val,digits):
   return round(val+10**(-len(str(val))-1), digits)

2

programming python Decimal Python Python decimal precision

Hướng dẫn python fixed decimal places - python đã cố định vị trí thập phân

15. Số học dấu phẩy động: Các vấn đề và giới hạnFloating Point Arithmetic: Issues and Limitations¶

15.1. Lỗi đại diệnRepresentation Error¶

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội