Python xác định vị trí thập phân

Bài toán làm tròn đầu vào và đầu ra đã được Python 3 giải quyết dứt điểm. 1 và bản sửa lỗi cũng được nhập vào Python 2. 7. 0

Nội dung chính Hiển thị

• Tài liệu
• # Làm tròn giá trị Python đến hai chữ số thập phân [và hơn thế nữa]
• # Làm tròn số thập phân lên và xuống. vòng[]
• # Thí dụ. làm tròn chữ số thập phân lên và xuống
• # Làm tròn số thập phân lên trong Python
• # Thí dụ. làm tròn đến 2 chữ số thập phân
• # Làm tròn số thập phân xuống trong Python
• # Thí dụ. làm tròn đến 2 chữ số thập phân
• # Làm tròn số thập phân của danh sách và mảng Python
• # Làm tròn danh sách đến vị trí thập phân với khả năng hiểu danh sách
• # Làm tròn danh sách đến vị trí thập phân với vòng lặp for của Python
• # Làm tròn mảng Python đến 2 chữ số thập phân
• # Làm tròn mảng NumPy đến hai chữ số thập phân
• Làm thế nào để bạn làm tròn đến 5 chữ số thập phân?
• Làm cách nào để bạn đặt số vị trí thập phân trong Python?
• Bạn dùng như thế nào. 2f bằng Python?
• Làm cách nào để giới hạn số thập phân trong Python?

Các số được làm tròn có thể được chuyển đổi ngược lại giữa float và string qua lại.
______08 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]]] >> 0.3
0.3
>>> float[repr[0.3]] == 0.3
True

Loại

round[12.54673, 2]
# Returns: 12.55

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

Kết quả của các phép tính số học phải được làm tròn lại vì lỗi làm tròn có thể tích lũy độ không chính xác cao hơn mức có thể xảy ra sau khi phân tích cú pháp một số. Điều đó không được khắc phục bằng thuật toán

round[12.54673, 2]
# Returns: 12.55

1 cải tiến [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

round[12.54673, 2]
# Returns: 12.55

2 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]]] > float[repr[0.3]] == 0.3
True

51

Hãy xem xét từng cách tiếp cận và mã Python mà chúng yêu cầu

# Làm tròn số thập phân lên và xuống. vòng[]

Với hàm

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]]] >> 0.3
0.3
>>> float[repr[0.3]] == 0.3
True

53] để làm tròn thành [Lutz, 2013; Sweigart, 2015]

Vì vậy, để làm tròn đến 2 chữ số thập phân, chúng tôi làm

round[12.54673, 2]
# Returns: 12.55

# Thí dụ. làm tròn chữ số thập phân lên và xuống

Để xem cách hoạt động của

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]]] > 0.3
0.3
>>> float[repr[0.3]] == 0.3
True

53]. Chúng tôi lưu trữ các giá trị của chúng trong các biến

>>> 0.3
0.3
>>> float[repr[0.3]] == 0.3
True

56 đến

>>> 0.3
0.3
>>> float[repr[0.3]] == 0.3
True

57

Sau đó, chúng tôi làm tròn từng số đến một số chữ số thập phân. Chúng tôi gọi hàm

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]]] >> 0.3
0.3
>>> float[repr[0.3]] == 0.3
True

59 đến

round[12.54673, 2]
# Returns: 12.55

70 cho điều đó. Chúng tôi lưu trữ các giá trị được làm tròn trong các biến mới [

round[12.54673, 2]
# Returns: 12.55

71 đến

round[12.54673, 2]
# Returns: 12.55

72]

Sau đó, hàm

round[12.54673, 2]
# Returns: 12.55

73 của Python hiển thị cả giá trị gốc và giá trị được làm tròn. Với phương thức chuỗi

round[12.54673, 2]
# Returns: 12.55

