Hướng dẫn how do i reduce the number of decimal places float in python? - làm cách nào để giảm số lượng vị trí thập phân nổi trong python?

Question

Tldr;)

Vấn đề làm tròn của đầu vào và đầu ra đã được giải quyết dứt khoát bằng Python 3.1 và bản sửa lỗi cũng được đưa vào Python 2.7.0.solved definitively by Python 3.1 and the fix is backported also to Python 2.7.0.

Nội dung chính Show

Bài kiểm tra
Tài liệu
Giới hạn phao đến các vị trí thập phân bằng cách sử dụng toán tử định dạng chuỗi
Trong Python, chúng ta có thể sử dụng % làm toán tử định dạng chuỗi. Nó sẽ đại diện cho một chuỗi. Nếu chúng ta muốn biểu diễn các giá trị dấu phẩy động bằng toán tử này, thì chúng ta phải chỉ định-%. Do đó, chúng ta có thể giới hạn một float đến hai vị trí thập phân bằng toán tử định dạng chuỗi này.
Giới hạn nổi cho n vị trí thập phân bằng cách sử dụng str.format () với vòng ()
Giới hạn nổi cho n vị trí thập phân bằng cách sử dụng str.format () với vòng ()
Giới hạn nổi cho n vị trí thập phân bằng cách sử dụng str.format () với vòng ()
Có thể sử dụng hàm vòng () với hàm str.format (). Nó sẽ giới hạn một số điểm nổi ở hai vị trí thập phân. Vòng () được đặt trong tham số định dạng ().
Có thể sử dụng hàm vòng () với hàm str.format (). Nó sẽ giới hạn một số điểm nổi ở hai vị trí thập phân. Vòng () được đặt trong tham số định dạng ().

Các số tròn có thể được chuyển đổi đảo ngược giữa phao và chuỗi qua lại:

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.

3 hoặc
import random from decimal import Decimal for _ in range(1000000): x = random.random() assert x == float(repr(x)) == float(Decimal(repr(x))) # Reversible repr() assert str(x) == repr(x) assert len(repr(round(x, 12))) <= 14 # no excessive decimal places.
4 back and forth:

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.

3 or

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.

4

>>> 0.3
0.3
>>> float(repr(0.3)) == 0.3
True

Một loại

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.

5 là không cần thiết để lưu trữ nữa.

Kết quả của các hoạt động số học phải được làm tròn một lần nữa vì các lỗi làm tròn có thể tích lũy không chính xác hơn so với điều đó có thể xảy ra sau khi phân tích một số. Không được cố định bởi thuật toán

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.

6 được cải thiện (Python> = 3.1,> = 2.7.0): because rounding errors could accumulate more inaccuracy than that is possible after parsing one number. That is not fixed by the improved

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.

6 algorithm (Python >= 3.1, >= 2.7.0):

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

The output string function

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.

7 was rounded to 12 valid digits in Python < 2.7x and < 3.1, to prevent excessive invalid digits similar to unfixed repr() output. That was still insufficientl after subtraction of very similar numbers and it was too much rounded after other operations. Python 2.7 and 3.1 use the same length of str() although the repr() is fixed. Some old versions of Numpy had also excessive invalid digits, even with fixed Python. The current Numpy is fixed. Python versions >= 3.2 have the same results of str() and repr() function and also output of similar functions in Numpy.

Bài kiểm tra

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.

Tài liệu

Xem Ghi chú phát hành Python 2.7 - Ngôn ngữ khác thay đổi đoạn thứ tư:

Chuyển đổi giữa các số dấu phẩy động và chuỗi hiện được làm tròn chính xác trên hầu hết các nền tảng. Những chuyển đổi này xảy ra ở nhiều nơi khác nhau: str () trên phao và số phức; các nhà xây dựng nổi và phức tạp; định dạng số; tuần tự hóa và khử tự động các phao và số phức bằng các mô-đun
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
8,
import random from decimal import Decimal for _ in range(1000000): x = random.random() assert x == float(repr(x)) == float(Decimal(repr(x))) # Reversible repr() assert str(x) == repr(x) assert len(repr(round(x, 12))) <= 14 # no excessive decimal places.
9 và
float_value = 67.89433
0; phân tích cú pháp phao và văn học tưởng tượng trong mã Python; và chuyển đổi thập phân sang phao. between floating-point numbers and strings are now correctly rounded on most platforms. These conversions occur in many different places: str() on floats and complex numbers; the float and complex constructors; numeric formatting; serializing and de-serializing floats and complex numbers using the
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
8,
import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.
9 and
float_value = 67.89433
0 modules; parsing of float and imaginary literals in Python code; and Decimal-to-float conversion.
Liên quan đến điều này, phần repr () của số điểm nổi x hiện đang trả về kết quả dựa trên chuỗi thập phân ngắn nhất mà Lọ đảm bảo quay trở lại X dưới cách làm tròn chính xác (với chế độ làm tròn nửa vòng tròn). Trước đây, nó đã đưa ra một chuỗi dựa trên làm tròn x đến 17 chữ số thập phân.repr() of a floating-point number x now returns a result based on the shortest decimal string that’s guaranteed to round back to x under correct rounding (with round-half-to-even rounding mode). Previously it gave a string based on rounding x to 17 decimal digits.