74, chúng tôi căn chỉnh giá trị ban đầu sang trái. Điều đó tạo ra một đầu ra giống như bảng đẹp. Như chúng ta có thể thấy từ đầu ra, mỗi giá trị được làm tròn chính xác

>>> 0.3
0.3
>>> float[repr[0.3]] == 0.3
True

5

# Làm tròn số thập phân lên trong Python

Một tùy chọn khác là luôn làm tròn các chữ số thập phân của một số lên. Đó là ví dụ những gì các công ty làm. thay vì làm tròn giá lên hoặc xuống, các giá trị như

round[12.54673, 2]
# Returns: 12.55

75 luôn được làm tròn lên đến $4. 55

Tuy nhiên, Python không có chức năng tích hợp cho điều đó. Nhưng chúng ta có thể tự tạo và tận dụng hàm

round[12.54673, 2]
# Returns: 12.55

76. Khi chúng tôi làm như vậy, sử dụng chức năng trông như thế này

round[12.54673, 2]
# Returns: 12.55

7

Đây là cách chúng tôi viết mã hàm

round[12.54673, 2]
# Returns: 12.55

77 đó

round[12.54673, 2]
# Returns: 12.55

7

Hàm này có hai tham số. giá trị cần làm tròn [________ 378] và số chữ số thập phân cần nhận [_______ 379]. Khi tham số thứ hai đó không được đặt, nó sẽ mặc định là

round[12.54673, 2]
# Returns: 12.55

70

Mã của chức năng có hai phần. Đầu tiên xác nhận và xử lý tham số

round[12.54673, 2]
# Returns: 12.55

79. Thứ hai thực hiện làm tròn thực tế

Để xác thực điều đó, chúng tôi sử dụng câu lệnh if xếp tầng của Python. Điều kiện đầu tiên có

round[12.54673, 2]
# Returns: 12.55

72 xem tham số

round[12.54673, 2]
# Returns: 12.55

79 có phải là số khác không phải là số nguyên [

round[12.54673, 2]
# Returns: 12.55

74]. Khi đúng như vậy, chúng tôi tạo một

round[12.54673, 2]
# Returns: 12.55

75 để thông báo cho người dùng rằng chức năng này được sử dụng sai cách

Tiếp theo, chúng tôi kiểm tra xem

round[12.54673, 2]
# Returns: 12.55

79 có dưới [

round[12.54673, 2]
# Returns: 12.55

77] không. Vì hàm không biết cách xử lý các vị trí thập phân âm, nên chúng tôi kích hoạt một

round[12.54673, 2]
# Returns: 12.55

78 để thông báo điều này với người dùng của hàm

Bài kiểm tra

round[12.54673, 2]
# Returns: 12.55

79 cuối cùng xem tham số

round[12.54673, 2]
# Returns: 12.55

79 có bằng [

round[12.54673, 2]
# Returns: 12.55

11]

round[12.54673, 2]
# Returns: 12.55

12 không. Khi hàm phải làm tròn một giá trị lên mà không có chữ số thập phân, chúng ta chỉ cần thực thi hàm

round[12.54673, 2]
# Returns: 12.55

76 và làm tròn thành một số nguyên

Sau đó, chúng ta đến phần thứ hai của chức năng. Đây là nơi chúng tôi làm tròn thực tế đến vị trí thập phân. Nhưng trước tiên chúng ta xác định hệ số hiệu chỉnh. Để có được giá trị đó, chúng tôi tăng

round[12.54673, 2]
# Returns: 12.55

14 thành sức mạnh của tham số

round[12.54673, 2]
# Returns: 12.55

79. Chúng tôi lưu trữ kết quả trong biến

round[12.54673, 2]
# Returns: 12.55

16

Tiếp theo chúng ta gọi hàm

round[12.54673, 2]
# Returns: 12.55

76. Bên trong dấu ngoặc đơn, chúng tôi chỉ định giá trị làm tròn lên [

round[12.54673, 2]
# Returns: 12.55

78] nhân với

round[12.54673, 2]
# Returns: 12.55

16. Sau đó, chúng tôi chia kết quả làm tròn cho

round[12.54673, 2]
# Returns: 12.55

16 để lấy lại số vị trí thập phân thích hợp

Giả sử hàm phải làm trò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]]] >> 0.3
0.3
>>> float[repr[0.3]] == 0.3
True

56 đến

>>> 0.3
0.3
>>> float[repr[0.3]] == 0.3
True

57]. Mỗi cái có một giá trị dấu phẩy động với một vài chữ số thập phân. Hãy làm tròn giá trị của chúng

Vì điều đó, chúng tôi gọi hàm

round[12.54673, 2]
# Returns: 12.55

77 nhiều lần. Chúng tôi cung cấp cho nó một đối số. giá trị để làm tròn. Sau đó, hàm sẽ tự động sử dụng hai chữ số thập phân để làm tròn. Chúng tôi đặt các giá trị được làm tròn trong các biến

round[12.54673, 2]
# Returns: 12.55

71 đến

round[12.54673, 2]
# Returns: 12.55

72

Hàm

round[12.54673, 2]
# Returns: 12.55

73 sau đó xuất giá trị ban đầu và được làm tròn. Đây là cách hàm làm tròn mọi biến đến hai chữ số thập phâ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]]] >> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

08 và

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

09 lên, người đó làm tròn xuống thành

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

10 và

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

11

Không có chức năng tích hợp sẵn nào trong Python cho kiểu làm tròn đó. Nhưng chúng ta có thể tự xây dựng và tận dụng hàm

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

12. Sử dụng một chức năng tùy chỉnh như vậy trông giống như

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

0

Điều đó hoạt động tốt. Bây giờ hãy viết mã chức năng tùy chỉnh đó

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

1

Phần lớn chức năng này giống với chức năng tùy chỉnh khác [

round[12.54673, 2]
# Returns: 12.55

77] mà chúng ta đã thảo luận trước đó

Sự khác biệt chính là bây giờ chúng ta sử dụng chức năng

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

12. Hàm này làm tròn tham số

round[12.54673, 2]
# Returns: 12.55

78 nhân với biến

round[12.54673, 2]
# Returns: 12.55

16 xuống. Sau đó, chúng tôi chia lại với

round[12.54673, 2]
# Returns: 12.55

16 để có đúng số chữ số thập phân

Giả sử chúng ta yêu cầu hàm làm tròn

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

18 xuống 2 chữ số thập phân. Sau đó, mã đầu tiên nhân giá trị đó vớ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]]] > 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

24

# Thí dụ. làm tròn đến 2 chữ số thập phân

Hãy xem chức năng trên hoạt động như thế nào trong thực tế. Chương trình nhỏ này có chức năng làm tròn xuống 5 giá trị khác nhau

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

2

Trước tiên, chúng tôi nhập mô-đun

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

00. Bằng cách đó, hàm

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

26 tùy chỉnh có thể sử dụng

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

12. Sau đó chúng tôi chèn chức năng tùy chỉnh đó

Sau đó, chúng tôi thực hiện năm biến [

>>> 0.3
0.3
>>> float[repr[0.3]] == 0.3
True

56 đến

>>> 0.3
0.3
>>> float[repr[0.3]] == 0.3
True

57]. Mỗi người giữ một giá trị với số thập phân để làm tròn xuống. Làm tròn đó là những gì chúng ta làm tiếp theo

Vì vậy, chúng tôi liên tục thực hiện

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

26. Mỗi lần chúng ta cung cấp cho hàm hai đối số. giá trị cần làm tròn và số chữ số thập phân cần giữ. Chúng tôi đưa kết quả vào các biến mới [______371 đến

round[12.54673, 2]
# Returns: 12.55

72]

Đoạn mã cuối cùng đưa ra kết quả với hàm

round[12.54673, 2]
# Returns: 12.55

73. Chúng tôi căn trái giá trị ban đầu bằng phương pháp