Vấn đề liên quan

Thông tin thêm: Định dạng

float_value = 67.89433

1 trước Python 2.7 tương tự như
float_value = 67.89433
2 hiện tại. Cả hai loại đều sử dụng cùng độ chính xác gấp đôi của IEEE 754 với 52 bit mantissa. Một sự khác biệt lớn là
float_value = 67.89433
3 được định dạng thường xuyên với số thập phân quá mức để không thể mất một chút, nhưng không có số IEEE 754 hợp lệ tồn tại trong khoảng 13.94999999999999 và 13.9500000000001. Kết quả là không tốt và chuyển đổi
float_value = 67.89433
4 không thể đảo ngược với Numpy. Mặt khác:
float_value = 67.89433
5 được định dạng để mọi chữ số đều quan trọng; Trình tự là không có khoảng trống và chuyển đổi có thể đảo ngược. Đơn giản: Nếu bạn có thể có số Numpy.Loat64, hãy chuyển đổi nó thành phao bình thường để được định dạng cho con người, không phải cho bộ xử lý số, nếu không thì không có gì cần thiết hơn với Python 2.7+. The formatting of

float_value = 67.89433

1 before Python 2.7 was similar to the current

float_value = 67.89433

2. Both types use the same 64 bit IEEE 754 double precision with 52 bit mantissa. A big difference is that

float_value = 67.89433

3 is formatted frequently with an excessive decimal number so that no bit can be lost, but no valid IEEE 754 number exists between 13.949999999999999 and 13.950000000000001. The result is not nice and the conversion

float_value = 67.89433

4 is not reversible with numpy. On the other hand:

float_value = 67.89433

5 is formatted so that every digit is important; the sequence is without gaps and the conversion is reversible. Simply: If you perhaps have a numpy.float64 number, convert it to normal float in order to be formatted for humans, not for numeric processors, otherwise nothing more is necessary with Python 2.7+.

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

3

Trong ví dụ này, chúng tôi sẽ tạo một số điểm nổi và giới hạn nó ở hai vị trí thập phân bằng cách sử dụng str. định dạng () với hàm vòng ().

Giới hạn phao đến các vị trí thập phân bằng cách sử dụng toán tử định dạng chuỗi
Trong Python, chúng ta có thể sử dụng % làm toán tử định dạng chuỗi. Nó sẽ đại diện cho một chuỗi. Nếu chúng ta muốn biểu diễn các giá trị dấu phẩy động bằng toán tử này, thì chúng ta phải chỉ định-%. Do đó, chúng ta có thể giới hạn một float đến hai vị trí thập phân bằng toán tử định dạng chuỗi này.
Giới hạn nổi cho n vị trí thập phân bằng cách sử dụng str.format () với vòng ()
Giới hạn nổi cho n vị trí thập phân bằng cách sử dụng str.format () với vòng ()
Giới hạn nổi cho n vị trí thập phân bằng cách sử dụng str.format () với vòng ()

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

1

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

1

Có thể sử dụng hàm vòng () với hàm str.format (). Nó sẽ giới hạn một số điểm nổi ở hai vị trí thập phân. Vòng () được đặt trong tham số định dạng ().

Giới hạn phao đến các vị trí thập phân bằng cách sử dụng toán tử định dạng chuỗi

Trong Python, chúng ta có thể sử dụng % làm toán tử định dạng chuỗi. Nó sẽ đại diện cho một chuỗi. Nếu chúng ta muốn biểu diễn các giá trị dấu phẩy động bằng toán tử này, thì chúng ta phải chỉ định-%. Do đó, chúng ta có thể giới hạn một float đến hai vị trí thập phân bằng toán tử định dạng chuỗi này.

Ở đây, n = 2

Float_value là số điểm nổi đầu vào.

float_value = 67.89433

Trong ví dụ này, chúng tôi sẽ tạo một số điểm nổi và giới hạn nó ở hai vị trí thập phân bằng toán tử định dạng chuỗi.

67.82

Chúng ta có thể thấy rằng 67.822342 được trả về là 67,82 bằng cách chỉ giới hạn hai giá trị thập phân bằng toán tử định dạng chuỗi.

Trong Python, chúng ta có thể sử dụng % làm toán tử định dạng chuỗi. Nó sẽ đại diện cho một chuỗi. Nếu chúng ta muốn biểu diễn các giá trị dấu phẩy động bằng toán tử này, thì chúng ta phải chỉ định-%. Do đó, chúng ta có thể giới hạn một float đến hai vị trí thập phân bằng toán tử định dạng chuỗi này.

Ở đây, n = 2