round[12.54673, 2]
# Returns: 12.55

74 và bao gồm cả giá trị được làm tròn. Khi đầu ra hiển thị, mỗi giá trị được làm tròn xuống một số vị trí thập phân nhất định

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

3

# Làm tròn số thập phân của danh sách và mảng Python

Các ví dụ trên luôn làm tròn một giá trị tại một thời điểm. Tuy nhiên, đôi khi chúng ta có một dãy có các giá trị mà chúng ta muốn làm tròn thành một số chữ số thập phân. Hãy xem cách thực hiện trong Python

# Làm tròn danh sách đến vị trí thập phân với khả năng hiểu danh sách

Một tùy chọn là làm tròn mọi giá trị bằng cách hiểu danh sách. Điều này chỉ cần một chút mã và chạy hiệu quả. Khả năng hiểu danh sách hoạt động tốt nhất khi mã của bạn không quá phức tạp. Các giá trị làm tròn đơn giản đáp ứng dấu đó

Đây là một ví dụ nhanh

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

4

Danh sách

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

35 chúng tôi tạo ở đây nhận các giá trị của nó từ cách hiểu danh sách. Sự hiểu biết đó thực thi biểu thức

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

36 cho mọi giá trị được tạo bởi vòng lặp

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]]] >> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

38. Đó là cách chúng tôi duyệt qua danh sách

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

39 ban đầu, từng phần tử một

Đây là một chương trình nhỏ làm tròn mọi giá trị trong danh sách

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

5

Trước tiên, chúng tôi nhập mô-đun

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

00. Sau đó, chúng tôi chèn các hàm

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

26 và

round[12.54673, 2]
# Returns: 12.55

77 mà chúng tôi đã thực hiện trước đó trong bài viết này

Tiếp theo, chúng tôi tạo một danh sách với các số. Danh sách

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

39 đó có 6 giá trị dấu phẩy động. Sau đó, chúng tôi làm tròn từng giá trị trong danh sách đó. Chúng tôi sử dụng ba cách hiểu danh sách khác nhau cho điều đó

Vòng đầu tiên làm tròn mọi giá trị danh sách đến hai chữ số thập phân [lên và xuống] bằng hàm

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]]] >> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

45

Cách hiểu danh sách thứ hai có hàm

round[12.54673, 2]
# Returns: 12.55

77 làm tròn đến hai chữ số thập phân. Danh sách mới mà điều này trả về là những gì chúng tôi lưu trữ trong

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

47. Mức độ hiểu danh sách thứ ba và cuối cùng làm tròn xuống hai chữ số thập phân [

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

26]. Kết quả của sự hiểu biết đó được lưu trữ trong danh sách

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

49

Đoạn mã cuối cùng của chương trình xuất ra cả bốn danh sách với hàm

round[12.54673, 2]
# Returns: 12.55

73. Đây là cách các giá trị được làm tròn đó trông như thế nào

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

6

Trong ví dụ trên, chúng tôi đã tạo danh sách mới với khả năng hiểu danh sách. Nếu bạn không cần giữ các giá trị danh sách ban đầu, thì khả năng hiểu danh sách cũng có thể ghi đè lên danh sách hiện có. Để làm như vậy, chúng tôi đặt giá trị của danh sách thành kết quả của việc hiểu danh sách

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

7

# Làm tròn danh sách đến vị trí thập phân với vòng lặp for của Python

Cách thứ hai để làm tròn giá trị danh sách là dùng vòng lặp

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]]] >> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

8

Danh sách

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

52 chúng tôi tạo ở đây bắt đầu trống [

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

53]. Nhưng bên trong vòng lặp

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]]] >> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

55 trong danh sách và chuyển vào giá trị được làm tròn từ danh sách ban đầu [

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

36]

Chương trình nhỏ này làm tròn các giá trị danh sách vớ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]]] >> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

9

Trước tiên, chúng tôi nhập lại mô-đun

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