Syntax:

round(float_value, n)

Nó có hai tham số.

Float_value là số điểm nổi
n đại diện cho tổng số vị trí thập phân được làm tròn trong số điểm nổi đã cho.

Ở đây, chúng ta phải làm tròn số điểm nổi đến 2 vị trí thập phân. Vì vậy, n = 2

round(float_value, 2)

Example:

Trong ví dụ này, chúng tôi sẽ tạo ra một số điểm nổi và giới hạn nó ở hai vị trí thập phân.

# Create a float value
float_value = 67.822342

# display actual float value
print("Actual value: ",float_value)

# formatted value
print("2 Decimal places: ",round(float_value, 2))

Output:

Actual value:  67.822342
2 Decimal places:  67.82

Chúng ta có thể thấy rằng 67.822342 được trả về là 67,82 bằng cách chỉ giới hạn hai giá trị thập phân.

Giới hạn nổi cho n vị trí thập phân bằng cách sử dụng str.format () với vòng ()

Str.format () được sử dụng để định dạng chuỗi. Nó được sử dụng để định dạng số điểm nổi đã cho để trả về với 2 vị trí thập phân bằng cách sử dụng Chuỗi Formatter - {: .2f}.

Syntax:

"{:.nf} ".format(float_value)

Nó có hai tham số.

float_value là số điểm nổi
.nf đại diện cho một định dạng chuỗi sẽ trả về các số điểm nổi với các vị trí thập phân n.

Ở đây, n = 2

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

0

Example:

Trong ví dụ này, chúng tôi sẽ tạo ra một số điểm nổi và giới hạn nó ở hai vị trí thập phân.

Chúng ta có thể thấy rằng 67.822342 được trả về là 67,82 bằng cách chỉ giới hạn hai giá trị thập phân.

Output:

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

2

Chúng ta có thể thấy rằng 67.822342 được trả về là 67,82 bằng cách chỉ giới hạn hai giá trị thập phân.

Giới hạn nổi cho n vị trí thập phân bằng cách sử dụng str.format () với vòng ()

Str.format () được sử dụng để định dạng chuỗi. Nó được sử dụng để định dạng số điểm nổi đã cho để trả về với 2 vị trí thập phân bằng cách sử dụng Chuỗi Formatter - {: .2f}.

Syntax:

float_value là số điểm nổi

Example:

.nf đại diện cho một định dạng chuỗi sẽ trả về các số điểm nổi với các vị trí thập phân n.

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

4

Output:

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

2

Chúng ta có thể thấy rằng 67.822342 được trả về là 67,82 bằng cách chỉ giới hạn hai giá trị thập phân.

Giới hạn nổi cho n vị trí thập phân bằng cách sử dụng str.format () với vòng ()

Str.format () được sử dụng để định dạng chuỗi. Nó được sử dụng để định dạng số điểm nổi đã cho để trả về với 2 vị trí thập phân bằng cách sử dụng Chuỗi Formatter - {: .2f}.

Syntax:

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

6

float_value là số điểm nổi

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

7

.nf đại diện cho một định dạng chuỗi sẽ trả về các số điểm nổi với các vị trí thập phân n.

Example:

Ở đây, n = 2

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

8

Output:

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

9

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

1

Có thể sử dụng hàm vòng () với hàm str.format (). Nó sẽ giới hạn một số điểm nổi ở hai vị trí thập phân. Vòng () được đặt trong tham số định dạng ().

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

3

Syntax:

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.

0

.nf đại diện cho một định dạng chuỗi sẽ trả về các số điểm nổi với các vị trí thập phân n.

Example:

Ở đây, n = 2

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.

1

Output:

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

9

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

1

Có thể sử dụng hàm vòng () với hàm str.format (). Nó sẽ giới hạn một số điểm nổi ở hai vị trí thập phân. Vòng () được đặt trong tham số định dạng ().

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

3

programming python Float Python Format float Python Decimal Python

Hướng dẫn how do i reduce the number of decimal places float in python? - làm cách nào để giảm số lượng vị trí thập phân nổi trong python?

Tldr;)

Bài kiểm tra

Tài liệu

Giới hạn phao đến các vị trí thập phân bằng cách sử dụng toán tử định dạng chuỗi

Giới hạn nổi cho n vị trí thập phân bằng cách sử dụng str.format () với vòng ()

Giới hạn nổi cho n vị trí thập phân bằng cách sử dụng str.format () với vòng ()

Giới hạn nổi cho n vị trí thập phân bằng cách sử dụng str.format () với vòng ()

Có thể sử dụng hàm vòng () với hàm str.format (). Nó sẽ giới hạn một số điểm nổi ở hai vị trí thập phân. Vòng () được đặt trong tham số định dạng ().

Có thể sử dụng hàm vòng () với hàm str.format (). Nó sẽ giới hạn một số điểm nổi ở hai vị trí thập phân. Vòng () được đặt trong tham số định dạng ().

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