00. Sau đó, chúng tôi sao chép/dán các hàm

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

26 và

round[12.54673, 2]
# Returns: 12.55

77 mà chúng tôi đã thực hiện trước đó trong bài viết này

Sau đó, chúng tôi tạo một danh sách với một số giá trị dấu phẩy động, cả dương và âm. Sau đó, chúng tôi mã ba danh sách trống [

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

53].

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

45,

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

47 và

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

49. Chúng sẽ giữ các giá trị được làm tròn

Để thực hiện điều đó, chúng tôi tạo một vòng lặp

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]]] >> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

39. Trong mỗi chu kỳ vòng lặp, giá trị danh sách hiện tại được truy cập bằng biến vòng lặp

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

67. Bên trong vòng lặp đó, chúng tôi nối thêm một giá trị được làm tròn vào từng danh sách trong số ba danh sách bằng phương thức

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

55 của Python

Đoạn mã cuối cùng của chương trình sau đó xuất ra danh sách ban đầu và các dẫn xuất được làm tròn của nó. Đây là những gì hiển thị

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]]] >> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

69 của Python. Ví dụ

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]]] > 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

70 từ mô-đun

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

71. Sau đó, chúng tôi tạo một mảng với các giá trị dấu phẩy động. Chúng tôi đặt tên cho mảng đó là

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

39

Sau đó, chúng tôi xây dựng một mảng thứ hai. Cái này có các giá trị từ mảng ban đầu được làm tròn đến 2 chữ số thập phân. Để thực hiện điều đó, chúng tôi sử dụng cách hiểu danh sách. Làm tròn mỗi giá trị thành hai chữ số thập phân [

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

36]. Chúng tôi đặt tên cho mảng mới, được làm tròn đó là

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

35

Hàm

round[12.54673, 2]
# Returns: 12.55

73 sau đó xuất ra mảng ban đầu và được làm tròn. Như chúng ta có thể biết, mỗi giá trị được làm tròn đúng đến hai chữ số thập phâ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]]]  0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

76. Sau đó, chúng tôi tạo một mảng NumPy với hàm

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

77. Mảng đó có một số giá trị dấu phẩy động

Sau đó, chúng tôi làm tròn mảng ban đầu thành hai chữ số thập phân. Đối với điều đó, chúng tôi gọi hàm

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

78 với hai đối số. Đầu tiên là mảng có giá trị để làm tròn. Thứ hai là số chữ số thập phân để làm tròn thành. Chúng tôi lưu trữ mảng mà hàm trả về trong biến

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

35

Đoạn mã cuối cùng xuất ra cả mảng ban đầu và mảng được làm tròn. Điều đó cho thấy cách các giá trị được làm tròn độc đáo đến 2 chữ số thập phâ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]]] >> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

78 làm tròn lên và xuống. Để luôn làm tròn lên hoặc luôn làm tròn xuống, chúng ta phải sử dụng các hàm tùy chỉnh

round[12.54673, 2]
# Returns: 12.55

77 và

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

26

Khi chúng ta sử dụng các hàm đó để hiểu danh sách, chúng có thể làm tròn từng giá trị từ một mảng NumPy. Ví dụ

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]]] > 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

84 thành

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

85]. Nhưng khi chúng ta tận dụng hàm

round[12.54673, 2]
# Returns: 12.55

76 trong một hàm tùy chỉnh, chúng ta có thể dễ dàng tự thực hiện điều đó

Không có hàm nào luôn làm tròn các chữ số thập phân xuống [

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

87 trở thành

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

88]. Nhưng khi chúng ta bọc hàm

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
[0.1, 0.2, 0.3]

12 trong một hàm tùy chỉnh, chúng ta có thể tự tạo hành vi đó

Để làm tròn mọi giá trị trong danh sách hoặc mảng, chúng ta có thể sử dụng vòng lặp hiểu danh sách hoặc vòng lặp

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